@cortexkit/opencode-magic-context 0.49.18 → 0.49.20

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

@@ -6,7 +6,7 @@ import {
   resolveLegacyConfigSources,
   getProtectedTokensTierOverrides,
   loadPluginConfigDetailed
-} from "./server-nj659894.js";
+} from "./server-5arr9ecn.js";
 import {
   getHarness2,
   harnessOwnsOpenCodeStore2
@@ -21,7 +21,7 @@ import {
   log2,
   sessionLog2,
   getLoggerDiagnostics2
-} from "./server-f2xf5gcb.js";
+} from "./server-6495nmn9.js";
 import {
   hasTrustedAbsoluteWall,
   applyProvenInputFloor,
@@ -33,7 +33,7 @@ import {
   getSdkContextLimit,
   getSdkOutputLimit,
   getModelsDevCacheState
-} from "./server-tbe1femw.js";
+} from "./server-29qp8nz4.js";
 import {
   isValidLanguageCode,
   withContentLanguageDirective,
@@ -64,7 +64,7 @@ import {
   userMemoryCollectionEnabled2,
   userObservationCollectionEnabled2,
   userObservationsRequested2
-} from "./server-qd11g795.js";
+} from "./server-92g7d776.js";
 import {
   historianRunConfig,
   dreamerRunConfig,
@@ -127,6 +127,8 @@ import {
   hasProcessLocalLkgProof,
   lkgDirtyRevision,
   rememberLkgDirtyRevision,
+  readPersistedLkgUntaggedInputIds,
+  persistLkgUntaggedInputIds,
   noteLkgRecoveryPrefix,
   readLkgRecoveryPrefix,
   noteLkgHealthyPrefix,
@@ -203,11 +205,15 @@ import {
   parseProviderModel,
   modelBodyField,
   toModelEntry,
+  ModelProducedNoOutputError,
+  noteModelActivityMonitored,
+  noteModelOutputReceived,
   isPromptTimeoutError,
   getPromptFailureDetail,
   raceWithSignal,
   promptSyncWithValidatedOutputRetry,
   normalizeSDKResponse,
+  annotateSubagentInvocationError,
   failedInvocationStatus,
   sumTokensFromChildMessages,
   recordChildInvocation,
@@ -280,10 +286,10 @@ import {
   startCompartmentAgent,
   setRecompStarting2,
   setRecompTerminal2
-} from "./server-bfpda1tb.js";
+} from "./server-c7dxxsj7.js";
 import {
   resolveHistorianModel2
-} from "./server-8cd2j99z.js";
+} from "./server-5kym00ag.js";
 import {
   formatFailClosedBlockingMessage,
   formatFailClosedBlockingSummary,
@@ -305,7 +311,7 @@ import {
   openDatabaseAsync,
   isDatabasePersisted,
   getDatabasePersistenceError
-} from "./server-a2eqhkxr.js";
+} from "./server-hqzyq8n4.js";
 import {
   pruneMissingProjectIdentities,
   setHomeProjectPermission,
@@ -322,7 +328,7 @@ import {
   storedPathBelongsToIdentity,
   beginBootQuietPeriod,
   scheduleAfterBootQuiet
-} from "./server-rmygf5pn.js";
+} from "./server-ne8arh8t.js";
 import {
   detectLatestTurnThinkingMismatch,
   isPrefixBoundThinkingModel,
@@ -418,6 +424,8 @@ import {
   applyStrippedPlaceholderDelta,
   THINKING_BINDING_RECOVERY_FROZEN_PREFIX,
   thinkingBindingRecoveryFrozenId,
+  compactionOffThinkingFrozenId,
+  compactionOffFrozenThinkingIds,
   getThinkingBindingRecoveryTarget,
   clearThinkingBindingRecoveryIf,
   getMergedReasoningStrippedIds,
@@ -515,7 +523,7 @@ import {
   readRawSessionMessageById2,
   readSessionChunk2,
   readRawSessionSeedTail2
-} from "./server-xhab8jx8.js";
+} from "./server-ej96a39v.js";
 import {
   embedPauseBySession,
   embedRunStateBySession,
@@ -544,7 +552,7 @@ import {
   embedSessionCompartmentChunks2,
   getEmbeddingCoverageStatus2,
   getAutoEmbeddingSessionCoverage2
-} from "./server-8by8qfec.js";
+} from "./server-0epqaxhd.js";
 import {
   textMentionsRecentCommit,
   hasMeaningfulUserText2,
@@ -555,7 +563,7 @@ import {
   estimateTokens,
   estimateFixedPromptTokens,
   normalizeText
-} from "./server-tgnbmwah.js";
+} from "./server-3mz2qh5a.js";
 import {
   SubcClient,
   connectionFileExists,
@@ -563,7 +571,7 @@ import {
   toSynapseLaneDescriptor,
   formatSynapseLaneDescriptor,
   SynapseEmbeddingProvider
-} from "./server-6tmj0s7j.js";
+} from "./server-af2pght7.js";
 import {
   inRootAsyncContext2,
   getTagIdentityWriteGeneration2,
@@ -577,30 +585,34 @@ import {
   isTransientSqliteError2,
   SqliteAcquisitionBusyError2,
   withAsyncPrivilegedWriter2
-} from "./server-beht37jy.js";
+} from "./server-1zx2pa5d.js";
 import"./server-51779zs2.js";
+import {
+  createWorkerShutdown
+} from "./server-cpjk5jd2.js";
 import {
   isRawCompactionSummaryInfo2,
   extractInMemoryMessageViews2,
   buildInMemoryTailRawMessages2,
   RawOrdinalsNotReady2,
   runSessionWarmupWorker
-} from "./server-xj136kt8.js";
-import"./server-1wy7b9de.js";
+} from "./server-55rgxfrw.js";
+import"./server-br1x0tev.js";
 import {
-  deleteChunkEmbedBackoffForSession
-} from "./server-46neh5fa.js";
+  deleteChunkEmbedBackoffForSession2
+} from "./server-wyawsa88.js";
 import {
   registerOwnRpcServerInstance,
   rpcPortDir,
   rpcPortFilePath,
   parseRpcPortFile,
   inspectProcessesAsync
-} from "./server-da07v4xp.js";
+} from "./server-k3t06fxr.js";
 import {
   BoundedSessionMap,
   LkgRecoveryFenceError,
   lkgServedArrayDigest,
+  takeLkgRecoveryLockSweepPage,
   hasCleanLkgRecoveryFence,
   dirtyLkgRecoveryRevision,
   ownsLkgDirtyFence,
@@ -621,7 +633,7 @@ import {
   isMessageIndexReconciledThrough2,
   indexMessagesAfterOrdinal2,
   sweepOrphanedOpenCodeMessageIndexesCooperatively2
-} from "./server-2ehj0bw7.js";
+} from "./server-63fqdghs.js";
 import {
   stableStringify,
   getTemporalDecisions,
@@ -629,7 +641,7 @@ import {
   freezeTemporalDecisions,
   tagRevisionKey,
   tagIdentityRevisionKey
-} from "./server-pwv4ezb0.js";
+} from "./server-168pb207.js";
 import {
   resolveModelCalibration,
   calibrateBuckets,
@@ -724,7 +736,7 @@ import {
   adoptNullOwnerToolTag2,
   getCandidateToolOwners2,
   pickNearestPriorOwner2
-} from "./server-27gq4mfz.js";
+} from "./server-a3dwxfgd.js";
 import {
   resolveOpenCodeDbPath,
   assertOpenCodeStoreGeneration,
@@ -740,12 +752,12 @@ import {
   latestRealUserTurnIdFromOpenCodeDb,
   getMessageTimesFromOpenCodeDb,
   findLastAssistantModelFromOpenCodeDb
-} from "./server-n1prf1g6.js";
+} from "./server-brj8j2gk.js";
 import {
   getCurrentToolSetHash,
   recordToolDefinition,
   getMeasuredToolDefinitionTokens
-} from "./server-g3qma5c0.js";
+} from "./server-dj7tz4ph.js";
 import {
   V2_MEMORY_CATEGORIES,
   CATEGORY_PRIORITY
@@ -758,7 +770,7 @@ import {
   resolveStoredPathWorkspaceIdentity,
   storedPathBelongsToWorkspace,
   computeWorkspaceEpochFingerprint
-} from "./server-gpvay0xz.js";
+} from "./server-9x0kmta4.js";
 import {
   configureContextDatabasePragmas2
 } from "./server-fb3zxn06.js";
@@ -804,15 +816,15 @@ import {
   readGitFileChangeTimesSince,
   verificationFileExists,
   normalizeVerificationFiles
-} from "./server-my7k4eds.js";
+} from "./server-vn2nwcv6.js";
 import {
   deriveTriggerBudget2,
   deriveHistorianChunkTokens2,
   resolveKnownHistorianContextLimit2,
   resolveHistorianProducerLimits2,
   resolveHistorianContextLimit2
-} from "./server-34kwfsr4.js";
-import"./server-d04vrx0j.js";
+} from "./server-53eh1r8r.js";
+import"./server-ygtykank.js";
 import {
   isEmbeddingHostBusy2
 } from "./server-qt1qqasc.js";
@@ -825,18 +837,20 @@ import {
   releaseGitSweepLease,
   recordSessionProjectIdentity,
   hasRecordedSessionProjectIdentity
-} from "./server-hy3d3vsx.js";
+} from "./server-4nw4fqhr.js";
 import {
   saveEmbeddingIfHashMatches,
   invalidateProject2,
   invalidateMemory2
 } from "./server-4dhv7mqz.js";
 import {
+  getCachedLocalEmbeddingPooling,
+  preflightLocalEmbeddingPooling,
   getLocalEmbeddingNativeMemoryStats
-} from "./server-h1v0pyxb.js";
+} from "./server-j4jnp9b5.js";
 import {
   cosineSimilarity
-} from "./server-zzkj2fch.js";
+} from "./server-xsryvyf6.js";
 import {
   computeCueContentHash,
   hasMuralCueColumns,
@@ -861,7 +875,7 @@ import {
   mergeMemoryStats2,
   archiveMemory2,
   getMemoryCountsByStatus2
-} from "./server-n37sebck.js";
+} from "./server-y4a3nhtk.js";
 import {
   registerNotificationSink2,
   pushNotification2,
@@ -869,11 +883,11 @@ import {
   drainNotifications2,
   isTuiConnected2
 } from "./server-x8a7jmkh.js";
-import"./server-h0410h0v.js";
+import"./server-1bw1wcbp.js";
 import {
   flushIgnoredMessages2,
   sendStatusNotification2
-} from "./server-a9xqj88f.js";
+} from "./server-230fnbws.js";
 import {
   renderSingleStoreMigrationRequiredRefusal,
   SingleStoreMigrationRequiredError,
@@ -893,14 +907,14 @@ import {
   resolveMemoriesByIdsForSearch2,
   unifiedSearch2,
   formatSearchResults2
-} from "./server-1nyybqan.js";
+} from "./server-m91f9m5s.js";
 import {
   resolvePromptContext2
 } from "./server-fmsr7v69.js";
 import"./server-kaqs6h31.js";
 import {
   renderSearchArchiveOffThread2
-} from "./server-qv7f0hhe.js";
+} from "./server-4sxjs6hn.js";
 import {
   compareSemverCore
 } from "./server-84w6rvvf.js";
@@ -940,7 +954,7 @@ import {
 } from "./server-8ajstryz.js";
 import {
   logSlowWriteTransaction
-} from "./server-6pmqg9m4.js";
+} from "./server-gyy4k6mf.js";
 import {
   shouldEnforcePrivateStoragePermissions,
   ensureStorageDirectorySync,
@@ -3178,7 +3192,7 @@ function dropCompartmentsAfter(db, sessionId, anchor, holderId, activeBranch = f
       if (marker && clearPendingPiCompactionMarkerStateIf(db, sessionId, marker, null))
         clearedMarker = marker;
     }
-    deleteChunkEmbedBackoffForSession(db, sessionId);
+    deleteChunkEmbedBackoffForSession2(db, sessionId);
     queueM0Mutation(db, { sessionId, mutationType: "recomp_boundary_change" });
     clearCachedM0M1(db, sessionId);
     db.exec("COMMIT");
@@ -3437,6 +3451,11 @@ function scheduleReconciliation(db, sessionId, readMessages) {
   });
 }
 async function sweepOrphanedOpenCodeMessageIndexesOffThread(db, openSource, options = {}) {
+  if (getHarness2() === "opencode" || getHarness2() === "opencode2")
+    options = {
+      ...options,
+      fenceLockNames: options.fenceLockNames ?? takeLkgRecoveryLockSweepPage()
+    };
   if (getHarness2() === "opencode2")
     openSource = () => new Database2(gaDatabasePath(getDataDir(), process.env.OPENCODE_CHANNEL ?? "latest"), {
       readonly: true,
@@ -4141,7 +4160,8 @@ ${trimmedBody}…
   return wrapped;
 }
 function selectAutoSearchResults(results, threshold) {
-  return results.filter((result) => (result.relevanceScore ?? result.score) >= threshold);
+  const relevance = (result) => result.relevanceScore ?? result.score;
+  return results.filter((result) => relevance(result) >= threshold).sort((left, right) => relevance(right) - relevance(left));
 }
 
 // src/hooks/magic-context/auto-search-worker-client.ts
@@ -4234,6 +4254,13 @@ function retryUnpublishedAutoSearchNoHint(db, sessionId, messageId, startedAt) {
   }
   return true;
 }
+
+class AutoSearchBusyError extends Error {
+  constructor() {
+    super("an earlier auto-search of this session is still running");
+    this.name = "AutoSearchBusyError";
+  }
+}
 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");
 }
@@ -4242,14 +4269,19 @@ var searchWorkers = new WeakMap;
 var liveSearchWorkers = new Set;
 var MAX_IDLE_SEARCH_WORKERS = 4;
 var SEARCH_WORKER_IDLE_MS = 5 * 60000;
+var DETACHED_SEARCH_LIMIT_MS = 30000;
+var AUTO_SEARCH_WORKER_CLOSE_DEADLINE_MS = 2000;
 var workersCreated = 0;
 var workersReused = 0;
