@cortexkit/opencode-magic-context 0.49.35 → 0.49.37

package/dist/{context-fk8e3h9p.js → context-ngk2jz60.js}

@@ -37,7 +37,7 @@ import {
   rebaseSessionCoordinatesAsync,
   resolveOpenCodeProtectedTailBoundary,
   getActiveCompartmentRun
-} from "./index-4bgk5ztz.js";
+} from "./index-9tdvbdv1.js";
 import"./index-sd3egckz.js";
 import {
   getHarness2
@@ -61,7 +61,7 @@ import {
   resolveKnownHistorianContextLimit2,
   resolveHistorianContextLimit2
 } from "./index-dnqqqc5f.js";
-import"./index-nxrsns5x.js";
+import"./index-c5dzns43.js";
 import {
   CANONICAL_DREAM_TASKS,
   DREAM_TASK_CAPABILITIES,
@@ -131,7 +131,7 @@ import {
   applyJsonSchemaParameterDescriptions,
   MagicContextRpcServer,
   subagentTemperature
-} from "./index-b6xz3qbe.js";
+} from "./index-gnmhbyyc.js";
 import {
   resolveHistorianModel2
 } from "./index-5kym00ag.js";
@@ -154,8 +154,9 @@ import {
   isTransientSqliteError2,
   withAsyncPrivilegedWriter2
 } from "./index-gzy5w8ya.js";
-import"./index-cpjk5jd2.js";
-import"./index-qncw9hey.js";
+import"./index-96ztjvkn.js";
+import"./index-1d042x6w.js";
+import"./index-r2epb000.js";
 import"./index-1zx87sdm.js";
 import {
   stripPersistedAssistantText,
@@ -164,7 +165,7 @@ import {
   isDroppedToolOutput,
   evaluateChannel2,
   buildChannel2Reminder
-} from "./index-ksv0a31x.js";
+} from "./index-8jjjmhab.js";
 import {
   hasMeaningfulUserText2,
   preloadTokenizer,
@@ -174,7 +175,7 @@ import {
   getTableColumnNames
 } from "./index-9wnbnx8f.js";
 import"./index-58e3y90n.js";
-import"./index-pztqab6k.js";
+import"./index-vd2ywmfe.js";
 import {
   needsBlockedRead,
   DreamTokenBudgetExceeded,
@@ -207,17 +208,17 @@ import {
   cleanUserText2,
   readRawSessionMessageIdOrdinalsForRange2,
   readRawSessionMessageOrdinalById2
-} from "./index-brg2w6qc.js";
+} from "./index-tn9drm1a.js";
 import {
   BoundedSessionMap,
   recordToolDefinitionSet,
   getCurrentToolSetHash
 } from "./index-jkanybgq.js";
-import"./index-pq0dpwrc.js";
-import"./index-faxb7mck.js";
+import"./index-2rs7912w.js";
+import"./index-b1ydbp95.js";
 import {
   scheduleClearAndReindex
-} from "./index-87ctnzz9.js";
+} from "./index-dz48h1wx.js";
 import {
   invalidateAutoEmbedSession,
   clearEmbedSessionState
@@ -225,7 +226,7 @@ import {
 import"./index-g4t7850m.js";
 import {
   deleteChunkEmbedBackoffForSession2
-} from "./index-zhqwda72.js";
+} from "./index-dcjkw41m.js";
 import"./index-2p37txes.js";
 import {
   advanceSessionActivity,
@@ -252,8 +253,9 @@ import {
   noteLkgProviderResponse,
   clearLkgMeasuredRequest,
   getSlot,
+  dropSlot,
   copySessionStateForClone
-} from "./index-f297z1n8.js";
+} from "./index-72czy45z.js";
 import {
   startBootDeadline,
   BOOT_SQLITE_BUSY_TIMEOUT_MS,
@@ -261,7 +263,7 @@ import {
   openDatabaseAsync,
   isDatabasePersisted,
   getDatabasePersistenceError
-} from "./index-gyaa159j.js";
+} from "./index-9fgmkfaf.js";
 import"./index-fr0wbhdn.js";
 import"./index-nj360hcs.js";
 import {
@@ -280,29 +282,29 @@ import {
   EmergencyFailClosedError,
   DegradedPassRefusalError,
   isSyntheticHeadMessage2
-} from "./index-x2mrq5xv.js";
-import"./index-f9b3vtt1.js";
+} from "./index-dfdg2cgg.js";
+import"./index-850vthn3.js";
 import"./index-qt1qqasc.js";
 import {
   retainProjectEmbedding2
-} from "./index-jn0ddrhp.js";
+} from "./index-21fgrfrf.js";
 import"./index-jz5bk7xd.js";
 import"./index-4dhv7mqz.js";
-import"./index-1rhgxqs8.js";
-import"./index-pswsyf1w.js";
+import"./index-xd2p95m7.js";
+import"./index-ty4vhe4n.js";
 import"./index-jjvbk92s.js";
 import {
   renderUserFacingFailure,
   userFacingFailureCode
-} from "./index-0c7p8mq5.js";
+} from "./index-xnm0wq1r.js";
 import {
   pushNotification2,
   isTuiConnected2
 } from "./index-x8a7jmkh.js";
 import"./index-fw42ms3m.js";
-import"./index-2v6nvy3k.js";
-import"./index-3j9t1v4n.js";
-import"./index-3d3872c6.js";
+import"./index-ae1ar4v1.js";
+import"./index-wcwhhtdh.js";
+import"./index-ys7j6679.js";
 import"./index-gp3kcpc4.js";
 import {
   detectConflicts
@@ -323,12 +325,12 @@ import {
   readV2RawMessagePagesForConversion2,
   createV2RawMessageReader2,
   createV2RawMessageProvider2
-} from "./index-vzhhr1ht.js";
+} from "./index-4y35msh5.js";
 import"./index-fmsr7v69.js";
-import"./index-qx8j6kds.js";
+import"./index-j105mf16.js";
 import"./index-kaqs6h31.js";
