@cortexkit/opencode-magic-context 0.48.0 → 0.49.0

package/dist/v2/{context-sf98kstd.js → context-crbt6p1y.js}

@@ -9,7 +9,7 @@ import {
   resolveLegacyConfigSources,
   getProtectedTokensTierOverrides,
   loadPluginConfigDetailed
-} from "./server-x2g40a71.js";
+} from "./server-19zjmn02.js";
 import {
   getHarness2,
   harnessOwnsOpenCodeStore2
@@ -24,7 +24,7 @@ import {
   log2,
   sessionLog2,
   getLoggerDiagnostics2
-} from "./server-5m3dt5r1.js";
+} from "./server-t4k4qexw.js";
 import {
   hasTrustedAbsoluteWall,
   applyProvenInputFloor,
@@ -36,7 +36,7 @@ import {
   getSdkContextLimit,
   getSdkOutputLimit,
   getModelsDevCacheState
-} from "./server-v06jcv0w.js";
+} from "./server-8k2agx29.js";
 import {
   withContentLanguageDirective,
   parseCron,
@@ -117,7 +117,7 @@ import {
   getAutoSearchHintDecisions,
   appendAutoSearchHintDecision,
   pruneNoteNudgeAnchors,
-  pruneAutoSearchHintDecisions,
+  flushAutoSearchHintDecisionRetirement,
   getPersistedTodoPermissionDenied,
   setPersistedTodoPermissionDenied,
   getPersistedTodoSyntheticAnchor,
@@ -193,6 +193,9 @@ import {
   copySessionStateForClone,
   queueMemoryMutation,
   getMaxMemoryMutationIdForProjects,
+  rememberUnpublishedAutoSearchNoHint,
+  getUnpublishedAutoSearchNoHint,
+  forgetUnpublishedAutoSearchNoHint,
   registerAutoSearchWork,
   gaDatabasePath,
   RAW_MESSAGE_TYPES,
@@ -214,13 +217,6 @@ import {
   readCoordinateGeneration,
   rebaseSessionCoordinatesAsync,
   HiddenCompletionRefusal,
-  USER_FACING_FAILURES,
-  renderUserFacingFailure,
-  userFacingFailureCode,
-  renderCapabilityRefusal,
-  renderDreamFailure,
-  dreamFailureCode,
-  renderEmbeddingFailure,
   getCompartmentEvents,
   USER_MEMORY_CANDIDATE_TTL_MS,
   insertUserMemoryCandidates,
@@ -332,7 +328,7 @@ import {
   startCompartmentAgent,
   setRecompStarting2,
   setRecompTerminal2
-} from "./server-k8x2rbxc.js";
+} from "./server-x4hscabv.js";
 import {
   CANONICAL_DREAM_TASKS,
   DREAM_TASK_CAPABILITIES,
@@ -375,8 +371,9 @@ import {
   openDatabaseAsync,
   isDatabasePersisted,
   getDatabasePersistenceError
-} from "./server-8pyt7hev.js";
+} from "./server-sa8jvrfc.js";
 import {
+  sameProjectDirectory,
   canonicalProjectDirectory,
   setHomeProjectPermission,
   shouldSkipHomeProjectMemory,
@@ -392,7 +389,7 @@ import {
   storedPathBelongsToIdentity,
   beginBootQuietPeriod,
   scheduleAfterBootQuiet
-} from "./server-yczc713m.js";
+} from "./server-xwz4dqh9.js";
 import {
   detectLatestTurnThinkingMismatch,
   isPrefixBoundThinkingModel,
@@ -449,11 +446,12 @@ import {
   getRawSessionStoredMessageCount2,
   readRawSessionMessageIdOrdinalsForRange2,
   readRawSessionMessagePartsById2,
+  readRawSessionBoundaryEndpoints2,
   readRawSessionMessageOrdinalById2,
   readRawSessionMessageById2,
   readSessionChunk2,
   readRawSessionSeedTail2
-} from "./server-2fbhp79z.js";
+} from "./server-4ez8mntn.js";
 import {
   textMentionsRecentCommit,
   hasMeaningfulUserText2,
@@ -464,21 +462,15 @@ import {
   estimateTokens,
   estimateFixedPromptTokens,
   normalizeText
-} from "./server-1r6pmz4f.js";
+} from "./server-kzns2hbz.js";
 import {
-  Priority,
-  AdmissionClass,
-  SocketClosedError,
-  SocketTimeoutError,
-  StaleRouteHandleError,
   SubcClient,
-  isConsumerReconnectTransient,
   connectionFileExists,
   SYNAPSE_DEFAULT_MODEL,
   toSynapseLaneDescriptor,
   formatSynapseLaneDescriptor,
   SynapseEmbeddingProvider
-} from "./server-4k748ke6.js";
+} from "./server-hb6xhh9q.js";
 import {
   getTagIdentityWriteGeneration2,
   Database2,
@@ -492,10 +484,10 @@ import {
   SqliteAcquisitionBusyError2,
   withAsyncPrivilegedWriter2
 } from "./server-kb9nn0a0.js";
-import"./server-k228xhjg.js";
+import"./server-3j4d00kf.js";
 import {
   deleteChunkEmbedBackoffForSession
-} from "./server-ezhze64f.js";
+} from "./server-ss95ky04.js";
 import {
   advanceSessionActivity,
   backfillSessionActivity,
@@ -504,13 +496,14 @@ import {
   isMessageIndexReconciledThrough,
   indexMessagesAfterOrdinal,
   sweepOrphanedOpenCodeMessageIndexes
-} from "./server-sggvvzhb.js";
+} from "./server-1tk82krw.js";
 import {
   stableStringify,
   getTemporalDecisions,
   observeTemporalDecisions,
-  freezeTemporalDecisions
-} from "./server-52awr2mw.js";
+  freezeTemporalDecisions,
+  tagIdentityRevisionKey
+} from "./server-6byqfbqf.js";
 import {
   resolveModelCalibration,
   calibrateBuckets,
@@ -582,6 +575,7 @@ import {
   updateTagStatus2,
   markWhitespaceAssistantTagInert2,
   getInertWhitespaceAssistantTags2,
+  getInertWhitespaceAssistantTagsByNumbers2,
   updateTagDropMode2,
   updateCavemanDepth2,
   updateTagMessageId2,
@@ -603,13 +597,13 @@ import {
   adoptNullOwnerToolTag2,
   getCandidateToolOwners2,
   pickNearestPriorOwner2
-} from "./server-686jg6eb.js";
+} from "./server-c5rrgrcd.js";
 import {
   isRawCompactionSummaryInfo2,
   extractInMemoryMessageViews2,
   buildInMemoryTailRawMessages2,
   runSessionWarmupWorker
-} from "./server-g5r0n3b6.js";
+} from "./server-7h861yms.js";
 import {
   resolveOpenCodeDbPath,
   assertOpenCodeStoreGeneration,
@@ -624,12 +618,12 @@ import {
   latestPersistedMessageForRecovery,
   getMessageTimesFromOpenCodeDb,
   findLastAssistantModelFromOpenCodeDb
-} from "./server-xdfwt6kh.js";
+} from "./server-pj4pjv02.js";
 import {
   getCurrentToolSetHash,
   recordToolDefinition,
   getMeasuredToolDefinitionTokens
-} from "./server-qye6ykf7.js";
+} from "./server-7ekna9zs.js";
 import {
   V2_MEMORY_CATEGORIES,
   CATEGORY_PRIORITY
@@ -644,7 +638,7 @@ import {
   resolveStoredPathWorkspaceIdentity,
   storedPathBelongsToWorkspace,
   computeWorkspaceEpochFingerprint
-} from "./server-e0vdaae2.js";
+} from "./server-v4mewb78.js";
 import"./server-fb3zxn06.js";
 import {
   drainBackgroundBatches,
@@ -673,7 +667,7 @@ import {
   drainCommitBacklogForProject2,
   embedSessionCompartmentChunks2,
   getEmbeddingCoverageStatus2
-} from "./server-7wwc2nga.js";
+} from "./server-jvxzm1jy.js";
 import {
   SESSION_NOTE_CONDITION_ERROR,
   getNoteByIdInScope,
@@ -699,6 +693,12 @@ import {
   createPrimer,
   updatePrimerSupport,
   updatePrimerAnswer,
+  renderUserFacingFailure,
+  userFacingFailureCode,
+  renderCapabilityRefusal,
+  renderDreamFailure,
+  dreamFailureCode,
+  renderEmbeddingFailure,
   recordMemoryMapping,
   recordMemoryVerifications,
   getUnmappedMemoryIds,
@@ -710,14 +710,14 @@ import {
   readGitFileChangeTimesSince,
   verificationFileExists,
   normalizeVerificationFiles
-} from "./server-8tqanswc.js";
+} from "./server-zp53y8js.js";
 import {
   deriveTriggerBudget2,
   deriveHistorianChunkTokens2,
   resolveKnownHistorianContextLimit2,
   resolveHistorianProducerLimits2,
   resolveHistorianContextLimit2
-} from "./server-z2037m6z.js";
+} from "./server-2s9qz6n7.js";
 import {
   isEmbeddingHostBusy2
 } from "./server-qt1qqasc.js";
@@ -728,10 +728,10 @@ import {
 } from "./server-4dhv7mqz.js";
 import {
   getLocalEmbeddingNativeMemoryStats
-} from "./server-vqpf3167.js";
+} from "./server-2s6ayq3t.js";
 import {
   cosineSimilarity
-} from "./server-gjcr4w98.js";
+} from "./server-w32kmdez.js";
 import {
   computeCueContentHash,
   hasMuralCueColumns,
@@ -764,12 +764,23 @@ import {
   drainNotifications2,
   isTuiConnected2
 } from "./server-x8a7jmkh.js";
-import"./server-zxhgvsf9.js";
+import"./server-676xw7at.js";
 import {
   flushIgnoredMessages2,
   sendStatusNotification2
-} from "./server-xxm59eww.js";
+} from "./server-ycw9qqcy.js";
 import {
+  renderSingleStoreMigrationRequiredRefusal,
+  SingleStoreMigrationRequiredError,
+  singleStoreMigrationRequiredFailure,
+  projectNeedsSingleStoreMigration,
+  STORE_AHEAD_OF_BINARY_CODE,
+  storeAheadOfBinaryFailure,
+  TRANSFORM_PAGE_UPLOAD_TIMEOUT_MS,
+  transformColdStartExecuteTimeoutMs,
+  getDefaultSubcConnectionFile,
+  isModuleTransportGenerationChangedResult,
+  SubcModuleTransport,
   indexCommitsForProject,
   embedUnembeddedCommits,
   createUnifiedSearchDiagnostics2,
@@ -777,7 +788,7 @@ import {
   resolveMemoriesByIdsForSearch2,
   unifiedSearch2,
   formatSearchResults2
-} from "./server-psqc7e9n.js";
+} from "./server-q4ph9bwn.js";
 import {
   resolvePromptContext2
 } from "./server-fmsr7v69.js";
