@cortexkit/opencode-magic-context 0.49.30 → 0.49.32

package/dist/v2/{context-wx4sfhgr.js → context-ehews84p.js}

@@ -304,7 +304,7 @@ import {
   startCompartmentAgent,
   setRecompStarting2,
   setRecompTerminal2
-} from "./server-k33t88h3.js";
+} from "./server-4n176b5m.js";
 import {
   resolveHistorianModel2
 } from "./server-5kym00ag.js";
@@ -712,13 +712,34 @@ import {
 import {
   cleanSearchText,
   matchedSearchSnippet,
-  getLastIndexedOrdinal,
-  getMessageIndexReconciliationStartOrdinal,
-  isMessageIndexReconciledThrough,
-  clearIndexedMessages,
-  indexMessagesAfterOrdinal
+  getLastIndexedOrdinal
 } from "./server-hwag0khr.js";
 import"./server-awr8qa4c.js";
+import {
+  getMessageIndexEpoch,
+  isMessageIndexSearchable,
+  scheduleReconciliation,
+  scheduleClearAndReindex,
+  getMessageIndexQueueHeapStats,
+  renderSingleStoreMigrationRequiredRefusal,
+  SingleStoreMigrationRequiredError,
+  singleStoreMigrationRequiredFailure,
+  projectNeedsSingleStoreMigration,
+  STORE_AHEAD_OF_BINARY_CODE,
+  storeAheadOfBinaryFailure,
+  TRANSFORM_PAGE_UPLOAD_TIMEOUT_MS,
+  transformColdStartExecuteTimeoutMs,
+  getDefaultSubcConnectionFile,
+  isModuleTransportGenerationChangedResult,
+  SubcModuleTransport,
+  indexCommitsForProject,
+  embedUnembeddedCommits,
+  createUnifiedSearchDiagnostics2,
+  parseIdShapedQuery2,
+  resolveMemoriesByIdsForSearch2,
+  unifiedSearch2,
+  formatSearchResults2
+} from "./server-n14edf07.js";
 import {
   embedPauseBySession,
   embedRunStateBySession,
@@ -748,7 +769,7 @@ import {
   embedSessionCompartmentChunks2,
   getEmbeddingCoverageStatus2,
   getAutoEmbeddingSessionCoverage2
-} from "./server-zh3esb0z.js";
+} from "./server-ab8017gw.js";
 import {
   SubcClient,
   connectionFileExists,
@@ -759,7 +780,7 @@ import {
 } from "./server-ab1g0wn9.js";
 import {
   deleteChunkEmbedBackoffForSession2
-} from "./server-4sn3at8p.js";
+} from "./server-h1byrhwx.js";
 import {
   registerOwnRpcServerInstance,
   rpcPortDir,
@@ -825,7 +846,7 @@ import {
   readGitFileChangeTimesSince,
   verificationFileExists,
   normalizeVerificationFiles
-} from "./server-ph300d6m.js";
+} from "./server-tkdabx8q.js";
 import {
   deriveTriggerBudget2,
   deriveHistorianChunkTokens2,
@@ -859,7 +880,7 @@ import {
 } from "./server-vr4szghm.js";
 import {
   cosineSimilarity
-} from "./server-p0snacz3.js";
+} from "./server-2aasmpsp.js";
 import {
   computeCueContentHash,
   hasMuralCueColumns,
@@ -897,26 +918,6 @@ import {
   flushIgnoredMessages2,
   sendStatusNotification2
 } from "./server-qc915kw2.js";
-import {
-  renderSingleStoreMigrationRequiredRefusal,
-  SingleStoreMigrationRequiredError,
-  singleStoreMigrationRequiredFailure,
-  projectNeedsSingleStoreMigration,
-  STORE_AHEAD_OF_BINARY_CODE,
-  storeAheadOfBinaryFailure,
-  TRANSFORM_PAGE_UPLOAD_TIMEOUT_MS,
-  transformColdStartExecuteTimeoutMs,
-  getDefaultSubcConnectionFile,
-  isModuleTransportGenerationChangedResult,
-  SubcModuleTransport,
-  indexCommitsForProject,
-  embedUnembeddedCommits,
-  createUnifiedSearchDiagnostics2,
-  parseIdShapedQuery2,
-  resolveMemoriesByIdsForSearch2,
-  unifiedSearch2,
-  formatSearchResults2
-} from "./server-42nebt63.js";
 import {
   resolvePromptContext2
 } from "./server-fmsr7v69.js";
@@ -1739,234 +1740,6 @@ function summarizeManualDream(summary) {
 `);
 }
 
-// src/features/magic-context/message-index-async.ts
-var indexCancellations = new Map;
-var sessionEpochs = new Map;
-var workerMeasurements = new WeakMap;
-function isDatabaseLockedError(error) {
-  if (!error || typeof error !== "object")
-    return false;
-  const e = error;
-  if (typeof e.code === "string") {
-    if (e.code === "SQLITE_BUSY" || e.code === "SQLITE_LOCKED")
-      return true;
-  }
-  if (typeof e.message === "string") {
-    if (/database is locked/i.test(e.message))
-      return true;
-    if (/sqlite_(busy|locked)/i.test(e.message))
-      return true;
-  }
-  return false;
-}
-var RECONCILIATION_BATCH_SIZE = 100;
-
-class MagicContextMessageIndexHeapHolder {
-  reconciledSessions = new Set;
-  reconciledSnapshots = new Map;
-  stalledSessions = new Set;
-  reconciliationScheduledSessions = new Set;
-  clearAndReindexScheduledSessions = new Map;
-  sessionLocks = new Map;
-  incrementalTimers = new Map;
-  pendingIncrementalKeys = new Set;
-  completedIncrementalKeys = new Set;
-  activeReconcilerBuffers = new Map;
-}
-var heapHolder = new MagicContextMessageIndexHeapHolder;
-function clearCompletedIncrementalKeys(sessionId) {
-  const prefix = `${sessionId}\x00`;
-  for (const key of heapHolder.completedIncrementalKeys) {
-    if (key.startsWith(prefix))
-      heapHolder.completedIncrementalKeys.delete(key);
-  }
-}
-var PREPARE_RETRY_MS = 60000;
-async function sourceReady(source, sessionId) {
-  const prepare = source?.prepare;
-  return typeof prepare === "function" ? prepare(sessionId) : true;
-}
-function defer(fn) {
-  const immediate = globalThis.setImmediate;
-  if (typeof immediate === "function") {
-    inRootAsyncContext2(() => immediate(fn));
-    return;
-  }
-  inRootAsyncContext2(() => setTimeout(fn, 0));
-}
-function yieldToEventLoop() {
-  return new Promise((resolve) => defer(resolve));
-}
-function runWithSessionLock(sessionId, operation) {
-  const previous = heapHolder.sessionLocks.get(sessionId) ?? Promise.resolve();
-  const run = previous.catch(() => {
-    return;
-  }).then(async () => {
-    await operation();
-  });
-  heapHolder.sessionLocks.set(sessionId, run);
-  run.finally(() => {
-    if (heapHolder.sessionLocks.get(sessionId) === run) {
-      heapHolder.sessionLocks.delete(sessionId);
-    }
-  }).catch(() => {
-    return;
-  });
-  return run;
-}
-function logIndexingError(sessionId, action, error) {
-  if (isDatabaseLockedError(error)) {
-    sessionLog2(sessionId, `message FTS async ${action} skipped (database busy; will retry on next reconciliation)`);
-    return;
-  }
-  sessionLog2(sessionId, `message FTS async ${action} failed: ${error instanceof Error ? error.message : String(error)}`);
-  log2(`[message-index-async] ${action} failed for ${sessionId}:`, error);
-}
-function serializedMessageBytes(messages) {
-  try {
-    return Buffer.byteLength(JSON.stringify(messages));
-  } catch {
-    return 0;
-  }
-}
-function logReconciliationStall(sessionId, reason) {
-  if (heapHolder.stalledSessions.has(sessionId))
-    return;
-  heapHolder.stalledSessions.add(sessionId);
-  sessionLog2(sessionId, `message FTS reconciliation stalled: ${reason}; will retry`);
-}
-async function reconcileSessionIndex(db, sessionId, readMessages) {
-  if (!await sourceReady(readMessages, sessionId)) {
-    logReconciliationStall(sessionId, "raw message reader is not ready");
-    return false;
-  }
-  await runWithSessionLock(sessionId, async () => {
-    if (!readMessages.getRevision && heapHolder.reconciledSessions.has(sessionId))
-      return;
-    let fallbackSnapshot = null;
-    try {
-      const fullReader = typeof readMessages === "function" ? readMessages : null;
-      const revision = readMessages.getRevision?.(sessionId);
-      const previous = heapHolder.reconciledSnapshots.get(sessionId);
-      const finalWatermark = previous && revision === previous.revision ? previous.count : revision !== undefined && readMessages.getCountAfterRevision ? previous && revision > previous.revision ? previous.count + readMessages.getCountAfterRevision(sessionId, previous.revision, revision) : readMessages.getCountAfterRevision(sessionId, -1, revision) : readMessages.getCount ? readMessages.getCount(sessionId) : (fallbackSnapshot = fullReader?.(sessionId) ?? []).length;
-      let cursor = getMessageIndexReconciliationStartOrdinal(db, sessionId);
-      let after = cursor === previous?.count ? previous.after : undefined;
-      while (cursor < finalWatermark) {
-        const pageEnd = Math.min(finalWatermark, cursor + RECONCILIATION_BATCH_SIZE);
-        const messages = readMessages.readPage ? readMessages.readPage(sessionId, cursor, RECONCILIATION_BATCH_SIZE, finalWatermark, after) : (fallbackSnapshot ?? []).filter((message) => message.ordinal > cursor && message.ordinal <= pageEnd);
-        const retainedMessages = fallbackSnapshot ?? messages;
-        heapHolder.activeReconcilerBuffers.set(sessionId, retainedMessages);
-        withSqliteBackgroundWriter2(() => indexMessagesAfterOrdinal(db, sessionId, messages, cursor, pageEnd));
-        const nextCursor = getMessageIndexReconciliationStartOrdinal(db, sessionId);
-        if (nextCursor <= cursor)
-          break;
-        cursor = nextCursor;
-        const last = messages.at(-1);
-        after = last?.ordinal === cursor && typeof last.createdAt === "number" ? { timeCreated: last.createdAt, id: last.id } : undefined;
-        if (cursor < finalWatermark) {
-          await yieldToEventLoop();
-        }
-      }
-      if (isMessageIndexReconciledThrough(db, sessionId, finalWatermark)) {
-        heapHolder.reconciledSessions.add(sessionId);
-        if (revision !== undefined) {
-          if (!after && finalWatermark > 0 && readMessages.readPage) {
-            const last = readMessages.readPage(sessionId, finalWatermark - 1, 1, finalWatermark).at(-1);
-            if (last?.ordinal === finalWatermark && typeof last.createdAt === "number")
-              after = { timeCreated: last.createdAt, id: last.id };
-          }
-          heapHolder.reconciledSnapshots.set(sessionId, {
-            revision,
-            count: finalWatermark,
-            after
-          });
-        }
-      } else {
-        logReconciliationStall(sessionId, `gap after ordinal ${cursor} (store count ${finalWatermark})`);
-      }
-    } finally {
-      heapHolder.activeReconcilerBuffers.delete(sessionId);
-    }
-  });
-  return true;
-}
-function scheduleReconciliation(db, sessionId, readMessages) {
-  if (!readMessages.getRevision && heapHolder.reconciledSessions.has(sessionId) || heapHolder.reconciliationScheduledSessions.has(sessionId)) {
-    return;
-  }
-  heapHolder.reconciliationScheduledSessions.add(sessionId);
-  scheduleAfterBootQuiet(() => {
-    defer(() => {
-      let appendedDuringReconciliation = false;
-      const previousSnapshot = heapHolder.reconciledSnapshots.get(sessionId);
-      reconcileSessionIndex(db, sessionId, readMessages).then((ran) => {
-        if (ran) {
-          const snapshot = heapHolder.reconciledSnapshots.get(sessionId);
-          appendedDuringReconciliation = snapshot !== undefined && snapshot !== previousSnapshot && readMessages.getRevision !== undefined && readMessages.getRevision(sessionId) !== snapshot.revision;
-          return;
-        }
-        inRootAsyncContext2(() => setTimeout(() => {
-          heapHolder.reconciliationScheduledSessions.delete(sessionId);
-          scheduleReconciliation(db, sessionId, readMessages);
-        }, PREPARE_RETRY_MS)).unref?.();
-      }).catch((error) => {
-        logReconciliationStall(sessionId, error instanceof Error ? error.message : String(error));
-        if (isDatabaseLockedError(error))
-          inRootAsyncContext2(() => setTimeout(() => scheduleReconciliation(db, sessionId, readMessages), 1000)).unref();
-      }).finally(() => {
-        heapHolder.reconciliationScheduledSessions.delete(sessionId);
-        if (appendedDuringReconciliation)
-          scheduleReconciliation(db, sessionId, readMessages);
-      });
-    });
-  });
-}
-function scheduleClearAndReindex(db, sessionId, readMessages) {
-  heapHolder.reconciledSessions.delete(sessionId);
-  heapHolder.reconciledSnapshots.delete(sessionId);
-  heapHolder.reconciliationScheduledSessions.delete(sessionId);
-  clearCompletedIncrementalKeys(sessionId);
-  const existing = heapHolder.clearAndReindexScheduledSessions.get(sessionId);
-  if (existing) {
-    existing.source = readMessages;
-    return;
-  }
-  const pending = { source: readMessages };
-  heapHolder.clearAndReindexScheduledSessions.set(sessionId, pending);
-  scheduleAfterBootQuiet(() => {
-    defer(() => {
-      let cleared = false;
-      runWithSessionLock(sessionId, () => {
-        if (heapHolder.clearAndReindexScheduledSessions.get(sessionId) !== pending)
-          return;
-        heapHolder.clearAndReindexScheduledSessions.delete(sessionId);
-        heapHolder.reconciledSessions.delete(sessionId);
-        heapHolder.reconciledSnapshots.delete(sessionId);
-        clearCompletedIncrementalKeys(sessionId);
-        clearIndexedMessages(db, sessionId);
-        cleared = true;
-      }).then(() => cleared ? reconcileSessionIndex(db, sessionId, pending.source) : undefined).catch((error) => {
-        heapHolder.reconciledSessions.delete(sessionId);
-        if (heapHolder.clearAndReindexScheduledSessions.get(sessionId) === pending)
-          heapHolder.clearAndReindexScheduledSessions.delete(sessionId);
-        logIndexingError(sessionId, "clear and reindex", error);
-      });
-    });
-  });
-}
-function getMessageIndexQueueHeapStats() {
-  return {
-    queueLength: heapHolder.reconciliationScheduledSessions.size + heapHolder.incrementalTimers.size + heapHolder.pendingIncrementalKeys.size,
-    reconciliationScheduled: heapHolder.reconciliationScheduledSessions.size,
-    incrementalTimers: heapHolder.incrementalTimers.size,
-    pendingIncremental: heapHolder.pendingIncrementalKeys.size,
-    activeSessionLocks: heapHolder.sessionLocks.size,
-    completedIncrementalKeys: heapHolder.completedIncrementalKeys.size,
-    activeBufferMessages: [...heapHolder.activeReconcilerBuffers.values()].reduce((sum, messages) => sum + messages.length, 0),
-    activeBufferBytes: [...heapHolder.activeReconcilerBuffers.values()].reduce((sum, messages) => sum + serializedMessageBytes(messages), 0)
-  };
-}
-
 // src/shared/model-cache-ttl.ts
 var MODEL_CACHE_LIFETIMES = [
   {
@@ -4328,6 +4101,8 @@ class AutoSearchBusyError extends Error {
   }
 }
 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)) {
+  const messageIndexEpoch = getMessageIndexEpoch(sessionId);
+  const messageIndexWasSearchable = isMessageIndexSearchable(sessionId);
   const {
     rerankConfig: _rerankConfig,
     rerankClient: _rerankClient,
@@ -4336,7 +4111,8 @@ async function searchAutoHint(db, sessionId, projectPath, query, options, entry
     captureRerankLanes: _captureRerankLanes,
     ...hintOptions
   } = options;
-  return executeAutoSearchWorker(db, sessionId, projectPath, query, { ...hintOptions, explicitSearch: false, rerank: false }, entry, "search");
+  const results = await executeAutoSearchWorker(db, sessionId, projectPath, query, { ...hintOptions, explicitSearch: false, rerank: false }, entry, "search");
+  return messageIndexWasSearchable && isMessageIndexSearchable(sessionId) && getMessageIndexEpoch(sessionId) === messageIndexEpoch ? results : results.filter((result) => result.source !== "message");
 }
 var pendingBackfills = new WeakMap;
 var searchWorkers = new WeakMap;
@@ -5812,16 +5588,47 @@ function getDreamTaskBacklog(db, projectPath, task, options = {}) {
   }
 }
 var backlogCaches = new WeakMap;
+var displayBacklogCaches = new WeakMap;
+var DISPLAY_BACKLOG_MAX_AGE_MS = 60000;
 function getDreamTaskBacklogs(db, projectPath, tasks = CANONICAL_DREAM_TASKS, options = {}) {
   if (tasks.length === 0)
     return {};
   if (!isKnownAutocommit(db)) {
     backlogCaches.delete(db);
+    displayBacklogCaches.delete(db);
     const result = {};
     for (const task of tasks)
       result[task] = getDreamTaskBacklog(db, projectPath, task, options);
     return result;
   }
+  if (options.display) {
+    let entries = displayBacklogCaches.get(db);
+    if (!entries) {
+      entries = new Map;
+      displayBacklogCaches.set(db, entries);
+    }
+    const optionKey = (value) => value === undefined ? "omitted" : value === null ? "null" : `number:${value}`;
+    const key = JSON.stringify([
+      projectPath,
+      tasks,
+      optionKey(options.lastRunAt),
+      optionKey(options.retrospectiveWatermarkMs)
+    ]);
+    const now = Date.now();
+    const cached = entries.get(key);
+    if (cached && now < cached.expiresAt && now >= cached.expiresAt - DISPLAY_BACKLOG_MAX_AGE_MS)
+      return structuredClone(cached.value);
+    const value = {};
+    for (const task of tasks)
+      value[task] = getDreamTaskBacklog(db, projectPath, task, options);
+    if (entries.size >= 256)
+      entries.delete(entries.keys().next().value);
+    entries.set(key, {
+      expiresAt: now + DISPLAY_BACKLOG_MAX_AGE_MS,
+      value: structuredClone(value)
+    });
+    return value;
+  }
   let cache = backlogCaches.get(db);
   if (!cache) {
     cache = {
@@ -7640,6 +7447,7 @@ function prepareLegacyToolSkeletonConversions(db, sessionId, targets, options =
     });
   };
   const rows = readRows(db);
+  options.prepareRemovals?.(rows);
   const converted = new Map;
   for (const row of rows) {
     const target = targets.get(row.tagNumber);
@@ -11990,6 +11798,7 @@ async function runPostTransformPhase(args) {
     emergencyReclaimedTokens,
     droppedCount,
     emergency,
+    prefixMutationPermitted: isCacheBustingPass,
     bustedThisPass,
     prefixTrimStatus: deliveredPrefix?.prefixTrimStatus ?? null,
     thinkingBindingRecovery,
@@ -13431,7 +13240,7 @@ var MODULE_PAGE_MAX_BYTES = SUBC_MAX_FRAME_BODY_BYTES - MODULE_PAGE_ENVELOPE_HEA
 var MODULE_ITEM_CONTINUATION_CHUNK_BYTES = 64 * 1024;
 var MODULE_ITEM_CONTINUATION_KEY = "__shadow_item_continuation";
 var MODULE_ORDINAL_PAGE_SIZE = 500;
-function yieldToEventLoop2() {
+function yieldToEventLoop() {
   return new Promise((resolve) => setTimeout(resolve, 0));
 }
 function canonicalJson(value) {
@@ -13521,7 +13330,7 @@ async function resolveOrdinalsForModule(args) {
         pageEnds.push({ anchor: pageAnchor, entryCount: entries.length });
         if (page.length < MODULE_ORDINAL_PAGE_SIZE)
           break;
-        await yieldToEventLoop2();
+        await yieldToEventLoop();
       }
       return { entries, end: pageAnchor, pageEnds };
     };
@@ -19656,6 +19465,15 @@ function createTransform(deps) {
       db,
       sessionID: sessionId
     }) : undefined;
+    const hostEstimate = deps.hostInputEstimate?.(sessionId);
+    const hostOverWindow = fullFeatureMode && !compactionOff && resolvedContextLimit !== undefined && resolvedContextLimit > 0 && hostEstimate !== undefined && Number.isFinite(hostEstimate.tokens) && Number.isFinite(hostEstimate.pressureTokens) && hostEstimate.tokens > resolvedContextLimit;
+    if (hostOverWindow) {
+      contextUsageEarly = {
+        inputTokens: Math.max(contextUsageEarly.inputTokens, hostEstimate.pressureTokens),
+        percentage: Math.max(100, contextUsageEarly.percentage, hostEstimate.pressureTokens / resolvedContextLimit * 100)
+      };
+      usagePercentageSynthetic = true;
+    }
     let unmanagedOverWindowPass = null;
     const unmanagedOverWindowCarried = unmanagedOverWindowSessions.has(sessionId);
     if (fullFeatureMode && !compactionOff && typeof resolvedContextLimit === "number" && resolvedContextLimit > 0 && (unmanagedOverWindowCarried || isFirstTransformPassForSession && getLastCompartmentEndMessage(db, sessionId) < 0 && getMaxDroppedTagNumber2(db, sessionId) === 0)) {
@@ -20198,7 +20016,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       bustReason: calibrationBustReason,
       onAdopt: (message) => sessionLog2(sessionId, message)
     });
-    let contextUsageFromEstimate = false;
+    let contextUsageFromEstimate = hostOverWindow;
     if (contextUsage.inputTokens <= 0 && protectionCacheBustingPass) {
       const overflowRecoveryPass = usagePercentageSynthetic || emergencyRecoveryArmed;
       const savedProviderReading = overflowRecoveryPass ? null : savedProviderReadingForPass({
@@ -20752,6 +20570,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         sessionId,
         systemPromptHash: sessionMeta.systemPromptHash
       });
+    deps.onPassPermission?.(sessionId, postTransformResult.prefixMutationPermitted);
   };
   const timedTransform = (input, output) => withTransformTimingSummary(() => transform(input, output));
   return Object.assign(timedTransform, {
@@ -23258,7 +23077,7 @@ function buildSidebarSnapshot(db, sessionId, directory, liveSessionState, inject
     const dreamerProgress = projectIdentity ? liveSessionState?.dreamerProgressByProject?.get(projectIdentity) ?? null : null;
     if (projectIdentity) {
       try {
-        dreamerBacklog = getDreamTaskBacklogs(db, projectIdentity, CANONICAL_DREAM_TASKS.filter((task) => smartNotesEnabled || task !== "evaluate-smart-notes"));
+        dreamerBacklog = getDreamTaskBacklogs(db, projectIdentity, CANONICAL_DREAM_TASKS.filter((task) => smartNotesEnabled || task !== "evaluate-smart-notes"), { display: true });
       } catch {}
     }
     if (projectIdentity) {
@@ -24010,7 +23829,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-wb28kr9k.js"));
+    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-3r9kcs61.js"));
     const { sendIgnoredMessage } = await importPluginModule(() => import("./send-session-notification-x5nzy34v.js"));
     log2(`[rpc] recomp requested for session ${sessionId}`);
     if (!args.client && !args.hiddenCompletionExecutor) {
@@ -24095,7 +23914,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-2t0pdqzm.js"));
+    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-ddmvbkra.js"));
     const model = liveSessionState.liveModelBySession.get(sessionId);
     const contextLimit = model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
     const ctx = {
@@ -25208,8 +25027,14 @@ class FoldOwner {
   async observe(args) {
     return this.serial(args.sessionID, async () => {
       let state = await this.read(args.sessionID);
+      if (state?.rendered && state.rendered.id !== args.rendered.id)
+        state = undefined;
       let changed = !state;
-      const renderedSha = foldDigest(JSON.stringify(args.rendered));
+      const observedSha = foldDigest(JSON.stringify(args.rendered));
+      const rendered = structuredClone(args.rendered);
+      if (state?.withoutRecentContext && state.withoutRecentContext === rendered.id)
+        stripCheckpointRecentContext(rendered, args.summary);
+      const renderedSha = foldDigest(JSON.stringify(rendered));
       if (!state) {
         args.onHard("boot_recovery");
         state = {
@@ -25220,10 +25045,10 @@ class FoldOwner {
         };
       }
       const reason = args.cutSeq < state.watermark ? "host_cut_before_watermark" : state.submittedSha !== foldDigest(args.summary) || state.renderedSha && state.renderedSha !== renderedSha ? "host_rerender" : undefined;
-      if (reason && state.rejectedSha !== renderedSha) {
+      if (reason && state.rejectedSha !== observedSha) {
         args.onHard(reason);
         state.reason = reason;
-        state.rejectedSha = renderedSha;
+        state.rejectedSha = observedSha;
         changed = true;
       }
       if (state.cutSeq === undefined && args.cutSeq >= state.watermark) {
@@ -25231,7 +25056,7 @@ class FoldOwner {
         changed = true;
       }
       if (!state.rendered && reason !== "host_cut_before_watermark") {
-        state.rendered = structuredClone(args.rendered);
+        state.rendered = rendered;
         state.renderedSha = renderedSha;
         state.renderedSummary = args.summary;
         changed = true;
@@ -25241,6 +25066,50 @@ class FoldOwner {
       return state;
     });
   }
+  async stripRecentContext(sessionID, checkpointID) {
+    return this.serial(sessionID, async () => {
+      const state = await this.read(sessionID);
+      if (!state?.rendered || state.rendered.id !== checkpointID)
+        return;
+      if (state.withoutRecentContext === checkpointID)
+        return state;
+      if (!stripCheckpointRecentContext(state.rendered, state.renderedSummary ?? state.submitted))
+        return state;
+      state.withoutRecentContext = checkpointID;
+      state.renderedSha = foldDigest(JSON.stringify(state.rendered));
+      await this.storage.set(this.key(sessionID), state);
+      return state;
+    });
+  }
+}
+function stripCheckpointRecentContext(message, summary) {
+  let changed = false;
+  for (const part of message.content) {
+    if (part.type !== "text" || typeof part.text !== "string")
+      continue;
+    const summaryStart = part.text.indexOf("<summary>");
+    if (summaryStart < 0)
+      continue;
+    const summaryText = part.text.indexOf(summary, summaryStart + "<summary>".length);
+    if (summaryText < 0)
+      continue;
+    const start = part.text.indexOf("</summary>", summaryText + summary.length) + "</summary>".length;
+    const end = part.text.lastIndexOf("</conversation-checkpoint>");
+    if (start < "</summary>".length || end < start)
+      continue;
+    const suffix = part.text.slice(start, end);
+    if (!/^\s*<recent-context>[\s\S]*<\/recent-context>\s*$/.test(suffix))
+      continue;
+    part.text = `${part.text.slice(0, start)}
+${part.text.slice(end)}`;
+    changed = true;
+  }
+  if (changed && message.metadata && typeof message.metadata === "object") {
+    const metadata = { ...message.metadata };
+    delete metadata.recent;
+    message.metadata = metadata;
+  }
+  return changed;
 }
 
 // src/v2/fold/memory-cache.ts
@@ -32200,7 +32069,6 @@ function parseMapMemoriesManifest(text) {
 }
 function validateMapMemoriesManifest(text, expectedIds) {
   const parsed = parseMapMemoriesManifest(text);
-  assertParsedManifestNonEmpty(parsed.length, expectedIds.size, text, "mappings", "memory");
   assertNoDuplicateManifestIds(parsed.filter((entry) => expectedIds.has(entry.id)).map((entry) => entry.id), "mappings");
   return parsed;
 }
@@ -34414,8 +34282,7 @@ function parsePartialVerifyManifest(text, expectedIds) {
 var VERIFY_BATCH_SIZE = 5;
 var VERIFY_TOKENS_PER_MEMORY = 1e5;
 var VERIFY_RUN_TOKEN_BUDGET = 2500000;
-var VERIFY_RUN_SLICE_MS = 240000;
-var VERIFY_IN_FLIGHT_GRACE_MS = 120000;
+var VERIFY_BATCH_DEFAULT_MS = 240000;
 function verifyBatchTokenBudget(size, configured) {
   return Math.min(configured ?? Number.MAX_SAFE_INTEGER, size * VERIFY_TOKENS_PER_MEMORY);
 }
@@ -34445,8 +34312,8 @@ function validateVerifyCompletion(messages, text, expectedIds, responseText = te
 }
 var IDENTICAL_PROVIDER_FAILURE_BATCH_LIMIT = 2;
 var VERIFY_BATCH_FLOOR_MS = 30000;
-function computeVerifyBatchSliceMs(remainingMs, _batchesRemaining) {
-  return Math.min(remainingMs, VERIFY_RUN_SLICE_MS);
+function computeVerifyBatchSliceMs(remainingMs, batchesRemaining) {
+  return Math.min(remainingMs, Math.max(VERIFY_BATCH_DEFAULT_MS, remainingMs / Math.max(1, batchesRemaining)));
 }
 function closeBroadCycle(args, cycleStartAt) {
   if (!args.forceBroad || cycleStartAt === undefined)
@@ -34470,7 +34337,6 @@ async function runVerify(args) {
 }
 async function runVerifyWithCooldown(args) {
   const runStartedAt = Date.now();
-  const sliceDeadline = runStartedAt + VERIFY_RUN_SLICE_MS;
   const result = {
     verified: 0,
     updated: 0,
@@ -34518,12 +34384,10 @@ async function runVerifyWithCooldown(args) {
   try {
     for (let i = 0;i < batches.length; i += 1) {
       const now = Date.now();
-      const startCutoff = Math.min(args.deadline, sliceDeadline);
-      const hardStop = Math.min(args.deadline, sliceDeadline + VERIFY_IN_FLIGHT_GRACE_MS);
-      const remainingMs = Math.max(0, hardStop - now);
-      if (now >= startCutoff) {
+      const remainingMs = Math.max(0, args.deadline - now);
+      if (now >= args.deadline) {
         result.stopReason = "deadline";
-        log2(`[dreamer] ${args.forceBroad ? "verify-broad" : "verify"}: stopping before batch ${i + 1}/${batches.length} — the run deadline passed ${now - startCutoff}ms ago`);
+        log2(`[dreamer] ${args.forceBroad ? "verify-broad" : "verify"}: stopping before batch ${i + 1}/${batches.length} — the run deadline passed ${now - args.deadline}ms ago`);
         break;
       }
       if (remainingMs < VERIFY_BATCH_FLOOR_MS) {
@@ -35462,7 +35326,7 @@ function createDreamTaskExecutor(deps) {
             return { status: "failed", transient: true, error };
           }
           const processed = result.mapped + result.independent;
-          if (processed > 0) {
+          if (processed > 0 || result.failure === undefined) {
             const progress = `map-memories: committed ${processed} mapping(s) (mapped ${result.mapped}, independent ${result.independent}); ${result.remaining} remain`;
             recordRun("completed", null, { progress });
             return { status: "completed" };
@@ -53183,6 +53047,28 @@ ${baseline}
   draft.messages.splice(0, draft.messages.length, checkpoint, ...draft.messages.filter((message) => message !== first));
   return true;
 }
+function estimateCheckpointRequest(draft) {
+  let toolDefinitionTokens = 0;
+  for (const tool of Object.values(draft.tools)) {
+    const schema = JSON.stringify(tool.input);
+    if (schema === undefined)
+      throw new Error("Checkpoint request has an unserializable tool schema");
+    toolDefinitionTokens += estimateTokens(tool.description) + estimateTokens(schema);
+  }
+  const estimateDraft = {
+    ...draft,
+    messages: draft.messages.map((message) => HEAD_IDS.some((id) => message.id === id) ? { ...message, id: undefined } : message)
+  };
+  return estimateFinalWireInputTokens({
+    messages: adaptPayload(estimateDraft).messages,
+    toolDefinitionTokens,
+    systemPromptTokens: estimateTokens(JSON.stringify(draft.system)),
+    providerID: draft.model.providerID,
+    modelID: draft.model.id,
+    agentName: draft.agent,
+    sessionId: draft.sessionID
+  });
+}
 var HIDDEN_SESSION_ERROR_GRACE_MS = 50;
 var STORE_POOL_DISPOSE_WAIT_MS = 1000;
 function isBlockingV2TransformError(error) {
@@ -54015,7 +53901,7 @@ async function registerContext(context) {
   await context.session.hook("compaction", async (draft) => {
     const hiddenSummary = hiddenChildHook.compactionSummary(draft.sessionID, draft.agent);
     if (hiddenSummary !== undefined) {
-      draft.result = { summary: hiddenSummary };
+      draft.result = { summary: hiddenSummary, metadata: { keepID: undefined } };
       return;
     }
     if (compactionOff)
@@ -54040,7 +53926,7 @@ async function registerContext(context) {
               previousCut: reader.latestCompaction(draft.sessionID),
               summary
             })) {
-              draft.result = { summary };
+              draft.result = { summary, metadata: { keepID: undefined } };
               return;
             }
           }
@@ -54056,7 +53942,7 @@ async function registerContext(context) {
         materialize: () => moduleBaseline ?? materialize(draft)
       });
       sessionLog2(draft.sessionID, `v2 compaction hook: fired answered=true source=${source}`);
-      draft.result = { summary: fold.submitted };
+      draft.result = { summary: fold.submitted, metadata: { keepID: undefined } };
     } catch (cause) {
       await refuseBeforeProvider(context.session, draft.sessionID, "compaction-fold", cause);
       throw new V2ContextRefusal("Magic Context could not preserve the host checkpoint.", {
@@ -54102,6 +53988,8 @@ async function registerContext(context) {
       ...args.messages.filter((message) => message !== args.incoming)
     ];
   };
+  const checkpointPassPermissions = new Map;
+  const checkpointInputEstimates = new Map;
   const initializeTransform = (database) => transform ??= createTransform({
     ...createV2TransformFeatureDeps(config, compactionOff, directory, embeddings.ensureRegistered),
     cacheTtlConfig: config.cache_ttl,
@@ -54111,6 +53999,10 @@ async function registerContext(context) {
     tagger,
     ...createV2ThresholdDeps(config),
     contextUsageMap: usage,
+    hostInputEstimate: (sessionID) => checkpointInputEstimates.get(sessionID),
+    onPassPermission: (sessionID, permission) => {
+      checkpointPassPermissions.set(sessionID, permission);
+    },
     compactionOff,
     storeGeneration: "v2",
     normalizeRestoredAssistantText: (text, providerID) => stripCopiedTagNotation(text, providerID === "anthropic"),
@@ -54532,6 +54424,21 @@ async function registerContext(context) {
       }
       const mapped = adaptPayload(draft, admitted, messageTimes, anchorTimesOnly);
       bindSystemDateRequestIdentity(mapped, draft);
+      checkpointPassPermissions.delete(draft.sessionID);
+      checkpointInputEstimates.delete(draft.sessionID);
+      if (checkpoint && submitted !== undefined) {
+        const projected = structuredClone(checkpoint);
+        if (stripCheckpointRecentContext(projected, submitted)) {
+          const estimate = estimateCheckpointRequest({
+            ...draft,
+            messages: [checkpoint, ...draft.messages]
+          });
+          checkpointInputEstimates.set(draft.sessionID, {
+            tokens: estimate.tokens,
+            pressureTokens: estimate.pressureTokens ?? estimate.tokens
+          });
+        }
+      }
       await createMessagesTransformHandler({
         magicContext: { "experimental.chat.messages.transform": transform },
         compactionOff,
@@ -54540,6 +54447,14 @@ async function registerContext(context) {
         rustReplayParticipant: () => transform?.getRustReplayParticipant() ?? null
       })({}, mapped);
       mapped.commit();
+      const checkpointPermission = checkpointPassPermissions.get(draft.sessionID);
+      checkpointPassPermissions.delete(draft.sessionID);
+      checkpointInputEstimates.delete(draft.sessionID);
+      if (checkpoint?.id && checkpointPermission && replayHead === undefined) {
+        const stripped = await folds.stripRecentContext(draft.sessionID, checkpoint.id);
+        if (stripped?.rendered)
+          checkpoint = structuredClone(stripped.rendered);
+      }
       stageOpenCodeV2TransformDecision({
         sessionId: draft.sessionID,
         responseAfterSequence
@@ -54618,17 +54533,45 @@ async function registerContext(context) {
       }
     }
   };
+  const refuseOversizedCheckpoint = async (draft) => {
+    const hasCheckpoint = draft.messages.some((message) => message.content.some((part) => part.type === "text" && typeof part.text === "string" && part.text.startsWith("<conversation-checkpoint>")));
+    const limit = draft.model.limit?.input ?? draft.model.limit?.context;
+    if (!hasCheckpoint || !limit)
+      return;
+    let estimate;
+    try {
+      estimate = estimateCheckpointRequest(draft);
+    } catch (cause) {
+      await refuseBeforeProvider(context.session, draft.sessionID, "checkpoint-fit-estimate", cause);
+      throw new V2ContextRefusal("Magic Context could not size the host checkpoint.", {
+        cause
+      });
+    }
+    if (estimate.tokens <= limit)
+      return;
+    await refuseBeforeProvider(context.session, draft.sessionID, "checkpoint-over-window");
+    throw new V2ContextRefusal("Magic Context refused an oversized host checkpoint.");
+  };
   await context.session.hook("context", (draft) => withSqliteTransformPass2(async () => {
     const anchor = generateReplayAnchor(draft.messages);
-    await runManagedContext(draft);
+    try {
+      await runManagedContext(draft);
+      if (!compactionOff)
+        await refuseOversizedCheckpoint(draft);
+    } finally {
+      checkpointInputEstimates.delete(draft.sessionID);
+      checkpointPassPermissions.delete(draft.sessionID);
+    }
     if (!compactionOff)
       generateReplay.capture(draft, anchor);
     else
       sessionLog2(draft.sessionID, "generate replay capture skipped: compaction-disabled");
   }));
   await context.session.hook("generate", async (draft) => {
-    if (!compactionOff && !deletedSessions.has(draft.sessionID))
+    if (!compactionOff && !deletedSessions.has(draft.sessionID)) {
       generateReplay.apply(draft);
+      await refuseOversizedCheckpoint(draft);
+    }
   });
   withoutSqliteTransformPass2(() => warmModelLimitCacheFromCatalog(context));
   const rpcLiveSessionState = createV2RpcLiveSessionState({