@cortexkit/opencode-magic-context 0.44.3 → 0.45.0

package/dist/{index-q5p1aqvv.js → index-2aq21j41.js}

@@ -1,23 +1,18 @@
 import {
   getHarness
-} from "./index-s70wtd8k.js";
+} from "./index-q6hef7fh.js";
 import {
   log,
   sessionLog
-} from "./index-3bygzk2d.js";
+} from "./index-hybnrwq0.js";
 import {
-  openCodeDbExists,
-  withReadOnlySessionDb,
-  getMessageTimesFromOpenCodeDb
-} from "./index-4an2p8qa.js";
+  isTransientSqliteError
+} from "./index-a4m2b1yv.js";
 import {
   BoundedSessionMap,
-  resolveWorkspaceShareCategories,
-  resolveWorkspaceIdentitySet,
-  expandWorkspaceIdentitySetWithAliases,
-  resolveStoredPathWorkspaceIdentity,
-  sourceNameForMemory,
+  renderUserFacingFailure,
   loadCompartmentChunkEmbeddingsForSearch,
+  getMaxM0MutationId,
   getIndexedMessageCorpusSize,
   escalationBands,
   MERGED_REASONING_PARTS_PREFIX,
@@ -25,6 +20,9 @@ import {
   HYGIENE_PROVIDER_UNITS_VERSION,
   sessionDecisionCalibration,
   transitionSessionHygieneUnits,
+  ReplayDocumentError,
+  readReplayEnvelope,
+  updateReplayDocument,
   getEmergencyInputSample,
   setEmergencyDropSample,
   clearEmergencyDropSample,
@@ -62,7 +60,6 @@ import {
   replacePendingCompactionMarkerStateIf,
   clearPendingCompactionMarkerStateIf,
   recordEmbeddingMeasurement,
-  getMaxM0MutationId,
   updateSessionMeta,
   advanceToolReclaimWatermark,
   getNotes,
@@ -73,17 +70,15 @@ import {
   saveSourceContent,
   replaceSourceContent,
   getSourceContents,
-  isFable51ThinkingBindingModel,
   cosineSimilarity,
   saveCommitEmbedding,
   loadProjectCommitEmbeddings,
   loadUnembeddedCommits,
   countEmbeddedCommits,
   upsertCommits,
-  getLatestIndexedCommitTimeMs,
+  getLatestIndexedCommitSha,
   enforceProjectCap,
   getProjectEmbeddings,
-  peekProjectEmbeddings,
   contentSha256,
   getShadowEmbeddingMeasurementCohort,
   getPrimaryEmbeddingMeasurementCohort,
@@ -117,12 +112,23 @@ import {
   peekNoteNudgeText,
   markNoteNudgeDelivered,
   getActiveCompartmentRun
-} from "./index-yhm60r53.js";
+} from "./index-16ny736w.js";
 import {
   textMentionsRecentCommit,
   hasMeaningfulUserText2,
-  estimateTokens,
-  stableStringify,
+  estimateTokens
+} from "./index-gd5qx1j9.js";
+import {
+  isValidLanguageCode
+} from "./index-q7yesyk9.js";
+import {
+  resolveWorkspaceShareCategories,
+  resolveWorkspaceIdentitySet,
+  expandWorkspaceIdentitySetWithAliases,
+  resolveStoredPathWorkspaceIdentity,
+  sourceNameForMemory
+} from "./index-fr2z4qy8.js";
+import {
   CTX_REDUCE_KEEP,
   newestCtxReduceTagNumbers,
   stripWellFormedLeadingTagPrefix,
@@ -166,32 +172,120 @@ import {
   getTagsBySession,
   getActiveTagsBySession,
   getTailHygieneTags,
+  getDroppedTagsByNumbers,
   getTagById,
   getToolTagNumberByOwner,
   getNullOwnerToolTag,
   adoptNullOwnerToolTag,
   getCandidateToolOwners,
   pickNearestPriorOwner,
+  stripSystemInjection,
   isTextPart,
   isToolPartWithOutput,
   isFilePart,
   buildFileSourceContent,
+  toolPartHasUserAnswer,
   isEditTool,
+  modelAcceptsEmptyContent,
+  neutralizeDroppedReasoningPart,
+  restoreNeutralizedReasoningPart,
+  isNeutralizedReasoningPart,
+  makeSentinel,
+  makeWholeMessageSentinel,
+  isSentinel,
+  replaySentinelByMessageIds,
   SKELETON_REAL_INPUT_MAX_BYTES,
   partHasCompletedResult,
   extractToolCallObservation,
   ToolMutationBatch,
   createToolDropTarget
-} from "./index-dgg5y7er.js";
+} from "./index-4krbw8z9.js";
 import {
-  canonicalModelIdentity
-} from "./index-9y5p0d50.js";
+  openCodeDbExists,
+  withReadOnlySessionDb,
+  getMessageTimesFromOpenCodeDb
+} from "./index-bmzf7zxv.js";
+import {
+  stableStringify
+} from "./index-anq4nn6f.js";
 import {
   getErrorMessage
-} from "./index-33q7s9y2.js";
+} from "./index-y8v6yerm.js";
 import {
   logSlowWriteTransaction
-} from "./index-kr5qehbd.js";
+} from "./index-x23gah8c.js";
+
+// src/features/magic-context/storage-reasoning-removal.ts
+var NAMESPACE = "reasoningRemoval";
+var BACKUP_NAMESPACE = "reasoningRemovalBackup";
+function invalidState(sessionId) {
+  return new Error(`invalid persisted reasoning removal state for session ${sessionId}`);
+}
+function parseState(doc, sessionId, namespace = NAMESPACE) {
+  const lane = doc[namespace];
+  if (lane === undefined)
+    return { messageIds: new Set, dropLeavesReasoning: false };
+  if (!isRecord(lane) || !Array.isArray(lane.messageIds))
+    throw invalidState(sessionId);
+  const ids = new Set;
+  for (const id of lane.messageIds) {
+    if (typeof id !== "string" || id.length === 0)
+      throw invalidState(sessionId);
+    ids.add(id);
+  }
+  if (lane.dropLeavesReasoning !== undefined && typeof lane.dropLeavesReasoning !== "boolean") {
+    throw invalidState(sessionId);
+  }
+  return { messageIds: ids, dropLeavesReasoning: lane.dropLeavesReasoning === true };
+}
+function writeState(doc, state) {
+  doc.version = 2;
+  const lane = {
+    messageIds: [...state.messageIds],
+    ...state.dropLeavesReasoning ? { dropLeavesReasoning: true } : {}
+  };
+  doc[NAMESPACE] = lane;
+  doc[BACKUP_NAMESPACE] = { ...lane, messageIds: [...lane.messageIds] };
+}
+function getReasoningRemovalState(db, sessionId) {
+  const doc = readReplayEnvelope(db, sessionId);
+  try {
+    return parseState(doc, sessionId);
+  } catch (error) {
+    if (doc[BACKUP_NAMESPACE] === undefined)
+      throw error;
+    return parseState(doc, sessionId, BACKUP_NAMESPACE);
+  }
+}
+function addRemovedReasoningIds(db, sessionId, ids) {
+  const requested = [...ids].filter((id) => typeof id === "string" && id.length > 0);
+  if (requested.length === 0)
+    return true;
+  return updateReplayDocument(db, sessionId, (doc) => {
+    const current = parseState(doc, sessionId);
+    let changed = false;
+    for (const id of requested) {
+      if (current.messageIds.has(id))
+        continue;
+      current.messageIds.add(id);
+      changed = true;
+    }
+    if (!changed)
+      return false;
+    writeState(doc, current);
+    return true;
+  });
+}
+function markDropLeavesReasoning(db, sessionId) {
+  return updateReplayDocument(db, sessionId, (doc) => {
+    const current = parseState(doc, sessionId);
+    if (current.dropLeavesReasoning)
+      return false;
+    current.dropLeavesReasoning = true;
+    writeState(doc, current);
+    return true;
+  });
+}
 
 // src/hooks/magic-context/apply-operations.ts
 var RECENT_TOOL_SKELETON_WINDOW = 20;