+var searchesSkippedBusy = 0;
 async function acquireSearchWorker(db, key, entry, input, signal) {
   const pool = searchWorkers.get(db) ?? new Map;
   searchWorkers.set(db, pool);
   while (!signal.aborted) {
     let slot = pool.get(key);
     if (slot?.busy) {
+      if (input.job === "search" && (slot.detached || slot.busySessionId === input.sessionId))
+        return "busy";
       const current = slot;
       await new Promise((resolve) => {
         const done = () => {
@@ -4258,6 +4290,8 @@ async function acquireSearchWorker(db, key, entry, input, signal) {
         };
         signal.addEventListener("abort", done, { once: true });
         current.busy?.then(done);
+        if (!current.detached)
+          current.detachedSignal?.then(done);
         if (signal.aborted)
           done();
       });
@@ -4266,14 +4300,16 @@ async function acquireSearchWorker(db, key, entry, input, signal) {
     const fresh = !slot;
     if (!slot) {
       const worker = inRootAsyncContext2(() => new Worker(entry, { workerData: { ...input, persistent: true } }));
+      const shutdown = createWorkerShutdown(worker, "auto-search", AUTO_SEARCH_WORKER_CLOSE_DEADLINE_MS);
       slot = {
         worker,
         dispose() {
+          this.disposed = true;
           clearTimeout(this.idleTimer);
           if (pool.get(key) === this)
             pool.delete(key);
           liveSearchWorkers.delete(this);
-          worker.terminate();
+          shutdown.close();
           worker.unref();
         }
       };
@@ -4287,9 +4323,14 @@ async function acquireSearchWorker(db, key, entry, input, signal) {
       workersReused++;
     clearTimeout(slot.idleTimer);
     const current = slot;
+    current.busySessionId = input.sessionId;
+    current.detached = false;
     current.busy = new Promise((resolve) => {
       current.release = resolve;
     });
+    current.detachedSignal = new Promise((resolve) => {
+      current.markDetached = resolve;
+    });
     current.worker.ref();
     return { slot: current, fresh };
   }
@@ -4298,6 +4339,9 @@ async function acquireSearchWorker(db, key, entry, input, signal) {
 function queueAutoSearchBackfill(db, sessionId, projectPath, query) {
   if (isEmbeddingHostBusy2())
     return Promise.resolve();
+  const snapshot = getProjectEmbeddingSnapshot2(projectPath);
+  if (!snapshot?.enabled || !snapshot.features.memoryEnabled)
+    return Promise.resolve();
   const key = `${sessionId}\x00${projectPath}`;
   const pending = pendingBackfills.get(db) ?? new Map;
   pendingBackfills.set(db, pending);
@@ -4345,6 +4389,7 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     signal: deadlineSignal,
     readMessages: _readMessages,
     searchMessageHistory: _searchMessageHistory,
+    stepTimings: _stepTimings,
     ...serializable
   } = options;
   const lifecycle = registerAutoSearchWork(sessionId);
@@ -4380,30 +4425,55 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     lifecycle.done();
     return [];
   }
+  if (lease === "busy") {
+    lifecycle.done();
+    searchesSkippedBusy++;
+    throw new AutoSearchBusyError;
+  }
   const { slot, fresh } = lease;
   const worker = slot.worker;
+  const detachable = job === "search" && entry.href === defaultAutoSearchWorkerEntry().href;
+  const startedAt = performance.now();
+  let detachedAt;
+  let ownerVectorMs;
+  let abandonTimer;
   return new Promise((resolve, reject) => {
     let settled = false;
-    const finish = (results, error) => {
+    let released = false;
+    const settle = (results, error) => {
       if (settled)
         return;
       settled = true;
+      if (error)
+        reject(error);
+      else
+        resolve(results);
+    };
+    const release = (dispose) => {
+      if (released)
+        return;
+      released = true;
+      clearTimeout(abandonTimer);
       signal?.removeEventListener("abort", abort);
       lifecycle.signal.removeEventListener("abort", abort);
       lifecycle.done();
       worker.off("message", onMessage);
       worker.off("error", onError);
       worker.off("exit", onExit);
-      if (error || signal.aborted || entry.href !== defaultAutoSearchWorkerEntry().href)
+      if (dispose || !detachable)
         slot.dispose();
-      else {
+      else if (!slot.disposed) {
         slot.idleTimer = setTimeout(() => slot.dispose(), SEARCH_WORKER_IDLE_MS);
         slot.idleTimer.unref?.();
       }
-      const release = slot.release;
+      const free = slot.release;
       slot.busy = undefined;
       slot.release = undefined;
-      release?.();
+      slot.busySessionId = undefined;
+      slot.detached = false;
+      slot.detachedSignal = undefined;
+      slot.markDetached = undefined;
+      free?.();
       const reusable = liveSearchWorkers.delete(slot);
       if (reusable)
         liveSearchWorkers.add(slot);
@@ -4411,51 +4481,82 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
       for (const prior of idle.slice(0, Math.max(0, idle.length - MAX_IDLE_SEARCH_WORKERS)))
         prior.dispose();
       worker.unref();
-      if (error)
-        reject(error);
-      else
-        resolve(results);
     };
-    const abort = () => finish([]);
+    const finish = (results, error) => {
+      settle(results, error);
+      release(Boolean(error) || signal.aborted);
+    };
+    const abort = () => {
+      if (lifecycle.signal.aborted || !detachable) {
+        finish([]);
+        return;
+      }
+      if (settled)
+        return;
+      detachedAt = performance.now();
+      slot.detached = true;
+      slot.markDetached?.();
+      settle([]);
+      abandonTimer = setTimeout(() => {
+        log2(`[auto-search] session ${sessionId}: search still running ${DETACHED_SEARCH_LIMIT_MS} ms after its deadline; disposing its worker (owner vector wait ${formatMs(ownerVectorMs)})`);
+        release(true);
+      }, DETACHED_SEARCH_LIMIT_MS);
+      abandonTimer.unref?.();
+    };
     signal?.addEventListener("abort", abort, { once: true });
     lifecycle.signal.addEventListener("abort", abort, { once: true });
     const onError = (error) => finish([], error);
     const onExit = (code) => finish([], new Error(`auto-search worker exited (${code})`));
     const onMessage = async (reply) => {
-      if (settled)
+      if (released)
         return;
-      if (reply.kind === "result") {
+      if (reply.kind === "result" || reply.kind === "error") {
+        if (detachedAt !== undefined) {
+          logLateSearch(sessionId, performance.now() - detachedAt, detachedAt - startedAt, ownerVectorMs, reply.kind === "result" ? reply.timings : undefined, reply.kind === "error");
+          release(reply.kind === "error");
+          return;
+        }
+        if (reply.kind === "error") {
+          finish([], new Error(reply.error));
+          return;
+        }
         if (snapshot && getProjectEmbeddingSnapshot2(projectPath)?.generation !== snapshot.generation)
           finish([]);
         else
           finish(reply.results);
         return;
       }
-      if (reply.kind === "error") {
-        finish([], new Error(reply.error));
-        return;
-      }
       if (reply.kind === "messages" || reply.kind === "accepted")
         return;
       const response = { id: reply.id };
-      try {
+      if (!signal.aborted) {
+        const requestedAt = performance.now();
+        try {
+          if (reply.kind === "query")
+            response.result = await (job === "backfill" ? embedTextForProject2(projectPath, reply.text, signal, "query") : boundedHintEmbedding(embedQuery, reply.text, signal)) ?? null;
+          else {
+            const passage = await embedBatchForProject2(projectPath, reply.texts, signal, reply.purpose);
+            const current = getProjectEmbeddingSnapshot2(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);
+        }
         if (reply.kind === "query")
-          response.result = await (job === "backfill" ? embedTextForProject2(projectPath, reply.text, signal, "query") : boundedHintEmbedding(embedQuery, reply.text, signal)) ?? null;
-        else {
-          const passage = await embedBatchForProject2(projectPath, reply.texts, signal, reply.purpose);
-          const current = getProjectEmbeddingSnapshot2(projectPath);
-          response.passage = passage && current ? {
-            ...passage,
-            providerIdentity: current.providerIdentity,
-            runtimeFingerprint: current.runtimeFingerprint,
-            dimensions: passage.vectors.find((vector) => vector !== null)?.length ?? null
-          } : null;
+          ownerVectorMs = performance.now() - requestedAt;
+        if (signal.aborted) {
+          response.result = undefined;
+          response.passage = undefined;
+          response.error = undefined;
         }
-      } catch (error) {
-        response.error = error instanceof Error ? error.message : String(error);
       }
       response.embeddingHostBusy = isEmbeddingHostBusy2();
-      if (!settled && !signal?.aborted) {
+      if (!released) {
         try {
           worker.postMessage(response);
         } catch (error) {
@@ -4477,6 +4578,15 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     }
   });
 }
+function formatMs(value) {
+  return value === undefined ? "n/a" : `${Math.round(value)} ms`;
+}
+function logLateSearch(sessionId, lateMs, waitedMs, ownerVectorMs, timings, failed) {
+  const steps = timings?.steps;
+  const warm = timings?.lastPoolWarm;
+  const pool = warm ? `last pool refresh ${warm.outcome} in ${formatMs(warm.totalMs)} (probe ${formatMs(warm.probeMs)}, read ${formatMs(warm.readMs)}, decode ${formatMs(warm.decodeMs)}, ${warm.probedRows} rows probed, ${warm.decodedRows} decoded)` : "no pool refresh yet";
+  log2(`[auto-search] session ${sessionId}: deadline passed after ${formatMs(waitedMs)}; the search ${failed ? "failed" : "finished"} ${formatMs(lateMs)} later. Steps: message FTS ${formatMs(steps?.messageMs)}, vector wait ${formatMs(steps?.vectorWaitMs)} (owner embedding ${formatMs(ownerVectorMs)}), chunk lane ${formatMs(steps?.chunkMs)} (pool ${steps?.chunkPool ?? "n/a"}), other lanes ${formatMs(steps?.otherLanesMs)}, job ${formatMs(timings?.jobMs)}; ${pool}`);
+}
 async function boundedHintEmbedding(embed, text, signal) {
   const controller = new AbortController;
   const combined = AbortSignal.any([signal, controller.signal]);
@@ -4500,6 +4610,7 @@ function defaultAutoSearchWorkerEntry() {
 }
 var MESSAGE_WORKER_ACCEPT_TIMEOUT_MS = 400;
 var MESSAGE_WORKER_RESULT_TIMEOUT_MS = 30000;
+var MESSAGE_SEARCH_WORKER_CLOSE_DEADLINE_MS = 2000;
 var messageSearchWorkerFallbacks = new Map;
 function searchMessageHistoryOffThread(db, request, entry = defaultAutoSearchWorkerEntry(), deadlines = {}) {
   const fallback = (reason, detail) => {
@@ -4527,6 +4638,7 @@ function searchMessageHistoryOffThread(db, request, entry = defaultAutoSearchWor
   return new Promise((resolve) => {
     let settled = false;
     let worker;
+    let shutdown;
     let deadline;
     const finish = (outcome, reason, detail) => {
       if (settled)
@@ -4535,7 +4647,7 @@ function searchMessageHistoryOffThread(db, request, entry = defaultAutoSearchWor
       clearTimeout(deadline);
       if (reason)
         fallback(reason, detail);
-      worker?.terminate();
+      shutdown?.close();
       worker?.unref();
       resolve(outcome);
     };
@@ -4546,6 +4658,7 @@ function searchMessageHistoryOffThread(db, request, entry = defaultAutoSearchWor
     };
     try {
       worker = inRootAsyncContext2(() => new Worker(entry, { workerData: input }));
+      shutdown = createWorkerShutdown(worker, "message-search", MESSAGE_SEARCH_WORKER_CLOSE_DEADLINE_MS);
     } catch (error) {
       finish(null, "start-failed", error);
       return;
@@ -4814,7 +4927,8 @@ async function runAutoSearchHint(args) {
           },
           isEmbeddingRuntimeEnabled: () => embeddingEnabled === true,
           visibleMemoryIds: options.visibleMemoryIds ?? null,
-          sources: ["memory", "message", "git_commit"]
+          sources: ["memory", "message", "git_commit"],
+          chunkPoolWarmOnly: true
         };
         return searchAutoHint(db, sessionId, options.projectPath, rawPrompt, {
           ...searchOptions,
@@ -4825,6 +4939,11 @@ async function runAutoSearchHint(args) {
     } catch (error) {
       if (lifecycleSignal.aborted)
         return AUTO_SEARCH_OK;
+      if (error instanceof AutoSearchBusyError) {
+        sessionLog2(sessionId, "auto-search: an earlier search of this session is still running, skipping hint for this turn");
+        persistAutoSearchSkip(db, sessionId, userMsgId);
+        return { ok: false, kind: "timeout" };
+      }
       log2(`[auto-search] unified search failed for session ${sessionId} (no-hint frozen for this turn): ${error instanceof Error ? error.message : String(error)}`);
       const outcome = await writeNoHintAndReconcile("error");
       return outcome.ok ? { ok: false, kind: "search-failure" } : outcome;
@@ -4874,7 +4993,7 @@ ${hintText}`;
       if (outcome.decision.decision === "hint") {
         appendReminderToUserMessageById(messages, userMsgId, outcome.decision.text);
       }
-      sessionLog2(sessionId, `auto-search: attached hint to ${userMsgId} (${results.length} fragments, top score ${results[0].score.toFixed(3)})`);
+      sessionLog2(sessionId, `auto-search: attached hint to ${userMsgId} (${results.length} fragments, top relevance ${(results[0].relevanceScore ?? results[0].score).toFixed(3)})`);
       return AUTO_SEARCH_OK;
     } finally {
       if (!lifecycleSignal.aborted && results !== null)
@@ -4931,6 +5050,30 @@ function getSessionErrorInfo(properties) {
   };
 }
 
+// src/hooks/magic-context/diagnostic-log-state.ts
+var states = new BoundedSessionMap(1000);
+var scope = (sessionId) => `${getMagicContextStorageDir()}\x00${getHarness2()}\x00${sessionId}`;
+function diagnosticStateChanged(sessionId, category, state) {
+  const key = scope(sessionId);
+  const previous = states.get(key) ?? new Map;
+  if (previous.get(category) === state)
+    return false;
+  previous.set(category, state);
+  states.set(key, previous);
+  return true;
+}
+function clearDiagnosticLogState(sessionId) {
+  states.delete(scope(sessionId));
+}
+
+// src/hooks/magic-context/nudge-evaluation-log.ts
+function logNudgeEvaluation(sessionId, phase, line) {
+  const category = `${phase}:${line.split(":", 1)[0]}`;
+  const state = line.split(" ").filter((field) => /^(ctx_reduce|band|dampening|verdict|reason|lease)=/.test(field)).join(" ");
+  if (diagnosticStateChanged(sessionId, category, state))
+    sessionLog2(sessionId, line);
+}
+
 // src/features/magic-context/dreamer/storage-task-schedule.ts
 function toRow(r) {
   return {
@@ -5807,7 +5950,7 @@ function canConsumeDeferredOnThisPass(args) {
   return args.schedulerDecision === "execute" || args.contextPercentage >= (args.forceMaterializationPercentage ?? escalationBands(65).forceMaterializationPercentage);
 }
 function hasReclaimRide(signals) {
-  return signals.hardFold || signals.force || signals.explicitFlush || signals.publishedHistory || signals.subagentExecute === true;
+  return signals.hardFold || signals.force || signals.explicitFlush || signals.publishedHistory || signals.subagentExecute === true || signals.executeReclaim === true;
 }
 function prefixMutationPermitted(gate) {
   return !gate.signedThinkingHold || gate.firstRender || gate.idleExpiry || gate.emergency;
@@ -5820,13 +5963,233 @@ var RECLAIM_RIDE_NAMES = [
   "force",
   "explicitFlush",
   "publishedHistory",
-  "subagentExecute"
+  "subagentExecute",
+  "executeReclaim"
 ];
 function reclaimRideLabel(signals) {
   const active = RECLAIM_RIDE_NAMES.filter((name) => signals[name]);
   return `ride=${active.length > 0 ? active.join("+") : "none"}`;
 }
 
+// src/hooks/magic-context/pending-drop-eligibility.ts
+function pendingDropVeto(tagNumber, target, protectedTagIds) {
+  if (protectedTagIds.has(tagNumber))
+    return "protected";
+  if (target?.thinkingDropProtected)
+    return "active_thinking";
+  return null;
+}
+function capturePendingDropEligibility(targets, protectedTagIds) {
+  const eligible = new Set;
+  for (const [number, target] of targets) {
+    if (pendingDropVeto(number, target, protectedTagIds))
+      continue;
+    if (target.drop) {
+      if (target.canDrop?.() === true)
+        eligible.add(number);
+    } else {
+      const content = target.getContent?.();
+      const replacement = `[dropped §${number}§]`;
+      if (typeof content === "string" && content.length > replacement.length && target.canSetContent?.(replacement) !== false)
+        eligible.add(number);
+    }
+  }
+  return eligible;
+}
+function pendingDropEligibilityKey(db, sessionId, input, protectionInputs) {
+  const digests = input.map((message) => message.contentDigest?.() ?? null);
+  if (digests.some((digest) => digest === null))
+    return null;
+  const revision = db.prepare("SELECT value FROM schema_migrations_meta WHERE key = ?").get(tagRevisionKey(sessionId));
+  if (!revision?.value)
+    return null;
+  return JSON.stringify([
+    input.map((message, index) => [
+      message.id,
+      message.role,
+      message.synthetic,
+      digests[index]
+    ]),
+    revision.value,
+    readEpochFloorSnapshot(db, sessionId),
+    sessionDecisionCalibration(db, sessionId).toolsRatio,
+    loadProtectedTailMeta(db, sessionId),
+    [...getMergedReasoningStrippedIds(db, sessionId)].sort(),
+    [...getReasoningRemovalState(db, sessionId).messageIds].sort(),
+    protectionInputs
+  ]);
+}
+function createPendingDropEligibilityCache() {
+  const sessions = new Map;
+  return {
+    read(sessionId, key) {
+      const previous = sessions.get(sessionId);
+      if (key === null || previous?.key !== key) {
+        sessions.delete(sessionId);
+        return;
+      }
+      return previous.eligible;
+    },
+    record(sessionId, key, eligible) {
+      sessions.delete(sessionId);
+      if (key === null)
+        return;
+      const oldest = sessions.keys().next().value;
+      if (sessions.size >= 64 && oldest !== undefined)
+        sessions.delete(oldest);
+      sessions.set(sessionId, { key, eligible: new Set(eligible) });
+    }
+  };
+}
+
+// src/hooks/magic-context/postprocess-read-cache.ts
+var connections = new WeakMap;
+function snapshot(db, sessionId) {
+  const transaction = db;
+  try {
+    if (transaction.inTransaction || transaction.isTransaction) {
+      connections.delete(db);
+      return { version: -1, changes: -1 };
+    }
+  } catch {
+    connections.delete(db);
+    return { version: -1, changes: -1 };
+  }
+  let connection = connections.get(db);
+  if (!connection) {
+    connection = {
+      stamp: db.prepare("SELECT total_changes() AS changes, data_version AS version FROM pragma_data_version"),
+      sessions: new BoundedSessionMap(100)
+    };
+    connections.set(db, connection);
+  }
+  const stamp = connection.stamp.get();
+  const previous = connection.sessions.get(sessionId);
+  if (previous?.version === stamp.version && previous.changes === stamp.changes) {
+    return previous;
+  }
+  const value = { ...stamp };
+  connection.sessions.set(sessionId, value);
+  return value;
+}
+function postprocessTailTags(db, sessionId) {
+  const state = snapshot(db, sessionId);
+  return state.tags ??= getTailHygieneTags2(db, sessionId);
+}
+function postprocessOldestTags(db, sessionId, protectedNumbers) {
+  const state = snapshot(db, sessionId);
+  const hints = state.hints;
+  if (hints && hints.protectedNumbers.size === protectedNumbers.size && [...protectedNumbers].every((number) => hints.protectedNumbers.has(number))) {
+    return hints.value;
+  }
+  const value = getOldestActiveUnprotectedToolTags2(db, sessionId, protectedNumbers);
+  state.hints = { protectedNumbers: new Set(protectedNumbers), value };
+  return value;
+}
+function postprocessReplaySnapshot(db, sessionId) {
+  const state = snapshot(db, sessionId);
+  const replay = state.replay ??= loadPostprocessReplaySnapshot(db, sessionId);
+  return {
+    ...replay,
+    staleReduceStrippedIds: new Set(replay.staleReduceStrippedIds),
+    processedImageStrippedIds: new Set(replay.processedImageStrippedIds),
+    processedImageMarkers: new Map(replay.processedImageMarkers),
+    strippedPlaceholderIds: new Set(replay.strippedPlaceholderIds),
+    hiddenSeamPlaceholderIds: new Set(replay.hiddenSeamPlaceholderIds),
+    mergedReasoningStrippedIds: new Set(replay.mergedReasoningStrippedIds),
+    trailingBlankDecisions: new Map(replay.trailingBlankDecisions),
+    noteNudgeAnchors: structuredClone(replay.noteNudgeAnchors),
+    autoSearchHintDecisions: structuredClone(replay.autoSearchHintDecisions),
+    todoSyntheticAnchor: structuredClone(replay.todoSyntheticAnchor),
+    pendingCompactionMarker: structuredClone(replay.pendingCompactionMarker),
+    compactionMarker: structuredClone(replay.compactionMarker)
+  };
+}
+
+// src/hooks/magic-context/execute-reclaim.ts
+var NAMESPACE = "executeReclaim";
+var failedWrites = new WeakMap;
+function readExecuteReclaimState(db, sessionId) {
+  return parseState(postprocessReplaySnapshot(db, sessionId).executeReclaim);
+}
+function parseState(lane) {
+  const value = lane;
+  return {
+    heldPasses: typeof value?.heldPasses === "number" ? Math.max(0, value.heldPasses) : 0,
+    floorOrdinal: typeof value?.floorOrdinal === "number" ? value.floorOrdinal : null,
+    floorPromptId: typeof value?.floorPromptId === "string" ? value.floorPromptId : null
+  };
+}
+function writeExecuteReclaimState(db, sessionId, patch) {
+  if (failedWrites.get(db)?.has(sessionId))
+    return false;
+  try {
+    const current = readExecuteReclaimState(db, sessionId);
+    if (JSON.stringify(current) === JSON.stringify({ ...current, ...patch }))
+      return true;
+    if (!updateReplayDocument(db, sessionId, (doc) => {
+      const previous = parseState(doc[NAMESPACE]);
+      const state = { ...previous, ...patch };
+      if (JSON.stringify(previous) === JSON.stringify(state))
+        return false;
+      doc.version = 2;
+      doc[NAMESPACE] = state;
+      return true;
+    }))
+      throw new Error("Could not persist execute reclaim state");
+    return true;
+  } catch (error) {
+    let failed = failedWrites.get(db);
+    if (!failed)
+      failedWrites.set(db, failed = new Set);
+    failed.add(sessionId);
+    sessionLog2(sessionId, `execute reclaim state persistence failed; retaining existing policy: ${String(error)}`);
+    return false;
+  }
+}
+function clearExecuteReclaimState(db, sessionId) {
+  writeExecuteReclaimState(db, sessionId, {
+    heldPasses: 0,
+    floorOrdinal: null,
+    floorPromptId: null
+  });
+}
+function maintainExecuteFloorMark(db, sessionId, promptId, belowExecute) {
+  failedWrites.get(db)?.delete(sessionId);
+  const state = readExecuteReclaimState(db, sessionId);
+  if (state.floorOrdinal !== null && (belowExecute || promptId !== null && promptId !== state.floorPromptId)) {
+    writeExecuteReclaimState(db, sessionId, { floorOrdinal: null, floorPromptId: null });
+  }
+}
+function estimateExecuteReclaimTokens(args) {
+  const eligible = capturePendingDropEligibility(args.targets, args.protectedTagIds);
+  const queued = new Set(args.pendingOps.filter((op) => op.operation === "drop").map((op) => op.tagId));
+  const candidates = args.tags.filter((tag) => tag.status === "active" && queued.has(tag.tagNumber) && eligible.has(tag.tagNumber));
+  const preparationTargets = new Map;
+  for (const tag of candidates) {
+    const target = args.targets.get(tag.tagNumber);
+    if (target?.prepareDrop)
+      preparationTargets.set(tag.tagNumber, target);
+  }
+  const prepared = preparationTargets.size === 0 ? new Set : args.probePreparation?.(preparationTargets) ?? new Set([...preparationTargets].filter(([, target]) => target.prepareDrop?.() !== false).map(([number]) => number));
+  const seed = sessionDecisionCalibration(args.db, args.sessionId);
+  return candidates.reduce((total, tag) => {
+    if (preparationTargets.has(tag.tagNumber) && !prepared.has(tag.tagNumber))
+      return total;
+    const ratio = tag.type === "tool" ? seed.toolsRatio : seed.proseRatio;
+    return total + Math.max(0, (tag.tokenCount ?? Math.ceil(tag.byteSize / 4)) * ratio);
+  }, 0);
+}
+function originateExecuteReclaim(args) {
+  if (failedWrites.get(args.db)?.has(args.sessionId))
+    return false;
+  const state = readExecuteReclaimState(args.db, args.sessionId);
+  const heldPasses = args.primaryExecute && args.reclaimableTokens > 0 && !args.alreadyBusting ? state.heldPasses + 1 : 0;
+  if (!writeExecuteReclaimState(args.db, args.sessionId, { heldPasses }))
+    return false;
+  return args.primaryExecute && !args.alreadyBusting && !args.summaryCanCome && args.reclaimableTokens > 0 && (args.usableWindow > 0 && args.reclaimableTokens >= args.usableWindow * 0.02 || heldPasses >= 3);
+}
+
 // src/hooks/magic-context/historian-drain-gate.ts
 var loggedWindows = new WeakMap;
 function isHistorianDrainBudgetSpent(args) {
@@ -5978,7 +6341,7 @@ function resolveBoundaryContextLimit(usage, fallbackContextLimit) {
   }
   return 128000;
 }
-function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, inMemoryTail, taggerFloor = 0) {
+function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, inMemoryTail, taggerFloor = 0, liftLivePromptFloor = false) {
   return withRawSessionMessageCache2(() => {
     try {
       const memoryPrimed = inMemoryTail ? primeInMemoryTailRawMessageCache2({
@@ -6008,7 +6371,8 @@ function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThr
         executeThresholdPercentage,
         usage,
         usageSource: "live",
-        taggerFloor
+        taggerFloor,
+        liftLivePromptFloor
       });
       const hasProtectedEligibleHead = boundary.offset < Math.min(boundary.protectedTailStart, boundary.eligibleEndOrdinal);
       if (!hasProtectedEligibleHead) {
@@ -6044,7 +6408,10 @@ 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, keepReasoningTokens, commitClusterTrigger, preloadedActiveTags, contextLimit, inMemoryTail, taggerFloorOverride, reasoningProjection, reclaimRide, eligiblePendingDropTagIds) {
+function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPercentage, executeThresholdPercentage, triggerBudget, keepReasoningTokens, commitClusterTrigger, preloadedActiveTags, contextLimit, inMemoryTail, taggerFloorOverride, reasoningProjection, reclaimRide, eligiblePendingDropTagIds, primaryExecute = false) {
+  if (usage.percentage < executeThresholdPercentage) {
+    writeExecuteReclaimState(db, sessionId, { floorOrdinal: null, floorPromptId: null });
+  }
   if (sessionMeta.compartmentInProgress) {
     sessionLog2(sessionId, `compartment trigger: skipped — historian already in progress (usage=${usage.percentage.toFixed(1)}%)`);
     return { shouldFire: false };
@@ -6097,7 +6464,22 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
       resolvedInMemoryTail = undefined;
     }
   }
-  const tailInfo = getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, resolvedInMemoryTail, taggerFloor);
+  let tailInfo = getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, resolvedInMemoryTail, taggerFloor);
+  const markState = readExecuteReclaimState(db, sessionId);
+  const mark = markState.floorOrdinal;
+  const livePromptOrdinal = tailInfo.boundarySnapshot?.diagnostics?.livePromptFloor.ordinal;
+  let consumedFloorMark = false;
+  if (mark !== null) {
+    const consumed = writeExecuteReclaimState(db, sessionId, {
+      floorOrdinal: null,
+      floorPromptId: null
+    });
+    if (consumed && mark === livePromptOrdinal && markState.floorPromptId === tailInfo.boundarySnapshot?.diagnostics?.livePromptFloor.messageId && usage.percentage >= executeThresholdPercentage) {
+      consumedFloorMark = true;
+      sessionLog2(sessionId, `compartment trigger: live-prompt floor mark consumed at ${mark}`);
+      tailInfo = getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, resolvedInMemoryTail, taggerFloor, true);
+    }
+  }
   if (!tailInfo.hasNewRawHistory) {
     try {
       const lastCompartmentEnd = getLastCompartmentEndMessage(db, sessionId);
@@ -6181,7 +6563,21 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
     return { shouldFire: false };
   }
   if (!tailInfo.hasProtectedEligibleHead || !tailInfo.isMeaningful) {
-    sessionLog2(sessionId, `compartment trigger: not firing at ${usage.percentage.toFixed(1)}% because unsummarized tail from ${tailInfo.nextStartOrdinal} is too small`);
+    let floorOnly = false;
+    const boundary = tailInfo.boundarySnapshot;
+    const floor = boundary?.diagnostics?.livePromptFloor;
+    if (!consumedFloorMark && floor?.ordinal && floor.from > floor.to) {
+      const withoutFloor = getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, resolvedInMemoryTail, taggerFloor, true);
+      floorOnly = withoutFloor.hasProtectedEligibleHead && withoutFloor.isMeaningful;
+      if (floorOnly && primaryExecute && usage.percentage >= executeThresholdPercentage && writeExecuteReclaimState(db, sessionId, {
+        floorOrdinal: floor.ordinal,
+        floorPromptId: floor.messageId ?? null
+      })) {
+        sessionLog2(sessionId, `compartment trigger: live-prompt floor mark set at ${floor.ordinal}`);
+      }
+    }
+    const refusal = floorOnly ? `no eligible head (live-prompt floor at ${floor?.ordinal})` : tailInfo.hasProtectedEligibleHead ? "below meaningfulness" : "no eligible head";
+    sessionLog2(sessionId, `compartment trigger: not firing at ${usage.percentage.toFixed(1)}% — ${refusal}; offset=${tailInfo.nextStartOrdinal} protectedStart=${boundary?.protectedTailStart ?? "none"} eligibleEnd=${boundary?.eligibleEndOrdinal ?? "none"} rawTokens=${tailInfo.trueRawEligibleTokens} chunkTokens=${tailInfo.tokenEstimate}`);
     return { shouldFire: false };
   }
   sessionLog2(sessionId, `compartment trigger: proactive fire at ${usage.percentage.toFixed(1)}% (floor=${proactiveTriggerPercentage}% projected post-drop=${formatProjectedPostDropPercentage(projectedPostDropPercentage)} target=${relativePostDropTarget.toFixed(1)}%)`);
@@ -6434,7 +6830,7 @@ function maybeInjectChannel1Nudge(args, sessionId, tool, output) {
     evaluable: state.evaluable,
     generationInvalidated: state.generationInvalidated
   });
-  sessionLog2(sessionId, formatChannel1Evaluation(decision));
+  logNudgeEvaluation(sessionId, "tool-completion", formatChannel1Evaluation(decision));
   setLastNudgeUndropped(args.db, sessionId, decision.nextLastNudge);
   const nextNudgeState = {
     ...nudgeState,
@@ -6691,6 +7087,9 @@ function latestAssistantTurnStart(messages) {
 function latestAssistantTurnMessages(messages) {
   return new Set(messages.slice(latestAssistantTurnStart(messages)));
 }
+function isAnthropicThinkingPart(part, familyRoute) {
+  return isRecord(part) && THINKING_TYPES.has(String(part.type ?? part.kind)) && (familyRoute || isRecord(part.metadata) && isRecord(part.metadata.anthropic));
+}
 function hasActiveAnthropicThinkingTurn(messages, provider, model) {
   const familyRoute = isAnthropicFamilyRoute(provider, model);
   for (const message of messages.slice(latestAssistantTurnStart(messages))) {
@@ -6699,7 +7098,7 @@ function hasActiveAnthropicThinkingTurn(messages, provider, model) {
     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))))
+    if (parts.some((part) => isAnthropicThinkingPart(part, familyRoute)))
       return true;
   }
   return false;
@@ -7036,96 +7435,26 @@ function resolveHistoryBudgetTokens(historyBudgetPercentage, contextUsage, execu
 }
 
 // src/features/magic-context/storage-host-instruction-retention.ts
-var NAMESPACE = "hostInstructionRetention";
+var NAMESPACE2 = "hostInstructionRetention";
 var enabled = true;
 function hostInstructionRetentionEnabled() {
   return enabled;
 }
 function isHostInstructionRetentionOn(db, sessionId) {
-  const lane = readReplayEnvelope(db, sessionId)[NAMESPACE];
+  const lane = readReplayEnvelope(db, sessionId)[NAMESPACE2];
   return typeof lane === "object" && lane !== null && lane.on === true;
 }
 function markHostInstructionRetention(db, sessionId) {
   return updateReplayDocument(db, sessionId, (doc) => {
-    const lane = doc[NAMESPACE];
+    const lane = doc[NAMESPACE2];
     if (typeof lane === "object" && lane !== null && lane.on === true)
       return false;
     doc.version = 2;
-    doc[NAMESPACE] = { on: true };
+    doc[NAMESPACE2] = { on: true };
     return true;
   });
 }
 
-// src/hooks/magic-context/pending-drop-eligibility.ts
-function pendingDropVeto(tagNumber, target, protectedTagIds) {
-  if (protectedTagIds.has(tagNumber))
-    return "protected";
-  if (target?.thinkingDropProtected)
-    return "active_thinking";
-  return null;
-}
-function capturePendingDropEligibility(targets, protectedTagIds) {
-  const eligible = new Set;
-  for (const [number, target] of targets) {
-    if (pendingDropVeto(number, target, protectedTagIds))
-      continue;
-    if (target.drop) {
-      if (target.canDrop?.() === true)
-        eligible.add(number);
-    } else {
-      const content = target.getContent?.();
-      if (typeof content === "string" && content.length > `[dropped §${number}§]`.length)
-        eligible.add(number);
-    }
-  }
-  return eligible;
-}
-function pendingDropEligibilityKey(db, sessionId, input, protectionInputs) {
-  const digests = input.map((message) => message.contentDigest?.() ?? null);
-  if (digests.some((digest) => digest === null))
-    return null;
-  const revision = db.prepare("SELECT value FROM schema_migrations_meta WHERE key = ?").get(tagRevisionKey(sessionId));
-  if (!revision?.value)
-    return null;
-  return JSON.stringify([
-    input.map((message, index) => [
-      message.id,
-      message.role,
-      message.synthetic,
-      digests[index]
-    ]),
-    revision.value,
-    readEpochFloorSnapshot(db, sessionId),
-    sessionDecisionCalibration(db, sessionId).toolsRatio,
-    loadProtectedTailMeta(db, sessionId),
-    [...getMergedReasoningStrippedIds(db, sessionId)].sort(),
-    [...getReasoningRemovalState(db, sessionId).messageIds].sort(),
-    protectionInputs
-  ]);
-}
-function createPendingDropEligibilityCache() {
-  const sessions = new Map;
-  return {
-    read(sessionId, key) {
-      const previous = sessions.get(sessionId);
-      if (key === null || previous?.key !== key) {
-        sessions.delete(sessionId);
-        return;
-      }
-      return previous.eligible;
-    },
-    record(sessionId, key, eligible) {
-      sessions.delete(sessionId);
-      if (key === null)
-        return;
-      const oldest = sessions.keys().next().value;
-      if (sessions.size >= 64 && oldest !== undefined)
-        sessions.delete(oldest);
-      sessions.set(sessionId, { key, eligible: new Set(eligible) });
-    }
-  };
-}
-
 // src/hooks/magic-context/apply-operations.ts
 var RECENT_TOOL_SKELETON_WINDOW = 20;
 function buildReplacementContent(tagId) {
@@ -7411,12 +7740,16 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
               }
             } else if (target) {
               const replacement = buildReplacementContent(pendingOp.tagId);
+              if (target.canSetContent?.(replacement) === false) {
+                reject("content_unchanged");
+                continue;
+              }
               persistDrop();
               mutations.push(() => {
                 const priorContent = target.getContent?.();
                 const changed = target.setContent(replacement);
-                record(changed);
                 if (changed) {
+                  record(true);
                   const originalCharacters = typeof priorContent === "string" ? priorContent.length : tagById.get(pendingOp.tagId)?.byteSize ?? replacement.length;
                   onTagReduced?.({
                     tagNumber: pendingOp.tagId,
@@ -7679,14 +8012,14 @@ function foldExecutesThisPass(foldDue, materialized) {
 }
 
 // src/features/magic-context/storage-caveman-rules.ts
-var NAMESPACE2 = "caveman";
+var NAMESPACE3 = "caveman";
 var CURRENT_RULES_VERSION = 2;
 var ORIGINAL_RULES = {
   currentRules: false,
   englishWordRules: true,
   legacyReasoningTags: new Set
 };
-function parseState(lane) {
+function parseState2(lane) {
   if (!isRecord(lane) || lane.rules !== CURRENT_RULES_VERSION)
     return ORIGINAL_RULES;
   const tags = Array.isArray(lane.legacyReasoningTags) ? lane.legacyReasoningTags : [];
@@ -7698,7 +8031,7 @@ function parseState(lane) {
 }
 function getCavemanReplayState(db, sessionId) {
   try {
-    return parseState(readReplayEnvelope(db, sessionId)[NAMESPACE2]);
+    return parseState2(readReplayEnvelope(db, sessionId)[NAMESPACE3]);
   } catch (error) {
     if (error instanceof ReplayDocumentError)
       return ORIGINAL_RULES;
@@ -7708,11 +8041,11 @@ function getCavemanReplayState(db, sessionId) {
 function recordCavemanCurrentRules(db, sessionId, englishWordRules, legacyReasoningTags) {
   const tags = [...new Set(legacyReasoningTags)].sort((a, b) => a - b);
   const persisted = updateReplayDocument(db, sessionId, (doc) => {
-    const current = parseState(doc[NAMESPACE2]);
+    const current = parseState2(doc[NAMESPACE3]);
     if (current.currentRules && current.englishWordRules === englishWordRules)
       return false;
     doc.version = 2;
-    doc[NAMESPACE2] = {
+    doc[NAMESPACE3] = {
       rules: CURRENT_RULES_VERSION,
       legacyReasoningTags: current.currentRules ? [...current.legacyReasoningTags].sort((a, b) => a - b) : tags,
       ...englishWordRules ? {} : { englishWordRules: false }
@@ -8196,70 +8529,6 @@ function isVisibleNoteReadPart(part) {
   return false;
 }
 
-// src/hooks/magic-context/postprocess-read-cache.ts
-var connections = new WeakMap;
-function snapshot(db, sessionId) {
-  const transaction = db;
-  try {
-    if (transaction.inTransaction || transaction.isTransaction) {
-      connections.delete(db);
-      return { version: -1, changes: -1 };
-    }
-  } catch {
-    connections.delete(db);
-    return { version: -1, changes: -1 };
-  }
-  let connection = connections.get(db);
-  if (!connection) {
-    connection = {
-      stamp: db.prepare("SELECT total_changes() AS changes, data_version AS version FROM pragma_data_version"),
-      sessions: new BoundedSessionMap(100)
-    };
-    connections.set(db, connection);
-  }
-  const stamp = connection.stamp.get();
-  const previous = connection.sessions.get(sessionId);
-  if (previous?.version === stamp.version && previous.changes === stamp.changes) {
-    return previous;
-  }
-  const value = { ...stamp };
-  connection.sessions.set(sessionId, value);
-  return value;
-}
-function postprocessTailTags(db, sessionId) {
-  const state = snapshot(db, sessionId);
-  return state.tags ??= getTailHygieneTags2(db, sessionId);
-}
-function postprocessOldestTags(db, sessionId, protectedNumbers) {
-  const state = snapshot(db, sessionId);
-  const hints = state.hints;
-  if (hints && hints.protectedNumbers.size === protectedNumbers.size && [...protectedNumbers].every((number) => hints.protectedNumbers.has(number))) {
-    return hints.value;
-  }
-  const value = getOldestActiveUnprotectedToolTags2(db, sessionId, protectedNumbers);
-  state.hints = { protectedNumbers: new Set(protectedNumbers), value };
-  return value;
-}
-function postprocessReplaySnapshot(db, sessionId) {
-  const state = snapshot(db, sessionId);
-  const replay = state.replay ??= loadPostprocessReplaySnapshot(db, sessionId);
-  return {
-    ...replay,
-    staleReduceStrippedIds: new Set(replay.staleReduceStrippedIds),
-    processedImageStrippedIds: new Set(replay.processedImageStrippedIds),
-    processedImageMarkers: new Map(replay.processedImageMarkers),
-    strippedPlaceholderIds: new Set(replay.strippedPlaceholderIds),
-    hiddenSeamPlaceholderIds: new Set(replay.hiddenSeamPlaceholderIds),
-    mergedReasoningStrippedIds: new Set(replay.mergedReasoningStrippedIds),
-    trailingBlankDecisions: new Map(replay.trailingBlankDecisions),
-    noteNudgeAnchors: structuredClone(replay.noteNudgeAnchors),
-    autoSearchHintDecisions: structuredClone(replay.autoSearchHintDecisions),
-    todoSyntheticAnchor: structuredClone(replay.todoSyntheticAnchor),
-    pendingCompactionMarker: structuredClone(replay.pendingCompactionMarker),
-    compactionMarker: structuredClone(replay.compactionMarker)
-  };
-}
-
 // src/hooks/magic-context/strict-thinking-prefix.ts
 function servedPrefixMatches(args) {
   const heads = args.messages?.slice(0, 2);
@@ -9131,6 +9400,10 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
           dropReasoningParts: thinkingParts,
           mutationParts: [{ message, part: textPart }],
           textPrefix: skipPrefixInjection ? "" : prependTag(tagId, ""),
+          canSetContent: (content) => {
+            const partialEnd = messageId ? getPartialEnds().get(messageId) : undefined;
+            return textPart.text !== content && (partialEnd === undefined || partIndex <= partialEnd);
+          },
           setContent: (content, options) => {
             if (textPart.text === content)
               return false;
@@ -9404,7 +9677,10 @@ function freezeReasoningOnBustingPass(args) {
     return { strip: null, persistenceFailed: false };
   let persisted = false;
   try {
-    persisted = addMergedReasoningStrippedIds(args.db, args.sessionId, messageIds.map(thinkingBindingRecoveryFrozenId));
+    persisted = addMergedReasoningStrippedIds(args.db, args.sessionId, [
+      ...messageIds.map(thinkingBindingRecoveryFrozenId),
+      ...args.compactionOff ? messageIds.map(compactionOffThinkingFrozenId) : []
+    ]);
   } catch (error) {
     sessionLog2(args.sessionId, "proactive thinking strip: persistence threw:", error);
   }
@@ -9430,6 +9706,25 @@ function proactiveStripStartIndex(args) {
     return divergence;
   return divergence ?? lastServed.messages.length;
 }
+function servesThinkingBlock(messages, providerID, modelID) {
+  const familyRoute = isAnthropicFamilyRoute(providerID, modelID);
+  for (const message of messages) {
+    if (message.info.role !== "assistant")
+      continue;
+    for (const part of message.parts) {
+      if (!isAnthropicThinkingPart(part, familyRoute) || part.ignored === true)
+        continue;
+      if (part.type === "redacted_thinking")
+        return true;
+      if (typeof part.text === "string" && part.text !== "")
+        return true;
+      const records = isRecord(part.metadata) ? Object.values(part.metadata) : [];
+      if (records.some((record) => isRecord(record) && record.redactedData !== undefined))
+        return true;
+    }
+  }
+  return false;
+}
 function isPartDroppedBeforeWire(part, providerID) {
   if (!modelAcceptsEmptyContent(providerID) || !isRecord(part))
     return false;
@@ -9914,7 +10209,7 @@ function finalizeMessageRepresentation(messages, resolvedProviderID, options) {
       clearedParts = stripClearedReasoning(targetedMessages.filter((message) => !restoredMessages.has(message)));
     }
   }
-  const bindingRecoveryParts = options?.skipMergedReasoningStrip ? 0 : stripReasoningFromAssistantIds(messages, resolvedProviderID, options?.frozenThinkingBindingMessageIds ?? new Set, restoredMessages);
+  const bindingRecoveryParts = stripReasoningFromAssistantIds(messages, resolvedProviderID, options?.frozenThinkingBindingMessageIds ?? new Set, restoredMessages);
   const mergedReasoningParts = bindingRecoveryParts + (options?.skipMergedReasoningStrip ? 0 : stripReasoningFromMergedAssistants(messages, resolvedProviderID, {
     mutationExemptMessage: options?.reasoningMutationExemptMessage,
     frozenMessageIds: options?.mergedReasoningStrippedIds,
@@ -9991,8 +10286,9 @@ async function runPostTransformPhase(args) {
   let deferredMaterialize = args.canConsumeDeferredLate && deferredMaterializationWasPending;
   let materializationRequested = isExplicitFlush || deferredMaterialize;
   const m0M1EnabledForFold = args.m0M1 !== undefined && (!!args.m0M1.projectPath || !!args.m0M1.projectDirectory) && (args.fullFeatureMode || compactionOff);
-  const frozenThinking = new Set(args.activeThinkingTurn ? getMergedReasoningStrippedIds(args.db, args.sessionId) : []);
-  const bindingThinking = new Set([...frozenThinking].filter((id) => id.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX)).map((id) => id.slice(THINKING_BINDING_RECOVERY_FROZEN_PREFIX.length)));
+  const frozenThinking = new Set(args.activeThinkingTurn || compactionOff ? getMergedReasoningStrippedIds(args.db, args.sessionId) : []);
+  const compactionOffFrozenThinking = compactionOff ? compactionOffFrozenThinkingIds(frozenThinking) : new Set;
+  const bindingThinking = compactionOff ? new Set(compactionOffFrozenThinking) : new Set([...frozenThinking].filter((id) => id.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX)).map((id) => id.slice(THINKING_BINDING_RECOVERY_FROZEN_PREFIX.length)));
   const retainedThinking = args.activeThinkingTurn ? retainedActiveThinkingParts({
     messages: args.messages,
     providerID: args.resolvedProviderID,
@@ -10017,15 +10313,22 @@ async function runPostTransformPhase(args) {
   let freezeM0M1 = args.freezeM0M1 === true || activeThinkingPrefixHold;
   let rewritingSignedPrefix = false;
   let thinkingReleasedForFit = false;
-  const releaseThinkingForRewrite = (forFit = false) => {
+  const releaseThinkingForRewrite = (forFit = false, stripInCompactionOff = false) => {
+    const stripOffWire = compactionOff && stripInCompactionOff;
     const stripped = freezeReasoningOnBustingPass({
       db: args.db,
       sessionId: args.sessionId,
       messages: args.messages,
-      alreadyFrozen: bindingThinking
+      alreadyFrozen: bindingThinking,
+      compactionOff: stripOffWire
     });
     if (stripped.persistenceFailed)
       throw new Error("Cannot persist signed thinking omission before prefix rewrite");
+    if (stripOffWire)
+      for (const id of stripped.strip?.messageIds ?? [])
+        compactionOffFrozenThinking.add(id);
+    for (const id of stripped.strip?.messageIds ?? [])
+      bindingThinking.add(id);
     retainedThinking.clear();
     protectedThinkingMessages.clear();
     activeThinkingTurn = false;
@@ -10038,6 +10341,10 @@ async function runPostTransformPhase(args) {
   if (args.forceSignedRebuildForFit && (activeThinkingPrefixHold || activeThinkingTurn && args.thinkingBindingRecoveryEnabledForModel === true)) {
     releaseThinkingForRewrite(true);
   }
+  if (args.compactionModeTransition === true && args.thinkingBindingRecoveryEnabledForModel === true) {
+    sessionLog2(args.sessionId, "compaction mode switch: stripping signed thinking");
+    releaseThinkingForRewrite(false, true);
+  }
   const foldDueDecision = m0M1EnabledForFold && args.m0M1 && !freezeM0M1 ? mustMaterialize({
     db: args.db,
     sessionId: args.sessionId,
@@ -10077,6 +10384,7 @@ async function runPostTransformPhase(args) {
   };
   if ((foldDueDecision.value || softRefreshOpportunity || firstRenderBust && activeThinkingPrefixHold) && m0M1EnabledForFold && args.m0M1) {
     let committedFoldBustsServedPrefix;
+    let committedFoldChangesHead;
     try {
       const previousM1 = args.sessionMeta.cachedM1Bytes?.toString("utf8");
       const foldResult = injectM0M1({
@@ -10106,6 +10414,12 @@ async function runPostTransformPhase(args) {
               m1Text: rendered.m1Bytes.toString(),
               muralDataUrl: rendered.muralDataUrl
             }) : foldBustsServedPrefix(foldDueDecision.reason, servedPrefixBeforeFold, rendered);
+            committedFoldChangesHead = firstRenderBust ? !servedPrefixMatches({
+              messages: servedBeforeFirstRender,
+              m0Text: rendered.m0Bytes.toString(),
+              m1Text: rendered.m1Bytes.toString(),
+              muralDataUrl: rendered.muralDataUrl
+            }) : foldChangesServedPrefix(servedPrefixBeforeFold, rendered);
             if (bustsPrefix) {
               if (!conversions.isCurrent(db)) {
                 throw new MaterializeContentionError({
@@ -10123,7 +10437,10 @@ async function runPostTransformPhase(args) {
       });
       preparedPrefix = foldResult;
       if (activeThinkingPrefixHold && firstRenderBust && committedFoldBustsServedPrefix) {
-        releaseThinkingForRewrite();
+        releaseThinkingForRewrite(false, true);
+      } else if (compactionOff && !activeThinkingPrefixHold && args.thinkingBindingRecoveryEnabledForModel === true && committedFoldChangesHead) {
+        sessionLog2(args.sessionId, "compaction-off fold changed the head: stripping signed thinking");
+        releaseThinkingForRewrite(false, true);
       }
       prefixPreflightFailed = foldResult.materializationContentionRetryExhausted === true;
       foldExecutedThisPass = foldExecutesThisPass(foldDueDecision.value || softRefreshOpportunity, foldResult.m0RematerializedThisPass);
@@ -10181,12 +10498,30 @@ async function runPostTransformPhase(args) {
   const heldIdleExpiryRebuild = activeThinkingPrefixHold && args.m0M1?.hardSignals?.cacheExpired === true;
   const idleExpiryRebuild = (!freezeM0M1 || activeThinkingPrefixHold) && args.m0M1?.hardSignals?.cacheExpired === true;
   const rideSignals = {
+    executeReclaim: false,
     subagentExecute: !args.fullFeatureMode && args.schedulerDecision === "execute",
     hardFold: rewritingSignedPrefix || foldBustsServedPrefixThisPass || firstRenderBust || idleExpiryRebuild,
     force: emergencyDropEligible && (args.contextUsage.percentage >= 95 || args.contextUsageFromEstimate !== true && getEmergencyInputSample(args.db, args.sessionId) === 0),
     explicitFlush: isExplicitFlush && hasPendingMaterializationOrigin(args.pendingMaterializationSessions, args.sessionId, "user_flush"),
     publishedHistory: !prefixPreflightFailed && (publishedM1RefreshedThisPass || !m0M1EnabledForFold && (args.pendingCompartmentInjection?.compartmentCount ?? 0) > 0 && legacyPublishedHeadChanged(args))
   };
+  const protectedToolTags = protectedToolTagNumbers(args.tags, args.protectedTools);
+  rideSignals.executeReclaim = !compactionOff && originateExecuteReclaim({
+    db: args.db,
+    sessionId: args.sessionId,
+    primaryExecute: args.fullFeatureMode && args.schedulerDecision === "execute" && args.contextUsage.percentage < args.forceMaterializationPercentage,
+    alreadyBusting: Object.values(rideSignals).some(Boolean) || args.historyRebuiltThisPass,
+    summaryCanCome: compartmentRunning || args.sessionMeta.compartmentInProgress || (prefixPreflightFailed || freezeM0M1 || activeThinkingPrefixHold) && (args.deferredHistoryRefreshSessions.has(args.sessionId) || args.deferredMaterializationSessions.has(args.sessionId) || args.historyRefreshSessions?.has(args.sessionId) === true) || readExecuteReclaimState(args.db, args.sessionId).floorOrdinal !== null,
+    reclaimableTokens: estimateExecuteReclaimTokens({
+      db: args.db,
+      sessionId: args.sessionId,
+      pendingOps,
+      tags: args.tags,
+      targets: newTargets,
+      protectedTagIds: new Set([...args.protectedTagIds, ...protectedToolTags])
+    }),
+    usableWindow: args.usableWindow
+  });
   const publishedWorkDrainAllowed = !compactionOff && reclaimRidePermitted(rideSignals, {
     signedThinkingHold: activeThinkingPrefixHold,
     firstRender: firstRenderBust,
@@ -10194,7 +10529,7 @@ async function runPostTransformPhase(args) {
     emergency: emergencyDropEligible
   });
   const shouldApplyPendingOps = publishedWorkDrainAllowed;
-  const shouldRunHeuristics = publishedWorkDrainAllowed && (rideSignals.publishedHistory || materializationRequested || forceMaterialization || foldBustsServedPrefixThisPass || firstRenderBust || heldIdleExpiryRebuild || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
+  const shouldRunHeuristics = publishedWorkDrainAllowed && (rideSignals.publishedHistory || rideSignals.executeReclaim || materializationRequested || forceMaterialization || foldBustsServedPrefixThisPass || firstRenderBust || heldIdleExpiryRebuild || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
   const isCacheBustingPass = publishedWorkDrainAllowed;
   let unheldSignedTurnBust = false;
   if (isCacheBustingPass && !activeThinkingPrefixHold && activeThinkingTurn && args.thinkingBindingRecoveryEnabledForModel === true) {
@@ -10286,17 +10621,28 @@ async function runPostTransformPhase(args) {
       throw new EmergencyFailClosedError("Magic Context could not read its saved reasoning-removal state for this session", { cause: error });
     }
   }
+  const heuristicsLogChanged = diagnosticStateChanged(args.sessionId, "heuristics", JSON.stringify([
+    args.currentTurnId,
+    shouldRunHeuristics,
+    shouldRunHeuristics ? null : args.schedulerDeferReason
+  ]));
+  const pendingLogChanged = diagnosticStateChanged(args.sessionId, "pending-ops", JSON.stringify([
+    args.currentTurnId,
+    shouldApplyPendingOps,
+    shouldApplyPendingOps ? null : args.schedulerDeferReason,
+    shouldApplyPendingOps ? null : (getPendingOpsCount(args.db, args.sessionId) ?? 0) > 0
+  ]));
   if (shouldRunHeuristics) {
     const subagentRerun = !args.fullFeatureMode && alreadyRanThisTurn && args.schedulerDecision === "execute" && !isExplicitFlush && !forceMaterialization;
     const reason = isExplicitFlush ? `pending_materialization origin=${pendingOrigin}` : deferredMaterialize ? "deferred_materialization" : forceMaterialization ? `force_materialization (${args.contextUsage.percentage.toFixed(1)}% >= ${args.forceMaterializationPercentage}%)` : foldBustsServedPrefixThisPass && args.schedulerDecision !== "execute" ? `m0_hard_fold (drain folded into executed m[0] bust, scheduler=${args.schedulerDecision})` : subagentRerun ? `${reclaimRideLabel(rideSignals)} subagent_rerun (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})` : `${reclaimRideLabel(rideSignals)} (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})`;
     sessionLog2(args.sessionId, `heuristics WILL RUN — reason=${reason}, context=${args.contextUsage.percentage.toFixed(1)}%, turn=${args.currentTurnId}`);
-  } else if (args.schedulerDeferReason !== undefined && args.schedulerDeferReason !== null) {
+  } else if (heuristicsLogChanged && args.schedulerDeferReason !== undefined && args.schedulerDeferReason !== null) {
     sessionLog2(args.sessionId, `heuristics WILL NOT RUN — reason=${args.schedulerDeferReason}`);
   }
   if (alreadyRanThisTurn && args.schedulerDecision === "execute" && !materializationRequested && args.fullFeatureMode) {
     sessionLog2(args.sessionId, `transform: skipping heuristics (already ran for turn ${args.currentTurnId})`);
   }
-  if (!shouldApplyPendingOps && args.schedulerDeferReason !== undefined && args.schedulerDeferReason !== null) {
+  if (!shouldApplyPendingOps && pendingLogChanged && args.schedulerDeferReason !== undefined && args.schedulerDeferReason !== null) {
     sessionLog2(args.sessionId, `pending ops WILL NOT APPLY — reason=${args.schedulerDeferReason} pendingOps=${formatPendingOpsDepth()} context=${args.contextUsage.percentage.toFixed(1)}%`);
   }
   if (hasPendingUserOps && !shouldApplyPendingOps) {
@@ -10305,7 +10651,6 @@ async function runPostTransformPhase(args) {
   let explicitMaterializedSuccessfully = false;
   let deferredMaterializedSuccessfully = false;
   let pendingOpsDidMutate = false;
-  const protectedToolTags = protectedToolTagNumbers(args.tags, args.protectedTools);
   const firstApplicationEdits = { any: false, beforeNewerThinking: false };
   const recordFirstApplicationWireEdit = (beforeNewerThinking) => {
     firstApplicationEdits.any = true;
@@ -11041,7 +11386,10 @@ async function runPostTransformPhase(args) {
   const mergedReasoningStrippedIds = new Set(replaySnapshot?.mergedReasoningStrippedIds ?? []);
   const frozenThinkingBindingMessageIds = new Set;
   let thinkingBindingRecovery = null;
-  if (!compactionOff) {
+  if (compactionOff) {
+    for (const id of compactionOffFrozenThinking)
+      frozenThinkingBindingMessageIds.add(id);
+  } else {
     try {
       for (const id of mergedReasoningStrippedIds) {
         if (id.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX)) {
@@ -11383,6 +11731,8 @@ async function runPostTransformPhase(args) {
     });
   }
   logTransformTiming(args.sessionId, "pp.tailGuard", tTailGuard);
+  if (bustedThisPass)
+    clearExecuteReclaimState(args.db, args.sessionId);
   return {
     explicitMaterializedSuccessfully,
     deferredMaterializedSuccessfully,
@@ -11403,8 +11753,7 @@ async function runPostTransformPhase(args) {
     prefixTrimStatus: deliveredPrefix?.prefixTrimStatus ?? null,
     thinkingBindingRecovery,
     proactiveThinkingStrip,
-    thinkingReleasedForFit,
-    openTurnSignedThinkingKept: args.thinkingBindingRecoveryEnabledForModel === true && activeThinkingTurn && !rewritingSignedPrefix
+    thinkingReleasedForFit
   };
 }
 function checkM0MutationDriftAndSignal(args) {
@@ -11504,6 +11853,35 @@ function describeSystemPromptChange(previous, current) {
   return `presetChanged=${previous ? previous.preset !== current.preset : "unknown"} elements=[${elements.join("; ")}]`;
 }
 
+// src/hooks/magic-context/system-prompt-sticky-date.ts
+var STICKY_DATE_KEY = "systemPromptStickyDate";
+function readPersistedSystemPromptStickyDate(db, sessionId) {
+  try {
+    const saved = readReplayEnvelope(db, sessionId, "read")[STICKY_DATE_KEY];
+    return typeof saved === "string" && saved.length > 0 ? saved : undefined;
+  } catch (error) {
+    sessionLog2(sessionId, "system prompt sticky date record unreadable:", error);
+    return;
+  }
+}
+function persistSystemPromptStickyDate(db, sessionId, stickyDate) {
+  try {
+    const written = updateReplayDocument(db, sessionId, (doc) => {
+      if (doc[STICKY_DATE_KEY] === stickyDate)
+        return false;
+      doc.version = 2;
+      doc[STICKY_DATE_KEY] = stickyDate;
+      return true;
+    });
+    if (!written)
+      sessionLog2(sessionId, "system prompt sticky date record not written");
+    return written;
+  } catch (error) {
+    sessionLog2(sessionId, "system prompt sticky date record write failed:", error);
+    return false;
+  }
+}
+
 // src/hooks/magic-context/system-date-refresh.ts
 var channels = new WeakMap;
 var outputUpdates = new WeakMap;
@@ -11574,6 +11952,7 @@ function beginSystemDateRequest(history, sessionId, stage, turnId, identity) {
       systemDone: false,
       messagesSeen: false,
       permitted: undefined,
+      signedThinkingKept: undefined,
       ambiguous: identity === undefined && (turnId === undefined || sameTurn)
     };
     const blocked = [...requests.values()].filter((candidate) => !candidate.explicit && candidate.ambiguous && !(candidate.systemSeen && candidate.messagesSeen) && candidate.turnId === turnId).length;
@@ -11596,6 +11975,10 @@ function systemDateRefreshPermission(history, request) {
   const current = state(history, request);
   return current?.ambiguous ? undefined : current?.permitted;
 }
+function systemDateSignedThinkingKept(history, request) {
+  const current = state(history, request);
+  return current?.ambiguous ? undefined : current?.signedThinkingKept;
+}
 function waitForSystemDateRefresh(history, request, apply) {
   const current = state(history, request);
   if (!current)
@@ -11610,7 +11993,7 @@ function retire(history, current) {
   if (unpairable) {
     const apply = current.waiting;
     current.waiting = undefined;
-    apply?.(false);
+    apply?.(false, undefined);
   }
   const channel = channels.get(history);
   const requests = channel?.get(current.sessionId);
@@ -11618,14 +12001,15 @@ function retire(history, current) {
   if (requests?.size === 0)
     channel?.delete(current.sessionId);
 }
-function finishSystemDateRefresh(history, request, permitted) {
+function finishSystemDateRefresh(history, request, permitted, signedThinkingKept) {
   const current = state(history, request);
   if (!current)
     return;
   current.permitted = current.ambiguous ? false : permitted;
+  current.signedThinkingKept = current.ambiguous ? undefined : signedThinkingKept;
   const apply = current.waiting;
   current.waiting = undefined;
-  apply?.(current.permitted);
+  apply?.(current.permitted, current.signedThinkingKept);
   retire(history, current);
 }
 function finishSystemDateHook(history, request) {
@@ -11661,6 +12045,15 @@ function createSystemPromptHashHandler(deps) {
   });
   const guidanceEpochs = createPromptSurfaceGuidanceEpochCache(promptSurfaceRuntime);
   const stickyDateBySession = new Map;
+  const recordedStickyDateBySession = new Map;
+  const recordedStickyDate = (sessionId) => {
+    let recorded = recordedStickyDateBySession.get(sessionId);
+    if (recorded === undefined) {
+      recorded = readPersistedSystemPromptStickyDate(deps.db, sessionId) ?? null;
+      recordedStickyDateBySession.set(sessionId, recorded);
+    }
+    return recorded ?? undefined;
+  };
   const diagnosticPrompts = new Map;
   const processSystemPrompt = async (input, output) => {
     const sessionId = input.sessionID;
@@ -11728,20 +12121,47 @@ function createSystemPromptHashHandler(deps) {
       return;
     const previousHash = sessionMetaEarly?.systemPromptHash ?? "";
     const hasPersistedHash = previousHash !== "" && previousHash !== "0";
-    if (!hasPersistedHash)
-      stickyDateBySession.delete(sessionId);
-    const stickyDate = stickyDateBySession.get(sessionId);
+    const prefixBoundModel = isPrefixBoundThinkingModel(liveModel?.providerID, liveModel?.modelID);
+    let stickyDate = stickyDateBySession.get(sessionId);
+    if (!hasPersistedHash) {
+      const previous = stickyDate ?? recordedStickyDate(sessionId);
+      const live = systemPromptDates(liveSystemContent).live;
+      const fieldCount = (dates) => dates === undefined ? 0 : JSON.parse(dates).length;
+      stickyDate = (!modelKey || prefixBoundModel) && previous !== undefined && live !== undefined && fieldCount(previous) === fieldCount(live) ? previous : undefined;
+      if (stickyDate === undefined)
+        stickyDateBySession.delete(sessionId);
+      else
+        stickyDateBySession.set(sessionId, stickyDate);
+    }
+    if (stickyDate === undefined && hasPersistedHash) {
+      const recorded = recordedStickyDate(sessionId);
+      const live = systemPromptDates(liveSystemContent).live;
+      if (recorded !== undefined && live !== undefined && recorded !== live && systemPromptFingerprint(systemPromptDates(liveSystemContent, recorded).stable, promptSurface.preset) === previousHash) {
+        stickyDate = recorded;
+        stickyDateBySession.set(sessionId, recorded);
+        sessionLog2(sessionId, `system prompt date restored after restart: real=${live}, using=${recorded}`);
+      }
+    }
+    const setStickyDate = (value) => {
+      stickyDateBySession.set(sessionId, value);
+      if (value !== recordedStickyDate(sessionId)) {
+        if (persistSystemPromptStickyDate(deps.db, sessionId, value))
+          recordedStickyDateBySession.set(sessionId, value);
+      }
+    };
     const dates = systemPromptDates(liveSystemContent, stickyDate);
     const currentDate = dates.live;
     const stableCandidate = dates.stable;
     const stableCandidateHash = systemPromptFingerprint(stableCandidate, promptSurface.preset);
     const contentOrPresetChanged = hasPersistedHash && stableCandidateHash !== previousHash;
     const rewritePermission = systemDateRefreshPermission(deps.historyRefreshSessions, dateRequest);
+    const signedThinkingKept = systemDateSignedThinkingKept(deps.historyRefreshSessions, dateRequest);
+    const systemDateMayMove = (rewrite, keptSignedThinking) => (rewrite || idleCacheExpired) && keptSignedThinking !== true;
     let deferredDateRefresh = false;
-    if (currentDate && stickyDate && currentDate !== stickyDate && isCacheBusting && !idleCacheExpired && !contentOrPresetChanged && !requestMessagesFinal) {
+    if (currentDate && stickyDate && currentDate !== stickyDate && (idleCacheExpired ? prefixBoundModel : isCacheBusting) && !contentOrPresetChanged && !requestMessagesFinal) {
       const liveElements = [...output.system];
-      deferredDateRefresh = waitForSystemDateRefresh(deps.historyRefreshSessions, dateRequest, (permitted) => {
-        if (!permitted) {
+      deferredDateRefresh = waitForSystemDateRefresh(deps.historyRefreshSessions, dateRequest, (permitted, keptSignedThinking) => {
+        if (!systemDateMayMove(permitted, keptSignedThinking)) {
           deps.systemPromptRefreshSessions.add(sessionId);
           return;
         }
@@ -11754,7 +12174,7 @@ function createSystemPromptHashHandler(deps) {
             cachedM0SystemHash: hash,
             systemPromptTokens: estimateTokens(content)
           });
-          stickyDateBySession.set(sessionId, currentDate);
+          setStickyDate(currentDate);
           output.system.splice(0, output.system.length, ...liveElements);
           publishSystemDateOutput(output.system);
           deps.systemPromptRefreshSessions.delete(sessionId);
@@ -11765,12 +12185,12 @@ function createSystemPromptHashHandler(deps) {
         }
       });
     }
-    const dateMayAdvance = idleCacheExpired || contentOrPresetChanged || isCacheBusting && !deferredDateRefresh && (dateRequest ? rewritePermission === true : rewritePermission !== false);
+    const dateMayAdvance = contentOrPresetChanged || !deferredDateRefresh && systemDateMayMove(isCacheBusting && (dateRequest ? rewritePermission === true : rewritePermission !== false), signedThinkingKept);
     if (currentDate && !stickyDate) {
-      stickyDateBySession.set(sessionId, currentDate);
+      setStickyDate(currentDate);
     } else if (currentDate && stickyDate && currentDate !== stickyDate) {
       if (dateMayAdvance) {
-        stickyDateBySession.set(sessionId, currentDate);
+        setStickyDate(currentDate);
         sessionLog2(sessionId, `system prompt date updated: ${stickyDate} → ${currentDate} (cache-busting pass)`);
       } else {
         let offset = 0;
@@ -11828,7 +12248,7 @@ function createSystemPromptHashHandler(deps) {
         sessionLog2(sessionId, "system prompt meta persist failed (fail-open):", error);
       }
     }
-    if (isCacheBusting && !deferredDateRefresh && (contentOrPresetChanged || !currentDate || currentDate === stickyDate || !dateRequest || rewritePermission === true)) {
+    if (isCacheBusting && !deferredDateRefresh && (contentOrPresetChanged || !currentDate || currentDate === stickyDate || !dateRequest || rewritePermission === true && signedThinkingKept !== true)) {
       deps.systemPromptRefreshSessions.delete(sessionId);
     }
   };
@@ -11843,6 +12263,7 @@ function createSystemPromptHashHandler(deps) {
     handler,
     clearSession: (sessionId) => {
       diagnosticPrompts.delete(sessionId);
+      recordedStickyDateBySession.delete(sessionId);
       clearSystemDateRefresh(deps.historyRefreshSessions, sessionId);
       guidanceEpochs.clear(sessionId);
       clearSystemPromptHashSession(sessionId, {
@@ -18324,8 +18745,8 @@ async function runCompartmentPhaseImpl(args) {
     }
     return "completed";
   }
-  if (!historianRunnable && args.sessionMeta.compartmentInProgress) {
-    sessionLog2(args.sessionId, "transform: historian disabled; clearing stale compartmentInProgress flag");
+  if ((!historianRunnable || !args.canRunCompartments && !getActiveCompartmentRun(args.sessionId)) && args.sessionMeta.compartmentInProgress) {
+    sessionLog2(args.sessionId, "transform: historian unavailable; clearing stale compartmentInProgress flag");
     updateSessionMeta(args.db, args.sessionId, { compartmentInProgress: false });
     compartmentInProgress = false;
   }
@@ -18576,8 +18997,10 @@ function createTransform(deps) {
   const loadedSessions = new Set;
   const prefixHoldLogTurnIds = new Map;
   const thinkingFitRetries = new Set;
+  const compactionModeTransitionPending = new Set;
   const clearSessionLogState = (sessionId) => {
     prefixHoldLogTurnIds.delete(sessionId);
+    clearDiagnosticLogState(sessionId);
   };
   const unmanagedOverWindowSessions = new Set;
   const rustModeTransform = deps.transformMode === "rust" && deps.rustModeModuleClient ? createRustModeTransform(deps, {
@@ -18626,6 +19049,11 @@ function createTransform(deps) {
     const tLkgEntry = performance.now();
     const lkgInput = deps.transformMode === "rust" ? [] : projectEntry(sessionId, messages);
     const recovery = deps.compactionOff || deps.transformMode === "rust" ? {} : readLkgRecoveryPrefix(sessionId, lkgInput, messages, deps.db);
+    const persistedUntaggedInputIds = deps.compactionOff || deps.transformMode === "rust" ? [] : readPersistedLkgUntaggedInputIds(deps.db, sessionId);
+    const untaggedReplayIds = new Set([
+      ...recovery.prefix?.untaggedInputIds ?? [],
+      ...persistedUntaggedInputIds
+    ]);
     logTransformTiming(sessionId, "lkg.entryProjection", tLkgEntry, deps.transformMode === "rust" || !entryReuse ? undefined : `reused=${entryReuse.reused} retained=${entryReuse.retained} retainedBytes=${entryReuse.retainedBytes}`);
     const resolvedSessionId = sessionId;
     const runNotificationParams = (sid) => {
@@ -18713,6 +19141,7 @@ function createTransform(deps) {
       const hasTransitionEffects = transition.recordToWrite !== null || transition.notice !== null || transition.invalidatedM0Baseline || transition.clearedCompartmentInProgress || transition.historianCatchUpSignaled;
       if (hasTransitionEffects) {
         if (transition.invalidatedM0Baseline) {
+          compactionModeTransitionPending.add(sessionId);
           sessionMeta = {
             ...sessionMeta,
             cachedM0Bytes: null,
@@ -19045,6 +19474,8 @@ function createTransform(deps) {
       contextLimit: boundaryContextLimit
     });
     let _boundarySnapshotCache;
+    if (fullFeatureMode && !compactionOff)
+      maintainExecuteFloorMark(db, sessionId, currentTurnId, boundaryUsageForProtectedTail.percentage < boundaryExecuteThreshold);
     const getRunnableBoundaryForCompartment = (emergencyTailScale) => {
       if (!canRunCompartments)
         return null;
@@ -19170,8 +19601,9 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       recordedSessionProjectIdentity.set(sessionId, sessionIdentityForBinding);
     }
     const taggerFloor = compactionOff ? 0 : deriveTaggerLoadFloor(messages, sessionId, db);
-    if (!compactionOff && taggerFloor === 0 && messages.length > 0) {
-      sessionLog2(sessionId, `tag floor: 0 (full-scan fallback) — no leading wire message resolved a tag across ${messages.length} msgs`);
+    const tagFloorMode = compactionOff || messages.length === 0 ? "inactive" : taggerFloor === 0 ? "fallback" : "scoped";
+    if (diagnosticStateChanged(sessionId, "tag-floor", tagFloorMode) && tagFloorMode !== "inactive") {
+      sessionLog2(sessionId, taggerFloor === 0 ? `tag floor: 0 (full-scan fallback) — no scoped floor above the safety margin across ${messages.length} msgs` : `tag floor: ${taggerFloor} (scoped load)`);
     }
     const ownerRatio = sessionDecisionCalibration(db, sessionId).proseRatio;
     noteTransformPassForExactOrdinalReads(sessionId);
@@ -19208,7 +19640,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
             idleExpiry: false,
             emergency: contextUsageEarly.percentage >= forceMaterializationPercentage
           }
-        }, pendingDropEligibility.read(sessionId, dropProjectionKey()));
+        }, pendingDropEligibility.read(sessionId, dropProjectionKey()), schedulerDecision === "execute");
         if (triggerResult.shouldFire) {
           sessionLog2(sessionId, `compartment trigger: firing (reason=${triggerResult.reason})`);
           updateSessionMeta(db, sessionId, { compartmentInProgress: true });
@@ -19259,10 +19691,11 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     let taggingSucceeded = false;
     let recoveryBatch = null;
     let recoveryNormalized = false;
-    const normalizeRecoveryTail = recovery.prefix ? () => {
+    const untaggedReplayTailServed = !!recovery.prefix || untaggedReplayIds.size > 0 && messages.some((message) => untaggedReplayIds.has(message.info.id ?? ""));
+    const normalizeRecoveryTail = untaggedReplayTailServed ? () => {
       if (recoveryNormalized)
         return;
-      const tail = messages.filter((message) => recovery.prefix?.untaggedInputIds.has(message.info.id ?? ""));
+      const tail = messages.filter((message) => untaggedReplayIds.has(message.info.id ?? ""));
       const tagged = tagMessages(sessionId, tail, deps.tagger, db, {
         skipPrefixInjection: !ctxReduceCallable,
         servedMessages: messages,
@@ -19288,7 +19721,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         const messagesForTagging = messagesBeforeInitialPrepare && hiddenMessagesAtCompactionSeam.length > 0 ? messagesBeforeInitialPrepare : messages;
         const canAdoptScopedToolSweep = isCacheBusting || canConsumeDeferredEarly;
         const scopedToolSweep = useScopedToolSweep(db, sessionId, canAdoptScopedToolSweep) ? true : createPreAdoptionToolSweepResolver(db, sessionId);
-        const result = tagMessages(sessionId, recovery.prefix ? messagesForTagging.filter((message) => !recovery.prefix?.untaggedInputIds.has(message.info.id ?? "")) : messagesForTagging, deps.tagger, db, {
+        const result = tagMessages(sessionId, untaggedReplayIds.size > 0 ? messagesForTagging.filter((message) => !untaggedReplayIds.has(message.info.id ?? "")) : messagesForTagging, deps.tagger, db, {
           skipPrefixInjection,
           scopedToolSweep,
           servedMessages: messages,
@@ -19578,6 +20011,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       activeThinkingPrefixHold,
       directoryPrefixHold: unresolvedDirectoryHold,
       forceSignedRebuildForFit: thinkingFitRetries.has(sessionId) || !!recovery.rebuildReason,
+      compactionModeTransition: compactionModeTransitionPending.has(sessionId),
       readLastServedMessages: () => {
         const slot = getInMemorySlot(sessionId) ?? loadPersistedLkgSlot(db, sessionId);
         try {
@@ -19635,6 +20069,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         hardSignals: m0HardSignals
       }
     });
+    compactionModeTransitionPending.delete(sessionId);
     if (recovery.prefix && !recoveryNormalized) {
       const priorIds = new Set(recovery.prefix.inputs.map((input) => input.id));
       const newIds = new Set(lkgInput.flatMap((input) => input.id && !priorIds.has(input.id) ? [input.id] : []));
@@ -19646,7 +20081,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       postTransformResult.bustedThisPass = true;
     passOutcome.markFinalized();
     const finalWireTail = describeFinalWireTail(messages);
-    const signedFitPreviouslyRefused = !compactionOff && getMergedReasoningStrippedIds(db, sessionId).has(SIGNED_FIT_REFUSED_MARKER);
+    const signedFitPreviouslyRefused = !compactionOff && activeThinkingPrefixHold && getMergedReasoningStrippedIds(db, sessionId).has(SIGNED_FIT_REFUSED_MARKER);
     let finalWireEstimate;
     if (postTransformResult.bustedThisPass) {
       try {
@@ -19807,7 +20242,13 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     if (!finalWireEstimate) {
       sessionLog2(sessionId, `transform: final-wire telemetry estimate=unavailable trusted=false conversation=unknown tools=unknown system=unknown toolDefinitions=unknown tail=${finalWireTail}`);
     }
-    finishSystemDateRefresh(deps.historyRefreshSessions, dateRequest, postTransformResult.bustedThisPass && !activeThinkingPrefixHold && postTransformResult.openTurnSignedThinkingKept !== true || postTransformResult.thinkingReleasedForFit === true);
+    if (!compactionOff) {
+      const stillUntagged = untaggedReplayTailServed && !recoveryNormalized ? [...untaggedReplayIds] : [];
+      if (JSON.stringify([...new Set(stillUntagged)].sort()) !== JSON.stringify([...new Set(persistedUntaggedInputIds)].sort()) && !persistLkgUntaggedInputIds(db, sessionId, stillUntagged))
+        throw new Error("Cannot persist the last-good untagged-message record");
+    }
+    const signedThinkingServed = isPrefixBoundThinkingModel(modelForBudget?.providerID, modelForBudget?.modelID) && servesThinkingBlock(messages, modelForBudget?.providerID, modelForBudget?.modelID);
+    finishSystemDateRefresh(deps.historyRefreshSessions, dateRequest, postTransformResult.bustedThisPass && !activeThinkingPrefixHold && !signedThinkingServed || postTransformResult.thinkingReleasedForFit === true, signedThinkingServed);
     if (activeThinkingPrefixHold && !postTransformResult.thinkingReleasedForFit && sessionMeta.cachedM0Bytes != null && sessionMeta.cachedM1Bytes != null) {
       recordHeldHeadForRequest(sessionId, currentLkgRequestIdentity(sessionId), (ownsHistory) => deferDeliveredSystemRefresh(deps, sessionId, ownsHistory));
     }
@@ -19965,7 +20406,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           postReduceGraceBaselineU: channel1State.postReduceGraceBaselineU,
           postReduceGracePreLevel: channel1State.postReduceGracePreLevel
         });
-        sessionLog2(sessionId, formatChannel1Evaluation(channel1Decision));
+        logNudgeEvaluation(sessionId, "transform", formatChannel1Evaluation(channel1Decision));
         const channel2Evaluation = evaluateChannel2(channelBaseline);
         const leaseBefore = getChannel2NudgeState(db, sessionId);
         if (channelBaseline.evaluable && !channelBaseline.generationInvalidated && !channelBaseline.reducedSinceRefresh) {
@@ -19976,7 +20417,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           }
         }
         const leaseAfter = getChannel2NudgeState(db, sessionId);
-        sessionLog2(sessionId, formatChannel2Evaluation(channel2Evaluation, {
+        logNudgeEvaluation(sessionId, "transform", formatChannel2Evaluation(channel2Evaluation, {
           leaseBefore,
           leaseAfter,
           gateHoldReason: channelBaseline.reducedSinceRefresh ? "recent-reduce-refresh" : undefined
@@ -20355,7 +20796,8 @@ function tryMessagesTransformLkgReplay(args) {
             sessionId,
             entry,
             messages: replay.messages,
-            ...keys
+            ...keys,
+            db
           }))
             return false;
           retirePendingSystemPromptDelivery(sessionId);
@@ -21944,7 +22386,7 @@ function loadRegistrationConfig(directory) {
     configCache.delete(directory);
   return detailed;
 }
-async function ensureProjectRegisteredFromOpenCodeDirectory(directory, db) {
+async function ensureProjectRegisteredFromOpenCodeDirectory(directory, db, options = {}) {
   const detailed = loadRegistrationConfig(directory);
   const projectIdentity = resolveProjectIdentityForSession(directory, detailed.config.allow_home_project);
   if (!projectIdentity)
@@ -21965,6 +22407,9 @@ async function ensureProjectRegisteredFromOpenCodeDirectory(directory, db) {
     memoryEnabled: detailed.config.memory.enabled,
     gitCommitEnabled: detailed.config.memory.git_commit_indexing.enabled
   };
+  if (options.preflightLocalPooling && routing.primary.provider === "local") {
+    await preflightLocalEmbeddingPooling(routing.primary.model ?? "Xenova/all-MiniLM-L6-v2");
+  }
   const before = getProjectEmbeddingSnapshot2(projectIdentity);
   const registered = registerProjectEmbedding2(db, projectIdentity, routing.primary, features, directory);
   if (!before || before.providerIdentity !== registered.providerIdentity || before.runtimeFingerprint !== registered.runtimeFingerprint)
@@ -22895,6 +23340,7 @@ function buildDebugMemoryUsage(runtimeHolders = {}) {
   const lkg = getLkgSlotHeapStats();
   const tagger = runtimeHolders.taggerCache ?? EMPTY_TAGGER_HEAP_STATS;
   const wire = runtimeHolders.wireCache ?? EMPTY_WIRE_HEAP_STATS;
+  const replay = runtimeHolders.generateReplay ?? { totalBytes: 0, sessions: [] };
   const messageIndexQueue = getMessageIndexQueueHeapStats();
   const sessions = new Map;
   const session = (sessionId) => {
@@ -22908,7 +23354,8 @@ function buildDebugMemoryUsage(runtimeHolders = {}) {
         wireRawMessages: 0,
         wireMessages: 0,
         wireContentSnapshots: 0,
-        wireEstimatedBytes: 0
+        wireEstimatedBytes: 0,
+        generateReplayBytes: 0
       };
       sessions.set(sessionId, current);
     }
@@ -22928,6 +23375,8 @@ function buildDebugMemoryUsage(runtimeHolders = {}) {
     target.wireContentSnapshots += entry.rawContentSnapshots;
     target.wireEstimatedBytes += entry.estimatedBytes;
   }
+  for (const entry of replay.sessions)
+    session(entry.sessionId).generateReplayBytes += entry.bytes;
   return {
     pid: process.pid,
     bunVersion: typeof Bun !== "undefined" && typeof Bun.version === "string" ? Bun.version : "unavailable",
@@ -22958,6 +23407,10 @@ function buildDebugMemoryUsage(runtimeHolders = {}) {
         estimatedBytes: wire.estimatedBytes
       },
       compartmentMirrors: { entries: 0 },
+      generateReplay: {
+        sessionCount: replay.sessions.length,
+        estimatedBytes: replay.totalBytes
+      },
       messageIndexQueue,
       sessions: [...sessions.values()].sort((a, b) => a.sessionId.localeCompare(b.sessionId))
     }
@@ -23174,9 +23627,9 @@ function registerRpcHandlers(rpcServer, args) {
     return { count: buildCompartmentCount(db, sessionId, moduleStatus) };
   });
   const buildManagedCtx = async (db) => {
-    const { deriveHistorianChunkTokens, resolveHistorianContextLimit } = await importPluginModule(() => import("./derive-budgets-2zh4gm2c.js"));
-    const { resolveHistorianModel } = await importPluginModule(() => import("./model-resolution-nx97z3x7.js"));
-    const { userObservationCollectionEnabled, userObservationsRequested } = await importPluginModule(() => import("./task-config-nvz8mapa.js"));
+    const { deriveHistorianChunkTokens, resolveHistorianContextLimit } = await importPluginModule(() => import("./derive-budgets-knf763tt.js"));
+    const { resolveHistorianModel } = await importPluginModule(() => import("./model-resolution-280gmqvd.js"));
+    const { userObservationCollectionEnabled, userObservationsRequested } = await importPluginModule(() => import("./task-config-7md27rx8.js"));
     const DEFAULT_HISTORIAN_TIMEOUT_MS = 10 * 60 * 1000;
     const runConfig = historianRunConfig(config, currentPluginConfigReader(directory)?.poll().effective ?? config);
     const historianModel = resolveHistorianModel(runConfig, "opencode");
@@ -23207,7 +23660,7 @@ function registerRpcHandlers(rpcServer, args) {
       return { ok: false, error: "no session" };
     const readDirectory = args.readSessionDirectory;
     if (readDirectory) {
-      const { handoffHistoryWork } = await import("./history-owner-42e16w0n.js");
+      const { handoffHistoryWork } = await import("./history-owner-ad0crnrn.js");
       const handed = await handoffHistoryWork({
         storageDir: args.storageDir ?? getMagicContextStorageDir(),
         directory,
@@ -23226,8 +23679,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-4vfxej9t.js"));
-    const { sendIgnoredMessage } = await importPluginModule(() => import("./send-session-notification-3pxn658x.js"));
+    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-47m4hv5g.js"));
+    const { sendIgnoredMessage } = await importPluginModule(() => import("./send-session-notification-nwvrv34d.js"));
     log2(`[rpc] recomp requested for session ${sessionId}`);
     if (!args.client && !args.hiddenCompletionExecutor) {
       return {
@@ -23285,7 +23738,7 @@ function registerRpcHandlers(rpcServer, args) {
   rpcServer.handle("wrapup", async (params) => {
     const readDirectory = args.readSessionDirectory;
     if (readDirectory && params.sessionId) {
-      const { handoffHistoryWork } = await import("./history-owner-42e16w0n.js");
+      const { handoffHistoryWork } = await import("./history-owner-ad0crnrn.js");
       const sessionId = String(params.sessionId);
       const handed = await handoffHistoryWork({
         storageDir: args.storageDir ?? getMagicContextStorageDir(),
@@ -23311,7 +23764,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-psqz7yh0.js"));
+    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-639whfhq.js"));
     const model = liveSessionState.liveModelBySession.get(sessionId);
     const contextLimit = model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
     const ctx = {
@@ -23396,8 +23849,17 @@ function subagentToolRefusal(db, toolId, sessionId, isInternalChild = () => fals
 function hideSubagentTools(draft, db) {
   if (!getOrCreateSessionMeta(db, draft.sessionID).isSubagent)
     return;
+  removePrimaryOnlyTools(draft.tools);
+}
+function removePrimaryOnlyTools(tools) {
   for (const id of PRIMARY_ONLY_TOOLS)
-    delete draft.tools[id];
+    delete tools[id];
+}
+function storedSubagentMode(db, sessionId) {
+  const row = db.prepare("SELECT is_subagent FROM session_meta WHERE session_id = ?").get(sessionId);
+  if (!row || typeof row.is_subagent !== "number")
+    return;
+  return row.is_subagent === 1;
 }
 
 // src/shared/conflict-detector.ts
@@ -24746,18 +25208,56 @@ function containsHostInstance(value) {
   return false;
 }
 function clonePreservingInstances(value) {
-  if (isHostInstance(value))
+  return cloneCounting(value, undefined);
+}
+function clonePreservingInstancesMeasured(value) {
+  const meter = { bytes: 0 };
+  const copy = cloneCounting(value, meter);
+  return { copy, bytes: meter.bytes };
+}
+function cloneCounting(value, meter) {
+  if (isHostInstance(value)) {
+    if (meter)
+      meter.bytes += instanceBytes(value, new WeakSet);
     return value;
-  if (Array.isArray(value))
-    return value.map(clonePreservingInstances);
+  }
+  if (Array.isArray(value)) {
+    if (meter)
+      meter.bytes += 16 + 8 * value.length;
+    return value.map((entry) => cloneCounting(entry, meter));
+  }
   if (value && typeof value === "object") {
     const copy = {};
-    for (const [key, entry] of Object.entries(value))
-      copy[key] = clonePreservingInstances(entry);
+    if (meter)
+      meter.bytes += 32;
+    for (const [key, entry] of Object.entries(value)) {
+      if (meter)
+        meter.bytes += 16;
+      copy[key] = cloneCounting(entry, meter);
+    }
     return copy;
   }
+  if (meter)
+    meter.bytes += typeof value === "string" ? 2 * value.length : 8;
   return value;
 }
+function instanceBytes(value, seen) {
+  if (typeof value === "string")
+    return 2 * value.length;
+  if (!value || typeof value !== "object")
+    return 8;
+  if (seen.has(value))
+    return 0;
+  seen.add(value);
+  if (ArrayBuffer.isView(value))
+    return value.byteLength;
+  if (value instanceof ArrayBuffer)
+    return value.byteLength;
+  let bytes = 32;
+  for (const entry of Object.values(value))
+    bytes += 16 + instanceBytes(entry, seen);
+  return bytes;
+}
 function contentKey(value) {
   const plain = (entry) => {
     if (ArrayBuffer.isView(entry)) {
@@ -24813,7 +25313,7 @@ function rebuildFileContent(value, output, attachments) {
     rebuilt.unshift({ type: "text", text: output });
   return { type: "content", value: rebuilt };
 }
-function adaptPayload(draft, admittedIDs = new Set, messageTimes = new Map) {
+function adaptPayload(draft, admittedIDs = new Set, messageTimes = new Map, hiddenTimes = false) {
   const existingHeads = new Map(draft.messages.filter((m) => HEAD_IDS.some((id) => m.id === id)).map((m) => [m.id, m]));
   const source = draft.messages.filter((m) => !existingHeads.has(m.id));
   const results = new Map;
@@ -24932,6 +25432,16 @@ function adaptPayload(draft, admittedIDs = new Set, messageTimes = new Map) {
       },
       parts
     };
+    if (hiddenTimes && mapped.info.time !== undefined) {
+      const time = mapped.info.time;
+      delete mapped.info.time;
+      Object.defineProperty(mapped.info, "time", {
+        value: time,
+        enumerable: false,
+        configurable: true,
+        writable: true
+      });
+    }
     originals.set(mapped, message);
     if (isCoveredInstructionRow(message))
       markCoveredInstructionRow(mapped.info);
@@ -26432,10 +26942,12 @@ function assistantText(row) {
 
 class HiddenProviderError extends Error {
   settled;
+  hostError;
   constructor(detail, options = {}) {
     super(`Hidden completion provider error: ${detail}`);
     this.name = "HiddenProviderError";
     this.settled = options.settled ?? true;
+    this.hostError = options.hostError;
   }
 }
 function requestModel(request, current) {
@@ -26499,7 +27011,9 @@ async function awaitAssistantRow(openReader, readSessionError, localFailure, chi
           `terminal_row=${errorText(newIdle)}`,
           `session_error=${sessionError === undefined ? "unavailable" : errorText(sessionError)}`
         ];
-        throw sessionError === undefined || !isProviderFailure(sessionError) ? new Error(`Hidden completion failed: ${details.join("; ")}`) : new HiddenProviderError(details.join("; "));
+        throw sessionError === undefined || !isProviderFailure(sessionError) ? new Error(`Hidden completion failed: ${details.join("; ")}`, {
+          cause: sessionError
+        }) : new HiddenProviderError(details.join("; "), { hostError: sessionError });
       }
       if (outcome === "succeeded" && newAssistant)
         return newAssistant;
@@ -26513,7 +27027,9 @@ async function awaitAssistantRow(openReader, readSessionError, localFailure, chi
           `terminal_row=${errorText(newAssistant)}`,
           `session_error=${sessionError === undefined ? "unavailable" : errorText(sessionError)}`
         ];
-        throw sessionError === undefined || !isProviderFailure(sessionError) ? new Error(`Hidden completion failed: ${details.join("; ")}`) : new HiddenProviderError(details.join("; "));
+        throw sessionError === undefined || !isProviderFailure(sessionError) ? new Error(`Hidden completion failed: ${details.join("; ")}`, {
+          cause: sessionError
+        }) : new HiddenProviderError(details.join("; "), { hostError: sessionError });
       }
       if (newAssistant.data.error !== undefined) {
         throw new HiddenProviderError(errorText(newAssistant.data.error), {
@@ -26668,7 +27184,13 @@ async function createV2HiddenCompletionExecutor(host, options) {
         const head = await resolveHead(identity);
         const active = await lifecycle.open(identity, role, head);
         openedChild = active;
-        const handle = { id: active.id, childSessionId: active.id };
+        const configuredModel = toModelEntry(identity.model);
+        const handle = {
+          id: active.id,
+          childSessionId: active.id,
+          attemptedModel: modelKey(head),
+          ...configuredModel?.sourceConfigKey ? { modelConfigKey: configuredModel.sourceConfigKey } : {}
+        };
         const tokenBudget = identity.metadata?.tokenBudget;
         const run = {
           identity,
@@ -26699,6 +27221,7 @@ async function createV2HiddenCompletionExecutor(host, options) {
       }
     },
     async attempt(handle, request) {
+      const startedAt = Date.now();
       const run = runs.get(handle);
       if (!run)
         throw new Error("Unknown hidden completion run");
@@ -26716,6 +27239,10 @@ async function createV2HiddenCompletionExecutor(host, options) {
         throw new Error("Hidden completion prompt aborted");
       }
       const requested = await validateVariant(requestModel(request, run.child.model));
+      const requestedRef = modelKey(requested);
+      const configuredModel = [run.identity.model, ...run.identity.configuredModels ?? []].map(toModelEntry).find((entry) => entry?.model === requestedRef);
+      handle.attemptedModel = requestedRef;
+      handle.modelConfigKey = configuredModel?.sourceConfigKey ?? handle.modelConfigKey;
       if (run.identity.kind !== "dreamer-task" && request.body.temperature === undefined) {
         const configured = options.historianTemperature?.();
         if (typeof configured === "number" && Number.isFinite(configured))
@@ -26810,6 +27337,22 @@ async function createV2HiddenCompletionExecutor(host, options) {
         abortReject = reject;
       });
       const onAbort = () => {
+        const reason = request.signal?.reason;
+        if (reason instanceof ModelProducedNoOutputError && run.identity.kind === "dreamer-task") {
+          recordChildInvocation({
+            db: options.db,
+            parentSessionId: run.identity.parentSessionId ?? options.projectIdentity,
+            parentInvocationId: run.identity.parentInvocationId,
+            harness: "opencode2",
+            subagent: "dreamer",
+            task: run.identity.title.replace(/^magic-context-dream-/, ""),
+            startedAt,
+            status: "timed_out",
+            error: reason,
+            providerId: requested.providerID,
+            modelId: requested.modelID
+          });
+        }
         interruptAndRetire(run, "prompt-aborted").finally(() => abortReject(new Error("Hidden completion prompt aborted")));
       };
       const deadlineTimer = setTimeout(() => {
@@ -26838,6 +27381,9 @@ async function createV2HiddenCompletionExecutor(host, options) {
         })
       };
       inFlight.add(entry);
+      const stopWatching = host.watchModelActivity?.(run.child.id, () => noteModelOutputReceived(request.signal));
+      if (stopWatching)
+        noteModelActivityMonitored(request.signal);
       try {
         await Promise.race([
           host.prompt({ sessionID: run.child.id, text: marker }),
@@ -26893,12 +27439,20 @@ async function createV2HiddenCompletionExecutor(host, options) {
           usage: reportedUsage ? usage : meter(system, promptText(request), text ?? ""),
           lengthCapped: ["length", "max_tokens"].includes(row.data.finish ?? ""),
           providerId: row.data.model?.providerID ?? requested.providerID,
-          modelId: row.data.model?.id ?? requested.modelID
+          modelId: row.data.model?.id ?? requested.modelID,
+          attemptedModel: requestedRef,
+          modelConfigKey: handle.modelConfigKey
         };
         if (!run.child.ever_settled)
           run.child = lifecycle.markEverSettled(run.child);
       } catch (caught) {
         const error = attempt.budgetExceeded ?? attempt.stepLimit ?? attempt.refusal ?? caught;
+        const hostError = error instanceof HiddenProviderError ? error.hostError : error instanceof Error && error.message.startsWith("Hidden completion failed:") ? error.cause : undefined;
+        annotateSubagentInvocationError(error, {
+          attemptedModel: handle.attemptedModel,
+          modelConfigKey: handle.modelConfigKey,
+          ...hostError === undefined ? {} : { hostError }
+        });
         run.failed = true;
         if (!(error instanceof HiddenProviderError)) {
           run.unsettledFailure = true;
@@ -26912,6 +27466,7 @@ async function createV2HiddenCompletionExecutor(host, options) {
         }
         throw error;
       } finally {
+        stopWatching?.();
         clearTimeout(deadlineTimer);
         if (budgetPoll)
           clearInterval(budgetPoll);
@@ -26967,6 +27522,30 @@ async function createV2HiddenCompletionExecutor(host, options) {
   };
 }
 
+// src/v2/hidden-model-activity.ts
+class HiddenModelActivity {
+  watchers = new Map;
+  watch(sessionID, onOutput) {
+    this.watchers.set(sessionID, onOutput);
+    return () => {
+      if (this.watchers.get(sessionID) === onOutput)
+        this.watchers.delete(sessionID);
+    };
+  }
+  observe(event) {
+    if (!isRecord(event) || !isRecord(event.data))
+      return;
+    const { sessionID, delta, text } = event.data;
+    if (typeof sessionID !== "string")
+      return;
+    const streamed = ["session.text.delta", "session.reasoning.delta", "session.tool.input.delta"].includes(String(event.type)) && typeof delta === "string" && delta.length > 0;
+    const ended = ["session.text.ended", "session.reasoning.ended"].includes(String(event.type)) && typeof text === "string" && text.length > 0;
+    if (streamed || ended || event.type === "session.tool.input.started") {
+      this.watchers.get(sessionID)?.();
+    }
+  }
+}
+
 // src/v2/hooks/channel2.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
 var pendingCandidates = new WeakMap;
@@ -27832,7 +28411,9 @@ async function compressOneChunk(args, chunk, sliceMs, signal) {
         status: "completed",
         tokens: run.output.usage,
         providerId: run.output.providerId,
-        modelId: run.output.modelId
+        modelId: run.output.modelId,
+        attemptedModel: args.model,
+        configuredModels: args.fallbackModels
       });
     }
     stage = "apply";
@@ -27999,6 +28580,7 @@ async function applyCuesThroughModule(args, chunk, manifestText, signal) {
 }
 
 // src/features/magic-context/dreamer/hidden-single-shot.ts
+var DREAMER_FIRST_OUTPUT_TIMEOUT_MS = 90000;
 async function runHiddenSingleShotPrompt(args) {
   const system = withContentLanguageDirective(args.system, args.language);
   const opening = args.executor.open({
@@ -28023,6 +28605,7 @@ async function runHiddenSingleShotPrompt(args) {
       });
   }).catch(() => {});
   const handle = await raceWithSignal(opening, args.signal);
+  let completion;
   args.onOpened?.(handle.id);
   let promptSettled = false;
   try {
@@ -28040,10 +28623,14 @@ async function runHiddenSingleShotPrompt(args) {
     }, {
       transport: Object.assign((request) => args.executor.attempt(handle, request), { childSessionId: handle.childSessionId }),
       timeoutMs: args.timeoutMs,
+      ...args.firstOutputTimeoutMs !== undefined ? { firstOutputTimeoutMs: args.firstOutputTimeoutMs } : {},
       ...args.signal ? { signal: args.signal } : {},
       fallbackModels: args.fallbackModels,
       callContext: args.callContext,
-      fetchOutput: () => args.executor.collect(handle, 50),
+      fetchOutput: async () => {
+        completion = await args.executor.collect(handle, 50);
+        return completion;
+      },
       validateOutput: (completion) => {
         const tokens = completion.tokenLog ?? runTokenLog(undefined);
         sessionLog2(args.parentSessionId ?? "dreamer", `${args.callContext} response_chars=${(completion.text ?? completion.reasoning ?? "").length} ${formatRunTokenLog(tokens)}`);
@@ -28059,6 +28646,12 @@ async function runHiddenSingleShotPrompt(args) {
     promptSettled = true;
     return { validated: run.validated, completion: run.output, childSessionId: handle.id };
   } catch (error) {
+    const configuredModel = toModelEntry(args.model);
+    annotateSubagentInvocationError(error, {
+      attemptedModel: completion?.attemptedModel ?? handle.attemptedModel ?? configuredModel?.model,
+      modelConfigKey: completion?.modelConfigKey ?? handle.modelConfigKey ?? configuredModel?.sourceConfigKey,
+      ...completion?.hostError === undefined ? {} : { hostError: completion.hostError }
+    });
     if (args.onFailureOutput) {
       let timer;
       try {
@@ -28386,6 +28979,8 @@ If no promotions are warranted, return empty arrays. Always consume reviewed can
       startedAt,
       status: params.status,
       messages: params.messages,
+      attemptedModel: args.model,
+      configuredModels: args.fallbackModels,
       error: params.error
     });
   };
@@ -28893,6 +29488,7 @@ async function classifyOneChunk(args, chunk, anchors, sliceMs, signal) {
       }, {
         transport: Object.assign((request) => executor.attempt(opened, request), { childSessionId: opened.childSessionId }),
         timeoutMs: sliceMs,
+        firstOutputTimeoutMs: args.firstOutputTimeoutMs ?? DREAMER_FIRST_OUTPUT_TIMEOUT_MS,
         signal,
         fallbackModels: args.fallbackModels,
         callContext: "dreamer:classify-memories",
@@ -29172,6 +29768,8 @@ function recordInvocation(args, startedAt, params) {
     startedAt,
     status: params.status,
     messages: params.messages,
+    attemptedModel: args.model,
+    configuredModels: args.fallbackModels,
     ...params.completion && !params.completion.messages ? {
       tokens: params.completion.usage,
       providerId: params.completion.providerId,
@@ -29897,6 +30495,8 @@ Remember: output only the JSON object described by the system prompt.`;
       startedAt,
       status: params.status,
       messages: params.messages,
+      attemptedModel: args.model,
+      configuredModels: args.fallbackModels,
       error: params.error
     });
   };
@@ -30701,6 +31301,8 @@ async function confirmReadOnly(args, noteId, content, surfaceCondition, leaseSig
       startedAt,
       status: params.status,
       messages: params.messages,
+      attemptedModel: args.model,
+      configuredModels: args.fallbackModels,
       error: params.error
     });
   };
@@ -31367,6 +31969,7 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
         model: args.model,
         fallbackModels: args.fallbackModels,
         timeoutMs: sliceMs,
+        firstOutputTimeoutMs: args.firstOutputTimeoutMs ?? DREAMER_FIRST_OUTPUT_TIMEOUT_MS,
         signal,
         onOpened: () => {
           stage = "prompt";
@@ -31421,6 +32024,7 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
         onBudgetUpdate
       }),
       timeoutMs: sliceMs,
+      firstOutputTimeoutMs: args.firstOutputTimeoutMs ?? DREAMER_FIRST_OUTPUT_TIMEOUT_MS,
       signal,
       fallbackModels: args.fallbackModels,
       callContext: "dreamer:map-memories",
@@ -31613,12 +32217,14 @@ function recordInvocation2(args, startedAt, params) {
   recordChildInvocation({
     db: args.db,
     parentSessionId: args.parentSessionId,
-    harness: "opencode",
+    harness: args.hiddenCompletionExecutor?.capabilities.harness ?? "opencode",
     subagent: "dreamer",
     task: "map-memories",
     startedAt,
     status: params.status,
     messages: params.messages,
+    attemptedModel: args.model,
+    configuredModels: args.fallbackModels,
     error: params.error
   });
 }
@@ -32243,12 +32849,14 @@ function recordInvocation3(args, startedAt, params) {
   recordChildInvocation({
     db: args.db,
     parentSessionId: args.parentSessionId,
-    harness: "opencode",
+    harness: args.hiddenCompletionExecutor?.capabilities.harness ?? "opencode",
     subagent: "dreamer",
     task: "refresh-primers",
     startedAt,
     status: params.status,
     messages: params.messages,
+    attemptedModel: args.model,
+    configuredModels: args.fallbackModels,
     error: params.error
   });
 }
@@ -33498,6 +34106,7 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
         fallbackModels: args.fallbackModels,
         language: args.language,
         timeoutMs: sliceMs,
+        firstOutputTimeoutMs: args.firstOutputTimeoutMs ?? DREAMER_FIRST_OUTPUT_TIMEOUT_MS,
         signal: batchSignal,
         onFailureOutput: (completion) => {
           failedCompletion = completion;
@@ -33555,6 +34164,7 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
         onBudgetUpdate
       }),
       timeoutMs: sliceMs,
+      firstOutputTimeoutMs: args.firstOutputTimeoutMs ?? DREAMER_FIRST_OUTPUT_TIMEOUT_MS,
       signal: batchSignal,
       fallbackModels: args.fallbackModels,
       callContext: "dreamer:verify",
@@ -33847,12 +34457,14 @@ function recordInvocation4(args, startedAt, params) {
   recordChildInvocation({
     db: args.db,
     parentSessionId: args.parentSessionId,
-    harness: "opencode",
+    harness: args.hiddenCompletionExecutor?.capabilities.harness ?? "opencode",
     subagent: "dreamer",
     task: args.forceBroad ? "verify-broad" : "verify",
     startedAt,
     status: params.status,
     messages: params.messages,
+    attemptedModel: args.model,
+    configuredModels: args.fallbackModels,
     error: params.error
   });
 }
@@ -34728,6 +35340,25 @@ async function runRetrospectiveTask(config, ctx, helpers) {
   let childSessionId = null;
   let hiddenHandle = null;
   let promptSettled = false;
+  let invocationRecorded = false;
+  const recordInvocation = (status, messages, error) => {
+    if (!parent || !childSessionId || invocationRecorded)
+      return;
+    invocationRecorded = true;
+    recordChildInvocation({
+      db,
+      parentSessionId: parent,
+      harness: deps.hiddenCompletionExecutor?.capabilities.harness ?? "opencode",
+      subagent: "dreamer",
+      task: config.task,
+      startedAt: helpers.invocationStartedAt,
+      status,
+      messages,
+      attemptedModel: config.model,
+      configuredModels: config.fallbackModels,
+      error
+    });
+  };
   try {
     if (deps.hiddenCompletionExecutor) {
       hiddenHandle = await deps.hiddenCompletionExecutor.open({
@@ -34812,18 +35443,8 @@ async function runRetrospectiveTask(config, ctx, helpers) {
       return { ...run, output };
     };
     const finish = (run, watermark) => {
-      if (parent && run) {
-        recordChildInvocation({
-          db,
-          parentSessionId: parent,
-          harness: "opencode",
-          subagent: "dreamer",
-          task: config.task,
-          startedAt: helpers.invocationStartedAt,
-          status: "completed",
-          messages: run.output
-        });
-      }
+      if (run)
+        recordInvocation("completed", run.output);
       return completedWindow(watermark);
     };
     const userLines = renderGateUserLines(messages);
@@ -34916,6 +35537,7 @@ async function runRetrospectiveTask(config, ctx, helpers) {
     log2(`[dreamer] retrospective: flagged=${flagged.length} learnings=${learnings.length} memory=${applied.memoryWritten} observations=${applied.observationsInserted} dropped=${applied.observationsDropped} rejected=${applied.rejected.length}`);
     return finish(deepenRun, scan.maxScannedTs);
   } catch (error) {
+    recordInvocation(abortController.signal.aborted ? "aborted" : failedInvocationStatus(error), undefined, error);
     if (!detectOverflow(error).isOverflow)
       throw error;
     const failures = (activeOverflow?.failures ?? 0) + 1;
@@ -34987,6 +35609,25 @@ async function runAgenticTask(config, ctx, helpers) {
   let childSessionId = null;
   let promptSettled = false;
   let expiredArchived = 0;
+  let invocationRecorded = false;
+  const recordInvocation = (status, messages, error) => {
+    if (!parent || !childSessionId || invocationRecorded)
+      return;
+    invocationRecorded = true;
+    recordChildInvocation({
+      db,
+      parentSessionId: parent,
+      harness: deps.hiddenCompletionExecutor?.capabilities.harness ?? "opencode",
+      subagent: "dreamer",
+      task,
+      startedAt: invocationStartedAt,
+      status,
+      messages,
+      attemptedModel: config.model,
+      configuredModels: config.fallbackModels,
+      error
+    });
+  };
   try {
     let curateMemories;
     let curateCategory;
@@ -35075,6 +35716,9 @@ async function runAgenticTask(config, ctx, helpers) {
           callContext: `dreamer:${task}`,
           metadata: { tokenBudget: config.tokenBudget, onBudgetUpdate },
           allowEmpty: task === "curate",
+          onOpened: (sessionId) => {
+            childSessionId = sessionId;
+          },
           model: config.model,
           fallbackModels: config.fallbackModels,
           language: task === "curate" ? config.language ?? deps.language : undefined,
@@ -35190,18 +35834,7 @@ async function runAgenticTask(config, ctx, helpers) {
       helpers.reportProgress(curateRefused, curateRefused);
       log2(`[dreamer] curate safety summary: refused=${curateRefused}`);
     }
-    if (parent) {
-      recordChildInvocation({
-        db,
-        parentSessionId: parent,
-        harness: "opencode",
-        subagent: "dreamer",
-        task,
-        startedAt: invocationStartedAt,
-        status: "completed",
-        messages: run.output
-      });
-    }
+    recordInvocation("completed", run.output);
     if (task === "maintain-docs" && docsHashes && changes) {
       try {
         if (run.validated === "[]") {
@@ -35255,6 +35888,9 @@ async function runAgenticTask(config, ctx, helpers) {
         }
       } : {}
     };
+  } catch (error) {
+    recordInvocation(abortController.signal.aborted ? "aborted" : failedInvocationStatus(error), undefined, error);
+    throw error;
   } finally {
     heartbeat.stop();
     if (childSessionId)
@@ -36517,26 +37153,70 @@ function generateReplayAnchor(messages) {
     return;
   return { id, tail: clonePreservingInstances(messages.slice(index + 1)) };
 }
+var DEFAULT_GENERATE_REPLAY_LIMITS = Object.freeze({
+  maxSessions: 16,
+  sessionMaxBytes: 128 * 1024 * 1024,
+  totalMaxBytes: 256 * 1024 * 1024
+});
 
 class V2GenerateReplay {
   prefixes = new Map;
+  totalBytes = 0;
+  limits;
+  constructor(limits = DEFAULT_GENERATE_REPLAY_LIMITS) {
+    if (!Number.isSafeInteger(limits.maxSessions) || limits.maxSessions < 1 || !Number.isSafeInteger(limits.sessionMaxBytes) || limits.sessionMaxBytes < 1 || !Number.isSafeInteger(limits.totalMaxBytes) || limits.totalMaxBytes < 1)
+      throw new Error("Generate replay limits must be positive integers");
+    this.limits = { ...limits };
+  }
   capture(draft, anchor) {
+    this.forget(draft.sessionID);
     if (!anchor) {
-      this.prefixes.delete(draft.sessionID);
       sessionLog2(draft.sessionID, "generate replay capture skipped: no-anchor");
       return;
     }
+    const parts = {
+      anchor: clonePreservingInstancesMeasured(anchor),
+      system: clonePreservingInstancesMeasured(draft.system),
+      messages: clonePreservingInstancesMeasured(draft.messages),
+      tools: clonePreservingInstancesMeasured(draft.tools)
+    };
+    const bytes = 256 + parts.anchor.bytes + parts.system.bytes + parts.messages.bytes + parts.tools.bytes;
+    if (bytes > this.limits.sessionMaxBytes || bytes > this.limits.totalMaxBytes) {
+      sessionLog2(draft.sessionID, `generate replay capture skipped: over-session-cap (${bytes} > ${Math.min(this.limits.sessionMaxBytes, this.limits.totalMaxBytes)} bytes)`);
+      return;
+    }
+    while (this.prefixes.size > 0 && (this.prefixes.size >= this.limits.maxSessions || this.totalBytes + bytes > this.limits.totalMaxBytes)) {
+      const oldest = this.prefixes.keys().next().value;
+      if (oldest === undefined)
+        break;
+      this.forget(oldest);
+    }
     this.prefixes.set(draft.sessionID, {
-      anchor: clonePreservingInstances(anchor),
+      anchor: parts.anchor.copy,
       model: `${draft.model.providerID}/${draft.model.id}`,
       agent: draft.agent,
-      system: clonePreservingInstances(draft.system),
-      messages: clonePreservingInstances(draft.messages),
-      tools: clonePreservingInstances(draft.tools)
+      system: parts.system.copy,
+      messages: parts.messages.copy,
+      tools: parts.tools.copy,
+      bytes
     });
+    this.totalBytes += bytes;
   }
   forget(sessionID) {
+    const prefix = this.prefixes.get(sessionID);
+    if (!prefix)
+      return;
     this.prefixes.delete(sessionID);
+    this.totalBytes -= prefix.bytes;
+  }
+  stats() {
+    return {
+      totalBytes: this.totalBytes,
+      sessions: [...this.prefixes].map(([sessionId, prefix]) => ({
+        sessionId,
+        bytes: prefix.bytes
+      }))
+    };
   }
   apply(draft) {
     const prefix = this.prefixes.get(draft.sessionID);
@@ -36546,6 +37226,8 @@ class V2GenerateReplay {
     };
     if (!prefix)
       return skip("no-prefix");
+    this.prefixes.delete(draft.sessionID);
+    this.prefixes.set(draft.sessionID, prefix);
     if (prefix.model !== `${draft.model.providerID}/${draft.model.id}`)
       return skip("model-mismatch");
     if (prefix.agent !== draft.agent)
@@ -36589,21 +37271,25 @@ function identity(slot) {
 
 class V2LkgSystemReplay {
   systems = new BoundedSessionMap(1000);
-  capture(sessionId, slot, input, served) {
+  capture(sessionId, slot, input, served, head) {
     this.systems.set(sessionId, {
       slot: identity(slot),
-      input: JSON.stringify(input),
-      served: structuredClone(served)
+      input: hostInputKey(input),
+      served: structuredClone(served),
+      head: head ? structuredClone(head) : null
     });
   }
   restore(sessionId, slot, input, target) {
     const saved = this.systems.get(sessionId);
-    if (!slot || !saved || saved.slot !== identity(slot) || saved.input !== JSON.stringify(input))
-      return false;
+    if (!slot || !saved || saved.slot !== identity(slot) || saved.input !== hostInputKey(input))
+      return;
     target.splice(0, target.length, ...structuredClone(saved.served));
-    return true;
+    return { head: saved.head ? structuredClone(saved.head) : null };
   }
 }
+function hostInputKey(input) {
+  return JSON.stringify({ system: input.system, checkpoint: input.checkpoint });
+}
 
 // src/v2/hooks/model-limit-cache.ts
 var warmStarted = false;
@@ -49634,6 +50320,7 @@ function renderItemByTag(db, sessionId, number, textIndexDomain = "part") {
 }
 
 // src/tools/ctx-expand/tools.ts
+var CTX_EXPAND_RUST_TAG_REFUSAL = "Tag lookup isn't available on this session: its §N§ tags are numbered by the Rust transform engine and ctx_expand cannot resolve those numbers, so no content was returned. Expand by message instead: ctx_expand(message=<ordinal>) or ctx_expand(start=<ordinal>, end=<ordinal>), using ordinals from a <session-history> heading or a ctx_search hit.";
 var ctxExpandArgsShape = {
   tag: tool.schema.union([tool.schema.number(), tool.schema.string()]).optional().describe("Tag number from a §N§ tag or a [dropped §N§] placeholder, not a message ordinal. Returns that one item in full. Use alone."),
   start: tool.schema.number().optional().describe("First message ordinal of the range (a <session-history> heading's start, or a ctx_search hit), not a tag number."),
@@ -49656,9 +50343,12 @@ function createCtxExpandTool(deps) {
         message: "number"
       });
       const sessionId = toolContext.sessionID;
+      const mode = resolveCtxExpandMode(args, "positive");
+      if (mode.kind === "tag" && deps.transformMode === "rust") {
+        return CTX_EXPAND_RUST_TAG_REFUSAL;
+      }
       if (!await prepareRawSessionOrdinals2(sessionId))
         return "Session ordinals are warming in the background. Retry ctx_expand shortly; no approximate ordinal was served.";
-      const mode = resolveCtxExpandMode(args, "positive");
       if (mode.kind === "error") {
         return mode.message;
       }
@@ -51233,7 +51923,7 @@ function createCtxReduceTool(deps) {
       args = unwrapImitatedReducedArgs(args, ["drop"], { drop: "string" });
       const sessionId = toolContext.sessionID;
       if (!args.drop) {
-        return "Error: 'drop' must be provided.";
+        return `Error: 'drop' must be provided as a string of tag numbers, for example {"drop": "3-5,8"}.`;
       }
       const rustReduce = deps.rustToolBackends?.reduce;
       if (rustReduce) {
@@ -51518,6 +52208,7 @@ function createCtxSearchTool(deps) {
         explicitSearch: true,
         rerankConnectionFile: deps.rerankConnectionFile,
         searchMessageHistory: (request) => searchMessageHistoryOffThread(deps.db, request),
+        signal: toolContext.abort,
         ...dateRange
       });
       return formatSearchResults2(query, results, toolContext.sessionID, diagnostics);
@@ -51545,7 +52236,11 @@ async function registerTools(context, db, config, rustToolBackends, isInternalCh
       getProtectionWindow: (sessionID) => getProtectionWindowForSession(db, sessionID, getObservedEpochFloor(db, sessionID)),
       ...rustToolBackends ? { rustToolBackends } : {}
     }) : {},
-    ...createCtxExpandTools({ db, expandTools: config.historian?.expand_tools }),
+    ...createCtxExpandTools({
+      db,
+      expandTools: config.historian?.expand_tools,
+      transformMode: config.transform_mode
+    }),
     ...createCtxNoteTools({
       ...project,
       dreamerEnabled: isDreamerRunnable(config),
@@ -51632,6 +52327,13 @@ function bindV2TransformDecision(args) {
 }
 
 // src/hooks/magic-context/auto-embed-session.ts
+function localPoolingPreflightPending(projectIdentity) {
+  const snapshot = getProjectEmbeddingSnapshot2(projectIdentity);
+  if (snapshot?.provider !== "local")
+    return false;
+  const metadata = getCachedLocalEmbeddingPooling(snapshot.model);
+  return !metadata || metadata.status === "unresolved";
+}
 function embeddingIdentity(projectIdentity) {
   const snapshot = getProjectEmbeddingSnapshot2(projectIdentity);
   return JSON.stringify([
@@ -51652,7 +52354,8 @@ function maybeAutoEmbedSessionBackfill(deps, sessionId) {
     invalidateAutoEmbedSession(sessionId);
     autoEmbedIdentityBySession.set(sessionId, identity);
   }
-  if (autoEmbedAttemptedBySession.has(sessionId) || embedPauseBySession.has(sessionId) || embedRunStateBySession.has(sessionId) || Date.now() < (autoEmbedRetryAfterBySession.get(sessionId) ?? 0))
+  const poolingPreflightPending = localPoolingPreflightPending(deps.projectIdentity);
+  if (embedPauseBySession.has(sessionId) || embedRunStateBySession.has(sessionId) || Date.now() < (autoEmbedRetryAfterBySession.get(sessionId) ?? 0) || autoEmbedAttemptedBySession.has(sessionId) && !poolingPreflightPending)
     return;
   const controller = new AbortController;
   embedRunStateBySession.set(sessionId, controller);
@@ -51662,6 +52365,7 @@ function maybeAutoEmbedSessionBackfill(deps, sessionId) {
     let started = false;
     let reason = "error";
     let registeredIdentity = identity;
+    let poolingPendingAfterRegistration = poolingPreflightPending;
     try {
       await new Promise((resolve) => setTimeout(resolve, 0));
       if (controller.signal.aborted)
@@ -51669,6 +52373,7 @@ function maybeAutoEmbedSessionBackfill(deps, sessionId) {
       await deps.ensureRegistered();
       if (controller.signal.aborted)
         return;
+      poolingPendingAfterRegistration = localPoolingPreflightPending(deps.projectIdentity);
       markActive();
       registeredIdentity = embeddingIdentity(deps.projectIdentity);
       autoEmbedIdentityBySession.set(sessionId, registeredIdentity);
@@ -51676,7 +52381,9 @@ function maybeAutoEmbedSessionBackfill(deps, sessionId) {
       if (controller.signal.aborted || !coverage.enabled)
         return;
       if (coverage.embedded === coverage.total) {
-        complete = true;
+        complete = !poolingPendingAfterRegistration;
+        if (!complete)
+          retryDelay = 60000;
         return;
       }
       const model = getProjectEmbeddingSnapshot2(deps.projectIdentity)?.model;
@@ -51685,8 +52392,11 @@ function maybeAutoEmbedSessionBackfill(deps, sessionId) {
       const outcome = await embedSessionCompartmentChunks2(deps.db, deps.projectIdentity, sessionId, { signal: controller.signal, automatic: true });
       reason = outcome.status;
       const after = await getAutoEmbeddingSessionCoverage2(deps.db, deps.projectIdentity, sessionId);
-      complete = after.enabled && after.embedded === after.total;
-      if (!complete && outcome.status !== "busy" && outcome.status !== "aborted") {
+      complete = after.enabled && after.embedded === after.total && !poolingPendingAfterRegistration;
+      if (poolingPendingAfterRegistration) {
+        retryDelay = 60000;
+        reason = "pooling metadata unavailable";
+      } else if (!complete && outcome.status !== "busy" && outcome.status !== "aborted") {
         retryDelay = 60000;
         if (outcome.status === "nothing" || outcome.status === "done")
           reason = "deferred";
@@ -51842,6 +52552,26 @@ function persistV2UsageReading(args) {
 // src/v2/hooks/context.ts
 class V2LkgAdmissionReplay extends Error {
 }
+function applyCheckpointHead(draft, head) {
+  const { checkpoint, submitted } = head;
+  const first = draft.messages.find((message) => message.id === HEAD_IDS[0]);
+  const baseline = first?.content.find((part) => part.type === "text")?.text;
+  if (typeof baseline !== "string")
+    return false;
+  for (const part of checkpoint.content)
+    if (part.type === "text" && typeof part.text === "string") {
+      part.text = part.text.replace(`<summary>
+${submitted}
+</summary>`, `<summary>
+${baseline}
+</summary>`);
+    }
+  const volatile = draft.messages.find((message) => message.id === HEAD_IDS[1]);
+  if (volatile && first)
+    volatile.content.push(...first.content.filter((part) => part.type !== "text"));
+  draft.messages.splice(0, draft.messages.length, checkpoint, ...draft.messages.filter((message) => message !== first));
+  return true;
+}
 var HIDDEN_SESSION_ERROR_GRACE_MS = 50;
 var STORE_POOL_DISPOSE_WAIT_MS = 1000;
 function isBlockingV2TransformError(error) {
@@ -52074,6 +52804,7 @@ async function registerContext(context) {
   const queriedModels = new Set;
   const rawLimits = new Map;
   const hiddenSessionErrors = new Map;
+  const hiddenModelActivity = new HiddenModelActivity;
   const liveModels = new Map;
   const promptSurfaceRuntime = createPromptSurfaceRuntime({
     harness: "opencode2",
@@ -52168,6 +52899,7 @@ async function registerContext(context) {
     await cleanupLegacyOnce(database);
     return createV2HiddenCompletionExecutor({
       ...context.session,
+      watchModelActivity: (sessionID, onOutput) => hiddenModelActivity.watch(sessionID, onOutput),
       get: async (input) => {
         const session = await context.session.get(input);
         const error = hiddenSessionErrors.get(input.sessionID);
@@ -52509,6 +53241,7 @@ async function registerContext(context) {
             break;
           const event = value;
           try {
+            hiddenModelActivity.observe(event);
             if (event.type === "provider.updated" || event.type === "model.updated") {
               queriedModels.clear();
               continue;
@@ -52543,34 +53276,47 @@ async function registerContext(context) {
             if (event.type === "session.deleted") {
               clearLkgMeasuredRequest(sessionID);
               deletedSessions.add(sessionID);
-              transform?.clearSessionLogState(sessionID);
-              if (db) {
-                markSessionCleanupPending(db, sessionID);
-                clearSession(db, sessionID);
+              const failures = [];
+              try {
+                transform?.clearSessionLogState(sessionID);
+                if (db) {
+                  markSessionCleanupPending(db, sessionID);
+                  clearSession(db, sessionID, false, true);
+                }
+              } catch (error) {
+                failures.push(error);
               }
-              rawProviders.get(sessionID)?.();
-              rawProviders.delete(sessionID);
-              usage.delete(sessionID);
-              hiddenSessionErrors.delete(sessionID);
-              storageNoticeBySession.delete(sessionID);
-              liveModels.delete(sessionID);
-              variants.delete(sessionID);
-              agents.delete(sessionID);
-              channel1.delete(sessionID);
-              commitSeenLastPass.delete(sessionID);
-              clearEmbedSessionState(sessionID);
-              historyRefreshSessions.delete(sessionID);
-              clearPendingMaterialization(pendingMaterializationSessions, sessionID);
-              lastHeuristicsTurnId.delete(sessionID);
-              restoredRows.forget(sessionID);
-              if (nativeFoldReplay)
-                await nativeFoldReplay.forget(sessionID);
-              else
-                await forgetNativeFoldProvenance(context.storage, sessionID);
-              generateReplay.forget(sessionID);
-              systemPromptRefreshSessions.delete(sessionID);
-              systemPrompt?.clearSession(sessionID);
-              tagger.cleanup(sessionID);
+              try {
+                rawProviders.get(sessionID)?.();
+                rawProviders.delete(sessionID);
+                usage.delete(sessionID);
+                hiddenSessionErrors.delete(sessionID);
+                storageNoticeBySession.delete(sessionID);
+                liveModels.delete(sessionID);
+                variants.delete(sessionID);
+                agents.delete(sessionID);
+                channel1.delete(sessionID);
+                commitSeenLastPass.delete(sessionID);
+                clearEmbedSessionState(sessionID);
+                historyRefreshSessions.delete(sessionID);
+                clearPendingMaterialization(pendingMaterializationSessions, sessionID);
+                lastHeuristicsTurnId.delete(sessionID);
+                restoredRows.forget(sessionID);
+                if (nativeFoldReplay)
+                  await nativeFoldReplay.forget(sessionID);
+                else
+                  await forgetNativeFoldProvenance(context.storage, sessionID);
+                generateReplay.forget(sessionID);
+                systemPromptRefreshSessions.delete(sessionID);
+                systemPrompt?.clearSession(sessionID);
+                tagger.cleanup(sessionID);
+              } catch (error) {
+                failures.push(error);
+              }
+              if (failures.length === 1)
+                throw failures[0];
+              if (failures.length > 1)
+                throw new AggregateError(failures, "session deletion failed in both the store clear and the in-memory cleanup");
               continue;
             }
             if (event.type !== "session.execution.succeeded")
@@ -52688,6 +53434,42 @@ async function registerContext(context) {
       reader.close();
     }
   });
+  const temporalTimes = config.temporal_awareness === true;
+  const anchorTimesOnly = !temporalTimes && !rustModeModuleClient;
+  const timeIds = (messages) => {
+    if (temporalTimes)
+      return messages.flatMap((message) => message.id ? [message.id] : []);
+    if (!anchorTimesOnly)
+      return [];
+    const ids = [];
+    for (const message of [...messages].reverse()) {
+      if (message.id)
+        ids.push(message.id);
+      if (message.role === "assistant")
+        break;
+    }
+    return ids;
+  };
+  const restoreAfterCheckpoint = (args) => {
+    const { db, reader, draft, cut, boundaryRepair } = args;
+    const moduleBoundaryID = rustModeModuleClient ? getPersistedCompactionMarkerState(db, draft.sessionID)?.boundaryMessageId ?? null : null;
+    const moduleBoundarySeq = moduleBoundaryID ? reader.sequenceForId(draft.sessionID, moduleBoundaryID) : undefined;
+    const boundaryID = db.prepare("SELECT cached_m0_last_baseline_end_message_id AS id FROM session_meta WHERE session_id = ?").get(draft.sessionID)?.id ?? (boundaryRepair?.kind === "repaired" || boundaryRepair?.kind === "baseline-reset" ? boundaryRepair.anchorEndMessageId : null);
+    const servedBoundary = boundaryID ? servedBoundaryRow(reader, draft.sessionID, boundaryID) : null;
+    const boundary = (nativeFoldReplay?.sourceChanged(draft.sessionID) && !rustModeModuleClient ? (reader.earliestSequence(draft.sessionID) ?? 0) - 1 : undefined) ?? (moduleBoundarySeq !== undefined ? moduleBoundarySeq - 1 : undefined) ?? servedBoundary?.seq ?? reader.sequenceForId(draft.sessionID, boundaryID) ?? (reader.earliestSequence(draft.sessionID) ?? 0) - 1;
+    if (moduleBoundarySeq !== undefined)
+      sessionLog2(draft.sessionID, `v2 restore: from the module boundary ${moduleBoundaryID} to the host checkpoint`);
+    const present = new Set(args.messages.map((message) => message.id));
+    const restored = restoredRows.rows(reader, draft.sessionID, boundary, cut.seq).filter((row) => !present.has(row.id)).flatMap((row) => restoreRow(row, draft.model, hostUsesMediaAssets() ? {
+      asset: hostMediaAsset,
+      unavailable: (detail) => sessionLog2(draft.sessionID, `v2 restore: attachment replaced by a note row=${detail.rowID} name=${JSON.stringify(detail.name ?? null)} mediaType=${detail.mediaType} reason=${JSON.stringify(detail.reason)}`)
+    } : undefined));
+    return [
+      ...rustModeModuleClient ? [] : coveredInstructionRows(reader, draft.sessionID, Math.min(boundary, cut.seq), draft.model),
+      ...restored,
+      ...args.messages.filter((message) => message !== args.incoming)
+    ];
+  };
   const runManagedContext = async (draft) => {
     rememberHostMedia(draft.messages);
     if (hiddenChildHook.apply(draft))
@@ -52699,12 +53481,18 @@ async function registerContext(context) {
       return;
     const systemAtEntry = structuredClone(draft.system);
     const slotAtEntry = getSlot(draft.sessionID);
+    let checkpointAtEntry;
+    let replayHead;
+    const hostInput = () => checkpointAtEntry === undefined ? undefined : { system: systemAtEntry, checkpoint: checkpointAtEntry };
     const restoreLkgSystem = () => {
       retirePendingSystemPromptDelivery(draft.sessionID);
-      if (!lkgSystems.restore(draft.sessionID, getSlot(draft.sessionID), systemAtEntry, draft.system)) {
+      const input = hostInput();
+      const restored = input && lkgSystems.restore(draft.sessionID, getSlot(draft.sessionID), input, draft.system);
+      if (!restored) {
         sessionLog2(draft.sessionID, "lkg_system_state_mismatch");
         throw new Error("LKG system identity is unavailable or changed");
       }
+      replayHead = restored.head;
     };
     const isMagicContextSynthetic = (id) => isAdmittedSynthetic(context, draft.sessionID, id);
     const newest = draft.messages.at(-1);
@@ -52713,6 +53501,24 @@ async function registerContext(context) {
       return;
     }
     await dropStorageNotices(draft.messages, isMagicContextSynthetic);
+    const hostMessagesAtEntry = [...draft.messages];
+    const passTimes = new Map;
+    const readTimes = (reader, messages) => {
+      const ids = timeIds(messages);
+      const missing = ids.filter((id) => !passTimes.has(id));
+      if (missing.length > 0) {
+        const read = reader.messageTimes(draft.sessionID, missing);
+        for (const id of missing)
+          passTimes.set(id, read.get(id) ?? null);
+      }
+      const times = new Map;
+      for (const id of ids) {
+        const time = passTimes.get(id);
+        if (time)
+          times.set(id, time);
+      }
+      return times;
+    };
     liveModels.set(draft.sessionID, {
       providerID: draft.model.providerID,
       modelID: draft.model.id
@@ -52724,8 +53530,9 @@ async function registerContext(context) {
     applyV2PromptSurfaceTools(draft, promptSurfaceRuntime, config.prompt_surface, isSmartNoteSurfaceAvailable(config));
     const admissionDb = db ?? storage.current();
     const replayFits = (messages) => {
-      const system = structuredClone(draft.system);
-      if (!admissionDb || !draft.tools || !lkgSystems.restore(draft.sessionID, getSlot(draft.sessionID), draft.system, system))
+      const system = [];
+      const input = hostInput();
+      if (!admissionDb || !draft.tools || !input || !lkgSystems.restore(draft.sessionID, getSlot(draft.sessionID), input, system))
         return false;
       const limit = lkgReplayLimit({
         db: admissionDb,
@@ -52760,14 +53567,75 @@ async function registerContext(context) {
         })
       }).fit === "under";
     };
+    const buildReplayInput = async () => {
+      let messages = [...hostMessagesAtEntry];
+      const admitted = new Set;
+      let times;
+      try {
+        const reader = openStoreReader();
+        try {
+          const cut = reader.latestCompaction(draft.sessionID);
+          const localCut = cut && isLocalCheckpoint(cut) ? cut : undefined;
+          const incoming = localCut && messages.find((message) => message.id === localCut.id);
+          if (localCut && !incoming || cut && nativeFoldReplay)
+            return;
+          checkpointAtEntry = incoming || null;
+          const modeDb = db ?? storage.current();
+          const subagent = modeDb ? storedSubagentMode(modeDb, draft.sessionID) : undefined;
+          if (subagent === undefined)
+            return;
+          if (subagent)
+            removePrimaryOnlyTools(draft.tools);
+          if (!rustModeModuleClient) {
+            const candidates = syntheticCandidates(context, draft.sessionID, reader.syntheticMessageIDs(draft.sessionID));
+            for (const message of messages)
+              if (message.id && candidates.has(message.id) && await isAdmittedSynthetic(context, draft.sessionID, message.id))
+                admitted.add(message.id);
+            const replayDb = db ?? storage.current();
+            if (localCut && incoming && replayDb)
+              messages = restoreAfterCheckpoint({
+                db: replayDb,
+                reader,
+                draft,
+                messages,
+                cut: localCut,
+                incoming,
+                boundaryRepair: undefined
+              });
+            else if (localCut)
+              return;
+            times = readTimes(reader, messages);
+          }
+        } finally {
+          reader.close();
+        }
+      } catch (error) {
+        sessionLog2(draft.sessionID, "lkg replay input unavailable", error);
+        return;
+      }
+      const replayDraft = { ...draft, messages };
+      return {
+        draft: replayDraft,
+        mapped: adaptPayload(replayDraft, admitted, times, anchorTimesOnly)
+      };
+    };
+    const adoptReplay = (replayed) => {
+      if (replayed !== draft)
+        draft.messages.splice(0, draft.messages.length, ...replayed.messages);
+      if (replayHead)
+        applyCheckpointHead(draft, replayHead);
+    };
     let postFold = false;
     try {
       if (!compactionOff && admissionDb)
         await withAsyncPrivilegedWriter2(admissionDb, () => {
           return;
         }, {
-          beforeRetry: (error) => {
-            const mapped = adaptPayload(draft);
+          beforeRetry: async (error) => {
+            const input = await buildReplayInput();
+            if (!input)
+              return;
+            const { mapped } = input;
             if (tryMessagesTransformLkgReplay({
               output: mapped,
               sessionId: draft.sessionID,
@@ -52778,6 +53646,7 @@ async function registerContext(context) {
               onLkgReplay: restoreLkgSystem
             })) {
               mapped.commit();
+              adoptReplay(input.draft);
               throw new V2LkgAdmissionReplay;
             }
           }
@@ -52972,6 +53841,7 @@ async function registerContext(context) {
         postFold = cut !== undefined;
         if (localCut && !incoming)
           throw new Error("The host checkpoint disappeared from the context draft");
+        checkpointAtEntry = incoming || null;
         let nativeRestored;
         if (cut && nativeFoldReplay && await nativeFoldReplay.admits(draft.sessionID, cut, reader)) {
           try {
@@ -53013,22 +53883,17 @@ async function registerContext(context) {
             checkpoint = structuredClone(identity.rendered ?? incoming);
             submitted = identity.rendered ? identity.renderedSummary ?? identity.submitted : cut.data.summary ?? "";
           }
-          const moduleBoundaryID = rustModeModuleClient ? getPersistedCompactionMarkerState(db, draft.sessionID)?.boundaryMessageId ?? null : null;
-          const moduleBoundarySeq = moduleBoundaryID ? reader.sequenceForId(draft.sessionID, moduleBoundaryID) : undefined;
-          const boundaryID = db.prepare("SELECT cached_m0_last_baseline_end_message_id AS id FROM session_meta WHERE session_id = ?").get(draft.sessionID)?.id ?? (boundaryRepair?.kind === "repaired" || boundaryRepair?.kind === "baseline-reset" ? boundaryRepair.anchorEndMessageId : null);
-          const servedBoundary = boundaryID ? servedBoundaryRow(reader, draft.sessionID, boundaryID) : null;
-          const boundary = (nativeFoldReplay?.sourceChanged(draft.sessionID) && !rustModeModuleClient ? (reader.earliestSequence(draft.sessionID) ?? 0) - 1 : undefined) ?? (moduleBoundarySeq !== undefined ? moduleBoundarySeq - 1 : undefined) ?? servedBoundary?.seq ?? reader.sequenceForId(draft.sessionID, boundaryID) ?? (reader.earliestSequence(draft.sessionID) ?? 0) - 1;
-          if (moduleBoundarySeq !== undefined)
-            sessionLog2(draft.sessionID, `v2 restore: from the module boundary ${moduleBoundaryID} to the host checkpoint`);
-          const present = new Set(draft.messages.map((message) => message.id));
-          const restored = restoredRows.rows(reader, draft.sessionID, boundary, cut.seq).filter((row) => !present.has(row.id)).flatMap((row) => restoreRow(row, draft.model, hostUsesMediaAssets() ? {
-            asset: hostMediaAsset,
-            unavailable: (detail) => sessionLog2(draft.sessionID, `v2 restore: attachment replaced by a note row=${detail.rowID} name=${JSON.stringify(detail.name ?? null)} mediaType=${detail.mediaType} reason=${JSON.stringify(detail.reason)}`)
-          } : undefined));
-          draft.messages.splice(0, draft.messages.length, ...rustModeModuleClient ? [] : coveredInstructionRows(reader, draft.sessionID, Math.min(boundary, cut.seq), draft.model), ...restored, ...draft.messages.filter((message) => message !== incoming));
-        }
-        if (config.temporal_awareness === true)
-          messageTimes = reader.messageTimes(draft.sessionID, draft.messages.flatMap((message) => message.id ? [message.id] : []));
+          draft.messages.splice(0, draft.messages.length, ...restoreAfterCheckpoint({
+            db,
+            reader,
+            draft,
+            messages: draft.messages,
+            cut: localCut,
+            incoming,
+            boundaryRepair
+          }));
+        }
+        messageTimes = readTimes(reader, draft.messages);
       } finally {
         reader.close();
       }
@@ -53045,7 +53910,7 @@ async function registerContext(context) {
           nativeFoldReplay.invalidate(draft.sessionID, true);
         }
       }
-      const mapped = adaptPayload(draft, admitted, messageTimes);
+      const mapped = adaptPayload(draft, admitted, messageTimes, anchorTimesOnly);
       bindSystemDateRequestIdentity(mapped, draft);
       await createMessagesTransformHandler({
         magicContext: { "experimental.chat.messages.transform": transform },
@@ -53062,24 +53927,9 @@ async function registerContext(context) {
       if (db) {
         await deliverPendingChannel2(context, db, draft.sessionID, channel1.get(draft.sessionID));
       }
-      if (checkpoint && submitted !== undefined) {
-        const head = draft.messages.find((message) => message.id === HEAD_IDS[0]);
-        const baseline = head?.content.find((part) => part.type === "text")?.text;
-        if (typeof baseline === "string") {
-          for (const part of checkpoint.content)
-            if (part.type === "text" && typeof part.text === "string") {
-              part.text = part.text.replace(`<summary>
-${submitted}
-</summary>`, `<summary>
-${baseline}
-</summary>`);
-            }
-          const volatile = draft.messages.find((message) => message.id === HEAD_IDS[1]);
-          if (volatile && head)
-            volatile.content.push(...head.content.filter((part) => part.type !== "text"));
-          draft.messages.splice(0, draft.messages.length, checkpoint, ...draft.messages.filter((message) => message !== head));
-        }
-      }
+      const head = replayHead !== undefined ? replayHead : checkpoint && submitted !== undefined ? { checkpoint, submitted } : null;
+      const servedHead = head && structuredClone(head);
+      const headApplied = head ? applyCheckpointHead(draft, head) : false;
       if (nativeMessages && !checkpoint) {
         try {
           await nativeFoldReplay?.capture(draft, nativeMessages);
@@ -53090,7 +53940,7 @@ ${baseline}
       }
       const capturedSlot = getSlot(draft.sessionID);
       if (capturedSlot && (!slotAtEntry || capturedSlot.capturedAt !== slotAtEntry.capturedAt || capturedSlot.captureSequence !== slotAtEntry.captureSequence || capturedSlot.jsonPrefix !== slotAtEntry.jsonPrefix)) {
-        lkgSystems.capture(draft.sessionID, capturedSlot, systemAtEntry, draft.system);
+        lkgSystems.capture(draft.sessionID, capturedSlot, { system: systemAtEntry, checkpoint: checkpointAtEntry ?? null }, draft.system, headApplied ? servedHead : null);
       }
     } catch (error) {
       if (error instanceof V2LkgAdmissionReplay)
@@ -53099,8 +53949,11 @@ ${baseline}
         throw error;
       if (!compactionOff && (isTransientSqliteError2(error) || error instanceof StorageBusyRefusalError)) {
         if (isTransientSqliteError2(error)) {
-          const mapped = adaptPayload(draft);
+          const input = await buildReplayInput();
           try {
+            if (!input)
+              throw new StorageBusyRefusalError(error, "v2-context");
+            const { mapped } = input;
             await createMessagesTransformHandler({
               replayFits,
               onLkgReplay: restoreLkgSystem,
@@ -53112,6 +53965,7 @@ ${baseline}
               }
             })({}, mapped);
             mapped.commit();
+            adoptReplay(input.draft);
             return;
           } catch (replayError) {
             if (!(replayError instanceof StorageBusyRefusalError))
@@ -53193,7 +54047,8 @@ ${baseline}
         return null;
       }
     },
-    storageDir
+    storageDir,
+    getDebugMemoryHolders: () => ({ generateReplay: generateReplay.stats() })
   });
   rpcServer.handle("dream", async (params) => {
     const sessionId = String(params.sessionId ?? "");