@@ -813,7 +824,7 @@ import {
 } from "./server-8ajstryz.js";
 import {
   logSlowWriteTransaction
-} from "./server-aan4q8mx.js";
+} from "./server-3t0q2cqx.js";
 import {
   __toESM,
   __export
@@ -1329,7 +1340,7 @@ __export(exports_util, {
   assignProp: () => assignProp,
   base64ToUint8Array: () => base64ToUint8Array,
   base64urlToUint8Array: () => base64urlToUint8Array,
-  cached: () => cached,
+  cached: () => cached2,
   captureStackTrace: () => captureStackTrace,
   cleanEnum: () => cleanEnum,
   cleanRegex: () => cleanRegex,
@@ -1970,7 +1981,9 @@ function makeToolCompositeKey(ownerMsgId, callId) {
   return `${ownerMsgId}${TOOL_COMPOSITE_KEY_SEP}${callId}`;
 }
 var GET_COUNTER_SQL = `SELECT counter FROM session_meta WHERE session_id = ?`;
-var GET_TAGS_VERSION_SQL = `SELECT tags_version FROM session_meta WHERE session_id = ?`;
+var GET_TAGS_VERSION_SQL = `SELECT
+    (SELECT tags_version FROM session_meta WHERE session_id = ?) AS tags_version,
+    (SELECT value FROM schema_migrations_meta WHERE key = ?) AS identity_revision`;
 var GET_ASSIGNMENTS_SQL = "SELECT message_id, tag_number, type, tool_owner_message_id, byte_size, token_count, input_byte_size, input_token_count FROM tags WHERE session_id = ? ORDER BY tag_number ASC";
 var GET_ASSIGNMENTS_SCOPED_SQL = "SELECT message_id, tag_number, type, tool_owner_message_id, byte_size, token_count, input_byte_size, input_token_count FROM tags WHERE session_id = ? AND tag_number >= ? ORDER BY tag_number ASC";
 var probeTagsVersionStatements = new WeakMap;
@@ -2091,10 +2104,16 @@ function createTagger() {
       const memCounter = heapHolder.counters.get(sessionId) ?? 0;
       const dbMax = getMaxTagNumberBySession2(db, sessionId);
       const next = Math.max(memCounter, dbMax) + 1;
+      const loaded = heapHolder.loadSignatures.get(sessionId);
+      let ownedInitialIdentity;
       try {
         db.transaction(() => {
+          const admitted = loaded?.db === db && loaded.identityRevision === null ? probeSignature(sessionId, db) : null;
+          const initializesOwnedEpoch = admitted !== null && loaded !== undefined && admitted.identityRevision === null && admitted.tagsVersion === loaded.tagsVersion;
           getUpsertCounterStatement(db).run(sessionId, next, getHarness2());
           insertTag2(db, sessionId, messageId, type, byteSize, next, reasoningByteSize, toolName, inputByteSize, toolOwnerMessageId, entryFingerprint, tokenCounts);
+          if (initializesOwnedEpoch)
+            ownedInitialIdentity = probeSignature(sessionId, db).identityRevision;
         }).immediate();
       } catch (error) {
         if (!isUniqueConstraintError(error)) {
@@ -2115,6 +2134,8 @@ function createTagger() {
       const signature = heapHolder.loadSignatures.get(sessionId);
       if (signature?.db === db) {
         signature.tagsVersion += 1;
+        if (signature === loaded && ownedInitialIdentity !== undefined)
+          signature.identityRevision = ownedInitialIdentity;
       }
       if (type === "tool") {
         getSessionToolAccounting(sessionId).set(next, {
@@ -2217,15 +2238,16 @@ function createTagger() {
     return heapHolder.counters.get(sessionId) ?? 0;
   }
   function probeSignature(sessionId, db) {
-    const row = getProbeTagsVersionStatement(db).get(sessionId);
+    const row = getProbeTagsVersionStatement(db).get(sessionId, tagIdentityRevisionKey(sessionId));
     return {
-      tagsVersion: row?.tags_version ?? 0
+      tagsVersion: row?.tags_version ?? 0,
+      identityRevision: row?.identity_revision ?? null
     };
   }
   function initFromDb(sessionId, db, floor = 0) {
     const probe = probeSignature(sessionId, db);
     const cached = heapHolder.loadSignatures.get(sessionId);
-    if (cached !== undefined && cached.db === db && cached.tagsVersion === probe.tagsVersion && cached.floor === floor) {
+    if (cached !== undefined && cached.db === db && cached.tagsVersion === probe.tagsVersion && cached.identityRevision === probe.identityRevision && cached.floor === floor) {
       return;
     }
     const row = db.prepare(GET_COUNTER_SQL).get(sessionId);
@@ -2258,6 +2280,7 @@ function createTagger() {
     heapHolder.loadSignatures.set(sessionId, {
       db,
       tagsVersion: probe.tagsVersion,
+      identityRevision: probe.identityRevision,
       floor
     });
   }
@@ -2265,6 +2288,10 @@ function createTagger() {
     const signature = heapHolder.loadSignatures.get(sessionId);
     return signature?.db === db ? signature.tagsVersion : undefined;
   }
+  function getLoadedTagIdentityRevision(sessionId, db) {
+    const signature = heapHolder.loadSignatures.get(sessionId);
+    return signature?.db === db ? signature.identityRevision : undefined;
+  }
   function cleanup(sessionId) {
     heapHolder.counters.delete(sessionId);
     heapHolder.assignments.delete(sessionId);
@@ -2307,6 +2334,7 @@ function createTagger() {
     getCounter,
     initFromDb,
     getLoadedTagsVersion,
+    getLoadedTagIdentityRevision,
     cleanup,
     getHeapStats
   };
@@ -2619,11 +2647,15 @@ function degradedPassError(site, error) {
 
 // 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.";
+var ENGINE_BUSY_USER_MESSAGE = "Magic Context is still applying the previous context update for this session. Send your message again in a moment.";
 var PROTECTED_TOOL_RESULTS_OVER_LIMIT = "The tool results kept by protected_tools are larger than this model's context window, so this turn was not sent. Lower the protected_tools counts.";
 var PROTECTED_TOOL_RESULTS_OVER_LIMIT_CODE = "protected_tool_results_over_limit";
+var SIGNED_TURN_OVER_LIMIT = "This turn's context is larger than the model's context window even after all of its thinking and reclaimable tool output were removed, so it was not sent. Send a new message or start a new session to continue.";
+var SIGNED_TURN_OVER_LIMIT_CODE = "signed_turn_over_limit";
+var SIGNED_THINKING_RESET_FENCE_FAILED = "Magic Context could not record a thinking reset for this session, so this turn was not sent. Send your message again.";
 function contextRefusalError(message) {
   return new EmergencyFailClosedError(message, {
-    code: message === PROTECTED_TOOL_RESULTS_OVER_LIMIT ? PROTECTED_TOOL_RESULTS_OVER_LIMIT_CODE : undefined
+    code: message === PROTECTED_TOOL_RESULTS_OVER_LIMIT ? PROTECTED_TOOL_RESULTS_OVER_LIMIT_CODE : message === SIGNED_TURN_OVER_LIMIT ? SIGNED_TURN_OVER_LIMIT_CODE : undefined
   });
 }
 function protectedToolRefusal(error) {
@@ -2633,6 +2665,8 @@ function protectedToolRefusal(error) {
     const current = error;
     if (current.code === PROTECTED_TOOL_RESULTS_OVER_LIMIT_CODE)
       return contextRefusalError(PROTECTED_TOOL_RESULTS_OVER_LIMIT);
+    if (current.code === SIGNED_TURN_OVER_LIMIT_CODE)
+      return contextRefusalError(SIGNED_TURN_OVER_LIMIT);
     error = current.cause;
   }
   return;
@@ -2642,6 +2676,11 @@ function outgoingContextRefusal(estimate, limit, protectedToolTokens = 0) {
     return;
   return PROTECTED_TOOL_RESULTS_OVER_LIMIT;
 }
+function signedTurnContextRefusal(estimate, limit) {
+  if (estimate?.refusalGrade !== true || typeof estimate.refusalTokens !== "number" || !Number.isFinite(estimate.refusalTokens) || !limit || !Number.isFinite(limit) || limit <= 0 || estimate.refusalTokens <= limit)
+    return;
+  return SIGNED_TURN_OVER_LIMIT;
+}
 
 class EmergencyFailClosedError extends Error {
   code;
@@ -3025,6 +3064,8 @@ function persistAutoSearchSkip(db, sessionId, messageId, reason = "timeout") {
     ok = outcome.ok && outcome.decision.decision === "no-hint";
   } catch {}
   assertTransformWrite2();
+  if (!ok)
+    rememberUnpublishedAutoSearchNoHint(sessionId, messageId, reason);
   const persistence = Promise.resolve(ok);
   messages.set(messageId, persistence);
   return persistence;
@@ -3650,7 +3691,36 @@ function queueAutoSearchRegistration(db, projectPath, register) {
 function persistAutoSearchDecision(db, sessionId, decision, startedAt) {
   if (performance.now() - startedAt >= AUTO_SEARCH_TIMEOUT_MS)
     return null;
-  return appendAutoSearchHintDecision(db, sessionId, decision);
+  let outcome;
+  try {
+    outcome = appendAutoSearchHintDecision(db, sessionId, decision);
+  } catch (error) {
+    assertTransformWrite2();
+    rememberUnpublishedAutoSearchNoHint(sessionId, decision.messageId, decision.decision === "no-hint" ? decision.reason : "error");
+    if (!isTransientSqliteError2(error))
+      throw error;
+    log2(`[auto-search] decision save hit a busy store for session ${sessionId}; serving without a hint and retrying the save on a later pass: ${error instanceof Error ? error.message : String(error)}`);
+    return { ok: false, kind: "storage-busy" };
+  }
+  if (!outcome.ok) {
+    assertTransformWrite2();
+    rememberUnpublishedAutoSearchNoHint(sessionId, decision.messageId, decision.decision === "no-hint" ? decision.reason : "error");
+  } else if (outcome.decision.decision === "no-hint") {
+    forgetUnpublishedAutoSearchNoHint(sessionId, decision.messageId);
+  }
+  return outcome;
+}
+function retryUnpublishedAutoSearchNoHint(db, sessionId, messageId, startedAt) {
+  const reason = getUnpublishedAutoSearchNoHint(sessionId, messageId);
+  if (reason === undefined)
+    return false;
+  try {
+    persistAutoSearchDecision(db, sessionId, { messageId, decision: "no-hint", reason }, startedAt);
+  } catch (error) {
+    assertTransformWrite2();
+    log2(`[auto-search] frozen omission save still failed for session ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return true;
 }
 async function searchAutoHint(db, sessionId, projectPath, query, options, entry = new URL(new URL(import.meta.url).pathname.endsWith(".ts") ? "./auto-search-worker.ts" : "./auto-search-worker.js", import.meta.url)) {
   return executeAutoSearchWorker(db, sessionId, projectPath, query, options, entry, "search");
@@ -4038,6 +4108,9 @@ async function runAutoSearchHint(args) {
   return coalesceAutoSearchTurn(db, sessionId, userMsgId, async (lifecycleSignal) => {
     if (lifecycleSignal.aborted)
       return AUTO_SEARCH_OK;
+    if (retryUnpublishedAutoSearchNoHint(db, sessionId, userMsgId, startedAt)) {
+      return AUTO_SEARCH_OK;
+    }
     if (wasAutoSearchSkipped(db, sessionId, userMsgId))
       return AUTO_SEARCH_OK;
     const existing = getAutoSearchHintDecisions(db, sessionId);
@@ -4068,7 +4141,10 @@ async function runAutoSearchHint(args) {
         return { ok: false, kind: "timeout" };
       }
       if (!outcome.ok)
-        return { ok: false, kind: "cas-exhaustion" };
+        return {
+          ok: false,
+          kind: outcome.kind === "storage-busy" ? "storage-busy" : "cas-exhaustion"
+        };
       if (outcome.kind === "already-present" && outcome.decision.decision === "hint") {
         appendReminderToUserMessageById(messages, userMsgId, outcome.decision.text);
       }
@@ -4112,8 +4188,11 @@ async function runAutoSearchHint(args) {
         });
       }, startedAt);
     } catch (error) {
-      log2(`[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" };
+      if (lifecycleSignal.aborted)
+        return AUTO_SEARCH_OK;
+      log2(`[auto-search] unified search failed for session ${sessionId} (no-hint frozen for this turn): ${error instanceof Error ? error.message : String(error)}`);
+      const outcome = await writeNoHintAndReconcile("error");
+      return outcome.ok ? { ok: false, kind: "search-failure" } : outcome;
     }
     if (lifecycleSignal.aborted)
       return AUTO_SEARCH_OK;
@@ -4148,6 +4227,8 @@ ${hintText}`;
         return { ok: false, kind: "timeout" };
       }
       if (!outcome.ok) {
+        if (outcome.kind === "storage-busy")
+          return { ok: false, kind: "storage-busy" };
         sessionLog2(sessionId, `auto-search: CAS exhausted for ${userMsgId}; skipping wire append`);
         return { ok: false, kind: "cas-exhaustion" };
       }
@@ -4161,6 +4242,8 @@ ${hintText}`;
         queueAutoSearchBackfill(db, sessionId, options.projectPath, rawPrompt);
     }
   }, () => {
+    if (getUnpublishedAutoSearchNoHint(sessionId, userMsgId) !== undefined)
+      return;
     if (wasAutoSearchSkipped(db, sessionId, userMsgId))
       return;
     const decision = getAutoSearchHintDecisions(db, sessionId).find((entry) => entry.messageId === userMsgId);
@@ -6355,765 +6438,6 @@ function captureOpencodeReasoningBudgetStatus(sessionId, messages, budget, prefi
 // src/hooks/magic-context/maintenance-authority.ts
 var RUST_PARTIAL_RECOMP_REFUSAL = renderCapabilityRefusal("partial_history");
 
-// src/hooks/magic-context/module-transport.ts
-import { realpathSync } from "node:fs";
-import { join } from "node:path";
-
-// src/hooks/magic-context/reply-pages.ts
-import { createHash } from "node:crypto";
-var MAX_REPLY_BYTES = 128 * 1024 * 1024;
-var MAX_PAGE_BYTES = 512 * 1024;
-function fail() {
-  throw Object.assign(new Error("Incomplete or invalid module reply; abandon this pass"), {
-    code: "reply_page_invalid"
-  });
-}
-async function assembleReplyPages(response, fetchPage) {
-  if (!isRecord(response) || !("reply_page" in response))
-    return response;
-  const first = response.reply_page;
-  if (!isRecord(first))
-    fail();
-  const { id, total, bytes } = first;
-  if (typeof id !== "string" || !/^[a-f0-9]{64}$/.test(id) || typeof total !== "number" || !Number.isSafeInteger(total) || total < 2 || total > 4096 || typeof bytes !== "number" || !Number.isSafeInteger(bytes) || bytes <= 0 || bytes > MAX_REPLY_BYTES)
-    fail();
-  const chunks = [];
-  let received = 0;
-  for (let index = 0;index < total; index += 1) {
-    const envelope = index === 0 ? response : await fetchPage(id, index);
-    if (!isRecord(envelope) || !isRecord(envelope.reply_page))
-      fail();
-    const page = envelope.reply_page;
-    if (page.id !== id || page.index !== index || page.total !== total || page.bytes !== bytes || typeof page.data !== "string")
-      fail();
-    if (Buffer.byteLength(JSON.stringify(envelope)) > MAX_PAGE_BYTES)
-      fail();
-    const chunk = Buffer.from(page.data, "utf8");
-    received += chunk.length;
-    if (received > bytes)
-      fail();
-    chunks.push(chunk);
-  }
-  if (received !== bytes)
-    fail();
-  const rebuilt = Buffer.concat(chunks, received);
-  if (createHash("sha256").update(rebuilt).digest("hex") !== id)
-    fail();
-  return JSON.parse(rebuilt.toString("utf8"));
-}
-
-// src/hooks/magic-context/single-store-refusal.ts
-var SINGLE_STORE_MIGRATION_REQUIRED_CODE = "single_store_migration_required";
-function renderSingleStoreMigrationRequiredRefusal() {
-  const failure = USER_FACING_FAILURES.single_store_migration_required;
-  return `${failure.sentence} ${failure.action} (${failure.code})`;
-}
-
-class SingleStoreMigrationRequiredError extends Error {
-  code = SINGLE_STORE_MIGRATION_REQUIRED_CODE;
-  constructor(options) {
-    super(renderSingleStoreMigrationRequiredRefusal(), options);
-    this.name = "SingleStoreMigrationRequiredError";
-  }
-}
-function singleStoreMigrationRequiredFailure(error) {
-  let current = error;
-  const seen = new Set;
-  while (current !== null && typeof current === "object" && !seen.has(current)) {
-    seen.add(current);
-    if (current instanceof SingleStoreMigrationRequiredError)
-      return current;
-    const frame = current;
-    if (frame.code === SINGLE_STORE_MIGRATION_REQUIRED_CODE || frame.code === "single_store_state_split") {
-      return new SingleStoreMigrationRequiredError({ cause: error });
-    }
-    current = frame.cause;
-  }
-  return null;
-}
-function projectNeedsSingleStoreMigration(db, projectPath) {
-  const table = db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'authority_managed'").get();
-  return Boolean(table && db.prepare("SELECT 1 FROM authority_managed WHERE project_path = ?").get(projectPath));
-}
-
-// src/hooks/magic-context/store-ahead-refusal.ts
-var STORE_AHEAD_OF_BINARY_CODE = "store_ahead_of_binary";
-function renderStoreAheadOfBinaryRefusal(versions) {
-  const failure = USER_FACING_FAILURES.store_ahead_of_binary;
-  const sentence = versions ? `Magic Context refused to start: its store (store.db) is at schema v${versions.dbVersion} but this ck-mc build only knows up to v${versions.binaryMax}.` : failure.sentence;
-  return `${sentence} ${failure.action} (${failure.code})`;
-}
-
-class StoreAheadOfBinaryError extends Error {
-  code = STORE_AHEAD_OF_BINARY_CODE;
-  versions;
-  constructor(versions, options) {
-    super(renderStoreAheadOfBinaryRefusal(versions), options);
-    this.name = "StoreAheadOfBinaryError";
-    this.versions = versions;
-  }
-}
-function isRecord3(value) {
-  return value !== null && typeof value === "object";
-}
-function nonNegativeInteger(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
-}
-function versionsFromDetail(detail) {
-  if (!isRecord3(detail))
-    return null;
-  const dbVersion = nonNegativeInteger(detail.db_version);
-  const binaryMax = nonNegativeInteger(detail.binary_max);
-  return dbVersion !== null && binaryMax !== null ? { dbVersion, binaryMax } : null;
-}
-function versionsFromMessage(message) {
-  if (typeof message !== "string")
-    return null;
-  const match = /db_version=(\d+) binary_max=(\d+)/.exec(message) ?? /schema v(\d+) but this ck-mc build only knows up to v(\d+)/.exec(message);
-  if (!match)
-    return null;
-  return { dbVersion: Number(match[1]), binaryMax: Number(match[2]) };
-}
-function storeAheadOfBinaryFailure(error) {
-  let current = error;
-  const seen = new Set;
-  while (isRecord3(current) && !seen.has(current)) {
-    seen.add(current);
-    if (current instanceof StoreAheadOfBinaryError)
-      return current;
-    if (current.code === STORE_AHEAD_OF_BINARY_CODE) {
-      const versions = versionsFromDetail(current.detail) ?? versionsFromMessage(current.message);
-      return new StoreAheadOfBinaryError(versions, { cause: error });
-    }
-    current = current.cause;
-  }
-  return null;
-}
-
-// src/hooks/magic-context/module-transport.ts
-var DEFAULT_MODULE_ID = "magic-context";
-var CONNECT_BACKOFF_INITIAL_MS = 1000;
-var CONNECT_BACKOFF_MAX_MS = 30000;
-var CONNECT_BACKOFF_WAIT_BUDGET_MS = 12000;
-var CONNECT_BACKOFF_WAIT_JITTER_MS = 100;
-var HANDSHAKE_TIMEOUT_MS = 2000;
-var MODULE_SEND_TIMEOUT_MS = 15000;
-var TRANSFORM_PAGE_UPLOAD_TIMEOUT_MS = 5000;
-var TRANSFORM_COLD_START_EXECUTE_TIMEOUT_MS = 15000;
-var TRANSFORM_COLD_START_EXECUTE_TIMEOUT_PER_MESSAGE_MS = 2;
-var TRANSFORM_COLD_START_EXECUTE_TIMEOUT_MAX_MS = 90000;
-function transformColdStartExecuteTimeoutMs(seedMessageCount) {
-  const messages = Number.isSafeInteger(seedMessageCount) ? Math.max(0, seedMessageCount) : 0;
-  return Math.min(TRANSFORM_COLD_START_EXECUTE_TIMEOUT_MAX_MS, TRANSFORM_COLD_START_EXECUTE_TIMEOUT_MS + messages * TRANSFORM_COLD_START_EXECUTE_TIMEOUT_PER_MESSAGE_MS);
-}
-var MAX_WRAPUP_REQUEST_BUDGET_MS = 3800000;
-var SERIAL_LANE_MAX_WAITERS = 16;
-var SERIAL_LANE_MAX_WAITERS_PER_SESSION = 8;
-var SERIAL_LANE_MIN_REMAINING_MS = 25;
-var CANONICAL_ROOT_CACHE_MAX_ENTRIES = 256;
-function getDefaultSubcConnectionFile() {
-  return join(getDataDir(), "cortexkit", "run", "subc-connection.json");
-}
-function errorChainSome(error, predicate) {
-  let current = error;
-  const seen = new Set;
-  while (isRecord(current) && !seen.has(current)) {
-    seen.add(current);
-    if (predicate(current))
-      return true;
-    current = current.cause;
-  }
-  return false;
-}
-function isStaleOrDeadRouteFailure(error) {
-  return errorChainSome(error, (current) => {
-    const code = typeof current.code === "string" ? current.code : "";
-    const name = typeof current.name === "string" ? current.name : "";
-    const message = typeof current.message === "string" ? current.message : "";
-    return [
-      "stale_route_handle",
-      "route_closed",
-      "unknown_channel",
-      "unrecognized_channel",
-      "route_gone"
-    ].includes(code) || name === "StaleRouteHandleError" || /route handle \(\d+,\s*\d+\) is not live on the current connection/i.test(message) || /\b(?:unknown|unrecognized) channel\b/i.test(message);
-  });
-}
-function isDeadlineFailure(error) {
-  if (error instanceof SocketTimeoutError)
-    return true;
-  return errorChainSome(error, (current) => {
-    const code = typeof current.code === "string" ? current.code : "";
-    return ["ETIMEDOUT", "request_deadline", "deadline_exceeded_no_drop_observed"].includes(code);
-  });
-}
-function isConnectionFailure(error) {
-  if (error instanceof SocketClosedError || error instanceof SocketTimeoutError || error instanceof StaleRouteHandleError || isConsumerReconnectTransient(error) || isStaleOrDeadRouteFailure(error)) {
-    return true;
-  }
-  return errorChainSome(error, (current) => {
-    const code = typeof current.code === "string" ? current.code : "";
-    const message = typeof current.message === "string" ? current.message : "";
-    return [
-      "ENOENT",
-      "ECONNREFUSED",
-      "ECONNRESET",
-      "EPIPE",
-      "ETIMEDOUT",
-      "request_deadline",
-      "deadline_exceeded_no_drop_observed",
-      "connection_dropped",
-      "SUBC_CONNECTION_BACKOFF"
-    ].includes(code) || /\bclient closed\b|\bconnection closed\b|\bclosed the connection\b/i.test(message);
-  });
-}
-function routeOpenWithoutAmbientConsumerIdentity(client, target, identity, options = {}) {
-  return client.routeOpen(target, identity, {
-    ...options,
-    consumerIdentity: null
-  });
-}
-function isModuleTransportGenerationChangedResult(value) {
-  return isRecord(value) && value.transport_status === "connection_generation_changed" && typeof value.previous_generation === "number" && typeof value.current_generation === "number";
-}
-function moduleRequestBody(body, method) {
-  if (!isRecord(body))
-    return body;
-  const facade = typeof body.name === "string" && isRecord(body.arguments);
-  return { ...body, ...facade ? {} : { method }, accept_reply_pages: true };
-}
-
-class SubcModuleTransport {
-  connectionFile;
-  moduleId;
-  requestTimeoutMs;
-  routeSessionPrefix;
-  client = null;
-  routes = new Map;
-  routeOpenings = new Map;
-  canonicalRootCache = new Map;
-  sessionLanes = new Map;
-  queuedLaneWaiters = 0;
-  wrapupSessions = new Map;
-  nextProbeMs = 0;
-  connectionPromise = null;
-  backoffMs = CONNECT_BACKOFF_INITIAL_MS;
-  connectionGeneration = 0;
-  stateSyncCapabilityCache = null;
-  getCachedStateSyncCapabilities() {
-    const cached = this.stateSyncCapabilityCache;
-    if (!cached || cached.generation !== this.connectionGeneration)
-      return;
-    return cached.capabilities;
-  }
-  invalidateStateSyncCapabilities() {
-    this.stateSyncCapabilityCache = null;
-  }
-  async stateSyncCapabilities(args) {
-    const cached = this.getCachedStateSyncCapabilities();
-    if (cached)
-      return cached;
-    const response = await this.call({
-      sessionId: args.sessionId,
-      projectRoot: args.projectRoot,
-      method: "session.status",
-      body: { method: "session.status", v: 1, session_id: args.sessionId }
-    });
-    const raw = isRecord(response) ? response : {};
-    const value = isRecord(raw.result) ? raw.result : raw;
-    const epochs = isRecord(value.epochs) ? value.epochs : {};
-    const capabilities = {
-      state_sync_deltas: epochs.state_sync_deltas === true,
-      ...epochs.state_sync_resume === true ? { state_sync_resume: true } : {}
-    };
-    this.stateSyncCapabilityCache = { generation: this.connectionGeneration, capabilities };
-    return capabilities;
-  }
-  constructor(connectionFile, moduleId = DEFAULT_MODULE_ID, requestTimeoutMs = MODULE_SEND_TIMEOUT_MS, routeSessionPrefix = "") {
-    this.connectionFile = connectionFile;
-    this.moduleId = moduleId;
-    this.requestTimeoutMs = requestTimeoutMs;
-    this.routeSessionPrefix = routeSessionPrefix;
-  }
-  deadlineError(detail) {
-    const error = new Error(`module transport deadline expired ${detail}`);
-    error.code = "ETIMEDOUT";
-    return error;
-  }
-  laneTimeoutError() {
-    return this.deadlineError("while queued");
-  }
-  connectionChangedError(detail) {
-    const error = new Error(detail);
-    error.code = "ECONNRESET";
-    return error;
-  }
-  async beforeDeadline(operation, deadlineMs, detail) {
-    operation.catch(() => {});
-    const remainingMs = deadlineMs - Date.now();
-    if (remainingMs <= 0)
-      throw this.deadlineError(detail);
-    let timer;
-    try {
-      return await Promise.race([
-        operation,
-        new Promise((_resolve, reject) => {
-          timer = setTimeout(() => reject(this.deadlineError(detail)), remainingMs);
-        })
-      ]);
-    } finally {
-      if (timer)
-        clearTimeout(timer);
-    }
-  }
-  cleanupLane(sessionId, lane) {
-    if (!lane.active && lane.waiters.length === 0 && this.sessionLanes.get(sessionId) === lane) {
-      this.sessionLanes.delete(sessionId);
-    }
-  }
-  laneRelease(sessionId, lane) {
-    let released = false;
-    return () => {
-      if (released)
-        return;
-      released = true;
-      lane.active = false;
-      this.dispatchNextLaneWaiter(sessionId, lane);
-    };
-  }
-  dispatchNextLaneWaiter(sessionId, lane) {
-    if (lane.active)
-      return;
-    while (lane.waiters.length > 0) {
-      const waiter = lane.waiters.shift();
-      if (!waiter)
-        continue;
-      this.queuedLaneWaiters = Math.max(0, this.queuedLaneWaiters - 1);
-      if (waiter.settled)
-        continue;
-      waiter.settled = true;
-      clearTimeout(waiter.timer);
-      waiter.signal?.removeEventListener("abort", waiter.onAbort);
-      if (waiter.signal?.aborted) {
-        waiter.reject(waiter.signal.reason ?? new Error("module transport call aborted"));
-        continue;
-      }
-      if (waiter.deadlineMs - Date.now() < SERIAL_LANE_MIN_REMAINING_MS) {
-        waiter.reject(this.laneTimeoutError());
-        continue;
-      }
-      lane.active = true;
-      waiter.resolve(this.laneRelease(sessionId, lane));
-      return;
-    }
-    this.cleanupLane(sessionId, lane);
-  }
-  queueFullError() {
-    const error = new Error("module transport queue is full");
-    error.code = "EBUSY";
-    return error;
-  }
-  acquireCorrectnessLane(sessionId, signal, deadlineMs) {
-    if (signal?.aborted) {
-      return Promise.reject(signal.reason ?? new Error("module transport call aborted"));
-    }
-    if (deadlineMs - Date.now() < SERIAL_LANE_MIN_REMAINING_MS) {
-      return Promise.reject(this.laneTimeoutError());
-    }
-    const lane = this.sessionLanes.get(sessionId) ?? { active: false, waiters: [] };
-    this.sessionLanes.set(sessionId, lane);
-    if (!lane.active && lane.waiters.length === 0) {
-      lane.active = true;
-      return Promise.resolve(this.laneRelease(sessionId, lane));
-    }
-    if (this.queuedLaneWaiters >= SERIAL_LANE_MAX_WAITERS || lane.waiters.length >= SERIAL_LANE_MAX_WAITERS_PER_SESSION) {
-      return Promise.reject(this.queueFullError());
-    }
-    return new Promise((resolve, reject) => {
-      const waiter = {};
-      const removeAndReject = (error) => {
-        if (waiter.settled)
-          return;
-        waiter.settled = true;
-        clearTimeout(waiter.timer);
-        signal?.removeEventListener("abort", waiter.onAbort);
-        const index = lane.waiters.indexOf(waiter);
-        if (index >= 0) {
-          lane.waiters.splice(index, 1);
-          this.queuedLaneWaiters = Math.max(0, this.queuedLaneWaiters - 1);
-        }
-        reject(error);
-        this.cleanupLane(sessionId, lane);
-      };
-      waiter.signal = signal;
-      waiter.deadlineMs = deadlineMs;
-      waiter.resolve = resolve;
-      waiter.reject = reject;
-      waiter.settled = false;
-      waiter.onAbort = () => removeAndReject(signal?.reason ?? new Error("module transport call aborted"));
-      waiter.timer = setTimeout(() => removeAndReject(this.laneTimeoutError()), Math.max(0, deadlineMs - Date.now()));
-      signal?.addEventListener("abort", waiter.onAbort, { once: true });
-      lane.waiters.push(waiter);
-      this.queuedLaneWaiters += 1;
-    });
-  }
-  async call(args) {
-    const callStartedAt = performance.now();
-    const timings = {
-      lane: 0,
-      route: 0,
-      encode: 0,
-      issue: 0,
-      responseWait: 0,
-      settle: 0
-    };
-    const wrapupInFlight = (this.wrapupSessions.get(args.sessionId) ?? 0) > 0;
-    const attemptTimeoutMs = args.timeoutMs ?? (args.method === "session.wrapup" || args.method === "session.status" && wrapupInFlight ? MAX_WRAPUP_REQUEST_BUDGET_MS : args.attemptClass === "transform_series_execute" ? TRANSFORM_COLD_START_EXECUTE_TIMEOUT_MS : args.method === "transform" ? Math.min(this.requestTimeoutMs, TRANSFORM_PAGE_UPLOAD_TIMEOUT_MS) : this.requestTimeoutMs);
-    const tracksWrapup = args.method === "session.wrapup";
-    if (tracksWrapup) {
-      this.wrapupSessions.set(args.sessionId, (this.wrapupSessions.get(args.sessionId) ?? 0) + 1);
-    }
-    const finishWrapupTracking = () => {
-      if (!tracksWrapup)
-        return;
-      const remaining = (this.wrapupSessions.get(args.sessionId) ?? 1) - 1;
-      if (remaining > 0)
-        this.wrapupSessions.set(args.sessionId, remaining);
-      else
-        this.wrapupSessions.delete(args.sessionId);
-    };
-    const laneDeadlineMs = Date.now() + attemptTimeoutMs;
-    let releaseLane = () => {};
-    try {
-      const outsideSessionOrder = args.method.startsWith("historian.");
-      if (!args.bypassSessionLane && !outsideSessionOrder) {
-        releaseLane = await this.acquireCorrectnessLane(args.sessionId, args.signal, laneDeadlineMs);
-      }
-    } catch (error) {
-      finishWrapupTracking();
-      if (args.method === "state_sync" && isDeadlineFailure(error)) {
-        const body = isRecord(args.body) ? args.body : {};
-        throw Object.assign(new Error(`state_sync timeout stage=correctness_lane page=${body.seed_batch_index ?? 0}/${body.seed_batch_total ?? 1} series=${body.seed_id ?? "delta"} budget_ms=${attemptTimeoutMs}`), {
-          code: "state_sync_timeout",
-          stage: "correctness_lane",
-          page: body.seed_batch_index ?? 0,
-          pages: body.seed_batch_total ?? 1,
-          series: body.seed_id ?? null,
-          cause: error
-        });
-      }
-      throw error;
-    }
-    timings.lane = performance.now() - callStartedAt;
-    let rejectAbort;
-    const aborted = new Promise((_resolve, reject) => {
-      rejectAbort = reject;
-    });
-    aborted.catch(() => {});
-    const onAbort = () => rejectAbort(args.signal?.reason ?? new Error("module transport call aborted"));
-    args.signal?.addEventListener("abort", onAbort, { once: true });
-    try {
-      for (let attempt = 0;attempt < 2; attempt += 1) {
-        let ensuredRoute = null;
-        let initialResponseReceived = false;
-        try {
-          if (args.signal?.aborted) {
-            throw args.signal.reason ?? new Error("module transport call aborted");
-          }
-          const attemptDeadlineMs = Date.now() + attemptTimeoutMs;
-          const routeStartedAt = performance.now();
-          ensuredRoute = await this.ensureRoute(args.sessionId, args.projectRoot, attemptDeadlineMs, args.signal);
-          if (args.signal?.aborted) {
-            throw args.signal.reason ?? new Error("module transport call aborted");
-          }
-          timings.route += performance.now() - routeStartedAt;
-          const encodeStartedAt = performance.now();
-          const body = args.body instanceof Uint8Array ? args.body : Buffer.from(JSON.stringify(moduleRequestBody(args.body, args.method)));
-          timings.encode += performance.now() - encodeStartedAt;
-          const issueStartedAt = performance.now();
-          const request = ensuredRoute.client.request(ensuredRoute.route, body, {
-            priority: Priority.Background,
-            admissionClass: AdmissionClass.Normal,
-            timeoutMs: Math.max(1, attemptDeadlineMs - Date.now())
-          });
-          timings.issue += performance.now() - issueStartedAt;
-          const waitStartedAt = performance.now();
-          const response = await this.beforeDeadline(Promise.race([request, aborted]), attemptDeadlineMs, "waiting for the module response");
-          timings.responseWait += performance.now() - waitStartedAt;
-          initialResponseReceived = true;
-          if (this.client !== ensuredRoute.client || this.connectionGeneration !== ensuredRoute.generation) {
-            throw this.connectionChangedError("subc connection changed while awaiting the module response");
-          }
-          const pageRoute = ensuredRoute;
-          const assembled = await assembleReplyPages(response, async (id, index) => {
-            if (args.signal?.aborted)
-              throw args.signal.reason;
-            const page = await this.beforeDeadline(Promise.race([
-              pageRoute.client.request(pageRoute.route, Buffer.from(JSON.stringify({
-                method: "reply.page",
-                reply_page_id: id,
-                reply_page_index: index
-              })), {
-                priority: Priority.Background,
-                admissionClass: AdmissionClass.Normal,
-                timeoutMs: Math.max(1, attemptDeadlineMs - Date.now())
-              }),
-              aborted
-            ]), attemptDeadlineMs, "waiting for a module reply page");
-            if (this.client !== pageRoute.client || this.connectionGeneration !== pageRoute.generation) {
-              throw this.connectionChangedError("subc connection changed during reply paging");
-            }
-            return page;
-          });
-          return assembled;
-        } catch (error) {
-          if (args.signal?.aborted)
-            throw args.signal.reason ?? error;
-          const migration = singleStoreMigrationRequiredFailure(error);
-          if (migration)
-            throw migration;
-          const storeAhead = storeAheadOfBinaryFailure(error);
-          if (storeAhead)
-            throw storeAhead;
-          if (args.method === "state_sync" && isDeadlineFailure(error)) {
-            const body = isRecord(args.body) ? args.body : {};
-            throw Object.assign(new Error(`state_sync timeout stage=module_ack page=${body.seed_batch_index ?? 0}/${body.seed_batch_total ?? 1} series=${body.seed_id ?? "delta"} budget_ms=${attemptTimeoutMs}`), {
-              code: "state_sync_timeout",
-              stage: "module_ack",
-              page: body.seed_batch_index ?? 0,
-              pages: body.seed_batch_total ?? 1,
-              series: body.seed_id ?? null,
-              cause: error
-            });
-          }
-          if (args.attemptClass === "transform_series_execute" && isDeadlineFailure(error)) {
-            throw error;
-          }
-          if (isConnectionFailure(error)) {
-            const previousGeneration = ensuredRoute?.generation ?? this.connectionGeneration;
-            if (ensuredRoute) {
-              this.dropRoute(ensuredRoute.routeKey, ensuredRoute.route);
-              this.invalidateConnection(ensuredRoute.client);
-            } else {
-              this.invalidateConnection();
-            }
-            const locallyUnsent = isRecord(error) && error.name === "StaleRouteHandleError" && error.code === "stale_route_handle";
-            if (attempt === 0 && ensuredRoute && !initialResponseReceived && locallyUnsent && !args.generationSensitive) {
-              continue;
-            }
-            if (args.method === "transform") {
-              if (!ensuredRoute)
-                throw error;
-              throw Object.assign(new Error("Transform transport interrupted; abandon this pass"), { code: "transform_transport_interrupted", cause: error });
-            }
-            if (args.generationSensitive && !args.signal?.aborted) {
-              return {
-                transport_status: "connection_generation_changed",
-                previous_generation: previousGeneration,
-                current_generation: this.connectionGeneration
-              };
-            }
-            if (attempt === 0 && !args.signal?.aborted)
-              continue;
-          }
-          throw error;
-        }
-      }
-      throw new Error("module transport route retry exhausted");
-    } finally {
-      args.signal?.removeEventListener("abort", onAbort);
-      finishWrapupTracking();
-      releaseLane();
-      timings.settle = Math.max(0, performance.now() - callStartedAt - timings.lane - timings.route - timings.encode - timings.issue - timings.responseWait);
-      args.onTimings?.(timings);
-    }
-  }
-  async deleteSession(sessionId, projectRoot) {
-    await this.call({
-      sessionId,
-      projectRoot,
-      method: "session.delete",
-      body: { method: "session.delete", v: 1, session_id: sessionId }
-    });
-  }
-  closeSession(sessionId) {
-    const client = this.client;
-    const prefix = `${sessionId}\x00`;
-    const routes = [...this.routes.entries()].filter(([key]) => key.startsWith(prefix));
-    for (const [key, cachedRoute] of routes) {
-      this.routes.delete(key);
-      if (client) {
-        client.closeRoute(cachedRoute.route).catch((error) => {
-          if (this.client === client && isConnectionFailure(error)) {
-            this.invalidateConnection(client);
-          }
-        });
-      }
-    }
-    if (routes.length === 0 && this.sessionLanes.get(sessionId)?.active) {
-      this.invalidateConnection(client);
-    }
-  }
-  async ensureRoute(sessionId, rawProjectRoot, deadlineMs = Date.now() + this.requestTimeoutMs, signal) {
-    const projectRoot = this.canonicalRoot(rawProjectRoot);
-    const routeKey = `${sessionId}\x00${projectRoot}`;
-    const client = await this.ensureConnected(signal);
-    const generation = this.connectionGeneration;
-    const existing = this.routes.get(routeKey);
-    if (existing?.generation === generation) {
-      return { client, route: existing.route, routeKey, generation };
-    }
-    if (existing)
-      this.routes.delete(routeKey);
-    const opening = this.routeOpenings.get(routeKey);
-    if (opening?.client === client && opening.generation === generation) {
-      return await opening.promise;
-    }
-    const promise = (async () => {
-      const target = { kind: "tool_provider", module_id: this.moduleId };
-      const identity = {
-        project_root: projectRoot,
-        harness: getHarness2(),
-        session: `${this.routeSessionPrefix}${sessionId}`
-      };
-      const route = await this.beforeDeadline(routeOpenWithoutAmbientConsumerIdentity(client, target, identity), deadlineMs, "opening the module route");
-      if (this.client !== client || generation !== this.connectionGeneration) {
-        await client.closeRoute(route).catch(() => {
-          return;
-        });
-        throw this.connectionChangedError("subc connection changed while opening module route");
-      }
-      this.routes.set(routeKey, { route, generation });
-      return { client, route, routeKey, generation };
-    })();
-    const routeOpening = { client, generation, promise };
-    this.routeOpenings.set(routeKey, routeOpening);
-    try {
-      return await promise;
-    } finally {
-      if (this.routeOpenings.get(routeKey) === routeOpening) {
-        this.routeOpenings.delete(routeKey);
-      }
-    }
-  }
-  dropRoute(routeKey, route) {
-    const existing = this.routes.get(routeKey);
-    if (!existing || route && existing.route !== route)
-      return;
-    this.routes.delete(routeKey);
-  }
-  canonicalRoot(root) {
-    const cached = this.canonicalRootCache.get(root);
-    if (cached !== undefined) {
-      this.canonicalRootCache.delete(root);
-      this.canonicalRootCache.set(root, cached);
-      return cached;
-    }
-    let resolved = root;
-    try {
-      resolved = realpathSync.native(root);
-    } catch {}
-    this.canonicalRootCache.set(root, resolved);
-    while (this.canonicalRootCache.size > CANONICAL_ROOT_CACHE_MAX_ENTRIES) {
-      const oldestRoot = this.canonicalRootCache.keys().next().value;
-      if (oldestRoot === undefined)
-        break;
-      this.canonicalRootCache.delete(oldestRoot);
-    }
-    return resolved;
-  }
-  connectClient() {
-    return SubcClient.connect({
-      connectionFile: this.connectionFile,
-      handshakeTimeoutMs: HANDSHAKE_TIMEOUT_MS
-    });
-  }
-  backoffActiveError() {
-    const error = new Error(`subc connection backoff active until ${this.nextProbeMs}`);
-    error.code = "SUBC_CONNECTION_BACKOFF";
-    return error;
-  }
-  sleepAbortable(durationMs, signal) {
-    return new Promise((resolve, reject) => {
-      if (signal?.aborted) {
-        reject(signal.reason ?? new Error("module transport call aborted"));
-        return;
-      }
-      const onAbort = () => {
-        clearTimeout(timer);
-        signal?.removeEventListener("abort", onAbort);
-        reject(signal?.reason ?? new Error("module transport call aborted"));
-      };
-      const timer = setTimeout(() => {
-        signal?.removeEventListener("abort", onAbort);
-        resolve();
-      }, Math.max(0, durationMs));
-      signal?.addEventListener("abort", onAbort, { once: true });
-    });
-  }
-  async ensureConnected(signal) {
-    if (this.client)
-      return this.client;
-    if (this.connectionPromise)
-      return await this.connectionPromise;
-    let now = Date.now();
-    if (now < this.nextProbeMs) {
-      const remainingMs = this.nextProbeMs - now;
-      if (remainingMs > CONNECT_BACKOFF_WAIT_BUDGET_MS)
-        throw this.backoffActiveError();
-      const jitterMs = Math.floor(Math.random() * CONNECT_BACKOFF_WAIT_JITTER_MS);
-      await this.sleepAbortable(remainingMs + jitterMs, signal);
-      if (this.client)
-        return this.client;
-      if (this.connectionPromise)
-        return await this.connectionPromise;
-      now = Date.now();
-      if (now < this.nextProbeMs)
-        throw this.backoffActiveError();
-    }
-    const generation = this.connectionGeneration;
-    const connecting = (async () => {
-      let candidate = null;
-      try {
-        candidate = await this.connectClient();
-        if (generation !== this.connectionGeneration) {
-          candidate.close();
-          throw this.connectionChangedError("subc connection attempt was superseded");
-        }
-        this.client = candidate;
-        this.routes.clear();
-        this.backoffMs = CONNECT_BACKOFF_INITIAL_MS;
-        this.nextProbeMs = 0;
-        return candidate;
-      } catch (error) {
-        candidate?.close();
-        if (generation === this.connectionGeneration)
-          this.invalidateConnection();
-        this.nextProbeMs = Date.now() + this.backoffMs;
-        this.backoffMs = Math.min(this.backoffMs * 2, CONNECT_BACKOFF_MAX_MS);
-        throw error;
-      }
-    })();
-    this.connectionPromise = connecting;
-    try {
-      return await connecting;
-    } finally {
-      if (this.connectionPromise === connecting)
-        this.connectionPromise = null;
-    }
-  }
-  invalidateConnection(client = this.client) {
-    if (client && this.client !== client)
-      return;
-    this.connectionGeneration += 1;
-    this.invalidateStateSyncCapabilities();
-    this.client = null;
-    this.routes.clear();
-    this.routeOpenings.clear();
-    client?.close();
-  }
-}
-
 // src/hooks/magic-context/command-handler.ts
 var recompConfirmationBySession = new Map;
 var RECOMP_USAGE = [
@@ -7736,6 +7060,13 @@ function prepareLatestThinkingRecovery(args) {
   }
   return { restore: true, ended: false };
 }
+function endLatestThinkingRecoveryAfterReset(db, sessionId) {
+  const target = getThinkingBindingRecoveryTarget(db, sessionId);
+  if (target?.startsWith(LATEST_THINKING_RESTORE)) {
+    db.prepare("UPDATE session_meta SET thinking_binding_recovery_target = '' WHERE session_id = ? AND thinking_binding_recovery_target = ?").run(sessionId, target);
+  }
+  knownRejectedSessions.delete(sessionId);
+}
 function captureOriginalTurn(messages, parts, setParts) {
   const start = Math.max(0, latestAssistantTurnStart(messages) - 1);
   const originals = messages.slice(start).map((message) => ({ message, parts: clone(parts(message)) }));
@@ -8923,6 +8254,39 @@ function postprocessReplaySnapshot(db, sessionId) {
   };
 }
 
+// src/hooks/magic-context/strict-thinking-prefix.ts
+function servedPrefixMatches(args) {
+  const heads = args.messages?.slice(0, 2);
+  if (!heads || heads.length !== 2 || args.m0Text == null || args.m1Text == null)
+    return false;
+  const text = (message) => {
+    if (!isRecord(message))
+      return;
+    if (typeof message.content === "string")
+      return message.content;
+    const parts = Array.isArray(message.parts) ? message.parts : message.content;
+    if (!Array.isArray(parts))
+      return;
+    return parts.filter(isRecord).filter((part) => part.type === "text").map((part) => String(part.text ?? "")).join("");
+  };
+  if (text(heads[0]) !== args.m0Text || text(heads[1]) !== args.m1Text)
+    return false;
+  const head = heads[0];
+  if (!isRecord(head))
+    return false;
+  const parts = Array.isArray(head.parts) ? head.parts : head.content;
+  if (!Array.isArray(parts))
+    return !args.muralDataUrl;
+  const images = parts.filter(isRecord).filter((part) => part.type === "image" || part.type === "file");
+  if (!args.muralDataUrl)
+    return images.length === 0;
+  if (images.length !== 1)
+    return false;
+  const image = images[0];
+  const url = typeof image.url === "string" ? image.url : typeof image.data === "string" && typeof image.mimeType === "string" ? `data:${image.mimeType};base64,${image.data}` : undefined;
+  return url === args.muralDataUrl;
+}
+
 // src/hooks/magic-context/supersession-reclaim.ts
 var SUPERSESSION_RECENT_MESSAGE_WINDOW = 20;
 function recentSupersessionOwnerMessageIds(db, sessionId) {
@@ -9235,6 +8599,7 @@ 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);
+  const identityRevision = tagger.getLoadedTagIdentityRevision?.(sessionId, db);
   if (tagsVersion === undefined)
     return getInertWhitespaceAssistantTags2(db, sessionId, messageIds);
   let bySession = inertWhitespaceCache.get(db);
@@ -9243,10 +8608,10 @@ function getCachedInertWhitespaceAssistantTags(db, sessionId, tagger, messages)
     inertWhitespaceCache.set(db, bySession);
   }
   const cached = bySession.get(sessionId);
-  if (cached?.tagsVersion === tagsVersion && cached.ownersKey === ownersKey)
+  if (cached?.tagsVersion === tagsVersion && cached.identityRevision === identityRevision && cached.ownersKey === ownersKey)
     return cached.tags;
   const tags = getInertWhitespaceAssistantTags2(db, sessionId, messageIds);
-  bySession.set(sessionId, { tagsVersion, ownersKey, tags });
+  bySession.set(sessionId, { tagsVersion, identityRevision, ownersKey, tags });
   return tags;
 }
 function makeToolOwnerCacheKey(sessionId, callId) {
@@ -10085,6 +9450,8 @@ function applyRustModeThinkingStrips(args, hostEditBeforeNewestThinking) {
   const recoveryMessageIds = new Set;
   let thinkingBindingRecovery = null;
   let proactiveThinkingStrip = null;
+  const signedThinkingReset = args.cacheBustingPass === true && args.moduleSignedThinkingReset === true;
+  const stripProtection = signedThinkingReset ? undefined : args.protectedThinkingMessages;
   {
     try {
       for (const id of getMergedReasoningStrippedIds(args.db, args.sessionId)) {
@@ -10111,26 +9478,31 @@ function applyRustModeThinkingStrips(args, hostEditBeforeNewestThinking) {
     } catch (error) {
       sessionLog2(args.sessionId, "rust thinking binding recovery failed:", error);
     }
-    stripReasoningFromAssistantIds(args.messages, args.resolvedProviderID, recoveryMessageIds, args.protectedThinkingMessages);
-    const moduleBustStrips = !args.activeThinkingTurn && args.cacheBustingPass === true && (args.moduleReasoningTrimOnly !== true || hostEditBeforeNewestThinking);
-    const stripFrom = args.thinkingBindingRecoveryEnabledForModel === true ? proactiveStripStartIndex({ ...args, cacheBustingPass: moduleBustStrips }) : null;
+    stripReasoningFromAssistantIds(args.messages, args.resolvedProviderID, recoveryMessageIds, stripProtection);
+    const moduleBustStrips = signedThinkingReset || !args.activeThinkingTurn && args.cacheBustingPass === true && (args.moduleReasoningTrimOnly !== true || hostEditBeforeNewestThinking);
+    const stripFrom = args.thinkingBindingRecoveryEnabledForModel === true || signedThinkingReset ? proactiveStripStartIndex({ ...args, cacheBustingPass: moduleBustStrips }) : null;
     if (stripFrom !== null) {
+      const stripped = args.messages.slice(stripFrom);
       const outcome = freezeReasoningOnBustingPass({
         db: args.db,
         sessionId: args.sessionId,
-        messages: args.messages.slice(stripFrom),
-        protectedMessages: args.protectedThinkingMessages,
+        messages: stripped,
+        protectedMessages: stripProtection,
         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), args.protectedThinkingMessages);
+      }
+      const removed = signedThinkingReset ? new Set(findReasoningBearingAssistantIds(stripped)) : new Set(outcome.strip?.messageIds ?? []);
+      if (removed.size > 0) {
+        stripReasoningFromAssistantIds(args.messages, args.resolvedProviderID, removed, stripProtection);
       }
     }
   }
-  args.restoreLatestTurnOriginals?.();
+  if (!signedThinkingReset)
+    args.restoreLatestTurnOriginals?.();
   return { thinkingBindingRecovery, proactiveThinkingStrip };
 }
 function runRustModePostprocess(args) {
@@ -10173,7 +9545,7 @@ function runRustModePostprocess(args) {
     appendReminderToUserMessageById(args.messages, anchor.messageId, anchor.text);
   }
   for (const decision of getAutoSearchHintDecisions(args.db, args.sessionId)) {
-    if (decision.decision === "hint") {
+    if (decision.decision === "hint" && getUnpublishedAutoSearchNoHint(args.sessionId, decision.messageId) === undefined) {
       appendReminderToUserMessageById(args.messages, decision.messageId, decision.text);
     }
   }
@@ -10436,7 +9808,7 @@ async function runPostTransformPhase(args) {
   const reasoningMutationExemptMessage = findLatestAssistantReasoningMutationExemptMessage(args.messages);
   const pendingMaterializationAtPassStart = args.pendingMaterializationSessions.has(args.sessionId);
   const deferredMaterializationAtPassStart = args.deferredMaterializationSessions.has(args.sessionId);
-  const isExplicitFlush = pendingMaterializationAtPassStart;
+  let isExplicitFlush = pendingMaterializationAtPassStart;
   const deferredMaterializationWasPending = deferredMaterializationAtPassStart;
   const alreadyRanThisTurn = args.currentTurnId !== null && args.lastHeuristicsTurnId.get(args.sessionId) === args.currentTurnId;
   const forceMaterialization = args.fullFeatureMode && !compactionOff && args.contextUsage.percentage >= args.forceMaterializationPercentage;
@@ -10453,8 +9825,8 @@ async function runPostTransformPhase(args) {
   }
   const activeCompartmentRun = args.canRunCompartments ? getActiveCompartmentRun(args.sessionId) : undefined;
   const compartmentRunning = args.canRunCompartments && !args.awaitedCompartmentRun && activeCompartmentRun !== undefined;
-  const deferredMaterialize = args.canConsumeDeferredLate && deferredMaterializationWasPending;
-  const materializationRequested = isExplicitFlush || deferredMaterialize;
+  let deferredMaterialize = args.canConsumeDeferredLate && deferredMaterializationWasPending;
+  let materializationRequested = isExplicitFlush || deferredMaterialize;
   const m0M1EnabledForFold = args.m0M1 !== undefined && (!!args.m0M1.projectPath || !!args.m0M1.projectDirectory) && (args.fullFeatureMode || compactionOff);
   const frozenThinking = new Set(args.activeThinkingTurn ? getMergedReasoningStrippedIds(args.db, args.sessionId) : []);
   const bindingThinking = new Set([...frozenThinking].filter((id) => id.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX)).map((id) => id.slice(THINKING_BINDING_RECOVERY_FROZEN_PREFIX.length)));
@@ -10466,9 +9838,9 @@ async function runPostTransformPhase(args) {
     bindingIds: bindingThinking,
     removedIds: getReasoningRemovalState(args.db, args.sessionId).messageIds
   }) : new Set;
-  const activeThinkingTurn = retainedThinking.size > 0;
+  let activeThinkingTurn = retainedThinking.size > 0;
   const protectedThinkingMessages = new Set(args.messages.filter((message) => message.parts.some((part) => retainedThinking.has(part))));
-  const newTargets = protectNewTagMutations(args.messages, args.targets, retainedThinking, args.thinkingBindingRecoveryEnabledForModel === true);
+  let newTargets = protectNewTagMutations(args.messages, args.targets, retainedThinking, args.thinkingBindingRecoveryEnabledForModel === true);
   let maxReasoningTag = 0;
   for (const tag of args.messageTagNumbers.values())
     maxReasoningTag = Math.max(maxReasoningTag, tag);
@@ -10478,7 +9850,28 @@ async function runPostTransformPhase(args) {
     if (tag && tag > 0)
       safeReasoningCutoff = Math.min(safeReasoningCutoff, tag - 1);
   }
-  const freezeM0M1 = args.freezeM0M1 === true || activeThinkingTurn && args.thinkingBindingRecoveryEnabledForModel === true;
+  let activeThinkingPrefixHold = args.activeThinkingPrefixHold === true || activeThinkingTurn && args.thinkingBindingRecoveryEnabledForModel === true;
+  let freezeM0M1 = args.freezeM0M1 === true || activeThinkingPrefixHold;
+  let rewritingSignedPrefix = false;
+  let thinkingReleasedForFit = false;
+  const releaseThinkingForRewrite = (forFit = false) => {
+    const stripped = freezeReasoningOnBustingPass({
+      db: args.db,
+      sessionId: args.sessionId,
+      messages: args.messages,
+      alreadyFrozen: bindingThinking
+    });
+    if (stripped.persistenceFailed)
+      throw new Error("Cannot persist signed thinking omission before prefix rewrite");
+    retainedThinking.clear();
+    protectedThinkingMessages.clear();
+    activeThinkingTurn = false;
+    activeThinkingPrefixHold = false;
+    freezeM0M1 = args.directoryPrefixHold === true;
+    newTargets = args.targets;
+    rewritingSignedPrefix = true;
+    thinkingReleasedForFit ||= forFit;
+  };
   const foldDueDecision = m0M1EnabledForFold && args.m0M1 && !freezeM0M1 ? mustMaterialize({
     db: args.db,
     sessionId: args.sessionId,
@@ -10498,6 +9891,7 @@ async function runPostTransformPhase(args) {
   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;
+  const servedBeforeFirstRender = firstRenderBust ? args.readLastServedMessages?.() : null;
   let foldExecutedThisPass = false;
   let foldBustsServedPrefixThisPass = false;
   let publishedM1RefreshedThisPass = false;
@@ -10515,7 +9909,7 @@ async function runPostTransformPhase(args) {
     m1Bytes: args.sessionMeta.cachedM1Bytes ?? null,
     muralDataUrl: args.sessionMeta.cachedM0MuralDataUrl ?? null
   };
-  if ((foldDueDecision.value || softRefreshOpportunity) && m0M1EnabledForFold && args.m0M1) {
+  if ((foldDueDecision.value || softRefreshOpportunity || firstRenderBust && activeThinkingPrefixHold) && m0M1EnabledForFold && args.m0M1) {
     let committedFoldBustsServedPrefix;
     try {
       const previousM1 = args.sessionMeta.cachedM1Bytes?.toString("utf8");
@@ -10540,7 +9934,12 @@ async function runPostTransformPhase(args) {
         onFoldPrepare: () => {
           const conversions = prepareLegacyToolSkeletonConversions(args.db, args.sessionId, args.targets);
           return (db, rendered) => {
-            const bustsPrefix = foldBustsServedPrefix(foldDueDecision.reason, servedPrefixBeforeFold, rendered);
+            const bustsPrefix = activeThinkingPrefixHold ? !servedPrefixMatches({
+              messages: servedBeforeFirstRender,
+              m0Text: rendered.m0Bytes.toString(),
+              m1Text: rendered.m1Bytes.toString(),
+              muralDataUrl: rendered.muralDataUrl
+            }) : foldBustsServedPrefix(foldDueDecision.reason, servedPrefixBeforeFold, rendered);
             if (bustsPrefix) {
               if (!conversions.isCurrent(db)) {
                 throw new MaterializeContentionError({
@@ -10557,6 +9956,9 @@ async function runPostTransformPhase(args) {
         }
       });
       preparedPrefix = foldResult;
+      if (activeThinkingPrefixHold && firstRenderBust && committedFoldBustsServedPrefix) {
+        releaseThinkingForRewrite();
+      }
       prefixPreflightFailed = foldResult.materializationContentionRetryExhausted === true;
       foldExecutedThisPass = foldExecutesThisPass(foldDueDecision.value || softRefreshOpportunity, foldResult.m0RematerializedThisPass);
       foldBustsServedPrefixThisPass = foldExecutedThisPass && (committedFoldBustsServedPrefix ?? true);
@@ -10592,6 +9994,15 @@ async function runPostTransformPhase(args) {
   }
   logTransformTiming(args.sessionId, "pp.prefixPreflight", tPostprocessSetup, `foldExecuted=${foldExecutedThisPass} m1Refreshed=${publishedM1RefreshedThisPass}`);
   const tPassDecisions = performance.now();
+  const frontToolCandidates = args.tags.filter((tag) => tag.type === "tool" && tag.status === "active" && args.targets.get(tag.tagNumber)?.canDrop?.());
+  if (activeThinkingPrefixHold && (args.forceSignedRebuildForFit || args.contextUsage.percentage >= 95 && frontToolCandidates.length > 0 && frontToolCandidates.every((tag) => newTargets.get(tag.tagNumber)?.thinkingRewriteProtected === true))) {
+    releaseThinkingForRewrite(true);
+  }
+  if (activeThinkingPrefixHold) {
+    isExplicitFlush = false;
+    deferredMaterialize = false;
+    materializationRequested = false;
+  }
   const shouldReadPendingOps = !compactionOff && (materializationRequested || publishedM1RefreshedThisPass || args.schedulerDecision === "execute" || forceMaterialization || foldExecutedThisPass || firstRenderBust || compartmentRunning);
   const pendingOps = shouldReadPendingOps ? getPendingOps(args.db, args.sessionId) : [];
   const hasPendingUserOps = pendingOps.length > 0;
@@ -10601,7 +10012,8 @@ async function runPostTransformPhase(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 heldIdleExpiryRebuild = activeThinkingPrefixHold && args.m0M1?.hardSignals?.cacheExpired === true;
+  const idleExpiryRebuild = (!freezeM0M1 || activeThinkingPrefixHold) && args.m0M1?.hardSignals?.cacheExpired === true;
   const rideSignals = {
     subagentExecute: !args.fullFeatureMode && args.schedulerDecision === "execute",
     hardFold: foldBustsServedPrefixThisPass || firstRenderBust || idleExpiryRebuild,
@@ -10609,15 +10021,16 @@ async function runPostTransformPhase(args) {
     explicitFlush: isExplicitFlush || deferredMaterialize && !prefixPreflightFailed,
     publishedHistory: publishedM1RefreshedThisPass || !m0M1EnabledForFold && (args.pendingCompartmentInjection?.compartmentCount ?? 0) > 0 && (args.historyRebuiltThisPass || args.rebuiltHistoryFromInitialPrepare || args.canConsumeDeferredLate && args.deferredHistoryWasPendingAtPassStart)
   };
-  const publishedWorkDrainAllowed = !compactionOff && hasReclaimRide(rideSignals);
+  const publishedWorkDrainAllowed = !compactionOff && (!activeThinkingPrefixHold || firstRenderBust || idleExpiryRebuild || emergencyDropEligible) && hasReclaimRide(rideSignals);
   const shouldApplyPendingOps = publishedWorkDrainAllowed;
-  const shouldRunHeuristics = !compactionOff && hasReclaimRide(rideSignals) && (rideSignals.publishedHistory || materializationRequested || forceMaterialization || foldBustsServedPrefixThisPass || firstRenderBust || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
+  const shouldRunHeuristics = publishedWorkDrainAllowed && (rideSignals.publishedHistory || materializationRequested || forceMaterialization || foldBustsServedPrefixThisPass || firstRenderBust || heldIdleExpiryRebuild || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
   const isCacheBustingPass = publishedWorkDrainAllowed;
+  const canEditWholePrefix = isCacheBustingPass && !activeThinkingPrefixHold;
   const previousTemporalDecisions = args.temporalCandidates && !compactionOff ? new Map([
     ...args.temporalObservedDecisions ?? [],
     ...getTemporalDecisions(args.db, args.sessionId, args.temporalReplayIds ?? args.temporalCandidates.keys())
   ]) : undefined;
-  const temporalDecisions = args.temporalCandidates && !compactionOff ? isCacheBustingPass ? new Map([
+  const temporalDecisions = args.temporalCandidates && !compactionOff ? canEditWholePrefix ? new Map([
     ...previousTemporalDecisions ?? [],
     ...freezeTemporalDecisions(args.db, args.sessionId, args.temporalCandidates)
   ]) : previousTemporalDecisions : undefined;
@@ -10775,7 +10188,7 @@ async function runPostTransformPhase(args) {
         wordRules: args.cavemanTextCompression.wordRules
       } : undefined;
       const heuristicTags = shouldApplyPendingOps ? getActiveTagsBySession2(args.db, args.sessionId) : args.tags;
-      const emergencyRewriteAlreadyPriced = pendingOpsDidMutate || foldBustsServedPrefixThisPass || args.historyRebuiltThisPass || args.compartmentInjectionRebuiltFromDb || args.rebuiltHistoryFromInitialPrepare;
+      const emergencyRewriteAlreadyPriced = pendingOpsDidMutate || foldBustsServedPrefixThisPass || firstRenderBust || heldIdleExpiryRebuild || args.historyRebuiltThisPass || args.compartmentInjectionRebuiltFromDb || args.rebuiltHistoryFromInitialPrepare;
       if (emergencyDropEligible && emergencyRewriteAlreadyPriced && getEmergencyInputSample(args.db, args.sessionId) > 0) {
         clearEmergencyDropSample(args.db, args.sessionId);
       }
@@ -10836,7 +10249,7 @@ async function runPostTransformPhase(args) {
         }
       }
       const reasoningEstimates = tryGetReasoningTokenEstimatesByMessage2(args.db, args.sessionId, sessionDecisionCalibration(args.db, args.sessionId).proseRatio);
-      const budgetCutoff = routineCleanupApplied && reasoningEstimates ? Math.min(safeReasoningCutoff, opencodeReasoningBudgetCutoff({
+      const budgetCutoff = routineCleanupApplied && !activeThinkingPrefixHold && reasoningEstimates ? Math.min(safeReasoningCutoff, opencodeReasoningBudgetCutoff({
         messages: args.messages,
         messageTagNumbers: args.messageTagNumbers,
         budget: args.keepReasoningTokens ?? DEFAULT_KEEP_REASONING_TOKENS,
@@ -10858,7 +10271,7 @@ async function runPostTransformPhase(args) {
         replayStrippedInlineThinking(args.messages, args.messageTagNumbers, persistedInlineWatermark);
       }
       let removedReasoningMessages = 0;
-      if (routineCleanupApplied && reasoningRemovalSelectable && reasoningRemovalReadable) {
+      if (routineCleanupApplied && !prefixBoundModel && reasoningRemovalSelectable && reasoningRemovalReadable) {
         const newIds = selectReasoningRemovals({
           messages: args.messages,
           messageTagNumbers: args.messageTagNumbers,
@@ -10975,7 +10388,7 @@ async function runPostTransformPhase(args) {
       logTransformTiming(args.sessionId, "toolReclaim.select", tReclaimSelect, `targets=${autoReclaimTargetCount}`);
       if (syntheticPendingOps.length > 0) {
         const tReclaimApply = performance.now();
-        autoReclaimDidMutate = applyPendingOperations(args.sessionId, args.db, args.targets, args.protectedTagIds, undefined, [], syntheticPendingOps, editMarkerTagIds, (reduction) => droppedTokenReductions.push(reduction));
+        autoReclaimDidMutate = applyPendingOperations(args.sessionId, args.db, newTargets, args.protectedTagIds, undefined, [], syntheticPendingOps, editMarkerTagIds, (reduction) => droppedTokenReductions.push(reduction));
         logTransformTiming(args.sessionId, "toolReclaim.apply", tReclaimApply);
         if (autoReclaimDidMutate) {
           droppedCount += syntheticPendingOps.length;
@@ -11028,7 +10441,7 @@ async function runPostTransformPhase(args) {
       const t8 = performance.now();
       const frozenStaleReduceIds = replaySnapshot.staleReduceStrippedIds;
       const staleReduceResult = dropStaleReduceCalls(args.messages, frozenStaleReduceIds, {
-        detect: isCacheBustingPass,
+        detect: canEditWholePrefix,
         protectedCount: args.protectedCount,
         protectedCallIds: new Set(args.tags.filter((tag) => protectedToolTags.has(tag.tagNumber)).map((tag) => tag.messageId)),
         onFirstApplication: recordFirstApplicationAt
@@ -11047,7 +10460,7 @@ async function runPostTransformPhase(args) {
       const tImg = performance.now();
       const frozenImageIds = replaySnapshot.processedImageStrippedIds;
       const imageResult = stripProcessedImages(args.messages, frozenImageIds, {
-        detect: isCacheBustingPass && args.watermark > 0,
+        detect: canEditWholePrefix && args.watermark > 0,
         watermark: args.watermark,
         messageTagNumbers: args.messageTagNumbers,
         onFirstApplication: recordFirstApplicationAt
@@ -11291,7 +10704,7 @@ async function runPostTransformPhase(args) {
       messages: args.messages,
       fullFeatureMode: args.fullFeatureMode,
       compactionOff,
-      isCacheBustingPass,
+      isCacheBustingPass: canEditWholePrefix,
       sessionMeta: args.sessionMeta,
       todowriteAvailability: args.todowriteAvailability,
       client: args.client,
@@ -11358,7 +10771,7 @@ async function runPostTransformPhase(args) {
     autoSearchHintAppendedThisPass = autoSearchCompletedThisPass && countAutoSearchHints(args.db, args.sessionId) !== autoSearchHintsBefore;
     logTransformTiming(args.sessionId, "pp.autoSearchHint", tAutoSearch);
   }
-  if (args.fullFeatureMode && isCacheBustingPass) {
+  if (args.fullFeatureMode && canEditWholePrefix) {
     const visibleIds = new Set;
     for (const message of args.messages) {
       if (typeof message.info?.id === "string") {
@@ -11366,15 +10779,15 @@ async function runPostTransformPhase(args) {
       }
     }
     const prunedAnchors = pruneNoteNudgeAnchors(args.db, args.sessionId, visibleIds);
-    const prunedDecisions = pruneAutoSearchHintDecisions(args.db, args.sessionId, visibleIds);
-    if (prunedAnchors > 0 || prunedDecisions > 0) {
-      sessionLog2(args.sessionId, `sticky-injection GC: pruned ${prunedAnchors} note-nudge anchor(s), ${prunedDecisions} auto-search decision(s)`);
+    flushAutoSearchHintDecisionRetirement(args.db, args.sessionId, visibleIds);
+    if (prunedAnchors > 0) {
+      sessionLog2(args.sessionId, `sticky-injection GC: pruned ${prunedAnchors} note-nudge anchor(s)`);
     }
   }
   const materializeReason = m0MaterializeReason ?? (explicitMaterializedSuccessfully ? "explicit_flush" : null);
   const materialized = m0RematerializedThisPass || explicitMaterializedSuccessfully || deferredMaterializedSuccessfully;
   let bustedThisPass = firstApplicationEdits.any || firstRenderBust || pendingOpsDidMutate || heuristicOrReasoningDidMutate || autoReclaimDidMutateThisPass || convertedToolSkeletonsDidMutate || m0RematerializedThisPass || m0M1InjectedThisPass && historyWasConsumedThisPass || historyWasConsumedThisPass;
-  const proactiveThinkingStripPermitted = isCacheBustingPass;
+  const proactiveThinkingStripPermitted = isCacheBustingPass && !activeThinkingPrefixHold;
   const tFrozenDecisions = performance.now();
   if (reasoningMutationTargetUnknown) {
     const reasoningCandidates = args.reasoningByMessage.size > 0 ? args.reasoningByMessage.keys() : args.messages;
@@ -11425,7 +10838,7 @@ async function runPostTransformPhase(args) {
           sessionLog2(args.sessionId, "thinking binding recovery: persistence failed; leaving the bound blocks intact");
         }
       }
-      if (canUseEmptySentinels && isCacheBustingPass) {
+      if (canUseEmptySentinels && canEditWholePrefix) {
         const candidates = findMergedReasoningStripDecisions(args.messages, args.resolvedProviderID, mergedReasoningStrippedIds, {
           mutationExemptMessage: reasoningMutationExemptMessage,
           protectedMessages: protectedThinkingMessages
@@ -11471,7 +10884,7 @@ async function runPostTransformPhase(args) {
       recordFirstApplicationAt(message, partIndex);
     }
   };
-  if (isCacheBustingPass && trailingBlankDecisions.size > 0) {
+  if (canEditWholePrefix && trailingBlankDecisions.size > 0) {
     const visibleMessageIds = new Set(args.messages.flatMap((message) => typeof message.info.id === "string" ? [message.info.id] : []));
     const poisonedKeepIds = [];
     for (const [id, decision] of trailingBlankDecisions) {
@@ -11576,7 +10989,7 @@ async function runPostTransformPhase(args) {
       }
     }
   }
-  const prefixEditBesidesReasoningTrim = firstRenderBust || materializationRequested || explicitMaterializedSuccessfully || deferredMaterializedSuccessfully || foldBustsServedPrefixThisPass || publishedM1RefreshedThisPass || m0RematerializedThisPass || m0M1InjectedThisPass && historyWasConsumedThisPass || historyWasConsumedThisPass || pendingOpsDidMutate || heuristicOrReasoningEditBesidesTrim || emergency || autoReclaimDidMutateThisPass || convertedToolSkeletonsDidMutate || deferredClearedMarkerRetires || noteNudgeAppendedThisPass || todoAnchorMovedThisPass || autoSearchHintAppendedThisPass || dropModeSwitchesThisPass || firstApplicationEdits.beforeNewerThinking;
+  const prefixEditBesidesReasoningTrim = firstRenderBust || heldIdleExpiryRebuild || materializationRequested || explicitMaterializedSuccessfully || deferredMaterializedSuccessfully || foldBustsServedPrefixThisPass || publishedM1RefreshedThisPass || m0RematerializedThisPass || m0M1InjectedThisPass && historyWasConsumedThisPass || historyWasConsumedThisPass || pendingOpsDidMutate || heuristicOrReasoningEditBesidesTrim || emergency || autoReclaimDidMutateThisPass || convertedToolSkeletonsDidMutate || deferredClearedMarkerRetires || noteNudgeAppendedThisPass || todoAnchorMovedThisPass || autoSearchHintAppendedThisPass || dropModeSwitchesThisPass || firstApplicationEdits.beforeNewerThinking;
   let proactiveThinkingStrip = null;
   if (!compactionOff && args.thinkingBindingRecoveryEnabledForModel === true && proactiveThinkingStripPermitted && prefixEditBesidesReasoningTrim) {
     const outcome = freezeReasoningOnBustingPass({
@@ -11623,8 +11036,9 @@ async function runPostTransformPhase(args) {
   const removedReasoningParts = reasoningRemovalEnabled ? removeReasoningParts(args.messages, removedReasoningIds, args.resolvedProviderID) : 0;
   const reasoningStatusRatio = sessionDecisionCalibration(args.db, args.sessionId).proseRatio;
   captureOpencodeReasoningBudgetStatus(args.sessionId, args.messages, args.keepReasoningTokens ?? DEFAULT_KEEP_REASONING_TOKENS, prefixBoundModel, reasoningStatusRatio);
-  args.restoreLatestTurnOriginals?.();
-  if (args.restoreLatestTurnOriginals) {
+  if (!rewritingSignedPrefix)
+    args.restoreLatestTurnOriginals?.();
+  if (!rewritingSignedPrefix && args.restoreLatestTurnOriginals) {
     refreshReasoningRemovalUnion();
     if (replayCommittedVisibleDrops()) {
       finalizeMessageRepresentation(args.messages, args.resolvedProviderID, finalizeOptions);
@@ -11748,7 +11162,8 @@ async function runPostTransformPhase(args) {
     bustedThisPass,
     prefixTrimStatus: deliveredPrefix?.prefixTrimStatus ?? null,
     thinkingBindingRecovery,
-    proactiveThinkingStrip
+    proactiveThinkingStrip,
+    thinkingReleasedForFit
   };
 }
 function checkM0MutationDriftAndSignal(args) {
@@ -11812,7 +11227,7 @@ class StorageBusyRefusalError extends Error {
 }
 
 // src/hooks/magic-context/system-prompt-hash.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash } from "node:crypto";
 var MAGIC_CONTEXT_MARKER = "## Magic Context";
 var SYSTEM_PROMPT_GUIDANCE_SEPARATOR = `
 
@@ -11912,7 +11327,7 @@ function createSystemPromptHashHandler(deps) {
     }
     const stickyDate = stickyDateBySession.get(sessionId);
     const stableCandidate = currentDate && stickyDate && currentDate !== stickyDate ? liveSystemContent.replace(DATE_PATTERN_ALL, stickyDate) : liveSystemContent;
-    const stableCandidateHash = createHash2("md5").update(promptSurfaceHashMaterial(stableCandidate, promptSurface.preset)).digest("hex");
+    const stableCandidateHash = createHash("md5").update(promptSurfaceHashMaterial(stableCandidate, promptSurface.preset)).digest("hex");
     const contentOrPresetChanged = hasPersistedHash && stableCandidateHash !== previousHash;
     const dateMayAdvance = isCacheBusting || idleCacheExpired || contentOrPresetChanged;
     if (currentDate && !stickyDate) {
@@ -11932,7 +11347,7 @@ function createSystemPromptHashHandler(deps) {
 `);
     if (!availability.frozen || !modelKey)
       return;
-    const currentHash = createHash2("md5").update(promptSurfaceHashMaterial(systemContent, promptSurface.preset)).digest("hex");
+    const currentHash = createHash("md5").update(promptSurfaceHashMaterial(systemContent, promptSurface.preset)).digest("hex");
     if (!sessionMetaEarly) {
       return;
     }
@@ -12053,7 +11468,8 @@ function writeRustTransformDecision(args) {
     droppedTokens: 0,
     droppedCount: 0,
     inputTokens: args.inputTokens,
-    bustedThisPass: mapped.bustedThisPass
+    bustedThisPass: mapped.bustedThisPass,
+    lkgFrozenReleaseReason: args.lkgFrozenReleaseReason
   });
 }
 function clearOpenCodePendingTransformDecision(sessionId) {
@@ -12214,7 +11630,7 @@ function commitCompactionModeRecord(db, sessionId, record) {
 }
 
 // src/hooks/magic-context/lkg-persist.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 function parseStringArray(value) {
   if (typeof value !== "string")
     return null;
@@ -12328,7 +11744,7 @@ function rememberFingerprint(db, sessionId, fingerprint) {
   saved.set(sessionId, fingerprint);
 }
 function slotFingerprint(slot) {
-  return createHash3("sha256").update(JSON.stringify([
+  return createHash2("sha256").update(JSON.stringify([
     slot.jsonPrefix,
     slot.inputIdSeq,
     slot.inputContentDigests,
@@ -13141,6 +12557,7 @@ var PASS_DEGRADATION_EFFECTS = {
   "auto-search-timeout": "served",
   "auto-search-search-failure": "served",
   "auto-search-cas-exhaustion": "served",
+  "auto-search-storage-busy": "served",
   "auto-search-internal-failure": "served",
   "thinking-binding-recovery-persistence-failure": "changes-request",
   "merged-reasoning-strip-persistence-failure": "changes-request",
@@ -13180,7 +12597,7 @@ function createPassOutcome() {
 }
 
 // src/hooks/magic-context/rust-mode-transform.ts
-import { createHash as createHash6, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash5, randomUUID as randomUUID2 } from "node:crypto";
 
 // src/features/magic-context/memory/single-store-embedding-drain.ts
 function isWatermarkRow(row) {
@@ -13244,7 +12661,7 @@ function advanceEmbeddedWatermark(db, projectPath, upTo) {
 }
 
 // src/features/magic-context/mural/source-revision.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 var statements = new WeakMap;
 function muralSourceRevision(db, projectPath) {
   let statement = statements.get(db);
@@ -13261,7 +12678,7 @@ function muralSourceRevision(db, projectPath) {
     statements.set(db, statement);
   }
   const row = statement.get(projectPath, Date.now());
-  return createHash4("sha256").update(row.revision).digest("hex");
+  return createHash3("sha256").update(row.revision).digest("hex");
 }
 
 // src/features/magic-context/install-instance-id.ts
@@ -13284,11 +12701,11 @@ function ensureInstallInstanceId(db) {
 var CLAIM_START_MARGIN_MS = 5000;
 var IDLE_INTERVAL_MS = 30000;
 var IDLE_POLLS_AFTER_PASS = 3;
-function isRecord4(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
 function refusalOf(response) {
-  if (!isRecord4(response))
+  if (!isRecord3(response))
     return "malformed_response";
   if (response.ok === true)
     return null;
@@ -13296,11 +12713,11 @@ function refusalOf(response) {
   return typeof refusal === "string" && refusal.length > 0 ? refusal : "malformed_response";
 }
 function readPendingRuns(response) {
-  if (!isRecord4(response) || !Array.isArray(response.runs))
+  if (!isRecord3(response) || !Array.isArray(response.runs))
     return [];
   const runs = [];
   for (const entry of response.runs) {
-    if (!isRecord4(entry))
+    if (!isRecord3(entry))
       continue;
     const runId = entry.run_id;
     const sessionId = entry.session_id;
@@ -13317,9 +12734,9 @@ function readPendingRuns(response) {
   return runs;
 }
 function readClaim(response) {
-  if (!isRecord4(response) || response.ok !== true)
+  if (!isRecord3(response) || response.ok !== true)
     return null;
-  const prompt = isRecord4(response.prompt) ? response.prompt : {};
+  const prompt = isRecord3(response.prompt) ? response.prompt : {};
   const runId = response.run_id;
   const sessionId = response.session_id;
   const token = response.token;
@@ -13527,17 +12944,19 @@ class HistorianHostRunner {
     });
   }
   async execute(claim, abort) {
+    const invocations = [];
     const budgetMs = Math.max(1, claim.awaitBudgetMs);
     const heartbeat = this.startHeartbeat(claim, abort);
     const cancelDeadline = this.schedule(() => {
       abort.abort(new Error(`historian host run ${claim.runId} exceeded its await budget`));
     }, budgetMs);
     try {
-      const completion = await this.runCompletion(claim, budgetMs, abort.signal);
+      const completion = await this.runCompletion(claim, budgetMs, abort.signal, invocations);
       if (heartbeat.claimOver)
         return;
       await this.report(claim, {
-        output: { text: completion.text, length_capped: completion.lengthCapped }
+        output: { text: completion.text, length_capped: completion.lengthCapped },
+        invocations
       });
     } catch (error) {
       if (heartbeat.claimOver) {
@@ -13552,7 +12971,8 @@ class HistorianHostRunner {
         error: {
           code: failureCode(error, abort.signal.aborted),
           message: describeError2(error)
-        }
+        },
+        invocations
       });
     } finally {
       cancelDeadline();
@@ -13628,7 +13048,7 @@ class HistorianHostRunner {
     });
     return failure ? `${key}: ${failure}` : null;
   }
-  async runCompletion(claim, budgetMs, signal) {
+  async runCompletion(claim, budgetMs, signal, invocations) {
     const binding = this.deps.openExecutor(claim.sessionId);
     if (!binding) {
       throw new Error(`no hidden completion carrier for session ${claim.sessionId}`);
@@ -13655,6 +13075,31 @@ class HistorianHostRunner {
     });
     let promptSettled = false;
     let attemptStartedAt = Date.now();
+    const withVariant = (model) => {
+      const qualifier = this.deps.resolveVariant?.(model);
+      return qualifier ? { model, qualifier } : model;
+    };
+    let attemptModel = head;
+    let attemptRecorded = false;
+    const recordAttempt = (completion, error) => {
+      if (attemptRecorded)
+        return;
+      attemptRecorded = true;
+      const split = attemptModel.indexOf("/");
+      const token = (value) => typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+      invocations.push({
+        provider_id: completion?.providerId ?? (split >= 0 ? attemptModel.slice(0, split) : null),
+        model_id: completion?.modelId ?? (split >= 0 ? attemptModel.slice(split + 1) : attemptModel),
+        started_at: attemptStartedAt,
+        ended_at: Date.now(),
+        status: error ? signal.aborted ? "aborted" : failedInvocationStatus(error) : completion?.text?.trim() ? "completed" : "empty",
+        input_tokens: token(completion?.usage.input),
+        output_tokens: token(completion?.usage.output),
+        cache_read_tokens: token(completion?.usage.cacheRead),
+        cache_write_tokens: token(completion?.usage.cacheWrite),
+        error: error ? describeError2(error) : null
+      });
+    };
     try {
       if (!handle.id)
         throw new Error("hidden completion carrier returned no session id");
@@ -13664,33 +13109,53 @@ class HistorianHostRunner {
         body: {
           agent: "historian",
           system: claim.system,
-          ...modelBodyField(head),
+          ...modelBodyField(withVariant(head)),
           parts: [{ type: "text", text: claim.user, synthetic: true }]
         }
       }, {
         transport: Object.assign((request) => {
           const model = request.body?.model;
           const key = model?.providerID && model?.modelID ? `${model.providerID}/${model.modelID}` : head;
-          const failure = this.admissionFailure(claim, key);
-          if (failure)
-            throw new Error(failure);
           attemptStartedAt = Date.now();
-          return executor.attempt(handle, request);
+          attemptModel = key;
+          attemptRecorded = false;
+          try {
+            const failure = this.admissionFailure(claim, key);
+            if (failure)
+              throw new Error(failure);
+            return executor.attempt(handle, request).catch((error) => {
+              recordAttempt(undefined, error);
+              throw error;
+            });
+          } catch (error) {
+            recordAttempt(undefined, error);
+            throw error;
+          }
         }, { childSessionId: handle.childSessionId }),
         timeoutMs: attemptMs,
         signal,
-        fallbackModels: rest,
+        fallbackModels: rest.map(withVariant),
         callContext: `historian-host:${claim.runId}`,
-        fetchOutput: () => withinAttempt(executor.collect(handle, 50), attemptStartedAt + attemptMs - Date.now(), attemptMs, signal),
+        fetchOutput: () => withinAttempt(executor.collect(handle, 50), attemptStartedAt + attemptMs - Date.now(), attemptMs, signal).catch((error) => {
+          recordAttempt(undefined, error);
+          throw error;
+        }),
         validateOutput: (completion) => {
           const text = completion.text;
-          if (!text)
-            throw new Error("historian host completion returned no output");
+          if (!text?.trim()) {
+            const error = new Error("historian host completion returned no output");
+            recordAttempt(completion, error);
+            throw error;
+          }
+          recordAttempt(completion);
           return { text, lengthCapped: completion.lengthCapped === true };
         }
       });
       promptSettled = true;
       return run.validated;
+    } catch (error) {
+      recordAttempt(undefined, error);
+      throw error;
     } finally {
       await executor.close(handle, {
         promptSettled,
@@ -13717,7 +13182,7 @@ class HistorianHostRunner {
       this.log(`report for ${claim.runId} refused: ${refusal}`);
       return;
     }
-    const publish = isRecord4(response) && typeof response.publish === "string" ? response.publish : "immediate";
+    const publish = isRecord3(response) && typeof response.publish === "string" ? response.publish : "immediate";
     this.log(`report for ${claim.runId} accepted (publish=${publish})`);
   }
   schedule(callback, delayMs) {
@@ -13756,6 +13221,7 @@ function createHistorianHostRunner(args) {
     enabled: args.enabled,
     ...args.maxOutputTokens !== undefined ? { maxOutputTokens: args.maxOutputTokens } : {},
     ...args.attemptTimeoutMs ? { attemptTimeoutMs: args.attemptTimeoutMs } : {},
+    ...args.resolveVariant ? { resolveVariant: args.resolveVariant } : {},
     ...args.now ? { now: args.now } : {},
     ...args.log ? { log: args.log } : {},
     ...args.idleIntervalMs !== undefined ? { idleIntervalMs: args.idleIntervalMs } : {},
@@ -14624,17 +14090,41 @@ function resolveSharedCompartmentBoundaries(db, sessionId) {
   const rows = db.prepare("SELECT sequence, start_message, end_message, COALESCE(start_message_id, '') AS start_message_id, COALESCE(end_message_id, '') AS end_message_id, start_block_index, end_block_index FROM compartments WHERE session_id=? ORDER BY sequence").all(sessionId);
   if (rows.every((row) => row.start_block_index !== null && row.end_block_index !== null))
     return [];
-  const ordinals = readRawSessionMessageIdOrdinalsForRange2(sessionId, 1, Number.MAX_SAFE_INTEGER);
-  const rawById = new Map;
+  let ordinalBasis;
+  const ordinals = () => {
+    ordinalBasis ??= readRawSessionMessageIdOrdinalsForRange2(sessionId, 1, Number.MAX_SAFE_INTEGER);
+    return ordinalBasis;
+  };
+  const stored = readRawSessionBoundaryEndpoints2(sessionId, rows.flatMap((row) => [row.start_message_id, row.end_message_id]), rows.flatMap((row) => row.end_block_index === null ? [row.end_message_id] : []));
+  const providerRaw = new Map;
   const endpoint = (rawId, blockIndex, edge) => {
-    if (!rawById.has(rawId))
-      rawById.set(rawId, readRawSessionMessagePartsById2(sessionId, rawId));
-    const raw = rawById.get(rawId) ?? null;
-    const ordinal = raw?.id === rawId ? ordinals.get(rawId) ?? null : null;
-    const block = blockIndex !== null ? blockIndex : edge === "start" ? 0 : moduleRawBlockMappings(raw).at(-1)?.blockIndex ?? 0;
-    return { ordinal, id: `${rawId}#${block}`, raw };
-  };
-  const idsByOrdinal = rows.some((row) => !row.start_message_id || !row.end_message_id) ? new Map([...ordinals].map(([id, ordinal]) => [ordinal, id])) : null;
+    const needsLastBlock = blockIndex === null && edge === "end";
+    let ordinal;
+    let createdAt;
+    let lastBlockIndex = 0;
+    if (stored === null) {
+      if (!providerRaw.has(rawId))
+        providerRaw.set(rawId, readRawSessionMessagePartsById2(sessionId, rawId));
+      const raw = providerRaw.get(rawId) ?? null;
+      ordinal = raw?.id === rawId ? ordinals().get(rawId) ?? null : null;
+      createdAt = raw?.createdAt;
+      if (needsLastBlock)
+        lastBlockIndex = moduleRawBlockMappings(raw).at(-1)?.blockIndex ?? 0;
+    } else {
+      let read = stored.get(rawId);
+      if (read === undefined || needsLastBlock && read && read.lastBlockIndex === undefined) {
+        read = readRawSessionBoundaryEndpoints2(sessionId, [rawId], needsLastBlock ? [rawId] : [])?.get(rawId) ?? null;
+        stored.set(rawId, read);
+      }
+      ordinal = read?.ordinal ?? null;
+      createdAt = read?.createdAt;
+      if (needsLastBlock)
+        lastBlockIndex = read?.lastBlockIndex ?? 0;
+    }
+    const block = blockIndex !== null ? blockIndex : edge === "start" ? 0 : lastBlockIndex;
+    return { ordinal, id: `${rawId}#${block}`, createdAt };
+  };
+  const idsByOrdinal = rows.some((row) => !row.start_message_id || !row.end_message_id) ? new Map([...ordinals()].map(([id, ordinal]) => [ordinal, id])) : null;
   const endpoints = rows.map((row) => ({
     start: endpoint(row.start_message_id, row.start_block_index, "start"),
     end: endpoint(row.end_message_id, row.end_block_index, "end")
@@ -14666,9 +14156,9 @@ function resolveSharedCompartmentBoundaries(db, sessionId) {
       start = resolveMissingId(row.start_message_id, row.start_block_index, startOrdinal, "start");
     if (!row.end_message_id)
       end = resolveMissingId(row.end_message_id, row.end_block_index, endOrdinal, "end");
-    const dates = typeof start.raw?.createdAt === "number" && typeof end.raw?.createdAt === "number" ? {
-      start_date: formatDate(start.raw.createdAt),
-      end_date: formatDate(end.raw.createdAt)
+    const dates = typeof start.createdAt === "number" && typeof end.createdAt === "number" ? {
+      start_date: formatDate(start.createdAt),
+      end_date: formatDate(end.createdAt)
     } : { start_date: null, end_date: null };
     return {
       sequence: row.sequence,
@@ -15662,6 +15152,9 @@ class FrozenReplayOverProvenLimitRefusal extends Error {
   }
 }
 var RUST_FAILURE_PARK_THRESHOLD = 3;
+var TRANSFORM_FINAL_PAGE_ABANDONED_CODE = "transform_final_page_abandoned";
+var TRANSFORM_PAGE_IN_PROGRESS_CODE = "authority_transform_page_in_progress";
+var RUST_IN_PROGRESS_PARK_EXEMPTION_MS = 5 * 60000;
 var RUST_PARK_RETRY_INTERVAL = 5;
 var RUST_EMERGENCY_WALL_PCT = 95;
 var RUST_PARK_PROBE_PRESSURE_BYPASS_PCT = 90;
@@ -15738,20 +15231,20 @@ function rustWireCacheEstimatedBytes(cache) {
   }
   return bytes;
 }
-function isRecord5(value) {
+function isRecord4(value) {
   return value !== null && typeof value === "object";
 }
 function moduleFailureCode(error) {
   let current = error;
   const seen = new Set;
-  while (isRecord5(current) && !seen.has(current)) {
+  while (isRecord4(current) && !seen.has(current)) {
     seen.add(current);
     if (typeof current.code === "string" && current.code.length > 0)
       return current.code;
     if (typeof current.message === "string") {
       try {
         const detail = JSON.parse(current.message);
-        if (isRecord5(detail) && typeof detail.code === "string")
+        if (isRecord4(detail) && typeof detail.code === "string")
           return detail.code;
       } catch {}
     }
@@ -15762,6 +15255,10 @@ function moduleFailureCode(error) {
 function isNonRetryableStateSyncFailure(error) {
   return moduleFailureCode(error) === "state_sync_non_retryable";
 }
+function isModuleBusyWithAbandonedTransform(error) {
+  const code = moduleFailureCode(error);
+  return code === TRANSFORM_FINAL_PAGE_ABANDONED_CODE || code === TRANSFORM_PAGE_IN_PROGRESS_CODE;
+}
 function replaceMessagesInPlace(output, next) {
   const target = output.messages;
   if (target !== next)
@@ -15769,9 +15266,9 @@ function replaceMessagesInPlace(output, next) {
   return target;
 }
 function messageInfo2(value) {
-  if (!isRecord5(value))
+  if (!isRecord4(value))
     return {};
-  return isRecord5(value.info) ? value.info : value;
+  return isRecord4(value.info) ? value.info : value;
 }
 function messageIdOf2(message) {
   const id = messageInfo2(message).id;
@@ -15832,10 +15329,10 @@ function messageCacheSignature(message) {
   const parts = Array.isArray(message.parts) ? message.parts : [];
   const serializedParts = JSON.stringify(parts) ?? "null";
   const serializedMessage = JSON.stringify(message) ?? "null";
-  return `${messageIdOf2(message) ?? ""}:${parts.length}:${Buffer.byteLength(serializedParts)}:${createHash6("sha256").update(serializedMessage).digest("hex")}`;
+  return `${messageIdOf2(message) ?? ""}:${parts.length}:${Buffer.byteLength(serializedParts)}:${createHash5("sha256").update(serializedMessage).digest("hex")}`;
 }
 function advanceWireFingerprint(previous, encoded) {
-  return createHash6("sha256").update(previous).update("\\0").update(JSON.stringify(encoded) ?? "null").digest("hex");
+  return createHash5("sha256").update(previous).update("\\0").update(JSON.stringify(encoded) ?? "null").digest("hex");
 }
 function buildWireFingerprint(encoded) {
   let fingerprint = "rust-wire-v1";
@@ -15941,7 +15438,7 @@ function isSyntheticUserMessage(message) {
   if (!message || messageInfo2(message).role !== "user" || !Array.isArray(message.parts)) {
     return false;
   }
-  return message.parts.length > 0 && message.parts.every((part) => isRecord5(part) && (part.synthetic === true || part.ignored === true));
+  return message.parts.length > 0 && message.parts.every((part) => isRecord4(part) && (part.synthetic === true || part.ignored === true));
 }
 function observeSyntheticTurn(state, messages) {
   const newest = newestUserMessage(messages);
@@ -15961,25 +15458,25 @@ function observeSyntheticTurn(state, messages) {
 function assertNativeBoundary(output, sessionId, boundaryId) {
   const first = output.find((message) => messageInfo2(message).role !== "system");
   const info = messageInfo2(first);
-  const parts = isRecord5(first) && Array.isArray(first.parts) ? first.parts : [];
-  const synthetic = parts.length > 0 && parts.every((part) => isRecord5(part) && part.synthetic === true);
+  const parts = isRecord4(first) && Array.isArray(first.parts) ? first.parts : [];
+  const synthetic = parts.length > 0 && parts.every((part) => isRecord4(part) && part.synthetic === true);
   if (info.role === "user" && info.sessionID === sessionId && synthetic)
     return;
   const headSummary = output.slice(0, 3).map((message) => {
     const mi = messageInfo2(message);
-    const mParts = isRecord5(message) && Array.isArray(message.parts) ? message.parts : [];
-    const partDesc = mParts.slice(0, 5).map((part) => isRecord5(part) ? `${String(part.type)}${part.synthetic === true ? "" : "!"}` : "?").join(",");
+    const mParts = isRecord4(message) && Array.isArray(message.parts) ? message.parts : [];
+    const partDesc = mParts.slice(0, 5).map((part) => isRecord4(part) ? `${String(part.type)}${part.synthetic === true ? "" : "!"}` : "?").join(",");
     return `role=${String(mi.role)} sid=${mi.sessionID === sessionId ? "ok" : String(mi.sessionID ?? "absent")} id=${String(mi.id ?? "-").slice(0, 24)} parts=[${partDesc}]`;
   });
   throw new Error(`rust transform wire invariant failed: boundary=${boundaryId} expected a synthetic m0 user message scoped to session ${sessionId}; head: ${headSummary.join(" | ")}`);
 }
 function responseValue(response) {
-  if (isRecord5(response) && (response.ok === false || response.isError === true || response.error != null)) {
+  if (isRecord4(response) && (response.ok === false || response.isError === true || response.error != null)) {
     throw new RustTransformProtocolError("rust transform wire invariant failed: error envelope cannot permit host mutations");
   }
-  if (isRecord5(response) && isRecord5(response.result))
+  if (isRecord4(response) && isRecord4(response.result))
     return response.result;
-  if (isRecord5(response))
+  if (isRecord4(response))
     return response;
   throw new Error("module transform returned a non-object response");
 }
@@ -16011,7 +15508,7 @@ function stateSyncInputSignature(args) {
 function isTransformPageAttemptMismatch(error) {
   let current = error;
   const seen = new Set;
-  while (isRecord5(current) && !seen.has(current)) {
+  while (isRecord4(current) && !seen.has(current)) {
     seen.add(current);
     const code = typeof current.code === "string" ? current.code : "";
     const message = typeof current.message === "string" ? current.message : "";
@@ -16038,7 +15535,7 @@ function mirrorRustRenderedMemoryIds(args) {
 function modelFromMessages(messages) {
   for (let index = messages.length - 1;index >= 0; index -= 1) {
     const info = messages[index]?.info;
-    const model = isRecord5(info?.model) ? info.model : undefined;
+    const model = isRecord4(info?.model) ? info.model : undefined;
     if (typeof model?.providerID === "string" && typeof model.modelID === "string") {
       return { providerID: model.providerID, modelID: model.modelID };
     }
@@ -16059,6 +15556,7 @@ function ensureState(states, sessionId) {
       passesSincePark: 0,
       warningSent: false,
       forceFullWire: false,
+      transformInProgressSinceMs: null,
       ordinalMemoAnchor: null,
       ordinalMemoStoredCount: null,
       ordinalMemoCanonicalCount: 0,
@@ -16192,8 +15690,8 @@ function shouldDisarmRustEmergencyRecovery(input) {
   return null;
 }
 function directiveTextOf(response) {
-  const directives = isRecord5(response.host_directives) ? response.host_directives : undefined;
-  const channel2 = isRecord5(directives?.channel2_nudge) ? directives.channel2_nudge : undefined;
+  const directives = isRecord4(response.host_directives) ? response.host_directives : undefined;
+  const channel2 = isRecord4(directives?.channel2_nudge) ? directives.channel2_nudge : undefined;
   return typeof channel2?.text === "string" && channel2.text.length > 0 ? channel2.text : undefined;
 }
 function isNeedFullSync(response) {
@@ -16203,18 +15701,18 @@ var TODO_HEAD_ANCHOR_ID2 = "__magic_context_todo_head__";
 function syntheticTodoAnchorFromNative(messages) {
   for (let index = 0;index < messages.length; index += 1) {
     const message = messages[index];
-    if (!isRecord5(message) || !Array.isArray(message.parts))
+    if (!isRecord4(message) || !Array.isArray(message.parts))
       continue;
-    const part = message.parts.find((candidate) => isRecord5(candidate) && candidate.syntheticTodoMarker === true);
-    if (!isRecord5(part) || typeof part.callID !== "string")
+    const part = message.parts.find((candidate) => isRecord4(candidate) && candidate.syntheticTodoMarker === true);
+    if (!isRecord4(part) || typeof part.callID !== "string")
       continue;
-    const state = isRecord5(part.state) ? part.state : undefined;
-    const input = state && isRecord5(state.input) ? state.input : undefined;
+    const state = isRecord4(part.state) ? part.state : undefined;
+    const input = state && isRecord4(state.input) ? state.input : undefined;
     const stateJson = normalizeTodoStateJson(input?.todos);
     if (stateJson === null || computeSyntheticCallId(stateJson) !== part.callID)
       continue;
     const previous = messages[index - 1];
-    const previousInfo = isRecord5(previous) && isRecord5(previous.info) ? previous.info : undefined;
+    const previousInfo = isRecord4(previous) && isRecord4(previous.info) ? previous.info : undefined;
     const messageId = previousInfo && typeof previousInfo.id === "string" && previousInfo.id.length > 0 ? previousInfo.id : TODO_HEAD_ANCHOR_ID2;
     return { callId: part.callID, messageId, stateJson };
   }
@@ -16243,7 +15741,7 @@ function hasNativeResponseContent(response) {
     return true;
   }
   const delta = response.native_messages_delta;
-  return isRecord5(delta) && Array.isArray(delta.messages);
+  return isRecord4(delta) && Array.isArray(delta.messages);
 }
 function applyNativeMessagesVerbatim(output, response, previous) {
   const nativeMessages = response.native_messages;
@@ -16257,7 +15755,7 @@ function applyNativeMessagesVerbatim(output, response, previous) {
     return replaceMessagesInPlace(output, nativeMessages);
   }
   const delta = response.native_messages_delta;
-  if (!isRecord5(delta) || !Array.isArray(delta.messages)) {
+  if (!isRecord4(delta) || !Array.isArray(delta.messages)) {
     throw new Error("rust transform response omitted native_messages");
   }
   const replaceFrom = delta.replace_from;
@@ -16458,7 +15956,14 @@ function createRustModeTransform(deps, options) {
         sessionDirectory: (sessionId) => deps.sessionDirectoryBySession?.get(sessionId) ?? deps.directory ?? process.cwd(),
         enabled: () => deps.historianHostRunnerEnabled !== false,
         ...deps.historianMaxOutputTokens !== undefined ? { maxOutputTokens: deps.historianMaxOutputTokens } : {},
-        attemptTimeoutMs: () => deps.resolveHistorianRun?.().timeoutMs ?? deps.historianTimeoutMs
+        attemptTimeoutMs: () => deps.resolveHistorianRun?.().timeoutMs ?? deps.historianTimeoutMs,
+        resolveVariant: (model) => {
+          const run = deps.resolveHistorianRun?.();
+          return resolvedHistorianModelVariants({
+            historianModel: run?.model ?? deps.historianModel,
+            fallbackModels: run?.fallbackModels ?? deps.fallbackModels
+          })[model];
+        }
       });
     } catch (error) {
       hostRunner = undefined;
@@ -16497,7 +16002,7 @@ function createRustModeTransform(deps, options) {
   };
   const callModule = async (args, attemptTimeoutMs = args.timeoutMs ?? timeoutMs, allowTimeoutRetry = true) => {
     const controller = new AbortController;
-    const body = isRecord5(args.body) ? args.body : {};
+    const body = isRecord4(args.body) ? args.body : {};
     const timeoutError = args.method === "state_sync" ? Object.assign(new Error(`state_sync timeout stage=module_ack page=${body.seed_batch_index ?? 0}/${body.seed_batch_total ?? 1} series=${body.seed_id ?? "delta"} budget_ms=${attemptTimeoutMs}`), {
       code: "state_sync_timeout",
       stage: "module_ack",
@@ -16528,18 +16033,24 @@ function createRustModeTransform(deps, options) {
         clock.clearTimeout(timer);
         sessionLog2(args.sessionId, "rust transform deadline: waiting up to 45000ms for identical final-page completion");
         const completionDeadline = clock.now() + 45000;
+        const abandoned = (cause) => Object.assign(new Error(timeoutError.message, { cause }), {
+          code: TRANSFORM_FINAL_PAGE_ABANDONED_CODE
+        });
         for (;; ) {
           const remaining = completionDeadline - clock.now();
           if (remaining <= 0)
-            throw timeoutError;
+            throw abandoned(timeoutError);
           try {
             return await callModule(args, remaining, false);
           } catch (retryError) {
-            if (moduleFailureCode(retryError) !== "authority_transform_page_in_progress")
+            if (moduleFailureCode(retryError) !== TRANSFORM_PAGE_IN_PROGRESS_CODE) {
+              if (retryError instanceof Error && /timed out|deadline/i.test(retryError.message))
+                throw abandoned(retryError);
               throw retryError;
+            }
             const wait = Math.min(250, completionDeadline - clock.now());
             if (wait <= 0)
-              throw timeoutError;
+              throw abandoned(retryError);
             await new Promise((resolve) => clock.setTimeout(resolve, wait));
           }
         }
@@ -16557,7 +16068,7 @@ function createRustModeTransform(deps, options) {
     const probeAfterMs = options.stallProbeAfterMsForTests ?? RUST_STALL_PROBE_AFTER_MS;
     const probeTimeoutMs = options.healthProbeTimeoutMsForTests ?? RUST_HEALTH_PROBE_TIMEOUT_MS;
     const originalAttemptId = randomUUID2();
-    const originalBody = isRecord5(args.body) ? { ...args.body, attempt_id: originalAttemptId } : args.body;
+    const originalBody = isRecord4(args.body) ? { ...args.body, attempt_id: originalAttemptId } : args.body;
     const original = callModule({ ...args, body: originalBody }, attemptTimeoutMs);
     if (attemptTimeoutMs <= probeAfterMs)
       return original;
@@ -16595,7 +16106,24 @@ function createRustModeTransform(deps, options) {
     sessionLog2(args.sessionId, `rust transform still pending after healthy probe original_attempt=${originalAttemptId} stall_ms=${clock.now() - startedAtMs}; duplicate resend suppressed`);
     return original;
   };
+  const inProgressRunWithinBound = (state) => state.transformInProgressSinceMs !== null && clock.now() - state.transformInProgressSinceMs <= RUST_IN_PROGRESS_PARK_EXEMPTION_MS;
+  const exemptInProgressRefusal = (state, error) => {
+    if (moduleFailureCode(error) !== TRANSFORM_PAGE_IN_PROGRESS_CODE) {
+      state.transformInProgressSinceMs = null;
+      return false;
+    }
+    state.transformInProgressSinceMs ??= clock.now();
+    return inProgressRunWithinBound(state);
+  };
   const markFailure = (sessionId, state, error) => {
+    if (isModuleBusyWithAbandonedTransform(error)) {
+      state.forceFullWire = true;
+    }
+    if (exemptInProgressRefusal(state, error)) {
+      state.failureCount += 1;
+      sessionLog2(sessionId, "rust transform deferred; the module is still applying an earlier transform of this session; attempting LKG replay:", error);
+      return;
+    }
     state.consecutiveFailures = isNonRetryableStateSyncFailure(error) ? Math.max(RUST_FAILURE_PARK_THRESHOLD, state.consecutiveFailures + 1) : state.consecutiveFailures + 1;
     state.failureCount += 1;
     sessionLog2(sessionId, "rust transform failed; attempting LKG replay:", error);
@@ -16944,6 +16472,7 @@ function createRustModeTransform(deps, options) {
     let requestInputTokens = 0;
     let decision = "error";
     let materializeReason = "none";
+    let frozenReleaseReason = null;
     let schedulerDecision;
     let responseCommitted;
     let responsePrefixBustPermitted;
@@ -17043,6 +16572,9 @@ function createRustModeTransform(deps, options) {
       if (moduleFailureCode(cause) === "transform_transport_interrupted") {
         throw new EmergencyFailClosedError(ENGINE_RECONNECTING_USER_MESSAGE, { cause });
       }
+      if (isModuleBusyWithAbandonedTransform(cause)) {
+        throw new EmergencyFailClosedError(moduleFailureCode(cause) === TRANSFORM_PAGE_IN_PROGRESS_CODE ? ENGINE_BUSY_USER_MESSAGE : ENGINE_RECONNECTING_USER_MESSAGE, { cause });
+      }
       if (!deps.compactionOff && isTransientSqliteError2(cause)) {
         throw new StorageBusyRefusalError(cause, "rust-mode-transform");
       }
@@ -17181,7 +16713,8 @@ function createRustModeTransform(deps, options) {
           decision,
           materializeReason: materializeReason === "none" ? null : materializeReason,
           inputTokens: requestInputTokens,
-          tsMs: passObservedAtMs
+          tsMs: passObservedAtMs,
+          lkgFrozenReleaseReason: applied && served ? frozenReleaseReason ?? undefined : undefined
         });
       }
     };
@@ -17192,12 +16725,12 @@ function createRustModeTransform(deps, options) {
       servedFrom = typeof response.served_from === "string" ? response.served_from : "unknown";
       schedulerDecision = typeof response.scheduler_decision === "string" ? response.scheduler_decision : undefined;
       schedulerDeferReason = typeof response.scheduler_defer_reason === "string" ? response.scheduler_defer_reason : undefined;
-      const historian = isRecord5(response.historian) ? response.historian : undefined;
+      const historian = isRecord4(response.historian) ? response.historian : undefined;
       historianNoFire = typeof historian?.no_fire === "string" ? historian.no_fire : undefined;
       historianCanonicalCause = typeof historian?.canonical_cause === "string" ? historian.canonical_cause : undefined;
       materializeReason = typeof response.materialize_reason === "string" && response.materialize_reason.length > 0 ? response.materialize_reason : "none";
       identityDelta = Array.isArray(response.identity_delta) ? response.identity_delta.filter((component) => typeof component === "string" && component.length > 0) : [];
-      const timings = isRecord5(response.timings) ? response.timings : undefined;
+      const timings = isRecord4(response.timings) ? response.timings : undefined;
       const applyOnceTotal = timings?.total;
       const handlerTotal = timings?.handler_total;
       moduleElapsedMs = typeof handlerTotal === "number" && Number.isFinite(handlerTotal) ? handlerTotal : typeof applyOnceTotal === "number" && Number.isFinite(applyOnceTotal) ? applyOnceTotal : 0;
@@ -17499,9 +17032,9 @@ function createRustModeTransform(deps, options) {
       const todoCalls = wireDelta ? new Map(state.todoCallSignatures) : new Map;
       for (const [offset, message] of todoCandidates.entries()) {
         const id = messageIdOf2(message) ?? `index:${todoStart + offset}`;
-        const parts = message.parts?.filter((part) => isRecord5(part) && part.type === "tool" && part.tool === "todowrite");
+        const parts = message.parts?.filter((part) => isRecord4(part) && part.type === "tool" && part.tool === "todowrite");
         if (parts?.length) {
-          todoCalls.set(id, createHash6("sha256").update(JSON.stringify(parts)).digest("hex"));
+          todoCalls.set(id, createHash5("sha256").update(JSON.stringify(parts)).digest("hex"));
         } else {
           todoCalls.delete(id);
         }
@@ -17672,7 +17205,7 @@ function createRustModeTransform(deps, options) {
       logStage(sessionId, "wireBuild", wireBuildStartedAt, timings, wireDelta ? `mode=tail_delta input=${encodedInput.length}` : "mode=full");
       const sendTransformSeries = async (payload, detail = "") => {
         const pagingStartedAt = performance.now();
-        const fullWire = !isRecord5(payload.tail_delta);
+        const fullWire = !isRecord4(payload.tail_delta);
         const pages = buildPagedModuleTransformPayloads(payload, options.modulePageMaxBytes, true);
         timings.paging += performance.now() - pagingStartedAt;
         const seedMessageCount = Array.isArray(payload.input) ? payload.input.length : Array.isArray(payload.messages) ? payload.messages.length : 0;
@@ -17730,6 +17263,7 @@ function createRustModeTransform(deps, options) {
         }
         if (!response)
           throw new Error("rust module returned no transform response");
+        state.transformInProgressSinceMs = null;
         return { response };
       };
       let transformSeriesRestarted = false;
@@ -17756,7 +17290,7 @@ function createRustModeTransform(deps, options) {
           body: { method: "session.flush", v: 1, session_id: sessionId },
           timeoutMs: options.moduleTimeoutMs
         });
-        if (!isRecord5(flushed) || flushed.ok !== true)
+        if (!isRecord4(flushed) || flushed.ok !== true)
           throw new RustTransformProtocolError("rust marker admission recovery: module did not acknowledge rebuilding the new cut");
       }
       let response = await sendTransformSeriesWithSingleRestart(body);
@@ -17889,6 +17423,20 @@ function createRustModeTransform(deps, options) {
       if (moduleDecisionBusts && decisionUpper === "SOFT+") {
         throw new RustTransformProtocolError("rust transform wire invariant failed: SOFT+ cannot permit a prefix bust");
       }
+      const signedThinkingReset = moduleDecisionBusts && response.signed_thinking_reset === true;
+      if (signedThinkingReset) {
+        const fenced = findReasoningBearingAssistantIds(messages);
+        let recorded = false;
+        try {
+          recorded = addMergedReasoningStrippedIds(deps.db, sessionId, fenced.map(thinkingBindingRecoveryFrozenId));
+        } catch (error) {
+          sessionLog2(sessionId, "signed thinking reset fence: persistence threw:", error);
+        }
+        if (!recorded) {
+          throw new EmergencyFailClosedError(SIGNED_THINKING_RESET_FENCE_FAILED);
+        }
+        sessionLog2(sessionId, `signed thinking reset fence: ${fenced.length} assistant(s) [${fenced.join(",")}]`);
+      }
       const cacheBustingPass = moduleDecisionBusts;
       let frozenReplayReleased = false;
       if (markerAdmissionRecovery && !moduleDecisionBusts)
@@ -17902,7 +17450,7 @@ function createRustModeTransform(deps, options) {
         timings.todoUnprobedBust += 1;
         sessionLog2(sessionId, `todo_permission_probe_miss decision=${decisionUpper} reason=${response.materialize_reason ?? "unknown"} verdict_stale_ok=false`);
       }
-      const deferredFirstDivergence = isRecord5(response.first_divergence) ? response.first_divergence : undefined;
+      const deferredFirstDivergence = isRecord4(response.first_divergence) ? response.first_divergence : undefined;
       const deferredFrozenPrefixDivergence = !cacheBustingPass && [deferredFirstDivergence?.block_id_old, deferredFirstDivergence?.block_id_new].some((blockId) => blockId === "mc_m0#0" || blockId === "mc_m1#0");
       if (deferredFrozenPrefixDivergence) {
         state.lkgRepresentationFrozen = true;
@@ -17912,7 +17460,6 @@ function createRustModeTransform(deps, options) {
       const materializedBoundary = materializedCompactionBoundary(response, moduleDecisionBusts);
       let thinkingBindingRecovery = null;
       let frozenHealthyPassesAfterApply = null;
-      let frozenReleaseReason = null;
       const applyStartedAt = performance.now();
       try {
         const moduleMessages = applyNativeMessagesVerbatim({ messages: [] }, response, previousWireCache?.nativeOutput ? {
@@ -18061,6 +17608,7 @@ function createRustModeTransform(deps, options) {
             cacheBustingPass: moduleDecisionBusts,
             prefixPermissionSupported: permissionSupported,
             moduleReasoningTrimOnly: response.reasoning_trim_only === true,
+            moduleSignedThinkingReset: response.signed_thinking_reset === true,
             ...permissionSupported && (passStartedFrozen || frozenReleaseReason || coldStartLastServed) ? { frozenReleaseLastServed } : {},
             trailingBlankSourceDecisions,
             trailingBlankNewestAssistantId: typeof trailingBlankNewestAssistantId === "string" ? trailingBlankNewestAssistantId : undefined,
@@ -18095,7 +17643,7 @@ function createRustModeTransform(deps, options) {
             agentName: deps.getNotificationParams?.(sessionId)?.agent,
             systemPromptHash: sessionMeta.systemPromptHash
           }, resolvedWindowGeometry?.usableHard ?? resolvedContextLimit);
-          const refusal = outgoingContextRefusal(servedFinalWireEstimate, resolvedWindowGeometry?.usableHard ?? resolvedContextLimit, protectedToolTokenCount(getActiveTagsBySession2(deps.db, sessionId), deps.protectedTools, resolveDecisionCalibration(model?.providerID, model?.modelID)));
+          const refusal = outgoingContextRefusal(servedFinalWireEstimate, resolvedWindowGeometry?.usableHard ?? resolvedContextLimit, protectedToolTokenCount(getActiveTagsBySession2(deps.db, sessionId), deps.protectedTools, resolveDecisionCalibration(model?.providerID, model?.modelID))) ?? (signedThinkingReset ? signedTurnContextRefusal(servedFinalWireEstimate, resolvedWindowGeometry?.usableHard ?? resolvedContextLimit) : undefined);
           if (refusal) {
             if (cacheBustingPass) {
               dropSlot(sessionId, "lkg_over_limit_replacement");
@@ -18118,6 +17666,8 @@ function createRustModeTransform(deps, options) {
         }
         const lkgSnapshotStartedAt = performance.now();
         const synchronousReplacement = shouldAdoptModuleAfterFreeze(moduleDecisionBusts, frozenReplayReleased) || !permissionSupported;
+        if (signedThinkingReset)
+          options.afterSignedThinkingResetFenceForTests?.(sessionId);
         if (synchronousReplacement && !markerDefinitelyNoCut) {
           dropSlot(sessionId, "lkg_cache_bust_pending_capture");
           state.lkgAcceptedCapture = undefined;
@@ -18126,6 +17676,11 @@ function createRustModeTransform(deps, options) {
         let captureMode = "async";
         if (capturePlan)
           state.lkgLastServedCaptureSequence = capturePlan.captureSequence;
+        const endRecoveryAfterResetCapture = () => {
+          if (signedThinkingReset && thinkingRecovery.restore) {
+            endLatestThinkingRecoveryAfterReset(deps.db, sessionId);
+          }
+        };
         const captureFailed = (mode, error) => {
           if (states.get(sessionId) !== state || capturePlan && capturePlan.captureSequence !== state.lkgCaptureSequence) {
             return;
@@ -18146,6 +17701,7 @@ function createRustModeTransform(deps, options) {
           captureMode = synchronousReplacement ? "sync_priced" : "sync_recovery";
           try {
             commitRustCapture(state, capturePlan, synchronousReplacement);
+            endRecoveryAfterResetCapture();
           } catch (error) {
             captureFailed("sync", error);
             if (synchronousReplacement)
@@ -18157,6 +17713,7 @@ function createRustModeTransform(deps, options) {
               const asyncStartedAt = performance.now();
               try {
                 const result = commitRustCapture(state, capturePlan);
+                endRecoveryAfterResetCapture();
                 logTransformTiming(sessionId, "rust.lkg_snapshot_async", asyncStartedAt, `result=${result} row_version=${capturePlan.rowVersion}`);
               } catch (error) {
                 captureFailed("async", error);
@@ -18255,7 +17812,7 @@ function createRustModeTransform(deps, options) {
         state.todoProbeIdentity = todoProbeIdentity;
         state.todoBustIdentity = todoBustIdentity;
       }
-      state.todoProbeNextPass = response.reconcile_pending === true || isRecord5(response.historian) && response.historian.fired === true;
+      state.todoProbeNextPass = response.reconcile_pending === true || isRecord4(response.historian) && response.historian.fired === true;
       state.lastAppliedAtMs = requestObservedAtMs;
       heapHolder.wireCaches.set(sessionId, pendingWireCache);
       timings.bookkeeping += performance.now() - bookkeepingStartedAt - timings.delivery;
@@ -18379,6 +17936,11 @@ function createRustModeTransform(deps, options) {
         sessionLog2(sessionId, "mc_rust_emergency_refusal before_lkg");
         markFailure(sessionId, state, error);
         finishPass(false, false);
+        if (moduleFailureCode(error) === TRANSFORM_PAGE_IN_PROGRESS_CODE && inProgressRunWithinBound(state)) {
+          throw new EmergencyFailClosedError(ENGINE_BUSY_USER_MESSAGE, {
+            cause: error
+          });
+        }
         const refusedUser = newestUserMessage(messages);
         const refusedUserMessageId = refusedUser ? messageIdOf2(refusedUser) : null;
         if (refusedUserMessageId) {
@@ -18938,6 +18500,11 @@ function createTransform(deps) {
   const finalWireUsage = createFinalWireUsageTracker();
   const host = resolveTransformHostSeams(deps);
   const loadedSessions = new Set;
+  const prefixHoldLogTurnIds = new Map;
+  const thinkingFitRetries = new Set;
+  const clearSessionLogState = (sessionId) => {
+    prefixHoldLogTurnIds.delete(sessionId);
+  };
   const unmanagedOverWindowSessions = new Set;
   const rustModeTransform = deps.transformMode === "rust" && deps.rustModeModuleClient ? createRustModeTransform(deps, {
     moduleClient: deps.rustModeModuleClient,
@@ -18967,6 +18534,7 @@ function createTransform(deps) {
     const startTime = performance.now();
     const historianRun = deps.resolveHistorianRun?.();
     const messages = output.messages;
+    const originalForThinkingFit = messages.some((message) => message.parts.some((part) => isRecord(part) && ["reasoning", "thinking", "redacted_thinking"].includes(String(part.type)))) ? structuredClone(messages) : null;
     const passOutcome = createPassOutcome();
     const tSessionId = performance.now();
     const sessionId = findSessionId(messages);
@@ -19154,16 +18722,15 @@ function createTransform(deps) {
       deps.pendingMaterializationSessions?.add(sessionId);
     let restoreLatestTurnOriginals;
     let activeThinkingTurn = hasActiveAnthropicThinkingTurn(messages, activeThinkingModel?.providerID, activeThinkingModel?.modelID);
-    let freezeM0M1 = activeThinkingTurn && isPrefixBoundThinkingModel(activeThinkingModel?.providerID, activeThinkingModel?.modelID) || sessionDirectoryFellBack && sessionMeta.cachedM0Bytes != null && sessionMeta.cachedM1Bytes != null && (() => {
+    const unresolvedDirectoryHold = sessionDirectoryFellBack && sessionMeta.cachedM0Bytes != null && sessionMeta.cachedM1Bytes != null && (() => {
       try {
         return hasRecordedSessionProjectIdentity(db, sessionId);
       } catch {
         return true;
       }
     })();
-    if (freezeM0M1) {
-      sessionLog2(sessionId, "session directory unresolved; replaying the frozen m[0]/m[1] and deferring any rebuild");
-    }
+    let activeThinkingPrefixHold = activeThinkingTurn && isPrefixBoundThinkingModel(activeThinkingModel?.providerID, activeThinkingModel?.modelID);
+    let freezeM0M1 = unresolvedDirectoryHold || activeThinkingPrefixHold;
     const compartmentDirectory = sessionDirectory;
     const historianRunnable = deps.historianRunnable !== false;
     const canRunCompartments = fullFeatureMode && !compactionOff && historianRunnable && (deps.client !== undefined || deps.hiddenCompletionExecutor !== undefined) && compartmentDirectory.length > 0;
@@ -19291,7 +18858,13 @@ function createTransform(deps) {
     }
     const resolvedProviderID = modelForBudget?.providerID;
     activeThinkingTurn ||= hasActiveAnthropicThinkingTurn(messages, resolvedProviderID, modelForBudget?.modelID);
-    freezeM0M1 ||= activeThinkingTurn && isPrefixBoundThinkingModel(resolvedProviderID, modelForBudget?.modelID);
+    activeThinkingPrefixHold ||= activeThinkingTurn && isPrefixBoundThinkingModel(resolvedProviderID, modelForBudget?.modelID);
+    freezeM0M1 ||= activeThinkingPrefixHold;
+    if (freezeM0M1 && prefixHoldLogTurnIds.get(sessionId) !== currentTurnId) {
+      prefixHoldLogTurnIds.set(sessionId, currentTurnId);
+      const reason = activeThinkingPrefixHold ? "active thinking turn (prefix-bound model)" : "session directory unresolved";
+      sessionLog2(sessionId, `m[0]/m[1] frozen: ${reason}; replaying the frozen prefix and deferring any rebuild`);
+    }
     const canUseEmptySentinels = modelAcceptsEmptyContent(resolvedProviderID);
     const protectedThinkingMessages = activeThinkingTurn || isAnthropicFamilyRoute(resolvedProviderID, modelForBudget?.modelID) ? latestAssistantTurnMessages(messages) : new Set;
     const resolvedContextLimit = modelForBudget ? resolveTrustedContextLimit(modelForBudget.providerID, modelForBudget.modelID, {
@@ -19822,7 +19395,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       client: deps.client,
       activeAgent,
       batch,
-      contextUsage,
+      contextUsage: thinkingFitRetries.has(sessionId) ? { ...contextUsage, percentage: Math.max(95, contextUsage.percentage) } : contextUsage,
       usableWindow: resolvedContextLimit ?? 0,
       schedulerDecision,
       schedulerDeferReason,
@@ -19837,6 +19410,17 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       compartmentInProgress,
       historyRefreshExplicitBeforePrepare,
       freezeM0M1,
+      activeThinkingPrefixHold,
+      directoryPrefixHold: unresolvedDirectoryHold,
+      forceSignedRebuildForFit: thinkingFitRetries.has(sessionId),
+      readLastServedMessages: () => {
+        const slot = getInMemorySlot(sessionId) ?? loadPersistedLkgSlot(db, sessionId);
+        try {
+          return slot ? JSON.parse(slot.jsonPrefix) : null;
+        } catch {
+          return null;
+        }
+      },
       deferredHistoryWasPendingAtPassStart,
       compartmentInjectionRebuiltFromDb: pendingCompartmentInjection?.rebuiltFromDb === true,
       rebuiltHistoryFromInitialPrepare,
@@ -19921,6 +19505,21 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       if (finalWireEstimate) {
         sessionLog2(sessionId, `transform: final-wire telemetry estimate=${finalWireEstimate.tokens} trusted=${finalWireEstimate.trusted} conversation=${finalWireEstimate.messageTokens.conversation} tools=${finalWireEstimate.messageTokens.toolCall} system=${finalWireEstimate.systemTokens} toolDefinitions=${finalWireEstimate.toolDefinitionTokens ?? "unknown"} tail=${finalWireTail}`);
       }
+      if ((finalWireEstimate?.refusalGrade || finalWireEstimate?.refusalBasis === "byte-bound" && finalWireEstimate.refusalTokens !== undefined) && boundaryContextLimit > 0 && (finalWireEstimate.refusalTokens ?? finalWireEstimate.tokens) > boundaryContextLimit) {
+        if (!thinkingFitRetries.has(sessionId) && activeThinkingPrefixHold && originalForThinkingFit && hasActiveAnthropicThinkingTurn(messages, resolvedProviderID, modelForBudget?.modelID)) {
+          thinkingFitRetries.add(sessionId);
+          deps.pendingMaterializationSessions.add(sessionId);
+          messages.splice(0, messages.length, ...originalForThinkingFit);
+          try {
+            await transform({}, output);
+          } finally {
+            thinkingFitRetries.delete(sessionId);
+          }
+          return;
+        }
+        if (thinkingFitRetries.has(sessionId) || postTransformResult.thinkingReleasedForFit)
+          throw contextRefusalError("The request remains over the model window after stripping signed thinking and reclaiming context");
+      }
       if (postTransformResult.prefixTrimStatus === "refused") {
         const untrimmed = finalWireEstimate ?? estimateFinalWireInputTokens({
           messages,
@@ -20184,10 +19783,12 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       });
   };
   return Object.assign(transform, {
+    clearSessionLogState,
     invalidateRustWireState(sessionId) {
       rustModeTransform?.invalidateWireState(sessionId);
     },
     async clearRustSession(sessionId) {
+      clearSessionLogState(sessionId);
       await rustModeTransform?.clearSession(sessionId);
     },
     disposeRust() {
@@ -20641,7 +20242,7 @@ function truncateError(name, code, message, maxLen = 240) {
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { once } from "node:events";
 import { rmSync } from "node:fs";
-import { join as join4 } from "node:path";
+import { join as join3 } from "node:path";
 
 // src/features/magic-context/dreamer/tick-failure.ts
 var DREAMER_TICK_FAILURE_KEY = "dreamer_tick_last_failure";
@@ -21723,7 +21324,7 @@ function computeOpenCodeWorkMetricsIncremental(openCodeDb, sessionId, carry) {
 import { readFileSync, statSync } from "node:fs";
 
 // src/plugin/embedding-bootstrap-helpers.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 var EMBEDDING_AFFECTING_KEYS = new Set([
   "embedding.api_key",
   "embedding.endpoint",
@@ -21771,7 +21372,7 @@ var EMBEDDING_WARNING_TERMS = [
 ];
 var loggedFailureSignatures = new Map;
 function sha256Prefix(value, length = 16) {
-  return createHash7("sha256").update(value).digest("hex").slice(0, length);
+  return createHash6("sha256").update(value).digest("hex").slice(0, length);
 }
 function warningLooksEmbeddingRelated(message) {
   const lower = message.toLowerCase();
@@ -22312,7 +21913,7 @@ function activeHostLimitations() {
 
 // src/shared/plugin-package-version.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
-import { dirname, join as join3 } from "node:path";
+import { dirname, join as join2 } from "node:path";
 import { fileURLToPath } from "node:url";
 var PACKAGE_NAME = "@cortexkit/opencode-magic-context";
 var cachedVersion;
@@ -22324,7 +21925,7 @@ function pluginPackageVersion(moduleUrl = import.meta.url) {
   try {
     let directory = dirname(fileURLToPath(moduleUrl));
     for (let depth = 0;depth < 10; depth++) {
-      const candidate = join3(directory, "package.json");
+      const candidate = join2(directory, "package.json");
       if (existsSync3(candidate)) {
         const parsed = JSON.parse(readFileSync3(candidate, "utf8"));
         if (typeof parsed === "object" && parsed !== null && "name" in parsed && parsed.name === PACKAGE_NAME && "version" in parsed && typeof parsed.version === "string") {
@@ -23071,11 +22672,11 @@ async function generateDebugHeapSnapshot(storageDir, memory) {
   if (rssBytes > maxRssBytes) {
     throw new Error(`heap snapshot refused: process rss ${Math.round(rssBytes / (1024 * 1024))} MiB exceeds the ${Math.round(maxRssBytes / (1024 * 1024))} MiB ceiling (MAGIC_CONTEXT_DEBUG_HEAP_SNAPSHOT_MAX_RSS_MB); use debug.memoryUsage instead`);
   }
-  const directory = join4(storageDir, "heap-snapshots");
+  const directory = join3(storageDir, "heap-snapshots");
   const enforcePrivatePermissions = shouldEnforcePrivateStoragePermissions();
   ensureStorageDirectorySync(directory);
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const path = join4(directory, `${timestamp}-${process.pid}.heapsnapshot`);
+  const path = join3(directory, `${timestamp}-${process.pid}.heapsnapshot`);
   let format = "jsc";
   let snapshotVersion;
   let snapshot;
@@ -23225,7 +22826,7 @@ function registerRpcHandlers(rpcServer, args) {
     return { count: buildCompartmentCount(db, sessionId, moduleStatus) };
   });
   const buildManagedCtx = async (db) => {
-    const { deriveHistorianChunkTokens, resolveHistorianContextLimit } = await importPluginModule(() => import("./derive-budgets-3vc0y84t.js"));
+    const { deriveHistorianChunkTokens, resolveHistorianContextLimit } = await importPluginModule(() => import("./derive-budgets-fgej9j46.js"));
     const { resolveHistorianModel } = await importPluginModule(() => import("./model-resolution-nx97z3x7.js"));
     const { userMemoryCollectionEnabled } = await importPluginModule(() => import("./task-config-x0hq3qfd.js"));
     const DEFAULT_HISTORIAN_TIMEOUT_MS = 10 * 60 * 1000;
@@ -23261,8 +22862,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-az61rfcg.js"));
-    const { sendIgnoredMessage } = await importPluginModule(() => import("./send-session-notification-6km439kn.js"));
+    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-ckfgt6wq.js"));
+    const { sendIgnoredMessage } = await importPluginModule(() => import("./send-session-notification-5m0yapqx.js"));
     log2(`[rpc] recomp requested for session ${sessionId}`);
     if (!args.client && !args.hiddenCompletionExecutor) {
       return {
@@ -23331,7 +22932,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-mz7efs7w.js"));
+    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-a7efxaax.js"));
     const model = liveSessionState.liveModelBySession.get(sessionId);
     const contextLimit = model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
     const ctx = {
@@ -23422,26 +23023,26 @@ function hideSubagentTools(draft, db) {
 
 // src/shared/conflict-detector.ts
 import { homedir as homedir2 } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join5 } from "node:path";
 
 // src/shared/opencode-config-dir.ts
 import { homedir } from "node:os";
-import { join as join5, resolve } from "node:path";
+import { join as join4, resolve } from "node:path";
 function resolveHomeDir() {
   return process.env.HOME?.trim() || homedir();
 }
 function getOpenCodeGlobalConfigDir() {
   if (process.platform === "win32") {
-    return join5(resolveHomeDir(), ".config", "opencode");
+    return join4(resolveHomeDir(), ".config", "opencode");
   }
-  return join5(process.env.XDG_CONFIG_HOME || join5(resolveHomeDir(), ".config"), "opencode");
+  return join4(process.env.XDG_CONFIG_HOME || join4(resolveHomeDir(), ".config"), "opencode");
 }
 function getEnvConfigDir() {
   const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   return envConfigDir ? resolve(envConfigDir) : undefined;
 }
 function getOpenCodeConfigDirs() {
-  const dirs = [getOpenCodeGlobalConfigDir(), join5(resolveHomeDir(), ".opencode")];
+  const dirs = [getOpenCodeGlobalConfigDir(), join4(resolveHomeDir(), ".opencode")];
   const envDir = getEnvConfigDir();
   if (envDir)
     dirs.push(envDir);
@@ -23515,19 +23116,19 @@ function checkCompaction(directory, hostGeneration) {
 function openCodeConfigFileChain(directory, hostGeneration) {
   const globalDir = getOpenCodeGlobalConfigDir();
   const wellKnown = [
-    join6(globalDir, "config.json"),
-    join6(globalDir, "opencode.json"),
-    join6(globalDir, "opencode.jsonc")
+    join5(globalDir, "config.json"),
+    join5(globalDir, "opencode.json"),
+    join5(globalDir, "opencode.jsonc")
   ];
-  const globalSupplementary = getOpenCodeConfigDirs().filter((dir) => dir !== globalDir).flatMap((dir) => [join6(dir, "opencode.json"), join6(dir, "opencode.jsonc")]);
+  const globalSupplementary = getOpenCodeConfigDirs().filter((dir) => dir !== globalDir).flatMap((dir) => [join5(dir, "opencode.json"), join5(dir, "opencode.jsonc")]);
   const explicitConfig = process.env.OPENCODE_CONFIG?.trim();
   const explicit = explicitConfig ? [explicitConfig] : [];
   const disableProjectConfig = process.env.OPENCODE_DISABLE_PROJECT_CONFIG?.toLowerCase();
   const skipProject = hostGeneration === "v1" && (disableProjectConfig === "true" || disableProjectConfig === "1");
-  const direct = skipProject ? [] : [join6(directory, "opencode.json"), join6(directory, "opencode.jsonc")];
+  const direct = skipProject ? [] : [join5(directory, "opencode.json"), join5(directory, "opencode.jsonc")];
   const projectSupplementary = skipProject ? [] : [
-    join6(directory, ".opencode", "opencode.json"),
-    join6(directory, ".opencode", "opencode.jsonc")
+    join5(directory, ".opencode", "opencode.json"),
+    join5(directory, ".opencode", "opencode.jsonc")
   ];
   const files = hostGeneration === "v2" ? [
     ...wellKnown,
@@ -23615,10 +23216,10 @@ function collectPluginEntries(directory) {
     }
   };
   for (const configPath of [
-    join6(directory, ".opencode", "opencode.jsonc"),
-    join6(directory, ".opencode", "opencode.json"),
-    join6(directory, "opencode.jsonc"),
-    join6(directory, "opencode.json")
+    join5(directory, ".opencode", "opencode.jsonc"),
+    join5(directory, ".opencode", "opencode.json"),
+    join5(directory, "opencode.jsonc"),
+    join5(directory, "opencode.json")
   ]) {
     const config = readJsoncFile(configPath);
     pushFrom(config?.plugin);
@@ -23628,7 +23229,7 @@ function collectPluginEntries(directory) {
     for (const dir of getOpenCodeConfigDirs()) {
       const names = dir === globalDir ? ["config.json", "opencode.json", "opencode.jsonc"] : ["opencode.json", "opencode.jsonc"];
       for (const name of names) {
-        const config = readJsoncFile(join6(dir, name));
+        const config = readJsoncFile(join5(dir, name));
         pushFrom(config?.plugin);
       }
     }
@@ -23663,7 +23264,7 @@ function readOmoDisabledHooks(directory) {
   try {
     for (const dir of getOpenCodeConfigDirs()) {
       for (const name of configNames) {
-        const config = readJsoncFile(join6(dir, name));
+        const config = readJsoncFile(join5(dir, name));
         if (config?.disabled_hooks) {
           for (const hook of config.disabled_hooks) {
             disabled.add(hook);
@@ -23673,7 +23274,7 @@ function readOmoDisabledHooks(directory) {
     }
   } catch {}
   for (const name of configNames) {
-    const config = readJsoncFile(join6(directory, name));
+    const config = readJsoncFile(join5(directory, name));
     if (config?.disabled_hooks) {
       for (const hook of config.disabled_hooks) {
         disabled.add(hook);
@@ -23681,9 +23282,9 @@ function readOmoDisabledHooks(directory) {
     }
   }
   const homeDir = process.env.HOME || homedir2();
-  const omoHomeDir = join6(homeDir, ".omo");
+  const omoHomeDir = join5(homeDir, ".omo");
   for (const name of ["omo.jsonc", "omo.json"]) {
-    const config = readJsoncFile(join6(omoHomeDir, name));
+    const config = readJsoncFile(join5(omoHomeDir, name));
     if (config?.["[opencode]"]?.disabled_hooks) {
       for (const hook of config["[opencode]"].disabled_hooks) {
         disabled.add(hook);
@@ -23691,7 +23292,7 @@ function readOmoDisabledHooks(directory) {
     }
   }
   for (const name of ["omo.jsonc", "omo.json"]) {
-    const config = readJsoncFile(join6(directory, ".omo", name));
+    const config = readJsoncFile(join5(directory, ".omo", name));
     if (config?.["[opencode]"]?.disabled_hooks) {
       for (const hook of config["[opencode]"].disabled_hooks) {
         disabled.add(hook);
@@ -24205,9 +23806,9 @@ function trimToRecordedBoundary(db, sessionId, messages) {
 }
 
 // src/v2/fold/host-media.ts
-var isRecord6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function isClassInstance(value) {
-  if (!isRecord6(value))
+  if (!isRecord5(value))
     return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype !== Object.prototype && prototype !== null;
@@ -24226,10 +23827,10 @@ function rememberHostMedia(messages) {
     if (!Array.isArray(content))
       continue;
     for (const part of content) {
-      if (!isRecord6(part) || part.type !== "media")
+      if (!isRecord5(part) || part.type !== "media")
         continue;
       const media = part.media;
-      if (isClassInstance(media) && isRecord6(media.source)) {
+      if (isClassInstance(media) && isRecord5(media.source)) {
         rememberedAssetClass = Object.getPrototypeOf(media).constructor;
         return;
       }
@@ -24286,7 +23887,7 @@ function hostMediaAsset(data, mediaType) {
   return hostMediaFromEncoded({ source: { type: "base64", data, mediaType } });
 }
 function hostMediaFromEncoded(value) {
-  if (!isRecord6(value.source))
+  if (!isRecord5(value.source))
     return "missing Media.Asset source";
   const encoded = structuredClone(value);
   if (encoded.source.type === "bytes") {
@@ -24320,8 +23921,8 @@ function hostMediaFromEncoded(value) {
 import { randomUUID as randomUUID4 } from "node:crypto";
 
 // src/v2/fold/owner.ts
-import { createHash as createHash8 } from "node:crypto";
-var foldDigest = (value) => createHash8("sha256").update(value).digest("hex");
+import { createHash as createHash7 } from "node:crypto";
+var foldDigest = (value) => createHash7("sha256").update(value).digest("hex");
 
 class FoldOwner {
   storage;
@@ -25897,7 +25498,7 @@ function createNativeHiddenChildren(host, removeSession, options) {
       return;
     }
     const directory = stored.location?.directory;
-    if (options.directory !== undefined && directory !== undefined && directory !== options.directory) {
+    if (options.directory !== undefined && directory !== undefined && !sameProjectDirectory(directory, options.directory)) {
       throw new HiddenCompletionRefusal("hidden_prompt_unrecognized", `hidden child ${sessionID} is bound to ${directory}, not to this instance's ${options.directory}`, true);
     }
     if (stored.parentID === parentID || parentDroppedNoted)
@@ -26014,6 +25615,111 @@ async function cleanupLegacyHiddenChildren(db, remove, note, options = {}) {
     db.prepare("INSERT OR IGNORE INTO schema_migrations_meta (key, value) VALUES (?, 'true')").run(COMPLETE);
 }
 
+// src/shared/models-dev-temperature.ts
+import { readFileSync as readFileSync5, statSync as statSync2 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join6 } from "node:path";
+var CATALOG_PROVIDER_ALIASES = {
+  "google-antigravity": "google",
+  "opencode-zen": "opencode"
+};
+var ANTIGRAVITY_MODEL_PREFIX = "antigravity-";
+var cached;
+function modelsDevCatalogPath(env = process.env) {
+  if (env.OPENCODE_MODELS_PATH)
+    return env.OPENCODE_MODELS_PATH;
+  return join6(env.XDG_CACHE_HOME || join6(homedir3(), ".cache"), "opencode", "models.json");
+}
+function buildIndex(raw) {
+  const index = new Map;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return index;
+  for (const [providerID, provider] of Object.entries(raw)) {
+    const models = provider?.models;
+    if (!models || typeof models !== "object")
+      continue;
+    for (const [modelID, model] of Object.entries(models)) {
+      const temperature = model?.temperature;
+      if (typeof temperature === "boolean")
+        index.set(`${providerID}/${modelID}`, temperature);
+    }
+  }
+  return index;
+}
+function loadIndex() {
+  const path = modelsDevCatalogPath();
+  try {
+    const stat = statSync2(path);
+    if (cached?.path === path && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size)
+      return cached.index;
+    const index = buildIndex(JSON.parse(readFileSync5(path, "utf8")));
+    cached = { path, mtimeMs: stat.mtimeMs, size: stat.size, index };
+    return index;
+  } catch {
+    return;
+  }
+}
+function catalogCandidates(providerID, modelID) {
+  const provider = Object.hasOwn(CATALOG_PROVIDER_ALIASES, providerID) ? CATALOG_PROVIDER_ALIASES[providerID] : providerID;
+  const candidates = [`${provider}/${modelID}`];
+  if (provider === "google" && modelID.startsWith(ANTIGRAVITY_MODEL_PREFIX))
+    candidates.push(`google/${modelID.slice(ANTIGRAVITY_MODEL_PREFIX.length)}`);
+  return candidates;
+}
+function catalogTemperature(model) {
+  const slash = model.indexOf("/");
+  if (slash <= 0 || slash === model.length - 1)
+    return;
+  const index = loadIndex();
+  if (!index)
+    return;
+  for (const entry of catalogCandidates(model.slice(0, slash), model.slice(slash + 1))) {
+    const temperature = index.get(entry);
+    if (temperature !== undefined)
+      return { temperature, entry };
+  }
+  return;
+}
+
+// src/shared/subagent-temperature.ts
+var loggedDecisions = new Set;
+function temperatureCapability(metadata) {
+  if (!metadata || typeof metadata !== "object")
+    return;
+  const model = metadata;
+  const supported = model.capabilities?.temperature ?? model.temperature ?? model.compat?.supportsTemperature ?? model.compat?.supportsSamplingParams;
+  return typeof supported === "boolean" ? supported : undefined;
+}
+function resolveTemperatureCapability(model, metadata) {
+  const host = temperatureCapability(metadata);
+  if (host !== undefined)
+    return { supported: host, source: "host" };
+  const catalog = catalogTemperature(model);
+  if (catalog)
+    return { supported: catalog.temperature, source: "catalog", entry: catalog.entry };
+  return { supported: undefined, source: "none" };
+}
+function describeTemperatureDecision(model, decision) {
+  const verdict = decision.supported === true ? "sent" : "omitted";
+  const answer = decision.supported === true ? "yes" : "no";
+  const reason = decision.source === "host" ? `host model metadata says ${answer}` : decision.source === "catalog" ? `models.dev cache entry ${decision.entry ?? "unknown"} says ${answer}` : "no host or models.dev metadata";
+  return `Subagent temperature ${verdict} for ${model}: ${reason}`;
+}
+function logTemperatureDecision(model, decision, log) {
+  const key = `${model}\x00${decision.source}\x00${decision.supported}\x00${decision.entry ?? ""}`;
+  if (loggedDecisions.has(key))
+    return;
+  loggedDecisions.add(key);
+  log(describeTemperatureDecision(model, decision), decision);
+}
+function subagentTemperature(model, metadata, temperature, log) {
+  if (temperature === undefined)
+    return;
+  const decision = resolveTemperatureCapability(model, metadata);
+  logTemperatureDecision(model, decision, log);
+  return decision.supported === true ? temperature : undefined;
+}
+
 // src/v2/hidden-completion.ts
 var POLL_INTERVAL_MS = 200;
 function modelKey(model) {
@@ -26368,6 +26074,26 @@ async function createV2HiddenCompletionExecutor(host, options) {
         throw new Error("Hidden completion prompt aborted");
       }
       const requested = await validateVariant(requestModel(request, run.child.model));
+      if (run.identity.kind !== "dreamer-task" && request.body.temperature === undefined) {
+        const configured = options.historianTemperature?.();
+        if (typeof configured === "number" && Number.isFinite(configured))
+          request = { ...request, body: { ...request.body, temperature: configured } };
+      }
+      if (typeof request.body.temperature === "number") {
+        let metadata;
+        try {
+          const listed = await options.modelCatalog?.();
+          const rows = Array.isArray(listed) ? listed : listed?.data;
+          metadata = rows?.find((row) => row?.providerID === requested.providerID && (row?.id === requested.modelID || row?.modelID === requested.modelID));
+        } catch {}
+        const temperature = subagentTemperature(modelKey(requested), metadata, request.body.temperature, (message) => note(message));
+        const body = { ...request.body };
+        if (temperature === undefined)
+          delete body.temperature;
+        else
+          body.temperature = temperature;
+        request = { ...request, body };
+      }
       if (run.retired) {
         run.child = await lifecycle.create(run.identity, run.role, requested);
         run.failed = false;
@@ -26783,11 +26509,11 @@ class DeletedSessionTombstones {
 }
 
 // src/features/magic-context/dreamer/task-executor.ts
-import { createHash as createHash15 } from "node:crypto";
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "node:fs";
+import { createHash as createHash14 } from "node:crypto";
+import { existsSync as existsSync7, readFileSync as readFileSync8 } from "node:fs";
 
 // src/features/magic-context/mural/compress-cues.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 
 // src/features/magic-context/dreamer/storage-dream-state.ts
 var getDreamStateStatements = new WeakMap;
@@ -27517,7 +27243,7 @@ async function applyCuesThroughModule(args, chunk, manifestText, signal) {
       log2(`[dreamer] compress-cues: skipped cue for memory ${entry.id} (${failure.reason}; rejection ${rejectionCount}/${CUE_REJECTION_LATCH_THRESHOLD})`);
     }
   }
-  const commandId = `mural-cues:${route.moduleCommandId}:${createHash9("sha256").update(chunk.map((candidate) => candidate.memory.id).join(",")).digest("hex").slice(0, 24)}`;
+  const commandId = `mural-cues:${route.moduleCommandId}:${createHash8("sha256").update(chunk.map((candidate) => candidate.memory.id).join(",")).digest("hex").slice(0, 24)}`;
   let response;
   try {
     response = await route.moduleClient.call({
@@ -28086,7 +27812,7 @@ function applyReviewVerdict(args, leaseKey, parsed, result) {
 }
 
 // src/features/magic-context/dreamer/classify.ts
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 
 // src/plugin/rust-tool-backends.ts
 function isRustAuthorityDrainingError(error) {
@@ -28523,7 +28249,7 @@ async function runClassifyThroughModule(args, chunk, anchors, signal, runOnHost)
     if (entry.qualifier)
       modelVariants[entry.model] = entry.qualifier;
   }
-  const commandId = `classify:${args.moduleCommandId ?? Date.now()}:${createHash10("sha256").update(chunk.map((candidate) => candidate.id).join(",")).digest("hex").slice(0, 24)}`;
+  const commandId = `classify:${args.moduleCommandId ?? Date.now()}:${createHash9("sha256").update(chunk.map((candidate) => candidate.id).join(",")).digest("hex").slice(0, 24)}`;
   const runTask = (hostCompletion) => args.moduleClient?.call({
     sessionId: args.moduleSessionId,
     projectRoot: args.moduleProjectRoot,
@@ -28798,14 +28524,14 @@ function takeCurateSafetyRefusalCount(sessionId) {
 
 // src/features/magic-context/dreamer/docs-proposals.ts
 import { execFileSync } from "node:child_process";
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 import {
   existsSync as existsSync4,
   mkdirSync,
   mkdtempSync,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync5,
-  realpathSync as realpathSync2,
+  readFileSync as readFileSync6,
+  realpathSync,
   renameSync,
   rmSync as rmSync2,
   writeFileSync
@@ -28813,12 +28539,12 @@ import {
 import { tmpdir } from "node:os";
 import { join as join7 } from "node:path";
 var FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
-var hash = (text) => createHash11("sha256").update(text).digest("hex");
+var hash = (text) => createHash10("sha256").update(text).digest("hex");
 var proposalDir = (projectDir) => join7(projectDir, ".cortexkit/magic-context/docs-update-proposals");
 function docsBaseHashes(projectDir) {
   return Object.fromEntries(FILES.map((name) => [
     name,
-    hash(existsSync4(join7(projectDir, name)) ? readFileSync5(join7(projectDir, name), "utf8") : "")
+    hash(existsSync4(join7(projectDir, name)) ? readFileSync6(join7(projectDir, name), "utf8") : "")
   ]));
 }
 function listPendingDocsProposals(projectDir) {
@@ -28827,7 +28553,7 @@ function listPendingDocsProposals(projectDir) {
 }
 function hasCurrentDocsProposal(projectDir) {
   const hashes = docsBaseHashes(projectDir);
-  return listPendingDocsProposals(projectDir).some((path) => Object.entries(hashes).every(([name, value]) => readFileSync5(path, "utf8").includes(`Base SHA-256 ${name}: ${value}`)));
+  return listPendingDocsProposals(projectDir).some((path) => Object.entries(hashes).every(([name, value]) => readFileSync6(path, "utf8").includes(`Base SHA-256 ${name}: ${value}`)));
 }
 function git(projectDir, args) {
   return execFileSync("git", args, {
@@ -28855,7 +28581,7 @@ function gitOutputPrefix(projectDir, args) {
 var MAX_PATHSPEC_BYTES = 256000;
 function docsChangeSet(projectDir, storedAnchor) {
   try {
-    if (realpathSync2(git(projectDir, ["rev-parse", "--show-toplevel"])) !== realpathSync2(projectDir))
+    if (realpathSync(git(projectDir, ["rev-parse", "--show-toplevel"])) !== realpathSync(projectDir))
       return null;
     const head = git(projectDir, ["rev-parse", "HEAD"]);
     const recorded = Boolean(storedAnchor);
@@ -28881,7 +28607,7 @@ function docsChangeSet(projectDir, storedAnchor) {
       const files = [
         ...new Set(changed.flat().filter((file) => file !== "ARCHITECTURE.md" && file !== "STRUCTURE.md" && !/(?:^|[./-])(test|spec)(?:[./-]|$)/.test(file) && !file.endsWith(".lock")))
       ];
-      const docs = FILES.map((file) => existsSync4(join7(projectDir, file)) ? readFileSync5(join7(projectDir, file), "utf8") : "").join(`
+      const docs = FILES.map((file) => existsSync4(join7(projectDir, file)) ? readFileSync6(join7(projectDir, file), "utf8") : "").join(`
 `);
       const relevant = files.some((file) => {
         const directory = file.split("/").slice(0, -1).join("/");
@@ -29037,7 +28763,7 @@ function validateDocsProposal(projectDir, output, budget, expected) {
   let tokens = 0;
   let diffs = "";
   for (const file of FILES) {
-    const before = existsSync4(join7(projectDir, file)) ? readFileSync5(join7(projectDir, file), "utf8") : "";
+    const before = existsSync4(join7(projectDir, file)) ? readFileSync6(join7(projectDir, file), "utf8") : "";
     let after = before;
     const seen = new Set;
     for (const change of changes.filter((item) => item.file === file)) {
@@ -29349,7 +29075,7 @@ function throwIfAborted2(signal) {
 }
 
 // src/features/magic-context/smart-notes/compiler.ts
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 
 // src/features/magic-context/smart-notes/compiler-prompt.ts
 var SMART_NOTE_COMPILER_SYSTEM_PROMPT = `You are the Magic Context smart-note compiler for the magic-context system.
@@ -29680,7 +29406,7 @@ function manifestAdvisoryWarnings(code, manifest) {
   return warnings;
 }
 function hashCheck(surfaceCondition, compiledCheck, manifest, checkCron) {
-  return createHash12("sha256").update(surfaceCondition ?? "").update("\x00").update(compiledCheck).update("\x00").update(JSON.stringify(manifest)).update("\x00").update(checkCron).digest("hex");
+  return createHash11("sha256").update(surfaceCondition ?? "").update("\x00").update(compiledCheck).update("\x00").update(JSON.stringify(manifest)).update("\x00").update(checkCron).digest("hex");
 }
 function extractJsonObject(output) {
   const fenced = output.match(/```(?:json)?\s*([\s\S]*?)```/i);
@@ -30429,7 +30155,7 @@ async function archiveExpiredMemories(args) {
 }
 
 // src/features/magic-context/dreamer/maintain-docs-protected-enforcement.ts
-import { existsSync as existsSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "node:fs";
 import { join as join9 } from "node:path";
 var MAINTAIN_DOCS_SNAPSHOT_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
 function snapshotMaintainDocsFiles(docsDir) {
@@ -30438,7 +30164,7 @@ function snapshotMaintainDocsFiles(docsDir) {
     const path = join9(docsDir, name);
     try {
       if (existsSync5(path)) {
-        snapshot.set(name, readFileSync6(path, "utf8"));
+        snapshot.set(name, readFileSync7(path, "utf8"));
       }
     } catch {}
   }
@@ -30446,10 +30172,10 @@ function snapshotMaintainDocsFiles(docsDir) {
 }
 
 // src/features/magic-context/dreamer/map-memories.ts
-import { createHash as createHash13 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 
 // src/features/magic-context/dreamer/map-memories-prompt.ts
-import { existsSync as existsSync6, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync6, statSync as statSync3 } from "node:fs";
 import path4 from "node:path";
 var MAP_MEMORIES_SYSTEM_PROMPT = `You are a memory mapper for the magic-context system. You map project memories to the repository files that back them.
 
@@ -30487,7 +30213,7 @@ function extractMemoryCandidatePaths(content, repoDir) {
     if (!abs.startsWith(`${root}/`))
       continue;
     try {
-      if (existsSync6(abs) && statSync2(abs).isFile())
+      if (existsSync6(abs) && statSync3(abs).isFile())
         found.add(rel);
     } catch {}
     if (found.size >= MAX_SEED_PATHS_PER_MEMORY)
@@ -30919,7 +30645,7 @@ async function applyParsedBatchMappings(args, batch, parsed, budgetFinalized = f
           name: "memory.set_mapping",
           arguments: {
             memory_project: args.projectIdentity,
-            command_id: `${args.moduleRoute.moduleCommandId}:${createHash13("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
+            command_id: `${args.moduleRoute.moduleCommandId}:${createHash12("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
             rows
           }
         }
@@ -32154,7 +31880,7 @@ function insertDreamRun(db, run) {
 }
 
 // src/features/magic-context/dreamer/verify.ts
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 
 // src/features/magic-context/dreamer/verify-diff.ts
 import { execFile as execFile2 } from "node:child_process";
@@ -32898,7 +32624,7 @@ async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budg
           name: "memory.set_verification",
           arguments: {
             memory_project: args.projectIdentity,
-            command_id: `${args.moduleRoute.moduleCommandId}:${createHash14("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
+            command_id: `${args.moduleRoute.moduleCommandId}:${createHash13("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
             rows
           }
         }
@@ -33704,7 +33430,7 @@ function parseFrictionGateVerdict(verdict) {
 }
 function computeRetrospectiveWindowKey(flagged) {
   const anchors = flagged.map((message) => `${message.sessionId}:${message.ts}`).sort().join("|");
-  return createHash15("sha256").update(anchors).digest("hex").slice(0, 32);
+  return createHash14("sha256").update(anchors).digest("hex").slice(0, 32);
 }
 function renderFrictionWindow(messages, flaggedOrdinals, radius = 2) {
   const flagged = new Set(flaggedOrdinals);
@@ -34172,8 +33898,8 @@ async function runAgenticTask(config, ctx, helpers) {
         existingDocs,
         docsChangeSet: changes?.text,
         docsContents: task === "maintain-docs" ? {
-          architecture: existingDocs?.architecture ? readFileSync7(`${docsDir}/ARCHITECTURE.md`, "utf8") : "(missing)",
-          structure: existingDocs?.structure ? readFileSync7(`${docsDir}/STRUCTURE.md`, "utf8") : "(missing)"
+          architecture: existingDocs?.architecture ? readFileSync8(`${docsDir}/ARCHITECTURE.md`, "utf8") : "(missing)",
+          structure: existingDocs?.structure ? readFileSync8(`${docsDir}/STRUCTURE.md`, "utf8") : "(missing)"
         } : undefined,
         docsBudget: config.docsMaxTokens ?? 12000,
         docsCurrentTokens: maintainDocsSnapshot ? Math.ceil([...maintainDocsSnapshot.values()].join("").length / 3.5) : 0,
@@ -34859,7 +34585,7 @@ async function runManualDreamNow(args) {
 }
 
 // src/plugin/dream-timer.ts
-import { statSync as statSync3 } from "node:fs";
+import { statSync as statSync4 } from "node:fs";
 
 // src/features/magic-context/dreamer/retrospective-orphan-sweep.ts
 var HISTORIAN_CHILD_TITLE = "magic-context-compartment";
@@ -35017,7 +34743,7 @@ var startupJitters = new Map;
 var nextStartupJitterSlot = 0;
 function directoryStillExists(directory) {
   try {
-    return statSync3(directory).isDirectory();
+    return statSync4(directory).isDirectory();
   } catch {
     return false;
   }
@@ -35523,7 +35249,7 @@ async function sessionInThisLocation(context, sessionID) {
   } catch {
     return false;
   }
-  return location?.directory === context.location.directory && (location.workspaceID ?? "") === (context.location.workspaceID ?? "");
+  return location?.directory !== undefined && sameProjectDirectory(location.directory, context.location.directory) && (location.workspaceID ?? "") === (context.location.workspaceID ?? "");
 }
 function startDreamTrigger(context, args) {
   const controller = new AbortController;
@@ -35590,13 +35316,28 @@ function startDreamTrigger(context, args) {
 }
 
 // src/v2/hooks/generate.ts
+function generateReplayAnchor(messages) {
+  let index = messages.length - 1;
+  while (index >= 0 && !messages[index]?.id)
+    index--;
+  if (index < 0)
+    return;
+  const id = messages.at(index)?.id;
+  if (!id)
+    return;
+  return { id, tail: clonePreservingInstances(messages.slice(index + 1)) };
+}
+
 class V2GenerateReplay {
   prefixes = new Map;
   capture(draft, anchor) {
-    if (!anchor)
+    if (!anchor) {
+      this.prefixes.delete(draft.sessionID);
+      sessionLog2(draft.sessionID, "generate replay capture skipped: no-anchor");
       return;
+    }
     this.prefixes.set(draft.sessionID, {
-      anchor,
+      anchor: clonePreservingInstances(anchor),
       model: `${draft.model.providerID}/${draft.model.id}`,
       agent: draft.agent,
       system: clonePreservingInstances(draft.system),
@@ -35609,12 +35350,23 @@ class V2GenerateReplay {
   }
   apply(draft) {
     const prefix = this.prefixes.get(draft.sessionID);
-    if (!prefix || prefix.model !== `${draft.model.providerID}/${draft.model.id}` || prefix.agent !== draft.agent)
+    const skip = (reason) => {
+      sessionLog2(draft.sessionID, `generate replay apply skipped: ${reason}`);
       return false;
-    const index = draft.messages.findIndex((message) => message.id === prefix.anchor);
+    };
+    if (!prefix)
+      return skip("no-prefix");
+    if (prefix.model !== `${draft.model.providerID}/${draft.model.id}`)
+      return skip("model-mismatch");
+    if (prefix.agent !== draft.agent)
+      return skip("agent-mismatch");
+    const index = draft.messages.findIndex((message) => message.id === prefix.anchor.id);
     if (index < 0)
-      return false;
-    const tail = draft.messages.slice(index + 1);
+      return skip("anchor-not-found");
+    const end = index + 1 + prefix.anchor.tail.length;
+    if (JSON.stringify(draft.messages.slice(index + 1, end)) !== JSON.stringify(prefix.anchor.tail))
+      return skip("anchor-tail-mismatch");
+    const tail = draft.messages.slice(end);
     draft.messages.splice(0, draft.messages.length, ...clonePreservingInstances(prefix.messages), ...tail);
     draft.system.splice(0, draft.system.length, ...clonePreservingInstances(prefix.system));
     draft.tools = clonePreservingInstances(prefix.tools);
@@ -35632,9 +35384,9 @@ function hiddenTerminalError(event) {
 }
 
 // src/v2/hooks/lkg-system.ts
-import { createHash as createHash16 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 function identity(slot) {
-  return createHash16("sha256").update(JSON.stringify({
+  return createHash15("sha256").update(JSON.stringify({
     capturedAt: slot.capturedAt,
     captureSequence: slot.captureSequence,
     rowVersion: slot.rowVersion,
@@ -36755,7 +36507,7 @@ function jsonStringifyReplacer(_, value) {
     return value.toString();
   return value;
 }
-function cached(getter) {
+function cached2(getter) {
   const set = false;
   return {
     get value() {
@@ -36866,7 +36618,7 @@ var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace :
 function isObject(data) {
   return typeof data === "object" && data !== null && !Array.isArray(data);
 }
-var allowsEval = cached(() => {
+var allowsEval = cached2(() => {
   if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
     return false;
   }
@@ -38909,7 +38661,7 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
 }
 var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
   $ZodType.init(inst, def);
-  const _normalized = cached(() => normalizeDef(def));
+  const _normalized = cached2(() => normalizeDef(def));
   defineLazy(inst._zod, "propValues", () => {
     const shape = def.shape;
     const propValues = {};
@@ -38959,7 +38711,7 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
 var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) => {
   $ZodObject.init(inst, def);
   const superParse = inst._zod.parse;
-  const _normalized = cached(() => normalizeDef(def));
+  const _normalized = cached2(() => normalizeDef(def));
   const generateFastpass = (shape) => {
     const doc = new Doc(["shape", "payload", "ctx"]);
     const normalized = _normalized.value;
@@ -39117,7 +38869,7 @@ var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnio
     }
     return propValues;
   });
-  const disc = cached(() => {
+  const disc = cached2(() => {
     const opts = def.options;
     const map = new Map;
     for (const o of opts) {
@@ -48433,8 +48185,8 @@ function resolveCtxExpandMode(args, domain) {
 }
 
 // src/tools/ctx-expand/render.ts
-import { createHash as createHash17 } from "node:crypto";
-function isRecord7(value) {
+import { createHash as createHash16 } from "node:crypto";
+function isRecord6(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function roleLabel(role) {
@@ -48446,7 +48198,7 @@ function roleLabel(role) {
 }
 function verboseRoleLabel(msg) {
   if (msg.role === "user" && msg.parts.length > 0 && msg.parts.every((part) => {
-    if (!isRecord7(part))
+    if (!isRecord6(part))
       return false;
     if (part.type === "tool_result")
       return true;
@@ -48474,15 +48226,15 @@ function keyArg(input) {
 function asToolPart(part) {
   const type = typeof part.type === "string" ? part.type : "";
   if (type === "tool") {
-    const state = isRecord7(part.state) ? part.state : null;
+    const state = isRecord6(part.state) ? part.state : null;
     const output = state && typeof state.output === "string" ? state.output : state && state.output != null ? JSON.stringify(state.output) : null;
-    const metadata = state && isRecord7(state.metadata) ? state.metadata : null;
+    const metadata = state && isRecord6(state.metadata) ? state.metadata : null;
     const title = state && typeof state.title === "string" && state.title || metadata && typeof metadata.title === "string" && metadata.title || null;
     return {
       name: typeof part.tool === "string" ? part.tool : "tool",
       callId: typeof part.callID === "string" ? part.callID : "",
       title,
-      input: state && isRecord7(state.input) ? state.input : null,
+      input: state && isRecord6(state.input) ? state.input : null,
       output
     };
   }
@@ -48491,7 +48243,7 @@ function asToolPart(part) {
       name: typeof part.name === "string" ? part.name : "tool",
       callId: typeof part.id === "string" ? part.id : "",
       title: null,
-      input: isRecord7(part.input) ? part.input : null,
+      input: isRecord6(part.input) ? part.input : null,
       output: null
     };
   }
@@ -48520,7 +48272,7 @@ function reasoningOf(part) {
   return null;
 }
 function renderPartPreview(part, expandTools) {
-  if (!isRecord7(part))
+  if (!isRecord6(part))
     return null;
   const expansion = expandToolPart(part, expandTools, true);
   if (expansion !== null)
@@ -48547,7 +48299,7 @@ function renderPartPreview(part, expandTools) {
   return `    • [${type}]`;
 }
 function renderPartFull(part) {
-  if (!isRecord7(part))
+  if (!isRecord6(part))
     return null;
   const text = textOf(part);
   if (text !== null) {
@@ -48634,11 +48386,11 @@ function renderItemByTag(db, sessionId, number, textIndexDomain = "part") {
     const message = readRawSessionMessageById2(sessionId, owner);
     if (!message)
       return `Tag ${number}'s original tool owner is no longer in stored history.`;
-    const parts = message?.parts.filter((part) => isRecord7(part) && asToolPart(part)?.callId === tag.messageId) ?? [];
-    if (!parts.some((part) => isRecord7(part) && asToolPart(part)?.output !== null)) {
+    const parts = message?.parts.filter((part) => isRecord6(part) && asToolPart(part)?.callId === tag.messageId) ?? [];
+    if (!parts.some((part) => isRecord6(part) && asToolPart(part)?.output !== null)) {
       visitRawSessionMessages2(sessionId, message.ordinal + 1, Number.MAX_SAFE_INTEGER, (candidate) => {
-        const matching = candidate.parts.filter((part) => isRecord7(part) && asToolPart(part)?.callId === tag.messageId);
-        if (matching.some((part) => isRecord7(part) && part.type === "tool_use"))
+        const matching = candidate.parts.filter((part) => isRecord6(part) && asToolPart(part)?.callId === tag.messageId);
+        if (matching.some((part) => isRecord6(part) && part.type === "tool_use"))
           return false;
         parts.push(...matching);
         return matching.length === 0;
@@ -48655,9 +48407,9 @@ function renderItemByTag(db, sessionId, number, textIndexDomain = "part") {
   if (!message)
     return `Tag ${number}'s original text is no longer in stored history.`;
   const index = scoped ? Number(scoped[2]) : 0;
-  const piText = message.parts.filter((part) => isRecord7(part) && part.type === "text");
+  const piText = message.parts.filter((part) => isRecord6(part) && part.type === "text");
   const part = message.parts[index];
-  const matching = derived ? piText.filter((part) => isRecord7(part) && typeof part.text === "string" && createHash17("sha256").update(part.text).digest("hex") === derived[3]) : [];
+  const matching = derived ? piText.filter((part) => isRecord6(part) && typeof part.text === "string" && createHash16("sha256").update(part.text).digest("hex") === derived[3]) : [];
   const selected = derived ? matching[Number(derived[4])] : textIndexDomain === "text" ? piText[index] : part;
   return selected ? renderPartFull(selected) ?? "" : `Tag ${number}'s original text part is no longer in stored history.`;
 }
@@ -49408,7 +49160,7 @@ import { isAbsolute as isAbsolute2 } from "node:path";
 
 // ../retina-local-fs/src/path-fence.ts
 import { lstat as lstat2, readlink, realpath as realpath2 } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
+import { homedir as homedir4 } from "node:os";
 import { basename, dirname as dirname2, isAbsolute, join as join10, relative, resolve as resolve2, sep } from "node:path";
 
 // ../retina-local-fs/src/errors.ts
@@ -49434,7 +49186,7 @@ async function resolveAndFenceProviderPath(configuredPath, options) {
 }
 var FENCED_CORTEXKIT_ROOTS = ["plexus", "claustrum", "staging", "run", "magic-context"];
 async function resolveFenceRoots(options) {
-  const configuredHomePath = resolve2(options.homeDirectory ?? process.env.HOME ?? homedir3());
+  const configuredHomePath = resolve2(options.homeDirectory ?? process.env.HOME ?? homedir4());
   let home;
   try {
     home = await realpath2(configuredHomePath);
@@ -50176,7 +49928,7 @@ function ctxReduceSelfStampMessage(tagNumber) {
   return CTX_REDUCE_SELF_STAMP_MESSAGE_TEMPLATE.replace("§N§", `§${tagNumber}§`);
 }
 // src/tools/ctx-reduce/tools.ts
-import { createHash as createHash18 } from "node:crypto";
+import { createHash as createHash17 } from "node:crypto";
 
 // src/features/magic-context/range-parser.ts
 function parseRangeString(input) {
@@ -50245,11 +49997,11 @@ function createCtxReduceTool(deps) {
       const stableId = `oc-${sessionId}-${callId}`;
       if (Buffer.byteLength(stableId) <= 128)
         return stableId;
-      return `oc-${createHash18("sha256").update(stableId).digest("hex")}`;
+      return `oc-${createHash17("sha256").update(stableId).digest("hex")}`;
     }
     fallbackCommandSequence += 1;
     const monotonicId = `oc-${sessionId}-${fallbackCommandSequence}`;
-    return Buffer.byteLength(monotonicId) <= 128 ? monotonicId : `oc-${createHash18("sha256").update(monotonicId).digest("hex")}`;
+    return Buffer.byteLength(monotonicId) <= 128 ? monotonicId : `oc-${createHash17("sha256").update(monotonicId).digest("hex")}`;
   };
   return tool({
     description: CTX_REDUCE_DESCRIPTION,
@@ -50332,7 +50084,7 @@ function createCtxReduceTool(deps) {
         ...protectedSet,
         ...protectedToolTagNumbers(getActiveTagsBySession2(deps.db, sessionId), deps.protectedTools)
       ]);
-      const inertWhitespaceTagNumbers = new Set(getInertWhitespaceAssistantTags2(deps.db, sessionId).map((tag) => tag.tagNumber));
+      const inertWhitespaceTagNumbers = new Set(getInertWhitespaceAssistantTagsByNumbers2(deps.db, sessionId, dropIds).map((tag) => tag.tagNumber));
       const inertDropIds = [
         ...new Set(dropIds.filter((id) => inertWhitespaceTagNumbers.has(id)))
       ];
@@ -50573,6 +50325,7 @@ function createCtxSearchTool(deps) {
         diagnostics,
         gitRepositoryAvailable: typeof toolContext.directory === "string" ? directoryHasGitMetadata(toolContext.directory) : undefined,
         explicitSearch: true,
+        rerankConnectionFile: deps.rerankConnectionFile,
         searchMessageHistory: (request) => searchMessageHistoryOffThread(deps.db, request),
         ...dateRange
       });
@@ -50608,7 +50361,7 @@ async function registerTools(context, db, config, rustToolBackends, isInternalCh
       smartNotesEnabled: config.smart_notes.enabled,
       ...rustToolBackends ? { rustToolBackends } : {}
     }),
-    ...createCtxSearchTools(project),
+    ...createCtxSearchTools({ ...project, rerankConnectionFile: config.subc?.connection_file }),
     ...config.memory.enabled ? {
       ...createCtxMemoryTools({
         ...project,
@@ -51079,6 +50832,7 @@ async function registerContext(context) {
       keepSubagents: config.keep_subagents === true,
       ensureAgent: () => hiddenAgentsReady ??= context.agent.reload(),
       modelCatalog: () => Promise.resolve(context.model.list()),
+      historianTemperature: () => config.historian?.temperature,
       openReader: openStoreReader
     });
   };
@@ -51389,6 +51143,7 @@ async function registerContext(context) {
         }
         if (event.type === "session.deleted") {
           deletedSessions.add(sessionID);
+          transform?.clearSessionLogState(sessionID);
           if (db) {
             markSessionCleanupPending(db, sessionID);
             clearSession(db, sessionID);
@@ -51922,10 +51677,12 @@ ${baseline}
     }
   };
   await context.session.hook("context", (draft) => withSqliteTransformPass2(async () => {
-    const anchor = draft.messages.at(-1)?.id;
+    const anchor = generateReplayAnchor(draft.messages);
     await runManagedContext(draft);
-    if (!compactionOff && draft.messages.some((message) => message.id === HEAD_IDS[0] || message.content.some((part) => typeof part.text === "string" && part.text.includes("<session-history>"))))
+    if (!compactionOff)
       generateReplay.capture(draft, anchor);
+    else
+      sessionLog2(draft.sessionID, "generate replay capture skipped: compaction-disabled");
   }));
   await context.session.hook("generate", async (draft) => {
     if (!compactionOff && !deletedSessions.has(draft.sessionID))