@@ -239,8 +333,8 @@ function foldChangesServedPrefix(before, after) {
 function foldBustsServedPrefix(reason, before, after) {
   return CACHE_LOSING_FOLD_REASONS.has(reason ?? "") || foldChangesServedPrefix(before, after);
 }
-function convertLegacyToolSkeletons(db, sessionId, targets) {
-  const rows = db.prepare(`SELECT tag_number AS tagNumber, drop_mode AS dropMode
+function convertLegacyToolSkeletons(db, sessionId, targets, options = {}) {
+  const rows = db.prepare(`SELECT tag_number AS tagNumber, drop_mode AS dropMode, message_id AS callId
                FROM tags
               WHERE session_id = ? AND type = 'tool' AND status = 'dropped'
                 AND drop_mode IN ('truncated', 'full')
@@ -253,6 +347,8 @@ function convertLegacyToolSkeletons(db, sessionId, targets) {
     const cannotRemove = target.cannotRemove?.() === true || target.requiresToolArcSkeleton === true || target.wouldStrandConversationEnd?.() === true;
     let mode;
     if (row.dropMode === "full") {
+      if (options.keepFullDrop?.(row.callId) === true)
+        continue;
       if (target.cannotRemove?.() !== true)
         continue;
       mode = "skeleton_real";
@@ -420,7 +516,7 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
 }
 function applyFlushedStatuses(sessionId, db, targets, preloadedTags) {
   let didMutateMessage = false;
-  const tags = preloadedTags ?? getTagsBySession(db, sessionId);
+  const tags = preloadedTags ?? getDroppedTagsByNumbers(db, sessionId, [...targets.keys()]);
   for (const tag of tags) {
     if (tag.status === "dropped") {
       const target = targets.get(tag.tagNumber);
@@ -472,6 +568,7 @@ var GIT_TIMEOUT_MS = 1e4;
 var DEFAULT_MAX_COMMITS = 5000;
 var RECORD_SEPARATOR = "\x1E";
 var FIELD_SEPARATOR = "\x1F";
+var FULL_OBJECT_NAME = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
 function classifyGitLogFailure(message) {
   if (message.includes("not a git repository"))
     return "not_a_repo";
@@ -486,9 +583,11 @@ async function readGitCommitsResult(directory, options = {}) {
     throw new Error(`readGitCommits: refusing revision that looks like an option: "${revision}"`);
   }
   const projectLabel = options.projectIdentity ?? "<project>";
+  const exclusion = options.excludeReachableFrom && FULL_OBJECT_NAME.test(options.excludeReachableFrom) ? options.excludeReachableFrom : null;
   const args = [
     "log",
     revision,
+    ...exclusion ? [`^${exclusion}`] : [],
     "--no-merges",
     `--max-count=${options.maxCommits ?? DEFAULT_MAX_COMMITS}`,
     `--format=%H${FIELD_SEPARATOR}%s${FIELD_SEPARATOR}%ae${FIELD_SEPARATOR}%ct${FIELD_SEPARATOR}%b${RECORD_SEPARATOR}`
@@ -497,6 +596,7 @@ async function readGitCommitsResult(directory, options = {}) {
     const iso = new Date(options.sinceMs).toISOString();
     args.push(`--since=${iso}`);
   }
+  args.push("--");
   let stdout;
   try {
     const result = await execFileAsync("git", args, {
@@ -509,6 +609,10 @@ async function readGitCommitsResult(directory, options = {}) {
     stdout = result.stdout;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
+    if (exclusion && message.includes("bad object")) {
+      log(`[git-commits] indexed tip ${exclusion.slice(0, 7)} is missing for ${projectLabel}; reading the full window`);
+      return readGitCommitsResult(directory, { ...options, excludeReachableFrom: undefined });
+    }
     const failure = classifyGitLogFailure(message);
     if (failure === "transient") {
       log(`[git-commits] readGitCommits failed for ${projectLabel}: ${message.slice(0, 500)}`);
@@ -546,7 +650,7 @@ function parseGitLogOutput(stdout) {
     const author = fields[2].trim();
     const timeSec = Number.parseInt(fields[3].trim(), 10);
     const body = fields[4].trim();
-    if (sha.length !== 40 || !Number.isFinite(timeSec) || timeSec <= 0) {
+    if (!FULL_OBJECT_NAME.test(sha) || !Number.isFinite(timeSec) || timeSec <= 0) {
       continue;
     }
     const message = body.length > 0 ? `${subject}
@@ -584,12 +688,13 @@ async function indexCommitsForProject(db, projectPath, directory, options) {
   }
   indexInProgress.add(projectPath);
   try {
-    const latestIndexed = getLatestIndexedCommitTimeMs(db, projectPath);
-    const sinceMs = latestIndexed !== null ? Math.max(latestIndexed - 60000, Date.now() - options.sinceDays * MS_PER_DAY) : Date.now() - options.sinceDays * MS_PER_DAY;
+    const latestIndexed = getLatestIndexedCommitSha(db, projectPath);
+    const sinceMs = Date.now() - options.sinceDays * MS_PER_DAY;
     const read = await readGitCommitsResult(directory, {
       sinceMs,
       maxCommits: options.maxCommits,
-      projectIdentity: projectPath
+      projectIdentity: projectPath,
+      excludeReachableFrom: latestIndexed ?? undefined
     });
     const commits = read.commits;
     result.scanned = commits.length;
@@ -599,10 +704,10 @@ async function indexCommitsForProject(db, projectPath, directory, options) {
     }
     if (commits.length === 0) {
       result.evicted = enforceProjectCap(db, projectPath, options.maxCommits);
-      log(`[git-commits] no new commits for ${projectPath} (sinceMs=${sinceMs} latestIndexed=${latestIndexed ?? "none"} evicted=${result.evicted})`);
+      log(`[git-commits] no new commits for ${projectPath} (sinceMs=${sinceMs} latestIndexed=${latestIndexed?.slice(0, 7) ?? "none"} evicted=${result.evicted})`);
       return result;
     }
-    log(`[git-commits] read ${commits.length} commits for ${projectPath} (sinceMs=${sinceMs} latestIndexed=${latestIndexed ?? "none"})`);
+    log(`[git-commits] read ${commits.length} commits for ${projectPath} (sinceMs=${sinceMs} latestIndexed=${latestIndexed?.slice(0, 7) ?? "none"})`);
     const upsert = upsertCommits(db, projectPath, commits);
     result.inserted = upsert.inserted;
     result.updated = upsert.updated;
@@ -709,6 +814,9 @@ function getFtsStatement(db, dated = false) {
   }
   return stmt;
 }
+function escapeLikePattern(text) {
+  return text.replace(/[\\%_]/g, (char) => `\\${char}`);
+}
 function getLikeFallbackStatement(db, dated = false) {
   const statements = dated ? datedFtsPlainStatements : ftsPlainStatements;
   let stmt = statements.get(db);
@@ -717,7 +825,7 @@ function getLikeFallbackStatement(db, dated = false) {
              FROM git_commits
              WHERE project_path = ?
                ${dated ? "AND committed_at BETWEEN ? AND ?" : ""}
-               AND lower(message) LIKE '%' || lower(?) || '%'
+               AND lower(message) LIKE '%' || lower(?) || '%' ESCAPE '\\'
              ORDER BY committed_at DESC LIMIT ?`);
     statements.set(db, stmt);
   }
@@ -764,7 +872,7 @@ function searchGitCommitsSync(db, projectPath, query, options) {
     }
   }
   if (ftsCandidates.length === 0) {
-    for (const row of getLikeFallbackStatement(db, dated).all(projectPath, ...dated ? [from, to] : [], trimmed, fetchLimit)) {
+    for (const row of getLikeFallbackStatement(db, dated).all(projectPath, ...dated ? [from, to] : [], escapeLikePattern(trimmed), fetchLimit)) {
       ftsCandidates.push(rowToCommit(row));
     }
   }
@@ -874,6 +982,61 @@ function containsProbeVerbatim(text, probes) {
   return probes.some((probe) => haystack.includes(probe.toLowerCase()));
 }
 
+// src/features/magic-context/message-fts-session-filter.ts
+var MESSAGE_FTS_SESSION_FILTER_SQL = `+message_history_fts.rowid IN (
+    SELECT fts_rowid FROM message_fts_rowid_map WHERE session_id = ?1
+) AND `;
+var coverageCaches = new WeakMap;
+function getCoverageCache(db) {
+  let cache = coverageCaches.get(db);
+  if (!cache) {
+    cache = {
+      pin: db.prepare("SELECT fts_rowid FROM message_fts_rowid_map LIMIT 1"),
+      stamp: db.prepare("SELECT total_changes() AS changes, data_version AS version FROM pragma_data_version"),
+      missing: db.prepare(`SELECT DISTINCT session_id AS sessionId
+                FROM message_history_fts WHERE rowid IN (
+                    SELECT id FROM message_history_fts_docsize
+                    EXCEPT SELECT fts_rowid FROM message_fts_rowid_map
+                )`)
+    };
+    coverageCaches.set(db, cache);
+  }
+  return cache;
+}
+function withMessageFtsSessionFilter(db, sessionId, read) {
+  let cacheable = false;
+  try {
+    const transaction = db;
+    cacheable = transaction.inTransaction === false || transaction.isTransaction === false;
+    if (!cacheable)
+      coverageCaches.delete(db);
+  } catch {
+    coverageCaches.delete(db);
+  }
+  return db.transaction(() => {
+    let sessionFirst = false;
+    try {
+      const cache = getCoverageCache(db);
+      cache.pin.get();
+      const stamp = cache.stamp.get();
+      let incomplete = cache.incompleteSessions;
+      if (!cacheable || !incomplete || cache.version !== stamp.version || cache.changes !== stamp.changes) {
+        const rows = cache.missing.all();
+        incomplete = new Set(rows.map((row) => row.sessionId));
+        if (cacheable) {
+          cache.version = stamp.version;
+          cache.changes = stamp.changes;
+          cache.incompleteSessions = incomplete;
+        }
+      }
+      sessionFirst = !incomplete.has(sessionId);
+    } catch {
+      coverageCaches.delete(db);
+    }
+    return read(sessionFirst);
+  }).deferred();
+}
+
 // src/features/magic-context/search-measurement.ts
 import { createHash } from "node:crypto";
 function resultId(result) {
@@ -967,6 +1130,7 @@ function sha256(value) {
 
 // src/features/magic-context/search.ts
 var DEFAULT_UNIFIED_SEARCH_LIMIT = 10;
+var MAX_UNIFIED_SEARCH_LIMIT = 25;
 var FTS_SEMANTIC_CANDIDATE_LIMIT = 50;
 var SEMANTIC_WEIGHT = 0.7;
 var FTS_WEIGHT = 0.3;
@@ -977,9 +1141,12 @@ var MESSAGE_SOURCE_BOOST = 1.275;
 var GIT_COMMIT_SOURCE_BOOST = 1.2;
 var PRIMER_SOURCE_BOOST = 1.25;
 var messageSearchStatements = new WeakMap;
+var sessionFirstMessageSearchStatements = new WeakMap;
 var messageSearchStatementsWithCutoff = new WeakMap;
+var sessionFirstMessageSearchStatementsWithCutoff = new WeakMap;
 var messageSearchStatementsWithDateRange = new WeakMap;
 var messageSearchDiagnosticStatements = new WeakMap;
+var sessionFirstMessageSearchDiagnosticStatements = new WeakMap;
 var messageSearchDiagnosticStatementsWithDateRange = new WeakMap;
 var batchedMessageSearchStatements = new WeakMap;
 var batchedFtsCountStatements = new WeakMap;
@@ -994,7 +1161,7 @@ function normalizeLimit(limit) {
   if (typeof limit !== "number" || !Number.isFinite(limit)) {
     return DEFAULT_UNIFIED_SEARCH_LIMIT;
   }
-  return Math.max(1, Math.floor(limit));
+  return Math.min(MAX_UNIFIED_SEARCH_LIMIT, Math.max(1, Math.floor(limit)));
 }
 function normalizeDateRange(from, to) {
   if (from === undefined && to === undefined)
@@ -1075,19 +1242,21 @@ function sourceNamesForSearchMemories(args) {
   }
   return sourceNames.size > 0 ? sourceNames : undefined;
 }
-function getMessageSearchStatement(db) {
-  let stmt = messageSearchStatements.get(db);
+function getMessageSearchStatement(db, sessionFirst) {
+  const statements = sessionFirst ? sessionFirstMessageSearchStatements : messageSearchStatements;
+  let stmt = statements.get(db);
   if (!stmt) {
-    stmt = db.prepare("SELECT message_ordinal AS messageOrdinal, message_id AS messageId, role, content FROM message_history_fts WHERE session_id = ? AND message_history_fts MATCH ? ORDER BY bm25(message_history_fts), CAST(message_ordinal AS INTEGER) ASC LIMIT ?");
-    messageSearchStatements.set(db, stmt);
+    stmt = db.prepare(`SELECT message_ordinal AS messageOrdinal, message_id AS messageId, role, content FROM message_history_fts WHERE ${sessionFirst ? MESSAGE_FTS_SESSION_FILTER_SQL : ""}session_id = ?1 AND message_history_fts MATCH ? ORDER BY bm25(message_history_fts), CAST(message_ordinal AS INTEGER) ASC LIMIT ?`);
+    statements.set(db, stmt);
   }
   return stmt;
 }
-function getMessageSearchStatementWithCutoff(db) {
-  let stmt = messageSearchStatementsWithCutoff.get(db);
+function getMessageSearchStatementWithCutoff(db, sessionFirst) {
+  const statements = sessionFirst ? sessionFirstMessageSearchStatementsWithCutoff : messageSearchStatementsWithCutoff;
+  let stmt = statements.get(db);
   if (!stmt) {
-    stmt = db.prepare("SELECT message_ordinal AS messageOrdinal, message_id AS messageId, role, content FROM message_history_fts WHERE session_id = ? AND message_history_fts MATCH ? AND CAST(message_ordinal AS INTEGER) <= ? ORDER BY bm25(message_history_fts), CAST(message_ordinal AS INTEGER) ASC LIMIT ?");
-    messageSearchStatementsWithCutoff.set(db, stmt);
+    stmt = db.prepare(`SELECT message_ordinal AS messageOrdinal, message_id AS messageId, role, content FROM message_history_fts WHERE ${sessionFirst ? MESSAGE_FTS_SESSION_FILTER_SQL : ""}session_id = ?1 AND message_history_fts MATCH ? AND CAST(message_ordinal AS INTEGER) <= ? ORDER BY bm25(message_history_fts), CAST(message_ordinal AS INTEGER) ASC LIMIT ?`);
+    statements.set(db, stmt);
   }
   return stmt;
 }
@@ -1108,9 +1277,9 @@ function getMessageSearchStatementWithDateRange(db, withCutoff) {
                JOIN message_fts_rowid_map AS map
                  ON map.session_id = message_history_fts.session_id
                 AND map.fts_rowid = message_history_fts.rowid
-              WHERE message_history_fts.session_id = ?
-                AND message_history_fts MATCH ?
-                AND map.message_time_ms BETWEEN ? AND ?
+              WHERE ${MESSAGE_FTS_SESSION_FILTER_SQL}message_history_fts.session_id = ?1
+                 AND message_history_fts MATCH ?
+                 AND map.message_time_ms BETWEEN ? AND ?
                 ${withCutoff ? "AND CAST(message_history_fts.message_ordinal AS INTEGER) <= ?" : ""}
               ORDER BY bm25(message_history_fts),
                        CAST(message_history_fts.message_ordinal AS INTEGER) ASC
@@ -1119,8 +1288,9 @@ function getMessageSearchStatementWithDateRange(db, withCutoff) {
   }
   return statement;
 }
-function getMessageSearchDiagnosticStatement(db) {
-  let stmt = messageSearchDiagnosticStatements.get(db);
+function getMessageSearchDiagnosticStatement(db, sessionFirst) {
+  const statements = sessionFirst ? sessionFirstMessageSearchDiagnosticStatements : messageSearchDiagnosticStatements;
+  let stmt = statements.get(db);
   if (!stmt) {
     stmt = db.prepare(`
             WITH matches AS MATERIALIZED (
@@ -1132,7 +1302,7 @@ function getMessageSearchDiagnosticStatement(db) {
                     CAST(message_ordinal AS INTEGER) AS ordinalValue,
                     bm25(message_history_fts) AS ftsRank
                 FROM message_history_fts
-                WHERE session_id = ? AND message_history_fts MATCH ?
+                WHERE ${sessionFirst ? MESSAGE_FTS_SESSION_FILTER_SQL : ""}session_id = ?1 AND message_history_fts MATCH ?
             ),
             eligible AS (
                 SELECT * FROM matches
@@ -1160,7 +1330,7 @@ function getMessageSearchDiagnosticStatement(db) {
             WHERE NOT EXISTS (SELECT 1 FROM eligible)
             ORDER BY summaryOnly ASC, ftsRank ASC, messageOrdinal ASC
         `);
-    messageSearchDiagnosticStatements.set(db, stmt);
+    statements.set(db, stmt);
   }
   return stmt;
 }
@@ -1180,9 +1350,9 @@ function getMessageSearchDiagnosticStatementWithDateRange(db) {
                 JOIN message_fts_rowid_map AS map
                   ON map.session_id = message_history_fts.session_id
                  AND map.fts_rowid = message_history_fts.rowid
-                WHERE message_history_fts.session_id = ?
-                  AND message_history_fts MATCH ?
-                  AND map.message_time_ms BETWEEN ? AND ?
+                WHERE ${MESSAGE_FTS_SESSION_FILTER_SQL}message_history_fts.session_id = ?1
+                   AND message_history_fts MATCH ?
+                   AND map.message_time_ms BETWEEN ? AND ?
             ),
             eligible AS (
                 SELECT * FROM matches
@@ -1214,13 +1384,13 @@ function getMessageSearchDiagnosticStatementWithDateRange(db) {
   }
   return statement;
 }
-function getBatchedFtsCountStatement(db, queryCount, cutoff, dateRange) {
+function getBatchedFtsCountStatement(db, queryCount, cutoff, dateRange, sessionFirst) {
   let statements = batchedFtsCountStatements.get(db);
   if (!statements) {
     statements = new Map;
     batchedFtsCountStatements.set(db, statements);
   }
-  const key = `${queryCount}:${cutoff === null ? "all" : "cutoff"}:${dateRange === null ? "all-dates" : "dated"}`;
+  const key = `${queryCount}:${cutoff === null ? "all" : "cutoff"}:${dateRange === null ? "all-dates" : "dated"}:${sessionFirst}`;
   let statement = statements.get(key);
   if (!statement) {
     const cutoffSql = cutoff === null ? "" : " AND CAST(message_history_fts.message_ordinal AS INTEGER) <= ?";
@@ -1230,27 +1400,30 @@ function getBatchedFtsCountStatement(db, queryCount, cutoff, dateRange) {
     const dateSql = dateRange === null ? "" : " AND map.message_time_ms BETWEEN ? AND ?";
     statement = db.prepare(Array.from({ length: queryCount }, (_, index) => `SELECT ${index} AS queryIndex, COUNT(*) AS count
                        FROM message_history_fts${joinSql}
-                      WHERE message_history_fts.session_id = ?
-                        AND message_history_fts MATCH ?${dateSql}${cutoffSql}`).join(`
+                      WHERE ${sessionFirst || dateRange !== null ? MESSAGE_FTS_SESSION_FILTER_SQL : ""}message_history_fts.session_id = ${index === 0 ? "?1" : "?"}
+                         AND message_history_fts MATCH ?${dateSql}${cutoffSql}`).join(`
 UNION ALL
 `));
     statements.set(key, statement);
   }
   return statement;
 }
-function countSessionFtsMatchesBatch(db, sessionId, ftsQueries, cutoff, dateRange) {
+function contentOnlyMessageQuery(ftsQuery) {
+  return ftsQuery.length === 0 ? "" : `content : (${ftsQuery})`;
+}
+function countSessionFtsMatchesBatch(db, sessionId, ftsQueries, cutoff, dateRange, sessionFirst) {
   if (ftsQueries.length === 0)
     return [];
   const bindings = [];
   for (const query of ftsQueries) {
-    bindings.push(sessionId, query);
+    bindings.push(sessionId, contentOnlyMessageQuery(query));
     if (dateRange !== null)
       bindings.push(dateRange.from, dateRange.to);
     if (cutoff !== null)
       bindings.push(cutoff);
   }
   try {
-    const rows = getBatchedFtsCountStatement(db, ftsQueries.length, cutoff, dateRange).all(...bindings);
+    const rows = getBatchedFtsCountStatement(db, ftsQueries.length, cutoff, dateRange, sessionFirst).all(...bindings);
     const counts = Array.from({ length: ftsQueries.length }, () => 0);
     for (const row of rows) {
       if (typeof row.queryIndex === "number" && row.queryIndex >= 0 && row.queryIndex < counts.length && typeof row.count === "number") {
@@ -1347,10 +1520,8 @@ function selectSemanticCandidates(args) {
   if (args.queryModelId && args.queryModelId !== "off") {
     const embeddingProjects = args.workspace?.isWorkspaced ? args.workspace.identities : [args.projectPath];
     for (const projectPath of embeddingProjects) {
-      const cachedEmbeddings = peekProjectEmbeddings(projectPath, args.queryModelId);
-      if (!cachedEmbeddings)
-        continue;
-      for (const memoryId of cachedEmbeddings.keys()) {
+      const storedEmbeddings = getProjectEmbeddings(args.db, projectPath, args.queryModelId);
+      for (const memoryId of storedEmbeddings.keys()) {
         candidateIds.add(memoryId);
       }
     }
@@ -1427,6 +1598,7 @@ async function searchMemories(args) {
   });
   const ftsScores = getFtsScores(ftsMatches);
   const semanticCandidates = selectSemanticCandidates({
+    db: args.db,
     memories,
     projectPath: args.projectPath,
     ftsMatches,
@@ -1481,18 +1653,19 @@ function normalizeMessageSearchRow(row, cutoff) {
     content: row.content
   };
 }
-function runMessageFtsQuery(db, sessionId, ftsQuery, fetchLimit, cutoff, dateRange) {
+function runMessageFtsQuery(db, sessionId, ftsQuery, fetchLimit, cutoff, dateRange, sessionFirst) {
   if (ftsQuery.length === 0)
     return [];
   let rawRows;
+  const matchQuery = contentOnlyMessageQuery(ftsQuery);
   if (dateRange !== null) {
-    const bindings = [sessionId, ftsQuery, dateRange.from, dateRange.to];
+    const bindings = [sessionId, matchQuery, dateRange.from, dateRange.to];
     if (cutoff !== null)
       bindings.push(cutoff);
     bindings.push(fetchLimit);
     rawRows = getMessageSearchStatementWithDateRange(db, cutoff !== null).all(...bindings);
   } else {
-    rawRows = cutoff !== null ? getMessageSearchStatementWithCutoff(db).all(sessionId, ftsQuery, cutoff, fetchLimit) : getMessageSearchStatement(db).all(sessionId, ftsQuery, fetchLimit);
+    rawRows = cutoff !== null ? getMessageSearchStatementWithCutoff(db, sessionFirst).all(sessionId, matchQuery, cutoff, fetchLimit) : getMessageSearchStatement(db, sessionFirst).all(sessionId, matchQuery, fetchLimit);
   }
   const rows = rawRows.map((row) => row);
   const result = [];
@@ -1506,7 +1679,8 @@ function runMessageFtsQuery(db, sessionId, ftsQuery, fetchLimit, cutoff, dateRan
 function runMessageFtsQueryWithDiagnostics(args) {
   if (args.ftsQuery.length === 0)
     return { rows: [], suppressedCount: 0 };
-  const rawRows = (args.dateRange === null ? getMessageSearchDiagnosticStatement(args.db).all(args.sessionId, args.ftsQuery, args.cutoff, args.fetchLimit, args.cutoff) : getMessageSearchDiagnosticStatementWithDateRange(args.db).all(args.sessionId, args.ftsQuery, args.dateRange.from, args.dateRange.to, args.cutoff, args.fetchLimit, args.cutoff)).map((row) => row);
+  const matchQuery = contentOnlyMessageQuery(args.ftsQuery);
+  const rawRows = (args.dateRange === null ? getMessageSearchDiagnosticStatement(args.db, args.sessionFirst).all(args.sessionId, matchQuery, args.cutoff, args.fetchLimit, args.cutoff) : getMessageSearchDiagnosticStatementWithDateRange(args.db).all(args.sessionId, matchQuery, args.dateRange.from, args.dateRange.to, args.cutoff, args.fetchLimit, args.cutoff)).map((row) => row);
   const suppressedCount = rawRows[0]?.suppressedCount ?? 0;
   const rows = [];
   for (const row of rawRows) {
@@ -1518,13 +1692,13 @@ function runMessageFtsQueryWithDiagnostics(args) {
   }
   return { rows, suppressedCount };
 }
-function getBatchedMessageSearchStatement(db, queryCount, cutoff, dateRange) {
+function getBatchedMessageSearchStatement(db, queryCount, cutoff, dateRange, sessionFirst) {
   let statements = batchedMessageSearchStatements.get(db);
   if (!statements) {
     statements = new Map;
     batchedMessageSearchStatements.set(db, statements);
   }
-  const key = `${queryCount}:${cutoff === null ? "all" : "cutoff"}:${dateRange === null ? "all-dates" : "dated"}`;
+  const key = `${queryCount}:${cutoff === null ? "all" : "cutoff"}:${dateRange === null ? "all-dates" : "dated"}:${sessionFirst}`;
   let statement = statements.get(key);
   if (!statement) {
     const cutoffSql = cutoff === null ? "" : " AND CAST(message_history_fts.message_ordinal AS INTEGER) <= ?";
@@ -1540,8 +1714,8 @@ function getBatchedMessageSearchStatement(db, queryCount, cutoff, dateRange) {
                        message_history_fts.content AS content,
                        bm25(message_history_fts) AS ftsRank
                   FROM message_history_fts${joinSql}
-                 WHERE message_history_fts.session_id = ?
-                   AND message_history_fts MATCH ?${dateSql}${cutoffSql}
+                 WHERE ${sessionFirst || dateRange !== null ? MESSAGE_FTS_SESSION_FILTER_SQL : ""}message_history_fts.session_id = ${index === 0 ? "?1" : "?"}
+                    AND message_history_fts MATCH ?${dateSql}${cutoffSql}
                  ORDER BY ftsRank
                  LIMIT ?
             )`);
@@ -1553,19 +1727,19 @@ ORDER BY queryIndex ASC, ftsRank ASC`);
   }
   return statement;
 }
-function runMessageFtsQueriesBatch(db, sessionId, ftsQueries, fetchLimit, cutoff, dateRange) {
+function runMessageFtsQueriesBatch(db, sessionId, ftsQueries, fetchLimit, cutoff, dateRange, sessionFirst) {
   if (ftsQueries.length === 0)
     return [];
   const bindings = [];
   for (const query of ftsQueries) {
-    bindings.push(sessionId, query);
+    bindings.push(sessionId, contentOnlyMessageQuery(query));
     if (dateRange !== null)
       bindings.push(dateRange.from, dateRange.to);
     if (cutoff !== null)
       bindings.push(cutoff);
     bindings.push(fetchLimit);
   }
-  const rows = getBatchedMessageSearchStatement(db, ftsQueries.length, cutoff, dateRange).all(...bindings);
+  const rows = getBatchedMessageSearchStatement(db, ftsQueries.length, cutoff, dateRange, sessionFirst).all(...bindings);
   const result = Array.from({ length: ftsQueries.length }, () => []);
   for (const row of rows) {
     if (typeof row.queryIndex !== "number" || row.queryIndex < 0 || row.queryIndex >= result.length) {
@@ -1586,6 +1760,9 @@ function probeDiscriminationWeight(df, corpusSize) {
   return 1 / (1 + IDF_FALLOFF * df / corpusSize);
 }
 function searchMessages(args) {
+  return withMessageFtsSessionFilter(args.db, args.sessionId, (sessionFirst) => searchMessagesInSnapshot(args, sessionFirst));
+}
+function searchMessagesInSnapshot(args, sessionFirst) {
   const cutoff = args.maxOrdinal != null && args.maxOrdinal >= 0 ? args.maxOrdinal : null;
   const fetchLimit = args.maxOrdinal != null && args.maxOrdinal >= 0 ? args.limit * 3 : args.limit;
   const baseQuery = sanitizeFtsQuery(args.query.trim());
@@ -1597,15 +1774,16 @@ function searchMessages(args) {
       ftsQuery: baseQuery,
       fetchLimit,
       cutoff,
-      dateRange: args.dateRange
+      dateRange: args.dateRange,
+      sessionFirst
     }) : {
-      rows: runMessageFtsQuery(args.db, args.sessionId, baseQuery, fetchLimit, cutoff, args.dateRange),
+      rows: runMessageFtsQuery(args.db, args.sessionId, baseQuery, fetchLimit, cutoff, args.dateRange, sessionFirst),
       suppressedCount: 0
     };
     if (args.diagnostics) {
       args.diagnostics.suppressedLiveMessageMatches = outcome.suppressedCount;
     }
-    const rows = outcome.rows.length > 0 || !args.relaxedRecall ? outcome.rows : runMessageFtsQuery(args.db, args.sessionId, relaxedFtsQuery(args.query), fetchLimit, cutoff, args.dateRange);
+    const rows = outcome.rows.length > 0 || !args.relaxedRecall ? outcome.rows : runMessageFtsQuery(args.db, args.sessionId, relaxedFtsQuery(args.query), fetchLimit, cutoff, args.dateRange, sessionFirst);
     const filtered = rows.slice(0, args.limit);
     return filtered.map((row, rank) => ({
       source: "message",
@@ -1618,7 +1796,7 @@ function searchMessages(args) {
   }
   const sanitizedProbes = probes.map((probe) => ({ probe, query: sanitizeFtsQuery(probe) })).filter((entry) => entry.query.length > 0);
   const corpusSize = getIndexedMessageCorpusSize(args.db, args.sessionId, cutoff);
-  const probeCounts = countSessionFtsMatchesBatch(args.db, args.sessionId, sanitizedProbes.map((entry) => entry.query), cutoff, args.dateRange);
+  const probeCounts = countSessionFtsMatchesBatch(args.db, args.sessionId, sanitizedProbes.map((entry) => entry.query), cutoff, args.dateRange, sessionFirst);
   const collectBaseDiagnostics = args.diagnostics !== undefined && cutoff !== null;
   const baseOutcome = collectBaseDiagnostics && baseQuery.length > 0 ? runMessageFtsQueryWithDiagnostics({
     db: args.db,
@@ -1626,7 +1804,8 @@ function searchMessages(args) {
     ftsQuery: baseQuery,
     fetchLimit,
     cutoff,
-    dateRange: args.dateRange
+    dateRange: args.dateRange,
+    sessionFirst
   }) : null;
   if (args.diagnostics) {
     args.diagnostics.suppressedLiveMessageMatches = baseOutcome?.suppressedCount ?? 0;
@@ -1635,7 +1814,7 @@ function searchMessages(args) {
     ...!collectBaseDiagnostics && baseQuery.length > 0 ? [baseQuery] : [],
     ...sanitizedProbes.map((entry) => entry.query)
   ];
-  const rowsByQuery = runMessageFtsQueriesBatch(args.db, args.sessionId, searchQueries, fetchLimit, cutoff, args.dateRange);
+  const rowsByQuery = runMessageFtsQueriesBatch(args.db, args.sessionId, searchQueries, fetchLimit, cutoff, args.dateRange, sessionFirst);
   const queryLists = [];
   let queryIndex = 0;
   if (baseQuery.length > 0) {
@@ -2077,7 +2256,7 @@ function resolveMemoriesByIdsForSearch(args) {
 async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
   const trimmedQuery = query.trim();
   const measurementStartedAt = Date.now();
-  if (trimmedQuery.length === 0) {
+  if (trimmedQuery.length === 0 || options.signal?.aborted) {
     return [];
   }
   const limit = normalizeLimit(options.limit);
@@ -2109,6 +2288,8 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
     return null;
   }) : Promise.resolve(null);
   await Promise.resolve();
+  if (options.signal?.aborted)
+    return [];
   const messageProbes = options.explicitSearch ? extractLiteralProbes(trimmedQuery) : [];
   const messageResults = runMessages ? searchMessages({
     db,
@@ -2122,6 +2303,8 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
     dateRange
   }) : [];
   const capturedQuery = await queryEmbeddingPromise;
+  if (options.signal?.aborted)
+    return [];
   const embeddingSnapshot = getProjectEmbeddingSnapshot(projectPath);
   const queryContract = capturedQuery instanceof Float32Array || capturedQuery === null ? null : capturedQuery;
   const generationIsCurrent = queryContract === null || embeddingSnapshot !== null && embeddingSnapshot.generation === queryContract.generation;
@@ -2348,34 +2531,169 @@ ${bodyParts.join(`
 `)}`;
 }
 
+// src/hooks/magic-context/auto-search-deadline.ts
+var AUTO_SEARCH_TIMEOUT_MS = 3000;
+async function withAutoSearchDeadline(operation, startedAt = performance.now()) {
+  const deadline = startedAt + AUTO_SEARCH_TIMEOUT_MS;
+  const remaining = deadline - performance.now();
+  if (remaining <= 0)
+    return null;
+  const controller = new AbortController;
+  const checkDeadline = () => {
+    if (!controller.signal.aborted && performance.now() >= deadline)
+      controller.abort();
+    return controller.signal.aborted;
+  };
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      resolve(null);
+      controller.abort();
+    }, remaining);
+  });
+  try {
+    return await Promise.race([
+      Promise.resolve().then(() => operation(controller.signal, checkDeadline)).then((result) => {
+        if (checkDeadline()) {
+          return null;
+        }
+        return result;
+      }),
+      timeout
+    ]);
+  } finally {
+    if (timer !== undefined)
+      clearTimeout(timer);
+  }
+}
+
 // src/hooks/magic-context/caveman.ts
-var PRESERVATION_PATTERNS = [
+var PRESERVATION_PATTERNS_BEFORE_PATHS = [
   /```[\s\S]*?```/g,
   /`[^`\n]+`/g,
   /https?:\/\/\S+/g,
-  /§\d+§/g,
-  /\b(?:msg|ses|toolu)_[A-Za-z0-9]+/g,
-  /(?:\.{1,2}\/)?(?:[\w.-]+\/)+[\w.-]+\.\w{1,6}/g,
-  /(?<![a-z0-9])[0-9a-f]{7,40}(?![a-z0-9])/gi
+  /§\d+§/g
 ];
-function protectRegions(text) {
+var ASCII_IDENTIFIER_PATTERN = /\b(?:msg|ses|toolu)_[A-Za-z0-9]+/g;
+var COMMIT_HASH_PATTERN = /(?<![a-z0-9])[0-9a-f]{7,40}(?![a-z0-9])/gi;
+var PLACEHOLDER_OPEN = "\x00MC_PRES_";
+function isPathSegmentCode(code) {
+  return isAsciiWordCode(code) || code === 46 || code === 45;
+}
+function isAsciiWordCode(code) {
+  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 95;
+}
+function fileNameTailEnd(text, start, end) {
+  for (let dot = end - 2;dot > start; dot -= 1) {
+    if (text.charCodeAt(dot) !== 46 || !isAsciiWordCode(text.charCodeAt(dot + 1)))
+      continue;
+    let tailEnd = dot + 1;
+    while (tailEnd < end && tailEnd - dot <= 6 && isAsciiWordCode(text.charCodeAt(tailEnd))) {
+      tailEnd += 1;
+    }
+    return tailEnd;
+  }
+  return -1;
+}
+function findFilePathMatches(text) {
+  const matches = [];
+  const length = text.length;
+  let position = 0;
+  while (position < length) {
+    if (!isPathSegmentCode(text.charCodeAt(position))) {
+      position += 1;
+      continue;
+    }
+    const segments = [];
+    let segmentStart = position;
+    for (;; ) {
+      let segmentEnd = segmentStart;
+      while (segmentEnd < length && isPathSegmentCode(text.charCodeAt(segmentEnd))) {
+        segmentEnd += 1;
+      }
+      segments.push([segmentStart, segmentEnd]);
+      if (segmentEnd + 1 < length && text.charCodeAt(segmentEnd) === 47 && isPathSegmentCode(text.charCodeAt(segmentEnd + 1))) {
+        segmentStart = segmentEnd + 1;
+        continue;
+      }
+      break;
+    }
+    for (let index = segments.length - 1;index >= 1; index -= 1) {
+      const tailEnd = fileNameTailEnd(text, segments[index][0], segments[index][1]);
+      if (tailEnd >= 0) {
+        matches.push([position, tailEnd]);
+        break;
+      }
+    }
+    position = segments[segments.length - 1][1];
+  }
+  return matches;
+}
+function protectRegions(text, identifierPattern) {
   const preserved = [];
+  const placeholderFor = (original) => {
+    const placeholder = `\x00MC_PRES_${preserved.length}\x00`;
+    preserved.push({ placeholder, original });
+    return placeholder;
+  };
   let working = text;
-  for (const pattern of PRESERVATION_PATTERNS) {
-    working = working.replace(pattern, (match) => {
-      const placeholder = `\x00MC_PRES_${preserved.length}\x00`;
-      preserved.push({ placeholder, original: match });
-      return placeholder;
-    });
+  for (const pattern of PRESERVATION_PATTERNS_BEFORE_PATHS) {
+    working = working.replace(pattern, (match) => placeholderFor(match));
   }
+  working = working.replace(identifierPattern, (match) => placeholderFor(match));
+  const pathMatches = findFilePathMatches(working);
+  if (pathMatches.length > 0) {
+    let rebuilt = "";
+    let cursor = 0;
+    for (const [start, end] of pathMatches) {
+      rebuilt += working.slice(cursor, start) + placeholderFor(working.slice(start, end));
+      cursor = end;
+    }
+    working = rebuilt + working.slice(cursor);
+  }
+  working = working.replace(COMMIT_HASH_PATTERN, (match) => placeholderFor(match));
   return { text: working, preserved };
 }
-function restoreRegions(text, preserved) {
-  let working = text;
-  for (let i = preserved.length - 1;i >= 0; i--) {
-    working = working.split(preserved[i].placeholder).join(preserved[i].original);
+function restoreRegions(text, preserved, sourceHasNul) {
+  if (preserved.length === 0)
+    return text;
+  if (sourceHasNul) {
+    let working = text;
+    for (let i = preserved.length - 1;i >= 0; i--) {
+      working = working.split(preserved[i].placeholder).join(preserved[i].original);
+    }
+    return working;
   }
-  return working;
+  const expanded = new Map;
+  const expand = (value) => {
+    let output = "";
+    let cursor = 0;
+    for (;; ) {
+      const start = value.indexOf(PLACEHOLDER_OPEN, cursor);
+      if (start < 0)
+        break;
+      let end = start + PLACEHOLDER_OPEN.length;
+      while (end < value.length && value.charCodeAt(end) >= 48 && value.charCodeAt(end) <= 57) {
+        end += 1;
+      }
+      const regionIndex = Number(value.slice(start + PLACEHOLDER_OPEN.length, end));
+      const region = preserved[regionIndex];
+      if (end === start + PLACEHOLDER_OPEN.length || value.charCodeAt(end) !== 0 || !region) {
+        output += value.slice(cursor, start + 1);
+        cursor = start + 1;
+        continue;
+      }
+      let restored = expanded.get(regionIndex);
+      if (restored === undefined) {
+        restored = expand(region.original);
+        expanded.set(regionIndex, restored);
+      }
+      output += value.slice(cursor, start) + restored;
+      cursor = end + 1;
+    }
+    return output + value.slice(cursor);
+  };
+  return expand(text);
 }
 var FILLER_WORDS = [
   "just",
@@ -2472,7 +2790,7 @@ var ULTRA_ABBREVIATIONS = {
 };
 function buildPhraseDropRegex(phrases) {
   const escaped = phrases.map((p) => p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
-  return new RegExp(`(\\s+)?\\b(?:${escaped.join("|")})\\b`, "gi");
+  return new RegExp(`(?:(?<!\\s)\\s+)?\\b(?:${escaped.join("|")})\\b`, "gi");
 }
 function dropPhrases(text, phrases) {
   return text.replace(buildPhraseDropRegex(phrases), "");
@@ -2485,7 +2803,7 @@ function dropArticles(text) {
 function dropAuxiliaries(text) {
   const sorted = [...AUXILIARIES].sort((a, b) => b.length - a.length);
   const escaped = sorted.map((a) => a.replace(/\s+/g, "\\s+"));
-  const pattern = new RegExp(`\\s+\\b(?:${escaped.join("|")})\\b\\s+(?=\\w+(?:ed|en|ing|ized|ised)\\b)`, "gi");
+  const pattern = new RegExp(`(?<!\\s)\\s+\\b(?:${escaped.join("|")})\\b\\s+(?=\\w+(?:ed|en|ing|ized|ised)\\b)`, "gi");
   let working = text.replace(pattern, " ");
   working = working.replace(/ +/g, " ");
   return working;
@@ -2553,10 +2871,125 @@ function normalizeWhitespace(text) {
 
 `);
 }
-function cavemanCompress(text, level) {
+var WORD_CHARS = "\\p{L}\\p{M}\\p{N}_";
+var NOT_AFTER_WORD = `(?<![${WORD_CHARS}])`;
+var NOT_BEFORE_WORD = `(?![${WORD_CHARS}])`;
+var HORIZONTAL_SPACE = "[^\\S\\n]";
+function escapeRegex(literal) {
+  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function asciiCaseInsensitive(literal, separator) {
+  let pattern = "";
+  for (const ch of literal) {
+    if (separator !== undefined && ch === " ")
+      pattern += separator;
+    else if (/[a-z]/i.test(ch))
+      pattern += `[${ch.toLowerCase()}${ch.toUpperCase()}]`;
+    else
+      pattern += escapeRegex(ch);
+  }
+  return pattern;
+}
+function unicodeWordPattern(words, separator) {
+  const alternation = words.map((word) => asciiCaseInsensitive(word, separator)).join("|");
+  return `${NOT_AFTER_WORD}(?:${alternation})${NOT_BEFORE_WORD}`;
+}
+var UNICODE_IDENTIFIER_PATTERN = new RegExp(`${NOT_AFTER_WORD}(?:msg|ses|toolu)_[A-Za-z0-9]+`, "gu");
+function buildUnicodePhraseDropRegex(phrases) {
+  const phrase = unicodeWordPattern(phrases);
+  return new RegExp(`(?<=^|\\n)(${HORIZONTAL_SPACE}*)(?:${phrase}${HORIZONTAL_SPACE}*)+` + `|(?<!${HORIZONTAL_SPACE})${HORIZONTAL_SPACE}+${phrase}` + `|${phrase}`, "gu");
+}
+var UNICODE_FILLER_DROP = buildUnicodePhraseDropRegex(FILLER_WORDS);
+var UNICODE_HEDGING_DROP = buildUnicodePhraseDropRegex(HEDGING_PHRASES);
+var UNICODE_PLEASANTRY_DROP = buildUnicodePhraseDropRegex(PLEASANTRIES);
+function dropPhrasesUnicode(text, pattern) {
+  return text.replace(pattern, (_match, indentation) => indentation ?? "");
+}
+var UNICODE_ARTICLE_DROP = new RegExp(`${unicodeWordPattern(["the", "a", "an"])}${HORIZONTAL_SPACE}+`, "gu");
+function dropArticlesUnicode(text) {
+  return text.replace(UNICODE_ARTICLE_DROP, "").replace(/ +/g, " ");
+}
+var UNICODE_AUXILIARY_DROP = new RegExp(`(?<!${HORIZONTAL_SPACE})${HORIZONTAL_SPACE}+` + unicodeWordPattern([...AUXILIARIES].sort((a, b) => b.length - a.length), `${HORIZONTAL_SPACE}+`) + `${HORIZONTAL_SPACE}+(?=[${WORD_CHARS}]+(?:${["ed", "en", "ing", "ized", "ised"].map((suffix) => asciiCaseInsensitive(suffix)).join("|")})${NOT_BEFORE_WORD})`, "gu");
+function dropAuxiliariesUnicode(text) {
+  return text.replace(UNICODE_AUXILIARY_DROP, " ").replace(/ +/g, " ");
+}
+var UNICODE_PHRASE_SHORTENINGS = [
+  ["in order to", "to"],
+  ["due to the fact that", "because"],
+  ["at this point in time", "now"],
+  ["at the moment", "now"],
+  ["in the event that", "if"],
+  ["for the purpose of", "for"],
+  ["with regard to", "about"],
+  ["in spite of the fact that", "though"],
+  ["on the grounds that", "because"],
+  ["for the reason that", "because"]
+].map(([phrase, replacement]) => [new RegExp(unicodeWordPattern([phrase]), "gu"), replacement]);
+var UNICODE_ULTRA_CONNECTIVES = [
+  [new RegExp(unicodeWordPattern(["and then", "then after", "afterwards"]), "gu"), "→"],
+  [new RegExp(unicodeWordPattern(["because of"]), "gu"), "//"],
+  [new RegExp(unicodeWordPattern(["therefore"]), "gu"), "→"],
+  [new RegExp(unicodeWordPattern(["because"]), "gu"), "//"],
+  [new RegExp(unicodeWordPattern(["however"]), "gu"), "but"],
+  [new RegExp(unicodeWordPattern(["furthermore"]), "gu"), "+"],
+  [new RegExp(unicodeWordPattern(["additionally"]), "gu"), "+"],
+  [new RegExp(unicodeWordPattern(["as well as"]), "gu"), "+"],
+  [new RegExp(` ${asciiCaseInsensitive("and")} `, "gu"), " + "],
+  [new RegExp(` ${asciiCaseInsensitive("or")} `, "gu"), " | "]
+];
+var UNICODE_ULTRA_ABBREVIATIONS = Object.entries(ULTRA_ABBREVIATIONS).map(([term, abbreviation]) => [new RegExp(unicodeWordPattern([term]), "gu"), abbreviation]);
+function applyReplacements(text, replacements) {
+  let working = text;
+  for (const [pattern, replacement] of replacements) {
+    working = working.replace(pattern, replacement);
+  }
+  return working;
+}
+function applyUltraAbbreviationsUnicode(text) {
+  let working = text;
+  for (const [pattern, abbreviation] of UNICODE_ULTRA_ABBREVIATIONS) {
+    if ((working.match(pattern)?.length ?? 0) < 3)
+      continue;
+    working = working.replace(pattern, (match) => match[0] === match[0].toUpperCase() ? abbreviation[0].toUpperCase() + abbreviation.slice(1) : abbreviation);
+  }
+  return working;
+}
+var CURRENT_CAVEMAN_RULES = "unicode-v2";
+function cavemanWordRulesForLanguage(language) {
+  const code = typeof language === "string" ? language.trim().toLowerCase() : "";
+  if (code === "en" || code.startsWith("en-"))
+    return "english";
+  return isValidLanguageCode(code) ? "none" : "english";
+}
+function cavemanCompress(text, level, rules = CURRENT_CAVEMAN_RULES, wordRules = "english") {
   if (text.length === 0)
     return text;
-  const { text: protectedText, preserved } = protectRegions(text);
+  if (rules === "ascii-v1")
+    return cavemanCompressAsciiV1(text, level);
+  const { text: protectedText, preserved } = protectRegions(text, UNICODE_IDENTIFIER_PATTERN);
+  const transformed = transformPreservingUserLines(protectedText, (chunk) => {
+    let working = chunk;
+    if (wordRules === "none")
+      return working;
+    working = dropPhrasesUnicode(working, UNICODE_FILLER_DROP);
+    working = dropPhrasesUnicode(working, UNICODE_HEDGING_DROP);
+    working = dropPhrasesUnicode(working, UNICODE_PLEASANTRY_DROP);
+    working = applyReplacements(working, UNICODE_PHRASE_SHORTENINGS);
+    if (level === "full" || level === "ultra") {
+      working = dropAuxiliariesUnicode(working);
+      working = dropArticlesUnicode(working);
+    }
+    if (level === "ultra") {
+      working = applyReplacements(working, UNICODE_ULTRA_CONNECTIVES);
+      working = applyUltraAbbreviationsUnicode(working);
+    }
+    return working;
+  });
+  const normalized = normalizeWhitespace(transformed).trim();
+  return restoreRegions(normalized, preserved, text.includes("\x00"));
+}
+function cavemanCompressAsciiV1(text, level) {
+  const { text: protectedText, preserved } = protectRegions(text, ASCII_IDENTIFIER_PATTERN);
   const transformed = transformPreservingUserLines(protectedText, (chunk) => {
     let working = chunk;
     working = dropPhrases(working, FILLER_WORDS);
@@ -2573,7 +3006,7 @@ function cavemanCompress(text, level) {
     }
     return working;
   });
-  const restored = restoreRegions(transformed, preserved);
+  const restored = restoreRegions(transformed, preserved, text.includes("\x00"));
   return normalizeWhitespace(restored).trim();
 }
 
@@ -2607,10 +3040,10 @@ function formatAge(committedAtMs) {
   const years = Math.floor(days / 365);
   return years === 1 ? "1y ago" : `${years}y ago`;
 }
-function renderFragment(result, charCap) {
+function renderFragment(result, charCap, wordRules) {
   switch (result.source) {
     case "memory": {
-      const compressed = cavemanCompress(result.content, "ultra");
+      const compressed = cavemanCompress(result.content, "ultra", CURRENT_CAVEMAN_RULES, wordRules);
       return truncate(compressed, charCap);
     }
     case "git_commit": {
@@ -2619,20 +3052,20 @@ function renderFragment(result, charCap) {
       return `commit ${result.shortSha} ${formatAge(result.committedAtMs)}: ${body}`;
     }
     case "message": {
-      const compressed = cavemanCompress(result.content, "ultra");
+      const compressed = cavemanCompress(result.content, "ultra", CURRENT_CAVEMAN_RULES, wordRules);
       return truncate(compressed, charCap);
     }
     case "compartment": {
       const source = result.snippet ?? result.title;
-      const compressed = cavemanCompress(source, "ultra");
+      const compressed = cavemanCompress(source, "ultra", CURRENT_CAVEMAN_RULES, wordRules);
       return truncate(compressed, charCap);
     }
     case "primer": {
-      const compressed = cavemanCompress(result.content, "ultra");
+      const compressed = cavemanCompress(result.content, "ultra", CURRENT_CAVEMAN_RULES, wordRules);
       return truncate(compressed, charCap);
     }
     case "note": {
-      const compressed = cavemanCompress(result.content, "ultra");
+      const compressed = cavemanCompress(result.content, "ultra", CURRENT_CAVEMAN_RULES, wordRules);
       return truncate(compressed, charCap);
     }
   }
@@ -2643,7 +3076,7 @@ function buildAutoSearchHint(results, options = {}) {
   const picks = results.slice(0, maxFragments);
   const lines = [];
   for (const result of picks) {
-    const fragment = renderFragment(result, fragmentCharCap);
+    const fragment = renderFragment(result, fragmentCharCap, options.wordRules ?? "english");
     if (fragment.length === 0)
       continue;
     lines.push(`- ${fragment}`);
@@ -2762,30 +3195,6 @@ function appendReminderToUserMessage(message, reminder) {
 }
 
 // src/hooks/magic-context/auto-search-runner.ts
-var AUTO_SEARCH_TIMEOUT_MS = 3000;
-async function unifiedSearchWithTimeout(db, sessionId, projectPath, prompt, options, timeoutMs) {
-  const controller = new AbortController;
-  let timer;
-  const timeoutPromise = new Promise((resolve) => {
-    timer = setTimeout(() => {
-      controller.abort();
-      resolve(null);
-    }, timeoutMs);
-  });
-  try {
-    return await Promise.race([
-      unifiedSearch(db, sessionId, projectPath, prompt, {
-        ...options,
-        signal: controller.signal,
-        countRetrievals: false
-      }),
-      timeoutPromise
-    ]);
-  } finally {
-    if (timer !== undefined)
-      clearTimeout(timer);
-  }
-}
 var AUTO_SEARCH_OK = { ok: true };
 function collectUserPromptParts(message) {
   let collected = "";
@@ -2846,6 +3255,7 @@ function findLatestMeaningfulUserMessage(messages) {
   return null;
 }
 async function runAutoSearchHint(args) {
+  const startedAt = performance.now();
   const { sessionId, db, messages, options } = args;
   if (!options.enabled)
     return AUTO_SEARCH_OK;
@@ -2888,27 +3298,36 @@ async function runAutoSearchHint(args) {
   }
   let results;
   try {
-    if (options.directory) {
-      await options.ensureProjectRegistered?.(options.directory, db);
-    }
-    const embeddingSnapshot = getProjectEmbeddingSnapshot(options.projectPath);
-    const memoryEnabled = embeddingSnapshot?.features.memoryEnabled ?? options.memoryEnabled;
-    const embeddingEnabled = embeddingSnapshot ? embeddingSnapshot.historyEnabled : options.embeddingEnabled;
-    const gitCommitsEnabled = embeddingSnapshot?.gitCommitEnabled ?? options.gitCommitsEnabled ?? false;
-    const searchOptions = {
-      limit: 10,
-      memoryEnabled,
-      embeddingEnabled,
-      gitCommitsEnabled,
-      embedQuery: async (text, signal) => {
-        const result = await embedTextForProject(options.projectPath, text, signal, "query");
-        return result;
-      },
-      isEmbeddingRuntimeEnabled: () => embeddingEnabled === true,
-      visibleMemoryIds: options.visibleMemoryIds ?? null,
-      sources: ["memory", "message", "git_commit"]
-    };
-    results = await unifiedSearchWithTimeout(db, sessionId, options.projectPath, rawPrompt, searchOptions, AUTO_SEARCH_TIMEOUT_MS);
+    results = await withAutoSearchDeadline(async (signal, checkDeadline) => {
+      if (options.directory) {
+        await options.ensureProjectRegistered?.(options.directory, db);
+      }
+      if (checkDeadline())
+        return null;
+      const embeddingSnapshot = getProjectEmbeddingSnapshot(options.projectPath);
+      const memoryEnabled = embeddingSnapshot?.features.memoryEnabled ?? options.memoryEnabled;
+      const embeddingEnabled = embeddingSnapshot ? embeddingSnapshot.historyEnabled : options.embeddingEnabled;
+      const gitCommitsEnabled = embeddingSnapshot?.gitCommitEnabled ?? options.gitCommitsEnabled ?? false;
+      const searchOptions = {
+        limit: 10,
+        memoryEnabled,
+        embeddingEnabled,
+        gitCommitsEnabled,
+        embedQuery: async (text, signal) => {
+          const result = await embedTextForProject(options.projectPath, text, signal, "query");
+          checkDeadline();
+          return result;
+        },
+        isEmbeddingRuntimeEnabled: () => embeddingEnabled === true,
+        visibleMemoryIds: options.visibleMemoryIds ?? null,
+        sources: ["memory", "message", "git_commit"]
+      };
+      return unifiedSearch(db, sessionId, options.projectPath, rawPrompt, {
+        ...searchOptions,
+        signal,
+        countRetrievals: false
+      });
+    }, startedAt);
   } catch (error) {
     log(`[auto-search] unified search failed for session ${sessionId} (will retry next pass): ${error instanceof Error ? error.message : String(error)}`);
     return { ok: false, kind: "search-failure" };
@@ -2924,7 +3343,7 @@ async function runAutoSearchHint(args) {
     sessionLog(sessionId, `auto-search: top score ${results[0].score.toFixed(3)} below threshold ${options.scoreThreshold}`);
     return writeNoHintAndReconcile("below-threshold");
   }
-  const hintText = buildAutoSearchHint(results);
+  const hintText = buildAutoSearchHint(results, { wordRules: options.wordRules });
   if (!hintText) {
     return writeNoHintAndReconcile("empty");
   }
@@ -3244,90 +3663,29 @@ function resolveTodowriteAvailability(sessionId) {
   return resolveToolAvailability(sessionId, TODOWRITE_TOOL);
 }
 
-// src/hooks/magic-context/sentinel.ts
-var WHOLE_MESSAGE_PLACEHOLDER_TEXT = "[dropped]";
-function modelAcceptsEmptyContent(providerID) {
-  return providerID === "anthropic";
-}
-var VARIANT_CACHE_PRESERVING_MODELS = {
-  "anthropic/claude-fable-5-1": "2026-09-02",
-  "openai/gpt-6-astra": "2026-09-05",
-  "anthropic/claude-opus-5-5": "2026-09-23"
-};
-function canonicalVariantModelIdentity(providerID, modelID) {
-  const normalizedProviderID = providerID.toLowerCase();
-  const isAnthropicFamily = normalizedProviderID === "anthropic" || normalizedProviderID === "google-vertex-anthropic" || normalizedProviderID.includes("bedrock");
-  if (isAnthropicFamily && isFable51ThinkingBindingModel("anthropic", modelID)) {
-    return "anthropic/claude-fable-5-1";
-  }
-  return canonicalModelIdentity(`${providerID}/${modelID}`).toLowerCase();
-}
-function variantChangeBustsProviderCache(providerID, modelID) {
-  if (!providerID || !modelID)
-    return false;
-  const identity = canonicalVariantModelIdentity(providerID, modelID);
-  if (Object.hasOwn(VARIANT_CACHE_PRESERVING_MODELS, identity))
-    return false;
-  const normalizedProviderID = providerID.toLowerCase();
-  return normalizedProviderID === "anthropic" || normalizedProviderID === "google-vertex-anthropic" || normalizedProviderID.includes("bedrock");
-}
-function makeSentinel(originalPart) {
-  const sentinel = {
-    type: "text",
-    text: ""
-  };
-  if (isRecord(originalPart)) {
-    if (originalPart.cache_control !== undefined) {
-      sentinel.cache_control = originalPart.cache_control;
-    }
-    if (originalPart.cacheControl !== undefined) {
-      sentinel.cacheControl = originalPart.cacheControl;
-    }
+// src/hooks/magic-context/degraded-pass-refusal.ts
+class DegradedPassRefusalError extends Error {
+  site;
+  code = "DEGRADED_PASS_REFUSAL";
+  recoverable = true;
+  estimatedTokens;
+  contextLimitTokens;
+  constructor(site, options) {
+    super(renderUserFacingFailure("transform_pass_degraded", "plain"), {
+      cause: options?.cause
+    });
+    this.site = site;
+    this.name = "DegradedPassRefusalError";
+    this.estimatedTokens = options?.estimatedTokens;
+    this.contextLimitTokens = options?.contextLimitTokens;
   }
-  return sentinel;
 }
-function makeWholeMessageSentinel(providerID) {
-  return {
-    type: "text",
-    text: modelAcceptsEmptyContent(providerID) ? "" : WHOLE_MESSAGE_PLACEHOLDER_TEXT
-  };
-}
-function isSentinel(part) {
-  if (!isRecord(part))
-    return false;
-  if (part.type !== "text")
-    return false;
-  if (typeof part.text !== "string")
-    return false;
-  return part.text === "" || part.text === WHOLE_MESSAGE_PLACEHOLDER_TEXT;
-}
-function replaySentinelByMessageIds(messages, ids, providerID, hiddenSeamIds = new Set) {
-  if (ids.size === 0)
-    return { replayed: 0, missingIds: [] };
-  const seen = new Set;
-  let replayed = 0;
-  for (let index = messages.length - 1;index >= 0; index -= 1) {
-    const msg = messages[index];
-    const id = msg.info.id;
-    if (!id || !ids.has(id))
-      continue;
-    seen.add(id);
-    if (!modelAcceptsEmptyContent(providerID) && hiddenSeamIds.has(id)) {
-      messages.splice(index, 1);
-      replayed += 1;
-      continue;
-    }
-    if (msg.parts.length === 1 && isSentinel(msg.parts[0]))
-      continue;
-    msg.parts.length = 0;
-    msg.parts.push(makeWholeMessageSentinel(providerID));
-    replayed += 1;
-  }
-  const missingIds = [];
-  for (const id of ids)
-    if (!seen.has(id))
-      missingIds.push(id);
-  return { replayed, missingIds };
+function degradedPassError(site, error) {
+  if (error instanceof DegradedPassRefusalError)
+    return error;
+  if (isTransientSqliteError(error) && error instanceof Error)
+    return error;
+  return new DegradedPassRefusalError(site, { cause: error });
 }
 
 // src/hooks/magic-context/drop-stale-reduce-calls.ts
@@ -3394,7 +3752,7 @@ function dropStaleReduceCalls(messages, frozenIds, options = {}) {
     const message = messages[i];
     const id = typeof message.info.id === "string" ? message.info.id : undefined;
     const inFrozen = id !== undefined && frozenIds.has(id);
-    const isNewDetection = !inFrozen && detect && i < protectedStart && id !== undefined && messageHasReducePart(message);
+    const isNewDetection = !inFrozen && detect && i < protectedStart && id !== undefined && messageHasReducePart(message) && !message.parts.some(toolPartHasUserAnswer);
     if (!inFrozen && !isNewDetection)
       continue;
     const touched = sentinelizeReduceParts(message);
@@ -3474,11 +3832,69 @@ function estimateDroppedTokensFromTagReductions(db, sessionId, reductions) {
   return Math.max(0, Math.round(total));
 }
 
+// src/hooks/magic-context/emergency-fail-closed.ts
+var ENGINE_RECONNECTING_USER_MESSAGE = "Magic Context's engine is reconnecting. Send your message again in a few seconds.";
+
+class EmergencyFailClosedError extends Error {
+  code = "EMERGENCY_FAIL_CLOSED";
+  constructor(message, options) {
+    super(message, options);
+    this.name = "EmergencyFailClosedError";
+  }
+}
+
 // src/hooks/magic-context/fold-execution-gate.ts
 function foldExecutesThisPass(foldDue, materialized) {
   return foldDue && materialized;
 }
 
+// src/features/magic-context/storage-caveman-rules.ts
+var NAMESPACE2 = "caveman";
+var CURRENT_RULES_VERSION = 2;
+var ORIGINAL_RULES = {
+  currentRules: false,
+  englishWordRules: true,
+  legacyReasoningTags: new Set
+};
+function parseState2(lane) {
+  if (!isRecord(lane) || lane.rules !== CURRENT_RULES_VERSION)
+    return ORIGINAL_RULES;
+  const tags = Array.isArray(lane.legacyReasoningTags) ? lane.legacyReasoningTags : [];
+  return {
+    currentRules: true,
+    englishWordRules: lane.englishWordRules !== false,
+    legacyReasoningTags: new Set(tags.filter((tag) => Number.isSafeInteger(tag) && tag > 0))
+  };
+}
+function getCavemanReplayState(db, sessionId) {
+  try {
+    return parseState2(readReplayEnvelope(db, sessionId)[NAMESPACE2]);
+  } catch (error) {
+    if (error instanceof ReplayDocumentError)
+      return ORIGINAL_RULES;
+    throw error;
+  }
+}
+function recordCavemanCurrentRules(db, sessionId, englishWordRules, legacyReasoningTags) {
+  const tags = [...new Set(legacyReasoningTags)].sort((a, b) => a - b);
+  const persisted = updateReplayDocument(db, sessionId, (doc) => {
+    const current = parseState2(doc[NAMESPACE2]);
+    if (current.currentRules && current.englishWordRules === englishWordRules)
+      return false;
+    doc.version = 2;
+    doc[NAMESPACE2] = {
+      rules: CURRENT_RULES_VERSION,
+      legacyReasoningTags: current.currentRules ? [...current.legacyReasoningTags].sort((a, b) => a - b) : tags,
+      ...englishWordRules ? {} : { englishWordRules: false }
+    };
+    return true;
+  });
+  if (!persisted)
+    return null;
+  const state = getCavemanReplayState(db, sessionId);
+  return state.currentRules && state.englishWordRules === englishWordRules ? state : null;
+}
+
 // src/hooks/magic-context/caveman-cleanup.ts
 var DEPTH_UNTOUCHED = 0;
 var DEPTH_LITE = 1;
@@ -3511,10 +3927,16 @@ function applyCavemanCleanup(sessionId, db, targets, tags, config) {
   };
   if (!config.enabled)
     return result;
+  const recordRewrite = (tagNumber, target, before) => {
+    result.mutatedTextTags += 1;
+    const after = target.getContent?.() ?? "";
+    result.textReductions.push({
+      tagNumber,
+      removedCharacters: Math.max(0, (before?.length ?? 0) - after.length)
+    });
+  };
   const protectedCutoff = config.protectedCutoff;
   const eligible = tags.filter((tag) => tag.type === "message" && tag.status === "active" && (protectedCutoff === null || tag.tagNumber < protectedCutoff) && tag.byteSize >= config.minChars).sort((a, b) => a.tagNumber - b.tagNumber);
-  if (eligible.length === 0)
-    return result;
   const tagsNeedingCompression = eligible.filter((tag, index) => {
     const target = targets.get(tag.tagNumber);
     if (!target?.getContent || !target.setContent)
@@ -3522,7 +3944,31 @@ function applyCavemanCleanup(sessionId, db, targets, tags, config) {
     const targetDepth = computeTargetDepth(index, eligible.length);
     return targetDepth > tag.cavemanDepth;
   });
-  if (tagsNeedingCompression.length === 0)
+  const englishWordRules = (config.wordRules ?? "english") === "english";
+  let state = getCavemanReplayState(db, sessionId);
+  if (!state.currentRules || state.englishWordRules !== englishWordRules) {
+    const compressedBefore = tags.filter((tag) => tag.type === "message" && tag.status === "active" && tag.cavemanDepth > 0);
+    const switched = recordCavemanCurrentRules(db, sessionId, englishWordRules, compressedBefore.map((tag) => tag.tagNumber));
+    if (switched) {
+      state = switched;
+      const deepened = new Set(tagsNeedingCompression.map((tag) => tag.tagNumber));
+      const rewrites = compressedBefore.filter((tag) => targets.has(tag.tagNumber) && !deepened.has(tag.tagNumber));
+      const originals = getSourceContents(db, sessionId, rewrites.map((tag) => tag.tagNumber));
+      for (const tag of rewrites) {
+        const target = targets.get(tag.tagNumber);
+        const originalText = originals.get(tag.tagNumber);
+        if (!target || typeof originalText !== "string" || originalText.length === 0) {
+          continue;
+        }
+        const before = target.getContent?.() ?? null;
+        if (applyCompressedText(target, tag.tagNumber, originalText, tag.cavemanDepth, state)) {
+          recordRewrite(tag.tagNumber, target, before);
+        }
+      }
+      sessionLog(sessionId, `caveman cleanup: switched to current rules (${englishWordRules ? "English" : "language-neutral"} word rules), rewrote ${rewrites.length} compressed text tags`);
+    }
+  }
+  if (eligible.length === 0 || tagsNeedingCompression.length === 0)
     return result;
   const originalByTag = getSourceContents(db, sessionId, tagsNeedingCompression.map((t) => t.tagNumber));
   const positionByTag = new Map;
@@ -3541,20 +3987,15 @@ function applyCavemanCleanup(sessionId, db, targets, tags, config) {
       const level = DEPTH_TO_LEVEL[targetDepth];
       if (!level)
         continue;
-      const compressed = cavemanCompress(originalText, level);
-      if (compressed.length === 0)
+      if (cavemanCompress(originalText, level, rulesFor(state), wordRulesFor(state)).length === 0) {
         continue;
+      }
       const target = targets.get(tag.tagNumber);
       if (!target)
         continue;
-      const priorContent = target.getContent?.();
-      const didMutate = target.setContent(compressed);
-      if (didMutate) {
-        result.mutatedTextTags += 1;
-        result.textReductions.push({
-          tagNumber: tag.tagNumber,
-          removedCharacters: Math.max(0, (priorContent?.length ?? originalText.length) - compressed.length)
-        });
+      const priorContent = target.getContent?.() ?? originalText;
+      if (applyCompressedText(target, tag.tagNumber, originalText, targetDepth, state)) {
+        recordRewrite(tag.tagNumber, target, priorContent);
       }
       updateCavemanDepth(db, sessionId, tag.tagNumber, targetDepth);
       if (targetDepth === DEPTH_LITE)
@@ -3571,79 +4012,62 @@ function applyCavemanCleanup(sessionId, db, targets, tags, config) {
   }
   return result;
 }
+function rulesFor(state) {
+  return state.currentRules ? CURRENT_CAVEMAN_RULES : "ascii-v1";
+}
+function wordRulesFor(state) {
+  return state.englishWordRules ? "english" : "none";
+}
+function applyCompressedText(target, tagNumber, originalText, depth, state) {
+  const level = DEPTH_TO_LEVEL[depth];
+  if (!level)
+    return false;
+  const before = target.getContent?.();
+  if (!state.currentRules || state.legacyReasoningTags.has(tagNumber)) {
+    const legacy = cavemanCompress(originalText, level, "ascii-v1");
+    if (!state.currentRules)
+      return legacy.length > 0 && target.setContent(legacy);
+    if (legacy.length > 0)
+      target.setContent(legacy);
+  }
+  const compressed = cavemanCompress(originalText, level, CURRENT_CAVEMAN_RULES, wordRulesFor(state));
+  if (compressed.length === 0)
+    return false;
+  target.setContent(`${target.textPrefix ?? ""}${compressed}`, { keepReasoning: true });
+  return target.getContent ? target.getContent() !== before : true;
+}
 function replayCavemanCompression(sessionId, db, targets, tags) {
   const compressedTags = tags.filter((tag) => tag.type === "message" && tag.status === "active" && tag.cavemanDepth > 0 && targets.has(tag.tagNumber));
   if (compressedTags.length === 0)
     return 0;
   const originalByTag = getSourceContents(db, sessionId, compressedTags.map((t) => t.tagNumber));
+  const state = getCavemanReplayState(db, sessionId);
   let replayed = 0;
   for (const tag of compressedTags) {
     const originalText = originalByTag.get(tag.tagNumber);
     if (typeof originalText !== "string" || originalText.length === 0)
       continue;
-    const level = DEPTH_TO_LEVEL[tag.cavemanDepth];
-    if (!level)
-      continue;
-    const compressed = cavemanCompress(originalText, level);
-    if (compressed.length === 0)
-      continue;
     const target = targets.get(tag.tagNumber);
     if (!target)
       continue;
-    if (target.setContent(compressed)) {
+    if (applyCompressedText(target, tag.tagNumber, originalText, tag.cavemanDepth, state)) {
       replayed += 1;
     }
   }
   return replayed;
 }
 
-// src/hooks/magic-context/system-injection-stripper.ts
-var SYSTEM_INJECTION_MARKERS = [
-  "<!-- OMO_INTERNAL_INITIATOR -->",
-  "[SYSTEM DIRECTIVE: MAGIC-CONTEXT",
-  "[SYSTEM DIRECTIVE: OH-MY-OPENCODE",
-  "[Category+Skill Reminder]",
-  "[EDIT ERROR - IMMEDIATE ACTION REQUIRED]",
-  "[task CALL FAILED - IMMEDIATE RETRY REQUIRED]",
-  "[EMERGENCY CONTEXT WINDOW WARNING]",
-  "Unstable background agent appears idle",
-  "**THE SUBAGENT JUST CLAIMED THIS TASK IS DONE."
-];
-var SYSTEM_REMINDER_REGEX = /<system-reminder>[\s\S]*?<\/system-reminder>/gi;
-var OMO_MARKER_REGEX = /<!-- OMO_INTERNAL_INITIATOR -->/g;
-function stripSystemInjection(text) {
-  let hasInjection = false;
-  for (const marker of SYSTEM_INJECTION_MARKERS) {
-    if (text.includes(marker)) {
-      hasInjection = true;
-      break;
-    }
-  }
-  if (SYSTEM_REMINDER_REGEX.test(text))
-    hasInjection = true;
-  SYSTEM_REMINDER_REGEX.lastIndex = 0;
-  if (!hasInjection)
-    return null;
-  let cleaned = text;
-  cleaned = cleaned.replace(SYSTEM_REMINDER_REGEX, "");
-  cleaned = cleaned.replace(OMO_MARKER_REGEX, "");
-  cleaned = cleaned.replace(/\[SYSTEM DIRECTIVE: OH-MY-(?:OPENCODE|CLAUDE)[^\]]*\][\s\S]*?(?=\n\n(?!\s*[-*])|$)/g, "");
-  for (const marker of SYSTEM_INJECTION_MARKERS) {
-    if (marker.startsWith("<!-- ") || marker.startsWith("[SYSTEM DIRECTIVE"))
-      continue;
-    const idx = cleaned.indexOf(marker);
-    if (idx === -1)
-      continue;
-    const blockEnd = cleaned.indexOf(`
-
-`, idx + marker.length);
-    cleaned = blockEnd !== -1 ? cleaned.slice(0, idx) + cleaned.slice(blockEnd) : cleaned.slice(0, idx);
-  }
-  return cleaned.trim();
-}
-
 // src/hooks/magic-context/heuristic-cleanup.ts
 var DEDUP_SAFE_TOOLS = new Set([
+  "grep",
+  "read",
+  "glob",
+  "ast_grep_search",
+  "lsp_diagnostics",
+  "lsp_symbols",
+  "lsp_find_references",
+  "lsp_goto_definition",
+  "lsp_prepare_rename",
   "mcp_grep",
   "mcp_read",
   "mcp_glob",
@@ -3684,7 +4108,8 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
       ceilingTokens: emergency.ceilingTokens,
       usagePercentage: emergency.usagePercentage,
       priorInputSample,
-      hasPriorDrop: priorInputSample > 0
+      hasPriorDrop: priorInputSample > 0,
+      passAlreadyPriced: emergency.passAlreadyPriced === true
     });
     if (plan.shouldDrop) {
       const toDrop = new Set(plan.tagNumbers);
@@ -3759,7 +4184,7 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
             }
           }
         } else {
-          const didSet = target.setContent(stripped);
+          const didSet = target.setContent(stripped, { keepReasoning: true });
           if (didSet) {
             replaceSourceContent(db, sessionId, tag.tagNumber, strippedSource);
             droppedInjections++;
@@ -3786,7 +4211,7 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
     const fingerprintGroups = new Map;
     for (const [compositeKey, fingerprint] of toolFingerprints) {
       const tag = tagsByCompositeKey.get(compositeKey);
-      if (!tag || config.protectedTagNumbers.has(tag.tagNumber))
+      if (!tag)
         continue;
       const group = fingerprintGroups.get(fingerprint) ?? [];
       group.push(tag);
@@ -3799,7 +4224,11 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
         group.sort((a, b) => a.tagNumber - b.tagNumber);
         for (let i = 0;i < group.length - 1; i++) {
           const tag = group[i];
+          if (config.protectedTagNumbers.has(tag.tagNumber))
+            continue;
           const target = targets.get(tag.tagNumber);
+          if (target?.canDrop?.() === false)
+            continue;
           const { result, mode } = applyNewToolDrop(target, { inWindow: false });
           if (result === "incomplete")
             continue;
@@ -3825,6 +4254,7 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
     const cavemanResult = applyCavemanCleanup(sessionId, db, targets, tags, {
       enabled: true,
       minChars: config.caveman.minChars,
+      wordRules: config.caveman.wordRules,
       protectedCutoff: config.protectedCutoff
     });
     compressedTextTags = cavemanResult.compressedToLite + cavemanResult.compressedToFull + cavemanResult.compressedToUltra;
@@ -4139,6 +4569,8 @@ function replayClearedReasoning(messages, reasoningByMessage, messageTagNumbers,
     if (!parts)
       continue;
     for (const tp of parts) {
+      if (tp.type === "text")
+        continue;
       if (tp.thinking !== undefined && tp.thinking !== "[cleared]") {
         tp.thinking = "[cleared]";
         cleared++;
@@ -4189,6 +4621,8 @@ function clearOldReasoning(messages, reasoningByMessage, messageTagNumbers, clea
     if (!parts)
       continue;
     for (const tp of parts) {
+      if (tp.type === "text")
+        continue;
       if (tp.thinking !== undefined && tp.thinking !== "[cleared]") {
         tp.thinking = "[cleared]";
         cleared++;
@@ -4480,8 +4914,9 @@ function applyFrozenTrailingBlankDecisions(messages, frozenDecisions) {
   return mutations;
 }
 function stripReasoningFromAssistantIds(messages, providerID, messageIds) {
-  if (providerID !== "anthropic" || messageIds.size === 0)
+  if (messageIds.size === 0)
     return 0;
+  const emptySentinels = modelAcceptsEmptyContent(providerID);
   let stripped = 0;
   for (const message of messages) {
     const id = message.info.id;
@@ -4491,9 +4926,16 @@ function stripReasoningFromAssistantIds(messages, providerID, messageIds) {
       const part = message.parts[index];
       if (!isRecord(part) || !REASONING_PART_TYPES.has(String(part.type)))
         continue;
-      message.parts[index] = makeSentinel(part);
+      if (emptySentinels) {
+        message.parts[index] = makeSentinel(part);
+      } else {
+        message.parts.splice(index, 1);
+        index -= 1;
+      }
       stripped += 1;
     }
+    if (message.parts.length === 0)
+      message.parts.push(makeWholeMessageSentinel(providerID));
   }
   return stripped;
 }
@@ -4591,6 +5033,135 @@ function stripProcessedImages(messages, frozenIds, options) {
   return { stripped, newlyStrippedIds };
 }
 
+// src/hooks/magic-context/reasoning-removal.ts
+var REMOVABLE_REASONING_TYPES = new Set(["reasoning", "thinking", "redacted_thinking"]);
+function isReasoningPart(part) {
+  return isRecord(part) && REMOVABLE_REASONING_TYPES.has(String(part.type));
+}
+function isReasoningOrNeutralized(part) {
+  return isReasoningPart(part) || isNeutralizedReasoningPart(part);
+}
+function hasWireContentBesideReasoning(message) {
+  return message.parts.some((part) => {
+    if (!isRecord(part) || part.ignored === true)
+      return false;
+    if (part.type === "tool" || part.type === "file")
+      return true;
+    return part.type === "text" && typeof part.text === "string" && part.text.trim() !== "";
+  });
+}
+function newestAssistant(messages) {
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    if (messages[index].info.role === "assistant")
+      return messages[index];
+  }
+  return;
+}
+function openRouterReasoningDetails(part) {
+  if (!isRecord(part) || !isRecord(part.metadata))
+    return;
+  const openrouter = part.metadata.openrouter;
+  if (!isRecord(openrouter) || !Array.isArray(openrouter.reasoning_details))
+    return;
+  return openrouter.reasoning_details;
+}
+function isProtectedReasoningDetail(detail) {
+  if (!isRecord(detail))
+    return true;
+  if (typeof detail.format !== "string")
+    return true;
+  return detail.format.startsWith("google-gemini");
+}
+function reasoningPayloadLeavesWithParts(message) {
+  for (const part of message.parts) {
+    const details = openRouterReasoningDetails(part);
+    if (details?.some(isProtectedReasoningDetail))
+      return false;
+  }
+  return true;
+}
+function stripOpenRouterReasoningDetails(message) {
+  let stripped = 0;
+  for (const part of message.parts) {
+    if (!openRouterReasoningDetails(part))
+      continue;
+    const metadata = part.metadata;
+    const { reasoning_details: _removed, ...rest } = metadata.openrouter;
+    metadata.openrouter = rest;
+    stripped += 1;
+  }
+  return stripped;
+}
+function selectReasoningRemovals(args) {
+  let maxTag = 0;
+  for (const tag of args.messageTagNumbers.values())
+    if (tag > maxTag)
+      maxTag = tag;
+  const cutoff = maxTag - args.clearReasoningAge;
+  if (maxTag === 0 || cutoff <= 0)
+    return [];
+  const newest = newestAssistant(args.messages);
+  const exempt = findLatestAssistantReasoningMutationExemptMessage(args.messages);
+  const selected = [];
+  for (const message of args.messages) {
+    if (message.info.role !== "assistant")
+      continue;
+    if (!message.parts.some(isReasoningOrNeutralized))
+      continue;
+    const id = typeof message.info.id === "string" && message.info.id.length > 0 ? message.info.id : undefined;
+    if (id !== undefined && (args.alreadyRemoved.has(id) || args.prefixBound && args.alsoGone?.has(id)))
+      continue;
+    const tag = args.messageTagNumbers.get(message) ?? 0;
+    const removable = id !== undefined && message !== newest && message !== exempt && tag > 0 && tag <= cutoff && hasWireContentBesideReasoning(message) && reasoningPayloadLeavesWithParts(message);
+    if (removable && id !== undefined)
+      selected.push(id);
+    else if (args.prefixBound)
+      break;
+  }
+  return selected;
+}
+function removeReasoningParts(messages, ids, providerID) {
+  if (ids.size === 0)
+    return 0;
+  const exempt = findLatestAssistantReasoningMutationExemptMessage(messages);
+  let removed = 0;
+  for (const message of messages) {
+    if (message.info.role !== "assistant" || message === exempt)
+      continue;
+    const id = message.info.id;
+    if (typeof id !== "string" || !ids.has(id))
+      continue;
+    if (!reasoningPayloadLeavesWithParts(message))
+      continue;
+    const before = message.parts.length;
+    const kept = message.parts.filter((part) => !isReasoningOrNeutralized(part));
+    if (kept.length === before)
+      continue;
+    removed += before - kept.length;
+    message.parts.length = 0;
+    message.parts.push(...kept);
+    stripOpenRouterReasoningDetails(message);
+    if (!hasWireContentBesideReasoning(message)) {
+      message.parts.push(makeWholeMessageSentinel(providerID));
+    }
+  }
+  return removed;
+}
+function settleDroppedReasoningParts(messages, mode) {
+  let settled = 0;
+  for (const message of messages) {
+    if (message.info.role !== "assistant")
+      continue;
+    for (const part of message.parts) {
+      if (!isNeutralizedReasoningPart(part))
+        continue;
+      if (restoreNeutralizedReasoningPart(part, mode === "legacy"))
+        settled += 1;
+    }
+  }
+  return settled;
+}
+
 // src/hooks/magic-context/supersession-reclaim.ts
 var TODOWRITE_KEEP = 1;
 var SUPERSESSION_RECENT_MESSAGE_WINDOW = 20;
@@ -5143,6 +5714,7 @@ function createExistingTagResolver(sessionId, tagger, db) {
   let cachedAssignmentSize = -1;
   let cachedScopedAssignments = null;
   const usedTagNumbers = new Set;
+  const claimedContentIds = new Set;
   function getScopedAssignments() {
     if (!cachedScopedAssignments || cachedAssignmentSize !== assignments.size) {
       cachedScopedAssignments = createScopedAssignments(assignments);
@@ -5153,13 +5725,14 @@ function createExistingTagResolver(sessionId, tagger, db) {
   return {
     resolve(messageId, type, currentContentId, ordinal, options) {
       const accept = options?.accept ?? (() => true);
+      claimedContentIds.add(currentContentId);
       const exactTagId = assignments.get(currentContentId);
       if (exactTagId !== undefined && accept(exactTagId)) {
         usedTagNumbers.add(exactTagId);
         return exactTagId;
       }
       const fallback = getScopedAssignments().get(messageId)?.[type][ordinal];
-      if (!fallback || usedTagNumbers.has(fallback.tagNumber) || !accept(fallback.tagNumber)) {
+      if (!fallback || usedTagNumbers.has(fallback.tagNumber) || claimedContentIds.has(fallback.contentId) || !accept(fallback.tagNumber)) {
         return;
       }
       updateTagMessageId(db, sessionId, fallback.tagNumber, currentContentId);
@@ -5181,20 +5754,22 @@ function logTransformTiming(sessionId, stage, startMs, extra) {
 // src/hooks/magic-context/tag-messages.ts
 var TOOL_OWNER_CACHE_KEY_SEP = "\x00";
 var inertWhitespaceCache = new WeakMap;
-function getCachedInertWhitespaceAssistantTags(db, sessionId, tagger) {
+function getCachedInertWhitespaceAssistantTags(db, sessionId, tagger, messages) {
+  const messageIds = messages.flatMap((message) => typeof message.info.id === "string" ? [message.info.id] : []);
+  const ownersKey = JSON.stringify(messageIds);
   const tagsVersion = tagger.getLoadedTagsVersion?.(sessionId, db);
   if (tagsVersion === undefined)
-    return getInertWhitespaceAssistantTags(db, sessionId);
+    return getInertWhitespaceAssistantTags(db, sessionId, messageIds);
   let bySession = inertWhitespaceCache.get(db);
   if (!bySession) {
     bySession = new Map;
     inertWhitespaceCache.set(db, bySession);
   }
   const cached = bySession.get(sessionId);
-  if (cached?.tagsVersion === tagsVersion)
+  if (cached?.tagsVersion === tagsVersion && cached.ownersKey === ownersKey)
     return cached.tags;
-  const tags = getInertWhitespaceAssistantTags(db, sessionId);
-  bySession.set(sessionId, { tagsVersion, tags });
+  const tags = getInertWhitespaceAssistantTags(db, sessionId, messageIds);
+  bySession.set(sessionId, { tagsVersion, ownersKey, tags });
   return tags;
 }
 function makeToolOwnerCacheKey(sessionId, callId) {
@@ -5371,7 +5946,7 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
   const tInertWhitespace = performance.now();
   const inertWhitespaceTagNumbers = new Set;
   const inertWhitespaceTagsByMessage = new Map;
-  for (const tag of getCachedInertWhitespaceAssistantTags(db, sessionId, tagger)) {
+  for (const tag of getCachedInertWhitespaceAssistantTags(db, sessionId, tagger, messages)) {
     inertWhitespaceTagNumbers.add(tag.tagNumber);
     tagger.bindTag(sessionId, tag.contentId, tag.tagNumber);
     const scoped = /^(.*):p(\d+)$/.exec(tag.contentId);
@@ -5390,6 +5965,22 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
   const tGetSourceContents = performance.now();
   const sourceContents = getSourceContents(db, sessionId, collectRelevantSourceTagIds(messages, assignments));
   logTransformTiming(sessionId, "tag.getSourceContents", tGetSourceContents);
+  let partialEndsCache;
+  const loadPartialEnds = () => {
+    if (partialEndsCache)
+      return partialEndsCache;
+    const first = new Map;
+    const last = new Map;
+    const rows = db.prepare("SELECT end_message_id, end_block_index FROM compartments WHERE session_id=? AND end_block_index IS NOT NULL ORDER BY rowid").all(sessionId);
+    for (const row of rows) {
+      if (!first.has(row.end_message_id))
+        first.set(row.end_message_id, row.end_block_index);
+      last.set(row.end_message_id, row.end_block_index);
+    }
+    partialEndsCache = { first, last };
+    return partialEndsCache;
+  };
+  const getPartialEnds = () => loadPartialEnds().first;
   let precedingThinkingParts = [];
   let lastReduceMessageIndex = -1;
   const RECENT_REDUCE_LOOKBACK = 10;
@@ -5543,15 +6134,20 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
         }
         targets.set(tagId, {
           message,
-          setContent: (content) => {
+          textPrefix: skipPrefixInjection ? "" : prependTag(tagId, ""),
+          setContent: (content, options) => {
             if (textPart.text === content)
               return false;
+            const partialEnd = messageId ? getPartialEnds().get(messageId) : undefined;
+            if (partialEnd !== undefined && partIndex > partialEnd)
+              return false;
             textPart.text = content;
+            if (options?.keepReasoning === true)
+              return true;
             for (const tp of thinkingParts) {
-              if (tp.thinking !== undefined)
-                tp.thinking = "[cleared]";
-              if (tp.text !== undefined)
-                tp.text = "[cleared]";
+              if (partialEnd !== undefined && message.parts.indexOf(tp) > partialEnd)
+                continue;
+              neutralizeDroppedReasoningPart(tp);
             }
             return true;
           },
@@ -5623,6 +6219,11 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
             const prevText = typeof prev === "object" && prev !== null && "text" in prev ? prev.text : "";
             if (prevText === content)
               return false;
+            if (messageId) {
+              const partialEnd = getPartialEnds().get(messageId);
+              if (partialEnd !== undefined && partIndex > partialEnd)
+                return false;
+            }
             messageParts[partIndex] = {
               type: "text",
               text: content
@@ -5643,7 +6244,18 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
   logTransformTiming(sessionId, "tag.assignTag", performance.now() - accAssignTag);
   logTransformTiming(sessionId, "tag.assignToolTag", performance.now() - accAssignToolTag);
   logTransformTiming(sessionId, "tag.saveSource", performance.now() - accSaveSource);
+  const partialEnds = toolTagByCallId.size > 0 ? loadPartialEnds().last : new Map;
   for (const [compositeKey, tagId] of toolTagByCallId) {
+    const occurrences = toolCallIndex.get(compositeKey)?.occurrences ?? [];
+    const touchesUncoveredPart = occurrences.some(({ message, part }) => {
+      const messageId = message.info.id;
+      if (typeof messageId !== "string")
+        return false;
+      const partialEnd = partialEnds.get(messageId);
+      return partialEnd !== undefined && message.parts.indexOf(part) > partialEnd;
+    });
+    if (touchesUncoveredPart)
+      continue;
     const thinkingParts = toolThinkingByCallId.get(compositeKey) ?? [];
     targets.set(tagId, createToolDropTarget(compositeKey, thinkingParts, toolCallIndex, batch, tagId));
   }
@@ -5730,7 +6342,7 @@ function removeSyntheticTodoParts(messages) {
     }
   }
 }
-async function applyTodoSynthesis(args) {
+async function applyTodoSynthesis2(args) {
   if (!args.fullFeatureMode || args.compactionOff)
     return 0;
   const persistedAnchor = args.replaySnapshot ? args.replaySnapshot.todoSyntheticAnchor : getPersistedTodoSyntheticAnchor(args.db, args.sessionId);
@@ -5795,7 +6407,10 @@ function freezeAllReasoningForBindingRecovery(args) {
     args.recoveredMessageIds.add(id);
   return { flagTarget: args.flagTarget, messageIds };
 }
-function freezeReasoningOnBustingPass(args) {
+function countAutoSearchHints(db, sessionId) {
+  return getAutoSearchHintDecisions(db, sessionId).filter((decision) => decision.decision === "hint").length;
+}
+function freezeReasoningOnBustingPass2(args) {
   const messageIds = findReasoningBearingAssistantIds(args.messages).filter((id) => !args.alreadyFrozen.has(id));
   if (messageIds.length === 0)
     return { strip: null, persistenceFailed: false };
@@ -5820,7 +6435,7 @@ function proactiveStripStartIndex(args) {
     return null;
   if (!lastServed.messages)
     return 0;
-  const divergence = firstServedDivergenceIndex(args.messages, lastServed.messages, {
+  const divergence = firstServedDivergenceIndex2(args.messages, lastServed.messages, {
     providerID: args.resolvedProviderID
   });
   if (lastServed.proven)
@@ -5846,7 +6461,7 @@ function servedMessageKey(message, providerID) {
   }));
   return stableStringify(plain);
 }
-function firstServedDivergenceIndex(messages, lastServed, options = {}) {
+function firstServedDivergenceIndex2(messages, lastServed, options = {}) {
   const shared = Math.min(messages.length, lastServed.length);
   for (let index = 0;index < shared; index += 1) {
     if (servedMessageKey(messages[index], options.providerID) !== servedMessageKey(lastServed[index], options.providerID)) {
@@ -5855,9 +6470,26 @@ function firstServedDivergenceIndex(messages, lastServed, options = {}) {
   }
   return null;
 }
+function rustModeServedKeyAfterPersistedStrips2(args) {
+  const recoveryMessageIds = new Set;
+  for (const id of getMergedReasoningStrippedIds(args.db, args.sessionId)) {
+    if (!id.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX))
+      continue;
+    const messageId = id.slice(THINKING_BINDING_RECOVERY_FROZEN_PREFIX.length);
+    if (messageId.length > 0)
+      recoveryMessageIds.add(messageId);
+  }
+  return (message) => {
+    const id = isRecord(message) && isRecord(message.info) ? message.info.id : undefined;
+    if (typeof id !== "string" || !recoveryMessageIds.has(id)) {
+      return servedMessageKey(message, args.resolvedProviderID);
+    }
+    const copy = [structuredClone(message)];
+    stripReasoningFromAssistantIds(copy, args.resolvedProviderID, recoveryMessageIds);
+    return servedMessageKey(copy[0], args.resolvedProviderID);
+  };
+}
 function replayRustModeBindingMismatchStrips2(args) {
-  if (!modelAcceptsEmptyContent(args.resolvedProviderID))
-    return;
   const recoveryMessageIds = new Set;
   for (const id of getMergedReasoningStrippedIds(args.db, args.sessionId)) {
     if (!id.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX))
@@ -5868,7 +6500,7 @@ function replayRustModeBindingMismatchStrips2(args) {
   }
   stripReasoningFromAssistantIds(args.messages, args.resolvedProviderID, recoveryMessageIds);
 }
-var RUST_MARKER_LOCK_SKIP_LOG = "rust compaction-marker: pending target write skipped on lock contention; next pass retries";
+var RUST_MARKER_LOCK_SKIP_LOG2 = "rust compaction-marker: pending target write skipped on lock contention; next pass retries";
 function isSqliteLockContentionError(error) {
   if (!error || typeof error !== "object")
     return false;
@@ -5912,7 +6544,7 @@ function applyRustModeDeferredCompactionMarker2(args) {
     } catch (error) {
       if (!isSqliteLockContentionError(error))
         throw error;
-      sessionLog(args.sessionId, `${RUST_MARKER_LOCK_SKIP_LOG}: ${error instanceof Error ? error.message : String(error)}`);
+      sessionLog(args.sessionId, `${RUST_MARKER_LOCK_SKIP_LOG2}: ${error instanceof Error ? error.message : String(error)}`);
       return;
     }
   }
@@ -5955,13 +6587,70 @@ function clearRustModeBoundaryRecord2(db, sessionId) {
   setPersistedCompactionMarkerState(db, sessionId, null);
   return true;
 }
+function applyRustModeThinkingStrips(args, hostEditBeforeNewestThinking) {
+  const recoveryMessageIds = new Set;
+  let thinkingBindingRecovery = null;
+  let proactiveThinkingStrip = null;
+  {
+    try {
+      for (const id of getMergedReasoningStrippedIds(args.db, args.sessionId)) {
+        if (!id.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX))
+          continue;
+        const messageId = id.slice(THINKING_BINDING_RECOVERY_FROZEN_PREFIX.length);
+        if (messageId.length > 0)
+          recoveryMessageIds.add(messageId);
+      }
+      const flagTarget = args.thinkingBindingRecoveryEnabledForModel ? getThinkingBindingRecoveryTarget(args.db, args.sessionId) : null;
+      if (flagTarget) {
+        thinkingBindingRecovery = freezeAllReasoningForBindingRecovery({
+          db: args.db,
+          sessionId: args.sessionId,
+          messages: args.messages,
+          flagTarget,
+          recoveredMessageIds: recoveryMessageIds
+        });
+        if (!thinkingBindingRecovery) {
+          sessionLog(args.sessionId, "rust thinking binding recovery: persistence failed; leaving the bound blocks intact");
+        }
+      }
+    } catch (error) {
+      sessionLog(args.sessionId, "rust thinking binding recovery failed:", error);
+    }
+    stripReasoningFromAssistantIds(args.messages, args.resolvedProviderID, recoveryMessageIds);
+    const moduleBustStrips = args.cacheBustingPass === true && (args.moduleReasoningTrimOnly !== true || hostEditBeforeNewestThinking);
+    const stripFrom = args.thinkingBindingRecoveryEnabledForModel === true ? proactiveStripStartIndex({ ...args, cacheBustingPass: moduleBustStrips }) : null;
+    if (stripFrom !== null) {
+      const outcome = freezeReasoningOnBustingPass2({
+        db: args.db,
+        sessionId: args.sessionId,
+        messages: args.messages.slice(stripFrom),
+        alreadyFrozen: recoveryMessageIds
+      });
+      if (outcome.strip) {
+        proactiveThinkingStrip = outcome.strip;
+        for (const id of outcome.strip.messageIds)
+          recoveryMessageIds.add(id);
+        stripReasoningFromAssistantIds(args.messages, args.resolvedProviderID, new Set(outcome.strip.messageIds));
+      }
+    }
+  }
+  return { thinkingBindingRecovery, proactiveThinkingStrip };
+}
 function runRustModePostprocess2(args) {
-  if (!args.fullFeatureMode || args.compactionOff) {
+  if (args.compactionOff) {
     return { thinkingBindingRecovery: null, proactiveThinkingStrip: null, markerAt: null };
   }
   if (args.messages.some((message) => !message || typeof message !== "object" || !isRecord(message.info))) {
     return { thinkingBindingRecovery: null, proactiveThinkingStrip: null, markerAt: null };
   }
+  if (!args.fullFeatureMode) {
+    return { ...applyRustModeThinkingStrips(args, false), markerAt: null };
+  }
+  const servedMarkerRecord = () => JSON.stringify([
+    getPersistedCompactionMarkerState(args.db, args.sessionId),
+    getDeferredClearedCompactionMarkerState(args.db, args.sessionId)
+  ]);
+  const servedMarkerBefore = servedMarkerRecord();
   applyRustModeDeferredCompactionMarker2({
     ...args.compactionMarkerStrategy ? { applyDeferred: args.compactionMarkerStrategy.applyDeferred } : {},
     db: args.db,
@@ -5969,7 +6658,7 @@ function runRustModePostprocess2(args) {
     boundary: args.materializedBoundary,
     sessionDirectory: args.sessionDirectory
   });
-  (args.compactionMarkerStrategy?.reconcile ?? reconcileMarkerRepresentation)(args.messages, getPersistedCompactionMarkerState(args.db, args.sessionId), {
+  (args.compactionMarkerStrategy?.reconcile ?? reconcileMarkerRepresentation2)(args.messages, getPersistedCompactionMarkerState(args.db, args.sessionId), {
     db: args.db,
     sessionId: args.sessionId,
     tagger: args.tagger,
@@ -6013,6 +6702,7 @@ function runRustModePostprocess2(args) {
   }
   const absorbingStripDecisions = new Map([...trailingBlankDecisions].filter(([, decision]) => decision === "strip"));
   applyFrozenTrailingBlankDecisions(args.messages, absorbingStripDecisions);
+  let noteNudgeAppended = false;
   const currentUserMessageId = findLastUserMessageId(args.messages);
   const noteReadStillVisible = hasVisibleNoteReadCall(args.messages);
   const deferredNoteText = peekNoteNudgeText(args.db, args.sessionId, currentUserMessageId, args.projectPath, noteReadStillVisible);
@@ -6024,55 +6714,12 @@ function runRustModePostprocess2(args) {
     const outcome = markNoteNudgeDelivered(args.db, args.sessionId, instruction, anchoredMessageId);
     if (anchoredMessageId && outcome.ok) {
       appendReminderToUserMessageById(args.messages, anchoredMessageId, instruction);
+      noteNudgeAppended = true;
     } else if (anchoredMessageId && !outcome.ok) {
       sessionLog(args.sessionId, `rust note-nudge delivery skipped wire append: ${outcome.kind}`);
     }
   }
-  const recoveryMessageIds = new Set;
-  let thinkingBindingRecovery = null;
-  let proactiveThinkingStrip = null;
-  if (modelAcceptsEmptyContent(args.resolvedProviderID)) {
-    try {
-      for (const id of getMergedReasoningStrippedIds(args.db, args.sessionId)) {
-        if (!id.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX))
-          continue;
-        const messageId = id.slice(THINKING_BINDING_RECOVERY_FROZEN_PREFIX.length);
-        if (messageId.length > 0)
-          recoveryMessageIds.add(messageId);
-      }
-      const flagTarget = args.thinkingBindingRecoveryEnabledForModel ? getThinkingBindingRecoveryTarget(args.db, args.sessionId) : null;
-      if (flagTarget) {
-        thinkingBindingRecovery = freezeAllReasoningForBindingRecovery({
-          db: args.db,
-          sessionId: args.sessionId,
-          messages: args.messages,
-          flagTarget,
-          recoveredMessageIds: recoveryMessageIds
-        });
-        if (!thinkingBindingRecovery) {
-          sessionLog(args.sessionId, "rust thinking binding recovery: persistence failed; leaving the bound blocks intact");
-        }
-      }
-    } catch (error) {
-      sessionLog(args.sessionId, "rust thinking binding recovery failed:", error);
-    }
-    stripReasoningFromAssistantIds(args.messages, args.resolvedProviderID, recoveryMessageIds);
-    const stripFrom = args.thinkingBindingRecoveryEnabledForModel === true ? proactiveStripStartIndex(args) : null;
-    if (stripFrom !== null) {
-      const outcome = freezeReasoningOnBustingPass({
-        db: args.db,
-        sessionId: args.sessionId,
-        messages: args.messages.slice(stripFrom),
-        alreadyFrozen: recoveryMessageIds
-      });
-      if (outcome.strip) {
-        proactiveThinkingStrip = outcome.strip;
-        for (const id of outcome.strip.messageIds)
-          recoveryMessageIds.add(id);
-        stripReasoningFromAssistantIds(args.messages, args.resolvedProviderID, new Set(outcome.strip.messageIds));
-      }
-    }
-  }
+  const { thinkingBindingRecovery, proactiveThinkingStrip } = applyRustModeThinkingStrips(args, noteNudgeAppended || servedMarkerRecord() !== servedMarkerBefore);
   const marker = getPersistedCompactionMarkerState(args.db, args.sessionId);
   return {
     thinkingBindingRecovery,
@@ -6085,7 +6732,7 @@ function dropMarkerSummaryTag(db, sessionId, summaryMessageId) {
   if (tagNumber !== null)
     updateTagStatus(db, sessionId, tagNumber, "dropped");
 }
-function reconcileMarkerRepresentation(messages, persistedMarkerState, options) {
+function reconcileMarkerRepresentation2(messages, persistedMarkerState, options) {
   if (persistedMarkerState === null) {
     if (options.isCacheBustingPass === true) {
       retireDeferredClearedCompactionMarkerState(options.db, options.sessionId);
@@ -6168,7 +6815,7 @@ function sourceAlreadyReflectsCoveringMarker(sessionId, sourceOrder, marker, pen
     return false;
   return sourceOrder.messageIds.includes(marker.summaryMessageId) && !sourceOrder.messageIds.includes(pending.endMessageId);
 }
-function clearPendingCompactionMarkerAfterSuccessfulDrain(args) {
+function clearPendingCompactionMarkerAfterSuccessfulDrain2(args) {
   if (clearPendingCompactionMarkerStateIf(args.db, args.sessionId, args.pending)) {
     return "cleared";
   }
@@ -6183,7 +6830,7 @@ function clearPendingCompactionMarkerAfterSuccessfulDrain(args) {
 }
 var defaultCompactionMarkerStrategy2 = {
   applyDeferred: applyDeferredCompactionMarker,
-  reconcile: reconcileMarkerRepresentation
+  reconcile: reconcileMarkerRepresentation2
 };
 async function abortSessionFailClosed2(client, sessionId) {
   if (typeof client?.session?.abort !== "function") {
@@ -6216,7 +6863,7 @@ function evaluateEmergencyFailClosed2(input) {
     reason: shouldAbort ? "provider-overflow-abort" : "proceed"
   };
 }
-function finalizeMessageRepresentation(messages, resolvedProviderID, options) {
+function finalizeMessageRepresentation2(messages, resolvedProviderID, options) {
   let clearedParts = 0;
   if (modelAcceptsEmptyContent(resolvedProviderID)) {
     const prependedMessageCount = Math.min(messages.length, Math.max(0, options?.prependedMessageCount ?? 0));
@@ -6247,6 +6894,13 @@ function finalizeMessageRepresentation(messages, resolvedProviderID, options) {
 async function runPostTransformPhase2(args) {
   const tPostprocessSetup = performance.now();
   const compactionOff = args.compactionOff === true;
+  const failPass = (site, error = new Error(`Could not complete ${site}`), kind) => {
+    args.passOutcome?.record(site, kind);
+    if (!compactionOff) {
+      sessionLog(args.sessionId, `transform refused degraded pass site=${site}:`, error);
+      throw degradedPassError(site, error);
+    }
+  };
   const trailingBlankSourceDecisions = args.trailingBlankSourceDecisions ?? snapshotTrailingBlankSourceDecisions(args.messages);
   let trailingBlankNewestAssistant;
   for (let index = args.messages.length - 1;index >= 0; index -= 1) {
@@ -6279,7 +6933,8 @@ async function runPostTransformPhase2(args) {
   const deferredMaterialize = args.canConsumeDeferredLate && deferredMaterializationWasPending;
   const materializationRequested = isExplicitFlush || deferredMaterialize;
   const m0M1EnabledForFold = args.m0M1 !== undefined && (!!args.m0M1.projectPath || !!args.m0M1.projectDirectory) && (args.fullFeatureMode || compactionOff);
-  const foldDueDecision = m0M1EnabledForFold && args.m0M1 ? mustMaterialize({
+  const freezeM0M1 = args.freezeM0M1 === true;
+  const foldDueDecision = m0M1EnabledForFold && args.m0M1 && !freezeM0M1 ? mustMaterialize({
     db: args.db,
     sessionId: args.sessionId,
     state: args.sessionMeta,
@@ -6290,10 +6945,11 @@ async function runPostTransformPhase2(args) {
     muralEnabled: args.m0M1.muralEnabled,
     memoryInjectionBudgetTokens: args.m0M1.memoryInjectionBudgetTokens,
     historyBudgetTokens: args.m0M1.historyBudgetTokens,
+    historyBudgetPolicyIdentity: args.m0M1.historyBudgetPolicyIdentity,
     hardSignals: args.m0M1.hardSignals
   }) : { value: false, reason: null };
   let preparedPrefix;
-  const shouldCaptureCachedPrefix = (foldDueDecision.value || args.schedulerDecision === "execute") && m0M1EnabledForFold && !emergencyDropEligible;
+  const shouldCaptureCachedPrefix = (foldDueDecision.value || args.schedulerDecision === "execute") && m0M1EnabledForFold && !emergencyDropEligible && !freezeM0M1;
   const cachedPrefixBeforePreflight = shouldCaptureCachedPrefix ? prepareCachedM0M1Replay(args.db, args.sessionId) : undefined;
   const completeCachedPrefixAvailable = args.sessionMeta.cachedM0Bytes != null && args.sessionMeta.cachedM1Bytes != null || cachedPrefixBeforePreflight !== undefined || m0M1EnabledForFold && !shouldCaptureCachedPrefix && hasCompleteCachedM0M1(args.db, args.sessionId);
   const firstRenderBust = m0M1EnabledForFold && !completeCachedPrefixAvailable;
@@ -6301,7 +6957,7 @@ async function runPostTransformPhase2(args) {
   let foldBustsServedPrefixThisPass = false;
   let publishedM1RefreshedThisPass = false;
   let prefixPreflightFailed = false;
-  const softRefreshOpportunity = args.schedulerDecision === "execute" || deferredMaterialize;
+  const softRefreshOpportunity = !freezeM0M1 && (args.schedulerDecision === "execute" || deferredMaterialize);
   let m0RematerializedThisPass = false;
   const m0CoverageBeforeFold = args.sessionMeta.cachedM0Bytes === null ? -1 : args.sessionMeta.cachedM0MaxCompartmentSeq;
   let m0MaterializeReason = null;
@@ -6328,6 +6984,7 @@ async function runPostTransformPhase2(args) {
         memoryEnabled: args.m0M1.memoryEnabled,
         memoryInjectionBudgetTokens: args.m0M1.memoryInjectionBudgetTokens,
         historyBudgetTokens: args.m0M1.historyBudgetTokens,
+        historyBudgetPolicyIdentity: args.m0M1.historyBudgetPolicyIdentity,
         temporalAwareness: args.m0M1.temporalAwareness,
         isCacheBustingPass: true,
         contentionFallbackPrefix: cachedPrefixBeforePreflight,
@@ -6373,7 +7030,7 @@ async function runPostTransformPhase2(args) {
     } catch (error) {
       preparedPrefix = cachedPrefixBeforePreflight;
       prefixPreflightFailed = true;
-      args.passOutcome?.record("m0-m1-fold-preexecution-degradation");
+      failPass("m0-m1-fold-preexecution-degradation", error);
       sessionLog(args.sessionId, "transform: m[0] HARD fold pre-execution failed:", getErrorMessage(error));
     }
     sessionLog(args.sessionId, `m[0] HARD fold decision: reason=${foldDueDecision.reason ?? "unknown"} executed=${foldExecutedThisPass} bustsServedPrefix=${foldBustsServedPrefixThisPass}`);
@@ -6385,8 +7042,9 @@ async function runPostTransformPhase2(args) {
     const depth = getPendingOpsCount(args.db, args.sessionId);
     return depth === null ? "not loaded (deferred pass)" : String(depth);
   };
+  const idleExpiryRebuild = !freezeM0M1 && args.m0M1?.hardSignals?.cacheExpired === true;
   const rideSignals = {
-    hardFold: foldBustsServedPrefixThisPass || firstRenderBust,
+    hardFold: foldBustsServedPrefixThisPass || firstRenderBust || idleExpiryRebuild,
     force: emergencyDropEligible && (args.contextUsage.percentage >= 95 || getEmergencyInputSample(args.db, args.sessionId) === 0),
     explicitFlush: isExplicitFlush || deferredMaterialize && !prefixPreflightFailed,
     publishedHistory: publishedM1RefreshedThisPass || !m0M1EnabledForFold && (args.pendingCompartmentInjection?.compartmentCount ?? 0) > 0 && (args.historyRebuiltThisPass || args.rebuiltHistoryFromInitialPrepare || args.canConsumeDeferredLate && args.deferredHistoryWasPendingAtPassStart)
@@ -6407,6 +7065,25 @@ async function runPostTransformPhase2(args) {
     }
   }
   const canUseEmptySentinels = modelAcceptsEmptyContent(args.resolvedProviderID);
+  const prefixBoundModel = args.thinkingBindingRecoveryEnabledForModel === true;
+  const reasoningRemovalEnabled = (!canUseEmptySentinels || prefixBoundModel) && !compactionOff;
+  const reasoningRemovalSelectable = reasoningRemovalEnabled && typeof args.resolvedProviderID === "string";
+  const removedReasoningIds = new Set;
+  let dropLeavesReasoning = false;
+  let reasoningRemovalReadable = false;
+  if (reasoningRemovalEnabled) {
+    try {
+      const state = getReasoningRemovalState(args.db, args.sessionId);
+      for (const id of state.messageIds)
+        removedReasoningIds.add(id);
+      dropLeavesReasoning = state.dropLeavesReasoning;
+      reasoningRemovalReadable = true;
+    } catch (error) {
+      args.passOutcome?.record("reasoning-removal-read-failure");
+      sessionLog(args.sessionId, "reasoning removal: persisted state and backup unreadable; failing the pass closed:", error);
+      throw new EmergencyFailClosedError("Magic Context could not read its saved reasoning-removal state for this session", { cause: error });
+    }
+  }
   if (shouldRunHeuristics) {
     const subagentRerun = !args.fullFeatureMode && alreadyRanThisTurn && args.schedulerDecision === "execute" && !isExplicitFlush && !forceMaterialization;
     const reason = isExplicitFlush ? "explicit_flush" : deferredMaterialize ? "deferred_materialization" : forceMaterialization ? `force_materialization (${args.contextUsage.percentage.toFixed(1)}% >= ${args.forceMaterializationPercentage}%)` : foldBustsServedPrefixThisPass && args.schedulerDecision !== "execute" ? `m0_hard_fold (drain folded into executed m[0] bust, scheduler=${args.schedulerDecision})` : subagentRerun ? `${reclaimRideLabel(rideSignals)} subagent_rerun (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})` : `${reclaimRideLabel(rideSignals)} (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})`;
@@ -6427,6 +7104,7 @@ async function runPostTransformPhase2(args) {
   let deferredMaterializedSuccessfully = false;
   let pendingOpsDidMutate = false;
   let heuristicOrReasoningDidMutate = false;
+  let heuristicOrReasoningEditBesidesTrim = false;
   let droppedCount = 0;
   let droppedTokens = 0;
   const droppedTokenReductions = [];
@@ -6477,21 +7155,23 @@ async function runPostTransformPhase2(args) {
       const t5 = performance.now();
       const cavemanConfig = args.cavemanTextCompression?.enabled ? {
         enabled: true,
-        minChars: args.cavemanTextCompression.minChars
+        minChars: args.cavemanTextCompression.minChars,
+        wordRules: args.cavemanTextCompression.wordRules
       } : undefined;
       const heuristicTags = shouldApplyPendingOps ? getActiveTagsBySession(args.db, args.sessionId) : args.tags;
-      const independentMutationBeforeHeuristics = pendingOpsDidMutate || args.didMutateFromFlushedStatuses || foldBustsServedPrefixThisPass || args.historyRebuiltThisPass || args.compartmentInjectionRebuiltFromDb || args.rebuiltHistoryFromInitialPrepare;
-      if (emergencyDropEligible && independentMutationBeforeHeuristics && getEmergencyInputSample(args.db, args.sessionId) > 0) {
+      const emergencyRewriteAlreadyPriced = pendingOpsDidMutate || foldBustsServedPrefixThisPass || args.historyRebuiltThisPass || args.compartmentInjectionRebuiltFromDb || args.rebuiltHistoryFromInitialPrepare;
+      if (emergencyDropEligible && emergencyRewriteAlreadyPriced && getEmergencyInputSample(args.db, args.sessionId) > 0) {
         clearEmergencyDropSample(args.db, args.sessionId);
       }
-      let routineCleanupApplied = (emergencyDropEligible ? args.contextUsage.percentage >= 95 || getEmergencyInputSample(args.db, args.sessionId) === 0 : !args.fullFeatureMode || !routinePressureAlreadyApplied) || materializationRequested || independentMutationBeforeHeuristics;
+      let routineCleanupApplied = (emergencyDropEligible ? args.contextUsage.percentage >= 95 || getEmergencyInputSample(args.db, args.sessionId) === 0 : !args.fullFeatureMode || !routinePressureAlreadyApplied) || materializationRequested || emergencyRewriteAlreadyPriced;
       let cleanup = applyHeuristicCleanup(args.sessionId, args.db, args.targets, args.messageTagNumbers, {
         protectedTagNumbers: args.protectedTagNumbers,
         protectedCutoff: args.protectedCutoff,
         emergency: emergencyDropEligible && args.emergencyCeilingTokens !== undefined && args.emergencyCeilingTokens > 0 ? {
           currentTotalInputTokens: args.contextUsage.inputTokens,
           ceilingTokens: args.emergencyCeilingTokens,
-          usagePercentage: args.contextUsage.percentage
+          usagePercentage: args.contextUsage.percentage,
+          passAlreadyPriced: emergencyRewriteAlreadyPriced
         } : undefined,
         routine: routineCleanupApplied,
         caveman: cavemanConfig
@@ -6528,11 +7208,63 @@ async function runPostTransformPhase2(args) {
       emergencyReclaimedTokens += cleanup.emergencyReclaimedTokens;
       droppedTokenReductions.push(...cleanup.droppedTokenReductions);
       const t7 = performance.now();
-      const clearedReasoning = routineCleanupApplied && canUseEmptySentinels ? clearOldReasoning(args.messages, args.reasoningByMessage, args.messageTagNumbers, args.clearReasoningAge) : 0;
+      const ageLaneAllowed = !prefixBoundModel;
+      const clearedReasoning = routineCleanupApplied && canUseEmptySentinels && ageLaneAllowed ? clearOldReasoning(args.messages, args.reasoningByMessage, args.messageTagNumbers, args.clearReasoningAge) : 0;
       if (routineCleanupApplied && canUseEmptySentinels) {
         stripClearedReasoning(args.messages);
       }
-      const strippedInline = routineCleanupApplied ? stripInlineThinking(args.messages, args.messageTagNumbers, args.clearReasoningAge) : 0;
+      const strippedInline = routineCleanupApplied && ageLaneAllowed ? stripInlineThinking(args.messages, args.messageTagNumbers, args.clearReasoningAge) : 0;
+      const persistedInlineWatermark = args.sessionMeta?.clearedReasoningThroughTag ?? 0;
+      if (routineCleanupApplied && persistedInlineWatermark > 0 && !compactionOff) {
+        replayStrippedInlineThinking(args.messages, args.messageTagNumbers, persistedInlineWatermark);
+      }
+      let removedReasoningMessages = 0;
+      if (routineCleanupApplied && reasoningRemovalSelectable && reasoningRemovalReadable) {
+        const bindingStrippedIds = new Set;
+        if (prefixBoundModel) {
+          for (const id of getMergedReasoningStrippedIds(args.db, args.sessionId)) {
+            if (!id.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX))
+              continue;
+            const messageId = id.slice(THINKING_BINDING_RECOVERY_FROZEN_PREFIX.length);
+            if (messageId.length > 0)
+              bindingStrippedIds.add(messageId);
+          }
+        }
+        const newIds = selectReasoningRemovals({
+          messages: args.messages,
+          messageTagNumbers: args.messageTagNumbers,
+          clearReasoningAge: args.clearReasoningAge,
+          alreadyRemoved: removedReasoningIds,
+          prefixBound: prefixBoundModel,
+          alsoGone: bindingStrippedIds
+        });
+        if (newIds.length > 0) {
+          let persisted = false;
+          try {
+            persisted = addRemovedReasoningIds(args.db, args.sessionId, newIds);
+          } catch (error) {
+            sessionLog(args.sessionId, "reasoning removal: persistence threw:", error);
+            failPass("reasoning-removal-persistence-failure", error);
+          }
+          if (persisted) {
+            for (const id of newIds)
+              removedReasoningIds.add(id);
+            try {
+              const committed = getReasoningRemovalState(args.db, args.sessionId);
+              for (const id of committed.messageIds)
+                removedReasoningIds.add(id);
+            } catch (error) {
+              sessionLog(args.sessionId, "reasoning removal: committed set re-read failed:", error);
+              failPass("reasoning-removal-read-failure", error);
+            }
+            removedReasoningMessages = newIds.length;
+            sessionLog(args.sessionId, `reasoning removal: froze ${newIds.length} assistant(s), total=${removedReasoningIds.size}`);
+          } else {
+            failPass("reasoning-removal-persistence-failure");
+            sessionLog(args.sessionId, "reasoning removal: persistence failed; serving the earlier set only");
+          }
+        }
+      }
       if (clearedReasoning > 0 || strippedInline > 0) {
         let maxTag = 0;
         for (const tag of args.messageTagNumbers.values()) {
@@ -6552,18 +7284,16 @@ async function runPostTransformPhase2(args) {
         }
       }
       logTransformTiming(args.sessionId, "clearOldReasoning", t7);
-      heuristicOrReasoningDidMutate = heuristicMutationCount + clearedReasoning + strippedInline > 0;
-      droppedCount += clearedReasoning + strippedInline;
-      if (pendingMaterializationAtPassStart) {
+      heuristicOrReasoningDidMutate = heuristicMutationCount + clearedReasoning + strippedInline + removedReasoningMessages > 0;
+      heuristicOrReasoningEditBesidesTrim = heuristicMutationCount + clearedReasoning + strippedInline > 0;
+      droppedCount += clearedReasoning + strippedInline + removedReasoningMessages;
+      if (pendingMaterializationAtPassStart && !freezeM0M1) {
         args.pendingMaterializationSessions.delete(args.sessionId);
       }
       if (args.currentTurnId) {
         args.lastHeuristicsTurnId.set(args.sessionId, args.currentTurnId);
       }
     }
-    if (args.schedulerDecision === "execute" && !materializationRequested) {
-      updateSessionMeta(args.db, args.sessionId, { lastResponseTime: Date.now() });
-    }
     if (emergencyDropEligible && (pendingOpsDidMutate || heuristicOrReasoningDidMutate)) {
       setEmergencyDropSample(args.db, args.sessionId, args.contextUsage.inputTokens);
     }
@@ -6640,15 +7370,15 @@ async function runPostTransformPhase2(args) {
     if (args.sessionMeta.lastTransformError !== null) {
       updateSessionMeta(args.db, args.sessionId, { lastTransformError: null });
     }
-    if (shouldRunHeuristics) {
+    if (shouldRunHeuristics && !freezeM0M1) {
       if (isExplicitFlush)
         explicitMaterializedSuccessfully = true;
       if (deferredMaterialize)
         deferredMaterializedSuccessfully = true;
     }
   } catch (error) {
-    args.passOutcome?.record("pending-operation-failure");
     sessionLog(args.sessionId, "transform failed applying pending operations:", error);
+    failPass("pending-operation-failure", error);
     updateSessionMeta(args.db, args.sessionId, { lastTransformError: getErrorMessage(error) });
   }
   if (isCacheBustingPass) {
@@ -6671,7 +7401,7 @@ async function runPostTransformPhase2(args) {
       }
       logTransformTiming(args.sessionId, "dropStaleReduceCalls", t8);
     } catch (error) {
-      args.passOutcome?.record("stale-reduce-strip-exception");
+      failPass("stale-reduce-strip-exception", error);
       sessionLog(args.sessionId, "transform failed dropping stale ctx_reduce calls:", error);
     }
   }
@@ -6689,12 +7419,15 @@ async function runPostTransformPhase2(args) {
       }
       logTransformTiming(args.sessionId, "stripProcessedImages", tImg);
     } catch (error) {
-      args.passOutcome?.record("image-strip-exception");
+      failPass("image-strip-exception", error);
       sessionLog(args.sessionId, "transform failed stripping processed images:", error);
     }
   }
   const m0M1Enabled = m0M1EnabledForFold;
   if (m0M1Enabled && args.m0M1) {
+    if (freezeM0M1 && !preparedPrefix) {
+      preparedPrefix = prepareCachedM0M1Replay(args.db, args.sessionId);
+    }
     const tInjectM0M1 = performance.now();
     try {
       const result = injectM0M1({
@@ -6708,8 +7441,9 @@ async function runPostTransformPhase2(args) {
         memoryEnabled: args.m0M1.memoryEnabled,
         memoryInjectionBudgetTokens: args.m0M1.memoryInjectionBudgetTokens,
         historyBudgetTokens: args.m0M1.historyBudgetTokens,
+        historyBudgetPolicyIdentity: args.m0M1.historyBudgetPolicyIdentity,
         temporalAwareness: args.m0M1.temporalAwareness,
-        isCacheBustingPass,
+        isCacheBustingPass: isCacheBustingPass && !freezeM0M1,
         preparedPrefix,
         prefixTrimSourceOrder: args.prefixTrimSourceOrder,
         allowFreshContentionFallback: forceMaterialization || emergencyDropEligible,
@@ -6729,7 +7463,8 @@ async function runPostTransformPhase2(args) {
         sessionLog(args.sessionId, `transform: injected m[0]/m[1] (rematerialized=${result.m0RematerializedThisPass}, reason=${result.decision.reason ?? "cache_hit"})`);
       }
     } catch (error) {
-      args.passOutcome?.record("m0-m1-injection-degradation");
+      clearInjectionCache(args.sessionId);
+      failPass("m0-m1-injection-degradation", error);
       sessionLog(args.sessionId, "transform: m[0]/m[1] injection failed:", getErrorMessage(error));
       if (args.pendingCompartmentInjection) {
         try {
@@ -6741,7 +7476,6 @@ async function runPostTransformPhase2(args) {
           sessionLog(args.sessionId, "transform: legacy fallback injection also failed:", getErrorMessage(fallbackError));
         }
       }
-      clearInjectionCache(args.sessionId);
     }
     logTransformTiming(args.sessionId, "pp.injectM0M1", tInjectM0M1);
   } else if (args.fullFeatureMode && !compactionOff && args.pendingCompartmentInjection) {
@@ -6834,7 +7568,7 @@ async function runPostTransformPhase2(args) {
           case "already-current":
           case "stale-skip":
             persistedCompactionMarkerState = getPersistedCompactionMarkerState(args.db, args.sessionId);
-            if (clearPendingCompactionMarkerAfterSuccessfulDrain({
+            if (clearPendingCompactionMarkerAfterSuccessfulDrain2({
               db: args.db,
               sessionId: args.sessionId,
               pending,
@@ -6844,7 +7578,7 @@ async function runPostTransformPhase2(args) {
             }
             break;
           case "retryable-failure":
-            args.passOutcome?.record("compaction-marker-drain-failure");
+            failPass("compaction-marker-drain-failure", outcome.error);
             sessionLog(args.sessionId, "compaction-marker drain: retryable failure; preserving deferred history refresh signal", outcome.error);
             suppressV12HistoryDrain = true;
             break;
@@ -6852,6 +7586,7 @@ async function runPostTransformPhase2(args) {
       }
     }
   }
+  const deferredClearedMarkerRetires = !compactionOff && isCacheBustingPass && persistedCompactionMarkerState === null && getDeferredClearedCompactionMarkerState(args.db, args.sessionId) !== null;
   if (!compactionOff) {
     (args.compactionMarkerStrategy ?? defaultCompactionMarkerStrategy2).reconcile(args.messages, persistedCompactionMarkerState, {
       db: args.db,
@@ -6871,6 +7606,7 @@ async function runPostTransformPhase2(args) {
   logTransformTiming(args.sessionId, "pp.markerReconcile", tMarker);
   const tNoteAndTodo = performance.now();
   const noteReadStillVisible = args.fullFeatureMode ? hasVisibleNoteReadCall(args.messages) : false;
+  let noteNudgeAppendedThisPass = false;
   const deferredNoteText = args.fullFeatureMode ? peekNoteNudgeText(args.db, args.sessionId, args.currentTurnId, args.projectPath, noteReadStillVisible) : null;
   if (deferredNoteText) {
     const noteInstruction = `
@@ -6880,13 +7616,16 @@ async function runPostTransformPhase2(args) {
     const outcome = markNoteNudgeDelivered(args.db, args.sessionId, noteInstruction, anchoredMessageId);
     if (anchoredMessageId && outcome.ok) {
       appendReminderToUserMessageById(args.messages, anchoredMessageId, noteInstruction);
+      noteNudgeAppendedThisPass = true;
     } else if (anchoredMessageId && !outcome.ok) {
       args.passOutcome?.record("note-nudge-cas-failure");
       sessionLog(args.sessionId, `note-nudge delivery skipped wire append: ${outcome.kind}`);
     }
   }
+  let todoAnchorMovedThisPass = false;
   if (args.fullFeatureMode && !compactionOff) {
-    prependedMessageCount += await applyTodoSynthesis({
+    const todoAnchorBefore = replaySnapshot ? replaySnapshot.todoSyntheticAnchor : getPersistedTodoSyntheticAnchor(args.db, args.sessionId);
+    prependedMessageCount += await applyTodoSynthesis2({
       db: args.db,
       sessionId: args.sessionId,
       messages: args.messages,
@@ -6899,6 +7638,10 @@ async function runPostTransformPhase2(args) {
       activeAgent: args.activeAgent,
       replaySnapshot
     });
+    if (isCacheBustingPass) {
+      const todoAnchorAfter = getPersistedTodoSyntheticAnchor(args.db, args.sessionId);
+      todoAnchorMovedThisPass = (todoAnchorBefore?.callId ?? null) !== (todoAnchorAfter?.callId ?? null) || (todoAnchorBefore?.messageId ?? null) !== (todoAnchorAfter?.messageId ?? null);
+    }
   }
   logTransformTiming(args.sessionId, "pp.noteAndTodoSynthesis", tNoteAndTodo);
   if (args.compartmentInjectionRebuiltFromDb && args.pendingCompartmentInjection) {
@@ -6913,7 +7656,7 @@ async function runPostTransformPhase2(args) {
     }
   }
   if (args.fullFeatureMode && isCacheBustingPass && args.m0M1 && (!!args.m0M1.projectPath || !!args.m0M1.projectDirectory)) {
-    checkM0MutationDriftAndSignal({
+    checkM0MutationDriftAndSignal2({
       db: args.db,
       sessionId: args.sessionId,
       cachedM0MaxMutationId: args.sessionMeta.cachedM0MaxMutationId,
@@ -6921,9 +7664,12 @@ async function runPostTransformPhase2(args) {
       historyRefreshSessions: args.historyRefreshSessions
     });
   }
+  let autoSearchHintsBefore = 0;
+  let autoSearchHintAppendedThisPass = false;
   if (args.fullFeatureMode && args.autoSearch?.enabled && args.projectPath) {
     const tAutoSearch = performance.now();
     const visibleMemoryIds = getVisibleMemoryIds(args.db, args.sessionId) ?? undefined;
+    autoSearchHintsBefore = countAutoSearchHints(args.db, args.sessionId);
     try {
       const autoSearchOutcome = await runAutoSearchHint({
         sessionId: args.sessionId,
@@ -6936,7 +7682,8 @@ async function runPostTransformPhase2(args) {
           directory: args.autoSearch.directory ?? args.sessionDirectory,
           projectPath: args.projectPath,
           ensureProjectRegistered: args.autoSearch.ensureProjectRegistered,
-          visibleMemoryIds
+          visibleMemoryIds,
+          wordRules: args.autoSearch.wordRules
         }
       });
       if (!autoSearchOutcome.ok) {
@@ -6946,6 +7693,7 @@ async function runPostTransformPhase2(args) {
       args.passOutcome?.record("auto-search-internal-failure");
       sessionLog(args.sessionId, "auto-search runner failed:", error);
     }
+    autoSearchHintAppendedThisPass = countAutoSearchHints(args.db, args.sessionId) !== autoSearchHintsBefore;
     logTransformTiming(args.sessionId, "pp.autoSearchHint", tAutoSearch);
   }
   if (args.fullFeatureMode && isCacheBustingPass) {
@@ -6982,9 +7730,10 @@ async function runPostTransformPhase2(args) {
     }
   }
   const mergedReasoningStrippedIds = new Set(replaySnapshot?.mergedReasoningStrippedIds ?? []);
+  let lateEditBeforeNewestThinking = false;
   const thinkingBindingRecoveryMessageIds = new Set;
   let thinkingBindingRecovery = null;
-  if (canUseEmptySentinels && !compactionOff) {
+  if (!compactionOff) {
     try {
       for (const id of mergedReasoningStrippedIds) {
         if (id.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX)) {
@@ -7006,14 +7755,16 @@ async function runPostTransformPhase2(args) {
           for (const messageId of thinkingBindingRecovery.messageIds) {
             mergedReasoningStrippedIds.add(thinkingBindingRecoveryFrozenId(messageId));
           }
-          if (thinkingBindingRecovery.messageIds.length > 0)
+          if (thinkingBindingRecovery.messageIds.length > 0) {
             bustedThisPass = true;
+            lateEditBeforeNewestThinking = true;
+          }
         } else {
-          args.passOutcome?.record("thinking-binding-recovery-persistence-failure");
+          failPass("thinking-binding-recovery-persistence-failure");
           sessionLog(args.sessionId, "thinking binding recovery: persistence failed; leaving the bound blocks intact");
         }
       }
-      if (isCacheBustingPass) {
+      if (canUseEmptySentinels && isCacheBustingPass) {
         const candidates = findMergedReasoningStripDecisions(args.messages, args.resolvedProviderID, mergedReasoningStrippedIds, { mutationExemptMessage: reasoningMutationExemptMessage });
         const newlyDetectedIds = candidates.filter((id) => !mergedReasoningStrippedIds.has(id));
         if (newlyDetectedIds.length > 0) {
@@ -7024,14 +7775,15 @@ async function runPostTransformPhase2(args) {
               mergedReasoningStrippedIds.add(id);
             }
             bustedThisPass = true;
+            lateEditBeforeNewestThinking = true;
           } else {
-            args.passOutcome?.record("merged-reasoning-strip-persistence-failure");
+            failPass("merged-reasoning-strip-persistence-failure");
             sessionLog(args.sessionId, "merged reasoning strip: persistence failed; leaving newly detected assistants intact");
           }
         }
       }
     } catch (error) {
-      args.passOutcome?.record("merged-reasoning-strip-exception");
+      failPass("merged-reasoning-strip-exception", error);
       sessionLog(args.sessionId, "transform failed freezing merged reasoning strip:", error);
     }
   }
@@ -7052,17 +7804,18 @@ async function runPostTransformPhase2(args) {
       try {
         const demotedIds = demoteTrailingBlankKeepDecisions(args.db, args.sessionId, poisonedKeepIds);
         if (demotedIds === null) {
-          args.passOutcome?.record("trailing-blank-heal-persistence-failure");
+          failPass("trailing-blank-heal-persistence-failure");
           sessionLog(args.sessionId, "trailing blank heal: persistence failed; retaining frozen keep decisions");
         } else {
           for (const id of demotedIds) {
             trailingBlankDecisions.set(id, "strip");
             bustedThisPass = true;
+            lateEditBeforeNewestThinking = true;
             sessionLog(args.sessionId, `trailing blank heal: demoted message ${id} from keep to strip because its source has no trailing blank`);
           }
         }
       } catch (error) {
-        args.passOutcome?.record("trailing-blank-heal-exception");
+        failPass("trailing-blank-heal-exception", error);
         sessionLog(args.sessionId, "transform failed healing trailing blank decisions:", error);
       }
     }
@@ -7079,7 +7832,7 @@ async function runPostTransformPhase2(args) {
           overwriteMessageId: newestAssistantId
         });
         if (persisted) {
-          const committed = getTrailingBlankDecisions(args.db, args.sessionId);
+          const committed = getTrailingBlankDecisions(args.db, args.sessionId, candidates.map(([id]) => id));
           for (const [id] of candidates) {
             const decision = committed.get(id);
             if (decision)
@@ -7087,12 +7840,15 @@ async function runPostTransformPhase2(args) {
           }
           if (isCacheBustingPass)
             bustedThisPass = true;
+          if (isCacheBustingPass && candidates.some(([id]) => id !== newestAssistantId)) {
+            lateEditBeforeNewestThinking = true;
+          }
         } else {
-          args.passOutcome?.record("trailing-blank-decision-persistence-failure");
+          failPass("trailing-blank-decision-persistence-failure");
           sessionLog(args.sessionId, "trailing blank decision: persistence failed; serving the frozen decisions");
         }
       } catch (error) {
-        args.passOutcome?.record("trailing-blank-decision-exception");
+        failPass("trailing-blank-decision-exception", error);
         sessionLog(args.sessionId, "transform failed freezing trailing blank decision:", error);
       }
     }
@@ -7108,9 +7864,11 @@ async function runPostTransformPhase2(args) {
     skipMergedReasoningStrip: compactionOff,
     skipTrailingWhitespaceStrip: compactionOff
   };
+  const dropModeSwitchesThisPass = !canUseEmptySentinels && !dropLeavesReasoning && typeof args.resolvedProviderID === "string" && isCacheBustingPass && reasoningRemovalReadable && args.messages.some((message) => message.info.role === "assistant" && message.parts.some((part) => isNeutralizedReasoningPart(part)));
+  const prefixEditBesidesReasoningTrim = firstRenderBust || materializationRequested || explicitMaterializedSuccessfully || deferredMaterializedSuccessfully || foldBustsServedPrefixThisPass || publishedM1RefreshedThisPass || m0RematerializedThisPass || m0M1InjectedThisPass && historyWasConsumedThisPass || historyWasConsumedThisPass || pendingOpsDidMutate || heuristicOrReasoningEditBesidesTrim || emergency || autoReclaimDidMutateThisPass || convertedToolSkeletonsDidMutate || deferredClearedMarkerRetires || noteNudgeAppendedThisPass || todoAnchorMovedThisPass || autoSearchHintAppendedThisPass || dropModeSwitchesThisPass || lateEditBeforeNewestThinking;
   let proactiveThinkingStrip = null;
-  if (canUseEmptySentinels && !compactionOff && args.fullFeatureMode && args.thinkingBindingRecoveryEnabledForModel === true && proactiveThinkingStripPermitted) {
-    const outcome = freezeReasoningOnBustingPass({
+  if (!compactionOff && args.thinkingBindingRecoveryEnabledForModel === true && proactiveThinkingStripPermitted && prefixEditBesidesReasoningTrim) {
+    const outcome = freezeReasoningOnBustingPass2({
       db: args.db,
       sessionId: args.sessionId,
       messages: args.messages,
@@ -7124,12 +7882,32 @@ async function runPostTransformPhase2(args) {
       }
       bustedThisPass = true;
     } else if (outcome.persistenceFailed) {
-      args.passOutcome?.record("proactive-thinking-strip-persistence-failure");
+      failPass("proactive-thinking-strip-persistence-failure");
+    }
+  }
+  let settledDroppedReasoning = 0;
+  if (!canUseEmptySentinels) {
+    let mode = "legacy";
+    if (dropLeavesReasoning) {
+      mode = "restore";
+    } else if (typeof args.resolvedProviderID === "string") {
+      if (isCacheBustingPass && reasoningRemovalReadable) {
+        try {
+          if (markDropLeavesReasoning(args.db, args.sessionId)) {
+            dropLeavesReasoning = true;
+            mode = "restore";
+          }
+        } catch (error) {
+          sessionLog(args.sessionId, "reasoning removal: drop mode write failed:", error);
+        }
+      }
     }
+    settledDroppedReasoning = settleDroppedReasoningParts(args.messages, mode);
   }
   const tFinalRepresentation = performance.now();
-  const finalRepresentation = finalizeMessageRepresentation(args.messages, args.resolvedProviderID, finalizeOptions);
-  sessionLog(args.sessionId, `final representation: clearedParts=${finalRepresentation.clearedParts} mergedReasoningParts=${finalRepresentation.mergedReasoningParts}`);
+  const finalRepresentation = finalizeMessageRepresentation2(args.messages, args.resolvedProviderID, finalizeOptions);
+  const removedReasoningParts = reasoningRemovalEnabled ? removeReasoningParts(args.messages, removedReasoningIds, args.resolvedProviderID) : 0;
+  sessionLog(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();
   let assertedBaseline;
@@ -7241,11 +8019,12 @@ async function runPostTransformPhase2(args) {
     droppedCount,
     emergency,
     bustedThisPass,
+    prefixTrimStatus: deliveredPrefix?.prefixTrimStatus ?? null,
     thinkingBindingRecovery,
     proactiveThinkingStrip
   };
 }
-function checkM0MutationDriftAndSignal(args) {
+function checkM0MutationDriftAndSignal2(args) {
   const currentMaxMutationId = getMaxM0MutationId(args.db, args.sessionId) ?? 0;
   const cachedMaxMutationId = args.cachedM0MaxMutationId ?? 0;
   if (currentMaxMutationId !== cachedMaxMutationId) {
@@ -7257,4 +8036,4 @@ function checkM0MutationDriftAndSignal(args) {
   return false;
 }
 
-export { indexCommitsForProject, embedUnembeddedCommits, createTagger, createUnifiedSearchDiagnostics, parseIdShapedQuery, resolveMemoriesByIdsForSearch, unifiedSearch, formatSearchResults, findSessionId, findLastUserMessageId, clearAutoSearchForSession, setCtxReduceRegisteredGlobally, resolveCtxReduceAvailabilityFromMessages, resolveCtxReduceAvailability, primeCtxReduceSpawnPermission, ctxReduceSpawnPermissionReadNeeded, spawnAgentFromMessages, spawnAgentFromOpenCodeDb, todowritePermissionDenied, cachedToolPermissionDenied, clearToolPermissionDenied, resolveTodowriteAvailabilityFromMessages, resolveTodowriteAvailability, modelAcceptsEmptyContent, variantChangeBustsProviderCache, canConsumeDeferredOnThisPass, hasReclaimRide, reclaimRideLabel, replayCavemanCompression, replayClearedReasoning, replayStrippedInlineThinking, stripClearedReasoning, snapshotTrailingBlankSourceDecisions, applyFlushedStatuses, stripStructuralNoise, logTransformTiming, hasRecentAssistantCommit, tagMessages, resetDegradedCacheCount2, isSyntheticHeadMessage2, replayRustModeBindingMismatchStrips2, applyRustModeDeferredCompactionMarker2, clearRustModeBoundaryRecord2, runRustModePostprocess2, defaultCompactionMarkerStrategy2, abortSessionFailClosed2, evaluateEmergencyFailClosed2, runPostTransformPhase2 };
+export { indexCommitsForProject, embedUnembeddedCommits, createTagger, createUnifiedSearchDiagnostics, parseIdShapedQuery, resolveMemoriesByIdsForSearch, unifiedSearch, formatSearchResults, cavemanWordRulesForLanguage, findSessionId, findLastUserMessageId, clearAutoSearchForSession, setCtxReduceRegisteredGlobally, resolveCtxReduceAvailabilityFromMessages, resolveCtxReduceAvailability, primeCtxReduceSpawnPermission, ctxReduceSpawnPermissionReadNeeded, spawnAgentFromMessages, spawnAgentFromOpenCodeDb, todowritePermissionDenied, cachedToolPermissionDenied, clearToolPermissionDenied, resolveTodowriteAvailabilityFromMessages, resolveTodowriteAvailability, canConsumeDeferredOnThisPass, hasReclaimRide, reclaimRideLabel, replayCavemanCompression, DegradedPassRefusalError, degradedPassError, ENGINE_RECONNECTING_USER_MESSAGE, EmergencyFailClosedError, replayClearedReasoning, replayStrippedInlineThinking, stripClearedReasoning, snapshotTrailingBlankSourceDecisions, applyFlushedStatuses, stripStructuralNoise, logTransformTiming, hasRecentAssistantCommit, tagMessages, resetDegradedCacheCount2, isSyntheticHeadMessage2, applyTodoSynthesis2, freezeReasoningOnBustingPass2, firstServedDivergenceIndex2, rustModeServedKeyAfterPersistedStrips2, replayRustModeBindingMismatchStrips2, RUST_MARKER_LOCK_SKIP_LOG2, applyRustModeDeferredCompactionMarker2, clearRustModeBoundaryRecord2, runRustModePostprocess2, reconcileMarkerRepresentation2, clearPendingCompactionMarkerAfterSuccessfulDrain2, defaultCompactionMarkerStrategy2, abortSessionFailClosed2, evaluateEmergencyFailClosed2, finalizeMessageRepresentation2, runPostTransformPhase2, checkM0MutationDriftAndSignal2 };