@cortexkit/pi-magic-context 0.46.1 → 0.47.0

package/dist/index.js

@@ -33,6 +33,7 @@ import {
   hasTrustedAbsoluteWall,
   applyProvenInputFloor,
   formatWindowDerivationLine,
+  formatWindowSource,
   isSaneLimit,
   resolveOutputReserve,
   getSdkWindowGeometry,
@@ -46,12 +47,14 @@ import {
   BoundedSessionMap,
   MAX_EXECUTE_THRESHOLD,
   escalationBands,
+  decodeMergedReasoningParts,
   HYGIENE_PROVIDER_UNITS_VERSION,
   sessionDecisionCalibration,
   transitionSessionHygieneUnits,
   computeProtectionWindow,
   readEpochFloorSnapshot,
   getProtectionWindowForSession,
+  ensureSessionMetaRow,
   persistCachedM0,
   clearCachedM0M1,
   isRustMarkerAdmissionFenced,
@@ -72,6 +75,7 @@ import {
   resolveCompactionModeRecord,
   getCompactionModeRecord,
   setCompactionModeRecord,
+  getProtectedTailDrainBudgetSkip,
   reserveProtectedTailDrainTokens,
   clearEmergencyDrainLatch,
   recordHistorianDrainFailure,
@@ -135,23 +139,13 @@ import {
   setSessionWorkMetrics,
   getSessionWorkMetrics,
   resolveEpochFloorForPass,
-  buildCanonicalChunkTextFromFts,
-  buildCompartmentSummaryFallbackText,
-  canonicalizeInMemoryChunkTextForEmbedding,
-  chunkCanonicalText,
-  chunkEmbeddingWindowsAreCurrent,
-  replaceCompartmentChunkEmbeddings,
-  deleteChunkEmbedBackoffForSession,
-  chunkWindowSourceKey,
-  readSessionActivity,
-  observeSessionActivity,
-  backfillSessionActivity,
+  registerAutoSearchWork,
+  cancelAutoSearchWork,
   getOrCreateSessionMeta,
   updateSessionMeta,
   advanceToolReclaimWatermark,
   retryPendingSessionCleanups,
   retryPendingRustSessionCleanupsForProject,
-  recordSessionProjectIdentity,
   embedPauseBySession,
   embedRunStateBySession,
   autoEmbedAttemptedBySession,
@@ -164,8 +158,6 @@ import {
   releaseCompartmentLease,
   releaseCompartmentLeaseBestEffort,
   isCompartmentLeaseHeld,
-  clearCompressionDepth,
-  clearCompressionDepthRange,
   isNoContentCompartment,
   HAS_COMPARTMENT_CONTENT_SQL,
   queueM0Mutation,
@@ -184,14 +176,6 @@ import {
   escapeXmlContent,
   getUncoveredCompartmentEndThrough,
   isPartialCompartmentEnd,
-  getMessageIndexSourceIdentity,
-  isMessageIndexSourceCurrent,
-  getLastIndexedOrdinal,
-  getMessageIndexReconciliationStartOrdinal,
-  isMessageIndexReconciledThrough,
-  indexSingleMessage,
-  indexMessagesAfterOrdinal,
-  sweepOrphanedOpenCodeMessageIndexes,
   readProjectDocsCanonical,
   providerResponseFailed,
   isSuccessfulProviderCompletion,
@@ -215,6 +199,7 @@ import {
   getSlot,
   dropSlot,
   noteEntry,
+  TOOL_SWEEP_SCOPED_MARKER,
   encodePiContentDecision,
   decodePiContentDecision,
   getPiContentDecisions,
@@ -223,31 +208,15 @@ import {
   saveNativeToolInputs,
   addNativeReasoningIds,
   copySessionStateForClone,
+  countHistorianRuns,
+  recordHistorianRun,
+  summarizeImportance,
+  tallyFactsByCategory,
   queueMemoryMutation,
   getMemoryMutationsForRender,
   getMemoryMutationsForRenderByProjects,
   getMaxMemoryMutationId,
   getMaxMemoryMutationIdForProjects,
-  getNotes,
-  addNote,
-  getSessionNotes,
-  getPendingSmartNotes,
-  getReadySmartNotes,
-  markNoteReady,
-  markNoteChecked,
-  PRIMER_CANDIDATE_TTL_MS,
-  PRIMER_CANDIDATE_MAX_AGE_MS,
-  primerOccurrenceKey,
-  primerOccurrenceUtcDay,
-  insertPrimerCandidates,
-  updatePrimerCandidateEmbedding,
-  getPrimerCandidatesByIds,
-  getPrimerCandidatesForPromotion,
-  countPrimerCandidatesForProject,
-  getActivePrimers,
-  createPrimer,
-  updatePrimerSupport,
-  updatePrimerAnswer,
   GLOBAL_USER_PROFILE_PROJECT_PATH,
   getProjectState,
   bumpProjectUserProfileVersion,
@@ -258,7 +227,6 @@ import {
   noteTouchedAt,
   noteNudgePickIndex,
   formatNoteNudge,
-  setEmbeddingSessionBusy,
   promptSurfaceHashMaterial,
   createPromptSurfaceRuntime,
   createPromptSurfaceGuidanceEpochCache,
@@ -273,25 +241,6 @@ import {
   convertPiAssistantEntryById,
   convertEntriesToRawMessagePage,
   countPiRawMessages,
-  computeCueContentHash,
-  hasMuralCueColumns,
-  getMuralCueState,
-  memoryNeedsCue,
-  setMuralCue,
-  recordMuralCueRejection,
-  invalidateMemory,
-  hasMemoryShareableColumn,
-  hasMemoryClassifiedAtColumn,
-  getUnclassifiedMemoryIds,
-  insertMemory,
-  getMemoryByHash,
-  getMemoriesByProject,
-  getMemoriesByProjects,
-  getMaxMemoryIdForProjects,
-  getMemoryById,
-  setMemoryClassification,
-  archiveMemory,
-  getMemoryCountsByStatus,
   USER_MEMORY_CANDIDATE_TTL_MS,
   insertUserMemoryCandidates,
   getUserMemoryCandidates,
@@ -315,48 +264,9 @@ import {
   peekCurateCategoryScope,
   beginCurateCategoryRun,
   curateTaskStateAfterSuccess,
-  cosineSimilarity,
-  drainBackgroundBatches,
-  GIT_SWEEP_LEASE_RENEWAL_MS,
-  acquireGitSweepLease,
-  renewGitSweepLease,
-  markGitSweepSuccessAndRelease,
-  parkGitSweepNonIndexable,
-  releaseGitSweepLease,
-  describeShadowBackfillWriteRefusal,
-  contentSha256,
-  drainProjectEmbeddingIdentityMaintenance,
-  drainStaleEmbeddingIdentitiesForProject,
-  enqueueShadowEmbeddingItems,
-  getProjectEmbeddingSnapshot,
-  getProjectChunkEmbeddingModelId,
-  getProjectEmbeddingMaxInputTokens,
-  embedTextForProject,
-  embedBatchForProject,
-  embedItemsForProject,
-  embedUnembeddedMemoriesForProject,
-  drainCommitBacklogForProject,
-  embedSessionCompartmentChunks,
-  getEmbeddingCoverageStatus,
-  getAutoEmbeddingSessionCoverage,
-  promoteSessionFactsDurable,
-  embedPromotedFacts,
-  recordMemoryMapping,
-  recordMemoryVerifications,
-  getUnmappedMemoryIds,
-  clearMemoryVerifications,
-  getMemoryVerifications,
-  resolveGitTopLevel,
-  readGitHead,
-  readGitChangedFilesSince,
-  readGitFileChangeTimesSince,
-  verificationFileExists,
-  normalizeVerificationFiles,
   isDirectiveShapedProjectRule,
   takeCurateSafetyRefusalCount,
   wakePlaneStatus,
-  indexCommitsForProject,
-  embedUnembeddedCommits,
   loadPiConfig,
   loadPiConfigDetailed,
   unregisterPiProjectEmbeddings,
@@ -395,7 +305,6 @@ import {
   trimUserMemoriesToBudget,
   renderMemoryBlockV2,
   stripMemoryMuralBlock,
-  unifiedSearch,
   rememberTodowriteToolCallTodos,
   parseTodos,
   setTodoSnapshot,
@@ -403,7 +312,7 @@ import {
   registerTodoStateLifecycle,
   syncCtxMemoryToolEnabled,
   registerMagicContextTools
-} from "./index-ykb8kkm3.js";
+} from "./index-k3ezsjng.js";
 import {
   isValidLanguageCode,
   withContentLanguageDirective,
@@ -418,7 +327,7 @@ import {
   connectionFileExists,
   formatSynapseLaneDescriptor,
   computeNormalizedHash
-} from "./index-r01b1b78.js";
+} from "./index-vgcemg0n.js";
 import {
   canonicalModelIdentity,
   piModelRefToCanonical,
@@ -427,7 +336,7 @@ import {
   ompModelRefToCanonical,
   resolveModelRefForOmp,
   normalizeProtectedToolName
-} from "./index-phh7e055.js";
+} from "./index-spk5vrhy.js";
 import {
   FAIL_CLOSED_DOCTOR_COMMAND,
   formatFailClosedBlockingMessage,
@@ -435,6 +344,25 @@ import {
   isFailClosedBlockingError,
   shouldBypassFailClosedBlock,
   createFailClosedController,
+  piHarnessKindFromExecutable,
+  getErrorMessage,
+  describeError,
+  configureContextDatabasePragmas,
+  startBootDeadline,
+  getSchemaFenceRejection,
+  getMigrationOnOpenRefusal,
+  LATEST_SUPPORTED_VERSION,
+  getDatabasePath,
+  getPersistedSchemaVersion,
+  setSqlitePragmaConfig,
+  applySqliteTuningPragmas,
+  runSqliteOptimize,
+  openDatabase,
+  openCurrentDatabase,
+  openDatabaseAsync,
+  closeDatabase
+} from "./index-kztsbkqq.js";
+import {
   setHomeProjectPermission,
   ProjectIdentityError,
   resolveProjectIdentityStrict,
@@ -442,7 +370,6 @@ import {
   resolveProjectIdentity,
   isUsableProjectIdentity,
   resolveProjectIdentityForSession,
-  piHarnessKindFromExecutable,
   V2_MEMORY_CATEGORIES,
   unescapeXml,
   parseCompartmentOutput,
@@ -454,26 +381,11 @@ import {
   sourceNameForMemory,
   computeWorkspaceEpochFingerprint,
   beginBootQuietPeriod,
-  scheduleAfterBootQuiet,
-  getErrorMessage,
-  describeError,
-  configureContextDatabasePragmas,
-  startBootDeadline,
-  getSchemaFenceRejection,
-  getMigrationOnOpenRefusal,
-  LATEST_SUPPORTED_VERSION,
-  getDatabasePath,
-  getPersistedSchemaVersion,
-  setSqlitePragmaConfig,
-  applySqliteTuningPragmas,
-  runSqliteOptimize,
-  openDatabase,
-  openCurrentDatabase,
-  openDatabaseAsync,
-  closeDatabase
-} from "./index-4vfrjwf6.js";
+  scheduleAfterBootQuiet
+} from "./index-xpbh1ypk.js";
 import {
   detectThinkingBindingMismatch,
+  detectLatestTurnThinkingMismatch,
   isPrefixBoundThinkingModel,
   detectOverflow,
   UNKNOWN_FIT_RATIO,
@@ -526,6 +438,7 @@ import {
   updateTagTokenCount,
   getPersistedToolTagAccounting,
   getAllStatusTagTokenTotalsFlat,
+  getReasoningTokenEstimatesByMessage,
   updateTagInputTokenCount,
   tagTokenCountIsNull,
   backfillTagTokenCounts,
@@ -575,6 +488,7 @@ import {
   isEditTool,
   applyEditMarkerToInput,
   modelAcceptsEmptyContent,
+  isAnthropicFamilyRoute,
   variantChangeBustsProviderCache,
   SKELETON_REAL_INPUT_MAX_BYTES,
   toolInputStringBytes,
@@ -594,7 +508,7 @@ import {
   getRawSessionTagKeysThrough2,
   getLegacyProtectedTailStartOrdinal2,
   readSessionChunk2
-} from "./index-xvw8zptx.js";
+} from "./index-7s8vw2y0.js";
 import {
   textMentionsRecentCommit,
   hasMeaningfulUserText2,
@@ -608,6 +522,7 @@ import {
   normalizeText
 } from "./index-266qrgss.js";
 import {
+  stableStringify,
   closeQuietly,
   isKnownAutocommit,
   observeTemporalDecisions,
@@ -621,10 +536,118 @@ import {
 } from "./index-td885aah.js";
 import {
   Database,
+  getSqliteDatabasePath,
   withSqliteBackgroundWriter,
   withSqliteTransformPass,
-  withoutSqliteTransformPass
-} from "./index-wv28nczk.js";
+  withoutSqliteTransformPass,
+  guardSqliteTransformPass,
+  assertTransformWrite,
+  withAsyncPrivilegedWriter
+} from "./index-0qejsd7f.js";
+import {
+  buildCanonicalChunkTextFromFts,
+  buildCompartmentSummaryFallbackText,
+  canonicalizeInMemoryChunkTextForEmbedding,
+  chunkCanonicalText,
+  chunkEmbeddingWindowsAreCurrent,
+  replaceCompartmentChunkEmbeddings,
+  deleteChunkEmbedBackoffForSession,
+  chunkWindowSourceKey,
+  readSessionActivity,
+  observeSessionActivity,
+  backfillSessionActivity,
+  recordSessionProjectIdentity,
+  clearCompressionDepth,
+  clearCompressionDepthRange,
+  getMessageIndexSourceIdentity,
+  isMessageIndexSourceCurrent,
+  getLastIndexedOrdinal,
+  getMessageIndexReconciliationStartOrdinal,
+  isMessageIndexReconciledThrough,
+  indexSingleMessage,
+  indexMessagesAfterOrdinal,
+  sweepOrphanedOpenCodeMessageIndexes,
+  getNotes,
+  addNote,
+  getSessionNotes,
+  getPendingSmartNotes,
+  getReadySmartNotes,
+  markNoteReady,
+  markNoteChecked,
+  PRIMER_CANDIDATE_TTL_MS,
+  PRIMER_CANDIDATE_MAX_AGE_MS,
+  primerOccurrenceKey,
+  primerOccurrenceUtcDay,
+  insertPrimerCandidates,
+  updatePrimerCandidateEmbedding,
+  getPrimerCandidatesByIds,
+  getPrimerCandidatesForPromotion,
+  countPrimerCandidatesForProject,
+  getActivePrimers,
+  createPrimer,
+  updatePrimerSupport,
+  updatePrimerAnswer,
+  setEmbeddingSessionBusy,
+  isEmbeddingHostBusy,
+  computeCueContentHash,
+  hasMuralCueColumns,
+  getMuralCueState,
+  memoryNeedsCue,
+  setMuralCue,
+  recordMuralCueRejection,
+  invalidateMemory,
+  hasMemoryShareableColumn,
+  hasMemoryClassifiedAtColumn,
+  getUnclassifiedMemoryIds,
+  insertMemory,
+  getMemoryByHash,
+  getMemoriesByProject,
+  getMemoriesByProjects,
+  getMaxMemoryIdForProjects,
+  getMemoryById,
+  setMemoryClassification,
+  archiveMemory,
+  getMemoryCountsByStatus,
+  cosineSimilarity,
+  drainBackgroundBatches,
+  GIT_SWEEP_LEASE_RENEWAL_MS,
+  acquireGitSweepLease,
+  renewGitSweepLease,
+  markGitSweepSuccessAndRelease,
+  parkGitSweepNonIndexable,
+  releaseGitSweepLease,
+  describeShadowBackfillWriteRefusal,
+  contentSha256,
+  drainProjectEmbeddingIdentityMaintenance,
+  drainStaleEmbeddingIdentitiesForProject,
+  enqueueShadowEmbeddingItems,
+  getProjectEmbeddingSnapshot,
+  getProjectChunkEmbeddingModelId,
+  getProjectEmbeddingMaxInputTokens,
+  embedTextForProject,
+  embedBatchForProject,
+  embedItemsForProject,
+  embedUnembeddedMemoriesForProject,
+  drainCommitBacklogForProject,
+  embedSessionCompartmentChunks,
+  getEmbeddingCoverageStatus,
+  getAutoEmbeddingSessionCoverage,
+  promoteSessionFactsDurable,
+  embedPromotedFacts,
+  recordMemoryMapping,
+  recordMemoryVerifications,
+  getUnmappedMemoryIds,
+  clearMemoryVerifications,
+  getMemoryVerifications,
+  resolveGitTopLevel,
+  readGitHead,
+  readGitChangedFilesSince,
+  readGitFileChangeTimesSince,
+  verificationFileExists,
+  normalizeVerificationFiles,
+  indexCommitsForProject,
+  embedUnembeddedCommits
+} from "./index-qaa5j277.js";
 import {
   pushNotification2
 } from "./index-q1yc6bs0.js";
@@ -635,6 +658,9 @@ import {
   readHostSystemPrompt
 } from "./index-w76x3af7.js";
 import"./index-n3g5mwa8.js";
+import {
+  __toESM
+} from "./index-22jkk6wg.js";
 import {
   setStoragePrivatePermissionEnforcement,
   ensureStorageDirectorySync,
@@ -645,9 +671,6 @@ import {
   logSlowWriteTransaction,
   WriteTransactionSteps
 } from "./index-2p1e8706.js";
-import {
-  __toESM
-} from "./index-22jkk6wg.js";
 
 // src/index.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
@@ -798,6 +821,10 @@ function sampleLiveConfig(boot, fresh) {
     let value = fresh;
     for (const part of parts)
       value = value?.[part];
+    if (value === undefined) {
+      removeLeaf(result, parts);
+      continue;
+    }
     let target = result;
     for (const part of parts.slice(0, -1)) {
       const child = target[part];
@@ -811,6 +838,26 @@ function sampleLiveConfig(boot, fresh) {
   }
   return result;
 }
+function removeLeaf(root, parts) {
+  const parents = parts.slice(0, -1);
+  let node = root;
+  for (const part of parents) {
+    const child = node[part];
+    if (!child || typeof child !== "object" || Array.isArray(child))
+      return;
+    node = child;
+  }
+  const leaf = parts.at(-1);
+  if (leaf === undefined || !Object.hasOwn(node, leaf))
+    return;
+  let target = root;
+  for (const part of parents) {
+    const copy = { ...target[part] };
+    target[part] = copy;
+    target = copy;
+  }
+  delete target[leaf];
+}
 function changedLiveKeys(previous, next) {
   const at = (config, path) => path.split(".").reduce((node, part) => node?.[part], config);
   return LIVE_RELOAD_CONFIG_PATHS.filter((path) => JSON.stringify(at(previous, path)) !== JSON.stringify(at(next, path)));
@@ -3590,9 +3637,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) {
@@ -3667,10 +3716,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;
 }
@@ -10045,7 +10095,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-901ekbga.js")
+      import("./index-en1k8h8m.js")
     ]));
     const module = await newQuickJSAsyncWASMModuleFromVariant(singlefileAsyncifyVariant);
     return module;
@@ -17553,6 +17603,7 @@ class PiSubagentRunner {
       let finalErrorMessage = null;
       let finalStopReason = null;
       let sawAgentEnd = false;
+      let preserveDrainedResult = false;
       let parseError = null;
       let agentEndMessages = null;
       let drainTimerStarted = false;
@@ -17576,6 +17627,15 @@ class PiSubagentRunner {
       let lastEventTimestamp = 0;
       const accumulatedMessages = [];
       accountingMessages = accumulatedMessages;
+      const captureFinalAssistant = (messages) => {
+        const result = extractFinalAssistant(messages);
+        finalAssistantText = result.text;
+        finalStopReason = result.stopReason;
+        finalErrorMessage = result.errorMessage;
+        const lastAssistant = [...messages].reverse().find((message) => typeof message === "object" && message !== null && message.role === "assistant");
+        preserveDrainedResult = (result.stopReason === "stop" || result.stopReason === "length") && !!result.text?.trim() && countToolCalls([lastAssistant]) === 0;
+        return result;
+      };
       rl.on("line", (line) => {
         if (settled || line.length === 0)
           return;
@@ -17703,6 +17763,10 @@ class PiSubagentRunner {
         });
         if (e.type === "auto_retry_start" || e.type === "agent_end" && event.willRetry === true) {
           sawAgentEnd = false;
+          preserveDrainedResult = false;
+          finalAssistantText = null;
+          finalStopReason = null;
+          finalErrorMessage = null;
           agentEndMessages = null;
           drainTimerStarted = false;
           if (drainTimerHandle) {
@@ -17712,14 +17776,11 @@ class PiSubagentRunner {
           armHardTimeout();
           return;
         }
-        if (e.type === "agent_end" && Array.isArray(e.messages)) {
+        if (e.type === "agent_end" && Array.isArray(e.messages) && !preserveDrainedResult) {
           sawAgentEnd = true;
           agentEndMessages = e.messages;
           accountingMessages = e.messages;
-          const result = extractFinalAssistant(e.messages);
-          finalAssistantText = result.text;
-          finalStopReason = result.stopReason;
-          finalErrorMessage = result.errorMessage;
+          const result = captureFinalAssistant(e.messages);
           emitProgress({
             type: "terminal",
             stopReason: result.stopReason ?? undefined,
@@ -17727,7 +17788,6 @@ class PiSubagentRunner {
             hasToolCall: false,
             ms: elapsedMs
           });
-          return;
         }
         if (e.type === "message_end" && e.message) {
           accumulatedMessages.push(e.message);
@@ -17735,12 +17795,9 @@ class PiSubagentRunner {
           if (m.role === "assistant") {
             const hasToolCall = Array.isArray(m.content) && m.content.some((c) => typeof c === "object" && c !== null && c.type === "toolCall");
             const isTerminalStopReason = typeof m.stopReason === "string" && (m.stopReason === "stop" || m.stopReason === "length" || m.stopReason === "error" || m.stopReason === "aborted");
-            if (isTerminalStopReason && !hasToolCall) {
+            if (isTerminalStopReason && !hasToolCall && !preserveDrainedResult) {
               sawAgentEnd = true;
-              const result = extractFinalAssistant(accumulatedMessages);
-              finalAssistantText = result.text;
-              finalStopReason = result.stopReason;
-              finalErrorMessage = result.errorMessage;
+              const result = captureFinalAssistant(accumulatedMessages);
               emitProgress({
                 type: "terminal",
                 stopReason: m.stopReason,
@@ -20704,12 +20761,14 @@ function normalizeMaterializeReason(harness, reason, rematerialized) {
   }
   return rematerialized ? "pressure_refold" : null;
 }
-function recordPendingPiTransformDecision(sessionId, decision, snapshotNewestAssistantEntryId) {
+function recordPendingPiTransformDecision(sessionId, decision, snapshotNewestAssistantEntryId, publicationGuard) {
+  publicationGuard?.();
   if (!decision.bustedThisPass)
     return;
   pendingPiDecisionBySession.set(sessionId, {
     ...decision,
-    snapshotNewestAssistantEntryId
+    snapshotNewestAssistantEntryId,
+    publicationGuard
   });
 }
 function findNewestPiAssistantEntryId(entries) {
@@ -20734,6 +20793,14 @@ function schedulePiTransformDecisionResolve(args) {
   const pending = pendingPiDecisionBySession.get(args.sessionId);
   if (!pending)
     return false;
+  try {
+    pending.publicationGuard?.();
+    args.assertCurrentPass?.();
+  } catch {
+    pendingPiDecisionBySession.delete(args.sessionId);
+    sessionLog(args.sessionId, "DISCARDED CONTEXT RESULT: pending Pi transform decision");
+    return false;
+  }
   const targetMessageId = findNewestPiAssistantEntryIdAfter(args.branchEntries, pending.snapshotNewestAssistantEntryId);
   if (!targetMessageId)
     return false;
@@ -20746,6 +20813,13 @@ function schedulePiTransformDecisionResolve(args) {
     try {
       if (!hasScheduledWriteToken(args.sessionId, token))
         return;
+      try {
+        pending.publicationGuard?.();
+        args.assertCurrentPass?.();
+      } catch {
+        sessionLog(args.sessionId, "DISCARDED CONTEXT RESULT: queued Pi transform decision");
+        return;
+      }
       writeTransformDecisionBestEffort(dbPath, {
         ...pending,
         sessionId: args.sessionId,
@@ -21040,6 +21114,10 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
           continue;
         }
         const target = targets.get(pendingOp.tagId);
+        if (target?.thinkingDropProtected) {
+          reject("active_thinking");
+          continue;
+        }
         const isToolTag = tagTypeById.get(pendingOp.tagId) === "tool";
         if (synthetic) {
           if (!isToolTag) {
@@ -21292,7 +21370,7 @@ function applyCavemanCleanup(sessionId, db, targets, tags, config) {
   const eligible = tags.filter((tag) => tag.type === "message" && tag.status === "active" && (protectedCutoff === null || tag.tagNumber < protectedCutoff) && tag.byteSize >= config.minChars).sort((a, b) => a.tagNumber - b.tagNumber);
   const tagsNeedingCompression = eligible.filter((tag, index) => {
     const target = targets.get(tag.tagNumber);
-    if (!target?.getContent || !target.setContent)
+    if (!target?.getContent || !target.setContent || target.thinkingRewriteProtected)
       return false;
     const targetDepth = computeTargetDepth(index, eligible.length);
     return targetDepth > tag.cavemanDepth;
@@ -21301,7 +21379,7 @@ function applyCavemanCleanup(sessionId, db, targets, tags, config) {
   let state = getCavemanReplayState(db, sessionId);
   if (!state.currentRules || state.englishWordRules !== englishWordRules) {
     const compressedBefore = tags.filter((tag) => tag.type === "message" && tag.status === "active" && tag.cavemanDepth > 0);
-    const switched = recordCavemanCurrentRules(db, sessionId, englishWordRules, compressedBefore.map((tag) => tag.tagNumber));
+    const switched = compressedBefore.some((tag) => targets.get(tag.tagNumber)?.thinkingRewriteProtected) ? null : recordCavemanCurrentRules(db, sessionId, englishWordRules, compressedBefore.map((tag) => tag.tagNumber));
     if (switched) {
       state = switched;
       const deepened = new Set(tagsNeedingCompression.map((tag) => tag.tagNumber));
@@ -21637,12 +21715,14 @@ function applyHeadCap(args) {
     diagnostics.completedRefence.tokenMass = index.rangeTokens(Math.min(...component.map((arc) => arc.invocation)), Math.max(...component.map((arc) => arc.result)) + 1);
   });
   diagnostics.completedRefence.to = end;
-  diagnostics.eligibleEnd = end <= offset ? offset : Math.min(end, protectedTailStart);
+  if (end > protectedTailStart)
+    end = offset;
+  diagnostics.eligibleEnd = end <= offset ? offset : end;
   args.observeDiagnostics?.(diagnostics);
   if (end <= offset && offset < protectedTailStart) {
     return { eligibleEndOrdinal: offset, oversizeAtomicUnit };
   }
-  return { eligibleEndOrdinal: Math.min(end, protectedTailStart), oversizeAtomicUnit };
+  return { eligibleEndOrdinal: end, oversizeAtomicUnit };
 }
 function resolveProtectedTailBoundary(ctx) {
   const createdAt = ctx.createdAt ?? Date.now();
@@ -21797,6 +21877,7 @@ function resolveProtectedTailBoundary(ctx) {
   }
   protectedTailStart = clampOrdinal(protectedTailStart, rawMessageCount);
   protectedTailStart = retreatPastHostUnservedRows(messages, protectedTailStart, offset);
+  protectedTailStart = Math.max(offset, fenceBoundaryForCompletedToolArcs(protectedTailStart, arcs, 1));
   const perRunCap = selectPerRunCap({
     usagePercentage,
     N: scaledN,
@@ -21816,7 +21897,8 @@ function resolveProtectedTailBoundary(ctx) {
     capTokens: perRunCap,
     recentOpenArcCutoff
   });
-  const eligibleEndOrdinal = retreatPastHostUnservedRows(messages, head.eligibleEndOrdinal, offset);
+  const servedEndOrdinal = retreatPastHostUnservedRows(messages, head.eligibleEndOrdinal, offset);
+  const eligibleEndOrdinal = Math.max(offset, fenceBoundaryForCompletedToolArcs(servedEndOrdinal, arcs, 1));
   const rawRangeFingerprint = computeRawRangeFingerprint(messages, offset, eligibleEndOrdinal);
   return {
     sessionId: ctx.sessionId,
@@ -21844,7 +21926,7 @@ function resolveProtectedTailBoundary(ctx) {
     cacheNamespace: ctx.cacheNamespace,
     createdAt,
     rawRangeFingerprint,
-    trueRawEligibleTokens: index.rangeTokens(offset, protectedTailStart),
+    trueRawEligibleTokens: index.rangeTokens(offset, eligibleEndOrdinal),
     oversizeAtomicUnit: head.oversizeAtomicUnit,
     boundaryReason,
     diagnostics: boundaryDiagnostics({
@@ -22075,6 +22157,8 @@ function getRawHistoryEligibility(db, sessionId) {
 function hasRunnableCompartmentWindow(snapshot) {
   if (snapshot.offset >= snapshot.protectedTailStart)
     return false;
+  if (snapshot.eligibleEndOrdinal <= snapshot.offset)
+    return false;
   const forceMaterializationPercentage = escalationBands(snapshot.executeThresholdPercentage).forceMaterializationPercentage;
   if (snapshot.usagePercentage >= forceMaterializationPercentage || snapshot.emergencyTailScale) {
     return snapshot.trueRawEligibleTokens >= deriveMinForceEligibleTokens(snapshot.N) || snapshot.eligibleEndOrdinal > snapshot.offset;
@@ -22145,6 +22229,187 @@ function recordHighPressureNoEligibleHead(db, snapshot) {
   return recordProtectedTailNoEligibleHead(db, snapshot.sessionId);
 }
 
+// ../plugin/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;
+}
+
+// ../plugin/src/hooks/magic-context/active-anthropic-turn.ts
+function isInActiveAnthropicTurn(messages, index, anthropic) {
+  if (!anthropic)
+    return false;
+  for (let user = messages.length - 1;user >= 0; user--) {
+    const message = messages[user];
+    if (!isRecord(message))
+      continue;
+    const info = isRecord(message.info) ? message.info : message;
+    if (info.role !== "user" || info.synthetic === true || message.synthetic === true)
+      continue;
+    const id = typeof info.id === "string" ? info.id : "";
+    if (id.startsWith("synth-user-"))
+      continue;
+    const parts = Array.isArray(message.parts) ? message.parts : Array.isArray(message.content) ? message.content : [];
+    if (parts.length > 0 && parts.every((part) => isRecord(part) && (part.synthetic === true || part.ignored === true || ["tool_result", "toolResult", "tool-result"].includes(String(part.type)))))
+      continue;
+    return index > user;
+  }
+  return false;
+}
+function hasAnthropicReasoning(messages) {
+  return messages.some((message) => {
+    if (!isRecord(message))
+      return false;
+    const info = isRecord(message.info) ? message.info : message;
+    if (isAnthropicFamilyRoute(typeof info.providerID === "string" ? info.providerID : typeof info.provider === "string" ? info.provider : undefined, typeof info.modelID === "string" ? info.modelID : typeof info.model === "string" ? info.model : undefined))
+      return true;
+    const parts = Array.isArray(message.parts) ? message.parts : [];
+    return parts.some((part) => isRecord(part) && isRecord(part.metadata) && isRecord(part.metadata.anthropic));
+  });
+}
+
+// ../plugin/src/hooks/magic-context/strip-content.ts
+var METADATA_PART_TYPES = new Set([
+  "step-start",
+  "step-finish",
+  "snapshot",
+  "patch",
+  "agent",
+  "retry",
+  "subtask",
+  "compaction"
+]);
+var CLEARED_REASONING_TYPES = new Set(["thinking", "reasoning"]);
+var REASONING_IGNORED_PART_TYPES = new Set([
+  "step-start",
+  "step-finish",
+  "snapshot",
+  "patch",
+  "agent",
+  "retry",
+  "subtask",
+  "compaction"
+]);
+var REASONING_PART_TYPES = new Set(["reasoning", "thinking", "redacted_thinking"]);
+function hasReasoningReplayContent(message) {
+  return message.parts.some((part) => {
+    if (!isRecord(part) || part.ignored === true)
+      return false;
+    const type = typeof part.type === "string" ? part.type : "";
+    if (REASONING_IGNORED_PART_TYPES.has(type))
+      return false;
+    return type !== "text" || typeof part.text !== "string" || part.text.trim().length > 0;
+  });
+}
+function findLatestAssistantReasoningMutationExemptMessage(messages) {
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message.info.role === "assistant" && hasReasoningReplayContent(message))
+      return message;
+  }
+  return;
+}
+
+// ../plugin/src/hooks/magic-context/reasoning-budget.ts
+var DEFAULT_KEEP_REASONING_TOKENS = 1e4;
+var UNKNOWN_REASONING_STEP_TOKENS = 1000;
+function resolveKeepReasoningTokens(config, modelKey) {
+  const values = config && typeof config === "object" ? Object.assign(Object.create(null), config) : undefined;
+  return typeof config === "number" ? config : resolveModelConfigValue(values, modelKey)?.value ?? values?.default ?? DEFAULT_KEEP_REASONING_TOKENS;
+}
+function reasoningStepCost(reported, textEstimate, opaque) {
+  if (reported !== undefined && Number.isFinite(reported) && reported > 0)
+    return reported;
+  if (textEstimate > 0)
+    return Math.ceil(textEstimate);
+  return opaque ? UNKNOWN_REASONING_STEP_TOKENS : 0;
+}
+function reasoningBudgetCutoff(steps, budget) {
+  const cost = (step) => step.alreadyRemoved ? 0 : typeof step.cost === "function" ? step.cost() : step.cost;
+  let kept = 0;
+  let upperBound = Number.POSITIVE_INFINITY;
+  for (const step of steps) {
+    if (!step.exempt)
+      continue;
+    kept += cost(step);
+    if (step.tag > 0)
+      upperBound = Math.min(upperBound, step.tag - 1);
+  }
+  for (let index = steps.length - 1;index >= 0; index--) {
+    const step = steps[index];
+    if (step.exempt || step.alreadyRemoved)
+      continue;
+    const tokens = cost(step);
+    if (kept + tokens <= budget) {
+      kept += tokens;
+      if (step.tag > 0)
+        upperBound = Math.min(upperBound, step.tag - 1);
+      continue;
+    }
+    let tag = step.tag;
+    for (let older = index - 1;tag <= 0 && older >= 0; older--)
+      tag = steps[older].tag;
+    return Math.max(0, Math.min(tag, upperBound));
+  }
+  return 0;
+}
+function reasoningTextAndOpaque(parts) {
+  let text = "";
+  let inlineText = "";
+  let opaque = false;
+  let hasReasoning = false;
+  const detailText = new Set;
+  for (const part of parts) {
+    if (!isRecord(part))
+      continue;
+    if (part.ignored === true)
+      continue;
+    if (isRecord(part.metadata)) {
+      const router = part.metadata.openrouter;
+      if (isRecord(router) && Array.isArray(router.reasoning_details) && router.reasoning_details.length > 0) {
+        hasReasoning = true;
+        opaque = true;
+        for (const detail of router.reasoning_details) {
+          if (!isRecord(detail))
+            continue;
+          if (detail.type === "reasoning.text" && typeof detail.text === "string")
+            detailText.add(detail.text);
+          if (detail.type === "reasoning.summary" && typeof detail.summary === "string")
+            detailText.add(detail.summary);
+        }
+      }
+    }
+    if (["reasoning", "thinking", "redacted_thinking"].includes(String(part.type))) {
+      hasReasoning = true;
+      const visible = part.type === "redacted_thinking" || part.redacted === true ? "" : typeof part.thinking === "string" ? part.thinking : typeof part.text === "string" ? part.text : "";
+      if (visible !== "[cleared]")
+        text += visible;
+      opaque ||= part.type === "redacted_thinking" || part.redacted === true || visible === "" && (part.metadata !== undefined || part.signature !== undefined || part.thinkingSignature !== undefined);
+    } else if (part.type === "text" && typeof part.text === "string") {
+      for (const match of part.text.matchAll(/<(?:thinking|think)>([\s\S]*?)<\/(?:thinking|think)>/gi))
+        inlineText += match[1];
+    }
+  }
+  return { text: text || [...detailText].join(""), inlineText, opaque, hasReasoning };
+}
+
 // ../plugin/src/hooks/magic-context/compartment-trigger.ts
 var PROACTIVE_TRIGGER_OFFSET_PERCENTAGE = 2;
 var POST_DROP_TARGET_RATIO = 0.75;
@@ -22187,7 +22452,7 @@ function estimateUntaggedInMemoryTailUpperBound(db, sessionId, inMemoryTail, tag
 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;
@@ -22197,9 +22462,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;
@@ -22269,7 +22550,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,
@@ -22281,7 +22562,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,
@@ -22303,11 +22584,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) {
@@ -22359,7 +22648,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);
@@ -22537,6 +22826,292 @@ function foldExecutesThisPass(foldDue, materialized) {
   return foldDue && materialized;
 }
 
+// ../plugin/src/hooks/magic-context/reasoning-removal.ts
+var REMOVABLE_REASONING_TYPES = new Set(["reasoning", "thinking", "redacted_thinking"]);
+
+// ../plugin/src/hooks/magic-context/latest-assistant-turn.ts
+var THINKING_TYPES = new Set(["reasoning", "thinking", "redacted_thinking"]);
+function role(message) {
+  if (!isRecord(message))
+    return;
+  return isRecord(message.info) ? message.info.role : message.role;
+}
+function content(message) {
+  if (!isRecord(message))
+    return;
+  return Array.isArray(message.parts) ? message.parts : message.content;
+}
+function latestAssistantTurnStart(messages) {
+  let lo = 0;
+  let hi = messages.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (isInActiveAnthropicTurn(messages, mid, true))
+      hi = mid;
+    else
+      lo = mid + 1;
+  }
+  return lo;
+}
+function latestAssistantTurnMessages(messages) {
+  return new Set(messages.slice(latestAssistantTurnStart(messages)));
+}
+function hasActiveAnthropicThinkingTurn(messages, provider, model) {
+  const familyRoute = isAnthropicFamilyRoute(provider, model);
+  for (const message of messages.slice(latestAssistantTurnStart(messages))) {
+    if (role(message) !== "assistant")
+      continue;
+    const parts = content(message);
+    if (!Array.isArray(parts))
+      continue;
+    if (parts.some((part) => isRecord(part) && THINKING_TYPES.has(String(part.type ?? part.kind)) && (familyRoute || isRecord(part.metadata) && isRecord(part.metadata.anthropic))))
+      return true;
+  }
+  return false;
+}
+function protectNewTagMutations(messages, targets, protectedParts, prefixBound) {
+  if (protectedParts.size === 0)
+    return targets;
+  const positions = new Map;
+  let ordinal = 0;
+  for (const message of messages)
+    for (const part of message.parts)
+      positions.set(part, ordinal++);
+  let lastProtected = -1;
+  for (const part of protectedParts)
+    lastProtected = Math.max(lastProtected, positions.get(part) ?? -1);
+  const result = new Map;
+  for (const [tag, target] of targets) {
+    const coordinates = target.mutationParts ?? (target.message ? target.message.parts.map((part) => ({ message: target.message, part })) : []);
+    const prefixEdit = prefixBound && coordinates.some(({ part }) => (positions.get(part) ?? Infinity) < lastProtected);
+    const dropsThinking = target.dropReasoningParts?.some((part) => protectedParts.has(part)) === true;
+    if (!prefixEdit && !dropsThinking) {
+      result.set(tag, target);
+      continue;
+    }
+    result.set(tag, {
+      ...target,
+      thinkingDropProtected: true,
+      thinkingRewriteProtected: prefixEdit,
+      canDrop: () => false,
+      drop: () => "incomplete",
+      truncate: () => "incomplete",
+      skeletonReal: () => "incomplete",
+      skeletonStripped: () => "incomplete",
+      editMarker: () => "incomplete",
+      editMarkerStripped: () => "incomplete",
+      setContent: (content, options) => prefixEdit || options?.keepReasoning !== true ? false : target.setContent(content, options)
+    });
+  }
+  return result;
+}
+
+// ../plugin/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 latestThinkingRecoveryCoversActiveTurn(args) {
+  let target;
+  try {
+    target = getThinkingBindingRecoveryTarget(args.db, args.sessionId);
+  } catch {
+    return false;
+  }
+  const bound = target?.startsWith(ARMED) ? target.slice(ARMED.length) : target?.startsWith(ACTIVE) ? target.slice(ACTIVE.length) : undefined;
+  if (bound === undefined)
+    return false;
+  const start = latestAssistantTurnStart(args.messages);
+  return start > 0 && args.id(args.messages[start - 1], start - 1) === bound;
+}
+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 armBindingRecoverySafely(db, sessionId) {
+  if (getThinkingBindingRecoveryTarget(db, sessionId)?.startsWith(LATEST_THINKING_RESTORE))
+    armLatestThinkingRecovery(db, sessionId);
+  else
+    armThinkingBindingRecovery(db, sessionId);
+}
+
+// ../plugin/src/hooks/magic-context/reasoning-budget-status.ts
+var sources = new Map;
+function captureOpencodeReasoningBudgetStatus(sessionId, messages, budget, prefixBound, proseRatio = 1) {
+  if (messages.some((message) => !isRecord(message) || !isRecord(message.info) || typeof message.info.role !== "string" || !Array.isArray(message.parts))) {
+    sources.delete(sessionId);
+    return;
+  }
+  const compact = messages.filter((message) => message.info.role === "assistant").map((message) => {
+    const info = message.info;
+    const visible = reasoningTextAndOpaque(message.parts);
+    const parts = message.parts.filter(isRecord).map((part) => ({
+      type: typeof part.type === "string" ? part.type : "",
+      text: typeof part.text === "string" && part.type !== "redacted_thinking" && part.redacted !== true ? part.text : undefined,
+      thinking: typeof part.thinking === "string" && part.redacted !== true ? part.thinking : undefined,
+      ignored: part.ignored === true,
+      redacted: part.redacted === true,
+      metadata: part.metadata === undefined ? undefined : {},
+      signature: part.signature === undefined ? undefined : true,
+      thinkingSignature: part.thinkingSignature === undefined ? undefined : true
+    }));
+    if (visible.hasReasoning && !reasoningTextAndOpaque(parts).hasReasoning)
+      parts.push({
+        type: "reasoning",
+        text: visible.text,
+        thinking: undefined,
+        ignored: false,
+        redacted: false,
+        metadata: visible.opaque ? {} : undefined,
+        signature: undefined,
+        thinkingSignature: undefined
+      });
+    return {
+      info: {
+        role: info.role,
+        tokens: isRecord(info.tokens) && typeof info.tokens.reasoning === "number" ? { reasoning: info.tokens.reasoning } : undefined
+      },
+      parts
+    };
+  });
+  sources.delete(sessionId);
+  sources.set(sessionId, { messages: compact, budget, prefixBound, proseRatio });
+  if (sources.size > 32)
+    sources.delete(sources.keys().next().value);
+}
+function reasoningBudgetStatusLine(sessionId) {
+  try {
+    const source = sources.get(sessionId);
+    if (!source)
+      return;
+    source.status ??= opencodeReasoningBudgetStatus(source.messages, source.budget, source.prefixBound, source.proseRatio);
+    return formatReasoningBudgetStatus(source.status);
+  } catch {
+    return;
+  }
+}
+function formatReasoningBudgetStatus(status) {
+  const count = (tokens) => tokens >= 1000 ? `${Number((tokens / 1000).toFixed(1))}k` : String(Math.round(tokens));
+  return `Reasoning kept: ${count(status.kept)} of ${count(status.budget)} (${status.estimated ? "estimated" : "reported"})${status.overrun ? ` (over budget: ${status.overrun})` : ""}`;
+}
+function opencodeReasoningBudgetStatus(messages, budget, prefixBound, proseRatio = 1) {
+  const assistants = messages.filter((message) => message.info.role === "assistant");
+  const newest = assistants.at(-1);
+  const exempt = findLatestAssistantReasoningMutationExemptMessage(messages);
+  let kept = 0;
+  let exemptCost = 0;
+  let estimated = false;
+  for (const message of assistants) {
+    const visible = reasoningTextAndOpaque(message.parts);
+    const info = message.info;
+    const reported = isRecord(info.tokens) && typeof info.tokens.reasoning === "number" ? info.tokens.reasoning : undefined;
+    const cost = (visible.hasReasoning ? reported !== undefined && Number.isFinite(reported) && reported > 0 ? reported : reasoningStepCost(reported, estimateTokens(visible.text) * proseRatio, visible.opaque) : 0) + Math.ceil(estimateTokens(visible.inlineText) * proseRatio);
+    kept += cost;
+    if (message === newest || message === exempt)
+      exemptCost += cost;
+    if (cost > 0 && (!(reported && Number.isFinite(reported) && reported > 0) || visible.inlineText !== ""))
+      estimated = true;
+  }
+  return {
+    kept,
+    budget,
+    estimated,
+    overrun: kept > budget ? exemptCost > budget ? "newest step" : prefixBound ? "signed prefix" : "awaiting rebuild" : undefined
+  };
+}
+
 // ../plugin/src/hooks/magic-context/supersession-reclaim.ts
 var SUPERSESSION_RECENT_MESSAGE_WINDOW = 20;
 function recentSupersessionOwnerMessageIds(db, sessionId) {
@@ -23337,6 +23912,10 @@ function buildAggregateTarget(tagId, occurrences, requiresToolArcSkeleton, conve
     return !occurrences.every((occ, index) => occ.part.remove && authorization[index] !== false);
   };
   return {
+    mutationParts: occurrences.map((occ) => ({
+      message: { info: occ.message.info, parts: [] },
+      part: occ.part
+    })),
     measureReclaim(skeleton) {
       let beforeTools = 0;
       let afterTools = 0;
@@ -23450,6 +24029,7 @@ function buildAggregateTarget(tagId, occurrences, requiresToolArcSkeleton, conve
 }
 function buildTextTarget(part, message, textPrefix) {
   return {
+    mutationParts: [{ message: { info: message.info, parts: [] }, part }],
     textPrefix,
     setContent(content) {
       return part.setText(content);
@@ -23465,6 +24045,7 @@ function buildTextTarget(part, message, textPrefix) {
 }
 function buildToolTarget(part, message, tagId) {
   return {
+    mutationParts: [{ message: { info: message.info, parts: [] }, part }],
     setContent(content) {
       return setToolContentOrText(part, content);
     },
@@ -23498,12 +24079,58 @@ function buildToolTarget(part, message, tagId) {
 
 // ../plugin/src/hooks/magic-context/auto-search-deadline.ts
 var AUTO_SEARCH_TIMEOUT_MS = 3000;
+var operationDeadlines = new WeakMap;
+function autoSearchDeadlineUnixMs(signal) {
+  const deadline = signal && operationDeadlines.get(signal);
+  return Date.now() + (deadline === undefined ? AUTO_SEARCH_TIMEOUT_MS : Math.max(0, deadline - performance.now()));
+}
+var skippedTurns = new Map;
+function wasAutoSearchSkipped(db, sessionId, messageId) {
+  return skippedTurns.get(sessionId)?.get(db)?.has(messageId) ?? false;
+}
+function clearAutoSearchTimeoutForSession(sessionId) {
+  cancelAutoSearchWork(sessionId);
+  if (sessionId === undefined)
+    skippedTurns.clear();
+  else
+    skippedTurns.delete(sessionId);
+}
+function persistAutoSearchSkip(db, sessionId, messageId, reason = "timeout") {
+  assertTransformWrite();
+  let turns = skippedTurns.get(sessionId);
+  if (!turns) {
+    turns = new WeakMap;
+    skippedTurns.set(sessionId, turns);
+  }
+  let messages = turns.get(db);
+  if (!messages) {
+    messages = new Map;
+    turns.set(db, messages);
+  }
+  const prior = messages.get(messageId);
+  if (prior)
+    return prior;
+  let ok = false;
+  try {
+    const outcome = appendAutoSearchHintDecision(db, sessionId, {
+      messageId,
+      decision: "no-hint",
+      reason
+    });
+    ok = outcome.ok && outcome.decision.decision === "no-hint";
+  } catch {}
+  assertTransformWrite();
+  const persistence = Promise.resolve(ok);
+  messages.set(messageId, persistence);
+  return persistence;
+}
 async function withAutoSearchDeadline(operation, startedAt = performance.now()) {
   const deadline = startedAt + AUTO_SEARCH_TIMEOUT_MS;
   const remaining = deadline - performance.now();
   if (remaining <= 0)
     return null;
   const controller = new AbortController;
+  operationDeadlines.set(controller.signal, deadline);
   const checkDeadline = () => {
     if (!controller.signal.aborted && performance.now() >= deadline)
       controller.abort();
@@ -23622,6 +24249,205 @@ ${trimmedBody}…
   return wrapped;
 }
 
+// ../plugin/src/hooks/magic-context/auto-search-worker-client.ts
+import { Worker } from "node:worker_threads";
+var pendingRegistrations = new WeakMap;
+var pendingTurns = new WeakMap;
+async function coalesceAutoSearchTurn(db, sessionId, messageId, operation, replay) {
+  let sessions = pendingTurns.get(db);
+  if (!sessions) {
+    sessions = new Map;
+    pendingTurns.set(db, sessions);
+  }
+  let turns = sessions.get(sessionId);
+  if (!turns) {
+    turns = new Map;
+    sessions.set(sessionId, turns);
+  }
+  const pending = turns.get(messageId);
+  if (pending && !pending.signal.aborted) {
+    const result = await pending.promise;
+    if (!pending.signal.aborted)
+      replay();
+    return result;
+  }
+  const lifecycle = registerAutoSearchWork(sessionId);
+  const work = Promise.resolve().then(() => operation(lifecycle.signal));
+  const turn = { promise: work, signal: lifecycle.signal };
+  turns.set(messageId, turn);
+  try {
+    return await work;
+  } finally {
+    lifecycle.done();
+    if (turns.get(messageId) === turn)
+      turns.delete(messageId);
+    if (turns.size === 0)
+      sessions.delete(sessionId);
+  }
+}
+function queueAutoSearchRegistration(db, projectPath, register) {
+  if (!register)
+    return;
+  let pending = pendingRegistrations.get(db);
+  if (!pending) {
+    pending = new Set;
+    pendingRegistrations.set(db, pending);
+  }
+  if (pending.has(projectPath))
+    return;
+  pending.add(projectPath);
+  const timer = setTimeout(() => {
+    if (getProjectEmbeddingSnapshot(projectPath)) {
+      pending.delete(projectPath);
+      return;
+    }
+    Promise.resolve().then(register).catch((error) => log(`[auto-search] background registration failed: ${error instanceof Error ? error.message : String(error)}`)).finally(() => pending.delete(projectPath));
+  }, 0);
+  timer.unref?.();
+}
+function persistAutoSearchDecision(db, sessionId, decision, startedAt) {
+  if (performance.now() - startedAt >= AUTO_SEARCH_TIMEOUT_MS)
+    return null;
+  return appendAutoSearchHintDecision(db, sessionId, decision);
+}
+async function searchAutoHint(db, sessionId, projectPath, query, options, entry = new URL(new URL(import.meta.url).pathname.endsWith(".ts") ? "./auto-search-worker.ts" : "./auto-search-worker.js", import.meta.url)) {
+  return executeAutoSearchWorker(db, sessionId, projectPath, query, options, entry, "search");
+}
+var pendingBackfills = new WeakMap;
+function queueAutoSearchBackfill(db, sessionId, projectPath, query) {
+  if (isEmbeddingHostBusy())
+    return Promise.resolve();
+  const key = `${sessionId}\x00${projectPath}`;
+  const pending = pendingBackfills.get(db) ?? new Map;
+  pendingBackfills.set(db, pending);
+  const prior = pending.get(key);
+  if (prior)
+    return prior;
+  const lifecycle = registerAutoSearchWork(sessionId);
+  const work = new Promise((resolve) => {
+    const done = () => {
+      lifecycle.done();
+      pending.delete(key);
+      resolve();
+    };
+    const queued = setTimeout(() => {
+      lifecycle.signal.removeEventListener("abort", cancel);
+      if (lifecycle.signal.aborted)
+        return done();
+      const controller = new AbortController;
+      const timeout = setTimeout(() => controller.abort(), 1e4);
+      timeout.unref?.();
+      executeAutoSearchWorker(db, sessionId, projectPath, query, { signal: AbortSignal.any([controller.signal, lifecycle.signal]) }, new URL(new URL(import.meta.url).pathname.endsWith(".ts") ? "./auto-search-worker.ts" : "./auto-search-worker.js", import.meta.url), "backfill").catch((error) => log("[auto-search] background backfill failed:", error)).finally(() => {
+        clearTimeout(timeout);
+        done();
+      });
+    }, 0);
+    const cancel = () => {
+      clearTimeout(queued);
+      done();
+    };
+    lifecycle.signal.addEventListener("abort", cancel, { once: true });
+    queued.unref?.();
+  });
+  pending.set(key, work);
+  return work;
+}
+async function executeAutoSearchWorker(db, sessionId, projectPath, query, options, entry, job) {
+  if (options.signal?.aborted)
+    return [];
+  const path = getSqliteDatabasePath(db);
+  if (!path)
+    throw new Error("auto-search requires a file-backed database for off-thread search");
+  const {
+    embedQuery,
+    isEmbeddingRuntimeEnabled,
+    signal: deadlineSignal,
+    readMessages: _readMessages,
+    ...serializable
+  } = options;
+  const lifecycle = registerAutoSearchWork(sessionId);
+  const signal = deadlineSignal ? AbortSignal.any([deadlineSignal, lifecycle.signal]) : lifecycle.signal;
+  const snapshot = getProjectEmbeddingSnapshot(projectPath);
+  const input = {
+    job,
+    path,
+    harness: getHarness(),
+    sessionId,
+    projectPath,
+    query,
+    options: {
+      ...serializable,
+      backfillMemoryEmbeddings: false,
+      countRetrievals: false,
+      measurementDisabled: true
+    },
+    embeddingRuntimeEnabled: isEmbeddingRuntimeEnabled?.() ?? false,
+    embeddingHostBusy: isEmbeddingHostBusy(),
+    snapshot,
+    deadlineUnixMs: autoSearchDeadlineUnixMs(deadlineSignal)
+  };
+  return new Promise((resolve, reject) => {
+    const worker = new Worker(entry, { workerData: input });
+    let settled = false;
+    const finish = (results, error) => {
+      if (settled)
+        return;
+      settled = true;
+      signal?.removeEventListener("abort", abort);
+      lifecycle.signal.removeEventListener("abort", abort);
+      lifecycle.done();
+      worker.terminate();
+      worker.unref();
+      if (error)
+        reject(error);
+      else
+        resolve(results);
+    };
+    const abort = () => finish([]);
+    signal?.addEventListener("abort", abort, { once: true });
+    lifecycle.signal.addEventListener("abort", abort, { once: true });
+    worker.on("error", (error) => finish([], error));
+    worker.on("exit", (code) => finish([], new Error(`auto-search worker exited (${code})`)));
+    worker.on("message", async (reply) => {
+      if (settled)
+        return;
+      if (reply.kind === "result") {
+        if (snapshot && getProjectEmbeddingSnapshot(projectPath)?.generation !== snapshot.generation)
+          finish([]);
+        else
+          finish(reply.results);
+        return;
+      }
+      if (reply.kind === "error") {
+        finish([], new Error(reply.error));
+        return;
+      }
+      const response = { id: reply.id };
+      try {
+        if (reply.kind === "query")
+          response.result = await (job === "backfill" ? embedTextForProject(projectPath, reply.text, signal, "query") : embedQuery?.(reply.text, signal)) ?? null;
+        else {
+          const passage = await embedBatchForProject(projectPath, reply.texts, signal, reply.purpose);
+          const current = getProjectEmbeddingSnapshot(projectPath);
+          response.passage = passage && current ? {
+            ...passage,
+            providerIdentity: current.providerIdentity,
+            runtimeFingerprint: current.runtimeFingerprint,
+            dimensions: passage.vectors.find((vector) => vector !== null)?.length ?? null
+          } : null;
+        }
+      } catch (error) {
+        response.error = error instanceof Error ? error.message : String(error);
+      }
+      response.embeddingHostBusy = isEmbeddingHostBusy();
+      if (!settled && !signal?.aborted)
+        worker.postMessage(response);
+    });
+    if (signal?.aborted)
+      abort();
+  });
+}
+
 // src/auto-search-pi.ts
 var DEFAULT_SCORE_THRESHOLD = 0.55;
 var DEFAULT_MIN_PROMPT_CHARS = 20;
@@ -23716,6 +24542,8 @@ function appendHintToUserMessage(message, hint) {
 }
 async function runAutoSearchHintForPi(args) {
   const startedAt = performance.now();
+  args.passGuard?.assert();
+  const wait = args.passGuard?.wait ?? ((pending) => pending);
   const { sessionId, db, messages, options, entryIdByRef } = args;
   const entryIds = args.entryIds === undefined ? messages.map((message, index) => {
     const timestamp = message.timestamp;
@@ -23732,118 +24560,165 @@ async function runAutoSearchHintForPi(args) {
   if (found === null)
     return messages;
   const { message: userMsg, messageId: userMsgId } = found;
-  const existing = args.decisions ?? getAutoSearchHintDecisions(db, sessionId);
-  const existingForMessage = existing.find((decision) => decision.messageId === userMsgId);
-  if (existingForMessage) {
-    if (existingForMessage.decision === "hint") {
-      appendHintToUserMessage(userMsg, existingForMessage.text);
+  await wait(coalesceAutoSearchTurn(db, sessionId, userMsgId, async (lifecycleSignal) => {
+    args.passGuard?.assert();
+    if (lifecycleSignal.aborted)
+      return messages;
+    if (wasAutoSearchSkipped(db, sessionId, userMsgId))
+      return messages;
+    const existing = args.decisions ?? getAutoSearchHintDecisions(db, sessionId);
+    const existingForMessage = existing.find((decision) => decision.messageId === userMsgId) ?? (args.decisions ? getAutoSearchHintDecisions(db, sessionId).find((decision) => decision.messageId === userMsgId) : undefined);
+    if (existingForMessage) {
+      if (existingForMessage.decision === "hint") {
+        appendHintToUserMessage(userMsg, existingForMessage.text);
+      }
+      return messages;
     }
-    return messages;
-  }
-  if (strictResolutionFailed) {
-    sessionLog(sessionId, "Pi auto-search: strict entry-id resolution failed; replayed persisted decisions only");
-    return messages;
-  }
-  if (found.index !== messages.length - 1)
-    return messages;
-  if (!isUsableProjectIdentity(options.projectPath))
-    return messages;
-  const writeNoHintAndReconcile = (reason) => {
-    const outcome = appendAutoSearchHintDecision(db, sessionId, {
-      messageId: userMsgId,
-      decision: "no-hint",
-      reason
-    });
-    if (!outcome.ok)
-      return;
-    if (outcome.kind === "already-present" && outcome.decision.decision === "hint") {
-      appendHintToUserMessage(userMsg, outcome.decision.text);
+    if (strictResolutionFailed) {
+      sessionLog(sessionId, "Pi auto-search: strict entry-id resolution failed; replayed persisted decisions only");
+      return messages;
     }
-  };
-  const rawPartsText = collectUserPromptParts(userMsg);
-  if (hasStackedAugmentation(rawPartsText)) {
-    sessionLog(sessionId, "auto-search: skipping — user message already carries augmentation/hint");
-    writeNoHintAndReconcile("stacked");
-    return messages;
-  }
-  const rawPrompt = extractUserPromptText(userMsg);
-  const minPromptChars = options.minPromptChars ?? DEFAULT_MIN_PROMPT_CHARS;
-  if (rawPrompt.length < minPromptChars) {
-    writeNoHintAndReconcile("too-short");
-    return messages;
-  }
-  let results;
-  try {
-    results = await withAutoSearchDeadline(async (signal, checkDeadline) => {
-      await args.ensureProjectRegistered?.();
-      if (checkDeadline())
-        return null;
-      const snapshot = getProjectEmbeddingSnapshot(options.projectPath);
-      const memoryEnabled = snapshot?.features.memoryEnabled ?? true;
-      const embeddingEnabled = snapshot ? snapshot.historyEnabled : true;
-      const gitCommitsEnabled = snapshot?.gitCommitEnabled ?? false;
-      const searchOptions = {
-        limit: 10,
-        memoryEnabled,
-        embeddingEnabled,
-        gitCommitsEnabled,
-        embedQuery: async (text, signal) => {
-          const result = await embedTextForProject(options.projectPath, text, signal, "query");
-          checkDeadline();
-          return result?.vector ?? null;
-        },
-        isEmbeddingRuntimeEnabled: () => embeddingEnabled === true,
-        visibleMemoryIds: options.visibleMemoryIds ?? null,
-        sources: ["memory", "message", "git_commit"]
-      };
-      return unifiedSearch(db, sessionId, options.projectPath, rawPrompt, {
-        ...searchOptions,
-        signal,
-        countRetrievals: false
+    if (found.index !== messages.length - 1)
+      return messages;
+    if (!isUsableProjectIdentity(options.projectPath))
+      return messages;
+    const snapshot = getProjectEmbeddingSnapshot(options.projectPath);
+    if (!snapshot) {
+      queueAutoSearchRegistration(db, options.projectPath, args.ensureProjectRegistered);
+      persistAutoSearchSkip(db, sessionId, userMsgId, "empty");
+      return messages;
+    }
+    const writeNoHintAndReconcile = async (reason) => {
+      args.passGuard?.assert();
+      const outcome = persistAutoSearchDecision(db, sessionId, {
+        messageId: userMsgId,
+        decision: "no-hint",
+        reason
+      }, startedAt);
+      args.passGuard?.assert();
+      if (outcome === null) {
+        persistAutoSearchSkip(db, sessionId, userMsgId);
+        return;
+      }
+      if (!outcome.ok)
+        return;
+      if (outcome.kind === "already-present" && outcome.decision.decision === "hint") {
+        appendHintToUserMessage(userMsg, outcome.decision.text);
+      }
+    };
+    const rawPartsText = collectUserPromptParts(userMsg);
+    if (hasStackedAugmentation(rawPartsText)) {
+      sessionLog(sessionId, "auto-search: skipping — user message already carries augmentation/hint");
+      await writeNoHintAndReconcile("stacked");
+      return messages;
+    }
+    const rawPrompt = extractUserPromptText(userMsg);
+    const minPromptChars = options.minPromptChars ?? DEFAULT_MIN_PROMPT_CHARS;
+    if (rawPrompt.length < minPromptChars) {
+      await writeNoHintAndReconcile("too-short");
+      return messages;
+    }
+    let results;
+    try {
+      results = await wait(withAutoSearchDeadline(async (signal, checkDeadline) => {
+        args.passGuard?.assert();
+        if (checkDeadline())
+          return null;
+        const memoryEnabled = snapshot?.features.memoryEnabled ?? true;
+        const embeddingEnabled = snapshot ? snapshot.historyEnabled : true;
+        const gitCommitsEnabled = snapshot?.gitCommitEnabled ?? false;
+        const searchOptions = {
+          limit: 10,
+          memoryEnabled,
+          embeddingEnabled,
+          gitCommitsEnabled,
+          embedQuery: async (text, signal) => {
+            const result = await wait(embedTextForProject(options.projectPath, text, signal, "query"));
+            args.passGuard?.assert();
+            checkDeadline();
+            return result;
+          },
+          isEmbeddingRuntimeEnabled: () => embeddingEnabled === true,
+          visibleMemoryIds: options.visibleMemoryIds ?? null,
+          sources: ["memory", "message", "git_commit"]
+        };
+        return searchAutoHint(db, sessionId, options.projectPath, rawPrompt, {
+          ...searchOptions,
+          signal,
+          countRetrievals: false
+        });
+      }, startedAt));
+    } catch (error) {
+      args.passGuard?.assert();
+      log(`[auto-search] unified search failed for session ${sessionId} (will retry next pass): ${error instanceof Error ? error.message : String(error)}`);
+      return messages;
+    }
+    args.passGuard?.assert();
+    if (lifecycleSignal.aborted)
+      return messages;
+    try {
+      if (results === null) {
+        sessionLog(sessionId, `auto-search: timed out after ${AUTO_SEARCH_TIMEOUT_MS}ms, skipping hint for this turn`);
+        persistAutoSearchSkip(db, sessionId, userMsgId);
+        return messages;
+      }
+      if (results.length === 0) {
+        await writeNoHintAndReconcile("empty");
+        return messages;
+      }
+      const scoreThreshold = options.scoreThreshold ?? DEFAULT_SCORE_THRESHOLD;
+      if (results[0].score < scoreThreshold) {
+        sessionLog(sessionId, `auto-search: top score ${results[0].score.toFixed(3)} below threshold ${scoreThreshold}`);
+        await writeNoHintAndReconcile("below-threshold");
+        return messages;
+      }
+      const hintText = buildAutoSearchHint(results, {
+        wordRules: options.wordRules
       });
-    }, startedAt);
-  } catch (error) {
-    log(`[auto-search] unified search failed for session ${sessionId} (will retry next pass): ${error instanceof Error ? error.message : String(error)}`);
-    return messages;
-  }
-  if (results === null) {
-    sessionLog(sessionId, `auto-search: timed out after ${AUTO_SEARCH_TIMEOUT_MS}ms, skipping hint for this turn (will retry)`);
-    return messages;
-  }
-  if (results.length === 0) {
-    writeNoHintAndReconcile("empty");
-    return messages;
-  }
-  const scoreThreshold = options.scoreThreshold ?? DEFAULT_SCORE_THRESHOLD;
-  if (results[0].score < scoreThreshold) {
-    sessionLog(sessionId, `auto-search: top score ${results[0].score.toFixed(3)} below threshold ${scoreThreshold}`);
-    writeNoHintAndReconcile("below-threshold");
-    return messages;
-  }
-  const hintText = buildAutoSearchHint(results, {
-    wordRules: options.wordRules
-  });
-  if (!hintText) {
-    writeNoHintAndReconcile("empty");
-    return messages;
-  }
-  const payload = `
+      if (!hintText) {
+        await writeNoHintAndReconcile("empty");
+        return messages;
+      }
+      const payload = `
 
 ${hintText}`;
-  const outcome = appendAutoSearchHintDecision(db, sessionId, {
-    messageId: userMsgId,
-    decision: "hint",
-    text: payload
-  });
-  if (!outcome.ok)
-    return messages;
-  if (outcome.decision.decision === "hint") {
-    appendHintToUserMessage(userMsg, outcome.decision.text);
-  }
-  sessionLog(sessionId, `auto-search: attached hint to ${userMsgId} (${results.length} fragments, top score ${results[0].score.toFixed(3)})`);
+      args.passGuard?.assert();
+      const outcome = persistAutoSearchDecision(db, sessionId, {
+        messageId: userMsgId,
+        decision: "hint",
+        text: payload
+      }, startedAt);
+      args.passGuard?.assert();
+      if (outcome === null) {
+        persistAutoSearchSkip(db, sessionId, userMsgId);
+        return messages;
+      }
+      if (!outcome.ok)
+        return messages;
+      if (outcome.decision.decision === "hint") {
+        appendHintToUserMessage(userMsg, outcome.decision.text);
+      }
+      sessionLog(sessionId, `auto-search: attached hint to ${userMsgId} (${results.length} fragments, top score ${results[0].score.toFixed(3)})`);
+      return messages;
+    } finally {
+      if (!lifecycleSignal.aborted && results !== null) {
+        args.passGuard?.assert();
+        queueAutoSearchBackfill(db, sessionId, options.projectPath, rawPrompt);
+      }
+    }
+  }, () => {
+    args.passGuard?.assert();
+    if (wasAutoSearchSkipped(db, sessionId, userMsgId))
+      return;
+    const decision = getAutoSearchHintDecisions(db, sessionId).find((entry) => entry.messageId === userMsgId);
+    if (decision?.decision === "hint")
+      appendHintToUserMessage(userMsg, decision.text);
+  }));
   return messages;
 }
-function clearAutoSearchForPiSession(_sessionId) {}
+function clearAutoSearchForPiSession(sessionId) {
+  clearAutoSearchTimeoutForSession(sessionId);
+}
 
 // src/pi-historian-runner.ts
 import * as crypto2 from "node:crypto";
@@ -23908,51 +24783,6 @@ async function embedAndStoreCompartmentChunks(db, sessionId, projectPath, compar
   }
 }
 
-// ../plugin/src/features/magic-context/storage-historian-runs.ts
-function recordHistorianRun(db, input) {
-  try {
-    const result = db.prepare(`INSERT INTO historian_runs (
-                    session_id, harness, subagent_invocation_id, run_kind, status,
-                    failure_reason, chunk_start_ordinal, chunk_end_ordinal, unprocessed_from,
-                    compartments_produced, compartment_id_min, compartment_id_max,
-                    facts_emitted, facts_by_category_json, events_emitted,
-                    importance_min, importance_max, importance_avg,
-                    discarded_last, legacy, created_at
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(input.sessionId, input.harness, input.subagentInvocationId ?? null, input.runKind, input.status, input.failureReason ?? null, input.chunkStartOrdinal ?? null, input.chunkEndOrdinal ?? null, input.unprocessedFrom ?? null, input.compartmentsProduced ?? 0, input.compartmentIdMin ?? null, input.compartmentIdMax ?? null, input.factsEmitted ?? 0, JSON.stringify({
-      ...input.factsByCategory ?? {},
-      facts_promoted: input.factsPromoted ?? 0,
-      events_published: input.eventsPublished ?? 0
-    }), input.eventsEmitted ?? 0, input.importanceMin ?? null, input.importanceMax ?? null, input.importanceAvg ?? null, input.discardedLast ? 1 : 0, input.legacy ? 1 : 0, Date.now());
-    return Number(result.lastInsertRowid);
-  } catch {
-    return null;
-  }
-}
-function summarizeImportance(values) {
-  const nums = values.filter((v) => typeof v === "number" && Number.isFinite(v));
-  if (nums.length === 0)
-    return { min: null, max: null, avg: null };
-  let min = nums[0];
-  let max = nums[0];
-  let sum = 0;
-  for (const v of nums) {
-    if (v < min)
-      min = v;
-    if (v > max)
-      max = v;
-    sum += v;
-  }
-  return { min, max, avg: sum / nums.length };
-}
-function tallyFactsByCategory(facts) {
-  const out = {};
-  for (const f of facts) {
-    const cat = (f.category ?? "UNKNOWN").trim() || "UNKNOWN";
-    out[cat] = (out[cat] ?? 0) + 1;
-  }
-  return out;
-}
-
 // ../plugin/src/hooks/magic-context/compartment-runner-drop-queue.ts
 function prepareCompartmentDrops(db, sessionId, upToMessageIndex, observedKeys, fromMessageIndex = 1) {
   const candidates = getActiveTagsBySession(db, sessionId).filter((tag) => {
@@ -28103,9 +28933,6 @@ function probe(db, sessionId, kind) {
 function hasPiFallbackMessageTags2(db, sessionId) {
   return probe(db, sessionId, "message");
 }
-function hasPiFallbackToolOwnerTags2(db, sessionId) {
-  return probe(db, sessionId, "tool");
-}
 
 // src/heuristic-cleanup-pi.ts
 var DEDUP_SAFE_TOOLS = new Set([
@@ -28366,6 +29193,8 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config, pre
           continue;
         const strippedSource = stripTagPrefix(stripped);
         if (strippedSource.trim().length === 0) {
+          if (target.thinkingDropProtected)
+            continue;
           const dropResult = target.drop?.() ?? "absent";
           const didReplace = dropResult === "absent" ? target.setContent(`[dropped §${tag.tagNumber}§]`) : false;
           if (dropResult === "removed" || dropResult === "absent") {
@@ -28380,7 +29209,7 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config, pre
           }
         } else {
           if (freezePiContentDecision(db, sessionId, "reminder-strip", tag.messageId)) {
-            if (target.setContent(stripped)) {
+            if (target.setContent(stripped, { keepReasoning: true })) {
               droppedInjections++;
               droppedTokenReductions.push({
                 tagNumber: tag.tagNumber,
@@ -30053,10 +30882,7 @@ function applyNativeToolInputReplayPi(args, saved) {
 function applyNativeReasoningReplayPi(args, saved) {
   if (!args.omissionAllowed)
     return 0;
-  let maxTag = 0;
-  for (const tag of args.messageIdToMaxTag.values())
-    maxTag = Math.max(maxTag, tag);
-  const cutoff = args.detectAged ? Math.max(args.localWatermark, maxTag - args.clearReasoningAge) : args.localWatermark;
+  const cutoff = args.detectAged ? Math.max(args.localWatermark, args.budgetCutoff) : args.localWatermark;
   const nextIds = new Set;
   const pending = new Map;
   for (let index = 0;index < args.messages.length; index++) {
@@ -30169,6 +30995,83 @@ function isSentinelPart(part) {
   return p.type === "text" && typeof p.text === "string" && (p.text === "" || p.text === WHOLE_MESSAGE_PLACEHOLDER_TEXT);
 }
 
+// src/pi-context-budget.ts
+var PI_CONTEXT_BUDGET = {
+  hostDeadlineMs: 30000,
+  hostMarginMs: 5000,
+  outcomeMs: 25000,
+  fallbackObservedMs: 4,
+  workMs: 21000,
+  writerMs: 16500,
+  completionReserveMs: 2000,
+  searchMs: 3000
+};
+
+class PiContextDeadlineError extends Error {
+}
+
+class PiContextBudget {
+  startedAt;
+  now;
+  sideTurn = false;
+  stage = "entry";
+  recovery = "not attempted";
+  abandoned = false;
+  completed = false;
+  failureReason;
+  assertOwner = () => {};
+  constructor(startedAt = performance.now(), now = () => performance.now()) {
+    this.startedAt = startedAt;
+    this.now = now;
+  }
+  elapsed() {
+    return this.now() - this.startedAt;
+  }
+  remainingWork() {
+    return Math.max(0, PI_CONTEXT_BUDGET.workMs - this.elapsed());
+  }
+  remainingOutcome = () => Math.max(0, PI_CONTEXT_BUDGET.outcomeMs - this.elapsed());
+  writerAllowance() {
+    return Math.max(0, Math.min(PI_CONTEXT_BUDGET.writerMs, this.remainingWork() - PI_CONTEXT_BUDGET.completionReserveMs));
+  }
+  assertOutcome = () => {
+    this.assertOwner();
+    if (this.abandoned || this.elapsed() >= PI_CONTEXT_BUDGET.outcomeMs)
+      throw new PiContextDeadlineError(this.diagnostic());
+  };
+  assert = () => {
+    this.assertOutcome();
+    if (this.elapsed() >= PI_CONTEXT_BUDGET.workMs)
+      throw new PiContextDeadlineError(this.diagnostic());
+  };
+  assertDecisionPublication = () => {
+    if (!this.completed)
+      this.assertOwner();
+    if (this.abandoned || this.elapsed() >= PI_CONTEXT_BUDGET.outcomeMs)
+      throw new PiContextDeadlineError(this.diagnostic());
+  };
+  diagnostic() {
+    return `stage=${this.stage} elapsed=${Math.round(this.elapsed())}ms recovery=${this.recovery}`;
+  }
+  waitUntil = async (pending, assert, remaining) => {
+    assert();
+    let timer;
+    try {
+      return await Promise.race([
+        pending,
+        new Promise((_, reject) => {
+          timer = setTimeout(() => reject(new PiContextDeadlineError(this.diagnostic())), remaining());
+        })
+      ]);
+    } finally {
+      clearTimeout(timer);
+      assert();
+    }
+  };
+  wait = (pending) => this.waitUntil(pending, this.assert, () => this.remainingWork());
+  waitMandatory = (pending) => this.waitUntil(pending, this.assertOutcome, this.remainingOutcome);
+}
+
 // src/pi-context-limit.ts
 var MIN_SANE_LIMIT = 16000;
 var MAX_SANE_LIMIT = 1e7;
@@ -30179,9 +31082,7 @@ function resolvePiWindowGeometry(args) {
   const rawWindow = isSaneLimit2(args.rawContextWindow) ? args.rawContextWindow : undefined;
   const observedWindow = args.rawContextWindowSource === "catalog" ? undefined : rawWindow;
   const catalogWindow = args.rawContextWindowSource === "catalog" && rawWindow !== undefined ? rawWindow : isSaneLimit2(args.model?.contextWindow) ? args.model.contextWindow : undefined;
-  const persistedUsable = isSaneLimit2(args.persistedInputTokens) && typeof args.persistedPercentage === "number" && Number.isFinite(args.persistedPercentage) && args.persistedPercentage > 0 ? args.persistedInputTokens / (args.persistedPercentage / 100) : undefined;
-  const persistedWindow = isSaneLimit2(args.persistedInputTokens) && typeof args.persistedPercentage === "number" && Number.isFinite(args.persistedPercentage) && args.persistedPercentage > 0 ? args.persistedInputTokens / (args.persistedPercentage / 100) : undefined;
-  const context = observedWindow ?? catalogWindow ?? persistedWindow;
+  const context = observedWindow ?? catalogWindow ?? args.provenInputTokens;
   if (!isSaneLimit2(context))
     return;
   const providerID = args.model?.provider ?? "unknown";
@@ -30200,20 +31101,16 @@ function resolvePiWindowGeometry(args) {
   if (!result)
     return result;
   let resolved = result;
-  if (outputReserveOverride === undefined && isSaneLimit2(persistedUsable)) {
-    const persistedDenominator = Math.round(persistedUsable);
-    if (persistedDenominator < resolved.usableSoft) {
-      resolved = {
-        ...resolved,
-        usableSoft: persistedDenominator,
-        derivation: {
-          ...resolved.derivation,
-          reserve: Math.max(0, resolved.derivation.window - persistedDenominator)
-        }
-      };
-    } else {
-      resolved = applyProvenInputFloor(resolved, persistedDenominator).geometry;
-    }
+  const persistedUsable = isSaneLimit2(args.persistedInputTokens) && typeof args.persistedPercentage === "number" && Number.isFinite(args.persistedPercentage) && args.persistedPercentage > 0 ? Math.round(args.persistedInputTokens / (args.persistedPercentage / 100)) : undefined;
+  if (outputReserveOverride === undefined && isSaneLimit2(persistedUsable) && persistedUsable < resolved.usableSoft) {
+    resolved = {
+      ...resolved,
+      usableSoft: persistedUsable,
+      derivation: {
+        ...resolved.derivation,
+        reserve: Math.max(0, resolved.derivation.window - persistedUsable)
+      }
+    };
   }
   if (!isSaneLimit2(args.detectedContextLimit) && isSaneLimit2(args.provenInputTokens)) {
     resolved = applyProvenInputFloor(resolved, args.provenInputTokens).geometry;
@@ -30226,32 +31123,183 @@ function resolvePiUsableContextLimit(args) {
 
 // src/pi-context-refusal.ts
 import { Text as Text2 } from "@earendil-works/pi-tui";
+
+// src/omp-request-kind.ts
+var SIDE_REMINDER = `<system-reminder>
+Ephemeral side-channel turn; reuses current conversation context.
+Tool catalog attached only to keep prompt cache warm; tools NOT available this turn.
+Do NOT emit tool calls; reply plain text only. Tool calls discarded without execution.
+</system-reminder>`;
+function textContainsReminder(value) {
+  if (typeof value === "string")
+    return value.trim() === SIDE_REMINDER;
+  if (!Array.isArray(value))
+    return false;
+  return value.some((block) => {
+    if (!block || typeof block !== "object")
+      return false;
+    const part = block;
+    return typeof part.text === "string" && part.text.trim() === SIDE_REMINDER;
+  });
+}
+function isOmpSideContext(event) {
+  const tail = event.messages.at(-1);
+  if (tail?.role !== "user" || tail.attribution !== "agent")
+    return false;
+  return event.messages.some((message) => {
+    const row = message;
+    return row.role === "developer" && row.attribution === "agent" && textContainsReminder(row.content);
+  });
+}
+
+// src/pi-context-refusal.ts
 var ENTRY_TYPE = "magic-context-turn-refused";
 var RETRY_MESSAGE = "Magic Context could not safely prepare this turn; send your message again.";
-function registerPiGuardedContext(pi, handler) {
+
+class PiContextSupersededError extends Error {
+}
+var receiptMaps = new Set;
+function clearPiContextReceipt(sessionId) {
+  for (const receipts of receiptMaps)
+    receipts.delete(sessionId);
+}
+function operationKey(ctx) {
+  return ctx.sessionManager?.getSessionId?.() ?? ctx.sessionManager ?? "no-session";
+}
+function registerPiGuardedContext(pi, handler, options = {}) {
+  const operations = new Map;
+  const sideSessions = new Map;
+  receiptMaps.add(operations);
+  const newOperation = () => ({
+    ready: false,
+    refused: false,
+    ended: false
+  });
+  const fenceEnabled = resolvePiHarnessKind() === "omp";
+  const refuse = (ctx, budget, reason, isCurrent) => {
+    if (!isCurrent()) {
+      log(`[magic-context][pi] DISCARDED CONTEXT RESULT ${budget.diagnostic()}`, reason);
+      return;
+    }
+    budget.abandoned = true;
+    budget.recovery = budget.recovery === "not attempted" ? "no managed result; refused" : budget.recovery;
+    const message = isCheckoutClaimRefusalError(reason) ? reason.message : `${RETRY_MESSAGE} ${budget.diagnostic()} (${reason instanceof Error ? reason.message : String(reason)})`;
+    try {
+      ctx.ui?.notify(message, "error");
+    } catch (error) {
+      log("[magic-context][pi] refusal notice failed", error);
+    }
+    try {
+      pi.appendEntry(ENTRY_TYPE, { message });
+    } catch (error) {
+      log("[magic-context][pi] refusal entry failed", error);
+    } finally {
+      if (!budget.sideTurn)
+        ctx.abort();
+    }
+    if (isCheckoutClaimRefusalError(reason))
+      return;
+    try {
+      options.onRefusal?.(ctx, budget, message, isCurrent);
+    } catch (error) {
+      log("[magic-context][pi] refusal diagnostic failed", error);
+    }
+  };
+  if (fenceEnabled) {
+    pi.on("agent_start", (_event, ctx) => {
+      operations.set(operationKey(ctx), newOperation());
+    });
+    pi.on("agent_end", (_event, ctx) => {
+      const key = operationKey(ctx);
+      const counts = sideSessions.get(key);
+      if (counts)
+        log(`[magic-context][pi] OMP context counts session=${String(key)} side_contexts=${counts.sides} context_passes=${counts.contexts} dispatch_fence=${counts.sides ? "latched off" : "on"}`);
+      const operation = operations.get(key);
+      if (operation) {
+        operation.ended = true;
+        operation.ready = false;
+      }
+    });
+    pi.on("before_provider_request", (_event, ctx) => {
+      if (options.compactionOff?.(ctx))
+        return;
+      const key = operationKey(ctx);
+      if (sideSessions.get(key)?.sides)
+        return;
+      let operation = operations.get(key);
+      if (!operation) {
+        operation = newOperation();
+        operations.set(key, operation);
+      }
+      const active = operation;
+      const isCurrent = () => operations.get(key) === active;
+      const budget = active.pass ?? new PiContextBudget;
+      try {
+        budget.assertOwner();
+        if (!budget.completed)
+          budget.assertOutcome();
+        if (!active.ready || active.refused || active.ended || budget.abandoned)
+          throw new Error("missing managed context receipt");
+      } catch (error) {
+        active.refused = true;
+        budget.stage = "provider dispatch";
+        refuse(ctx, budget, error, isCurrent);
+      }
+    });
+  }
   pi.registerEntryRenderer?.(ENTRY_TYPE, (entry) => new Text2(entry.data?.message ?? RETRY_MESSAGE, 0, 0));
   pi.on("context", async (event, ctx) => {
+    const budget = new PiContextBudget;
+    budget.sideTurn = fenceEnabled && isOmpSideContext(event);
+    const key = operationKey(ctx);
+    if (fenceEnabled) {
+      let counts = sideSessions.get(key);
+      if (!counts) {
+        counts = { contexts: 0, sides: 0 };
+        sideSessions.set(key, counts);
+      }
+      counts.contexts++;
+      if (budget.sideTurn && ++counts.sides === 1)
+        log(`[magic-context][pi] OMP dispatch fence disabled for session ${String(key)}: verified ephemeral context; session-wide abort cannot distinguish provider operations (side_contexts=${counts.sides} context_passes=${counts.contexts})`);
+    }
+    const owner = operations.get(key);
+    let operation = operations.get(key);
+    if (budget.sideTurn || !operation || !fenceEnabled) {
+      operation = newOperation();
+      if (!budget.sideTurn)
+        operations.set(key, operation);
+    }
+    const active = operation;
+    active.pass = budget;
+    active.ready = false;
+    const isOwned = () => budget.sideTurn ? operations.get(key) === owner : operations.get(key) === active && active.pass === budget;
+    const isCurrent = () => isOwned() && (budget.sideTurn || !active.ended);
+    budget.assertOwner = () => {
+      if (!isCurrent())
+        throw new PiContextSupersededError("Pi context pass superseded before writer admission");
+    };
     try {
-      return await withSqliteTransformPass(() => handler(event, ctx));
+      const result = await withSqliteTransformPass(() => handler(event, ctx, budget));
+      budget.assertOutcome();
+      if (result?.messages) {
+        budget.completed = true;
+        active.ready = true;
+      }
+      return result;
     } catch (error) {
-      log("[magic-context][pi] turn refused", error);
-      const message = isCheckoutClaimRefusalError(error) ? error.message : RETRY_MESSAGE;
-      if (typeof ctx.abort !== "function")
+      if (error instanceof PiContextSupersededError || !isCurrent()) {
+        log(`[magic-context][pi] DISCARDED CONTEXT RESULT ${budget.diagnostic()}`, error);
         throw error;
-      if (message !== RETRY_MESSAGE && ctx.hasUI) {
-        try {
-          ctx.ui.notify(message, "error");
-        } catch (notifyError) {
-          log("[magic-context][pi] refusal notice failed", notifyError);
-        }
       }
-      try {
-        pi.appendEntry(ENTRY_TYPE, { message });
-      } catch (displayError) {
-        log("[magic-context][pi] refusal entry failed", displayError);
-      } finally {
-        ctx.abort();
+      log("[magic-context][pi] turn refused", error);
+      if (typeof ctx.abort !== "function") {
+        budget.abandoned = true;
+        if (!isCheckoutClaimRefusalError(error))
+          options.onRefusal?.(ctx, budget, error instanceof Error ? error.message : String(error), isOwned);
+        throw error;
       }
+      active.refused = true;
+      refuse(ctx, budget, error, isOwned);
       return { messages: event.messages };
     }
   });
@@ -30786,7 +31834,7 @@ function plainOutputFields(messages) {
   }
   return outputs;
 }
-function snapshotInputs(messages, entryIds) {
+function snapshotInputs(messages, entryIds, omitsBookkeeping) {
   if (!entryIds || entryIds.length !== messages.length) {
     return { inputs: [], failure: "lkg_entry_ids_unavailable" };
   }
@@ -30797,7 +31845,7 @@ function snapshotInputs(messages, entryIds) {
   const inputs = [];
   const seen = new Set;
   for (let index = 0;index < entryIds.length; index += 1) {
-    const fields = lkgContentFields(messages[index]);
+    const fields = lkgContentFields(omitsBookkeeping ? piProviderInput(messages[index]) : messages[index]);
     if (!fields)
       return { inputs: [], failure: "lkg_content_snapshot_failed" };
     const id = entryIds[index] || `pi-lkg-unmapped:${lkgContentDigestFromFields(fields)}`;
@@ -30813,6 +31861,35 @@ function snapshotInputs(messages, entryIds) {
   }
   return { inputs, failure: null };
 }
+var bookkeepingOmittingApis = new Set([
+  "anthropic-messages",
+  "google-generative-ai",
+  "openai-completions",
+  "openai-responses",
+  "openai-codex-responses"
+]);
+function omitsRootBookkeeping(args) {
+  if (args.transport != null)
+    return false;
+  let api = args.apiKey;
+  if (api === undefined) {
+    const apis = new Set(args.messages.flatMap((message) => {
+      const value = message;
+      return value?.role === "assistant" && typeof value.api === "string" ? [value.api] : [];
+    }));
+    if (apis.size === 1)
+      api = [...apis][0];
+  }
+  return typeof api === "string" && bookkeepingOmittingApis.has(api);
+}
+function piProviderInput(message) {
+  if (!message || typeof message !== "object" || Array.isArray(message))
+    return message;
+  const descriptors = Object.getOwnPropertyDescriptors(message);
+  delete descriptors.completedAt;
+  delete descriptors.contextSnapshot;
+  return Object.create(Object.getPrototypeOf(message), descriptors);
+}
 function extendsMeasuredRequest(measuredJson, nextJson) {
   return measuredJson === nextJson || measuredJson.length > 2 && nextJson.startsWith(`${measuredJson.slice(0, -1)},`);
 }
@@ -30833,7 +31910,7 @@ function createPiLkgCoordinator(db, scheduleCapture = (capture) => setImmediate(
     return state;
   };
   const beginPass = (args) => {
-    const snapped = snapshotInputs(args.messages, args.entryIds);
+    const snapped = snapshotInputs(args.messages, args.entryIds, omitsRootBookkeeping(args));
     const slot = getSlot(args.sessionId);
     if (snapped.failure || !slot) {
       return {
@@ -30987,6 +32064,7 @@ function createPiLkgCoordinator(db, scheduleCapture = (capture) => setImmediate(
     return result.ok && measuredPrefix ? { ...result, measuredPrefix } : result;
   };
   const captureAppliedPass = (args) => {
+    args.assertCurrentPass?.();
     const { snapshot } = args;
     if (snapshot.preparationFailure || snapshot.inputs.length === 0)
       return;
@@ -31003,12 +32081,14 @@ function createPiLkgCoordinator(db, scheduleCapture = (capture) => setImmediate(
         ...plainOutput ? args.outputMessages.slice(prefix).map((message) => JSON.stringify(message) ?? "null") : []
       ];
       jsonPrefix = !plainOutput ? JSON.stringify(args.outputMessages) : priorOutput && prefix === outputs.length && prefix === priorOutput.inputs.length ? priorOutput.json : `[${jsonMessages.join(",")}]`;
+      args.assertCurrentPass?.();
       state.outputSnapshot = plainOutput ? {
         inputs: outputs,
         jsonMessages,
         json: jsonPrefix
       } : null;
     } catch (error) {
+      args.assertCurrentPass?.();
       dropSlot(snapshot.sessionId, "lkg_snapshot_serialize_failed");
       const failedState = stateFor(snapshot.sessionId);
       failedState.syncCaptureRequired = true;
@@ -31032,6 +32112,7 @@ function createPiLkgCoordinator(db, scheduleCapture = (capture) => setImmediate(
     const outputIds = args.outputEntryIds ?? inferredIds;
     const inputIds = new Set(snapshot.inputs.map((input) => input.id));
     const ownership = outputIds.length === args.outputMessages.length && outputIds.every((id) => id === null || typeof id === "string" && inputIds.has(id)) ? [...outputIds] : undefined;
+    args.assertCurrentPass?.();
     state.captureSequence += 1;
     const plan = {
       sessionId: snapshot.sessionId,
@@ -31047,6 +32128,7 @@ function createPiLkgCoordinator(db, scheduleCapture = (capture) => setImmediate(
     state.capturedRequest = args.hostEnvelopeSignature ? { ...plan, envelopeSignature: args.hostEnvelopeSignature } : undefined;
     const livePrior = getSlot(snapshot.sessionId);
     const unchanged = livePrior && livePrior.modelKey === plan.modelKey && livePrior.providerKey === plan.providerKey && livePrior.jsonPrefix === plan.jsonPrefix && livePrior.inputIdSeq.length === plan.inputs.length && exactReusablePrefix(plan.inputs, state.acceptedInputs) === plan.inputs.length && JSON.stringify(livePrior.piOutputEntryIds) === JSON.stringify(ownership);
+    args.assertCurrentPass?.();
     if (unchanged && !state.syncCaptureRequired) {
       const kept = {
         ...livePrior,
@@ -31062,6 +32144,12 @@ function createPiLkgCoordinator(db, scheduleCapture = (capture) => setImmediate(
       dropSlot(snapshot.sessionId, "lkg_cache_bust_pending_capture");
     }
     const commit = () => {
+      try {
+        args.assertCurrentPass?.();
+      } catch (error) {
+        sessionLog(plan.sessionId, "DISCARDED CONTEXT RESULT: queued LKG capture", error);
+        return;
+      }
       if (plan.captureSequence !== state.captureSequence)
         return;
       const startedAt = performance.now();
@@ -31090,6 +32178,7 @@ function createPiLkgCoordinator(db, scheduleCapture = (capture) => setImmediate(
         } : undefined);
         reusedPrefix = incremental.reusedPrefix;
         if (!state.syncCaptureRequired && prior && reusedPrefix === plan.inputs.length && prior.inputIdSeq.length === plan.inputs.length && prior.jsonPrefix === plan.jsonPrefix && JSON.stringify(prior.piOutputEntryIds) === JSON.stringify(ownership)) {
+          args.assertCurrentPass?.();
           state.acceptedInputs = plan.inputs;
           return;
         }
@@ -31105,6 +32194,7 @@ function createPiLkgCoordinator(db, scheduleCapture = (capture) => setImmediate(
           capturedAt: plan.capturedAt,
           captureSequence: plan.captureSequence
         };
+        args.assertCurrentPass?.();
         if (!captureSlot(plan.sessionId, slot)) {
           throw new Error("LKG slot rejected the Pi snapshot");
         }
@@ -31113,6 +32203,12 @@ function createPiLkgCoordinator(db, scheduleCapture = (capture) => setImmediate(
         const persisted = saveLkgSlotToDb(db, plan.sessionId, slot);
         state.syncCaptureRequired = !persisted;
       } catch (error) {
+        try {
+          args.assertCurrentPass?.();
+        } catch (discarded) {
+          sessionLog(plan.sessionId, "DISCARDED CONTEXT RESULT: LKG publication", discarded);
+          return;
+        }
         if (plan.captureSequence !== state.captureSequence)
           return;
         dropSlot(plan.sessionId, "lkg_async_capture_failed");
@@ -31209,7 +32305,7 @@ function resolvePiLkgOutputEntryIds(messages, syntheticLeadingCount, entryId) {
 
 // src/pi-lkg-fit-envelope.ts
 import { createHash as createHash13 } from "node:crypto";
-function readPiLkgFitEnvelope(ctx, pi, modelKey, frozen) {
+function readPiLkgFitEnvelope(ctx, pi, modelKey, frozen, wireSchema) {
   try {
     if (!modelKey || typeof pi.getAllTools !== "function")
       return;
@@ -31221,7 +32317,8 @@ function readPiLkgFitEnvelope(ctx, pi, modelKey, frozen) {
     for (const tool of allTools) {
       if (!tool || typeof tool !== "object")
         return;
-      const { name, description, parameters } = tool;
+      const { name, description } = tool;
+      const parameters = wireSchema ? wireSchema(tool) : tool.parameters;
       if (typeof name !== "string" || !name.length || typeof description !== "string" || !parameters || typeof parameters !== "object" || Array.isArray(parameters))
         return;
       tools.push({ name, description, parameters });
@@ -31278,6 +32375,27 @@ function readPiLkgFitEnvelope(ctx, pi, modelKey, frozen) {
 }
 
 // src/pi-pressure.ts
+var MAX_UNKNOWN_PI_INPUT_TOKENS = 3000000;
+function piPressureEvidenceLimit(geometry) {
+  return geometry && hasTrustedAbsoluteWall(geometry) ? geometry.derivation.absoluteWall : MAX_UNKNOWN_PI_INPUT_TOKENS;
+}
+var rejectedUsageLogged = new Set;
+var rejectedProviderUsage = new Set;
+function recordPiProviderUsageValidity(sessionId, rejected) {
+  if (rejected)
+    rejectedProviderUsage.add(sessionId);
+  else
+    rejectedProviderUsage.delete(sessionId);
+}
+function piProviderUsageWasRejected(sessionId) {
+  return rejectedProviderUsage.has(sessionId);
+}
+function noteRejectedPiUsage(sessionId, reading, limit, source) {
+  if (rejectedUsageLogged.has(sessionId))
+    return;
+  rejectedUsageLogged.add(sessionId);
+  sessionLog(sessionId, `provider_usage_not_single_request: ${source} input ${reading} exceeds pressure evidence bound ${limit}; ignoring possible turn-aggregate billing usage and using request estimates`);
+}
 function extractAssistantUsage(message) {
   if (!message || typeof message !== "object")
     return null;
@@ -31301,6 +32419,13 @@ function extractAssistantUsage(message) {
   return result;
 }
 function computePiPressure(usage, contextLimit, absoluteWall) {
+  const inputTokens = piUsageInputTokens(usage);
+  if (inputTokens === null || inputTokens > (absoluteWall ?? MAX_UNKNOWN_PI_INPUT_TOKENS))
+    return null;
+  const percentage = contextLimit > 0 ? inputTokens / contextLimit * 100 : 0;
+  return { inputTokens, percentage };
+}
+function piUsageInputTokens(usage) {
   if (!usage)
     return null;
   const input = usage.input ?? 0;
@@ -31308,14 +32433,10 @@ function computePiPressure(usage, contextLimit, absoluteWall) {
   const cacheWrite = usage.cacheWrite ?? 0;
   const componentPromptTokens = input + cacheRead + cacheWrite;
   const totalPromptTokens = typeof usage.totalTokens === "number" && Number.isFinite(usage.totalTokens) && typeof usage.output === "number" && Number.isFinite(usage.output) ? Math.max(0, usage.totalTokens - usage.output) : undefined;
-  let inputTokens = totalPromptTokens !== undefined && totalPromptTokens > 0 ? Math.min(componentPromptTokens, totalPromptTokens) : componentPromptTokens;
+  const inputTokens = totalPromptTokens !== undefined && totalPromptTokens > 0 ? Math.min(componentPromptTokens, totalPromptTokens) : componentPromptTokens;
   if (inputTokens <= 0 || !Number.isFinite(inputTokens))
     return null;
-  if (typeof absoluteWall === "number" && Number.isFinite(absoluteWall) && absoluteWall > 0 && inputTokens > absoluteWall) {
-    inputTokens = absoluteWall;
-  }
-  const percentage = contextLimit > 0 ? inputTokens / contextLimit * 100 : 0;
-  return { inputTokens, percentage };
+  return inputTokens;
 }
 function resolvePiPressureSnapshot(args) {
   const persistedInputTokens = Number.isFinite(args.persistedInputTokens) && args.persistedInputTokens > 0 ? args.persistedInputTokens : 0;
@@ -31381,11 +32502,31 @@ function isPiContextUsageRawBranchEstimate(sessionManager) {
 function resolveGuardedPiPressureSnapshot(args) {
   const live = typeof args.liveInputTokens === "number" && Number.isFinite(args.liveInputTokens) ? args.liveInputTokens : 0;
   const setAside = args.liveIsRawBranchEstimate === true && live > 0;
-  const snapshot = resolvePiPressureSnapshot(setAside ? {
+  const bound = args.providerInputLimit ?? MAX_UNKNOWN_PI_INPUT_TOKENS;
+  const rejectedPersisted = args.persistedInputTokens > bound;
+  const rejectedLive = live > bound;
+  const sanitized = {
     ...args,
+    persistedInputTokens: rejectedPersisted ? 0 : args.persistedInputTokens,
+    persistedPercentage: rejectedPersisted ? 0 : args.persistedPercentage,
+    liveInputTokens: rejectedLive ? undefined : args.liveInputTokens
+  };
+  const snapshot = resolvePiPressureSnapshot(setAside ? {
+    ...sanitized,
     liveInputTokens: undefined,
     ...args.persistedFromLive ? { persistedInputTokens: 0, persistedPercentage: 0 } : {}
-  } : args);
+  } : sanitized);
+  if (args.fallbackInputTokens !== undefined) {
+    return {
+      snapshot: resolvePiPressureSnapshot({
+        ...args,
+        persistedInputTokens: snapshot.inputTokens,
+        persistedPercentage: snapshot.percentage,
+        liveInputTokens: args.fallbackInputTokens
+      }),
+      setAsideEstimate: setAside ? live : undefined
+    };
+  }
   return { snapshot, setAsideEstimate: setAside ? live : undefined };
 }
 var lastLiveUsageClassification = new Map;
@@ -31394,6 +32535,8 @@ function recordPiLiveUsageClassification(sessionId, isRawBranchEstimate) {
 }
 function clearPiLiveUsageClassification(sessionId) {
   lastLiveUsageClassification.delete(sessionId);
+  rejectedUsageLogged.delete(sessionId);
+  rejectedProviderUsage.delete(sessionId);
 }
 function resolvePiStatusPressureSnapshot(args) {
   const { sessionId, ...pressureArgs } = args;
@@ -31410,6 +32553,10 @@ function noteRawBranchEstimateSetAside(sessionId, reading, source) {
 }
 function resolvePiPressureSnapshotWithEstimateGuard(args) {
   const { snapshot, setAsideEstimate } = resolveGuardedPiPressureSnapshot(args);
+  const bound = args.providerInputLimit ?? MAX_UNKNOWN_PI_INPUT_TOKENS;
+  const rejected = Math.max(args.persistedInputTokens, args.liveInputTokens ?? 0);
+  if (rejected > bound)
+    noteRejectedPiUsage(args.sessionId, rejected, bound, args.source);
   if (setAsideEstimate !== undefined) {
     noteRawBranchEstimateSetAside(args.sessionId, setAsideEstimate, args.source);
   } else if (snapshot.inputTokens > 0) {
@@ -31424,6 +32571,38 @@ function formatPiPressureForLog(snapshot) {
 // src/pi-proven-floor.ts
 var FLOOR_STATE_KEY = "piProvenInputFloor";
 var mismatchLogged = new Set;
+function largestAcceptedInput(entries, modelKey, providerInputLimit) {
+  let largest = 0;
+  for (const entry of entries) {
+    if (!entry || typeof entry !== "object")
+      continue;
+    const row = entry;
+    if (row.type !== "message" || !row.message || typeof row.message !== "object")
+      continue;
+    const message = row.message;
+    if (piProvenFloorModelKey({
+      provider: message.provider,
+      id: message.model
+    }) !== modelKey || providerResponseFailed({
+      finish: message.stopReason,
+      error: message.errorMessage
+    }))
+      continue;
+    const pressure = computePiPressure(extractAssistantUsage(message), 0, providerInputLimit);
+    if (pressure)
+      largest = Math.max(largest, pressure.inputTokens);
+  }
+  return largest;
+}
+function hasMeasuredBasis(raw) {
+  if (typeof raw !== "string")
+    return false;
+  try {
+    return JSON.parse(raw)?.[FLOOR_STATE_KEY]?.basis === "provider_usage_v1";
+  } catch {
+    return false;
+  }
+}
 function piProvenFloorModelKey(model) {
   if (!model)
     return;
@@ -31468,7 +32647,7 @@ function recordPiProvenFloorModel(db, sessionId, modelKey, tokens) {
 		                AND json_type(deferred_execute_state) = 'object'
 		               THEN deferred_execute_state ELSE '{}' END,
 		          '$.${FLOOR_STATE_KEY}', json(?))
-		  WHERE session_id = ?`).run(JSON.stringify({ modelKey, tokens }), sessionId);
+		  WHERE session_id = ?`).run(JSON.stringify({ modelKey, tokens, basis: "provider_usage_v1" }), sessionId);
 }
 function resolvePiProvenInputFloor(args) {
   const row = readFloorRow(args.db, args.sessionId);
@@ -31492,6 +32671,21 @@ function resolvePiProvenInputFloor(args) {
     }
     return 0;
   }
+  const providerInputLimit = args.providerInputLimit ?? MAX_UNKNOWN_PI_INPUT_TOKENS;
+  if (!hasMeasuredBasis(row.state) || observed > providerInputLimit) {
+    let measured = 0;
+    try {
+      measured = largestAcceptedInput(args.readBranch?.() ?? [], record.modelKey, providerInputLimit);
+    } catch {}
+    updateSessionMeta(args.db, args.sessionId, {
+      observedSafeInputTokens: measured,
+      cacheAlertSent: false,
+      lastUsageContextLimit: 0
+    });
+    recordPiProvenFloorModel(args.db, args.sessionId, record.modelKey, measured);
+    sessionLog(args.sessionId, `legacy proven input floor ${observed} re-derived from accepted provider usage: ${measured}`);
+    return measured;
+  }
   return observed;
 }
 
@@ -32067,6 +33261,29 @@ function injectSyntheticTodowriteForPi(args) {
   return args.messages;
 }
 
+// src/pi-tool-wire-schema.ts
+import { isAbsolute as isAbsolute2 } from "node:path";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+var resolver;
+function loadPiToolWireSchema() {
+  if (resolver)
+    return resolver;
+  resolver = (async () => {
+    const specifier = "@oh-my-pi/pi-ai/utils/schema/wire";
+    for (const base of [process.argv[1], import.meta.url]) {
+      if (!base || !base.startsWith("file:") && !isAbsolute2(base))
+        continue;
+      try {
+        const path = import.meta.resolve(specifier, base.startsWith("file:") ? base : pathToFileURL2(base).href);
+        const host = await import(path);
+        if (typeof host.toolWireSchema === "function")
+          return host.toolWireSchema;
+      } catch {}
+    }
+  })();
+  return resolver;
+}
+
 // src/provider-error-recovery-pi.ts
 function reportBindingRecovery(sessionId, report, message) {
   if (report)
@@ -32084,10 +33301,16 @@ function handlePiProviderFailure(args) {
   const provider = typeof message.provider === "string" ? message.provider : undefined;
   const model = typeof message.model === "string" ? message.model : undefined;
   const binding = detectThinkingBindingMismatch(message.errorMessage);
+  if (detectLatestTurnThinkingMismatch(message.errorMessage) && !args.compactionOff && isAnthropicFamilyRoute(provider, model)) {
+    armLatestThinkingRecovery(args.db, args.sessionId);
+    clearPiLkgSessionState(args.sessionId);
+    dropSlot(args.sessionId, "latest-thinking-recovery-arm");
+    return { kind: "thinking_binding", armed: true };
+  }
   if (binding.isBindingMismatch) {
     const enabled = args.thinkingBindingRecoveryEnabled !== false && !args.compactionOff && isPrefixBoundThinkingModel(provider, model);
     if (enabled) {
-      armThinkingBindingRecovery(args.db, args.sessionId);
+      armBindingRecoverySafely(args.db, args.sessionId);
       clearPiLkgSessionState(args.sessionId);
       dropSlot(args.sessionId, "thinking-binding-recovery-arm");
       reportBindingRecovery(args.sessionId, args.report, `thinking-binding recovery armed from message_end (provider paths: failing=${binding.failingBlockPath ?? "?"} firstChanged=${binding.firstChangedPath ?? "?"})`);
@@ -32137,12 +33360,16 @@ function stripThinkingParts(message) {
   return before - strippedContent.length;
 }
 function applyPiThinkingBindingRecovery(args) {
+  const protectedMessages = latestAssistantTurnMessages(args.messages);
   const frozenEntryIds = frozenBindingEntryIds(args.db, args.sessionId);
-  const flagTarget = isPrefixBoundThinkingModel(args.provider, args.model) ? getThinkingBindingRecoveryTarget(args.db, args.sessionId) : null;
+  const flagTargetCandidate = isPrefixBoundThinkingModel(args.provider, args.model) ? getThinkingBindingRecoveryTarget(args.db, args.sessionId) : null;
+  const flagTarget = flagTargetCandidate?.startsWith(LATEST_THINKING_RESTORE) ? null : flagTargetCandidate;
   let applied = null;
   if (flagTarget) {
     const entryIds = new Set;
     for (let index = 0;index < args.messages.length; index += 1) {
+      if (protectedMessages.has(args.messages[index]))
+        continue;
       const entryId = args.entryIds[index];
       if (entryId && hasThinkingPart(args.messages[index]))
         entryIds.add(entryId);
@@ -32158,7 +33385,15 @@ function applyPiThinkingBindingRecovery(args) {
       reportBindingRecovery(args.sessionId, args.report, `thinking-binding recovery consumed on context pass target=${flagTarget} entries=${applied.entryIds.length} [${applied.entryIds.join(",")}]`);
     }
   }
+  const restoringActiveTurn = latestThinkingRecoveryCoversActiveTurn({
+    db: args.db,
+    sessionId: args.sessionId,
+    messages: args.messages,
+    id: (message, index) => resolvePiStableId(message, index, args.entryIds)
+  });
   for (let index = 0;index < args.messages.length; index += 1) {
+    if (restoringActiveTurn && protectedMessages.has(args.messages[index]))
+      continue;
     const entryId = args.entryIds[index];
     if (entryId && frozenEntryIds.has(entryId))
       stripThinkingParts(args.messages[index]);
@@ -32170,9 +33405,12 @@ function applyPiProactiveThinkingStrip(args) {
     return null;
   if (!isPrefixBoundThinkingModel(args.provider, args.model))
     return null;
+  const protectedMessages = latestAssistantTurnMessages(args.messages);
   const entryIds = [];
   const indices = [];
   for (let index = 0;index < args.messages.length; index += 1) {
+    if (protectedMessages.has(args.messages[index]))
+      continue;
     const entryId = args.entryIds[index];
     if (!entryId || !hasThinkingPart(args.messages[index]))
       continue;
@@ -32264,27 +33502,65 @@ function buildMessageIdToMaxTag(targets) {
   }
   return out;
 }
+function piReasoningStatusMessages(messages) {
+  return messages.filter(isRecord).map((message) => {
+    const usage = isRecord(message.usage) ? message.usage : {};
+    const parts = Array.isArray(message.content) ? message.content.filter(isRecord).map((part) => part.type === "thinking" ? {
+      ...part,
+      type: part.redacted === true ? "redacted_thinking" : "thinking"
+    } : part) : [];
+    const payload = isRecord(message.providerPayload) ? message.providerPayload : undefined;
+    if (payload && Array.isArray(payload.items) && payload.items.some((item) => isRecord(item) && item.type === "reasoning"))
+      parts.push({ type: "reasoning", text: "", metadata: {} });
+    return {
+      info: { role: message.role, tokens: { reasoning: usage.reasoning } },
+      parts
+    };
+  });
+}
 function piReasoningClearCutoff(args) {
   if (args.prefixBound)
     return piPrefixBoundReasoningCutoff(args);
-  let maxTag = 0;
-  for (const t of args.messageIdToMaxTag.values())
-    if (t > maxTag)
-      maxTag = t;
-  let cutoff = maxTag - args.clearReasoningAge;
-  if (maxTag === 0 || cutoff <= 0)
-    return 0;
-  for (let i = args.messages.length - 1;i >= 0; i--) {
-    const raw = args.messages[i];
-    if (!raw || typeof raw !== "object" || raw.role !== "assistant")
-      continue;
-    const id = args.piMessageStableId(raw, i);
-    const newestTag = id ? args.messageIdToMaxTag.get(id) ?? 0 : 0;
-    if (newestTag > 0)
-      cutoff = Math.min(cutoff, newestTag - 1);
-    break;
-  }
-  return Math.max(0, cutoff);
+  return piBudgetCutoff(args);
+}
+function piBudgetCutoff(args) {
+  const assistants = args.messages.map((message, index) => ({ message, index })).filter((entry) => isAssistantWithContent(entry.message));
+  const newest = assistants.at(-1);
+  const exempt = [...assistants].reverse().find((entry) => entry.message.content.some((part) => part.type !== "text" || part.text.trim() !== ""));
+  return reasoningBudgetCutoff(assistants.map((entry) => {
+    const id = args.piMessageStableId(entry.message, entry.index);
+    return {
+      tag: id ? args.messageIdToMaxTag.get(id) ?? 0 : 0,
+      exempt: entry === newest || entry === exempt || isInActiveAnthropicTurn(args.messages, entry.index, args.anthropic === true || args.prefixBound === true || hasAnthropicReasoning(args.messages)),
+      alreadyRemoved: id !== undefined && args.alreadyGone?.(id) === true && !hasInlineThinkingMarkup(entry.message),
+      cost: () => {
+        let text = "";
+        let inlineText = "";
+        let opaque = false;
+        const typedGone = id !== undefined && args.alreadyGone?.(id) === true;
+        const hasTypedReasoning = !typedGone && thinkingParts(entry.message).length > 0;
+        for (const part of typedGone ? [] : thinkingParts(entry.message).filter(isLiveThinking)) {
+          if (part.redacted)
+            opaque = true;
+          else
+            text += part.thinking;
+          opaque ||= !!part.thinkingSignature && !part.thinking;
+        }
+        for (const part of entry.message.content) {
+          if (part.type !== "text")
+            continue;
+          for (const match of part.text.matchAll(/<(?:think|thinking)>([\s\S]*?)<\/(?:think|thinking)>/gi))
+            inlineText += match[1];
+        }
+        opaque ||= !typedGone && entry.message.providerPayload?.items?.some((item) => isRecord(item) && item.type === "reasoning") === true;
+        if (!hasTypedReasoning && !text && !opaque && !inlineText)
+          return 0;
+        const reported = entry.message.usage?.reasoning;
+        const typed = hasTypedReasoning || text || opaque ? reported !== undefined && reported > 0 ? reported : reasoningStepCost(reported, estimateTokens(text) * (args.proseRatio ?? 1), opaque) : 0;
+        return typed + Math.ceil(estimateTokens(inlineText) * (args.proseRatio ?? 1));
+      }
+    };
+  }), args.keepReasoningTokens);
 }
 function isAssistantWithContent(raw) {
   return !!raw && typeof raw === "object" && raw.role === "assistant" && Array.isArray(raw.content);
@@ -32299,13 +33575,10 @@ function hasInlineThinkingMarkup(msg) {
   return msg.content.some((part) => !!part && typeof part === "object" && part.type === "text" && typeof part.text === "string" && stripInlineThinkingMarkup(part.text) !== part.text);
 }
 function piPrefixBoundReasoningCutoff(args) {
-  let maxTag = 0;
-  for (const t of args.messageIdToMaxTag.values())
-    if (t > maxTag)
-      maxTag = t;
-  const ageCutoff = maxTag - args.clearReasoningAge;
-  if (maxTag === 0 || ageCutoff <= 0)
+  const ageCutoff = piBudgetCutoff({ ...args, prefixBound: true });
+  if (ageCutoff <= 0)
     return 0;
+  const protectedMessages = args.protectLatestTurn ? latestAssistantTurnMessages(args.messages) : new Set;
   let newestIndex = -1;
   for (let i = args.messages.length - 1;i >= 0; i--) {
     if (isAssistantWithContent(args.messages[i])) {
@@ -32330,7 +33603,7 @@ function piPrefixBoundReasoningCutoff(args) {
     if (id && !inline && args.alreadyGone?.(id))
       continue;
     const tag = tagAt(i);
-    const removable = i !== newestIndex && id !== undefined && tag > 0 && tag <= ageCutoff && !inline && !live.some((part) => part.redacted === true);
+    const removable = !protectedMessages.has(raw) && i !== newestIndex && id !== undefined && tag > 0 && tag <= ageCutoff && !inline && !live.some((part) => part.redacted === true);
     walk.push({ index: i, tag, removable });
   }
   let stop = walk.findIndex((entry) => !entry.removable);
@@ -32358,20 +33631,17 @@ function piPrefixBoundReasoningCutoff(args) {
   }
 }
 function clearOldReasoningPi(args) {
-  const { messages, messageIdToMaxTag, clearReasoningAge, piMessageStableId } = args;
-  let maxTag = 0;
-  for (const t of messageIdToMaxTag.values())
-    if (t > maxTag)
-      maxTag = t;
-  if (maxTag === 0)
-    return { cleared: 0, newWatermark: 0 };
-  const ageCutoff = Math.min(maxTag - clearReasoningAge, args.maxCutoff ?? Number.POSITIVE_INFINITY);
-  if (ageCutoff <= 0)
+  const { messages, messageIdToMaxTag, piMessageStableId } = args;
+  const ageCutoff = args.maxCutoff;
+  if (!Number.isFinite(ageCutoff) || ageCutoff <= 0)
     return { cleared: 0, newWatermark: 0 };
   let cleared = 0;
   let newWatermark = 0;
+  const protectedMessages = args.protectLatestTurn ? latestAssistantTurnMessages(messages) : new Set;
   for (let i = 0;i < messages.length; i++) {
     const raw = messages[i];
+    if (protectedMessages.has(raw))
+      continue;
     if (!raw || typeof raw !== "object")
       continue;
     const msg = raw;
@@ -32404,20 +33674,17 @@ function clearOldReasoningPi(args) {
   return { cleared, newWatermark };
 }
 function stripInlineThinkingPi(args) {
-  const { messages, messageIdToMaxTag, clearReasoningAge, piMessageStableId } = args;
-  let maxTag = 0;
-  for (const t of messageIdToMaxTag.values())
-    if (t > maxTag)
-      maxTag = t;
-  if (maxTag === 0)
-    return { stripped: 0, newWatermark: 0 };
-  const ageCutoff = Math.min(maxTag - clearReasoningAge, args.maxCutoff ?? Number.POSITIVE_INFINITY);
-  if (ageCutoff <= 0)
+  const { messages, messageIdToMaxTag, piMessageStableId } = args;
+  const ageCutoff = args.maxCutoff;
+  if (!Number.isFinite(ageCutoff) || ageCutoff <= 0)
     return { stripped: 0, newWatermark: 0 };
   let stripped = 0;
   let newWatermark = 0;
+  const protectedMessages = args.protectLatestTurn ? latestAssistantTurnMessages(messages) : new Set;
   for (let i = 0;i < messages.length; i++) {
     const raw = messages[i];
+    if (protectedMessages.has(raw))
+      continue;
     if (!raw || typeof raw !== "object")
       continue;
     const msg = raw;
@@ -32455,8 +33722,11 @@ function replayClearedReasoningPi(args) {
   if (watermark <= 0)
     return 0;
   let cleared = 0;
+  const protectedMessages = args.protectLatestTurn ? latestAssistantTurnMessages(messages) : new Set;
   for (let i = 0;i < messages.length; i++) {
     const raw = messages[i];
+    if (protectedMessages.has(raw))
+      continue;
     if (!raw || typeof raw !== "object")
       continue;
     const msg = raw;
@@ -32490,8 +33760,11 @@ function replayStrippedInlineThinkingPi(args) {
   if (watermark <= 0)
     return 0;
   let stripped = 0;
+  const protectedMessages = args.protectLatestTurn ? latestAssistantTurnMessages(messages) : new Set;
   for (let i = 0;i < messages.length; i++) {
     const raw = messages[i];
+    if (protectedMessages.has(raw))
+      continue;
     if (!raw || typeof raw !== "object")
       continue;
     const msg = raw;
@@ -32697,13 +33970,25 @@ function replayPiReminderStrips(args) {
 
 // src/served-array-ledger.ts
 import { createHash as createHash14 } from "node:crypto";
+import { readFileSync as readFileSync8 } from "node:fs";
 import * as path7 from "node:path";
 var PI_SERVED_ARRAY_TAIL_MESSAGES = 40;
 var PI_SERVED_ARRAY_BODY_CAPTURE_ENV = "MAGIC_CONTEXT_PI_SERVED_BODY_CAPTURE";
 var LEDGER_DIRECTORY = "pi-served-array-digests";
 var BODY_DIRECTORY = "pi-served-array-bodies";
+var IDENTITY_DIRECTORY = "pi-served-tag-numbers";
 var FLUSH_DELAY_MS = 25;
+
+class PiServedIdentityError extends Error {
+  constructor(cause) {
+    super("Pi served-number identity could not be persisted or restored", {
+      cause
+    });
+    this.name = "PiServedIdentityError";
+  }
+}
 var previousBySession = new Map;
+var servedTagNumbersBySession = new Map;
 var sequenceBySession = new Map;
 var pendingLinesByPath = new Map;
 var flushTimer = null;
@@ -32711,8 +33996,37 @@ var swallowedWriteCount = 0;
 var lastWriteError = null;
 function clearPiServedArraySession(sessionId) {
   previousBySession.delete(sessionId);
+  servedTagNumbersBySession.delete(sessionId);
   sequenceBySession.delete(sessionId);
 }
+function getPiServedTagNumbers(sessionId, storageDir = getMagicContextStorageDir()) {
+  const filePath = getPiServedTagNumbersPath(sessionId, storageDir);
+  const cached = servedTagNumbersBySession.get(sessionId);
+  if (cached?.path === filePath)
+    return cached.numbers;
+  let text;
+  try {
+    text = readFileSync8(filePath, "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+    text = "";
+  }
+  const numbers = new Set;
+  for (const line of text.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    const row = JSON.parse(line);
+    if (row.version !== 1 || row.session_id !== sessionId || !Array.isArray(row.tag_numbers) || !row.tag_numbers.every((number) => Number.isSafeInteger(number) && number > 0)) {
+      throw new Error("Invalid durable Pi served-number record; refusing identity adoption");
+    }
+    for (const number of row.tag_numbers)
+      numbers.add(number);
+  }
+  servedTagNumbersBySession.set(sessionId, { path: filePath, numbers });
+  return numbers;
+}
 function sha256(value) {
   return createHash14("sha256").update(value).digest("hex");
 }
@@ -32726,6 +34040,9 @@ function getPiServedArrayLedgerPath(sessionId, storageDir = getMagicContextStora
 function getPiServedArrayBodyPath(sessionId, storageDir = getMagicContextStorageDir()) {
   return path7.join(storageDir, BODY_DIRECTORY, `${safeSessionFileStem(sessionId)}.jsonl`);
 }
+function getPiServedTagNumbersPath(sessionId, storageDir = getMagicContextStorageDir()) {
+  return path7.join(storageDir, IDENTITY_DIRECTORY, `${safeSessionFileStem(sessionId)}.jsonl`);
+}
 function fullBodyCaptureEnabled() {
   const value = process.env[PI_SERVED_ARRAY_BODY_CAPTURE_ENV]?.trim().toLowerCase();
   return value === "1" || value === "true" || value === "yes" || value === "on";
@@ -32791,8 +34108,19 @@ function flushPiServedArrayLedger() {
     return;
   const pending = [...pendingLinesByPath.entries()];
   pendingLinesByPath.clear();
-  for (const [filePath, lines] of pending)
-    appendPendingLines(filePath, lines);
+  for (const [filePath, lines] of pending) {
+    const admitted = lines.filter((item) => {
+      try {
+        item.assertCurrentPass?.();
+        return true;
+      } catch (error) {
+        log("[magic-context][pi] DISCARDED CONTEXT RESULT: queued served capture", error);
+        return false;
+      }
+    }).map((item) => item.line);
+    if (admitted.length)
+      appendPendingLines(filePath, admitted);
+  }
 }
 function scheduleFlush() {
   if (flushTimer)
@@ -32800,19 +34128,30 @@ function scheduleFlush() {
   flushTimer = setTimeout(flushPiServedArrayLedger, FLUSH_DELAY_MS);
   flushTimer.unref?.();
 }
-function enqueue(filePath, line) {
+function enqueue(filePath, line, assertCurrentPass) {
   const pending = pendingLinesByPath.get(filePath);
   if (pending)
-    pending.push(line);
+    pending.push({ line, assertCurrentPass });
   else
-    pendingLinesByPath.set(filePath, [line]);
+    pendingLinesByPath.set(filePath, [{ line, assertCurrentPass }]);
   scheduleFlush();
 }
 function capturePiServedArray(sessionId, messages, options = {}) {
+  options.assertCurrentPass?.();
+  let identityPersistenceFailed = false;
   try {
     const serializedMessages = options.serializedOutput?.jsonMessages ?? messages.map(serializeMessage);
     const serializedArray = options.serializedOutput?.json ?? `[${serializedMessages.join(",")}]`;
     const digest = sha256(serializedArray);
+    const storageDir = options.storageDir ?? getMagicContextStorageDir();
+    identityPersistenceFailed = true;
+    const previousNumbers = getPiServedTagNumbers(sessionId, storageDir);
+    identityPersistenceFailed = false;
+    const served = new Set(previousNumbers);
+    for (const number of options.servedTagNumbers ?? []) {
+      if (Number.isSafeInteger(number) && number > 0)
+        served.add(number);
+    }
     const previous = previousBySession.get(sessionId);
     const divergence = previous ? firstDivergence(previous.serializedMessages, serializedMessages) : null;
     const sequence = (sequenceBySession.get(sessionId) ?? 0) + 1;
@@ -32829,9 +34168,27 @@ function capturePiServedArray(sessionId, messages, options = {}) {
       block_vector_start: tailStart,
       block_vectors: messages.slice(tailStart).map(blockVector)
     };
-    const storageDir = options.storageDir ?? getMagicContextStorageDir();
+    options.assertCurrentPass?.();
+    const newNumbers = [...served].filter((number) => !previousNumbers.has(number));
+    const identityPath = getPiServedTagNumbersPath(sessionId, storageDir);
+    if (newNumbers.length) {
+      identityPersistenceFailed = true;
+      ensureStorageDirectorySync(path7.dirname(identityPath));
+      options.assertCurrentPass?.();
+      writeStorageFileSync(identityPath, `${JSON.stringify({ version: 1, session_id: sessionId, tag_numbers: newNumbers })}
+`, {
+        encoding: "utf8",
+        flag: "a"
+      });
+      identityPersistenceFailed = false;
+    }
+    options.assertCurrentPass?.();
+    servedTagNumbersBySession.set(sessionId, {
+      path: identityPath,
+      numbers: served
+    });
     enqueue(getPiServedArrayLedgerPath(sessionId, storageDir), `${JSON.stringify(record)}
-`);
+`, options.assertCurrentPass);
     if (options.fullBodyCapture ?? fullBodyCaptureEnabled()) {
       const bodyHeader = JSON.stringify({
         version: 1,
@@ -32841,12 +34198,15 @@ function capturePiServedArray(sessionId, messages, options = {}) {
         sha256: digest
       });
       enqueue(getPiServedArrayBodyPath(sessionId, storageDir), `${bodyHeader.slice(0, -1)},"messages":${serializedArray}}
-`);
+`, options.assertCurrentPass);
     }
     previousBySession.set(sessionId, { digest, serializedMessages });
     sequenceBySession.set(sessionId, sequence);
     return record;
   } catch (error) {
+    options.assertCurrentPass?.();
+    if (identityPersistenceFailed)
+      throw new PiServedIdentityError(error);
     recordWriteFailure(error);
     return;
   }
@@ -33115,19 +34475,6 @@ function clearPiSystemPromptSession(sessionId) {
   stickyDateBySession.delete(sessionId);
 }
 
-// src/timeout.ts
-function withTimeout(p, ms) {
-  let handle;
-  const timeout = new Promise((resolve) => {
-    handle = setTimeout(() => resolve(undefined), ms);
-    handle.unref?.();
-  });
-  return Promise.race([p, timeout]).finally(() => {
-    if (handle)
-      clearTimeout(handle);
-  });
-}
-
 // src/transcript-pi.ts
 function createPiTranscript(source, sessionId, entryIds, options = {}) {
   const working = source.slice();
@@ -33711,11 +35058,11 @@ var pendingDecisionLogObserverForTests;
 var mutationGateObserverForTests;
 var lkgRecoveryLogObserverForTests;
 var variantChangeLogObserverForTests;
+var beforePipelineForTests;
 function logPiLkgRecovery(sessionId, message) {
   lkgRecoveryLogObserverForTests?.(message);
   sessionLog(sessionId, message);
 }
-var DEFAULT_CLEAR_REASONING_AGE = 50;
 var PI_STABLE_ID_SCHEME = 1;
 var lastEmergencyNotificationAtMs = new Map;
 var EMERGENCY_NOTIFICATION_COOLDOWN_MS = 60000;
@@ -33728,11 +35075,22 @@ var deferredMaterializationSessions = new Set;
 var sessionsByProject = new Map;
 var lastSeenProjectIdentityBySession = new Map;
 var persistedProjectIdentityBySession = new Map;
+var sessionProjectBindingFailureLogAtBySession = new Map;
+var SESSION_PROJECT_BINDING_FAILURE_LOG_INTERVAL_MS = 10 * 60 * 1000;
 var rawMessageProviderUnregistersBySession = new Map;
 var activeContextHandlerSessions = new Set;
 var lastHeuristicsTurnIdBySession = new Map;
 var routinePressureAppliedBySession = new Map;
 var firstContextPassSeenBySession = new Set;
+var contextPassGeneration = new Map;
+
+class PiLkgAdmissionReplay extends Error {
+  messages;
+  constructor(messages) {
+    super("Saved request served before writer wait");
+    this.messages = messages;
+  }
+}
 var liveModelBySession = new Map;
 var latestAssistantModelTimestampBySession = new Map;
 var taggedStableMessageIdsBySession = new Map;
@@ -33938,7 +35296,7 @@ function trackSessionForProject(projectIdentity, sessionId) {
 function isContextHandlerSessionActive(sessionId) {
   return activeContextHandlerSessions.has(sessionId);
 }
-function updateSessionProjectTracking(sessionId, projectIdentity, db) {
+function updateSessionProjectTracking(sessionId, projectIdentity, db, observedCwd) {
   if (!projectIdentity)
     return;
   const prev = lastSeenProjectIdentityBySession.get(sessionId);
@@ -33951,9 +35309,22 @@ function updateSessionProjectTracking(sessionId, projectIdentity, db) {
   }
   if (db && persistedProjectIdentityBySession.get(sessionId) !== projectIdentity) {
     try {
-      recordSessionProjectIdentity(db, sessionId, projectIdentity);
+      const change = recordSessionProjectIdentity(db, sessionId, projectIdentity);
       persistedProjectIdentityBySession.set(sessionId, projectIdentity);
-    } catch {}
+      if (change) {
+        sessionLog(sessionId, `project binding changed harness=${getHarness()} cwd=${observedCwd ?? "unknown"} old=${change.previousProjectPath ?? "none"} new=${change.projectPath}`);
+      }
+    } catch (error) {
+      const now = Date.now();
+      const lastLoggedAt = sessionProjectBindingFailureLogAtBySession.get(sessionId);
+      if (lastLoggedAt === undefined || now - lastLoggedAt >= SESSION_PROJECT_BINDING_FAILURE_LOG_INTERVAL_MS) {
+        sessionProjectBindingFailureLogAtBySession.set(sessionId, now);
+        sessionLog(sessionId, `project binding write failed harness=${getHarness()} cwd=${observedCwd ?? "unknown"} attempted=${projectIdentity}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+  if (db && persistedProjectIdentityBySession.get(sessionId) === projectIdentity && sessionProjectBindingFailureLogAtBySession.delete(sessionId)) {
+    sessionLog(sessionId, `project binding write recovered harness=${getHarness()} cwd=${observedCwd ?? "unknown"} identity=${projectIdentity}`);
   }
   trackSessionForProject(projectIdentity, sessionId);
   lastSeenProjectIdentityBySession.set(sessionId, projectIdentity);
@@ -33976,11 +35347,6 @@ function recordPiLiveModel(sessionId, modelKey, assistantTimestamp) {
   liveModelBySession.set(sessionId, modelKey);
   return true;
 }
-function summarizeTransformError(error) {
-  const raw = error instanceof Error ? error.message : String(error);
-  const normalized = raw.replace(/\s+/g, " ").trim();
-  return normalized.length > 180 ? `${normalized.slice(0, 177).trimEnd()}...` : normalized || "Unknown transform error";
-}
 function persistLastTransformErrorIfChanged(db, sessionId, summary, knownCurrent) {
   try {
     const current = knownCurrent === undefined ? getOrCreateSessionMeta(db, sessionId).lastTransformError : knownCurrent;
@@ -34293,31 +35659,15 @@ function piMessageEntryFingerprint(message) {
   const record = message;
   if (typeof record.role !== "string")
     return null;
-  const firstText = firstPiTextContent(record.content);
-  const firstTextHash = crypto3.createHash("sha256").update(firstText ?? "").digest("hex").slice(0, 16);
+  const contentHash = crypto3.createHash("sha256").update(stableStringify(record.content)).digest("hex");
   return JSON.stringify([
     typeof record.responseId === "string" ? record.responseId : null,
     typeof record.timestamp === "number" || typeof record.timestamp === "string" ? record.timestamp : null,
     record.role,
     typeof record.toolCallId === "string" ? record.toolCallId : null,
-    firstTextHash
+    contentHash
   ]);
 }
-function firstPiTextContent(content) {
-  if (typeof content === "string")
-    return content;
-  if (!Array.isArray(content))
-    return null;
-  for (const part of content) {
-    if (!part || typeof part !== "object")
-      continue;
-    const record = part;
-    if (record.type === "text" && typeof record.text === "string") {
-      return record.text;
-    }
-  }
-  return null;
-}
 function buildEntryFingerprintMap(messages, resolveStableId, reusableMessageIds, includeReusable = true) {
   const map = new Map;
   for (let i = 0;i < messages.length; i++) {
@@ -34401,47 +35751,64 @@ function runImmediateTransaction(db, fn) {
     throw error;
   }
 }
-function hasAdoptablePiFallbackMessageTags(db, sessionId, fingerprintById) {
-  const fingerprints = [
-    ...new Set([...fingerprintById].filter(([id]) => !id.startsWith("pi-msg-")).map(([, fingerprint]) => fingerprint))
-  ];
-  for (let index = 0;index < fingerprints.length; index += 900) {
-    const batch = fingerprints.slice(index, index + 900);
-    const placeholders = batch.map(() => "?").join(",");
-    const match = db.prepare(`SELECT 1 FROM tags WHERE session_id = ? AND type = 'message'
-             AND entry_fingerprint IN (${placeholders})
-             AND message_id LIKE 'pi-msg-%' LIMIT 1`).get(sessionId, ...batch);
-    if (match != null)
-      return true;
+function readPiAdoptionRevision(db) {
+  return {
+    external: db.prepare("PRAGMA data_version").get(),
+    local: db.prepare("SELECT total_changes() AS changes").get()
+  };
+}
+function preparePiAdoptionFingerprints(fingerprintById) {
+  const realIdsByFingerprint = new Map;
+  for (const [id, fingerprint] of fingerprintById) {
+    if (id.startsWith("pi-msg-"))
+      continue;
+    const ids = realIdsByFingerprint.get(fingerprint) ?? [];
+    ids.push(id);
+    realIdsByFingerprint.set(fingerprint, ids);
   }
-  return false;
+  const fingerprints = [...realIdsByFingerprint.keys()];
+  const batches = [];
+  for (let i = 0;i < fingerprints.length; i += 900) {
+    const values = fingerprints.slice(i, i + 900);
+    batches.push({ values, placeholders: values.map(() => "?").join(",") });
+  }
+  return { realIdsByFingerprint, batches };
 }
-function readAdoptablePiFallbackFingerprints(db, sessionId, fingerprintById) {
-  const fingerprints = [
-    ...new Set([...fingerprintById].filter(([id]) => !id.startsWith("pi-msg-")).map(([, fingerprint]) => fingerprint))
-  ];
+function readAdoptablePiFallbackFingerprints(db, sessionId, batches) {
   const found = new Set;
-  for (let index = 0;index < fingerprints.length; index += 900) {
-    const batch = fingerprints.slice(index, index + 900);
-    const placeholders = batch.map(() => "?").join(",");
+  for (const { values, placeholders } of batches) {
     const rows = db.prepare(`SELECT DISTINCT entry_fingerprint FROM tags WHERE session_id = ? AND type = 'message'
-             AND entry_fingerprint IN (${placeholders}) AND message_id LIKE 'pi-msg-%'`).all(sessionId, ...batch);
+			 AND entry_fingerprint IN (${placeholders}) AND message_id LIKE 'pi-msg-%'`).all(sessionId, ...values);
     for (const row of rows)
       found.add(row.entry_fingerprint);
   }
   return found;
 }
 function adoptPiFallbackTags(db, sessionId, tagger, fingerprintById, options = {}) {
-  const hasFallbackMessageTags = options.hasFallbackMessageTags === true || hasPiFallbackMessageTags2(db, sessionId);
-  const hasFallbackToolOwnerTags = options.hasFallbackToolOwnerTags === true || hasPiFallbackToolOwnerTags2(db, sessionId);
-  const shouldRunMessageMigration = hasFallbackMessageTags && hasAdoptablePiFallbackMessageTags(db, sessionId, fingerprintById);
-  const shouldRunToolOwnerMigration = Boolean(options.messages && options.resolveStableId && hasFallbackToolOwnerTags);
-  if (!shouldRunMessageMigration && !shouldRunToolOwnerMigration)
+  let { realIdsByFingerprint, batches } = preparePiAdoptionFingerprints(fingerprintById);
+  const ownerMap = options.messages && options.resolveStableId ? buildPiToolOwnerMap(options.messages, options.resolveStableId) : null;
+  if (!batches.length && !ownerMap?.size && !options.rebuildFingerprints)
     return;
+  const revision = () => readPiAdoptionRevision(db);
+  const beforeDiscovery = revision();
+  const discovered = hasPiFallbackMessageTags(db, sessionId) ? readAdoptablePiFallbackFingerprints(db, sessionId, batches) : new Set;
+  const targetsFor = (fingerprints) => [...fingerprints].flatMap((fingerprint) => (realIdsByFingerprint.get(fingerprint) ?? []).map((id) => [id, fingerprint]));
+  const discoveredTargets = targetsFor(discovered);
   runImmediateTransaction(db, () => {
-    if (shouldRunMessageMigration) {
-      const adoptable = readAdoptablePiFallbackFingerprints(db, sessionId, fingerprintById);
-      for (const [realMessageId, fingerprint] of fingerprintById) {
+    const admitted = revision();
+    const preflight = options.preflightRevision;
+    const rebuild = options.rebuildFingerprints;
+    const expanded = Boolean(preflight && rebuild && (preflight.external.data_version !== admitted.external.data_version || preflight.local.changes !== admitted.local.changes));
+    if (expanded && rebuild) {
+      ({ realIdsByFingerprint, batches } = preparePiAdoptionFingerprints(rebuild()));
+    }
+    if (batches.length && hasPiFallbackMessageTags(db, sessionId)) {
+      const unchanged = !expanded && beforeDiscovery.external.data_version === admitted.external.data_version && beforeDiscovery.local.changes === admitted.local.changes;
+      const adoptable = unchanged ? discovered : readAdoptablePiFallbackFingerprints(db, sessionId, batches);
+      const targets = expanded ? targetsFor(adoptable) : discoveredTargets.filter(([, fp]) => adoptable.has(fp));
+      if (!expanded)
+        targets.push(...targetsFor([...adoptable].filter((fp) => !discovered.has(fp))));
+      for (const [realMessageId, fingerprint] of targets) {
         if (realMessageId.startsWith("pi-msg-"))
           continue;
         if (!adoptable.has(fingerprint))
@@ -34461,7 +35828,7 @@ function adoptPiFallbackTags(db, sessionId, tagger, fingerprintById, options = {
           if (!ordinalMatch)
             continue;
           const realContentId = `${realMessageId}:p${ordinalMatch[1]}`;
-          const adoption = adoptPiFallbackMessageTag(db, sessionId, c.tagNumber, c.messageId, realContentId);
+          const adoption = adoptPiFallbackMessageTag(db, sessionId, c.tagNumber, c.messageId, realContentId, getPiServedTagNumbers(sessionId));
           if (adoption.action !== "skipped") {
             tagger.unbindTag(sessionId, c.messageId);
             if (adoption.action === "folded") {
@@ -34472,8 +35839,7 @@ function adoptPiFallbackTags(db, sessionId, tagger, fingerprintById, options = {
         }
       }
     }
-    if (shouldRunToolOwnerMigration && options.messages && options.resolveStableId) {
-      const ownerMap = buildPiToolOwnerMap(options.messages, options.resolveStableId);
+    if (ownerMap && hasPiFallbackToolOwnerTags(db, sessionId)) {
       for (const row of findPiFallbackToolOwnerTags(db, sessionId)) {
         const parsed = parsePiFallbackToolOwnerId(row.toolOwnerMessageId);
         if (parsed?.role !== "assistant")
@@ -34484,7 +35850,7 @@ function adoptPiFallbackTags(db, sessionId, tagger, fingerprintById, options = {
         const [realOwnerId] = owners;
         if (!realOwnerId || realOwnerId.startsWith("pi-msg-"))
           continue;
-        const adoption = adoptPiFallbackToolOwnerTag(db, sessionId, row.tagNumber, row.callId, row.toolOwnerMessageId, realOwnerId);
+        const adoption = adoptPiFallbackToolOwnerTag(db, sessionId, row.tagNumber, row.callId, row.toolOwnerMessageId, realOwnerId, getPiServedTagNumbers(sessionId));
         if (adoption.action !== "skipped") {
           tagger.unbindToolTag(sessionId, row.toolOwnerMessageId, row.callId);
           if (adoption.action === "folded") {
@@ -34555,20 +35921,40 @@ function registerPiContextHandler(pi, baseOptions, processOptions = {}) {
     variantChangeLogObserverForTests?.(message);
     sessionLog(sessionId, message);
   });
-  registerPiGuardedContext(pi, async (event, ctx) => {
+  const contextHandler = async (event, ctx, budget) => {
+    const passSessionId = ctx.sessionManager ? resolveSessionId2(ctx) : undefined;
+    const generation = Symbol();
+    if (passSessionId && !budget.sideTurn)
+      contextPassGeneration.set(passSessionId, generation);
+    const signal = event.signal ?? ctx.signal;
+    const assertOperation = budget.assertOwner;
+    budget.assertOwner = () => {
+      assertOperation();
+      if (!budget.sideTurn && passSessionId && contextPassGeneration.get(passSessionId) !== generation)
+        throw new PiContextSupersededError("Pi context pass superseded before writer admission");
+      signal?.throwIfAborted();
+    };
+    let assertCurrentPass = budget.assert;
+    const guardAwait = budget.wait;
+    const passGuard = { assert: assertCurrentPass, wait: guardAwait };
+    guardSqliteTransformPass({
+      assert: assertCurrentPass,
+      remainingMs: () => budget.remainingWork()
+    });
+    budget.stage = "schema/claim";
+    const toolWireSchema = await guardAwait(loadPiToolWireSchema());
     if (processOptions.checkoutClaim) {
       const claimSessionId = resolveSessionId2(ctx);
       if (claimSessionId) {
-        const refusal = await processOptions.checkoutClaim.refusal(claimSessionId, ctx.cwd);
+        const refusal = await guardAwait(processOptions.checkoutClaim.refusal(claimSessionId, ctx.cwd));
         if (refusal)
           throw refusal;
       }
     }
-    const transformStartTime = performance.now();
+    const transformStartTime = budget.startedAt;
     let rawMessageCount = 0;
     let rawFallbackLimit;
     let sessionIdForError;
-    let sessionMetaForPass;
     let lkgPassSnapshot;
     let lkgCompactionOff = baseOptions.compactionOff === true;
     let lkgEmergencyRecoveryArmed = false;
@@ -34596,17 +35982,21 @@ function registerPiContextHandler(pi, baseOptions, processOptions = {}) {
       const scheduler = schedulerFor(options);
       lkgCompactionOff = options.compactionOff === true;
       const projectIdentity = resolveProjectIdentityForSession(projectDirectory, options.allowHomeProject) ?? "";
-      updateSessionProjectTracking(sessionId, projectIdentity, options.db);
       logTransformTiming(sessionId, "findSessionId", tFindSession, `messages=${event.messages.length}`);
+      budget.stage = "branch projection";
       const tEntryBranch = performance.now();
       const branchEntries = readPiBranchEntriesForContext(ctx, sessionId);
+      assertCurrentPass();
       const piLiveUsageIsRawBranchEstimate = isPiLiveUsageRawBranchEstimate(branchEntries);
       recordPiLiveUsageClassification(sessionId, piLiveUsageIsRawBranchEstimate);
-      schedulePiTransformDecisionResolve({
-        db: options.db,
-        sessionId,
-        branchEntries
-      });
+      assertCurrentPass();
+      if (!budget.sideTurn)
+        schedulePiTransformDecisionResolve({
+          db: options.db,
+          sessionId,
+          branchEntries,
+          assertCurrentPass
+        });
       let rawOrdinalCount;
       const rawMessageProvider = {
         getMessageCount: () => rawOrdinalCount ??= branchEntries !== null ? countPiRawMessages(branchEntries) : readPiSessionMessages(ctx).length,
@@ -34626,13 +36016,56 @@ function registerPiContextHandler(pi, baseOptions, processOptions = {}) {
       const lkgModelKey = resolvePiContextModelKey(ctx) ?? null;
       const lkgContextModel = ctx.model;
       const lkgProviderKey = typeof lkgContextModel?.provider === "string" ? lkgContextModel.provider : null;
-      lkgPassSnapshot = lkgCoordinator.beginPass({
+      const snapshot = lkgCoordinator.beginPass({
         sessionId,
         messages: event.messages,
         entryIds: lkgEntryIds,
         modelKey: lkgModelKey,
-        providerKey: lkgProviderKey
+        providerKey: lkgProviderKey,
+        apiKey: ctx.model?.api ?? null,
+        transport: ctx.model?.transport
       });
+      lkgPassSnapshot = snapshot;
+      let checkedReplay = false;
+      budget.stage = "writer admission";
+      assertCurrentPass();
+      const sessionMetaForUsage = await guardAwait(withAsyncPrivilegedWriter(options.db, () => {
+        assertCurrentPass();
+        return getOrCreateSessionMeta(options.db, sessionId);
+      }, {
+        signal,
+        budgetMs: budget.writerAllowance(),
+        assertCurrentPass,
+        jitter: true,
+        beforeRetry: (error) => {
+          assertCurrentPass();
+          if (checkedReplay)
+            return;
+          checkedReplay = true;
+          const state = loadPiHistorianStateSnapshot(options.db, sessionId);
+          lkgEmergencyRecoveryArmed = state.needsEmergencyRecovery;
+          if (state.detectedContextLimit > 0)
+            rawFallbackLimit = resolvePiWindowGeometry({
+              model: ctx.model,
+              rawContextWindow: piUsage?.contextWindow,
+              detectedContextLimit: state.detectedContextLimit
+            })?.usableHard;
+          if (lkgCompactionOff || lkgEmergencyRecoveryArmed || isProviderOverflowFailClosedProven(sessionId))
+            return;
+          const replay = lkgCoordinator.replay(snapshot, (id) => ctx.sessionManager.getEntry?.(id)?.parentId);
+          if (!replay.ok)
+            return;
+          try {
+            assertPiRawFallbackFits(replay.messages, rawFallbackLimit, (line) => logPiLkgRecovery(sessionId, line), error, readPiLkgFitEnvelope(ctx, pi, lkgModelKey, sessionDecisionCalibration(options.db, sessionId), toolWireSchema), replay.measuredPrefix);
+          } catch {
+            return;
+          }
+          logPiLkgRecovery(sessionId, `TRANSIENT STORAGE FAILURE ${piStorageErrorReason(error)}: LKG replay served ${replay.messages.length} messages instead of raw ${rawMessageCount}`);
+          throw new PiLkgAdmissionReplay(replay.messages);
+        }
+      }));
+      assertCurrentPass();
+      updateSessionProjectTracking(sessionId, projectIdentity, options.db, projectDirectory);
       const lkgInputIdByRef = new Map;
       for (const input of lkgPassSnapshot.inputs)
         lkgInputIdByRef.set(event.messages[input.messageIndex], input.id);
@@ -34660,8 +36093,6 @@ function registerPiContextHandler(pi, baseOptions, processOptions = {}) {
         }
       }
       const tMeta = performance.now();
-      const sessionMetaForUsage = getOrCreateSessionMeta(options.db, sessionId);
-      sessionMetaForPass = sessionMetaForUsage;
       const historianStateForPass = options.compactionOff ? EMPTY_PI_HISTORIAN_STATE_SNAPSHOT : (() => {
         try {
           return loadPiHistorianStateSnapshot(options.db, sessionId);
@@ -34817,7 +36248,7 @@ function registerPiContextHandler(pi, baseOptions, processOptions = {}) {
       } catch (err) {
         sessionLog(sessionId, `transform: overflow state read failed: ${err instanceof Error ? err.message : String(err)}`);
       }
-      const sessionMeta = sessionMetaForUsage;
+      let sessionMeta = sessionMetaForUsage;
       const modelKey = liveModelBySession.get(sessionId);
       const providerId = typeof ctx.model?.provider === "string" ? ctx.model.provider : undefined;
       const canUseEmptySentinels = modelAcceptsEmptyContent(providerId);
@@ -34835,28 +36266,14 @@ function registerPiContextHandler(pi, baseOptions, processOptions = {}) {
         detectedContextLimit
       });
       rawFallbackLimit = baseWindowGeometry?.usableHard ?? rawFallbackLimit;
-      let provenInputTokens = resolvePiProvenInputFloor({
+      const providerInputLimit = piPressureEvidenceLimit(baseWindowGeometry);
+      const provenInputTokens = resolvePiProvenInputFloor({
         db: options.db,
         sessionId,
-        modelKey: currentModelKey
+        modelKey: currentModelKey,
+        readBranch: () => branchEntries ?? undefined,
+        providerInputLimit
       });
-      if (baseWindowGeometry && hasTrustedAbsoluteWall(baseWindowGeometry) && provenInputTokens > baseWindowGeometry.derivation.absoluteWall) {
-        sessionLog(sessionId, `transform: persisted proven floor ${provenInputTokens} exceeds trusted absolute wall ${baseWindowGeometry.derivation.absoluteWall}; cleared and re-resolved to ${baseWindowGeometry.usableSoft}`);
-        updateSessionMeta(options.db, sessionId, {
-          observedSafeInputTokens: 0,
-          cacheAlertSent: false,
-          lastUsageContextLimit: baseWindowGeometry.usableSoft,
-          lastInputTokens: sessionMeta.lastInputTokens > baseWindowGeometry.derivation.absoluteWall ? baseWindowGeometry.derivation.absoluteWall : sessionMeta.lastInputTokens,
-          lastContextPercentage: sessionMeta.lastInputTokens > baseWindowGeometry.derivation.absoluteWall ? baseWindowGeometry.derivation.absoluteWall / baseWindowGeometry.usableSoft * 100 : sessionMeta.lastContextPercentage
-        });
-        provenInputTokens = 0;
-        sessionMeta.observedSafeInputTokens = 0;
-        sessionMeta.cacheAlertSent = false;
-        if (usageInputTokens > baseWindowGeometry.derivation.absoluteWall) {
-          usageInputTokens = baseWindowGeometry.derivation.absoluteWall;
-          usagePercentage = usageInputTokens / baseWindowGeometry.usableSoft * 100;
-        }
-      }
       const windowGeometry = resolvePiWindowGeometry({
         rawContextWindow: usageContextLimit,
         rawContextWindowSource: usageContextWindowSource,
@@ -34874,7 +36291,19 @@ function registerPiContextHandler(pi, baseOptions, processOptions = {}) {
       if (!usedPersistedUsage && isSaneLimit(usageContextLimit) && usageInputTokens > 0) {
         usagePercentage = usageInputTokens / usageContextLimit * 100;
       }
+      let fallbackInputTokens;
+      const suspectReading = Math.max(usageInputTokens, piUsage?.tokens ?? 0);
+      if (suspectReading > providerInputLimit || piProviderUsageWasRejected(sessionId)) {
+        if (suspectReading > providerInputLimit)
+          noteRejectedPiUsage(sessionId, suspectReading, providerInputLimit, "transform");
+        const replay = !lkgCompactionOff && lkgPassSnapshot ? lkgCoordinator.replay(lkgPassSnapshot, (id) => ctx.sessionManager.getEntry?.(id)?.parentId) : undefined;
+        const counts = tokenizePiMessages(replay?.ok ? replay.messages : event.messages);
+        const envelope = readPiLkgFitEnvelope(ctx, pi, currentModelKey, sessionDecisionCalibration(options.db, sessionId));
+        fallbackInputTokens = counts.conversation + counts.toolCall + (envelope?.systemTokens ?? 0) + (envelope?.toolDefinitionTokens ?? 0);
+      }
       ({ percentage: usagePercentage, inputTokens: usageInputTokens } = resolvePiPressureSnapshotWithEstimateGuard({
+        providerInputLimit,
+        fallbackInputTokens,
         sessionId,
         source: "transform",
         liveIsRawBranchEstimate: piLiveUsageIsRawBranchEstimate,
@@ -34931,14 +36360,25 @@ function registerPiContextHandler(pi, baseOptions, processOptions = {}) {
         if (now - lastNotifiedAt >= EMERGENCY_NOTIFICATION_COOLDOWN_MS) {
           lastEmergencyNotificationAtMs.set(sessionId, now);
           sendPiIgnoredNotification(ctx, "Context full — /ctx-flush or /clear to continue.");
-          sessionLog(sessionId, `EMERGENCY: usage=${usagePercentage.toFixed(1)}% — notified user, awaiting in-flight historian + evaluating tiered emergency reclaim`);
-        }
-        const histPromise = inFlightHistorian.get(sessionId);
-        if (histPromise) {
-          try {
-            await withTimeout(histPromise, 30000);
-            sessionLog(sessionId, "EMERGENCY: historian wait completed (or timed out)");
-          } catch {}
+          sessionLog(sessionId, `EMERGENCY: usage=${usagePercentage.toFixed(1)}% — notified user, evaluating available emergency reclaim`);
+        }
+        const historian = inFlightHistorian.get(sessionId);
+        const visibleToolResults = new Set(event.messages.flatMap((message) => message.role === "toolResult" ? [message.toolCallId] : []));
+        const toolTags = getTagsBySession(options.db, sessionId).filter((tag) => tag.type === "tool");
+        const knownTools = new Set(toolTags.map((tag) => tag.messageId));
+        const activeTools = new Set(toolTags.filter((tag) => tag.status === "active").map((tag) => tag.messageId));
+        const hasToolReclaim = event.messages.some((message) => message.role === "assistant" && message.content.some((part) => part.type === "toolCall" && visibleToolResults.has(part.id) && (!knownTools.has(part.id) || activeTools.has(part.id))));
+        if (historian && !hasToolReclaim && getPendingOps(options.db, sessionId).length === 0 && !historyRefreshSessions.has(sessionId) && !deferredHistoryRefreshSessions.has(sessionId)) {
+          budget.stage = "emergency historian";
+          await budget.wait(historian);
+          assertCurrentPass();
+          sessionMeta = getOrCreateSessionMeta(options.db, sessionId);
+          piM0M1PassSnapshot = options.injection ? createPiM0M1PassSnapshot({
+            db: options.db,
+            sessionId,
+            compactionOff: false,
+            sessionMeta
+          }) : undefined;
         }
         if (emergencyRecoveryArmed && realUsagePercentageBeforeEmergencyBump < forceMaterializationPercentage && !inFlightHistorian.has(sessionId) && !hasEligiblePiCompartmentHistory(options.db, sessionId)) {
           try {
@@ -34961,7 +36401,17 @@ function registerPiContextHandler(pi, baseOptions, processOptions = {}) {
       }) / 100)) : undefined;
       logTransformTiming(sessionId, "prePipelineTotal", transformStartTime);
       const tRunPipeline = performance.now();
-      const result = await runPipeline({
+      budget.stage = "pipeline";
+      assertCurrentPass = budget.assertOutcome;
+      guardSqliteTransformPass({
+        assert: assertCurrentPass,
+        remainingMs: budget.remainingOutcome
+      });
+      if (beforePipelineForTests)
+        await budget.waitMandatory(beforePipelineForTests());
+      assertCurrentPass();
+      const result = await budget.waitMandatory(runPipeline({
+        assertCurrentPass,
         db: options.db,
         tagger,
         sessionId,
@@ -35006,27 +36456,30 @@ function registerPiContextHandler(pi, baseOptions, processOptions = {}) {
         },
         isCacheBusting,
         reasoningClearing: {
-          clearReasoningAge: options.heuristics?.clearReasoningAge ?? DEFAULT_CLEAR_REASONING_AGE,
+          keepReasoningTokens: resolveKeepReasoningTokens(options.heuristics?.keepReasoningTokens, resolvePiContextModelKey(ctx)),
           nativeReasoningMayClear: canClearNativeReasoning(ctx.model),
           prefixBound: isPrefixBoundThinkingModel(typeof ctx.model?.provider === "string" ? ctx.model.provider : undefined, typeof ctx.model?.id === "string" ? ctx.model.id : undefined),
           preserveReasoningToolArcs: ctx.model?.api !== "openai-codex-responses" && ctx.model?.api !== "openai-responses"
         },
+        resolvedProviderID: ctx.model?.provider,
+        resolvedModelID: ctx.model?.id,
         canUseEmptySentinels,
         temporalAwareness: options.injection?.temporalAwareness === true,
-        appendCompaction: resolvePiAppendCompaction(ctx),
+        appendCompaction: guardedPiAppendCompaction(ctx, assertCurrentPass),
         readBranchEntries: resolvePiReadBranchEntries(ctx),
         isSubagent: sessionMeta.isSubagent,
         compactionOff: options.compactionOff === true,
         injectionPassSnapshot: piM0M1PassSnapshot
-      });
+      }));
       logTransformTiming(sessionId, "runPipeline", tRunPipeline);
       const postPipelineStart = performance.now();
       const tTransformDecision = performance.now();
       if (strictEntryIds) {
+        assertCurrentPass();
         recordSuccessfulTaggedMessageIds(sessionId, strictEntryIds);
       }
       const piDecisionSnapshotNewestAssistant = result.bustedThisPass ? findNewestPiAssistantEntryId(branchEntries) : undefined;
-      if (piDecisionSnapshotNewestAssistant !== undefined) {
+      const publishTransformDecision = !budget.sideTurn && piDecisionSnapshotNewestAssistant !== undefined ? () => {
         recordPendingPiTransformDecision(sessionId, {
           tsMs: Date.now(),
           decision: schedulerDecision,
@@ -35041,28 +36494,55 @@ function registerPiContextHandler(pi, baseOptions, processOptions = {}) {
           droppedCount: result.droppedCount,
           inputTokens: usageInputTokens,
           bustedThisPass: true
-        }, piDecisionSnapshotNewestAssistant);
-      }
+        }, piDecisionSnapshotNewestAssistant, budget.assertDecisionPublication);
+      } : undefined;
       logTransformTiming(sessionId, "transformDecisionAndReuseState", tTransformDecision);
       const tHistorianScheduling = performance.now();
-      if (options.historian && !options.compactionOff) {
-        maybeFireHistorian({
-          pi,
-          ctx,
-          sessionId,
-          db: options.db,
-          historian: options.historian,
-          isFirstContextPassForSession,
-          activeTags: result.activeTags,
-          rawMessageProvider,
-          taggerFloor,
-          sessionMeta,
-          piUsage,
-          minimumPercentage: usagePercentage,
-          liveIsRawBranchEstimate: piLiveUsageIsRawBranchEstimate,
-          historianStateSnapshot: historianStateForPass,
-          publishedHistoryRide: isCacheBusting
+      const historian = options.historian;
+      budget.stage = "historian scheduling";
+      if (historian && !options.compactionOff && budget.remainingWork() > 0) {
+        guardSqliteTransformPass({
+          assert: budget.assert,
+          remainingMs: () => budget.remainingWork()
         });
+        try {
+          budget.assert();
+          maybeFireHistorian({
+            startGuard: () => {
+              if (!budget.completed)
+                budget.assertOwner();
+              if (budget.abandoned || budget.remainingWork() === 0)
+                throw new PiContextDeadlineError(budget.diagnostic());
+            },
+            pi,
+            ctx,
+            sessionId,
+            db: options.db,
+            historian,
+            isFirstContextPassForSession,
+            activeTags: result.activeTags,
+            rawMessageProvider,
+            taggerFloor,
+            sessionMeta,
+            piUsage,
+            pressureSnapshot: {
+              percentage: usagePercentage,
+              inputTokens: usageInputTokens
+            },
+            minimumPercentage: usagePercentage,
+            liveIsRawBranchEstimate: piLiveUsageIsRawBranchEstimate,
+            historianStateSnapshot: historianStateForPass,
+            publishedHistoryRide: isCacheBusting
+          });
+        } catch (error) {
+          budget.assertOutcome();
+          sessionLog(sessionId, `historian scheduling skipped: ${String(error)}`);
+        } finally {
+          guardSqliteTransformPass({
+            assert: budget.assertOutcome,
+            remainingMs: budget.remainingOutcome
+          });
+        }
       }
       logTransformTiming(sessionId, "historianScheduling", tHistorianScheduling);
       const tPostTransform = performance.now();
@@ -35098,9 +36578,15 @@ function registerPiContextHandler(pi, baseOptions, processOptions = {}) {
       }
       logTransformTiming(sessionId, "noteNudges", tNoteNudges);
       const tAutoSearch = performance.now();
-      if (options.autoSearch?.enabled && !options.compactionOff) {
+      budget.stage = "auto-search";
+      if (options.autoSearch?.enabled && !options.compactionOff && budget.remainingWork() > PI_CONTEXT_BUDGET.searchMs) {
+        guardSqliteTransformPass({
+          assert: budget.assert,
+          remainingMs: () => budget.remainingWork()
+        });
         try {
-          outputMessages = await runAutoSearchHintForPi({
+          outputMessages = await guardAwait(runAutoSearchHintForPi({
+            passGuard,
             sessionId,
             db: options.db,
             messages: outputMessages,
@@ -35116,9 +36602,15 @@ function registerPiContextHandler(pi, baseOptions, processOptions = {}) {
               visibleMemoryIds: getVisibleMemoryIds(options.db, sessionId) ?? null,
               wordRules: cavemanWordRulesForLanguage(options.language)
             }
-          });
+          }));
         } catch (err) {
+          assertCurrentPass();
           sessionLog(sessionId, `auto-search failed: ${err instanceof Error ? err.message : String(err)}`);
+        } finally {
+          guardSqliteTransformPass({
+            assert: budget.assertOutcome,
+            remainingMs: budget.remainingOutcome
+          });
         }
       }
       logTransformTiming(sessionId, "autoSearch", tAutoSearch);
@@ -35268,6 +36760,7 @@ function registerPiContextHandler(pi, baseOptions, processOptions = {}) {
       }
       logTransformTiming(sessionId, "channelNudgeAccounting", tChannelAccounting);
       const tWorkMetrics = performance.now();
+      budget.stage = "bookkeeping";
       try {
         const metrics = computePiWorkMetrics(outputMessages);
         setSessionWorkMetrics(options.db, sessionId, metrics.newWorkTokens, metrics.totalInputTokens);
@@ -35289,7 +36782,8 @@ function registerPiContextHandler(pi, baseOptions, processOptions = {}) {
       logTransformTiming(sessionId, "stableIdSchemePersist", tStableIdSchemePersist);
       logTransformTiming(sessionId, "postTransformPhase", tPostTransform);
       clearLastTransformErrorIfSet(options.db, sessionId, sessionMeta.lastTransformError);
-      options.maybeAutoEmbedSession?.(sessionId, projectDirectory, projectIdentity);
+      if (budget.remainingWork() > PI_CONTEXT_BUDGET.completionReserveMs)
+        withoutSqliteTransformPass(() => options.maybeAutoEmbedSession?.(sessionId, projectDirectory, projectIdentity));
       logTransformTiming(sessionId, "postPipelineTotal", postPipelineStart);
       const transformElapsedMs = performance.now() - transformStartTime;
       recordPiTransformTiming({
@@ -35301,19 +36795,27 @@ function registerPiContextHandler(pi, baseOptions, processOptions = {}) {
       sessionLog(sessionId, `transform completed in ${transformElapsedMs.toFixed(1)}ms (${outputMessages.length} messages, ${result.targetCount} targets, watermark: ${result.reasoningWatermark})`);
       runPiDebugAssertion(assertTailHygieneLastWriter);
       if (!options.compactionOff && (result.executedWorkThisPass || isCacheBusting || schedulerDecision === "execute")) {
-        const envelope = readPiLkgFitEnvelope(ctx, pi, resolvePiContextModelKey(ctx), sessionDecisionCalibration(options.db, sessionId));
+        const envelope = readPiLkgFitEnvelope(ctx, pi, resolvePiContextModelKey(ctx), sessionDecisionCalibration(options.db, sessionId), toolWireSchema);
         const estimate = estimatePiOutgoingInputTokens(outputMessages, envelope, lkgPassSnapshot ? lkgCoordinator.measureOutgoingPrefix(lkgPassSnapshot, outputMessages, (id) => ctx.sessionManager.getEntry?.(id)?.parentId) : undefined, rawFallbackLimit);
         const refusal = outgoingContextRefusal(estimate, rawFallbackLimit, protectedToolTokenCount(getActiveTagsBySession(options.db, sessionId), options.protectedTools, envelope ? calibrationForModelKey(envelope.modelKey) : undefined));
         if (refusal)
           throw contextRefusalError(refusal);
       }
       let serializedOutput;
-      if (!lkgCompactionOff && lkgPassSnapshot) {
+      budget.stage = "LKG/served publication";
+      budget.assertOutcome();
+      guardSqliteTransformPass({
+        assert: budget.assertOutcome,
+        remainingMs: () => Math.max(0, PI_CONTEXT_BUDGET.outcomeMs - budget.elapsed())
+      });
+      if (!budget.sideTurn && !lkgCompactionOff && lkgPassSnapshot) {
         let hostEnvelopeSignature;
         try {
-          hostEnvelopeSignature = readPiLkgFitEnvelope(ctx, pi, resolvePiContextModelKey(ctx), sessionDecisionCalibration(baseOptions.db, sessionId))?.envelopeSignature;
+          hostEnvelopeSignature = readPiLkgFitEnvelope(ctx, pi, resolvePiContextModelKey(ctx), sessionDecisionCalibration(baseOptions.db, sessionId), toolWireSchema)?.envelopeSignature;
         } catch {}
+        budget.assertOutcome();
         serializedOutput = lkgCoordinator.captureAppliedPass({
+          assertCurrentPass: budget.assertOutcome,
           hostEnvelopeSignature,
           snapshot: lkgPassSnapshot,
           outputMessages,
@@ -35321,7 +36823,15 @@ function registerPiContextHandler(pi, baseOptions, processOptions = {}) {
           cacheBusting: result.bustedThisPass
         });
       }
-      capturePiServedArray(sessionId, outputMessages, { serializedOutput });
+      budget.assertOutcome();
+      if (!budget.sideTurn)
+        capturePiServedArray(sessionId, outputMessages, {
+          servedTagNumbers: result.servedTagNumbers,
+          serializedOutput,
+          assertCurrentPass: budget.assertOutcome
+        });
+      if (!budget.sideTurn)
+        captureOpencodeReasoningBudgetStatus(sessionId, piReasoningStatusMessages(outputMessages), resolveKeepReasoningTokens(options.heuristics?.keepReasoningTokens, resolvePiContextModelKey(ctx)), isPrefixBoundThinkingModel(ctx.model?.provider, ctx.model?.id), sessionDecisionCalibration(options.db, sessionId).proseRatio);
       if (thinkingBindingRecoveryApplied) {
         try {
           clearThinkingBindingRecoveryIf(options.db, sessionId, thinkingBindingRecoveryApplied.flagTarget);
@@ -35329,14 +36839,34 @@ function registerPiContextHandler(pi, baseOptions, processOptions = {}) {
           sessionLog(sessionId, `thinking binding recovery cleanup deferred: ${error instanceof Error ? error.message : String(error)}`);
         }
       }
+      budget.assertOutcome();
+      publishTransformDecision?.();
       return { messages: outputMessages };
     } catch (err) {
+      budget.assertOutcome();
+      budget.stage = "recovery";
+      if (err instanceof PiServedIdentityError) {
+        if (sessionIdForError)
+          clearPiLkgSessionState(sessionIdForError);
+        throw new PiStorageBusyError({ cause: err });
+      }
+      if (err instanceof PiLkgAdmissionReplay && sessionIdForError) {
+        budget.assertOutcome();
+        if (!budget.sideTurn)
+          capturePiServedArray(sessionIdForError, err.messages, {
+            assertCurrentPass: budget.assertOutcome
+          });
+        budget.assertOutcome();
+        budget.recovery = "fitting LKG before writer retries";
+        return { messages: err.messages };
+      }
       if ((isFailClosedBlockingError(err) || err instanceof EmergencyFailClosedError) && !baseOptions.compactionOff)
         throw err;
       if (!lkgCompactionOff && sessionIdForError && isProviderOverflowFailClosedProven(sessionIdForError)) {
         throw new EmergencyFailClosedError("Emergency recovery transform failed; refusing an unbounded raw fallback", { cause: err });
       }
       const message = err instanceof Error ? err.message : String(err);
+      budget.failureReason = message;
       const stack = err instanceof Error ? err.stack : undefined;
       const transientStorageFailure = isTransientPiStorageError(err);
       const degradedPass = !lkgCompactionOff;
@@ -35349,14 +36879,21 @@ function registerPiContextHandler(pi, baseOptions, processOptions = {}) {
             assertPiRawFallbackFits(replay.messages, rawFallbackLimit, (line) => {
               if (sessionIdForError)
                 logPiLkgRecovery(sessionIdForError, line);
-            }, err, readPiLkgFitEnvelope(ctx, pi, resolvePiContextModelKey(ctx), sessionDecisionCalibration(baseOptions.db, sessionIdForError)), replay.measuredPrefix);
+            }, err, readPiLkgFitEnvelope(ctx, pi, resolvePiContextModelKey(ctx), sessionDecisionCalibration(baseOptions.db, sessionIdForError), toolWireSchema), replay.measuredPrefix);
             const reason = piStorageErrorReason(err);
             logPiLkgRecovery(sessionIdForError, `${failureLabel} ${reason}: LKG replay served ${replay.messages.length} messages instead of raw ${rawMessageCount}`);
-            capturePiServedArray(sessionIdForError, replay.messages);
+            budget.assertOutcome();
+            if (!budget.sideTurn)
+              capturePiServedArray(sessionIdForError, replay.messages, {
+                assertCurrentPass: budget.assertOutcome
+              });
+            budget.assertOutcome();
+            budget.recovery = "fitting LKG replay";
             return { messages: replay.messages };
           }
           logPiLkgRecovery(sessionIdForError, `${failureLabel} ${piStorageErrorReason(err)}: LKG unavailable (${replay.reason}); refusing unreduced ${rawMessageCount}-message input`);
         } catch (replayError) {
+          budget.assertOutcome();
           if (replayError instanceof PiStorageBusyError)
             throw replayError;
           logPiLkgRecovery(sessionIdForError, `${failureLabel} ${piStorageErrorReason(err)}: LKG replay unavailable (${replayError instanceof Error ? replayError.message : String(replayError)}); refusing unreduced ${rawMessageCount}-message input`);
@@ -35367,9 +36904,6 @@ function registerPiContextHandler(pi, baseOptions, processOptions = {}) {
       }
       if (transientStorageFailure)
         throw new PiStorageBusyError({ cause: err });
-      if (sessionIdForError && !transientStorageFailure) {
-        persistLastTransformErrorIfChanged(baseOptions.db, sessionIdForError, summarizeTransformError(err), sessionMetaForPass?.lastTransformError);
-      }
       if (!lkgCompactionOff && sessionIdForError) {
         throw new PiStorageBusyError({
           cause: err instanceof PiDegradedPassError ? err : new PiDegradedPassError("context-handler-failed", {
@@ -35380,6 +36914,23 @@ function registerPiContextHandler(pi, baseOptions, processOptions = {}) {
       log(`[magic-context][pi] context handler failed (continuing without mutation): ${message}`, stack);
       return;
     }
+  };
+  registerPiGuardedContext(pi, contextHandler, {
+    compactionOff: (ctx) => (baseOptions.resolveForProject?.(ctx.cwd) ?? baseOptions).compactionOff === true,
+    onRefusal: (ctx, budget, message, isCurrent) => {
+      const sessionId = resolveSessionId2(ctx);
+      if (!sessionId)
+        return;
+      withoutSqliteTransformPass(() => setImmediate(() => {
+        if (!isCurrent())
+          return;
+        try {
+          withSqliteBackgroundWriter(() => persistLastTransformErrorIfChanged(baseOptions.db, sessionId, budget.failureReason ?? message));
+        } catch (error) {
+          log(`[magic-context][pi] refused-turn diagnostic not persisted ${budget.diagnostic()}`, error);
+        }
+      }));
+    }
   });
   log("[magic-context][pi] registered context handler (tagging + drops + nudges)");
 }
@@ -35405,7 +36956,7 @@ function resolvePiHistorianTriggerInputs(args) {
     executeThresholdPercentage,
     triggerBudget: deriveTriggerBudget(contextLimit, executeThresholdPercentage),
     protectedTags: args.historian.protectedTags,
-    clearReasoningAge: args.historian.clearReasoningAge ?? DEFAULT_CLEAR_REASONING_AGE,
+    keepReasoningTokens: resolveKeepReasoningTokens(args.historian.keepReasoningTokens, args.modelKey),
     commitClusterTrigger: args.historian.commitClusterTrigger,
     contextLimit,
     emergencyCeilingTokens: Math.floor(contextLimit * (executeThresholdPercentage / 100))
@@ -35499,12 +37050,15 @@ function spawnPiHistorianRun(args) {
     currentContextLimit,
     fallbackModelId
   } = args;
+  args.startGuard?.();
   const holderId = crypto3.randomUUID();
   const controller = new AbortController;
   historianAbortControllers.set(sessionId, controller);
-  const runPromise = (async () => {
+  const runPromise = withoutSqliteTransformPass(() => (async () => {
+    await new Promise((resolve) => setTimeout(resolve, 0));
     if (controller.signal.aborted)
       return;
+    args.startGuard?.();
     const lease = acquireCompartmentLease(db, sessionId, holderId);
     if (!lease) {
       sessionLog(sessionId, "historian skipped: compartment lease held by another process");
@@ -35517,6 +37071,9 @@ function spawnPiHistorianRun(args) {
     }
     const renewal = startPiCompartmentLeaseRenewal(db, sessionId, holderId);
     try {
+      const runBoundary = typeof boundarySnapshot === "function" ? boundarySnapshot() : boundarySnapshot;
+      if (!runBoundary)
+        return;
       await runPiHistorian({
         db,
         sessionId,
@@ -35544,7 +37101,7 @@ function spawnPiHistorianRun(args) {
           const window = ctx.modelRegistry?.find(model.slice(0, slash), model.slice(slash + 1))?.contextWindow;
           return isSaneLimit(window) ? window : undefined;
         },
-        boundarySnapshot,
+        boundarySnapshot: runBoundary,
         refreshBoundarySnapshot,
         currentContextLimit,
         historianTimeoutMs: historian.timeoutMs,
@@ -35604,7 +37161,7 @@ function spawnPiHistorianRun(args) {
     } catch (error) {
       sessionLog(sessionId, `pi historian finalizer failed: ${error instanceof Error ? error.message : String(error)}`);
     }
-  });
+  }));
   inFlightHistorian.set(sessionId, runPromise);
   historian.onStatusChange?.(ctx, sessionId);
 }
@@ -35614,6 +37171,13 @@ function resolvePiAppendCompaction(ctx) {
     return;
   return sm.appendCompaction.bind(sm);
 }
+function guardedPiAppendCompaction(ctx, assertCurrentPass) {
+  const append = resolvePiAppendCompaction(ctx);
+  return append ? (...args) => {
+    assertCurrentPass();
+    return append(...args);
+  } : undefined;
+}
 function resolvePiReadBranchEntries(ctx) {
   const sm = ctx.sessionManager;
   if (typeof sm?.getBranch !== "function")
@@ -35671,10 +37235,20 @@ function maybeFireHistorian(args) {
       provenInputTokens: resolvePiProvenInputFloor({
         db,
         sessionId,
-        modelKey: resolvePiContextModelKey(ctx)
+        modelKey: resolvePiContextModelKey(ctx),
+        readBranch: () => ctx.sessionManager.getBranch(),
+        providerInputLimit: piPressureEvidenceLimit(resolvePiWindowGeometry({
+          rawContextWindow: usageContextLimit,
+          rawContextWindowSource: usageContextWindowSource,
+          model: ctx.model,
+          detectedContextLimit
+        }))
       }) || undefined
     });
-    if (sessionMeta.lastContextPercentage > 0 && sessionMeta.lastInputTokens > 0) {
+    if (args.pressureSnapshot) {
+      usage = args.pressureSnapshot;
+      usageSource = "request snapshot";
+    } else if (sessionMeta.lastContextPercentage > 0 && sessionMeta.lastInputTokens > 0) {
       usage = {
         percentage: sessionMeta.lastContextPercentage,
         inputTokens: sessionMeta.lastInputTokens
@@ -35692,7 +37266,7 @@ function maybeFireHistorian(args) {
       };
       usageSource = "piUsage fallback";
     }
-    usage = resolvePiPressureSnapshotWithEstimateGuard({
+    usage = args.pressureSnapshot ?? resolvePiPressureSnapshotWithEstimateGuard({
       sessionId,
       source: "historian trigger",
       liveIsRawBranchEstimate: args.liveIsRawBranchEstimate,
@@ -35712,7 +37286,6 @@ function maybeFireHistorian(args) {
     readMessages: () => readPiSessionMessages(ctx),
     readMessagePage: (afterOrdinal, limit, finalWatermark) => readPiSessionMessagePage(ctx, afterOrdinal, limit, finalWatermark)
   };
-  const unregister = setRawMessageProvider2(sessionId, provider);
   const modelKey = liveModelBySession.get(sessionId);
   const triggerInputs = resolvePiHistorianTriggerInputs({
     db,
@@ -35723,6 +37296,20 @@ function maybeFireHistorian(args) {
   });
   const historianForceMaterializationPercentage = escalationBands(triggerInputs.executeThresholdPercentage).forceMaterializationPercentage;
   const boundaryContextLimit = triggerInputs.contextLimit;
+  if (isHistorianDrainBudgetSpent({
+    db,
+    sessionId,
+    contextLimit: boundaryContextLimit,
+    executeThresholdPercentage: triggerInputs.executeThresholdPercentage,
+    usagePercentage: usage.percentage
+  })) {
+    if (sessionMeta.compartmentInProgress) {
+      updateSessionMeta(db, sessionId, { compartmentInProgress: false });
+      sessionMeta.compartmentInProgress = false;
+    }
+    return;
+  }
+  const unregister = setRawMessageProvider2(sessionId, provider);
   const resolvePiBoundarySnapshot = (emergencyTailScale) => resolveProtectedTailBoundary(resolveBoundaryContext({
     db,
     sessionId,
@@ -35753,16 +37340,19 @@ function maybeFireHistorian(args) {
       }
       const failureCount = historianStateSnapshot.historianFailureCount;
       if (failureCount > 0) {
-        boundarySnapshot = resolveRunnablePiBoundarySnapshot();
-      }
-      const shouldRecoverOnFirstPass = failureCount > 0 && boundarySnapshot !== undefined && hasEligiblePiCompartmentHistory(db, sessionId, boundarySnapshot);
-      if (shouldRecoverOnFirstPass) {
         triggered = true;
-        sessionLog(sessionId, `historian recovery triggered on session load after ${failureCount} failure(s)`);
-        sendPiIgnoredNotification(ctx, `## Historian recovery
+        const prepareRecoveryBoundary = () => {
+          const snapshot = resolveRunnablePiBoundarySnapshot();
+          if (!hasEligiblePiCompartmentHistory(db, sessionId, snapshot))
+            return;
+          sessionLog(sessionId, `historian recovery triggered on session load after ${failureCount} failure(s)`);
+          sendPiIgnoredNotification(ctx, `## Historian recovery
 
 Historian previously failed ${failureCount} time(s), so Magic Context is retrying history comparting immediately after restart.`);
+          return snapshot;
+        };
         spawnPiHistorianRun({
+          startGuard: args.startGuard,
           pi: args.pi,
           ctx,
           sessionId,
@@ -35770,7 +37360,7 @@ Historian previously failed ${failureCount} time(s), so Magic Context is retryin
           historian,
           provider,
           unregister,
-          boundarySnapshot,
+          boundarySnapshot: prepareRecoveryBoundary,
           refreshBoundarySnapshot: resolveRunnablePiBoundarySnapshot,
           currentContextLimit: boundaryContextLimit,
           fallbackModelId: modelKey
@@ -35778,7 +37368,7 @@ Historian previously failed ${failureCount} time(s), so Magic Context is retryin
         return;
       }
     }
-    const trigger = checkCompartmentTrigger(db, sessionId, sessionMeta, usage, 0, triggerInputs.executeThresholdPercentage, triggerInputs.triggerBudget, triggerInputs.clearReasoningAge, triggerInputs.commitClusterTrigger, args.activeTags, boundaryContextLimit, () => readPiHistorianTail(db, sessionId, provider), args.taggerFloor, { canClearReasoning: true }, {
+    const trigger = checkCompartmentTrigger(db, sessionId, sessionMeta, usage, 0, triggerInputs.executeThresholdPercentage, triggerInputs.triggerBudget, triggerInputs.keepReasoningTokens, triggerInputs.commitClusterTrigger, args.activeTags, boundaryContextLimit, () => readPiHistorianTail(db, sessionId, provider), args.taggerFloor, { canClearReasoning: true }, {
       hardFold: false,
       force: usage.percentage >= historianForceMaterializationPercentage && (usage.percentage >= 95 || getEmergencyInputSample(db, sessionId) === 0),
       explicitFlush: hasPendingMaterialization(sessionId),
@@ -35805,6 +37395,7 @@ Historian previously failed ${failureCount} time(s), so Magic Context is retryin
     triggered = true;
     sessionLog(sessionId, `historian trigger fired (reason=${trigger.reason ?? "unknown"}) usage=${usage.percentage.toFixed(1)}% — spawning subagent`);
     spawnPiHistorianRun({
+      startGuard: args.startGuard,
       pi: args.pi,
       ctx,
       sessionId,
@@ -35926,8 +37517,21 @@ async function runCompactionOffPipeline(args) {
   };
 }
 async function runPipeline(args) {
+  args.assertCurrentPass?.();
   if (args.compactionOff)
     return runCompactionOffPipeline(args);
+  const thinkingRecovery = prepareLatestThinkingRecovery({
+    db: args.db,
+    sessionId: args.sessionId,
+    messages: args.messages,
+    id: (message, index) => resolvePiStableId(message, index, args.entryIds, args.entryIdByRef ?? undefined),
+    parts: (message) => Array.isArray(message?.content) ? message.content : []
+  });
+  if (thinkingRecovery.ended)
+    signalPiPendingMaterialization(args.sessionId);
+  let restoreOriginals;
+  const activeThinkingTurn = hasActiveAnthropicThinkingTurn(args.messages, args.resolvedProviderID, args.resolvedModelID);
+  const protectedSignedPrefix = activeThinkingTurn && args.reasoningClearing?.prefixBound === true;
   const stableIdResolver = (msg, index) => resolvePiStableId(msg, index, args.entryIds, args.entryIdByRef ?? undefined);
   let foldingSystemState = null;
   try {
@@ -36090,7 +37694,10 @@ async function runPipeline(args) {
   let preFoldInjectionResult = null;
   const persistedM0BeforeFold = injectionPassSnapshot?.sessionMeta ?? args.sessionMeta;
   const m0CoverageBeforeFold = persistedM0BeforeFold.cachedM0Bytes === null ? -1 : persistedM0BeforeFold.cachedM0MaxCompartmentSeq;
-  if ((foldDueDecision.value || softRefreshOpportunity) && piM0State) {
+  if (protectedSignedPrefix && piM0State) {
+    piM0State.preparedPrefix = prepareCachedM0M1PiReplay(piM0State, args.db, injectionPassSnapshot?.cachedRow);
+  }
+  if (!protectedSignedPrefix && (foldDueDecision.value || softRefreshOpportunity) && piM0State) {
     try {
       preFoldInjectionResult = injectM0M1PiForRun(piM0State, args.db, [], undefined, softRefreshOpportunity, injectionPassSnapshot);
       prefixPreflightContended = preFoldInjectionResult.contentionExhausted === true;
@@ -36171,17 +37778,31 @@ async function runPipeline(args) {
   let protectionFloorResolution = resolveProtectionFloor();
   const shouldRunHeuristics = args.heuristics !== undefined && isCacheBustingPass && (rideSignals.publishedHistory || args.forceMaterialization === true || hasPendingMaterializeSignal || deferredMaterializeEligible || foldBustsServedPrefixThisPass || firstRenderBust || rideSignals.subagentExecute || args.schedulerDecision === "execute" && !alreadyRanHeuristicsThisTurn);
   const tFallbackIdentity = performance.now();
+  const preflightRevision = readPiAdoptionRevision(args.db);
   const hasFallbackMessageTags = hasPiFallbackMessageTags2(args.db, args.sessionId);
   const entryFingerprintByMessageId = buildEntryFingerprintMap(args.messages, stableIdResolver, args.reusableMessageIds, hasFallbackMessageTags);
+  args.assertCurrentPass?.();
   adoptPiFallbackTags(args.db, args.sessionId, args.tagger, entryFingerprintByMessageId, {
     messages: args.messages,
     resolveStableId: stableIdResolver,
-    hasFallbackMessageTags
+    hasFallbackMessageTags,
+    preflightRevision,
+    rebuildFingerprints: !hasFallbackMessageTags && args.reusableMessageIds?.size ? () => {
+      args.assertCurrentPass?.();
+      const full = buildEntryFingerprintMap(args.messages, stableIdResolver);
+      for (const [id, fingerprint] of full)
+        entryFingerprintByMessageId.set(id, fingerprint);
+      return entryFingerprintByMessageId;
+    } : undefined
   });
   logTransformTiming(args.sessionId, "fallbackIdentityAndAdoption", tFallbackIdentity);
   afterFallbackAdoptionForTests?.(args.stableIdSchemeCutover === true);
   const textIdentityPlan = buildPiTextIdentityPlan(args.db, args.sessionId, args.tagger, transcript, args.reusableMessageIds);
   const tTag = performance.now();
+  const mutationView = transcript.messages.map((message) => ({
+    ...message,
+    parts: message.parts
+  }));
   let tagTextTokenCache = piTagTextTokenCacheBySession.get(args.sessionId);
   if (!tagTextTokenCache) {
     tagTextTokenCache = new Map;
@@ -36192,23 +37813,55 @@ async function runPipeline(args) {
     tagToolTokenCache = new Map;
     piTagToolTokenCacheBySession.set(args.sessionId, tagToolTokenCache);
   }
-  const { targets } = runPersistedReplayStage("tagging-persistence-failure", () => args.tagger.cleanup(args.sessionId), () => tagTranscript(args.sessionId, transcript, args.tagger, args.db, {
-    skipPrefixInjection: !ctxReduceCallable,
-    entryFingerprintByMessageId,
-    reuseMessageIds: textIdentityPlan.reusableMessageIds,
-    textIdentityDriftMessageIds: textIdentityPlan.driftedMessageIds,
-    textIdentitySourceCache: textIdentityPlan.sourceCache,
-    textTokenCache: tagTextTokenCache,
-    toolTokenCache: tagToolTokenCache,
-    onTiming: hasPiTransformTimingObserver() ? (phase, elapsedMs) => {
-      recordPiTransformTiming({
-        sessionId: args.sessionId,
-        stage: `tag:${phase}`,
-        elapsedMs
-      });
-    } : undefined
-  }));
+  const { targets } = runPersistedReplayStage("tagging-persistence-failure", () => args.tagger.cleanup(args.sessionId), () => {
+    args.assertCurrentPass?.();
+    return tagTranscript(args.sessionId, { ...transcript, messages: mutationView }, args.tagger, args.db, {
+      skipPrefixInjection: !ctxReduceCallable,
+      entryFingerprintByMessageId,
+      reuseMessageIds: textIdentityPlan.reusableMessageIds,
+      textIdentityDriftMessageIds: textIdentityPlan.driftedMessageIds,
+      textIdentitySourceCache: textIdentityPlan.sourceCache,
+      textTokenCache: tagTextTokenCache,
+      toolTokenCache: tagToolTokenCache,
+      onTiming: hasPiTransformTimingObserver() ? (phase, elapsedMs) => {
+        recordPiTransformTiming({
+          sessionId: args.sessionId,
+          stage: `tag:${phase}`,
+          elapsedMs
+        });
+      } : undefined
+    });
+  });
   logTransformTiming(args.sessionId, "tagMessages", tTag);
+  const reasoningTagsForProtection = buildMessageIdToMaxTag(targets);
+  const frozenThinkingForProtection = activeThinkingTurn ? frozenBindingEntryIds(args.db, args.sessionId) : new Set;
+  const protectedThinkingProxies = new Set;
+  if (activeThinkingTurn) {
+    for (let i = latestAssistantTurnStart(workingMessages);i < mutationView.length; i++) {
+      const id = stableIdResolver(workingMessages[i], i);
+      if (!thinkingRecovery.restore && id && frozenThinkingForProtection.has(id))
+        continue;
+      for (let p = 0;p < mutationView[i].parts.length; p++) {
+        const part = mutationView[i].parts[p];
+        if (part.kind !== "thinking")
+          continue;
+        const local = workingMessages[i].content?.[p];
+        if (!thinkingRecovery.restore && !local?.redacted && id && (reasoningTagsForProtection.get(id) ?? Infinity) <= (args.sessionMeta.clearedReasoningThroughTag ?? 0))
+          continue;
+        protectedThinkingProxies.add(part);
+      }
+    }
+  }
+  const newTargets = protectNewTagMutations(mutationView.map((message) => ({
+    info: message.info,
+    parts: message.parts
+  })), targets, protectedThinkingProxies, args.reasoningClearing?.prefixBound === true);
+  if (thinkingRecovery.restore) {
+    transcript.commit();
+    restoreOriginals = captureOriginalTurn(args.messages, (message) => message.content, (message, content) => {
+      message.content = content;
+    });
+  }
   if (foldBustsServedPrefixThisPass) {
     try {
       let converted = 0;
@@ -36264,7 +37917,7 @@ async function runPipeline(args) {
     pendingDecisionLogObserverForTests?.(pendingDecisionLog);
     try {
       const tApplyPending = performance.now();
-      pendingOpsDidMutate = applyPendingOperations(args.sessionId, args.db, targets, new Set([
+      pendingOpsDidMutate = applyPendingOperations(args.sessionId, args.db, newTargets, new Set([
         ...args.contextUsage.percentage >= 95 ? [] : protectedTagNumbersForPass,
         ...protectedToolTags
       ]), pendingOperationTags, pendingOps, [], new Set, (reduction) => droppedTokenReductions.push(reduction));
@@ -36277,7 +37930,8 @@ async function runPipeline(args) {
       pendingOpsAppliedThisPass = true;
       if (hasPendingMaterializeSignal) {
         if (args.heuristics === undefined) {
-          consumePendingMaterialization(args.sessionId);
+          if (!pendingOps.some((op) => newTargets.get(op.tagId)?.thinkingDropProtected))
+            consumePendingMaterialization(args.sessionId);
         }
       }
     } catch (err) {
@@ -36317,6 +37971,7 @@ async function runPipeline(args) {
     try {
       const tReplayReasoning = performance.now();
       const clearedReplay = replayClearedReasoningPi({
+        protectLatestTurn: false,
         db: args.db,
         sessionId: args.sessionId,
         messages: workingMessages,
@@ -36324,6 +37979,7 @@ async function runPipeline(args) {
         piMessageStableId: stableIdResolver
       });
       const inlineReplay = replayStrippedInlineThinkingPi({
+        protectLatestTurn: false,
         db: args.db,
         sessionId: args.sessionId,
         messages: workingMessages,
@@ -36365,7 +38021,7 @@ async function runPipeline(args) {
         clearEmergencyDropSample(args.db, args.sessionId);
       }
       routineCleanupApplied = (emergencyDropEligible ? args.contextUsage.percentage >= 95 || getEmergencyInputSample(args.db, args.sessionId) === 0 : args.sessionMeta.isSubagent || !routinePressureAlreadyApplied) || hasPendingMaterializeSignal || deferredMaterialize || independentMutationBeforeHeuristics;
-      heuristicsResult = applyPiHeuristicCleanup(args.sessionId, args.db, targets, args.messages, {
+      heuristicsResult = applyPiHeuristicCleanup(args.sessionId, args.db, newTargets, args.messages, {
         protectedTags: args.protectedTags,
         prepareToolRemovalMeasurements: transcript.prepareToolRemovalMeasurements,
         protectedToolTags,
@@ -36382,7 +38038,7 @@ async function runPipeline(args) {
         caveman: args.isSubagent ? undefined : args.heuristics.caveman
       }, activeTags, stableIdResolver);
       if (!routineCleanupApplied && heuristicsResult.emergencyDroppedTools > 0) {
-        const ridingCleanup = applyPiHeuristicCleanup(args.sessionId, args.db, targets, args.messages, {
+        const ridingCleanup = applyPiHeuristicCleanup(args.sessionId, args.db, newTargets, args.messages, {
           protectedTags: args.protectedTags,
           protectedToolTags,
           protectedCutoff: usesTokenProtection ? protectionWindowForPass.cutoff : undefined,
@@ -36421,7 +38077,8 @@ async function runPipeline(args) {
       heuristicsExecuted = true;
       executedWorkThisPass = true;
       if (hasPendingMaterializeSignal) {
-        consumePendingMaterialization(args.sessionId);
+        if (!pendingOps.some((op) => newTargets.get(op.tagId)?.thinkingDropProtected))
+          consumePendingMaterialization(args.sessionId);
       }
       if (currentTurnId !== null) {
         lastHeuristicsTurnIdBySession.set(args.sessionId, currentTurnId);
@@ -36438,6 +38095,7 @@ async function runPipeline(args) {
     }
   }
   let reasoningPersistenceFailed = false;
+  let reasoningBudgetCutoffThisPass = 0;
   if (args.reasoningClearing && shouldRunHeuristics && routineCleanupApplied) {
     const rollbackReasoning = captureReasoningMutationRollback(workingMessages);
     try {
@@ -36445,25 +38103,30 @@ async function runPipeline(args) {
       const prevWatermark = args.sessionMeta.clearedReasoningThroughTag ?? 0;
       const prefixBound = args.reasoningClearing.prefixBound === true;
       const bindingStripped = prefixBound ? frozenBindingEntryIds(args.db, args.sessionId) : new Set;
+      const nativeGone = getNativeReplayState(args.db, args.sessionId).reasoningIds;
       const maxCutoff = piReasoningClearCutoff({
+        protectLatestTurn: activeThinkingTurn,
         messages: workingMessages,
         messageIdToMaxTag,
-        clearReasoningAge: args.reasoningClearing.clearReasoningAge,
+        keepReasoningTokens: args.reasoningClearing.keepReasoningTokens ?? DEFAULT_KEEP_REASONING_TOKENS,
+        proseRatio: sessionDecisionCalibration(args.db, args.sessionId).proseRatio,
         piMessageStableId: stableIdResolver,
         prefixBound,
-        alreadyGone: (id) => bindingStripped.has(id)
+        anthropic: args.canUseEmptySentinels || prefixBound,
+        alreadyGone: (id) => bindingStripped.has(id) || nativeGone.has(id)
       });
+      reasoningBudgetCutoffThisPass = maxCutoff;
       const clearOutcome = clearOldReasoningPi({
+        protectLatestTurn: activeThinkingTurn,
         messages: workingMessages,
         messageIdToMaxTag,
-        clearReasoningAge: args.reasoningClearing.clearReasoningAge,
         piMessageStableId: stableIdResolver,
         maxCutoff
       });
       const stripOutcome = stripInlineThinkingPi({
+        protectLatestTurn: activeThinkingTurn,
         messages: workingMessages,
         messageIdToMaxTag,
-        clearReasoningAge: args.reasoningClearing.clearReasoningAge,
         piMessageStableId: stableIdResolver,
         maxCutoff: prefixBound ? 0 : maxCutoff
       });
@@ -36498,6 +38161,7 @@ async function runPipeline(args) {
   if (args.reasoningClearing && shouldRunHeuristics && routineCleanupApplied) {
     try {
       replayStrippedInlineThinkingPi({
+        protectLatestTurn: false,
         db: args.db,
         sessionId: args.sessionId,
         messages: workingMessages,
@@ -36516,7 +38180,7 @@ async function runPipeline(args) {
     const syntheticPendingOps = buildSyntheticToolReclaimOps({
       db: args.db,
       sessionId: args.sessionId,
-      targets,
+      targets: newTargets,
       watermark: reclaimMeta.toolReclaimWatermark ?? 0,
       protectedToolTags,
       pendingOps
@@ -36528,7 +38192,7 @@ async function runPipeline(args) {
       const supersessionOps = buildSupersessionReclaimOps({
         db: args.db,
         sessionId: args.sessionId,
-        targets,
+        targets: newTargets,
         pendingOps,
         recentMessageIds,
         protectedToolTags
@@ -36542,7 +38206,7 @@ async function runPipeline(args) {
       const editReclaim = buildEditSupersessionReclaim({
         db: args.db,
         sessionId: args.sessionId,
-        targets,
+        targets: newTargets,
         pendingOps,
         recentMessageIds,
         protectedToolTags
@@ -36557,7 +38221,7 @@ async function runPipeline(args) {
     }
     autoReclaimTargetCount = syntheticPendingOps.length;
     if (syntheticPendingOps.length > 0) {
-      autoReclaimDidMutate = applyPendingOperations(args.sessionId, args.db, targets, protectedTagNumbersForPass, undefined, [], syntheticPendingOps, editMarkerTagIds, (reduction) => droppedTokenReductions.push(reduction));
+      autoReclaimDidMutate = applyPendingOperations(args.sessionId, args.db, newTargets, protectedTagNumbersForPass, undefined, [], syntheticPendingOps, editMarkerTagIds, (reduction) => droppedTokenReductions.push(reduction));
       if (autoReclaimDidMutate) {
         droppedCount += syntheticPendingOps.length;
         autoReclaimDidMutateThisPass = true;
@@ -36620,7 +38284,7 @@ async function runPipeline(args) {
       messageIdToMaxTag,
       stableId: stableIdResolver,
       localWatermark: args.sessionMeta.clearedReasoningThroughTag ?? 0,
-      clearReasoningAge: args.reasoningClearing.clearReasoningAge,
+      budgetCutoff: reasoningBudgetCutoffThisPass,
       omissionAllowed: args.reasoningClearing.nativeReasoningMayClear,
       canApply: isCacheBustingPass && !reasoningPersistenceFailed,
       detectAged: shouldRunHeuristics && routineCleanupApplied
@@ -36713,6 +38377,7 @@ async function runPipeline(args) {
   let preserveDeferredMaterializationForMarkerDrain = false;
   if (deferredHistoryDrainEligible) {
     try {
+      args.assertCurrentPass?.();
       const pending = getPendingPiCompactionMarkerState(args.db, args.sessionId);
       if (!pending) {
         if (injectionResult?.contentionExhausted === true) {
@@ -36733,6 +38398,7 @@ async function runPipeline(args) {
         preserveDeferredMaterializationForMarkerDrain = true;
         sessionLog(args.sessionId, "Pi compaction-marker drain skipped: sessionManager appendCompaction/getBranch or folding system state unavailable; preserving deferred signals");
       } else {
+        args.assertCurrentPass?.();
         const outcome = applyDeferredPiCompactionMarker({
           db: args.db,
           appendCompaction: args.appendCompaction,
@@ -36775,6 +38441,7 @@ async function runPipeline(args) {
         }
       }
     } catch (err) {
+      args.assertCurrentPass?.();
       sessionLog(args.sessionId, `Pi compaction-marker drain failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
     }
   }
@@ -36812,6 +38479,7 @@ async function runPipeline(args) {
   } catch (err) {
     sessionLog(args.sessionId, `token accounting failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
   }
+  restoreOriginals?.(workingMessages);
   const materialized = injectionResult?.m0Materialized === true;
   if (args.reasoningClearing?.prefixBound && firstEditSourceOrder && firstEditParts.size > 0 && !prefixEditBesidesReasoningTrim) {
     const frozenThinking = frozenBindingEntryIds(args.db, args.sessionId);
@@ -36860,8 +38528,21 @@ async function runPipeline(args) {
   if (bustedThisPass || isCacheBustingPass) {
     droppedTokens = estimateDroppedTokensFromTagReductions(args.db, args.sessionId, droppedTokenReductions);
   }
+  const visibleCallIds = new Set;
+  for (const message of outputMessages) {
+    if (message.role === "toolResult")
+      visibleCallIds.add(message.toolCallId);
+    if (message.role === "assistant" && Array.isArray(message.content)) {
+      for (const part of message.content) {
+        if (part.type === "toolCall")
+          visibleCallIds.add(part.id);
+      }
+    }
+  }
+  const servedTagNumbers = new Set(allTagsForPass.filter((tag) => targets.has(tag.tagNumber) && (tag.type === "message" ? ctxReduceCallable || tag.status !== "active" : tag.type === "tool" && visibleCallIds.has(tag.messageId) && (ctxReduceCallable || tag.status !== "active"))).map((tag) => tag.tagNumber));
   return {
     messages: outputMessages,
+    servedTagNumbers,
     heuristicsExecuted,
     executedWorkThisPass,
     historyInjected: injectionResult?.injected ?? false,
@@ -37120,6 +38801,8 @@ function clearContextHandlerSession(sessionId) {
   deferredHistoryRefreshSessions.delete(sessionId);
   deferredMaterializationSessions.delete(sessionId);
   firstContextPassSeenBySession.delete(sessionId);
+  contextPassGeneration.delete(sessionId);
+  clearPiContextReceipt(sessionId);
   commitSeenLastPass.delete(sessionId);
   liveModelBySession.delete(sessionId);
   latestAssistantModelTimestampBySession.delete(sessionId);
@@ -37142,6 +38825,7 @@ function clearContextHandlerSession(sessionId) {
   routinePressureAppliedBySession.delete(sessionId);
   lastSeenProjectIdentityBySession.delete(sessionId);
   persistedProjectIdentityBySession.delete(sessionId);
+  sessionProjectBindingFailureLogAtBySession.delete(sessionId);
   for (const [projectIdentity, sessions] of sessionsByProject) {
     sessions.delete(sessionId);
     if (sessions.size === 0)
@@ -38318,6 +40002,19 @@ function updateStatusLine(ctx, deps, force = false) {
 function renderStatusText(ctx, db, sessionId) {
   const usage = ctx.getContextUsage?.();
   const meta = readSessionMetaStatus(db, sessionId);
+  const providerInputLimit = piPressureEvidenceLimit(resolvePiWindowGeometry({
+    rawContextWindow: usage?.contextWindow ?? ctx.model?.contextWindow,
+    rawContextWindowSource: "catalog",
+    model: ctx.model,
+    detectedContextLimit: meta?.detected_context_limit ?? undefined
+  }));
+  const provenInputTokens = resolvePiProvenInputFloor({
+    db,
+    sessionId,
+    modelKey: piProvenFloorModelKey(ctx.model),
+    readBranch: () => ctx.sessionManager.getBranch(),
+    providerInputLimit
+  });
   const liveInputTokens = typeof usage?.tokens === "number" && Number.isFinite(usage.tokens) ? usage.tokens : undefined;
   const persistedInputTokens = typeof meta?.last_input_tokens === "number" && Number.isFinite(meta.last_input_tokens) && meta.last_input_tokens >= 0 ? meta.last_input_tokens : undefined;
   const windowGeometry = resolvePiWindowGeometry({
@@ -38325,10 +40022,12 @@ function renderStatusText(ctx, db, sessionId) {
     rawContextWindowSource: "catalog",
     model: ctx.model,
     detectedContextLimit: typeof meta?.detected_context_limit === "number" && meta.detected_context_limit > 0 ? meta.detected_context_limit : undefined,
+    provenInputTokens: provenInputTokens || undefined,
     persistedInputTokens,
-    persistedPercentage: typeof meta?.last_context_percentage === "number" ? meta.last_context_percentage : undefined
+    persistedPercentage: meta?.last_context_percentage ?? undefined
   });
   const pressure = liveInputTokens !== undefined || persistedInputTokens !== undefined ? resolvePiStatusPressureSnapshot({
+    providerInputLimit,
     sessionId,
     persistedPercentage: meta?.last_context_percentage ?? 0,
     persistedInputTokens: persistedInputTokens ?? 0,
@@ -39564,7 +41263,17 @@ function statusSections(source, now) {
           value: String(source.protectedTagCount),
           tone: "muted"
         },
-        { label: "Subagent", value: source.isSubagent ? "yes" : "no", tone: "muted" }
+        { label: "Subagent", value: source.isSubagent ? "yes" : "no", tone: "muted" },
+        {
+          label: "Denominator",
+          value: `${Math.round(source.contextLimit)} tokens`,
+          tone: "muted"
+        },
+        {
+          label: "Window source",
+          value: formatWindowSource(source.windowGeometry),
+          tone: "muted"
+        }
       ]
     },
     { title: "Cache TTL", labelWidth: 14, rows: cacheRows(source, now) },
@@ -39736,7 +41445,7 @@ function buildStatusViewFor(check, options) {
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.46.1",
+  version: "0.47.0",
   type: "module",
   description: "Pi and OMP coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -39765,7 +41474,7 @@ var package_default = {
   ],
   "//": "The build intentionally bundles typebox (no --external typebox) and keeps it a regular dependency. OMP's extension loader rewrites every bare `typebox` import to its own omptype-based shim, whose schemas are callable objects rather than JSON Schema; they fail structuredClone during tool registration, so an external typebox import stops Magic Context loading on OMP. src/typebox-bundling.test.ts guards this.",
   scripts: {
-    build: "bun ../../scripts/check-bun.mjs && tsc -p ../retina-local-fs/tsconfig.build.json && bun ../../scripts/clean-dist-chunks.mjs dist index.js subagent-entry.js historian-calibration-extension.js transformers-web.js transformers-node-wasm.js && bun build ../plugin/src/features/magic-context/memory/transformers-web-entry.ts --outfile dist/transformers-web.js --target browser --format esm --external onnxruntime-web && bun ../plugin/scripts/build-transformers-node-wasm.ts dist && bun build src/index.ts src/subagent-entry.ts src/historian-calibration-extension.ts ../plugin/src/features/magic-context/memory/embedding-worker.ts ../plugin/src/features/magic-context/migration-worker.ts --outdir dist --entry-naming '[name].[ext]' --target node --format esm --splitting --external @earendil-works/pi-coding-agent --external @earendil-works/pi-tui --external onnxruntime-node --external onnxruntime-web --external sharp --external node:sqlite",
+    build: "bun ../../scripts/check-bun.mjs && tsc -p ../retina-local-fs/tsconfig.build.json && bun ../../scripts/clean-dist-chunks.mjs dist index.js subagent-entry.js historian-calibration-extension.js transformers-web.js transformers-node-wasm.js && bun build ../plugin/src/features/magic-context/memory/transformers-web-entry.ts --outfile dist/transformers-web.js --target browser --format esm --external onnxruntime-web && bun ../plugin/scripts/build-transformers-node-wasm.ts dist && bun build src/index.ts src/subagent-entry.ts src/historian-calibration-extension.ts ../plugin/src/features/magic-context/memory/embedding-worker.ts ../plugin/src/features/magic-context/migration-worker.ts ../plugin/src/hooks/magic-context/auto-search-worker.ts --outdir dist --entry-naming '[name].[ext]' --target node --format esm --splitting --external @earendil-works/pi-coding-agent --external @earendil-works/pi-tui --external onnxruntime-node --external onnxruntime-web --external sharp --external node:sqlite",
     "build:e2e-argv": `bun ../../scripts/clean-dist-chunks.mjs ../../tests/docker/.generated subagent-runner-e2e.mjs && bun build src/subagent-runner.ts --outdir ../../tests/docker/.generated --entry-naming 'subagent-runner-e2e.mjs' --splitting --target node --format esm --external node:sqlite && node --input-type=module -e 'const { __test } = await import("../../tests/docker/.generated/subagent-runner-e2e.mjs"); if (typeof __test.buildArgs !== "function" || typeof __test.resolvePiInvocation !== "function") throw new Error("argv renderer exports missing"); console.log("Node argv renderer: 2 exports loaded")'`,
     typecheck: "tsc -p ../retina-local-fs/tsconfig.build.json && tsc --noEmit",
     test: "bun ../../scripts/check-bun.mjs && bun install --frozen-lockfile && BUN_JSC_useOMGJIT=0 bun test --parallel=4 --timeout 30000",
@@ -39978,7 +41687,7 @@ function piStatusWarnings(s) {
   return warnings;
 }
 function formatPiStatusSummary(s) {
-  const summary = renderUserStatusSummary({
+  const summary = `${renderUserStatusSummary({
     inputTokens: s.inputTokens,
     usableContextTokens: s.contextLimit,
     usagePercentage: s.usagePercentage,
@@ -40001,7 +41710,9 @@ function formatPiStatusSummary(s) {
     embedding: s.embedding,
     warnings: piStatusWarnings(s),
     dreamerSkipped: s.dreamer.skipped
-  }, "plain");
+  }, "plain")}
+Window source: ${formatWindowSource(s.windowGeometry)}; denominator: ${Math.round(s.contextLimit)} tokens${s.reasoningBudgetLine ? `
+${s.reasoningBudgetLine}` : ""}`;
   return s.configGeneration === undefined ? summary : `${summary}
 Config generation: ${s.configGeneration} (adopted ${s.configAdoptedAt ? new Date(s.configAdoptedAt).toLocaleString() : "unknown"})${s.configReloadFailure ? `
 Config reload failed ${s.configReloadFailure.path}: ${s.configReloadFailure.message}` : ""}`;
@@ -40074,6 +41785,8 @@ function renderPiStatusOverlay(s, theme, innerWidth) {
   lines.push(renderSplitRow(theme.fg(PI_TONE_COLORS[view.headline.left.tone], theme.bold(view.headline.left.text)), theme.fg(PI_TONE_COLORS[view.headline.right.tone], view.headline.right.text), innerWidth));
   if (view.windowLine)
     lines.push(theme.fg("muted", view.windowLine));
+  if (s.reasoningBudgetLine)
+    lines.push(theme.fg("muted", s.reasoningBudgetLine));
   const bar = renderBar(view.bar, innerWidth);
   if (bar)
     lines.push(bar);
@@ -40083,6 +41796,13 @@ function renderPiStatusOverlay(s, theme, innerWidth) {
   if (view.hygiene) {
     lines.push(renderStatusRow(view.hygiene, 9, innerWidth, theme));
   }
+  if (status.state === "ready") {
+    lines.push(renderStatusRow({
+      label: "Historian runs",
+      value: s.historianRuns.toLocaleString(),
+      tone: "muted"
+    }, 9, innerWidth, theme));
+  }
   const upgrade = status.state !== "ready" ? null : s.recompInFlight ? { label: "Recomp", value: "running…", tone: "warning" } : s.upgradeNeededCount > 0 ? {
     label: "Recomp",
     value: `${s.upgradeNeededCount} compartment${s.upgradeNeededCount === 1 ? "" : "s"} in the old layout · run /ctx-recomp`,
@@ -40237,9 +41957,13 @@ function refreshLiveStatus(detail, state, ctx, usage, now) {
     rawContextWindow: usage?.contextWindow ?? ctx.model?.contextWindow,
     rawContextWindowSource: "catalog",
     model: ctx.model,
-    ...live
+    detectedContextLimit: live.detectedContextLimit,
+    provenInputTokens: live.provenInputTokens,
+    persistedInputTokens: live.persistedInputTokens,
+    persistedPercentage: live.persistedPercentage
   });
   const pressure = resolvePiStatusPressureSnapshot({
+    providerInputLimit: live.providerInputLimit,
     sessionId: detail.sessionId,
     persistedPercentage: live.persistedPercentage,
     persistedInputTokens: live.persistedInputTokens,
@@ -40290,20 +42014,37 @@ function buildStatusDetail(pi, ctx, deps, sessionId, state, host = readStatusHos
     if (detected > 0)
       detectedContextLimit = detected;
   } catch {}
+  const providerInputLimit = piPressureEvidenceLimit(resolvePiWindowGeometry({
+    rawContextWindow: usage?.contextWindow ?? ctx.model?.contextWindow,
+    rawContextWindowSource: "catalog",
+    model: ctx.model,
+    detectedContextLimit
+  }));
+  const provenInputTokens = resolvePiProvenInputFloor({
+    db: deps.db,
+    sessionId,
+    modelKey: piProvenFloorModelKey(ctx.model),
+    readBranch: () => ctx.sessionManager.getBranch(),
+    providerInputLimit
+  });
   state.live = {
     persistedInputTokens: meta.lastInputTokens,
     persistedPercentage: meta.lastContextPercentage,
-    detectedContextLimit
+    detectedContextLimit,
+    provenInputTokens: provenInputTokens || undefined,
+    providerInputLimit
   };
   const windowGeometry = resolvePiWindowGeometry({
     rawContextWindow: usage?.contextWindow ?? ctx.model?.contextWindow,
     rawContextWindowSource: "catalog",
     model: ctx.model,
     detectedContextLimit,
+    provenInputTokens: provenInputTokens || undefined,
     persistedInputTokens: meta.lastInputTokens,
     persistedPercentage: meta.lastContextPercentage
   });
   const pressure = resolvePiStatusPressureSnapshot({
+    providerInputLimit,
     sessionId,
     persistedPercentage: meta.lastContextPercentage,
     persistedInputTokens: meta.lastInputTokens,
@@ -40383,6 +42124,7 @@ function buildStatusDetail(pi, ctx, deps, sessionId, state, host = readStatusHos
   const compressionBudget = contextLimit > 0 ? Math.floor(contextLimit * (Math.min(threshold.percentage, 80) / 100) * historyBudgetPercentage) : null;
   return {
     sessionId,
+    reasoningBudgetLine: reasoningBudgetStatusLine(sessionId),
     activeProfile: deps.activeProfile ?? null,
     configGeneration: deps.configGeneration,
     configAdoptedAt: deps.configAdoptedAt,
@@ -40411,7 +42153,7 @@ function buildStatusDetail(pi, ctx, deps, sessionId, state, host = readStatusHos
     pendingOpsCount: pendingOps,
     compactionMarker: getCompactionMarkerHealth(deps.db, sessionId),
     historianRunning: meta.compartmentInProgress,
-    timesExecuteThresholdReached: meta.timesExecuteThresholdReached,
+    historianRuns: countHistorianRuns(deps.db, sessionId),
     historianFailureCount: Number(metaRow?.historian_failure_count ?? 0),
     historianLastFailureAt: typeof metaRow?.historian_last_failure_at === "number" ? metaRow.historian_last_failure_at : null,
     historianLastError: metaRow?.historian_last_error ?? null,
@@ -40578,14 +42320,13 @@ function buildStatusDetails(deps, status) {
     droppedTags: status.droppedTags,
     totalBytes: status.activeBytes,
     pendingOps: status.pendingOpsCount,
-    lastExecuteThreshold: status.timesExecuteThresholdReached,
     compartmentCount: status.compartmentCount,
     lastCompartmentRange: status.lastCompartmentRange,
     memoryCount: status.memoryCount,
     noteCount: status.sessionNoteCount + status.readySmartNoteCount,
     dreamer: status.dreamer,
     historian: {
-      lastFireCount: status.timesExecuteThresholdReached,
+      runs: status.historianRuns,
       inProgress: status.historianRunning,
       lastFailureAt: status.historianLastFailureAt,
       lastError: status.historianLastError,
@@ -41291,6 +43032,19 @@ function registerPiSubagentHostTools(pi, harness) {
   });
 }
 
+// src/timeout.ts
+function withTimeout(p, ms) {
+  let handle;
+  const timeout = new Promise((resolve) => {
+    handle = setTimeout(() => resolve(undefined), ms);
+    handle.unref?.();
+  });
+  return Promise.race([p, timeout]).finally(() => {
+    if (handle)
+      clearTimeout(handle);
+  });
+}
+
 // src/index.ts
 var PI_HARNESS_DETECTION = await resolvePiHarnessDetection();
 var PI_HARNESS_KIND = PI_HARNESS_DETECTION.kind;
@@ -41517,21 +43271,6 @@ function getPiMessageModel(message) {
     model: typeof msg.model === "string" ? msg.model : undefined
   };
 }
-var piUsageBoundLogSeen = new Set;
-function logPiUsageBoundOnce(sessionId, reading, absoluteWall, reason) {
-  const key = `${sessionId}|${reason}`;
-  if (piUsageBoundLogSeen.has(key))
-    return;
-  piUsageBoundLogSeen.add(key);
-  info(`message_end: session=${sessionId} bounded ${reason} ${reading} at trusted absolute wall ${absoluteWall}; pressure_proof_not_capacity`);
-}
-function logPiUsageAboveWindowOnce(sessionId, reading, absoluteWall) {
-  const key = `${sessionId}|accepted above window`;
-  if (piUsageBoundLogSeen.has(key))
-    return;
-  piUsageBoundLogSeen.add(key);
-  info(`message_end: session=${sessionId} provider usage ${reading} exceeds configured window ${absoluteWall}; counted as real pressure against the configured limit`);
-}
 function resolvePiPressureContextLimit(args) {
   let detectedContextLimit;
   try {
@@ -41561,25 +43300,29 @@ async function persistPiPressureFromMessageEnd(args) {
   const activeModel = args.piModel ?? { provider, id: model };
   const modelKey = activeModel.provider && activeModel.id ? piModelRefToCanonical(`${activeModel.provider}/${activeModel.id}`) : undefined;
   const usage = extractAssistantUsage(args.message);
+  const detectedContextLimit = getOverflowState(args.db, args.sessionId, modelKey).detectedContextLimit;
   const reportedGeometry = resolvePiWindowGeometry({
     rawContextWindow: args.piContextWindow,
     rawContextWindowSource: args.piContextWindowSource,
-    model: activeModel
+    model: activeModel,
+    detectedContextLimit
   });
-  const trustedAbsoluteWall = reportedGeometry && hasTrustedAbsoluteWall(reportedGeometry) ? reportedGeometry.derivation.absoluteWall : undefined;
-  const unboundedPressure = computePiPressure(usage, args.piContextWindow);
+  const providerInputLimit = piPressureEvidenceLimit(reportedGeometry);
+  const reportedInput = piUsageInputTokens(usage);
+  const rejectedUsage = reportedInput !== null && reportedInput > providerInputLimit;
+  if (reportedInput !== null)
+    recordPiProviderUsageValidity(args.sessionId, rejectedUsage);
+  const unboundedPressure = computePiPressure(usage, args.piContextWindow, providerInputLimit);
+  if (rejectedUsage) {
+    noteRejectedPiUsage(args.sessionId, reportedInput, providerInputLimit, "message_end");
+  }
   const msg = args.message && typeof args.message === "object" ? args.message : undefined;
   const messageHadOverflowError = typeof msg?.errorMessage === "string" && detectOverflow(msg.errorMessage).isOverflow;
-  const readingAboveTrustedWall = unboundedPressure !== null && trustedAbsoluteWall !== undefined && unboundedPressure.inputTokens > trustedAbsoluteWall;
-  const requestAccepted = !messageHadOverflowError;
-  if (readingAboveTrustedWall && unboundedPressure && trustedAbsoluteWall) {
-    if (requestAccepted) {
-      logPiUsageAboveWindowOnce(args.sessionId, unboundedPressure.inputTokens, trustedAbsoluteWall);
-    } else {
-      logPiUsageBoundOnce(args.sessionId, unboundedPressure.inputTokens, trustedAbsoluteWall, "current reading");
-    }
-  }
-  const requestSucceeded = requestAccepted && !readingAboveTrustedWall;
+  const requestAccepted = !messageHadOverflowError && !providerResponseFailed({
+    finish: args.message?.stopReason,
+    error: msg?.errorMessage
+  });
+  const requestSucceeded = requestAccepted && !rejectedUsage;
   if (requestAccepted && unboundedPressure) {
     const rawOverflow = getOverflowState(args.db, args.sessionId);
     const detectedLimitMatchesModel = rawOverflow.detectedContextLimitModelKey === null || modelKey !== undefined && rawOverflow.detectedContextLimitModelKey === modelKey;
@@ -41589,10 +43332,12 @@ async function persistPiPressureFromMessageEnd(args) {
     }
   }
   const floorModelKey = piProvenFloorModelKey(activeModel);
-  let observedSafeInputTokens = resolvePiProvenInputFloor({
+  const observedSafeInputTokens = resolvePiProvenInputFloor({
     db: args.db,
     sessionId: args.sessionId,
-    modelKey: floorModelKey
+    modelKey: floorModelKey,
+    readBranch: args.readBranch,
+    providerInputLimit
   });
   const meta = getOrCreateSessionMeta(args.db, args.sessionId);
   const updates = {};
@@ -41604,17 +43349,6 @@ async function persistPiPressureFromMessageEnd(args) {
   if (assistant?.role === "assistant" && !providerResponseFailed(completion) && (unboundedPressure !== null || isSuccessfulProviderCompletion(completion))) {
     updates.lastResponseTime = Math.max(meta.lastResponseTime, Date.now());
   }
-  if (trustedAbsoluteWall !== undefined && observedSafeInputTokens > trustedAbsoluteWall) {
-    logPiUsageBoundOnce(args.sessionId, observedSafeInputTokens, trustedAbsoluteWall, "persisted floor");
-    observedSafeInputTokens = 0;
-    updates.observedSafeInputTokens = 0;
-    updates.cacheAlertSent = false;
-    updates.lastUsageContextLimit = reportedGeometry?.usableSoft ?? 0;
-    if (meta.lastInputTokens > trustedAbsoluteWall) {
-      updates.lastInputTokens = trustedAbsoluteWall;
-      updates.lastContextPercentage = reportedGeometry && reportedGeometry.usableSoft > 0 ? trustedAbsoluteWall / reportedGeometry.usableSoft * 100 : 0;
-    }
-  }
   const effectiveContextLimit = resolvePiPressureContextLimit({
     db: args.db,
     sessionId: args.sessionId,
@@ -41623,8 +43357,13 @@ async function persistPiPressureFromMessageEnd(args) {
     model: activeModel,
     provenInputTokens: observedSafeInputTokens
   });
+  if (rejectedUsage) {
+    updates.lastInputTokens = 0;
+    updates.lastContextPercentage = 0;
+    updates.lastUsageContextLimit = effectiveContextLimit;
+  }
   const reportedContextLimit = reportedGeometry?.usableSoft ?? 0;
-  const pressure = computePiPressure(usage, effectiveContextLimit, requestAccepted ? undefined : trustedAbsoluteWall);
+  const pressure = computePiPressure(usage, effectiveContextLimit, providerInputLimit);
   let cacheAlert;
   if (pressure) {
     notePiUsageReadingUsed(args.sessionId);
@@ -41649,7 +43388,7 @@ async function persistPiPressureFromMessageEnd(args) {
     if (requestSucceeded) {
       updates.observedSafeInputTokens = provenSafeInputTokens;
     }
-  } else if (usage === null && typeof args.piTokens === "number" && (trustedAbsoluteWall === undefined || args.piTokens <= trustedAbsoluteWall)) {
+  } else if ((usage === null || rejectedUsage) && typeof args.piTokens === "number" && Number.isFinite(args.piTokens) && args.piTokens > 0 && args.piTokens <= providerInputLimit) {
     if (args.piTokensIsRawBranchEstimate === true) {
       noteRawBranchEstimateSetAside(args.sessionId, args.piTokens, "message_end estimate");
     } else {
@@ -41734,7 +43473,7 @@ function resolveHistorianFromConfig(config, harness = PI_HARNESS_KIND, modelRegi
     executeThresholdTokens: config.execute_threshold_tokens,
     commitClusterTrigger: config.commit_cluster_trigger,
     protectedTags: config.protected_tags,
-    clearReasoningAge: config.clear_reasoning_age,
+    keepReasoningTokens: config.keep_reasoning_tokens,
     historyBudgetPercentage: config.history_budget_percentage,
     memoryEnabled: config.memory.enabled,
     autoPromote: config.memory.auto_promote,
@@ -41980,7 +43719,7 @@ async function startPiMagicContextRuntime(hostPi, database, dbPath) {
         minChars: cfg.caveman_text_compression.min_chars,
         wordRules: cavemanWordRulesForLanguage(cfg.language)
       } : undefined,
-      clearReasoningAge: cfg.clear_reasoning_age
+      keepReasoningTokens: cfg.keep_reasoning_tokens
     },
     injection: {
       memoryEnabled: cfg.memory.enabled,
@@ -42675,6 +44414,7 @@ async function startPiMagicContextRuntime(hostPi, database, dbPath) {
         piContextWindow,
         piContextWindowSource: "catalog",
         piModel: ctx.model,
+        readBranch: () => ctx.sessionManager.getBranch(),
         piTokens: piUsage && typeof piUsage.tokens === "number" ? piUsage.tokens : undefined,
         piTokensIsRawBranchEstimate: isPiContextUsageRawBranchEstimate(ctx.sessionManager),
         notifyIssue: async (message) => {