@cortexkit/opencode-magic-context 0.49.29 → 0.49.31

package/dist/v2/{context-g4ptae4x.js → context-cdqw9jex.js}

@@ -77,7 +77,6 @@ import {
   isCompartmentLeaseHeld,
   queueM0Mutation,
   getMaxM0MutationId,
-  getCompartments,
   getLastCompartmentEndMessage,
   getLastCompartmentEndMessageId,
   getUncoveredCompartmentEndsThrough,
@@ -305,7 +304,7 @@ import {
   startCompartmentAgent,
   setRecompStarting2,
   setRecompTerminal2
-} from "./server-q50ttc2g.js";
+} from "./server-rdjgz95f.js";
 import {
   resolveHistorianModel2
 } from "./server-5kym00ag.js";
@@ -330,7 +329,7 @@ import {
   openDatabaseAsync,
   isDatabasePersisted,
   getDatabasePersistenceError
-} from "./server-77gznpmf.js";
+} from "./server-d01pe8q5.js";
 import {
   pruneMissingProjectIdentities,
   setHomeProjectPermission,
@@ -482,6 +481,7 @@ import {
 } from "./server-3mz2qh5a.js";
 import {
   stableStringify,
+  getTableColumnNames,
   getTemporalDecisions,
   observeTemporalDecisions,
   freezeTemporalDecisions,
@@ -702,7 +702,7 @@ import {
   readRawSessionMessageById2,
   readSessionChunk2,
   readRawSessionSeedTail2
-} from "./server-mxzj3r0y.js";
+} from "./server-rb8m4vry.js";
 import {
   BoundedSessionMap,
   recordToolDefinitionSet,
@@ -717,7 +717,7 @@ import {
   isMessageIndexReconciledThrough,
   clearIndexedMessages,
   indexMessagesAfterOrdinal
-} from "./server-k9je35ev.js";
+} from "./server-hwag0khr.js";
 import"./server-awr8qa4c.js";
 import {
   embedPauseBySession,
@@ -916,14 +916,14 @@ import {
   resolveMemoriesByIdsForSearch2,
   unifiedSearch2,
   formatSearchResults2
-} from "./server-976dxaxh.js";
+} from "./server-42nebt63.js";
 import {
   resolvePromptContext2
 } from "./server-fmsr7v69.js";
 import"./server-kaqs6h31.js";
 import {
   renderSearchArchiveOffThread2
-} from "./server-w79f8ejn.js";
+} from "./server-rr4cbkr0.js";
 import {
   compareSemverCore
 } from "./server-84w6rvvf.js";
@@ -3381,6 +3381,26 @@ class EmergencyFailClosedError extends Error {
 }
 
 // src/hooks/magic-context/history-boundary-repair.ts