-import"./index-dy7w6wm4.js";
-import"./index-ezv6dz3y.js";
+import"./index-prw8apnc.js";
+import"./index-4ks89h5a.js";
 import {
   isDreamerRunnable,
   isSmartNoteSurfaceAvailable,
@@ -737,12 +739,22 @@ function decodeThroughHostSchema(encoded) {
   const assetSchema = mediaPart?.fields?.media;
   const encoding = assetSchema?.ast?.encoding;
   const decode = Array.isArray(encoding) ? encoding[0]?.transformation?.decode : undefined;
-  const run = decode?.run;
-  if (typeof run !== "function")
-    return "host media schema has no decode transformation";
-  const result = run.call(decode, { _tag: "Some", value: encoded }, {});
-  const option = result?._tag === "Success" ? result.value : undefined;
-  const asset = option?._tag === "Some" ? option.value : undefined;
+  const getter = decode;
+  let asset;
+  if (getter?._tag === "Transform") {
+    if (typeof getter.transform !== "function")
+      return "host media schema has no decode transformation";
+    asset = getter.transform(encoded);
+  } else {
+    if (getter?._tag !== undefined)
+      return `host media schema has unsupported decode transformation: ${String(getter._tag)}`;
+    const run = getter?.run;
+    if (typeof run !== "function")
+      return "host media schema has no decode transformation";
+    const result = run.call(decode, { _tag: "Some", value: encoded }, {});
+    const option = result?._tag === "Success" ? result.value : undefined;
+    asset = option?._tag === "Some" ? option.value : undefined;
+  }
   if (!isClassInstance(asset) || asset.source !== source)
     return "host media schema decode did not return an asset";
   return asset;
@@ -787,6 +799,7 @@ class HostFoldIdle {
   now;
   timers;
   windows = new Map;
+  attempted = new Map;
   constructor(fold, now = Date.now, timers = { setTimeout, clearTimeout }) {
     this.fold = fold;
     this.now = now;
@@ -808,6 +821,9 @@ class HostFoldIdle {
     }
     if (!Number.isFinite(ttl) || lastResponseTime <= 0)
       return;
+    const attempted = this.attempted.get(sessionID);
+    if (attempted?.cacheTtl === cacheTtl && attempted.lastResponseTime === lastResponseTime)
+      return;
     const window = { cacheTtl, lastResponseTime };
     this.windows.set(sessionID, window);
     const eligible = () => this.windows.get(sessionID) === window && computeHardCacheExpired(window.cacheTtl, window.lastResponseTime, this.now());
@@ -816,6 +832,7 @@ class HostFoldIdle {
         return;
       if (eligible()) {
         window.timer = undefined;
+        this.attempted.set(sessionID, { cacheTtl, lastResponseTime });
         const release = () => {
           if (this.windows.get(sessionID) === window)
             this.windows.delete(sessionID);
@@ -832,9 +849,37 @@ class HostFoldIdle {
   dispose() {
     for (const sessionID of this.windows.keys())
       this.active(sessionID);
+    this.attempted.clear();
   }
 }
 
+// src/v2/fold/manual-baseline.ts
+function stageManualBaseline(db, sessionID, render) {
+  const read = () => db.prepare("SELECT * FROM session_meta WHERE session_id = ?").get(sessionID);
+  const before = read();
+  const columns = Object.keys(before).filter((key) => key.startsWith("cached_m0_") || key.startsWith("cached_m1_") || key === "memory_block_count" || key === "memory_block_ids");
+  const update = db.prepare(`UPDATE session_meta SET ${columns.map((key) => `${key} = ?`).join(", ")} WHERE session_id = ?`);
+  const restore = (row) => update.run(...columns.map((key) => row[key] ?? null), sessionID);
+  let summary;
+  let staged;
+  try {
+    summary = render();
+    staged = read();
+  } finally {
+    restore(before);
+  }
+  const commit = db.prepare(`UPDATE session_meta SET ${columns.map((key) => `${key} = ?`).join(", ")} WHERE session_id = ? AND ${columns.map((key) => `${key} IS ?`).join(" AND ")}`);
+  return {
+    summary,
+    boundaryID: staged.cached_m0_last_baseline_end_message_id,
+    commit() {
+      const result = commit.run(...columns.map((key) => staged[key] ?? null), sessionID, ...columns.map((key) => before[key] ?? null));
+      if (result.changes !== 1)
+        throw new Error("Manual compaction baseline changed during admission");
+    }
+  };
+}
+
 // src/v2/fold/memory-cache.ts
 import { randomUUID } from "node:crypto";
 
@@ -1621,6 +1666,30 @@ function adaptPayload(draft, admittedIDs = new Set, messageTimes = new Map, hidd
   };
 }
 
+// src/v2/fold/code-mode-catalog.ts
+var changed = "The Code Mode tool catalog has changed.";
+var replacement = `${changed} This catalog supersedes the previous Code Mode tool catalog.`;
+function codeModeCatalogKind(data) {
+  const text = data.text ?? "";
+  const metadata = data.metadata;
+  const keyed = typeof metadata === "object" && metadata !== null && "instructionSources" in metadata;
+  if (keyed) {
+    const sources = metadata.instructionSources;
+    if (!Array.isArray(sources) || !sources.includes("core/codemode"))
+      return;
+    if (sources.length !== 1)
+      return text.startsWith(replacement) ? "combined-replacement" : undefined;
+  }
+  if (text.startsWith(replacement))
+    return "replacement";
+  if (text.startsWith(changed))
+    return "incremental";
+  if (keyed || text.startsWith(`# Code Mode
+`) || text.startsWith("No Code Mode tools are currently available."))
+    return "initial";
+  return;
+}
+
 // src/v2/fold/native-codec.ts
 class NativeReplayUnavailable extends Error {
 }
@@ -1674,11 +1743,24 @@ var keys = (value, allowed) => Object.keys(value).every((key) => allowed.include
 var identity = (value) => typeof value === "string" && value.length > 0 && Buffer.byteLength(value) <= 1024;
 var digest = (value) => typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
 function validReplayState(value) {
-  if (!object(value) || !keys(value, ["floor", "controls", "blocked", "upgrade", "withoutRecentContext"]))
+  if (!object(value) || !keys(value, [
+    "floor",
+    "controls",
+    "blocked",
+    "upgrade",
+    "withoutRecentContext",
+    "retiredInstructionThrough",
+    "retiredInstructionIDs"
+  ]))
     return false;
   const floor = value.floor;
   const upgrade = value.upgrade;
-  return object(floor) && keys(floor, ["kind", "id", "seq", "after", "digest"]) && ["start", "summary", "checkpoint", "host-checkpoint"].includes(floor.kind) && identity(floor.id) && typeof floor.seq === "number" && typeof floor.after === "number" && Number.isSafeInteger(floor.seq) && Number.isSafeInteger(floor.after) && floor.after === (floor.kind === "start" || floor.kind === "host-checkpoint" ? floor.seq - 1 : floor.seq) && digest(floor.digest) && validControls(value.controls) && (value.blocked === undefined || typeof value.blocked === "boolean") && (value.withoutRecentContext === undefined || typeof value.withoutRecentContext === "boolean") && (upgrade === undefined || object(upgrade) && keys(upgrade, ["admissionID", "mode"]) && identity(upgrade.admissionID) && ["bounded", "host-checkpoint", "source-repair"].includes(upgrade.mode));
+  return object(floor) && keys(floor, ["kind", "id", "seq", "after", "digest"]) && ["start", "summary", "checkpoint", "host-checkpoint"].includes(floor.kind) && identity(floor.id) && typeof floor.seq === "number" && typeof floor.after === "number" && Number.isSafeInteger(floor.seq) && Number.isSafeInteger(floor.after) && floor.after === (floor.kind === "start" || floor.kind === "host-checkpoint" ? floor.seq - 1 : floor.seq) && digest(floor.digest) && validControls(value.controls) && (value.blocked === undefined || typeof value.blocked === "boolean") && (value.withoutRecentContext === undefined || typeof value.withoutRecentContext === "boolean") && (value.retiredInstructionThrough === undefined || Number.isSafeInteger(value.retiredInstructionThrough) && value.retiredInstructionThrough >= 0) && (value.retiredInstructionIDs === undefined || Array.isArray(value.retiredInstructionIDs) && value.retiredInstructionIDs.every(identity)) && (upgrade === undefined || object(upgrade) && keys(upgrade, ["admissionID", "mode"]) && identity(upgrade.admissionID) && ["bounded", "host-checkpoint", "source-repair"].includes(upgrade.mode));
+}
+function instructionRetirement(replay) {
+  const ids = new Set(replay?.retiredInstructionIDs);
+  const through = replay?.retiredInstructionThrough ?? -1;
+  return (row) => row.type === "system" && (row.seq <= through || ids.has(row.id));
 }
 function validAdmissionV3(value) {
   if (!object(value) || !keys(value, ["version", "proof", "replay"]) || value.version !== 3 || !object(value.proof))
@@ -1837,11 +1919,17 @@ function controlsThrough(controls, reader, sessionID, through) {
 
 // src/v2/fold/native-replay.ts
 var coordinates = new WeakMap;
+var sequences = new WeakMap;
+function nativeRowSequence(message) {
+  return sequences.get(message);
+}
 function nativeRowID(message) {
   return coordinates.get(message) ?? message.id;
 }
-function bindNativeRowID(message, id) {
+function bindNativeRowID(message, id, seq) {
   coordinates.set(message, id);
+  if (seq !== undefined)
+    sequences.set(message, seq);
 }
 function copyNativeInput(messages) {
   const copies = reviveNative(encodeNative(messages));
@@ -1850,6 +1938,9 @@ function copyNativeInput(messages) {
     const id = original && nativeRowID(original);
     if (id !== undefined)
       coordinates.set(copy, id);
+    const seq = original && sequences.get(original);
+    if (seq !== undefined)
+      sequences.set(copy, seq);
   });
   return copies;
 }
@@ -1961,6 +2052,48 @@ class NativeFoldReplay {
   async baseline(sessionID) {
     return this.tail(sessionID)?.baseline;
   }
+  async retiredInstructionThrough(sessionID, reader) {
+    if (!reader.latestCompaction(sessionID))
+      return -1;
+    return (await this.floorState(sessionID, reader))?.retiredInstructionThrough ?? -1;
+  }
+  async instructionRetirement(sessionID, reader) {
+    if (!reader.latestCompaction(sessionID))
+      return instructionRetirement();
+    return instructionRetirement(await this.floorState(sessionID, reader));
+  }
+  async prepareManualFold(sessionID, reader, boundaryID, summary) {
+    const running = reader.latestRunningCompaction(sessionID);
+    if (!running || this.options.protocol !== 3)
+      throw new NativeReplayUnavailable("Manual compaction has no running host checkpoint");
+    const previous = await this.floorState(sessionID, reader);
+    if (this.unprovenControls.has(sessionID) || previous?.blocked)
+      throw new NativeReplayUnavailable("Manual compaction controls have not been captured");
+    const seq = boundaryID ? reader.sequenceForId(sessionID, boundaryID) : undefined;
+    const row = seq === undefined ? undefined : reader.range(sessionID, seq - 1, seq)[0];
+    const first = reader.page(sessionID, { limit: 1 }).rows[0];
+    let floor = row ? floorFor(row, "summary") : undefined;
+    floor ??= first ? floorFor(first, "start") : undefined;
+    if (!floor)
+      throw new NativeReplayUnavailable("Manual compaction has no history boundary");
+    const instructions = reader.instructionRowsThrough(sessionID, running.seq - 1);
+    const retiredInstructionIDs = [];
+    let newerFullCatalog = false;
+    for (const instruction of [...instructions].reverse()) {
+      const text = instruction.data.text ?? "";
+      const catalog = codeModeCatalogKind(instruction.data);
+      if (instruction.seq > floor.after && (catalog && catalog !== "combined-replacement" && newerFullCatalog || text.length > 0 && summary.includes(text)))
+        retiredInstructionIDs.push(instruction.id);
+      if (catalog === "replacement" || catalog === "combined-replacement")
+        newerFullCatalog = true;
+    }
+    return {
+      floor,
+      controls: previous?.controls ?? [],
+      ...floor.after >= 0 ? { retiredInstructionThrough: floor.after } : {},
+      retiredInstructionIDs
+    };
+  }
   admissionKey(sessionID) {
     return this.options.protocol === 3 ? `native-fold/v3/${encodeURIComponent(sessionID)}` : admissionKey(sessionID);
   }
@@ -2180,7 +2313,7 @@ ${cached}
     return pending.rows.filter((row) => row.seq > pending.value.replay.floor.after).flatMap((row) => {
       const messages = this.rendered(structuredClone(row), model);
       for (const message of messages)
-        coordinates.set(message, row.id);
+        bindNativeRowID(message, row.id, row.seq);
       return messages;
     });
   }
@@ -2407,6 +2540,7 @@ ${cached}
     if (!isLocalCheckpoint(cut) || cut.session_id !== sessionID)
       return;
     let after = -1;
+    const retired = instructionRetirement(replayOverride ?? this.tail(sessionID)?.replay);
     if (this.options.protocol === 3) {
       const replay = replayOverride ?? this.tail(sessionID)?.replay;
       if (!replay || !validFloor(reader, sessionID, replay.floor))
@@ -2421,7 +2555,7 @@ ${cached}
     }
     const through = cut.seq - 1;
     const metadata = (this.metadataThrough.get(sessionID) ?? -1) >= through ? this.metadata.get(sessionID) : undefined;
-    const required = (metadata ?? reader.rowStampsThrough(sessionID, through, this.options.protocol === 3 ? after : undefined)).filter(conversational).filter((row) => row.seq > after && row.seq <= through);
+    const required = (metadata ?? reader.rowStampsThrough(sessionID, through, this.options.protocol === 3 ? after : undefined)).filter(conversational).filter((row) => !retired(row)).filter((row) => row.seq > after && row.seq <= through);
     const tail = this.tail(sessionID);
     let records;
     if (!this.dirty.has(sessionID) && tail?.model === `${model.providerID}/${model.id}` && this.storage.containsRows(sessionID, required.map((row) => row.id))) {
@@ -2432,10 +2566,10 @@ ${cached}
       if (required.some((row) => !restored.has(row.id)))
         return;
     }
-    const projected = records.flatMap((row) => {
+    const projected = records.filter((row) => !retired(row)).flatMap((row) => {
       const messages = reviveNative(JSON.parse(row.data));
       for (const message of messages)
-        coordinates.set(message, row.id);
+        bindNativeRowID(message, row.id, row.seq);
       return messages;
     });
     return this.options.protocol === 3 ? insertControls(projected, controlsThrough((replayOverride ?? this.tail(sessionID)?.replay)?.controls ?? [], reader, sessionID, through), nativeRowID) : projected;
@@ -2517,7 +2651,7 @@ ${cached}
       if (!row)
         throw new NativeReplayUnavailable("Native carrier has no source row coordinate");
       cursor = row.seq;
-      coordinates.set(message, row.id);
+      bindNativeRowID(message, row.id, row.seq);
       if (message.role !== "tool")
         owner = row.id;
       const messages = grouped.get(row) ?? [];
@@ -2542,13 +2676,13 @@ ${cached}
           replay = { ...replay, blocked: false };
           const replayAfter = replay.floor.after;
           const replayStart = replay.floor.kind === "start";
+          const baseline = this.servedBaseline(draft);
           captured = native.filter((message) => {
             if (effortPart(message))
               return false;
             const id = nativeRowID(message);
             if (HEAD_IDS.some((head) => head === id))
               return false;
-            const baseline = this.servedBaseline(draft);
             if (!id)
               return !(baseline && message.role === "user" && message.content.some((part) => part.type === "text" && part.text === baseline));
             if (replayStart)
@@ -2662,21 +2796,23 @@ ${cached}
       if (await this.admissions?.get(admissionKey(draft.sessionID)) && !await this.readV3(draft.sessionID))
         return false;
       const running = reader.latestRunningCompaction(draft.sessionID);
-      const replay = await this.floorState(draft.sessionID, reader, undefined, undefined, true);
+      const replay = args.manual?.replay ?? await this.floorState(draft.sessionID, reader, undefined, undefined, true);
       if (!running || !replay || replay.blocked) {
         this.report(draft.sessionID, "fold refused: no usable host checkpoint boundary");
         return false;
       }
       const model = `${draft.model.providerID}/${draft.model.id}`;
-      if (this.tail(draft.sessionID)?.model !== model)
+      if (!args.manual && this.tail(draft.sessionID)?.model !== model)
         this.storage.replaceRows(draft.sessionID, reader.latestSequence(draft.sessionID), []);
-      await this.retainReplay(draft.sessionID, replay, model, reader.latestSequence(draft.sessionID));
-      await this.storage.supply(draft.sessionID, running.id, JSON.stringify({
-        source: this.storage.sourceID,
-        sessionID: draft.sessionID,
-        admissionID: running.id,
-        summary
-      }));
+      if (!args.manual)
+        await this.retainReplay(draft.sessionID, replay, model, reader.latestSequence(draft.sessionID));
+      if (!args.manual)
+        await this.storage.supply(draft.sessionID, running.id, JSON.stringify({
+          source: this.storage.sourceID,
+          sessionID: draft.sessionID,
+          admissionID: running.id,
+          summary
+        }));
       const value = {
         version: 3,
         replay,
@@ -2689,6 +2825,57 @@ ${cached}
         }
       };
       const payload = encodeAdmissionV3(value);
+      if (args.manual) {
+        const keys = [
+          capturedReplayKey(draft.sessionID),
+          this.admissionKey(draft.sessionID)
+        ];
+        const old = await Promise.all(keys.map((key) => this.admissions?.get(key)));
+        const capture = {
+          version: 3,
+          sessionID: draft.sessionID,
+          sourceDigest: foldDigest(reader.hostIdentity()),
+          through: reader.latestSequence(draft.sessionID),
+          replay
+        };
+        const capturedPayload = JSON.stringify(capture);
+        let written = 0;
+        try {
+          for (const [index, key] of keys.entries()) {
+            const data = index === 0 ? capturedPayload : payload;
+            await this.admissions?.set(key, {
+              payload: data,
+              digest: foldDigest(data)
+            });
+            written++;
+          }
+          args.manual.commit();
+        } catch (error) {
+          for (let index = written - 1;index >= 0; index--) {
+            const key = keys[index];
+            if (!key)
+              continue;
+            if (old[index] !== undefined)
+              await this.admissions?.set(key, old[index]);
+            else if (this.admissions?.remove)
+              await this.admissions.remove(key);
+            else
+              await this.admissions?.set(key, null);
+          }
+          throw error;
+        }
+        this.invalidate(draft.sessionID);
+        this.cancelLegacyUpgrade(draft.sessionID);
+        this.cancelEditedAdmission(draft.sessionID);
+        await this.retainReplay(draft.sessionID, replay, model, running.seq - 1);
+        await this.storage.supply(draft.sessionID, running.id, JSON.stringify({
+          source: this.storage.sourceID,
+          sessionID: draft.sessionID,
+          admissionID: running.id,
+          summary
+        }));
+        return true;
+      }
       await this.admissions?.set(this.admissionKey(draft.sessionID), {
         payload,
         digest: foldDigest(payload)
@@ -2757,7 +2944,13 @@ ${cached}
         this.report(sessionID, "replay refused: missing usable checkpoint boundary");
         throw new NativeReplayUnavailable("Host checkpoint replay boundary is unavailable");
       }
-      options = { ...options, bounded: false, after: replay.floor.after };
+      options = {
+        ...options,
+        bounded: false,
+        after: replay.floor.after,
+        retiredInstructionThrough: replay.retiredInstructionThrough,
+        retiredInstructionIDs: replay.retiredInstructionIDs
+      };
     }
     const release = this.storage.hold(sessionID);
     let result;
@@ -2823,10 +3016,13 @@ ${cached}
       reader?.close();
     }
     const messages = [];
+    const retired = instructionRetirement(options);
     for (const row of this.storage.rows(sessionID, after, cut.seq - 1)) {
+      if (retired(row))
+        continue;
       const revived = reviveNative(JSON.parse(row.data));
       for (const message of revived)
-        coordinates.set(message, row.id);
+        bindNativeRowID(message, row.id, row.seq);
       messages.push(...revived);
     }
     return messages;
@@ -2839,10 +3035,11 @@ ${cached}
         this.report(sessionID, "replay refused: missing usable checkpoint boundary");
         throw new NativeReplayUnavailable("Host checkpoint replay boundary is unavailable");
       }
-      const messages = reader.range(sessionID, replay?.floor.after ?? -1, cut.seq - 1).filter(conversational).flatMap((row) => {
+      const retired = instructionRetirement(replay);
+      const messages = reader.range(sessionID, replay?.floor.after ?? -1, cut.seq - 1).filter(conversational).filter((row) => !retired(row)).flatMap((row) => {
         const messages = this.rendered(row, model);
         for (const message of messages)
-          coordinates.set(message, row.id);
+          bindNativeRowID(message, row.id, row.seq);
         return messages;
       });
       return replay ? insertControls(messages, controlsThrough(replay.controls, reader, sessionID, cut.seq - 1), nativeRowID) : messages;
@@ -2977,6 +3174,12 @@ class HostFoldPolicy {
   }
 }
 
+// src/v2/fold/summary.ts
+var RAW_HISTORY_ACCOUNT = "Magic Context retains the conversation as raw messages; no summarized history is available yet.";
+function hasFoldSummary(summary) {
+  return typeof summary === "string" && summary.replace(/<[^>]*>/g, "").trim().length > 0;
+}
+
 // src/v2/fork-inheritance.ts
 var RAW_TYPES = new Set(RAW_MESSAGE_TYPES2);
 function forkBoundarySeq(origin, sequenceForId) {
@@ -3866,6 +4069,26 @@ async function createV2HiddenCompletionExecutor(host, options) {
       const budgetStopped = new Promise((_resolve, reject) => {
         budgetReject = reject;
       });
+      const chargeBudgetRows = (rows) => {
+        if (!budget)
+          return;
+        for (const row of rows) {
+          if (row.seq <= usageSeq)
+            continue;
+          if (!row.data.finish)
+            break;
+          usageSeq = row.seq;
+          const tokens = row.data.tokens;
+          const decision = budget.charge(Math.max(0, tokens?.input ?? 0), Math.max(0, tokens?.cache?.read ?? 0), Math.max(0, tokens?.cache?.write ?? 0), row.data.finish === "stop" && !(row.data.content ?? []).some((part) => part.type === "tool-call"), false);
+          const onBudgetUpdate = run.identity.metadata?.onBudgetUpdate;
+          if (typeof onBudgetUpdate === "function")
+            onBudgetUpdate({ ...budget.snapshot(), sessionId: run.child.id });
+          if (decision !== "continue") {
+            attempt.budgetExceeded = new DreamTokenBudgetExceeded(run.child.id, budget.snapshot().spent);
+            return attempt.budgetExceeded;
+          }
+        }
+      };
       if (budget) {
         budgetPoll = inRootAsyncContext2(() => setInterval(() => {
           try {
@@ -3873,25 +4096,12 @@ async function createV2HiddenCompletionExecutor(host, options) {
               const latest = reader.latestAssistant(run.child.id);
               return latest ? [latest] : [];
             })());
-            for (const row of fresh) {
-              if (row.seq <= usageSeq)
-                continue;
-              usageSeq = row.seq;
-              const tokens = row.data.tokens;
-              const decision = budget.charge(Math.max(0, tokens?.input ?? 0), Math.max(0, tokens?.cache?.read ?? 0), Math.max(0, tokens?.cache?.write ?? 0), row.data.finish === "stop" && !(row.data.content ?? []).some((part) => part.type === "tool-call"), false);
-              const onBudgetUpdate = run.identity.metadata?.onBudgetUpdate;
-              if (typeof onBudgetUpdate === "function")
-                onBudgetUpdate({
-                  ...budget.snapshot(),
-                  sessionId: run.child.id
-                });
-              if (decision !== "continue") {
-                if (budgetPoll)
-                  clearInterval(budgetPoll);
-                attempt.budgetExceeded = new DreamTokenBudgetExceeded(run.child.id, budget.snapshot().spent);
-                interruptAndRetire(run, "token-budget").finally(() => budgetReject(attempt.budgetExceeded));
-                return;
-              }
+            const exceeded = chargeBudgetRows(fresh);
+            if (exceeded) {
+              if (budgetPoll)
+                clearInterval(budgetPoll);
+              interruptAndRetire(run, "token-budget").finally(() => budgetReject(exceeded));
+              return;
             }
           } catch (error) {
             if (budgetPoll)
@@ -3988,6 +4198,11 @@ async function createV2HiddenCompletionExecutor(host, options) {
         const tokens = row.data.tokens;
         const tokenNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
         const steps = withReader(options.openReader, (reader) => reader.assistantSince?.(run.child.id, baseline) ?? [row]).filter((step) => step.seq > baseline && step.seq <= row.seq);
+        const exceeded = chargeBudgetRows(steps);
+        if (exceeded) {
+          await interruptAndRetire(run, "token-budget");
+          throw exceeded;
+        }
         const reportedUsage = steps.some((step) => tokenNumber(step.data.tokens?.input) !== undefined || tokenNumber(step.data.tokens?.output) !== undefined);
         const usage = sumRowUsage(steps);
         if (request.signal?.aborted || run.retired || Date.now() >= deadline) {
@@ -4207,6 +4422,100 @@ class V2MessageTimesCache {
 
 // src/v2/hooks/channel2.ts
 import { randomBytes } from "node:crypto";
+
+// src/v2/hooks/synthetic-admission.ts
+var memos = new WeakMap;
+var MAX_SESSIONS = 64;
+var MAX_IDS = 50000;
+function admissionSession(key) {
+  if (!key.startsWith("synthetic/"))
+    return;
+  const end = key.indexOf("/", "synthetic/".length);
+  return end < 0 ? undefined : key.slice("synthetic/".length, end);
+}
+function memoFor(storage) {
+  const prior = memos.get(storage);
+  if (prior)
+    return prior;
+  const sessions = new Map;
+  const set = storage.set;
+  const remove = storage.remove;
+  const invalidate = (key) => {
+    const sessionID = admissionSession(key);
+    if (sessionID !== undefined) {
+      sessions.delete(sessionID);
+      const current = memos.get(storage);
+      if (current) {
+        current.sessions.delete(sessionID);
+        current.revision++;
+      }
+    }
+  };
+  const wrappedSet = async (key, value) => {
+    invalidate(key);
+    try {
+      await set.call(storage, key, value);
+    } finally {
+      invalidate(key);
+    }
+  };
+  const wrappedRemove = remove && (async (key) => {
+    invalidate(key);
+    try {
+      await remove.call(storage, key);
+    } finally {
+      invalidate(key);
+    }
+  });
+  const memo = { sessions, revision: 0, set, remove, wrappedSet, wrappedRemove };
+  storage.set = wrappedSet;
+  if (wrappedRemove)
+    storage.remove = wrappedRemove;
+  memos.set(storage, memo);
+  return memo;
+}
+function forgetSyntheticAdmission(storage, sessionID) {
+  const memo = memoFor(storage);
+  memo.sessions.delete(sessionID);
+  memo.revision++;
+}
+function clearSyntheticAdmissions(storage) {
+  const memo = memos.get(storage);
+  if (!memo)
+    return;
+  memo.sessions.clear();
+  if (storage.set === memo.wrappedSet)
+    storage.set = memo.set;
+  if (storage.remove === memo.wrappedRemove)
+    storage.remove = memo.remove;
+  memos.delete(storage);
+}
+async function admittedSynthetic(storage, sessionID, id) {
+  for (;; ) {
+    const memo = memoFor(storage);
+    const session = memo.sessions.get(sessionID) ?? new Map;
+    memo.sessions.delete(sessionID);
+    memo.sessions.set(sessionID, session);
+    if (memo.sessions.size > MAX_SESSIONS)
+      memo.sessions.delete(memo.sessions.keys().next().value);
+    const known = session.get(id);
+    if (known !== undefined)
+      return known;
+    const revision = memo.revision;
+    const record = await storage.get(`synthetic/${sessionID}/${id}`);
+    if (memos.get(storage) !== memo || memo.revision !== revision)
+      continue;
+    const admitted = record !== null && typeof record === "object" && "id" in record && record.id === id;
+    if (memo.sessions.get(sessionID) !== session)
+      return admitted;
+    if (session.size >= MAX_IDS)
+      session.delete(session.keys().next().value);
+    session.set(id, admitted);
+    return admitted;
+  }
+}
+
+// src/v2/hooks/channel2.ts
 var pendingCandidates = new WeakMap;
 function syntheticCandidates(context, sessionID, stored) {
   const pending = pendingCandidates.get(context.storage);
@@ -4222,9 +4531,17 @@ function syntheticCandidates(context, sessionID, stored) {
 }
 function clearSyntheticCandidates(context) {
   pendingCandidates.delete(context.storage);
+  clearSyntheticAdmissions(context.storage);
+}
+function observeSyntheticAdmissionEvent(context, event) {
+  const sessionID = event.data?.sessionID;
+  if (!sessionID || !(event.type === "session.deleted" || event.type?.startsWith("session.revert.")))
+    return;
+  forgetSyntheticAdmission(context.storage, sessionID);
 }
 async function deliverSynthetic(context, sessionID, text) {
   const id = `msg_${randomBytes(12).toString("hex")}`;
+  forgetSyntheticAdmission(context.storage, sessionID);
   await context.storage.set(`synthetic/${sessionID}/${id}`, { id });
   let candidates = pendingCandidates.get(context.storage);
   if (!candidates) {
@@ -4236,8 +4553,7 @@ async function deliverSynthetic(context, sessionID, text) {
   return id;
 }
 async function isAdmittedSynthetic(context, sessionID, id) {
-  const record = await context.storage.get(`synthetic/${sessionID}/${id}`);
-  return record !== null && typeof record === "object" && "id" in record && record.id === id;
+  return admittedSynthetic(context.storage, sessionID, id);
 }
 async function deliverPendingChannel2(context, db, sessionID, baseline) {
   if (getChannel2NudgeState(db, sessionID) !== "pending")
@@ -5066,16 +5382,31 @@ async function interruptBeforeProvider(session, sessionID, timers = systemTimers
 }
 
 // src/v2/hooks/restore-rows.ts
+var DEFAULT_LIMITS = {
+  maxSessions: 16,
+  sessionRows: 40000,
+  totalRows: 80000,
+  sessionBytes: 192 * 1024 * 1024,
+  totalBytes: 256 * 1024 * 1024
+};
+
 class RestoredRowCache {
-  capacity;
   sessions = new Map;
-  constructor(capacity = 16) {
-    this.capacity = capacity;
+  limits;
+  totalRows = 0;
+  totalBytes = 0;
+  constructor(limits = {}) {
+    this.limits = {
+      ...DEFAULT_LIMITS,
+      ...typeof limits === "number" ? { maxSessions: limits } : limits
+    };
   }
   rows(reader, sessionID, after, through) {
-    if (through <= after)
+    if (through <= after) {
+      this.forget(sessionID);
       return [];
-    const kept = this.sessions.get(sessionID) ?? new Map;
+    }
+    const kept = this.sessions.get(sessionID)?.rows ?? new Map;
     const stamps = reader.spanRowStamps(sessionID, after, through);
     const runs = [];
     let previous = after;
@@ -5097,28 +5428,44 @@ class RestoredRowCache {
         fresh.set(row.seq, row);
     const next = new Map;
     const rows = [];
+    let bytes = 0;
     for (const [seq, stamp] of stamps) {
       const row = fresh.get(seq) ?? kept.get(seq)?.row;
       if (!row)
         continue;
-      next.set(seq, { stamp, row });
       rows.push(row);
+      const rowBytes = Number(stamp.slice(stamp.lastIndexOf("\x00") + 1));
+      if (!Number.isSafeInteger(rowBytes) || rowBytes < 0 || next.size >= Math.min(this.limits.sessionRows, this.limits.totalRows) || bytes + rowBytes > Math.min(this.limits.sessionBytes, this.limits.totalBytes))
+        continue;
+      next.set(seq, { stamp, row });
+      bytes += rowBytes;
     }
-    this.sessions.delete(sessionID);
-    this.sessions.set(sessionID, next);
-    while (this.sessions.size > this.capacity) {
+    this.forget(sessionID);
+    if (next.size) {
+      this.sessions.set(sessionID, { rows: next, bytes });
+      this.totalRows += next.size;
+      this.totalBytes += bytes;
+    }
+    while (this.sessions.size > this.limits.maxSessions || this.totalRows > this.limits.totalRows || this.totalBytes > this.limits.totalBytes) {
       const oldest = this.sessions.keys().next().value;
       if (oldest === undefined)
         break;
-      this.sessions.delete(oldest);
+      this.forget(oldest);
     }
     return structuredClone(rows);
   }
   forget(sessionID) {
+    const prior = this.sessions.get(sessionID);
+    if (prior) {
+      this.totalRows -= prior.rows.size;
+      this.totalBytes -= prior.bytes;
+    }
     this.sessions.delete(sessionID);
   }
   clear() {
     this.sessions.clear();
+    this.totalRows = 0;
+    this.totalBytes = 0;
   }
 }
 function readPages(reader, sessionID, after, through) {
@@ -5518,7 +5865,7 @@ function persistV2UsageReading(args) {
     args.contextUsageMap.set(sessionID, {
       usage: { inputTokens: reading.inputTokens, percentage },
       hasUsageTokens: true,
-      updatedAt: Date.now()
+      updatedAt: reading.completed || Date.now()
     });
   } else {
     args.contextUsageMap.delete(sessionID);
@@ -5566,7 +5913,7 @@ function bindKeptInstructionCoordinates(messages, incoming, reader, sessionID) {
       selected.forEach((row, index) => {
         const message = pending[index];
         if (message)
-          bindNativeRowID(message, row.id);
+          bindNativeRowID(message, row.id, row.seq);
       });
     }
     pending = [];
@@ -5860,10 +6207,10 @@ async function applyV2SystemPrompt(systemPrompt, draft) {
     text
   })));
 }
-function coveredInstructionRows(reader, sessionID, throughSeq, model) {
+function coveredInstructionRows(reader, sessionID, throughSeq, model, retired = () => false) {
   if (throughSeq < 0)
     return [];
-  return reader.instructionRowsThrough(sessionID, throughSeq).flatMap((row) => restoreRow(row, model)).map((message) => markCoveredInstructionRow(message));
+  return reader.instructionRowsThrough(sessionID, throughSeq).filter((row) => !retired(row)).flatMap((row) => restoreRow(row, model)).map((message) => markCoveredInstructionRow(message));
 }
 async function registerContext(context) {
   const directory = context.location.directory;
@@ -6342,7 +6689,15 @@ async function registerContext(context) {
     storage: nativeFoldMemory,
     openReader: openStoreReader,
     canReplay: (sessionID, reader) => nativeFoldReplay.canReplay(sessionID, reader),
-    canFold: (sessionID, reader) => nativeFoldReplay.canFold(sessionID, reader),
+    canFold: async (sessionID, reader) => {
+      const meta = getOrCreateSessionMeta(storage.require(), sessionID);
+      const summary = [
+        servedModuleM0Text(sessionID),
+        await nativeFoldReplay.baseline(sessionID),
+        meta.cachedM0Bytes?.toString("utf8")
+      ].find((value) => value !== RAW_HISTORY_ACCOUNT && hasFoldSummary(value));
+      return !meta.isSubagent && summary !== RAW_HISTORY_ACCOUNT && hasFoldSummary(summary) && nativeFoldReplay.canFold(sessionID, reader);
+    },
     threshold: Number(process.env.MC_OC2_HOST_FOLD_ROWS ?? 1000),
     log: sessionLog2
   }) : undefined;
@@ -6368,6 +6723,7 @@ async function registerContext(context) {
             if (!event.data?.sessionID)
               continue;
             const sessionID = event.data.sessionID;
+            observeSyntheticAdmissionEvent(context, event);
             overflowRecovery.observeTerminal(event, (id, messageID) => {
               const reader = openStoreReader();
               try {
@@ -6549,22 +6905,46 @@ async function registerContext(context) {
       await storage.probe();
       const watermark = reader.latestSequenceForIds(draft.sessionID, draft.messages.flatMap((message) => message.id ? [message.id] : []));
       const running = reader.latestRunningCompaction(draft.sessionID);
+      const attempt = running && nativeFoldMemory?.admission(draft.sessionID, running.id);
+      const manual = running?.data.reason === "manual" && !(attempt?.status === "pending" && attempt.owner_token);
       const moduleBaseline = rustModeModuleClient ? servedModuleM0Text(draft.sessionID) : undefined;
       const source = !rustModeModuleClient ? "typescript" : moduleBaseline === null ? "typescript_fallback" : "module";
       if (nativeFoldReplay) {
         try {
           const state = getOrCreateSessionMeta(storage.require(), draft.sessionID);
-          const summary = moduleBaseline ?? await nativeFoldReplay.baseline(draft.sessionID) ?? state.cachedM0Bytes?.toString("utf8") ?? "<session-history></session-history>";
-          if (await nativeFoldReplay.supply({
+          const staged = manual && moduleBaseline == null ? stageManualBaseline(storage.require(), draft.sessionID, () => materialize(draft)) : undefined;
+          const publishedHistory = Boolean(storage.require().prepare("SELECT 1 FROM compartments WHERE session_id = ? LIMIT 1").get(draft.sessionID));
+          const candidate = [
+            moduleBaseline,
+            await nativeFoldReplay.baseline(draft.sessionID),
+            state.cachedM0Bytes?.toString("utf8"),
+            (await folds.read(draft.sessionID))?.submitted
+          ].find((value) => value !== RAW_HISTORY_ACCOUNT && (publishedHistory && value?.includes("<session-history>") || hasFoldSummary(value)));
+          const manualHistory = manual && hasFoldSummary(staged?.summary ?? moduleBaseline);
+          const summary = manualHistory ? staged?.summary ?? candidate ?? RAW_HISTORY_ACCOUNT : candidate ?? RAW_HISTORY_ACCOUNT;
+          const manualReplay = manualHistory && summary ? await nativeFoldReplay.prepareManualFold(draft.sessionID, reader, staged ? staged.boundaryID : storage.require().prepare("SELECT cached_m0_last_baseline_end_message_id AS id FROM session_meta WHERE session_id = ?").get(draft.sessionID).id, summary) : undefined;
+          if ((hasFoldSummary(summary) || publishedHistory) && await nativeFoldReplay.supply({
             draft,
             reader,
             previousCut: reader.latestCompaction(draft.sessionID),
-            summary
+            summary,
+            manual: manualReplay ? { replay: manualReplay, commit: () => staged?.commit() } : undefined
           })) {
+            if (manualHistory) {
+              dropSlot(draft.sessionID, "manual host compaction");
+              generateReplay.forget(draft.sessionID);
+              restoredRows.forget(draft.sessionID);
+              historyRefreshSessions.add(draft.sessionID);
+              requestPendingMaterialization(pendingMaterializationSessions, draft.sessionID, "host_compaction");
+            }
             draft.result = { summary, metadata: { keepID: undefined } };
             return;
           }
+          if (manual)
+            throw new V2ContextRefusal("Magic Context could not admit the manual fold.");
         } catch (error) {
+          if (error instanceof V2ContextRefusal || manual)
+            throw error;
           nativeFoldReplay.invalidate(draft.sessionID, true);
           sessionLog2(draft.sessionID, `v2 host fold: legacy compaction reason=${JSON.stringify(String(error))}`);
         }
@@ -6573,7 +6953,10 @@ async function registerContext(context) {
         sessionID: draft.sessionID,
         watermark,
         runningCut: running?.seq,
-        materialize: () => moduleBaseline ?? materialize(draft)
+        materialize: () => {
+          const summary = moduleBaseline ?? materialize(draft);
+          return hasFoldSummary(summary) ? summary : RAW_HISTORY_ACCOUNT;
+        }
       });
       sessionLog2(draft.sessionID, `v2 compaction hook: fired answered=true source=${source}`);
       draft.result = { summary: fold.submitted, metadata: { keepID: undefined } };
@@ -6588,6 +6971,19 @@ async function registerContext(context) {
   });
   const temporalTimes = config.temporal_awareness === true;
   const anchorTimesOnly = !temporalTimes && !rustModeModuleClient;
+  const retireInstructionMessages = async (sessionID, reader, messages) => {
+    const retired = await nativeFoldReplay?.instructionRetirement(sessionID, reader);
+    if (!retired)
+      return messages;
+    return messages.filter((message) => {
+      const id = nativeRowID(message);
+      return message.role !== "system" || !id || !retired({
+        type: "system",
+        id,
+        seq: nativeRowSequence(message) ?? reader.sequenceForId(sessionID, id) ?? Infinity
+      });
+    });
+  };
   const timeIds = (messages) => {
     if (temporalTimes)
       return messages.flatMap((message) => message.id ? [message.id] : []);
@@ -6609,16 +7005,17 @@ async function registerContext(context) {
     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 ? servedBoundaryRow2(reader, draft.sessionID, boundaryID) : null;
     const nativeFloor = await nativeFoldReplay?.restorationFloor(draft.sessionID, cut, reader);
+    const retiredInstructions = await nativeFoldReplay?.instructionRetirement(draft.sessionID, reader) ?? (() => false);
     const boundary = Math.max(nativeFloor ?? -Infinity, (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() ? {
+    const restored = restoredRows.rows(reader, draft.sessionID, boundary, cut.seq).filter((row) => !retiredInstructions(row)).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),
+      ...rustModeModuleClient ? [] : coveredInstructionRows(reader, draft.sessionID, Math.min(boundary, cut.seq), draft.model, retiredInstructions),
       ...restored,
       ...args.messages.filter((message) => message !== args.incoming)
     ];
@@ -6851,6 +7248,7 @@ async function registerContext(context) {
               }
             } else if (localCut)
               return;
+            messages = await retireInstructionMessages(draft.sessionID, reader, messages);
             times = readTimes(reader, messages);
           }
         } finally {
@@ -7080,6 +7478,7 @@ async function registerContext(context) {
             boundaryRepair
           }));
         }
+        draft.messages = await retireInstructionMessages(draft.sessionID, reader, draft.messages);
         messageTimes = readTimes(reader, draft.messages);
       } finally {
         reader.close();
@@ -7260,6 +7659,11 @@ async function registerContext(context) {
       if (!deletedSessions.has(draft.sessionID) && admissionRebuildPasses.has(draft.sessionID)) {
         await nativeFoldReplay?.commitLegacyUpgrade(draft.sessionID, true);
         await nativeFoldReplay?.commitEditedAdmission(draft.sessionID);
+        if (db && hostFoldIdle) {
+          const meta = getOrCreateSessionMeta(db, draft.sessionID);
+          if (computeHardCacheExpired(meta.cacheTtl, meta.lastResponseTime, Date.now()))
+            hostFoldIdle.idle(draft.sessionID, meta.cacheTtl, meta.lastResponseTime);
+        }
       }
     } finally {
       admissionRebuildPasses.delete(draft.sessionID);