@cortexkit/opencode-magic-context 0.49.35 → 0.49.37

package/dist/v2/{context-znqfkap4.js → context-05x7kr7f.js}

@@ -7,7 +7,7 @@ import {
   resolveLegacyConfigSources,
   getProtectedTokensTierOverrides,
   loadPluginConfigDetailed
-} from "./server-9k0mjef7.js";
+} from "./server-avdveykk.js";
 import {
   getHarness2,
   harnessOwnsOpenCodeStore2
@@ -38,6 +38,13 @@ import {
   getModelsDevCacheState
 } from "./server-qxzbmtqt.js";
 import {
+  string,
+  number,
+  boolean,
+  array,
+  object,
+  tuple,
+  literal,
   isValidLanguageCode,
   withContentLanguageDirective,
   parseCron,
@@ -49,7 +56,7 @@ import {
   DEFAULT_HISTORIAN_TIMEOUT_MS,
   DEFAULT_LOCAL_EMBEDDING_MODEL,
   DREAM_TASK_PROMOTION_DEFAULTS
-} from "./server-24g8r2d0.js";
+} from "./server-7zacmty5.js";
 import {
   CANONICAL_DREAM_TASKS,
   DREAM_TASK_CAPABILITIES,
@@ -202,7 +209,7 @@ import {
   startCompartmentAgent,
   setRecompStarting2,
   setRecompTerminal2
-} from "./server-fqj6ddpr.js";
+} from "./server-5by3vdzs.js";
 import {
   resolveHistorianModel2
 } from "./server-5kym00ag.js";
@@ -231,7 +238,7 @@ import {
   beginBootQuietPeriod,
   scheduleAfterBootQuiet
 } from "./server-69m30b21.js";
-import"./server-51779zs2.js";
+import"./server-v0p37hm2.js";
 import {
   inRootAsyncContext2,
   getTagIdentityWriteGeneration2,
@@ -246,9 +253,12 @@ import {
   SqliteAcquisitionBusyError2,
   withAsyncPrivilegedWriter2
 } from "./server-gzy5w8ya.js";
+import {
+  reuseWorker
+} from "./server-96ztjvkn.js";
 import {
   createWorkerShutdown
-} from "./server-cpjk5jd2.js";
+} from "./server-1d042x6w.js";
 import {
   areRustHistorianSyntheticParts2,
   isRawCompactionSummaryInfo2,
@@ -256,7 +266,7 @@ import {
   buildInMemoryTailRawMessages2,
   RawOrdinalsNotReady2,
   runSessionWarmupWorker
-} from "./server-s9xgyyj9.js";
+} from "./server-tnzbk64q.js";
 import {
   resolveModelCalibration,
   calibrateBuckets,
@@ -351,7 +361,7 @@ import {
   adoptNullOwnerToolTag2,
   getCandidateToolOwners2,
   pickNearestPriorOwner2
-} from "./server-bpvsvtph.js";
+} from "./server-xfjjbrkt.js";
 import {
   textMentionsRecentCommit,
   hasMeaningfulUserText2,
@@ -499,7 +509,6 @@ import {
   getPendingPiCompactionMarkerState,
   clearPendingPiCompactionMarkerStateIf,
   logPiCompactionMarkerClear,
-  setSessionWorkMetrics,
   getObservedEpochFloor,
   resolveEpochFloorForPass,
   getReasoningRemovalState,
@@ -581,7 +590,7 @@ import {
   readRawSessionMessageOrdinalById2,
   readSessionChunk2,
   readRawSessionSeedTail2
-} from "./server-1xesqm5h.js";
+} from "./server-jd7vzwn4.js";
 import {
   BoundedSessionMap,
   recordToolDefinitionSet,
@@ -592,8 +601,8 @@ import {
   cleanSearchText,
   matchedSearchSnippet,
   getLastIndexedOrdinal
-} from "./server-r3chnxs5.js";
-import"./server-ws5exe6q.js";
+} from "./server-dfq5vb8j.js";
+import"./server-nmyganc8.js";
 import {
   getMessageIndexEpoch,
   isMessageIndexSearchable,
@@ -619,7 +628,7 @@ import {
   resolveMemoriesByIdsForSearch2,
   unifiedSearch2,
   formatSearchResults2
-} from "./server-qa74bj91.js";
+} from "./server-7094pk3w.js";
 import {
   embedPauseBySession,
   embedRunStateBySession,
@@ -641,7 +650,7 @@ import {
 } from "./server-zzgtgqmd.js";
 import {
   deleteChunkEmbedBackoffForSession2
-} from "./server-hsf0qsn5.js";
+} from "./server-cp1a03vc.js";
 import {
   registerOwnRpcServerInstance,
   rpcPortDir,
@@ -752,7 +761,7 @@ import {
   saveSourceContent,
   replaceSourceContent,
   getSourceContents
-} from "./server-qf2kzsh2.js";
+} from "./server-t8y64xj7.js";
 import {
   startBootDeadline,
   getUnconfirmedMigrationHolders,
@@ -768,7 +777,7 @@ import {
   openDatabaseAsync,
   isDatabasePersisted,
   getDatabasePersistenceError
-} from "./server-7ccxt4nq.js";
+} from "./server-g3gqq4ac.js";
 import {
   V2_MEMORY_CATEGORIES,
   CATEGORY_PRIORITY
@@ -824,7 +833,7 @@ import {
   resolveHistorianProducerLimits2,
   resolveHistorianContextLimit2
 } from "./server-sd8hvzte.js";
-import"./server-xbtw0p9t.js";
+import"./server-r4430x9m.js";
 import {
   isEmbeddingHostBusy2
 } from "./server-qt1qqasc.js";
@@ -848,7 +857,7 @@ import {
   embedSessionCompartmentChunks2,
   getEmbeddingCoverageStatus2,
   getAutoEmbeddingSessionCoverage2
-} from "./server-bxpz2dcn.js";
+} from "./server-7acq7815.js";
 import {
   GIT_SWEEP_LEASE_RENEWAL_MS,
   acquireGitSweepLease,
@@ -868,10 +877,10 @@ import {
   getCachedLocalEmbeddingPooling,
   preflightLocalEmbeddingPooling,
   getLocalEmbeddingNativeMemoryStats
-} from "./server-rktnzs89.js";
+} from "./server-6vzh6wej.js";
 import {
   cosineSimilarity
-} from "./server-kkxzwa6w.js";
+} from "./server-gkse1wyz.js";
 import {
   computeCueContentHash,
   hasMuralCueColumns,
@@ -891,6 +900,7 @@ import {
   getMemoryById2,
   getMemoriesByIds2,
   updateMemorySeenCount2,
+  updateMemoryVerification2,
   setMemoryClassification2,
   supersededMemory2,
   mergeMemoryStats2,
@@ -915,7 +925,7 @@ import {
   readGitFileChangeTimesSince,
   verificationFileExists,
   normalizeVerificationFiles
-} from "./server-q0z2q2dx.js";
+} from "./server-nq3cb7be.js";
 import {
   registerNotificationSink2,
   pushNotification2,
@@ -944,7 +954,7 @@ import {
   readV2RawMessagePagesForConversion2,
   createV2RawMessageReader2,
   createV2RawMessageProvider2
-} from "./server-5jp38p98.js";
+} from "./server-6emy0v9a.js";
 import {
   resolvePromptContext2
 } from "./server-fmsr7v69.js";
@@ -952,14 +962,14 @@ import {
   renderMessageByOrdinal2,
   renderVerboseRangeForTool2,
   renderItemByTag2
-} from "./server-55v5hpth.js";
+} from "./server-qjyp27vf.js";
 import"./server-kaqs6h31.js";
 import {
   readV2ArchiveOffThread2
-} from "./server-x4m6xcn4.js";
+} from "./server-e51xmr4d.js";
 import {
   renderSearchArchiveOffThread2
-} from "./server-hnknwaz8.js";
+} from "./server-a9w5f0yw.js";
 import {
   markCoveredInstructionRow,
   isCoveredInstructionRow,
@@ -1099,11 +1109,11 @@ __export(exports_external, {
   _default: () => _default2,
   _function: () => _function,
   any: () => any,
-  array: () => array,
+  array: () => array2,
   base64: () => base642,
   base64url: () => base64url2,
   bigint: () => bigint2,
-  boolean: () => boolean2,
+  boolean: () => boolean3,
   catch: () => _catch2,
   check: () => check,
   cidrv4: () => cidrv42,
@@ -1157,7 +1167,7 @@ __export(exports_external, {
   ksuid: () => ksuid2,
   lazy: () => lazy,
   length: () => _length,
-  literal: () => literal,
+  literal: () => literal2,
   locales: () => exports_locales,
   looseObject: () => looseObject,
   lowercase: () => _lowercase,
@@ -1182,8 +1192,8 @@ __export(exports_external, {
   null: () => _null3,
   nullable: () => nullable,
   nullish: () => nullish2,
-  number: () => number2,
-  object: () => object2,
+  number: () => number3,
+  object: () => object3,
   optional: () => optional,
   overwrite: () => _overwrite,
   parse: () => parse3,
@@ -1213,7 +1223,7 @@ __export(exports_external, {
   size: () => _size,
   startsWith: () => _startsWith,
   strictObject: () => strictObject,
-  string: () => string2,
+  string: () => string3,
   stringFormat: () => stringFormat,
   stringbool: () => stringbool,
   success: () => success,
@@ -1226,7 +1236,7 @@ __export(exports_external, {
   transform: () => transform,
   treeifyError: () => treeifyError,
   trim: () => _trim,
-  tuple: () => tuple,
+  tuple: () => tuple2,
   uint32: () => uint32,
   uint64: () => uint64,
   ulid: () => ulid2,
@@ -1579,7 +1589,7 @@ __export(exports_regexes, {
   base64: () => base64,
   base64url: () => base64url,
   bigint: () => bigint,
-  boolean: () => boolean,
+  boolean: () => boolean2,
   browserEmail: () => browserEmail,
   cidrv4: () => cidrv4,
   cidrv6: () => cidrv6,
@@ -1608,7 +1618,7 @@ __export(exports_regexes, {
   md5_hex: () => md5_hex,
   nanoid: () => nanoid,
   null: () => _null,
-  number: () => number,
+  number: () => number2,
   rfc5322Email: () => rfc5322Email,
   sha1_base64: () => sha1_base64,
   sha1_base64url: () => sha1_base64url,
@@ -1622,7 +1632,7 @@ __export(exports_regexes, {
   sha512_base64: () => sha512_base64,
   sha512_base64url: () => sha512_base64url,
   sha512_hex: () => sha512_hex,
-  string: () => string,
+  string: () => string2,
   time: () => time,
   ulid: () => ulid,
   undefined: () => _undefined,
@@ -1706,10 +1716,10 @@ __export(exports_iso, {
 var exports_coerce = {};
 __export(exports_coerce, {
   bigint: () => bigint3,
-  boolean: () => boolean3,
+  boolean: () => boolean4,
   date: () => date4,
-  number: () => number3,
-  string: () => string3
+  number: () => number4,
+  string: () => string4
 });
 
 // src/v2/hooks/context.ts
@@ -4222,7 +4232,7 @@ async function acquireSearchWorker(db, key, entry, input, signal) {
     }
     const fresh = !slot;
     if (!slot) {
-      const worker = inRootAsyncContext2(() => new Worker(entry, { workerData: { ...input, persistent: true } }));
+      const worker = inRootAsyncContext2(() => input.job === "backfill" && entry.href === defaultAutoSearchWorkerEntry().href ? reuseWorker(entry, { workerData: input }) : new Worker(entry, { workerData: { ...input, persistent: true } }));
       const shutdown = createWorkerShutdown(worker, "auto-search", AUTO_SEARCH_WORKER_CLOSE_DEADLINE_MS);
       slot = {
         worker,
@@ -4300,6 +4310,7 @@ function queueAutoSearchBackfill(db, sessionId, projectPath, query) {
   pending.set(key, work);
   return work;
 }
+var nextSearchJobId = 0;
 async function executeAutoSearchWorker(db, sessionId, projectPath, query, options, entry, job) {
   if (options.signal?.aborted)
     return [];
@@ -4320,6 +4331,7 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
   const signal = deadlineSignal ? AbortSignal.any([deadlineSignal, lifecycle.signal]) : lifecycle.signal;
   const snapshot = getProjectEmbeddingSnapshot2(projectPath);
   const input = {
+    jobId: ++nextSearchJobId,
     job,
     path,
     harness: getHarness2(),
@@ -4439,6 +4451,8 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     const onMessage = async (reply) => {
       if (released)
         return;
+      if (entry.href === defaultAutoSearchWorkerEntry().href && reply.jobId !== input.jobId)
+        return;
       if (reply.kind === "diagnostics") {
         if (!settled && options.autoSearchDiagnostics) {
           const workerStarted = options.autoSearchDiagnostics.workerStarted;
@@ -4466,7 +4480,7 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
       }
       if (reply.kind === "messages" || reply.kind === "accepted")
         return;
-      const response = { id: reply.id };
+      const response = { id: reply.id, jobId: input.jobId };
       if (!signal.aborted) {
         const requestedAt = performance.now();
         try {
@@ -4595,7 +4609,7 @@ function searchMessageHistoryOffThread(db, request, entry = defaultAutoSearchWor
       deadline.unref?.();
     };
     try {
-      worker = inRootAsyncContext2(() => new Worker(entry, { workerData: input }));
+      worker = inRootAsyncContext2(() => entry.href === defaultAutoSearchWorkerEntry().href ? reuseWorker(entry, { workerData: input }) : new Worker(entry, { workerData: input }));
       shutdown = createWorkerShutdown(worker, "message-search", MESSAGE_SEARCH_WORKER_CLOSE_DEADLINE_MS);
     } catch (error) {
       finish(null, "start-failed", error);
@@ -5484,12 +5498,17 @@ function countCompartmentsSince(db, projectPath, since) {
   return row?.cnt ?? 0;
 }
 function countProjectSessionsSince(db, projectPath, since) {
-  const row = since === null ? db.prepare("SELECT COUNT(*) AS cnt FROM session_projects WHERE project_path = ?").get(projectPath) : db.prepare(`SELECT COUNT(*) AS cnt FROM session_projects sp
-                        LEFT JOIN schema_migrations_meta activity
-                          ON activity.key = 'retrospective_activity:' || sp.session_id
-                        LEFT JOIN message_history_index history ON history.session_id = sp.session_id
-                       WHERE sp.project_path = ?
-                         AND COALESCE(CAST(activity.value AS INTEGER), history.updated_at) > ?`).get(projectPath, since);
+  const scope = `FROM session_projects sp
+        LEFT JOIN session_meta m ON m.session_id = sp.session_id
+       WHERE sp.project_path = ? AND sp.harness = ?
+         AND COALESCE(m.is_subagent, 0) = 0`;
+  const row = since === null ? db.prepare(`SELECT COUNT(*) AS cnt ${scope}`).get(projectPath, getHarness2()) : db.prepare(`SELECT COUNT(*) AS cnt ${scope}
+                          AND COALESCE(
+                              (SELECT CAST(value AS INTEGER) FROM schema_migrations_meta
+                               WHERE key = 'retrospective_activity:' || sp.session_id),
+                              (SELECT updated_at FROM message_history_index
+                               WHERE session_id = sp.session_id AND harness = sp.harness)
+                          ) > ?`).get(projectPath, getHarness2(), since);
   return row?.cnt ?? 0;
 }
 function countMappedMemories(db, projectPath) {
@@ -5502,6 +5521,10 @@ function countMappedMemories(db, projectPath) {
                 AND v.file_path <> ''`).get(projectPath, Date.now());
   return row?.cnt ?? 0;
 }
+var CURRENT_VERIFY_SKIP_SQL = `COALESCE(CASE WHEN json_valid(m.metadata_json) THEN
+    json_extract(m.metadata_json, '$.dreamerVerifySkip.contentHash') = m.normalized_hash
+    AND json_type(m.metadata_json, '$.dreamerVerifySkip.fingerprint') = 'text'
+    ELSE 0 END, 0)`;
 function countUnverifiedMappedMemories(db, projectPath) {
   const row = db.prepare(`SELECT COUNT(DISTINCT m.id) AS cnt
                FROM memories m
@@ -5510,7 +5533,8 @@ function countUnverifiedMappedMemories(db, projectPath) {
                 AND m.status IN ('active','permanent')
                 AND (m.expires_at IS NULL OR m.expires_at > ?)
                 AND v.file_path <> ''
-                AND v.verified_at = 0`).get(projectPath, Date.now());
+                AND v.verified_at = 0
+                AND NOT (${CURRENT_VERIFY_SKIP_SQL})`).get(projectPath, Date.now());
   return row?.cnt ?? 0;
 }
 function countBroadCycleCandidates(db, projectPath, cycleStartAt) {
@@ -5519,6 +5543,7 @@ function countBroadCycleCandidates(db, projectPath, cycleStartAt) {
               WHERE m.project_path = ?
                 AND m.status IN ('active','permanent')
                 AND (m.expires_at IS NULL OR m.expires_at > ?)
+                AND NOT (${CURRENT_VERIFY_SKIP_SQL})
                 AND (
                     SELECT MAX(v.verified_at)
                       FROM memory_verifications v
@@ -5627,7 +5652,7 @@ function getDreamTaskBacklog(db, projectPath, task, options = {}) {
     case "verify-broad": {
       const total = countMappedMemories(db, projectPath);
       const cycleStartAt = getTaskScheduleState(db, projectPath, "verify-broad")?.lastBroadRunAt;
-      const pending = cycleStartAt == null ? total : countBroadCycleCandidates(db, projectPath, cycleStartAt);
+      const pending = countBroadCycleCandidates(db, projectPath, cycleStartAt ?? Number.MAX_SAFE_INTEGER);
       return { pending, total };
     }
     case "curate": {
@@ -5754,6 +5779,7 @@ function getDreamTaskBacklogs(db, projectPath, tasks = CANONICAL_DREAM_TASKS, op
   }
   const optionKey = (value) => value === undefined ? "omitted" : value === null ? "null" : `number:${value}`;
   const key = JSON.stringify([
+    getHarness2(),
     projectPath,
     tasks,
     optionKey(options.lastRunAt),
@@ -8584,6 +8610,130 @@ function isVisibleNoteReadPart(part) {
   return false;
 }
 
+// src/hooks/magic-context/strip-structural-noise.ts
+var STRUCTURAL_PART_TYPES = new Set(["meta", "step-start", "step-finish", "reasoning"]);
+var structuralSentinels = new WeakSet;
+function isStructuralNoiseSentinel(part) {
+  return isRecord(part) && structuralSentinels.has(part);
+}
+function isStructuralNoisePart(part) {
+  if (!isRecord(part) || typeof part.type !== "string") {
+    return false;
+  }
+  if (!STRUCTURAL_PART_TYPES.has(part.type)) {
+    return false;
+  }
+  if (part.type === "reasoning" && typeof part.text === "string" && part.text !== "[cleared]") {
+    return false;
+  }
+  return true;
+}
+function stripStructuralNoise(messages) {
+  let strippedParts = 0;
+  for (const message of messages) {
+    if (!Array.isArray(message.parts)) {
+      continue;
+    }
+    for (let i = 0;i < message.parts.length; i++) {
+      const part = message.parts[i];
+      if (isSentinel(part))
+        continue;
+      if (!isStructuralNoisePart(part))
+        continue;
+      message.parts[i] = makeSentinel(part);
+      if (isRecord(part) && part.type !== "reasoning") {
+        structuralSentinels.add(message.parts[i]);
+      }
+      strippedParts++;
+    }
+  }
+  return strippedParts;
+}
+
+// src/hooks/magic-context/project-structural-sentinels.ts
+function readOmissions(value) {
+  if (value === undefined)
+    return new Set;
+  if (!Array.isArray(value) || value.some((id) => typeof id !== "string" || !id))
+    throw new Error("Invalid structural-sentinel replay decisions");
+  return new Set(value);
+}
+function hasSignedReasoning(message) {
+  return message.info.role === "assistant" && message.parts.some((part) => {
+    if (!isRecord(part) || part.type !== "reasoning" || !isRecord(part.metadata))
+      return false;
+    const anthropic = part.metadata.anthropic;
+    return isRecord(anthropic) && typeof anthropic.signature === "string";
+  });
+}
+function readKeepIds(document) {
+  const value = document.structuralSentinelUpgrade;
+  if (value === undefined)
+    return;
+  if (!isRecord(value) || !Array.isArray(value.keep) || value.keep.some((id) => typeof id !== "string" || !id))
+    throw new Error("Invalid structural-sentinel upgrade");
+  return new Set(value.keep);
+}
+function prepareStructuralSentinelChoices(args) {
+  const document = readReplayEnvelope(args.db, args.sessionId);
+  if (readKeepIds(document))
+    return document;
+  const prior = !!args.db.prepare(`SELECT 1 WHERE
+                    EXISTS (SELECT 1 FROM session_meta WHERE session_id = ? AND trailing_blank_decisions <> '')
+                    OR EXISTS (SELECT 1 FROM session_replay_decisions WHERE session_id = ?)
+                    OR EXISTS (SELECT 1 FROM tags WHERE session_id = ?)
+                    OR EXISTS (SELECT 1 FROM lkg_slots WHERE session_id = ?)`).get(args.sessionId, args.sessionId, args.sessionId, args.sessionId);
+  try {
+    const persisted = updateReplayDocument(args.db, args.sessionId, (current) => {
+      if (readKeepIds(current))
+        return false;
+      current.version = 2;
+      current.structuralSentinelUpgrade = {
+        keep: prior ? args.messages.flatMap((message) => message.info.id && hasSignedReasoning(message) ? [message.info.id] : []) : []
+      };
+      return true;
+    });
+    if (!persisted)
+      throw new Error("Cannot persist structural-sentinel upgrade");
+  } catch (error) {
+    sessionLog2(args.sessionId, `structural-sentinel upgrade deferred: ${String(error)}`);
+    return document;
+  }
+  return readReplayEnvelope(args.db, args.sessionId);
+}
+function projectStructuralSentinels(args) {
+  const structuralMessages = args.messages.filter((message) => message.parts.some(isStructuralNoiseSentinel));
+  if (structuralMessages.length === 0)
+    return 0;
+  const document = args.deferUpgrade ? readReplayEnvelope(args.db, args.sessionId) : prepareStructuralSentinelChoices(args);
+  const keepIds = args.deferUpgrade ? undefined : readKeepIds(document);
+  let omittedIds = readOmissions(document.structuralSentinelOmissions);
+  const candidates = structuralMessages.filter((message) => typeof message.info.id === "string" && message.info.id !== "" && hasSignedReasoning(message));
+  const selected = keepIds && args.rebuilding ? candidates.filter((message) => keepIds.has(message.info.id ?? "") && !omittedIds.has(message.info.id ?? "")) : [];
+  if (selected.length) {
+    if (!updateReplayDocument(args.db, args.sessionId, (document) => {
+      const ids = readOmissions(document.structuralSentinelOmissions);
+      for (const message of selected) {
+        ids.add(message.info.id);
+      }
+      document.version = 2;
+      document.structuralSentinelOmissions = [...ids];
+      return true;
+    }))
+      throw new Error("Cannot persist structural-sentinel omissions");
+    omittedIds = readOmissions(readReplayEnvelope(args.db, args.sessionId).structuralSentinelOmissions);
+  }
+  let removed = 0;
+  for (const message of candidates) {
+    if (!omittedIds.has(message.info.id ?? "") && (!keepIds || keepIds.has(message.info.id ?? "")))
+      continue;
+    const parts = message.parts.filter((part) => !isStructuralNoiseSentinel(part));
+    removed += message.parts.length - parts.length;
+    message.parts = parts;
+  }
+  return removed;
+}
+
 // src/hooks/magic-context/strict-thinking-prefix.ts
 function servedPrefixMatches(args) {
   const heads = args.messages?.slice(0, 2);
@@ -8930,38 +9080,6 @@ ${typeof state?.output === "string" ? state.output : JSON.stringify(state?.outpu
     text: typeof part.text === "string" ? part.text : typeof part.thinking === "string" ? part.thinking : undefined
   };
 }
-// src/hooks/magic-context/strip-structural-noise.ts
-var STRUCTURAL_PART_TYPES = new Set(["meta", "step-start", "step-finish", "reasoning"]);
-function isStructuralNoisePart(part) {
-  if (!isRecord(part) || typeof part.type !== "string") {
-    return false;
-  }
-  if (!STRUCTURAL_PART_TYPES.has(part.type)) {
-    return false;
-  }
-  if (part.type === "reasoning" && typeof part.text === "string" && part.text !== "[cleared]") {
-    return false;
-  }
-  return true;
-}
-function stripStructuralNoise(messages) {
-  let strippedParts = 0;
-  for (const message of messages) {
-    if (!Array.isArray(message.parts)) {
-      continue;
-    }
-    for (let i = 0;i < message.parts.length; i++) {
-      const part = message.parts[i];
-      if (isSentinel(part))
-        continue;
-      if (!isStructuralNoisePart(part))
-        continue;
-      message.parts[i] = makeSentinel(part);
-      strippedParts++;
-    }
-  }
-  return strippedParts;
-}
 // src/hooks/magic-context/foreign-text-parts.ts
 function hasStringId(part) {
   return part !== null && typeof part === "object" && typeof part.id === "string";
@@ -10432,6 +10550,9 @@ async function runPostTransformPhase(args) {
     }
   };
   const trailingBlankSourceDecisions = args.trailingBlankSourceDecisions ?? snapshotTrailingBlankSourceDecisions(args.messages);
+  let structuralSentinelUpgradeFailed = args.structuralSentinelUpgradeFailed ?? false;
+  if (!structuralSentinelUpgradeFailed && args.opencode1 && !compactionOff && modelAcceptsEmptyContent(args.resolvedProviderID))
+    structuralSentinelUpgradeFailed = prepareStructuralSentinelChoices(args).structuralSentinelUpgrade === undefined;
   if (!modelAcceptsEmptyContent(args.resolvedProviderID) && !compactionOff)
     captureInlineThinkingRepairs(args.messages, args.messageTagNumbers, args.sessionMeta?.clearedReasoningThroughTag ?? 0);
   const servedShapeRepair = prepareServedShapeRepair(args.db, args.sessionId, args.messages, args.readLastServedMessages, compactionOff ? undefined : postprocessReplaySnapshot(args.db, args.sessionId));
@@ -10550,6 +10671,8 @@ async function runPostTransformPhase(args) {
   const servedBeforeFirstRender = firstRenderBust ? args.readLastServedMessages?.() : null;
   let foldExecutedThisPass = false;
   let foldBustsServedPrefixThisPass = false;
+  let foldChangesHeadThisPass = false;
+  let recoveryExternalFoldCause = null;
   let publishedM1RefreshedThisPass = false;
   let prefixPreflightFailed = false;
   const softRefreshOpportunity = !freezeM0M1 && (args.schedulerDecision === "execute" || deferredMaterialize || servedShapeRepair.needsRebuild);
@@ -10628,9 +10751,16 @@ async function runPostTransformPhase(args) {
       prefixPreflightFailed = foldResult.materializationContentionRetryExhausted === true;
       foldExecutedThisPass = foldExecutesThisPass(foldDueDecision.value || softRefreshOpportunity, foldResult.m0RematerializedThisPass);
       foldBustsServedPrefixThisPass = foldExecutedThisPass && (committedFoldBustsServedPrefix ?? true);
+      foldChangesHeadThisPass = foldExecutedThisPass && committedFoldChangesHead === true;
       publishedM1RefreshedThisPass = !foldResult.materializationContentionRetryExhausted && previousM1 !== args.sessionMeta.cachedM1Bytes?.toString("utf8");
       m0RematerializedThisPass = foldResult.m0RematerializedThisPass;
       m0MaterializeReason = foldResult.decision.reason;
+      if (!prefixPreflightFailed && foldExecutedThisPass) {
+        const decision = foldResult.decision;
+        if (decision.reason === "system_hash" && decision.systemHashPrev && decision.systemHashPrev !== "0" || decision.reason === "model_change" && decision.m0ModelKeyPrev || decision.reason === "tool_definitions") {
+          recoveryExternalFoldCause = decision.reason;
+        }
+      }
       if (foldResult.m0RematerializedThisPass && convertedToolSkeletons.size > 0) {
         convertedToolSkeletonsDidMutate = renderConvertedToolSkeletons(args.targets, convertedToolSkeletons);
         sessionLog2(args.sessionId, `HARD fold converted ${convertedToolSkeletons.size} legacy dropped-tool skeleton(s) to real-or-absent`);
@@ -10733,8 +10863,14 @@ async function runPostTransformPhase(args) {
       newTargets = args.targets;
     }
   }
+  const recoveryHasHistoryHead = m0M1EnabledForFold || (args.pendingCompartmentInjection?.compartmentCount ?? 0) > 0;
+  const recoveryHeadChangedThisPass = !prefixPreflightFailed && (foldChangesHeadThisPass || !firstRenderBust && publishedM1RefreshedThisPass || !m0M1EnabledForFold && legacyPublishedHeadChanged(args));
+  const recoveryHeadlessRebuild = !recoveryHasHistoryHead && (args.schedulerDecision === "execute" || isExplicitFlush || forceMaterialization || emergencyDropEligible);
+  const recoveredShapeRewriteProof = recoveryHeadChangedThisPass ? "head_bytes" : recoveryExternalFoldCause ?? (recoveryHeadlessRebuild ? "headless_rebuild" : null);
+  const canNormalizeRecoveredShape = isCacheBustingPass && !activeThinkingPrefixHold && recoveredShapeRewriteProof !== null;
+  sessionLog2(args.sessionId, `rewrite permission: allowed=${isCacheBustingPass} ${reclaimRideLabel(rideSignals)} served_shape_repair=${servedShapeRepair.needsRebuild} signed_prefix_release=${rewritingSignedPrefix} fold_prefix_loss=${foldBustsServedPrefixThisPass} first_render=${firstRenderBust} idle_expiry=${idleExpiryRebuild} thinking_hold=${activeThinkingPrefixHold} recovery_has_head=${recoveryHasHistoryHead} recovery_head_changed=${recoveryHeadChangedThisPass} recovery_headless_rebuild=${recoveryHeadlessRebuild} proven_external_fold=${recoveryExternalFoldCause ?? "none"} recovered_shape_proof=${recoveredShapeRewriteProof ?? "none"}`);
   let recoveryTailNormalizedThisPass = false;
-  if (args.normalizeRecoveryTail && isCacheBustingPass && !activeThinkingPrefixHold) {
+  if (args.normalizeRecoveryTail && canNormalizeRecoveredShape) {
     args.normalizeRecoveryTail();
     recoveryTailNormalizedThisPass = true;
     args.tags = getTagsBySession2(args.db, args.sessionId);
@@ -11852,6 +11988,19 @@ async function runPostTransformPhase(args) {
     if (reasoningRemovalEnabled)
       removeReasoningParts(args.messages, removedReasoningIds, args.resolvedProviderID);
   }
+  const releaseRecoveryThisPass = canEditWholePrefix;
+  if (releaseRecoveryThisPass)
+    args.releaseRecoveryPrefix?.();
+  sessionLog2(args.sessionId, `recovery projection: case=${canNormalizeRecoveredShape ? recoveredShapeRewriteProof : releaseRecoveryThisPass ? "conversation_only" : "defer"} released=${releaseRecoveryThisPass} normalized=${recoveryTailNormalizedThisPass}`);
+  if (canUseEmptySentinels && args.opencode1) {
+    projectStructuralSentinels({
+      db: args.db,
+      sessionId: args.sessionId,
+      messages: args.messages,
+      rebuilding: canNormalizeRecoveredShape && bustedThisPass,
+      deferUpgrade: structuralSentinelUpgradeFailed
+    });
+  }
   sessionLog2(args.sessionId, `final representation: clearedParts=${finalRepresentation.clearedParts} mergedReasoningParts=${finalRepresentation.mergedReasoningParts} removedReasoningParts=${removedReasoningParts} settledDroppedReasoning=${settledDroppedReasoning}`);
   logTransformTiming(args.sessionId, "finalizeMessageRepresentation", tFinalRepresentation, `clearedParts=${finalRepresentation.clearedParts} mergedReasoningParts=${finalRepresentation.mergedReasoningParts}`);
   const tTailBaseline = performance.now();
@@ -12715,6 +12864,44 @@ function createPassOutcome() {
   };
 }
 
+// src/hooks/magic-context/release-recovery-prefix.ts
+function groups(messages) {
+  const result = new Map;
+  for (const message of messages) {
+    if (!message.info.id)
+      continue;
+    const group = result.get(message.info.id) ?? [];
+    group.push(message);
+    result.set(message.info.id, group);
+  }
+  return result;
+}
+function visibleGroup(group) {
+  return JSON.stringify(group.map((message) => ({
+    role: message.info.role,
+    parts: message.parts.filter((part) => !isStructuralNoiseSentinel(part) && !(isRecord(part) && (part.type === "step-start" || part.type === "step-finish" || part.type === "meta"))).map(providerVisiblePart)
+  })));
+}
+function snapshotRecoveryMessages(messages) {
+  return new Map([...groups(messages)].map(([id, group]) => [id, visibleGroup(group)]));
+}
+function releaseRecoveryPrefix(args) {
+  const frozen = groups(args.frozen);
+  const rendered = groups(args.after);
+  const emitted = new Set;
+  return args.after.flatMap((message) => {
+    const id = message.info.id;
+    if (!id)
+      return [message];
+    if (emitted.has(id))
+      return [];
+    emitted.add(id);
+    const group = rendered.get(id) ?? [message];
+    const previous = frozen.get(id);
+    return previous && args.before.get(id) === visibleGroup(group) ? previous : group;
+  });
+}
+
 // src/hooks/magic-context/rust-mode-transform.ts
 import { createHash as createHash5, randomUUID as randomUUID2 } from "node:crypto";
 
@@ -15394,6 +15581,32 @@ function releaseRustServedRaw(db, sessionId, output, rebuiltIdentity) {
 }
 
 // src/hooks/magic-context/transform-context-state.ts
+var usageRefusals = new WeakMap;
+function recordUsageRefusal(db, sessionId, refusedAt = Date.now()) {
+  let sessions = usageRefusals.get(db);
+  if (!sessions) {
+    sessions = new Map;
+    usageRefusals.set(db, sessions);
+  }
+  if (!sessions.has(sessionId))
+    sessions.set(sessionId, refusedAt);
+}
+function shouldResetRefusedUsage(db, sessionId, meta, liveReading) {
+  const refusals = usageRefusals.get(db);
+  const refusedAt = refusals?.get(sessionId);
+  if (refusedAt === undefined)
+    return false;
+  const readingAt = liveReading?.hasUsageTokens ? liveReading.updatedAt : meta.lastResponseTime;
+  if (readingAt > refusedAt) {
+    refusals?.delete(sessionId);
+    return false;
+  }
+  const now = Date.now();
+  const foldedAt = meta.cachedM0MaterializedAt ?? 0;
+  if (foldedAt > refusedAt && foldedAt <= now)
+    return true;
+  return !!db.prepare("SELECT 1 FROM compartments WHERE session_id = ? AND harness = ? AND created_at > ? AND created_at <= ? LIMIT 1").get(sessionId, getHarness2(), refusedAt, now);
+}
 function loadPersistedUsageWatermark(db, sessionId) {
   const result = db.prepare("SELECT last_response_time FROM session_meta WHERE session_id = ?").get(sessionId);
   if (result === null || typeof result !== "object")
@@ -19335,6 +19548,7 @@ function createTransform(deps) {
         return;
       throw degradedPassError(site, error);
     };
+    const structuralSentinelUpgradeFailed = deps.storeGeneration === "v1" && !deps.compactionOff && deps.transformMode !== "rust" && prepareStructuralSentinelChoices({ db, sessionId, messages }).structuralSentinelUpgrade === undefined;
     if (deps.storeGeneration !== undefined) {
       try {
         if (rustModeTransform && readCoordinateGeneration(db, sessionId) !== deps.storeGeneration) {
@@ -19556,10 +19770,13 @@ function createTransform(deps) {
     loadedSessions.add(sessionId);
     const earlyStateSnapshot = loadTransformPassStateSnapshot(db, sessionId);
     const historianFailureState = earlyStateSnapshot.historianFailure;
-    if (isFirstTransformPassForSession && sessionMeta) {
+    const liveUsageBeforeReset = deps.contextUsageMap.get(sessionId);
+    const usageResetAfterRefusal = shouldResetRefusedUsage(db, sessionId, sessionMeta, liveUsageBeforeReset);
+    if ((isFirstTransformPassForSession || usageResetAfterRefusal) && sessionMeta) {
       const persistedPct = sessionMeta.lastContextPercentage ?? 0;
-      if (persistedPct > 0) {
-        sessionLog2(sessionId, `transform: first pass reset — percentage=${persistedPct.toFixed(1)}% — clearing stale usage state`);
+      if (persistedPct > 0 || usageResetAfterRefusal && (sessionMeta.lastInputTokens > 0 || deps.contextUsageMap.has(sessionId))) {
+        const resetPct = persistedPct || liveUsageBeforeReset?.usage.percentage || 0;
+        sessionLog2(sessionId, `transform: ${isFirstTransformPassForSession ? "first pass" : "refused turn recovery"} reset — percentage=${resetPct.toFixed(1)}% — clearing stale usage state`);
         updateSessionMeta(db, sessionId, {
           lastContextPercentage: 0,
           lastInputTokens: 0
@@ -19968,10 +20185,15 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     let taggingSucceeded = false;
     let recoveryBatch = null;
     let recoveryNormalized = false;
+    let recoveryReleased = false;
     const untaggedReplayTailServed = !!recovery.prefix || untaggedReplayIds.size > 0 && messages.some((message) => untaggedReplayIds.has(message.info.id ?? ""));
+    const releaseRecoveryReplay = untaggedReplayTailServed ? () => {
+      recoveryReleased = true;
+    } : undefined;
     const normalizeRecoveryTail = untaggedReplayTailServed ? () => {
       if (recoveryNormalized)
         return;
+      recoveryReleased = true;
       const tail = messages.filter((message) => untaggedReplayIds.has(message.info.id ?? ""));
       const tagged = tagMessages(sessionId, tail, deps.tagger, db, {
         skipPrefixInjection: !ctxReduceCallable,
@@ -20047,6 +20269,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     const targetTagNumbers = [...targets.keys()];
     const targetsSliceTags = compactionOff ? [] : getDroppedTagsByNumbers2(db, sessionId, targetTagNumbers);
     logTransformTiming(sessionId, "getDroppedTagsByNumbers", t1b, `targets=${targetTagNumbers.length} fetched=${targetsSliceTags.length}`);
+    const recoveryBeforePostprocess = recovery.prefix ? snapshotRecoveryMessages(messages) : undefined;
     let didMutateFromFlushedStatuses = false;
     if (taggingSucceeded) {
       try {
@@ -20191,7 +20414,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     let contextUsageFromEstimate = hostOverWindow;
     if (contextUsage.inputTokens <= 0 && protectionCacheBustingPass) {
       const overflowRecoveryPass = usagePercentageSynthetic || emergencyRecoveryArmed;
-      const savedProviderReading = overflowRecoveryPass ? null : savedProviderReadingForPass({
+      const savedProviderReading = overflowRecoveryPass || usageResetAfterRefusal ? null : savedProviderReadingForPass({
         persisted: persistedUsageBeforeResets,
         currentModelKey: currentModelKeyForBoundary ?? (hardModelKey || undefined),
         contextLimit: resolvedContextLimit,
@@ -20258,7 +20481,10 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     const tPostProcess = performance.now();
     dropProjectionEmergency = contextUsage.percentage >= 95;
     const postTransformResult = await runPostTransformPhase({
+      opencode1: deps.storeGeneration === "v1",
       opencode2: deps.storeGeneration === "v2",
+      structuralSentinelUpgradeFailed,
+      releaseRecoveryPrefix: releaseRecoveryReplay,
       normalizeRecoveryTail,
       compactionMarkerStrategy: deps.compactionMarkerStrategy ?? defaultCompactionMarkerStrategy,
       sessionId,
@@ -20353,7 +20579,17 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       }
     });
     compactionModeTransitionPending.delete(sessionId);
-    if (recovery.prefix && !recoveryNormalized) {
+    if (recovery.prefix && recoveryReleased && !recoveryNormalized) {
+      if (!recoveryBeforePostprocess)
+        throw new Error("Cannot release recovery without its pre-edit snapshot");
+      const released = releaseRecoveryPrefix({
+        frozen: JSON.parse(recovery.prefix.json),
+        before: recoveryBeforePostprocess,
+        after: messages
+      });
+      messages.splice(0, messages.length, ...released);
+    }
+    if (recovery.prefix && !recoveryReleased) {
       const renderedById = new Map;
       for (const message of messages) {
         if (!message.info.id)
@@ -20365,7 +20601,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       const suffix = recoveryTailSources.flatMap(({ identity, pristineSystem }) => pristineSystem ? [pristineSystem] : renderedById.get(identity) ?? []);
       messages.splice(0, messages.length, ...JSON.parse(recovery.prefix.json), ...suffix);
     }
-    const recoveryReleaseReason = recovery.rebuildReason ?? (recoveryNormalized ? "recovery_tail_normalized" : undefined);
+    const recoveryReleaseReason = recovery.rebuildReason ?? (recoveryNormalized ? "recovery_tail_normalized" : recoveryReleased ? "recovery_prefix_released" : undefined);
     if (recoveryReleaseReason)
       postTransformResult.bustedThisPass = true;
     passOutcome.markFinalized();
@@ -20500,6 +20736,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         }
         try {
           await host.hostRefuse(deps.client, sessionId);
+          recordUsageRefusal(db, sessionId);
         } catch (error) {
           sessionLog2(sessionId, "transform: emergency fail-closed abort failed; refusing to return a sendable prompt:", getErrorMessage(error));
           throw new EmergencyFailClosedError("Emergency recovery abort failed", {
@@ -20747,7 +20984,16 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       });
     deps.onPassPermission?.(sessionId, postTransformResult.prefixMutationPermitted);
   };
-  const timedTransform = (input, output) => withTransformTimingSummary(() => transform(input, output));
+  const timedTransform = (input, output) => withTransformTimingSummary(async () => {
+    const sessionId = findSessionId(output.messages);
+    try {
+      await transform(input, output);
+    } catch (error) {
+      if (sessionId && !deps.compactionOff && error instanceof EmergencyFailClosedError)
+        recordUsageRefusal(deps.db, sessionId);
+      throw error;
+    }
+  });
   return Object.assign(timedTransform, {
     clearSessionLogState,
     invalidateRustWireState(sessionId) {
@@ -22433,6 +22679,78 @@ function computeOpenCodeWorkMetricsIncremental(openCodeDb, sessionId, carry, gen
   return { carry, metrics: metricsFromCarry(view) };
 }
 
+// src/features/magic-context/work-metrics-carry-storage.ts
+var STATE_KEY = "magicContextWorkMetrics";
+var storedCarry = object({
+  version: literal(1),
+  source: string(),
+  newWorkSum: number(),
+  lastTimeCreated: number(),
+  lastId: string(),
+  perAgent: array(tuple([
+    string(),
+    object({
+      prevPrompt: number(),
+      phaseId: number(),
+      phasePeak: number(),
+      phaseHasQualifying: boolean(),
+      closedPhaseSum: number(),
+      lastOutput: number(),
+      seen: boolean()
+    })
+  ]))
+});
+function readState2(db, sessionId) {
+  const row = db.prepare("SELECT deferred_execute_state, new_work_tokens, total_input_tokens FROM session_meta WHERE session_id = ?").get(sessionId);
+  let root = {};
+  try {
+    const value = JSON.parse(row?.deferred_execute_state ?? "null");
+    if (value !== null && typeof value === "object" && !Array.isArray(value))
+      root = value;
+  } catch {}
+  return { root, newWorkTokens: row?.new_work_tokens, totalInputTokens: row?.total_input_tokens };
+}
+function matchesStoredState(state, source, carry, metrics) {
+  const parsed = storedCarry.safeParse(state.root[STATE_KEY]);
+  if (!parsed.success)
+    return false;
+  const previous = parsed.data;
+  if (previous.source !== source || previous.newWorkSum !== carry.newWorkSum || previous.lastTimeCreated !== carry.lastTimeCreated || previous.lastId !== carry.lastId || previous.perAgent.length !== carry.perAgent.size || state.newWorkTokens !== metrics.newWorkTokens || state.totalInputTokens !== metrics.totalInputTokens)
+    return false;
+  return previous.perAgent.every(([key, agent]) => {
+    const current = carry.perAgent.get(key);
+    return current !== undefined && agent.prevPrompt === current.prevPrompt && agent.phaseId === current.phaseId && agent.phasePeak === current.phasePeak && agent.phaseHasQualifying === current.phaseHasQualifying && agent.closedPhaseSum === current.closedPhaseSum && agent.lastOutput === current.lastOutput && agent.seen === current.seen;
+  });
+}
+function readSessionWorkMetricsCarry(db, sessionId, source) {
+  const parsed = storedCarry.safeParse(readState2(db, sessionId).root[STATE_KEY]);
+  if (!parsed.success || parsed.data.source !== source)
+    return;
+  return {
+    perAgent: new Map(parsed.data.perAgent),
+    newWorkSum: parsed.data.newWorkSum,
+    lastTimeCreated: parsed.data.lastTimeCreated,
+    lastId: parsed.data.lastId
+  };
+}
+function setSessionWorkMetricsCarry(db, sessionId, source, carry, metrics) {
+  const normalized = {
+    newWorkTokens: Math.max(0, Math.floor(metrics.newWorkTokens)),
+    totalInputTokens: Math.max(0, Math.floor(metrics.totalInputTokens))
+  };
+  if (matchesStoredState(readState2(db, sessionId), source, carry, normalized))
+    return;
+  db.transaction(() => {
+    const state = readState2(db, sessionId);
+    if (matchesStoredState(state, source, carry, normalized))
+      return;
+    ensureSessionMetaRow(db, sessionId);
+    const { root } = state;
+    root[STATE_KEY] = { ...carry, version: 1, source, perAgent: [...carry.perAgent] };
+    db.prepare("UPDATE session_meta SET deferred_execute_state = ?, new_work_tokens = ?, total_input_tokens = ? WHERE session_id = ?").run(JSON.stringify(root), normalized.newWorkTokens, normalized.totalInputTokens, sessionId);
+  }).immediate();
+}
+
 // src/plugin/embedding-bootstrap.ts
 import { readFileSync, statSync } from "node:fs";
 
@@ -23060,7 +23378,6 @@ function pluginPackageVersion(moduleUrl = import.meta.url) {
 }
 
 // src/plugin/rpc-handlers.ts
-var workMetricsCarryBySession = new Map;
 async function executeRustRecompRpc(moduleClient, sessionId, projectRoot) {
   if (!moduleClient)
     return { ok: false, error: "Rust module client is unavailable" };
@@ -23100,12 +23417,11 @@ function resolveSidebarWorkMetrics(db, sessionId, persistedNewWork, persistedTot
     return { newWorkTokens: persistedNewWork, totalInputTokens: persistedTotalInput };
   }
   try {
-    const carryKey = `${generation}:${sessionId}`;
-    const carry = workMetricsCarryBySession.get(carryKey) ?? emptyWorkMetricsCarry();
+    const source = `${generation}:${resolveOpenCodeDbPath(generation).path}`;
+    const carry = readSessionWorkMetricsCarry(db, sessionId, source) ?? emptyWorkMetricsCarry();
     const { carry: nextCarry, metrics } = withReadOnlySessionDb((openCodeDb) => computeOpenCodeWorkMetricsIncremental(openCodeDb, sessionId, carry, generation), generation);
-    workMetricsCarryBySession.set(carryKey, nextCarry);
     try {
-      setSessionWorkMetrics(db, sessionId, metrics.newWorkTokens, metrics.totalInputTokens);
+      setSessionWorkMetricsCarry(db, sessionId, source, nextCarry, metrics);
     } catch {}
     return metrics;
   } catch {
@@ -24004,8 +24320,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-fcnjref7.js"));
-    const { sendIgnoredMessage } = await importPluginModule(() => import("./send-session-notification-fst6hkg7.js"));
+    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-9cjk6aej.js"));
+    const { sendIgnoredMessage } = await importPluginModule(() => import("./send-session-notification-kxp47tsw.js"));
     log2(`[rpc] recomp requested for session ${sessionId}`);
     if (!args.client && !args.hiddenCompletionExecutor) {
       return {
@@ -24089,7 +24405,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-aqpqsveg.js"));
+    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-j1v62bkj.js"));
     const model = liveSessionState.liveModelBySession.get(sessionId);
     const contextLimit = model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
     const ctx = {
@@ -25108,12 +25424,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;
@@ -25158,6 +25484,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;
@@ -25179,6 +25506,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());
@@ -25187,6 +25517,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);
@@ -25203,9 +25534,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 as randomUUID4 } from "node:crypto";
 
@@ -25992,6 +26351,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 {
 }
@@ -26040,19 +26423,32 @@ var efforts = new Set(["none", "minimal", "low", "medium", "high", "xhigh", "max
 
 class ControlMetadataUnavailable extends Error {
 }
-var object = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var object2 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
 var keys = (value, allowed) => Object.keys(value).every((key) => allowed.includes(key));
 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 (!object2(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 object2(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 || object2(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))
+  if (!object2(value) || !keys(value, ["version", "proof", "replay"]) || value.version !== 3 || !object2(value.proof))
     return false;
   const proof = value.proof;
   return keys(proof, [
@@ -26069,7 +26465,7 @@ function encodeAdmissionV3(value) {
   return JSON.stringify(value);
 }
 function validCapturedReplayV3(value) {
-  return object(value) && keys(value, ["version", "sessionID", "sourceDigest", "through", "replay"]) && value.version === 3 && identity(value.sessionID) && digest(value.sourceDigest) && Number.isSafeInteger(value.through) && validReplayState(value.replay);
+  return object2(value) && keys(value, ["version", "sessionID", "sourceDigest", "through", "replay"]) && value.version === 3 && identity(value.sessionID) && digest(value.sourceDigest) && Number.isSafeInteger(value.through) && validReplayState(value.replay);
 }
 function floorFor(row, kind) {
   return {
@@ -26208,11 +26604,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));
@@ -26221,6 +26623,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;
 }
@@ -26332,6 +26737,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);
   }
@@ -26551,7 +26998,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;
     });
   }
@@ -26778,6 +27225,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))
@@ -26792,7 +27240,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))) {
@@ -26803,10 +27251,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;
@@ -26888,7 +27336,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) ?? [];
@@ -26913,13 +27361,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)
@@ -27033,21 +27481,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,
@@ -27060,6 +27510,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)
@@ -27128,7 +27629,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;
@@ -27194,10 +27701,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;
@@ -27210,10 +27720,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;
@@ -27348,6 +27859,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) {
@@ -28342,6 +28859,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 {
@@ -28349,25 +28886,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)
@@ -28464,6 +28988,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) {
@@ -28683,6 +29212,100 @@ class V2MessageTimesCache {
 
 // src/v2/hooks/channel2.ts
 import { randomBytes as randomBytes2 } 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);
@@ -28698,9 +29321,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_${randomBytes2(12).toString("hex")}`;
+  forgetSyntheticAdmission(context.storage, sessionID);
   await context.storage.set(`synthetic/${sessionID}/${id}`, { id });
   let candidates = pendingCandidates.get(context.storage);
   if (!candidates) {
@@ -28712,8 +29343,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")
@@ -28915,7 +29545,7 @@ class DeletedSessionTombstones {
 }
 
 // src/features/magic-context/dreamer/task-executor.ts
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 import { existsSync as existsSync7, readFileSync as readFileSync8 } from "node:fs";
 
 // src/features/magic-context/mural/compress-cues.ts
@@ -34658,7 +35288,7 @@ function insertDreamRun(db, run) {
 }
 
 // src/features/magic-context/dreamer/verify.ts
-import { createHash as createHash13 } from "node:crypto";
+import { createHash as createHash14 } from "node:crypto";
 
 // src/features/magic-context/dreamer/verify-diff.ts
 import { execFile as execFile3 } from "node:child_process";
@@ -34779,7 +35409,56 @@ Read only these changed line ranges if they may affect the claim.`
 }
 
 // src/features/magic-context/dreamer/verify-gate.ts
+import path6 from "node:path";
+
+// src/features/magic-context/dreamer/verify-state.ts
+import { createHash as createHash13 } from "node:crypto";
+import { readFile, realpath as realpath2 } from "node:fs/promises";
 import path5 from "node:path";
+function verificationMetadata(memory) {
+  try {
+    const parsed = JSON.parse(memory.metadataJson ?? "{}");
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+      return parsed;
+  } catch {}
+  return {};
+}
+async function verificationFilesFingerprint(directory, files) {
+  const root = await resolveGitTopLevel(directory) ?? path5.resolve(directory);
+  const hash = createHash13("sha256");
+  for (const file of [...new Set(files)].sort()) {
+    const absolute = path5.resolve(root, file);
+    const withinRoot = (candidate) => {
+      const relative = path5.relative(root, candidate);
+      return relative !== ".." && !relative.startsWith(`..${path5.sep}`) && !path5.isAbsolute(relative);
+    };
+    if (!withinRoot(absolute))
+      return null;
+    hash.update(JSON.stringify(file));
+    try {
+      if (!withinRoot(await realpath2(absolute)))
+        return null;
+      hash.update(createHash13("sha256").update(await readFile(absolute)).digest("hex"));
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        return null;
+      hash.update("missing");
+    }
+  }
+  return hash.digest("hex");
+}
+function recordVerificationVerdict(db, memory, verdict, at, fingerprint = null) {
+  const metadata = verificationMetadata(memory);
+  delete metadata.dreamerVerifySkip;
+  if (verdict === "skip" && fingerprint) {
+    metadata.dreamerVerifySkip = { contentHash: memory.normalizedHash, fingerprint, at };
+  }
+  metadata.dreamerVerifyVerdict = verdict;
+  metadata.dreamerVerifyAttemptedAt = at;
+  db.prepare("UPDATE memories SET metadata_json = ? WHERE id = ?").run(JSON.stringify(metadata), memory.id);
+}
+
+// src/features/magic-context/dreamer/verify-gate.ts
 function minOf(values) {
   return values.reduce((acc, v) => v < acc ? v : acc, Number.POSITIVE_INFINITY);
 }
@@ -34811,7 +35490,22 @@ async function partitionVerifyScope(args) {
   const runStartedAt = args.now ?? Date.now();
   const active = getMemoriesByProject2(args.db, args.projectIdentity);
   const verById = getMemoryVerifications(args.db, active.map((m) => m.id));
-  const candidates = active.filter((m) => (verById.get(m.id)?.files.length ?? 0) > 0);
+  const candidates = [];
+  const unchangedSkippedIds = [];
+  const changedSkippedIds = new Set;
+  for (const memory of active) {
+    const files = verById.get(memory.id)?.files ?? [];
+    if (!files.length)
+      continue;
+    const skip = verificationMetadata(memory).dreamerVerifySkip;
+    if (skip && skip.contentHash === memory.normalizedHash && typeof skip.fingerprint === "string" && skip.fingerprint === await verificationFilesFingerprint(args.projectDirectory, files)) {
+      unchangedSkippedIds.push(memory.id);
+    } else {
+      candidates.push(memory);
+      if (skip)
+        changedSkippedIds.add(memory.id);
+    }
+  }
   const toPrompt = (m) => {
     const verifiedAt = verById.get(m.id)?.verifiedAt ?? 0;
     let verifiedCommit = null;
@@ -34838,7 +35532,7 @@ async function partitionVerifyScope(args) {
       leaseKey: args.leaseKey,
       runStartedAt
     });
-    const broadCandidates = candidates.filter((m) => (verById.get(m.id)?.verifiedAt ?? 0) < broadCycleStartAt).sort((a, b) => {
+    const broadCandidates = candidates.filter((m) => changedSkippedIds.has(m.id) || (verById.get(m.id)?.verifiedAt ?? 0) < broadCycleStartAt).sort((a, b) => {
       const verifiedAtA = verById.get(a.id)?.verifiedAt ?? 0;
       const verifiedAtB = verById.get(b.id)?.verifiedAt ?? 0;
       return verifiedAtA - verifiedAtB || a.id - b.id;
@@ -34849,7 +35543,10 @@ async function partitionVerifyScope(args) {
       mode: "broad",
       inScope: broadCandidates.map(toPrompt),
       inScopeIds: broadCandidates.map((m) => m.id),
-      skippedIds: candidates.filter((m) => !broadIds.has(m.id)).map((m) => m.id),
+      skippedIds: [
+        ...unchangedSkippedIds,
+        ...candidates.filter((m) => !broadIds.has(m.id)).map((m) => m.id)
+      ],
       broadCycleStartAt,
       reason: `broad cycle (${broadCandidates.length} remain; started ${broadCycleStartAt})`
     };
@@ -34860,7 +35557,7 @@ async function partitionVerifyScope(args) {
       mode: "incremental",
       inScope: [],
       inScopeIds: [],
-      skippedIds: [],
+      skippedIds: unchangedSkippedIds,
       reason: "no file-mapped memories in scope"
     };
   }
@@ -34869,11 +35566,11 @@ async function partitionVerifyScope(args) {
     mode,
     inScope: candidates.map(toPrompt),
     inScopeIds: candidates.map((m) => m.id),
-    skippedIds: [],
+    skippedIds: unchangedSkippedIds,
     reason
   });
   const resolvedGitRoot = await resolveGitTopLevel(args.projectDirectory);
-  const gitRoot = resolvedGitRoot ?? path5.resolve(args.projectDirectory);
+  const gitRoot = resolvedGitRoot ?? path6.resolve(args.projectDirectory);
   const verifiedTimes = candidates.map((m) => verById.get(m.id)?.verifiedAt ?? 0).filter((t) => t > 0);
   const sinceMs = verifiedTimes.length > 0 ? minOf(verifiedTimes) : runStartedAt;
   const changeTimes = await readGitFileChangeTimesSince(args.projectDirectory, sinceMs, resolvedGitRoot ?? undefined);
@@ -34883,11 +35580,11 @@ async function partitionVerifyScope(args) {
   const head = await readGitHead(args.projectDirectory);
   const uncommitted = head ? await readGitChangedFilesSince(args.projectDirectory, head, resolvedGitRoot ?? undefined) ?? new Set : new Set;
   const inScope = [];
-  const skippedIds = [];
+  const skippedIds = [...unchangedSkippedIds];
   for (const m of candidates) {
     const v = verById.get(m.id);
     const verifiedAt = v?.verifiedAt ?? 0;
-    if (verifiedAt === 0) {
+    if (verifiedAt === 0 || changedSkippedIds.has(m.id)) {
       inScope.push(toPrompt(m));
       continue;
     }
@@ -35257,6 +35954,7 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
   let budgetFinalized = false;
   let failedCompletion;
   let headAtPrompt = null;
+  const skipSnapshots = new Map;
   const onBudgetUpdate = (state) => {
     budgetFinalized ||= state.finalizeFired;
     args.onBudgetUpdate?.({
@@ -35273,6 +35971,11 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
     });
   };
   try {
+    if (!args.moduleRoute) {
+      for (const memory of batch) {
+        skipSnapshots.set(memory.id, await raceWithSignal(verificationFilesFingerprint(args.sessionDirectory, memory.mappedFiles), batchSignal));
+      }
+    }
     headAtPrompt = await raceWithSignal(readGitHead(args.sessionDirectory), batchSignal);
     const evidence = !args.forceBroad && batch.every((m) => m.verifiedAt) ? await raceWithSignal(buildVerifyDiffEvidence(args.sessionDirectory, batch), batchSignal) : null;
     const prompt = buildVerifyPrompt(args.projectIdentity, await raceWithSignal(seedVerifyCandidates(batch, args.sessionDirectory), batchSignal), evidence);
@@ -35314,7 +36017,7 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
         tokens: run.completion.usage
       });
       reportUsage(run.completion.messages ?? [], run.childSessionId, run.completion.usage.input + (run.completion.usage.cacheRead ?? 0) + (run.completion.usage.cacheWrite ?? 0));
-      return await applyParsedVerifyManifest(args, batch, run.validated, evidence?.head ?? headAtPrompt, budgetFinalized);
+      return await applyParsedVerifyManifest(args, batch, run.validated, evidence?.head ?? headAtPrompt, budgetFinalized, skipSnapshots);
     }
     const client = args.client;
     if (!client)
@@ -35374,7 +36077,7 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
     promptSettled = true;
     recordInvocation4(args, startedAt, { status: "completed", messages: run.output });
     reportUsage(run.output, agentSessionId);
-    return await applyParsedVerifyManifest(args, batch, run.validated, evidence?.head ?? headAtPrompt, budgetFinalized);
+    return await applyParsedVerifyManifest(args, batch, run.validated, evidence?.head ?? headAtPrompt, budgetFinalized, skipSnapshots);
   } catch (error) {
     const desc = describeError(error);
     const providerFailure = error instanceof DreamerProviderOutputFailureError ? error : undefined;
@@ -35394,7 +36097,7 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
     if (interrupted) {
       const text = verifyAssistantText(messages) ?? failedCompletion?.text ?? "";
       const recovered = parsePartialVerifyManifest(text, new Set(batch.map((m) => m.id)));
-      const counts = await applyParsedVerifyManifest(args, batch, recovered, headAtPrompt, true);
+      const counts = await applyParsedVerifyManifest(args, batch, recovered, headAtPrompt, true, skipSnapshots);
       return {
         ...counts,
         timedOut: !(error instanceof DreamTokenBudgetExceeded),
@@ -35426,7 +36129,7 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
     signal.removeEventListener("abort", abort);
   }
 }
-async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budgetFinalized = false) {
+async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budgetFinalized = false, skipSnapshots) {
   const batchIds = new Set(batch.map((m) => m.id));
   const batchById = new Map(batch.map((memory) => [memory.id, memory]));
   const valid = {
@@ -35505,6 +36208,15 @@ async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budg
     }
     writes.push({ kind: "archive", id: a.id, reason: a.reason });
   }
+  if (!args.moduleRoute) {
+    for (const entry of valid.skipped) {
+      const original = batchById.get(entry.id);
+      if (!original)
+        continue;
+      const fingerprint = skipSnapshots ? skipSnapshots.get(entry.id) ?? null : await verificationFilesFingerprint(args.sessionDirectory, original.mappedFiles);
+      writes.push({ kind: "skip", id: entry.id, fingerprint });
+    }
+  }
   let verified = 0;
   let updated = 0;
   let archived = 0;
@@ -35534,7 +36246,7 @@ async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budg
           name: "memory.set_verification",
           arguments: {
             memory_project: args.projectIdentity,
-            command_id: `${args.moduleRoute.moduleCommandId}:${createHash13("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
+            command_id: `${args.moduleRoute.moduleCommandId}:${createHash14("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
             rows
           }
         }
@@ -35566,9 +36278,17 @@ async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budg
         continue;
       if (w.kind === "verify") {
         recordMemoryVerifications(args.db, w.id, w.files, now);
-        if (verifiedHead)
-          recordVerifiedCommit(args.db, memory, now, verifiedHead);
+        updateMemoryVerification2(args.db, w.id, "verified");
+        recordVerificationVerdict(args.db, memory, "verified", now);
+        const verifiedMemory = getMemoryById2(args.db, w.id);
+        if (verifiedHead && verifiedMemory)
+          recordVerifiedCommit(args.db, verifiedMemory, now, verifiedHead);
         verified += 1;
+      } else if (w.kind === "skip") {
+        if (memory.content !== batchById.get(w.id)?.content)
+          continue;
+        updateMemoryVerification2(args.db, w.id, "unverified");
+        recordVerificationVerdict(args.db, memory, "skip", now, w.fingerprint);
       } else if (w.kind === "update") {
         const duplicate = getMemoryByHash2(args.db, memory.projectPath, memory.category, w.hash);
         if (duplicate && duplicate.id !== memory.id) {
@@ -35577,6 +36297,8 @@ async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budg
           continue;
         }
         rewriteMemoryContent(args.db, memory, w.content, w.hash);
+        updateMemoryVerification2(args.db, w.id, "unverified");
+        recordVerificationVerdict(args.db, memory, "update", now);
         queueMemoryMutation(args.db, {
           projectPath: args.projectIdentity,
           mutationType: "update",
@@ -35587,6 +36309,8 @@ async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budg
         updated += 1;
       } else {
         archiveMemory2(args.db, w.id, w.reason);
+        updateMemoryVerification2(args.db, w.id, "stale");
+        recordVerificationVerdict(args.db, memory, "archive", now);
         queueMemoryMutation(args.db, {
           projectPath: args.projectIdentity,
           mutationType: "archive",
@@ -36380,7 +37104,7 @@ function parseFrictionGateVerdict(verdict) {
 }
 function computeRetrospectiveWindowKey(flagged) {
   const anchors = flagged.map((message) => `${message.sessionId}:${message.ts}`).sort().join("|");
-  return createHash14("sha256").update(anchors).digest("hex").slice(0, 32);
+  return createHash15("sha256").update(anchors).digest("hex").slice(0, 32);
 }
 function renderFrictionWindow(messages, flaggedOrdinals, radius = 2) {
   const flagged = new Set(flaggedOrdinals);
@@ -38485,9 +39209,9 @@ function hiddenTerminalError(event) {
 }
 
 // src/v2/hooks/lkg-system.ts
-import { createHash as createHash15 } from "node:crypto";
+import { createHash as createHash16 } from "node:crypto";
 function identity2(slot) {
-  return createHash15("sha256").update(JSON.stringify({
+  return createHash16("sha256").update(JSON.stringify({
     capturedAt: slot.capturedAt,
     captureSequence: slot.captureSequence,
     rowVersion: slot.rowVersion,
@@ -38704,16 +39428,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;
@@ -38735,28 +39474,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) {
@@ -40340,14 +41095,14 @@ function datetime(args) {
   const timeRegex = `${time2}(?:${opts.join("|")})`;
   return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
 }
-var string = (params) => {
+var string2 = (params) => {
   const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
   return new RegExp(`^${regex}$`);
 };
 var bigint = /^-?\d+n?$/;
 var integer = /^-?\d+$/;
-var number = /^-?\d+(?:\.\d+)?/;
-var boolean = /^(?:true|false)$/i;
+var number2 = /^-?\d+(?:\.\d+)?/;
+var boolean2 = /^(?:true|false)$/i;
 var _null = /^null$/i;
 var _undefined = /^undefined$/i;
 var lowercase = /^[^A-Z]*$/;
@@ -41073,7 +41828,7 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
 });
 var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
   $ZodType.init(inst, def);
-  inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string(inst._zod.bag);
+  inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string2(inst._zod.bag);
   inst._zod.parse = (payload, _) => {
     if (def.coerce)
       try {
@@ -41387,7 +42142,7 @@ var $ZodCustomStringFormat = /* @__PURE__ */ $constructor("$ZodCustomStringForma
 });
 var $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
   $ZodType.init(inst, def);
-  inst._zod.pattern = inst._zod.bag.pattern ?? number;
+  inst._zod.pattern = inst._zod.bag.pattern ?? number2;
   inst._zod.parse = (payload, _ctx) => {
     if (def.coerce)
       try {
@@ -41414,7 +42169,7 @@ var $ZodNumberFormat = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) =>
 });
 var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
   $ZodType.init(inst, def);
-  inst._zod.pattern = boolean;
+  inst._zod.pattern = boolean2;
   inst._zod.parse = (payload, _ctx) => {
     if (def.coerce)
       try {
@@ -50069,7 +50824,7 @@ var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
   inst.nullable = () => nullable(inst);
   inst.nullish = () => optional(nullable(inst));
   inst.nonoptional = (params) => nonoptional(inst, params);
-  inst.array = () => array(inst);
+  inst.array = () => array2(inst);
   inst.or = (arg) => union([inst, arg]);
   inst.and = (arg) => intersection(inst, arg);
   inst.transform = (tx) => pipe(inst, transform(tx));
@@ -50154,7 +50909,7 @@ var ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => {
   inst.time = (params) => inst.check(time2(params));
   inst.duration = (params) => inst.check(duration2(params));
 });
-function string2(params) {
+function string3(params) {
   return _string(ZodString, params);
 }
 var ZodStringFormat = /* @__PURE__ */ $constructor("ZodStringFormat", (inst, def) => {
@@ -50356,7 +51111,7 @@ var ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
   inst.isFinite = true;
   inst.format = bag.format ?? null;
 });
-function number2(params) {
+function number3(params) {
   return _number(ZodNumber, params);
 }
 var ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def) => {
@@ -50382,7 +51137,7 @@ var ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
   $ZodBoolean.init(inst, def);
   ZodType.init(inst, def);
 });
-function boolean2(params) {
+function boolean3(params) {
   return _boolean(ZodBoolean, params);
 }
 var ZodBigInt = /* @__PURE__ */ $constructor("ZodBigInt", (inst, def) => {
@@ -50490,7 +51245,7 @@ var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
   inst.length = (len, params) => inst.check(_length(len, params));
   inst.unwrap = () => inst.element;
 });
-function array(element, params) {
+function array2(element, params) {
   return _array(ZodArray, element, params);
 }
 function keyof(schema) {
@@ -50519,7 +51274,7 @@ var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
   inst.partial = (...args) => partial(ZodOptional, inst, args[0]);
   inst.required = (...args) => required(ZodNonOptional, inst, args[0]);
 });
-function object2(shape, params) {
+function object3(shape, params) {
   const def = {
     type: "object",
     get shape() {
@@ -50595,7 +51350,7 @@ var ZodTuple = /* @__PURE__ */ $constructor("ZodTuple", (inst, def) => {
     rest
   });
 });
-function tuple(items, _paramsOrRest, _params) {
+function tuple2(items, _paramsOrRest, _params) {
   const hasRest = _paramsOrRest instanceof $ZodType;
   const params = hasRest ? _params : _paramsOrRest;
   const rest = hasRest ? _paramsOrRest : null;
@@ -50724,7 +51479,7 @@ var ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
     }
   });
 });
-function literal(value, params) {
+function literal2(value, params) {
   return new ZodLiteral({
     type: "literal",
     values: Array.isArray(value) ? value : [value],
@@ -50952,7 +51707,7 @@ var ZodFunction = /* @__PURE__ */ $constructor("ZodFunction", (inst, def) => {
 function _function(params) {
   return new ZodFunction({
     type: "function",
-    input: Array.isArray(params?.input) ? tuple(params?.input) : params?.input ?? array(unknown()),
+    input: Array.isArray(params?.input) ? tuple2(params?.input) : params?.input ?? array2(unknown()),
     output: params?.output ?? unknown()
   });
 }
@@ -50996,7 +51751,7 @@ var stringbool = (...args) => _stringbool({
 }, ...args);
 function json2(params) {
   const jsonSchema = lazy(() => {
-    return union([string2(params), number2(), boolean2(), _null3(), array(jsonSchema), record(string2(), jsonSchema)]);
+    return union([string3(params), number3(), boolean3(), _null3(), array2(jsonSchema), record(string3(), jsonSchema)]);
   });
   return jsonSchema;
 }
@@ -51028,13 +51783,13 @@ function getErrorMap() {
 var ZodFirstPartyTypeKind;
 (function(ZodFirstPartyTypeKind) {})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
 // ../../node_modules/.bun/zod@4.1.8/node_modules/zod/v4/classic/coerce.js
-function string3(params) {
+function string4(params) {
   return _coercedString(ZodString, params);
 }
-function number3(params) {
+function number4(params) {
   return _coercedNumber(ZodNumber, params);
 }
-function boolean3(params) {
+function boolean4(params) {
   return _coercedBoolean(ZodBoolean, params);
 }
 function bigint3(params) {
@@ -51967,7 +52722,7 @@ import { existsSync as existsSync9 } from "node:fs";
 import { isAbsolute as isAbsolute2 } from "node:path";
 
 // ../retina-local-fs/src/path-fence.ts
-import { lstat as lstat2, realpath as realpath2 } from "node:fs/promises";
+import { lstat as lstat2, realpath as realpath3 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
 import { basename, dirname as dirname2, isAbsolute, join as join11, relative, resolve as resolve2, sep } from "node:path";
 
@@ -51997,7 +52752,7 @@ async function resolveFenceRoots(options) {
   const configuredHomePath = resolve2(options.homeDirectory ?? process.env.HOME ?? homedir4());
   let home;
   try {
-    home = await realpath2(configuredHomePath);
+    home = await realpath3(configuredHomePath);
   } catch (error) {
     throw fsError(configuredHomePath, error);
   }
@@ -52027,7 +52782,7 @@ function fenceCandidates(canonical, aliases) {
 }
 async function canonicalPath(path, allowMissing) {
   try {
-    return await realpath2(path);
+    return await realpath3(path);
   } catch (error) {
     if (!allowMissing || !isMissingError(error)) {
       throw fsError(path, error);
@@ -52052,7 +52807,7 @@ async function canonicalPath(path, allowMissing) {
       suffix.unshift(basename(candidate));
       candidate = parent;
       try {
-        return join11(await realpath2(candidate), ...suffix);
+        return join11(await realpath3(candidate), ...suffix);
       } catch (parentError) {
         if (!isMissingError(parentError)) {
           throw fsError(path, parentError);
@@ -52742,7 +53497,7 @@ function formatCtxReduceReply(stampedCount, selfStampCount = 0) {
   return parts.join(" ");
 }
 // src/tools/ctx-reduce/tools.ts
-import { createHash as createHash16 } from "node:crypto";
+import { createHash as createHash17 } from "node:crypto";
 
 // src/features/magic-context/range-parser.ts
 function parseRangeString(input) {
@@ -52805,11 +53560,11 @@ function createCtxReduceTool(deps) {
       const stableId = `oc-${sessionId}-${callId}`;
       if (Buffer.byteLength(stableId) <= 128)
         return stableId;
-      return `oc-${createHash16("sha256").update(stableId).digest("hex")}`;
+      return `oc-${createHash17("sha256").update(stableId).digest("hex")}`;
     }
     fallbackCommandSequence += 1;
     const monotonicId = `oc-${sessionId}-${fallbackCommandSequence}`;
-    return Buffer.byteLength(monotonicId) <= 128 ? monotonicId : `oc-${createHash16("sha256").update(monotonicId).digest("hex")}`;
+    return Buffer.byteLength(monotonicId) <= 128 ? monotonicId : `oc-${createHash17("sha256").update(monotonicId).digest("hex")}`;
   };
   return tool({
     description: CTX_REDUCE_DESCRIPTION,
@@ -53452,7 +54207,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);
@@ -53500,7 +54255,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 = [];
@@ -53794,10 +54549,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;
@@ -54276,7 +55031,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;
@@ -54302,6 +55065,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 {
@@ -54483,22 +55247,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))}`);
         }
@@ -54507,7 +55295,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 } };
@@ -54522,6 +55313,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] : []);
@@ -54543,16 +55347,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)
     ];
@@ -54785,6 +55590,7 @@ async function registerContext(context) {
               }
             } else if (localCut)
               return;
+            messages = await retireInstructionMessages(draft.sessionID, reader, messages);
             times = readTimes(reader, messages);
           }
         } finally {
@@ -55014,6 +55820,7 @@ async function registerContext(context) {
             boundaryRepair
           }));
         }
+        draft.messages = await retireInstructionMessages(draft.sessionID, reader, draft.messages);
         messageTimes = readTimes(reader, draft.messages);
       } finally {
         reader.close();
@@ -55194,6 +56001,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);