+function readStoreBoundaries(db, sessionId) {
+  const columns = getTableColumnNames(db, "compartments");
+  const numbers = ["id", "sequence", "start_message", "end_message", "created_at"];
+  const strings = ["session_id", "start_message_id", "end_message_id", "title", "content"];
+  const predicates = [...numbers, ...strings].every((column) => columns.has(column)) ? [
+    ...numbers.map((column) => `typeof(${column}) IN ('integer', 'real')`),
+    ...strings.map((column) => `typeof(${column}) = 'text'`)
+  ] : ["0"];
+  for (const column of ["p1", "p2", "p3", "p4", "episode_type"]) {
+    if (columns.has(column))
+      predicates.push(`typeof(${column}) IN ('text', 'null')`);
+  }
+  for (const column of ["importance", "legacy"]) {
+    if (columns.has(column))
+      predicates.push(`typeof(${column}) IN ('integer', 'real', 'null')`);
+  }
+  return db.prepare(`SELECT sequence, ${columns.has("end_message_id") ? "end_message_id" : "NULL"} AS endMessageId
+             FROM compartments WHERE session_id = ? AND ${predicates.join(" AND ")}
+             ORDER BY sequence ASC`).all(sessionId);
+}
 function readBaseline(db, sessionId) {
   const row = db.prepare("SELECT cached_m0_bytes IS NOT NULL AS hasM0, cached_m0_last_baseline_end_message_id AS boundary FROM session_meta WHERE session_id = ?").get(sessionId);
   return {
@@ -3447,7 +3467,7 @@ function dropCompartmentsAfter(db, sessionId, anchor, holderId, activeBranch = f
 }
 function repairMissingHistoryBoundary(args) {
   const { db, sessionId, isInHostStore, scope = "store" } = args;
-  const compartments = scope === "active-branch" ? db.prepare("SELECT sequence, COALESCE(end_message_id, '') AS endMessageId FROM compartments WHERE session_id = ? ORDER BY sequence").all(sessionId) : getCompartments(db, sessionId);
+  const compartments = scope === "active-branch" ? db.prepare("SELECT sequence, COALESCE(end_message_id, '') AS endMessageId FROM compartments WHERE session_id = ? ORDER BY sequence").all(sessionId) : readStoreBoundaries(db, sessionId);
   let latestIndex = compartments.length - 1;
   while (latestIndex >= 0 && !compartments[latestIndex]?.endMessageId)
     latestIndex -= 1;
@@ -3491,7 +3511,7 @@ function repairMissingHistoryBoundary(args) {
     let dropped;
     let anchorForDrop = anchor;
     try {
-      if (scope === "active-branch" && anchor) {
+      if (anchor) {
         const row = db.prepare("SELECT end_message AS endMessage FROM compartments WHERE session_id = ? AND sequence = ?").get(sessionId, anchor.sequence);
         if (!row)
           return { kind: "unresolved", reason: "busy", missingEndMessageId: missing };
@@ -7620,6 +7640,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);
@@ -11970,6 +11991,7 @@ async function runPostTransformPhase(args) {
     emergencyReclaimedTokens,
     droppedCount,
     emergency,
+    prefixMutationPermitted: isCacheBustingPass,
     bustedThisPass,
     prefixTrimStatus: deliveredPrefix?.prefixTrimStatus ?? null,
     thinkingBindingRecovery,
@@ -19636,6 +19658,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)) {
@@ -20178,7 +20209,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({
@@ -20732,6 +20763,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, {
@@ -22381,6 +22413,13 @@ WHERE session_id = ?
   AND (time_created > ? OR (time_created = ? AND id > ?))
 ORDER BY time_created, id`;
 var V2_ASSISTANT_USAGE_ROWS_AFTER_SQL = `
+WITH newer AS (
+  SELECT id, seq, data FROM session_message
+  WHERE session_id = ? AND type = 'assistant' AND data IS NOT NULL AND seq > ?
+  UNION ALL
+  SELECT id, seq, data FROM session_message
+  WHERE session_id = ? AND type = 'assistant' AND data IS NOT NULL AND seq = ? AND id > ?
+)
 SELECT
   json_extract(data, '$.agent') AS agent,
   seq AS time_created,
@@ -22389,14 +22428,10 @@ SELECT
     + COALESCE(json_extract(data, '$.tokens.cache.read'), 0)
     + COALESCE(json_extract(data, '$.tokens.cache.write'), 0) AS prompt,
   COALESCE(json_extract(data, '$.tokens.output'), 0) AS output
-FROM session_message
-WHERE session_id = ?
-  AND type = 'assistant'
-  AND data IS NOT NULL
-  AND (seq > ? OR (seq = ? AND id > ?))
+FROM newer
 ORDER BY seq, id`;
 function readAssistantUsageRowsAfter(openCodeDb, sessionId, afterTimeCreated, afterId, generation = "v1") {
-  const rows = openCodeDb.prepare(generation === "v2" ? V2_ASSISTANT_USAGE_ROWS_AFTER_SQL : ASSISTANT_USAGE_ROWS_AFTER_SQL).all(sessionId, afterTimeCreated, afterTimeCreated, afterId);
+  const rows = openCodeDb.prepare(generation === "v2" ? V2_ASSISTANT_USAGE_ROWS_AFTER_SQL : ASSISTANT_USAGE_ROWS_AFTER_SQL).all(...generation === "v2" ? [sessionId, afterTimeCreated, sessionId, afterTimeCreated, afterId] : [sessionId, afterTimeCreated, afterTimeCreated, afterId]);
   return rows.map((r) => ({
     agent: r.agent ?? null,
     timeCreated: Number(r.time_created ?? 0),
@@ -23987,7 +24022,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-f1df1gb8.js"));
+    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-kdxr4tx8.js"));
     const { sendIgnoredMessage } = await importPluginModule(() => import("./send-session-notification-x5nzy34v.js"));
     log2(`[rpc] recomp requested for session ${sessionId}`);
     if (!args.client && !args.hiddenCompletionExecutor) {
@@ -24072,7 +24107,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-jq33fda8.js"));
+    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-prfvyqbb.js"));
     const model = liveSessionState.liveModelBySession.get(sessionId);
     const contextLimit = model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
     const ctx = {
@@ -25185,8 +25220,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 = {
@@ -25197,10 +25238,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) {
@@ -25208,7 +25249,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;
@@ -25218,6 +25259,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
@@ -26862,6 +26947,7 @@ function createNativeHiddenChildren(host, removeSession, options) {
     const inFlight = removing.get(child.id);
     if (inFlight)
       return inFlight;
+    options.log(`[magic-context] hidden child ${child.id} removing`);
     const done = (async () => {
       try {
         let timer;
@@ -26876,6 +26962,7 @@ function createNativeHiddenChildren(host, removeSession, options) {
           if (timer)
             clearTimeout(timer);
         }
+        options.log(`[magic-context] hidden child ${child.id} removed`);
       } catch (error) {
         if (isSessionNotFound(error))
           return;
@@ -26887,14 +26974,19 @@ function createNativeHiddenChildren(host, removeSession, options) {
     removing.set(child.id, done);
     return done;
   };
-  const confirmPlacement = async (sessionID, parentID) => {
+  const noteCreated = (sessionID, role, parentID) => {
+    options.log(`[magic-context] hidden child ${sessionID} created role=${role} parent=${parentID} keep_subagents=${options.keepSubagents}`);
+  };
+  const confirmPlacement = async (sessionID, parentID, role) => {
     let stored;
     try {
       stored = await host.get({ sessionID });
     } catch (error) {
+      noteCreated(sessionID, role, "unknown");
       options.log(`[magic-context] could not read back hidden child ${sessionID} to confirm its parent: ${errorText(error)}`);
       return;
     }
+    noteCreated(sessionID, role, stored.parentID ?? "none");
     const directory = stored.location?.directory;
     if (options.directory !== undefined && directory !== undefined && !sameProjectDirectory(directory, options.directory)) {
       throw new HiddenCompletionRefusal("hidden_prompt_unrecognized", `hidden child ${sessionID} is bound to ${directory}, not to this instance's ${options.directory}. Reopen the parent session in ${directory}, then run /ctx-recomp so its owning instance can rebuild history.`, true);
@@ -26923,11 +27015,13 @@ function createNativeHiddenChildren(host, removeSession, options) {
     };
     if (parentID) {
       try {
-        await confirmPlacement(created.id, parentID);
+        await confirmPlacement(created.id, parentID, role);
       } catch (error) {
         await remove(child);
         throw error;
       }
+    } else {
+      noteCreated(created.id, role, "none");
     }
     return child;
   };
@@ -26936,16 +27030,22 @@ function createNativeHiddenChildren(host, removeSession, options) {
     open: create,
     create,
     retire(child) {
-      if (!kept(child))
+      if (kept(child)) {
+        options.log(`[magic-context] hidden child ${child.id} kept (keep_subagents)`);
+      } else {
         remove(child);
+      }
     },
     async finish(child, retired) {
       if (retired) {
         await removing.get(child.id);
         return;
       }
-      if (!kept(child))
+      if (kept(child)) {
+        options.log(`[magic-context] hidden child ${child.id} kept (keep_subagents)`);
+      } else {
         await remove(child);
+      }
     },
     updateModel: (child, model) => ({ ...child, model }),
     markEverSettled: (child) => ({ ...child, ever_settled: true })
@@ -26992,6 +27092,7 @@ async function cleanupLegacyHiddenChildren(db, remove, note, options = {}) {
               timer = setTimeout(() => reject(new Error("session.remove timed out")), Math.min(options.timeoutMs ?? 1000, Math.max(1, deadline - now())));
             })
           ]);
+          note(`[magic-context] legacy hidden child ${child.id} removed`);
         } catch (error) {
           if (!isSessionNotFound(error))
             throw error;
@@ -27899,6 +28000,96 @@ class HiddenModelActivity {
   }
 }
 
+// src/v2/message-times.ts
+function isSettled(entry, readAt) {
+  return (entry.version.type === "user" || entry.time.completed !== undefined) && typeof entry.version.updated === "number" && Number.isFinite(entry.version.updated) && entry.version.updated <= readAt - 1000;
+}
+function sameVersion(a, b) {
+  return a.type === b.type && a.seq === b.seq && a.created === b.created && a.updated === b.updated;
+}
+
+class V2MessageTimesCache {
+  capacity;
+  sessions = new Map;
+  constructor(capacity = 64) {
+    this.capacity = capacity;
+  }
+  delete(sessionID) {
+    this.sessions.delete(sessionID);
+  }
+  deleteMessage(sessionID, messageID) {
+    this.sessions.get(sessionID)?.entries.delete(messageID);
+  }
+  clear() {
+    this.sessions.clear();
+  }
+  pass(sessionID) {
+    const previous = this.sessions.get(sessionID);
+    const current = { entries: new Map };
+    this.sessions.delete(sessionID);
+    this.sessions.set(sessionID, current);
+    while (this.sessions.size > this.capacity) {
+      const oldest = this.sessions.keys().next().value;
+      if (oldest === undefined)
+        break;
+      this.sessions.delete(oldest);
+    }
+    const passTimes = new Map;
+    return (reader, ids) => {
+      const missing = [...new Set(ids)].filter((id) => !passTimes.has(id));
+      if (missing.length > 0) {
+        const readAt = Date.now();
+        const identity = reader.hostIdentity();
+        current.identity = identity;
+        const reusable = previous?.identity === identity ? previous.entries : undefined;
+        const known = [];
+        const refresh = [];
+        let first = Infinity;
+        let last = -Infinity;
+        for (const id of missing) {
+          const entry = reusable?.get(id);
+          if (entry && isSettled(entry, readAt)) {
+            known.push(id);
+            first = Math.min(first, entry.version.seq);
+            last = Math.max(last, entry.version.seq);
+          } else
+            refresh.push(id);
+        }
+        const versions = reader.messageTimeVersions(sessionID, known, { first, last });
+        for (const id of known) {
+          const version = versions.get(id);
+          const cached = reusable?.get(id);
+          if (!version) {
+            passTimes.set(id, null);
+          } else if (cached && sameVersion(cached.version, version) && (version.type === "user" || cached.time.completed !== undefined)) {
+            current.entries.set(id, cached);
+            passTimes.set(id, cached.time);
+          } else
+            refresh.push(id);
+        }
+        const times = reader.messageTimes(sessionID, refresh, versions);
+        for (const id of refresh) {
+          const time = times.get(id);
+          const version = versions.get(id);
+          passTimes.set(id, time ?? null);
+          if (time && version) {
+            const entry = { version, time };
+            if (isSettled(entry, readAt))
+              current.entries.set(id, entry);
+          }
+        }
+      }
+      const result = new Map;
+      for (const id of ids) {
+        const time = passTimes.get(id);
+        if (time)
+          result.set(id, { ...time });
+      }
+      return result;
+    };
+  }
+}
+
 // src/v2/hooks/channel2.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
 var pendingCandidates = new WeakMap;
@@ -32071,7 +32262,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;
 }
@@ -34285,8 +34475,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);
 }
@@ -34316,8 +34505,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)
@@ -34341,7 +34530,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,
@@ -34389,12 +34577,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) {
@@ -35333,7 +35519,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" };
@@ -53054,6 +53240,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) {
@@ -53251,6 +53459,7 @@ function coveredInstructionRows(reader, sessionID, throughSeq, model) {
 async function registerContext(context) {
   const directory = context.location.directory;
   const config = loadPluginConfigDetailed(directory).config;
+  log2(`[magic-context] OpenCode 2 keep_subagents=${config.keep_subagents === true}`);
   setHomeProjectPermission(config.allow_home_project);
   if (!config.enabled)
     return;
@@ -53383,6 +53592,7 @@ async function registerContext(context) {
   });
   let hiddenAgentsReady;
   const readerPool = new V2StoreReaderPool;
+  const messageTimesCache = new V2MessageTimesCache;
   const openStoreReader = () => readerPool.open(gaDatabasePath(getDataDir(), process.env.OPENCODE_CHANNEL ?? "latest"));
   const createHiddenExecutor = async (database) => {
     await cleanupLegacyOnce(database);
@@ -53746,6 +53956,12 @@ async function registerContext(context) {
             if (event.type?.startsWith("session.revert.") || event.type === "session.message.content.updated") {
               nativeFoldReplay?.onEvent(event);
               restoredRows.forget(sessionID);
+              messageTimesCache.delete(sessionID);
+            }
+            if (event.type === "session.step.started" || event.type === "session.step.ended" || event.type === "session.step.failed") {
+              const messageID = event.data.assistantMessageID;
+              if (typeof messageID === "string")
+                messageTimesCache.deleteMessage(sessionID, messageID);
             }
             if (event.type === "session.error" || event.type === "session.execution.failed") {
               const error = hiddenTerminalError(event);
@@ -53784,6 +54000,7 @@ async function registerContext(context) {
                 rawProviders.get(sessionID)?.();
                 rawProviders.delete(sessionID);
                 usage.delete(sessionID);
+                messageTimesCache.delete(sessionID);
                 hiddenSessionErrors.delete(sessionID);
                 storageNoticeBySession.delete(sessionID);
                 liveModels.delete(sessionID);
@@ -53877,7 +54094,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)
@@ -53902,7 +54119,7 @@ async function registerContext(context) {
               previousCut: reader.latestCompaction(draft.sessionID),
               summary
             })) {
-              draft.result = { summary };
+              draft.result = { summary, metadata: { keepID: undefined } };
               return;
             }
           }
@@ -53918,7 +54135,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.", {
@@ -53964,6 +54181,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,
@@ -53973,6 +54192,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"),
@@ -54078,22 +54301,9 @@ async function registerContext(context) {
     }
     await dropStorageNotices(draft.messages, isMagicContextSynthetic);
     const hostMessagesAtEntry = [...draft.messages];
-    const passTimes = new Map;
+    const cachedTimes = messageTimesCache.pass(draft.sessionID);
     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;
+      return cachedTimes(reader, timeIds(messages));
     };
     liveModels.set(draft.sessionID, {
       providerID: draft.model.providerID,
@@ -54407,6 +54617,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,
@@ -54415,6 +54640,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
@@ -54493,17 +54726,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({
@@ -54618,6 +54879,7 @@ async function registerContext(context) {
   }, 0));
   return {
     async dispose() {
+      messageTimesCache.clear();
       usageController.abort();
       await hiddenCompletionExecutor?.dispose();
       await usageDone;