@cortexkit/opencode-magic-context 0.49.9 → 0.49.11

package/dist/v2/{context-z2yagwy4.js → context-p1zfcw41.js}

@@ -9,7 +9,7 @@ import {
   resolveLegacyConfigSources,
   getProtectedTokensTierOverrides,
   loadPluginConfigDetailed
-} from "./server-4qr18rfg.js";
+} from "./server-5x7kmyz8.js";
 import {
   getHarness2,
   harnessOwnsOpenCodeStore2
@@ -38,6 +38,7 @@ import {
   getModelsDevCacheState
 } from "./server-nveratm5.js";
 import {
+  isValidLanguageCode,
   withContentLanguageDirective,
   parseCron,
   nextOccurrence,
@@ -48,7 +49,7 @@ import {
   DEFAULT_HISTORIAN_TIMEOUT_MS,
   DEFAULT_LOCAL_EMBEDDING_MODEL,
   DREAM_TASK_PROMOTION_DEFAULTS
-} from "./server-7e087rvk.js";
+} from "./server-jc8v585p.js";
 import {
   historianRunConfig,
   dreamerRunConfig,
@@ -57,8 +58,11 @@ import {
   withLiveDreamerOutputCap,
   embedPauseBySession,
   embedRunStateBySession,
+  autoEmbedAttemptedBySession,
+  autoEmbedIdentityBySession,
   invalidateAutoEmbedSession,
   getEmbedDrainUiStatus,
+  clearEmbedSessionState,
   acquireCompartmentLease,
   releaseCompartmentLeaseBestEffort,
   isCompartmentLeaseHeld,
@@ -201,12 +205,13 @@ import {
   createPromptAsyncTransport,
   CTX_NOTE_LIGHT_DESCRIPTION,
   ACTIVE_TOOL_IDS,
-  promptSurfaceHashMaterial,
+  systemPromptFingerprint,
   createPromptSurfaceRuntime,
   createPromptSurfaceGuidanceEpochCache,
   MARKER_SUMMARY_TEXT,
   markerUpdateDefinitelyDidNotCut,
   applyDeferredCompactionMarker,
+  isProjectMemoryEnabled,
   teardownChildSession,
   runTokenLog,
   formatRunTokenLog,
@@ -265,7 +270,7 @@ import {
   startCompartmentAgent,
   setRecompStarting2,
   setRecompTerminal2
-} from "./server-c9w52qss.js";
+} from "./server-7fvmt15t.js";
 import {
   CANONICAL_DREAM_TASKS,
   DREAM_TASK_CAPABILITIES,
@@ -296,6 +301,7 @@ import {
   getMigrationOnOpenRefusal,
   LATEST_SUPPORTED_VERSION,
   BOOT_SQLITE_BUSY_TIMEOUT_MS,
+  getDatabasePath,
   getPersistedSchemaVersion,
   runSqliteOptimize,
   openDatabase,
@@ -303,7 +309,7 @@ import {
   openDatabaseAsync,
   isDatabasePersisted,
   getDatabasePersistenceError
-} from "./server-23znwjqk.js";
+} from "./server-erfp0xb6.js";
 import {
   setHomeProjectPermission,
   shouldSkipHomeProjectMemory,
@@ -506,7 +512,7 @@ import {
   readRawSessionMessageById2,
   readSessionChunk2,
   readRawSessionSeedTail2
-} from "./server-gc8x2xdb.js";
+} from "./server-wkhfyzpg.js";
 import {
   textMentionsRecentCommit,
   hasMeaningfulUserText2,
@@ -543,7 +549,7 @@ import {
 import"./server-63ha7f0f.js";
 import {
   deleteChunkEmbedBackoffForSession
-} from "./server-9a6bwc12.js";
+} from "./server-ewqshbs8.js";
 import {
   registerOwnRpcServerInstance,
   rpcPortDir,
@@ -569,7 +575,7 @@ import {
   isMessageIndexReconciledThrough2,
   indexMessagesAfterOrdinal2,
   sweepOrphanedOpenCodeMessageIndexes2
-} from "./server-z0rjemg1.js";
+} from "./server-d3f4g62c.js";
 import {
   stableStringify,
   getTemporalDecisions,
@@ -691,7 +697,7 @@ import {
   latestRealUserTurnIdFromOpenCodeDb,
   getMessageTimesFromOpenCodeDb,
   findLastAssistantModelFromOpenCodeDb
-} from "./server-zrwaj29a.js";
+} from "./server-d6t16r89.js";
 import {
   getCurrentToolSetHash,
   recordToolDefinition,
@@ -735,9 +741,12 @@ import {
   embedUnembeddedMemoriesForProjectOutcome2,
   drainCommitBacklogForProject2,
   embedSessionCompartmentChunks2,
-  getEmbeddingCoverageStatus2
-} from "./server-4easnf78.js";
-import"./server-fb3zxn06.js";
+  getEmbeddingCoverageStatus2,
+  getAutoEmbeddingSessionCoverage2
+} from "./server-sg68np13.js";
+import {
+  configureContextDatabasePragmas2
+} from "./server-fb3zxn06.js";
 import {
   SESSION_NOTE_CONDITION_ERROR,
   getNoteByIdInScope,
@@ -780,7 +789,7 @@ import {
   readGitFileChangeTimesSince,
   verificationFileExists,
   normalizeVerificationFiles
-} from "./server-4zwx20yg.js";
+} from "./server-kn7skz9r.js";
 import {
   deriveTriggerBudget2,
   deriveHistorianChunkTokens2,
@@ -799,10 +808,10 @@ import {
 } from "./server-4dhv7mqz.js";
 import {
   getLocalEmbeddingNativeMemoryStats
-} from "./server-44ryn9rb.js";
+} from "./server-83d71zab.js";
 import {
   cosineSimilarity
-} from "./server-4rs8sm06.js";
+} from "./server-rxcq4t50.js";
 import {
   computeCueContentHash,
   hasMuralCueColumns,
@@ -839,7 +848,7 @@ import"./server-ckrb5rm8.js";
 import {
   flushIgnoredMessages2,
   sendStatusNotification2
-} from "./server-ak7w74j9.js";
+} from "./server-h3wc20sv.js";
 import {
   renderSingleStoreMigrationRequiredRefusal,
   SingleStoreMigrationRequiredError,
@@ -860,7 +869,7 @@ import {
   resolveMemoriesByIdsForSearch2,
   unifiedSearch2,
   formatSearchResults2
-} from "./server-2hxypdx5.js";
+} from "./server-pbpp8r8h.js";
 import {
   resolvePromptContext2
 } from "./server-fmsr7v69.js";
@@ -2416,6 +2425,275 @@ function createTagger() {
   };
 }
 
+// src/features/magic-context/transform-decision-log.ts
+var TRANSFORM_DECISIONS_RETENTION = 2000;
+var canonicalReasons = new Set([
+  "system_hash",
+  "model_change",
+  "project_memory_epoch",
+  "ttl_idle",
+  "explicit_flush",
+  "user_flush",
+  "fit_retry",
+  "pending_materialization",
+  "variant_change",
+  "recomp",
+  "boundary_repair",
+  "host_history_change",
+  "thinking_hold",
+  "mutation_drift",
+  "max_mutation_id",
+  "first_render",
+  "pressure_refold",
+  "upgrade_state",
+  "cached_m1_missing",
+  "project_change",
+  "compartment_render_epoch",
+  "m1_delta",
+  "ttl_expiry",
+  "epoch_change",
+  "coverage_fold",
+  "profile_transition",
+  "host_compaction",
+  "tag_identity_repair"
+]);
+var piReasonAliases = {
+  project_memory_change: "project_memory_epoch",
+  pending_mutations: "max_mutation_id",
+  renderer_upgrade: "upgrade_state",
+  cache_invalid: "cached_m1_missing",
+  drift: "pressure_refold"
+};
+var sharedReasonAliases = {
+  model_key: "model_change",
+  pressure: "pressure_refold"
+};
+var pendingDecisionBySession = new Map;
+var pendingPiDecisionBySession = new Map;
+var lastBoundMessageIdBySession = new Map;
+var scheduledWriteTokensBySession = new Map;
+var systemHashChangedSessions = new Set;
+var piSystemHashChangedSessions = new Set;
+var unbustedPassBySession = new Map;
+var newestInputAssistantBySession = new Map;
+var stagedV2DecisionBySession = new Map;
+var writerOverrideForTests = null;
+var retentionOverrideForTests = null;
+function normalizeMaterializeReason(harness, reason, rematerialized) {
+  const raw = typeof reason === "string" ? reason.trim() : "";
+  if (raw.length > 0) {
+    const alias = sharedReasonAliases[raw] ?? (harness === "pi" ? piReasonAliases[raw] : undefined) ?? undefined;
+    if (alias)
+      return alias;
+    if (canonicalReasons.has(raw))
+      return raw;
+    return null;
+  }
+  return rematerialized ? "pressure_refold" : null;
+}
+function writeRustTransformDecision(args) {
+  const rawDecision = args.decision.trim();
+  const decisionUpper = rawDecision.toUpperCase();
+  const mapped = decisionUpper === "HARD" || decisionUpper === "MIGRATE_HARD" ? { decision: "execute", materialized: true, bustedThisPass: true } : decisionUpper === "SOFT" || decisionUpper === "EXECUTE" || args.materializeReason === "ttl_idle" ? { decision: "execute", materialized: false, bustedThisPass: true } : decisionUpper === "SOFT+" ? { decision: "defer", materialized: false, bustedThisPass: false } : {
+    decision: rawDecision.toLowerCase() || "unknown",
+    materialized: false,
+    bustedThisPass: false
+  };
+  pendingDecisionBySession.set(args.sessionId, {
+    tsMs: args.tsMs ?? Date.now(),
+    decision: mapped.decision,
+    materialized: mapped.materialized,
+    materializeReason: args.materializeReason,
+    systemHashPrev: null,
+    systemHashNew: null,
+    m0ModelKeyPrev: null,
+    m0ModelKeyNew: null,
+    m0ToolSetHashPrev: null,
+    m0ToolSetHashNew: null,
+    emergency: false,
+    droppedTokens: 0,
+    droppedCount: 0,
+    inputTokens: args.inputTokens,
+    bustedThisPass: mapped.bustedThisPass,
+    lkgFrozenReleaseReason: args.lkgFrozenReleaseReason
+  });
+}
+function clearOpenCodePendingTransformDecision(sessionId, inputMessages) {
+  pendingDecisionBySession.delete(sessionId);
+  unbustedPassBySession.delete(sessionId);
+  if (!inputMessages)
+    return;
+  let newestAssistant = "";
+  for (const message of inputMessages) {
+    const id = message.info?.id;
+    if (message.info?.role !== "assistant" || typeof id !== "string")
+      continue;
+    if (id > newestAssistant)
+      newestAssistant = id;
+  }
+  newestInputAssistantBySession.set(sessionId, newestAssistant);
+}
+function noteSystemPromptHashChange(sessionId) {
+  systemHashChangedSessions.add(sessionId);
+}
+function noteOpenCodeUnbustedPass(sessionId, decision) {
+  unbustedPassBySession.set(sessionId, decision);
+}
+var IDLE_EXPIRY_REASONS = new Set([
+  "ttl_idle",
+  "ttl_expiry"
+]);
+function withSystemHashReason(decision) {
+  if (IDLE_EXPIRY_REASONS.has(decision.materializeReason))
+    return decision;
+  return { ...decision, materializeReason: "system_hash" };
+}
+function unknownPassDecision() {
+  return {
+    tsMs: Date.now(),
+    decision: "unknown",
+    materialized: false,
+    materializeReason: null,
+    systemHashPrev: null,
+    systemHashNew: null,
+    m0ModelKeyPrev: null,
+    m0ModelKeyNew: null,
+    emergency: false,
+    droppedTokens: 0,
+    droppedCount: 0,
+    inputTokens: 0,
+    bustedThisPass: false
+  };
+}
+function takeOpenCodeDecisionForBinding(sessionId, applySystemHashChange) {
+  const pending = pendingDecisionBySession.get(sessionId);
+  const unbusted = unbustedPassBySession.get(sessionId);
+  pendingDecisionBySession.delete(sessionId);
+  unbustedPassBySession.delete(sessionId);
+  if (!applySystemHashChange || !systemHashChangedSessions.has(sessionId))
+    return pending;
+  systemHashChangedSessions.delete(sessionId);
+  return withSystemHashReason(pending ?? unbusted ?? unknownPassDecision());
+}
+function recordPendingTransformDecision(sessionId, decision) {
+  if (!decision.bustedThisPass) {
+    pendingDecisionBySession.delete(sessionId);
+    return;
+  }
+  pendingDecisionBySession.set(sessionId, decision);
+}
+function stageOpenCodeV2TransformDecision(args) {
+  const systemHashChanged = systemHashChangedSessions.has(args.sessionId);
+  const decision = takeOpenCodeDecisionForBinding(args.sessionId, true);
+  stagedV2DecisionBySession.delete(args.sessionId);
+  if (!decision || args.responseAfterSequence === undefined)
+    return false;
+  if (!decision.bustedThisPass && !systemHashChanged)
+    return false;
+  stagedV2DecisionBySession.set(args.sessionId, {
+    decision,
+    responseAfterSequence: args.responseAfterSequence
+  });
+  return true;
+}
+function bindOpenCodeV2TransformDecision(args) {
+  const staged = stagedV2DecisionBySession.get(args.sessionId);
+  if (!staged)
+    return false;
+  const reply = args.firstAssistantAfter(staged.responseAfterSequence);
+  if (!reply || reply.state === "running") {
+    if (args.passStarting)
+      stagedV2DecisionBySession.delete(args.sessionId);
+    return false;
+  }
+  stagedV2DecisionBySession.delete(args.sessionId);
+  if (reply.state === "failed")
+    return false;
+  const dbPath = getDatabasePath(args.db);
+  if (!dbPath)
+    return false;
+  const token = addScheduledWriteToken(args.sessionId);
+  inRootAsyncContext2(() => setTimeout(() => {
+    try {
+      if (!hasScheduledWriteToken(args.sessionId, token))
+        return;
+      writeTransformDecisionBestEffort(dbPath, {
+        ...staged.decision,
+        sessionId: args.sessionId,
+        harness: "opencode2",
+        messageId: reply.id,
+        inputTokens: Number.isFinite(reply.inputTokens) ? reply.inputTokens : staged.decision.inputTokens
+      });
+    } finally {
+      deleteScheduledWriteToken(args.sessionId, token);
+    }
+  }, 0));
+  return true;
+}
+function addScheduledWriteToken(sessionId) {
+  const token = Symbol(sessionId);
+  let tokens = scheduledWriteTokensBySession.get(sessionId);
+  if (!tokens) {
+    tokens = new Set;
+    scheduledWriteTokensBySession.set(sessionId, tokens);
+  }
+  tokens.add(token);
+  return token;
+}
+function hasScheduledWriteToken(sessionId, token) {
+  return scheduledWriteTokensBySession.get(sessionId)?.has(token) === true;
+}
+function deleteScheduledWriteToken(sessionId, token) {
+  const tokens = scheduledWriteTokensBySession.get(sessionId);
+  if (!tokens)
+    return;
+  tokens.delete(token);
+  if (tokens.size === 0)
+    scheduledWriteTokensBySession.delete(sessionId);
+}
+function writeTransformDecisionBestEffort(dbPath, row) {
+  try {
+    const writer = writerOverrideForTests ?? writeTransformDecisionRow;
+    writer(dbPath, row);
+  } catch {}
+}
+function writeTransformDecisionRow(dbPath, row) {
+  const db = new Database2(dbPath);
+  try {
+    db.exec("PRAGMA busy_timeout=0");
+    configureContextDatabasePragmas2(db);
+    writeTransformDecisionRowOnDatabase(db, row, true);
+  } finally {
+    closeQuietly(db);
+  }
+}
+function writeTransformDecisionRowOnDatabase(db, row, configureBusyTimeout) {
+  if (configureBusyTimeout)
+    db.exec("PRAGMA busy_timeout=0");
+  const systemHashPrev = row.materialized ? row.systemHashPrev : null;
+  const systemHashNew = row.materialized ? row.systemHashNew : null;
+  const m0ModelKeyPrev = row.materialized ? row.m0ModelKeyPrev : null;
+  const m0ModelKeyNew = row.materialized ? row.m0ModelKeyNew : null;
+  const m0ToolSetHashPrev = row.m0ToolSetHashPrev ?? null;
+  const m0ToolSetHashNew = row.m0ToolSetHashNew ?? null;
+  const persistedMaterializeReason = row.lkgFrozenReleaseReason ? `lkg_frozen_release:${row.lkgFrozenReleaseReason}` + (row.materializeReason ? `;materialize_reason=${row.materializeReason}` : "") : row.materializeReason;
+  db.prepare(`INSERT OR REPLACE INTO transform_decisions (
+                session_id, harness, message_id, ts_ms, decision, materialized,
+                materialize_reason, system_hash_prev, system_hash_new,
+                m0_tool_set_hash_prev, m0_tool_set_hash_new,
+                m0_model_key_prev, m0_model_key_new, emergency, dropped_tokens,
+                dropped_count, input_tokens
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.sessionId, row.harness, row.messageId, row.tsMs, row.decision, row.materialized ? 1 : 0, persistedMaterializeReason, systemHashPrev, systemHashNew, m0ToolSetHashPrev, m0ToolSetHashNew, m0ModelKeyPrev, m0ModelKeyNew, row.emergency ? 1 : 0, Math.max(0, Math.floor(row.droppedTokens)), Math.max(0, Math.floor(row.droppedCount)), Math.max(0, Math.floor(row.inputTokens)));
+  db.prepare(`DELETE FROM transform_decisions
+             WHERE session_id = ? AND harness = ?
+               AND rowid NOT IN (
+                 SELECT rowid FROM transform_decisions
+                 WHERE session_id = ? AND harness = ?
+                 ORDER BY ts_ms DESC, rowid DESC
+                 LIMIT ?
+               )`).run(row.sessionId, row.harness, row.sessionId, row.harness, retentionOverrideForTests ?? TRANSFORM_DECISIONS_RETENTION);
+}
+
 // src/hooks/magic-context/ctx-reduce-availability.ts
 var ctxReduceRegisteredGlobally = true;
 function setCtxReduceRegisteredGlobally(registered) {
@@ -3628,6 +3906,12 @@ function applyUltraAbbreviationsUnicode(text) {
   return working;
 }
 var CURRENT_CAVEMAN_RULES = "unicode-v2";
+function cavemanWordRulesForLanguage(language) {
+  const code = typeof language === "string" ? language.trim().toLowerCase() : "";
+  if (code === "en" || code.startsWith("en-"))
+    return "english";
+  return isValidLanguageCode(code) ? "none" : "english";
+}
 function cavemanCompress(text, level, rules = CURRENT_CAVEMAN_RULES, wordRules = "english") {
   if (text.length === 0)
     return text;
@@ -6494,6 +6778,36 @@ function createModuleToolBackends(options) {
   };
 }
 
+// src/hooks/magic-context/render-options.ts
+function createM0RenderOptions(controls, contextUsage, modelKey, resolvedContextLimit, projectPath) {
+  return {
+    projectPath: controls.memoryConfig?.enabled ? projectPath : undefined,
+    memoryEnabled: controls.memoryConfig?.enabled,
+    memoryInjectionBudgetTokens: controls.memoryConfig?.injectionBudgetTokens,
+    injectDocs: controls.injectDocs,
+    muralEnabled: controls.muralEnabled,
+    temporalAwareness: controls.experimentalTemporalAwareness,
+    historyBudgetTokens: resolveHistoryBudgetTokens(controls.historyBudgetPercentage, contextUsage, controls.executeThresholdPercentage, modelKey, controls.executeThresholdTokens, resolvedContextLimit),
+    historyBudgetPolicyIdentity: historyBudgetPolicyIdentity(controls.historyBudgetPercentage, controls.executeThresholdPercentage, modelKey, controls.executeThresholdTokens)
+  };
+}
+function resolveHistoryBudgetTokens(historyBudgetPercentage, contextUsage, executeThresholdPercentage, modelKey, executeThresholdTokens, resolvedContextLimit) {
+  if (!historyBudgetPercentage)
+    return;
+  let contextLimit = resolvedContextLimit && resolvedContextLimit > 0 ? resolvedContextLimit : 0;
+  if (contextLimit <= 0) {
+    if (contextUsage.percentage <= 0)
+      return;
+    contextLimit = contextUsage.inputTokens / (contextUsage.percentage / 100);
+  }
+  if (!Number.isFinite(contextLimit) || contextLimit <= 0)
+    return;
+  return Math.floor(contextLimit * (resolveExecuteThreshold(executeThresholdPercentage ?? 65, modelKey, 65, {
+    tokensConfig: executeThresholdTokens,
+    contextLimit
+  }) / 100) * historyBudgetPercentage);
+}
+
 // src/hooks/magic-context/apply-operations.ts
 var RECENT_TOOL_SKELETON_WINDOW = 20;
 function buildReplacementContent(tagId) {
@@ -10691,9 +11005,6 @@ class StorageBusyRefusalError extends Error {
   }
 }
 
-// src/hooks/magic-context/system-prompt-hash.ts
-import { createHash } from "node:crypto";
-
 // src/hooks/magic-context/system-prompt-dates.ts
 function replaceHostDates(prompt, replace) {
   const fields = /<(plugin-env|environment|env)>[\s\S]*?<\/\1>|Today's date: [^\r\n<]+/g;
@@ -10940,7 +11251,7 @@ function createSystemPromptHashHandler(deps) {
     const dates = systemPromptDates(liveSystemContent, stickyDate);
     const currentDate = dates.live;
     const stableCandidate = dates.stable;
-    const stableCandidateHash = createHash("md5").update(promptSurfaceHashMaterial(stableCandidate, promptSurface.preset)).digest("hex");
+    const stableCandidateHash = systemPromptFingerprint(stableCandidate, promptSurface.preset);
     const contentOrPresetChanged = hasPersistedHash && stableCandidateHash !== previousHash;
     const rewritePermission = systemDateRefreshPermission(deps.historyRefreshSessions, dateRequest);
     let deferredDateRefresh = false;
@@ -10954,7 +11265,7 @@ function createSystemPromptHashHandler(deps) {
         try {
           const content = liveElements.join(`
 `);
-          const hash = createHash("md5").update(promptSurfaceHashMaterial(content, promptSurface.preset)).digest("hex");
+          const hash = systemPromptFingerprint(content, promptSurface.preset);
           updateSessionMeta(deps.db, sessionId, {
             systemPromptHash: hash,
             cachedM0SystemHash: hash,
@@ -10994,7 +11305,7 @@ function createSystemPromptHashHandler(deps) {
 `);
     if (!availability.frozen || !modelKey)
       return;
-    const currentHash = createHash("md5").update(promptSurfaceHashMaterial(systemContent, promptSurface.preset)).digest("hex");
+    const currentHash = systemPromptFingerprint(systemContent, promptSurface.preset);
     recordSystemPromptForRequest(sessionId, currentLkgRequestIdentity(sessionId), currentHash, deps.db, previousHash !== currentHash ? !deps.historyRefreshSessions.has(sessionId) : undefined, deps.historyRefreshSessions, deps.pendingMaterializationSessions);
     if (!sessionMetaEarly) {
       return;
@@ -11002,6 +11313,7 @@ function createSystemPromptHashHandler(deps) {
     const sessionMeta = sessionMetaEarly;
     if (previousHash !== "" && previousHash !== "0" && previousHash !== currentHash) {
       sessionLog2(sessionId, `system prompt hash changed: ${previousHash} → ${currentHash} (len=${systemContent.length}), ${idleCacheExpired ? "adopting on idle-expired request" : requestMessagesFinal ? "adopting on the request whose messages are already final" : "triggering flush"}`);
+      noteSystemPromptHashChange(sessionId);
       if (!adoptSystemChange) {
         deps.historyRefreshSessions.add(sessionId);
         deps.systemPromptRefreshSessions.add(sessionId);
@@ -11054,102 +11366,6 @@ function createSystemPromptHashHandler(deps) {
   };
 }
 
-// src/features/magic-context/transform-decision-log.ts
-var canonicalReasons = new Set([
-  "system_hash",
-  "model_change",
-  "project_memory_epoch",
-  "ttl_idle",
-  "explicit_flush",
-  "user_flush",
-  "fit_retry",
-  "pending_materialization",
-  "variant_change",
-  "recomp",
-  "boundary_repair",
-  "host_history_change",
-  "thinking_hold",
-  "mutation_drift",
-  "max_mutation_id",
-  "first_render",
-  "pressure_refold",
-  "upgrade_state",
-  "cached_m1_missing",
-  "project_change",
-  "compartment_render_epoch",
-  "m1_delta",
-  "ttl_expiry",
-  "epoch_change",
-  "coverage_fold",
-  "profile_transition",
-  "host_compaction",
-  "tag_identity_repair"
-]);
-var piReasonAliases = {
-  project_memory_change: "project_memory_epoch",
-  pending_mutations: "max_mutation_id",
-  renderer_upgrade: "upgrade_state",
-  cache_invalid: "cached_m1_missing",
-  drift: "pressure_refold"
-};
-var sharedReasonAliases = {
-  model_key: "model_change",
-  pressure: "pressure_refold"
-};
-var pendingDecisionBySession = new Map;
-var pendingPiDecisionBySession = new Map;
-var lastBoundMessageIdBySession = new Map;
-var scheduledWriteTokensBySession = new Map;
-function normalizeMaterializeReason(harness, reason, rematerialized) {
-  const raw = typeof reason === "string" ? reason.trim() : "";
-  if (raw.length > 0) {
-    const alias = sharedReasonAliases[raw] ?? (harness === "pi" ? piReasonAliases[raw] : undefined) ?? undefined;
-    if (alias)
-      return alias;
-    if (canonicalReasons.has(raw))
-      return raw;
-    return null;
-  }
-  return rematerialized ? "pressure_refold" : null;
-}
-function writeRustTransformDecision(args) {
-  const rawDecision = args.decision.trim();
-  const decisionUpper = rawDecision.toUpperCase();
-  const mapped = decisionUpper === "HARD" || decisionUpper === "MIGRATE_HARD" ? { decision: "execute", materialized: true, bustedThisPass: true } : decisionUpper === "SOFT" || decisionUpper === "EXECUTE" || args.materializeReason === "ttl_idle" ? { decision: "execute", materialized: false, bustedThisPass: true } : decisionUpper === "SOFT+" ? { decision: "defer", materialized: false, bustedThisPass: false } : {
-    decision: rawDecision.toLowerCase() || "unknown",
-    materialized: false,
-    bustedThisPass: false
-  };
-  pendingDecisionBySession.set(args.sessionId, {
-    tsMs: args.tsMs ?? Date.now(),
-    decision: mapped.decision,
-    materialized: mapped.materialized,
-    materializeReason: args.materializeReason,
-    systemHashPrev: null,
-    systemHashNew: null,
-    m0ModelKeyPrev: null,
-    m0ModelKeyNew: null,
-    m0ToolSetHashPrev: null,
-    m0ToolSetHashNew: null,
-    emergency: false,
-    droppedTokens: 0,
-    droppedCount: 0,
-    inputTokens: args.inputTokens,
-    bustedThisPass: mapped.bustedThisPass,
-    lkgFrozenReleaseReason: args.lkgFrozenReleaseReason
-  });
-}
-function clearOpenCodePendingTransformDecision(sessionId) {
-  pendingDecisionBySession.delete(sessionId);
-}
-function recordPendingTransformDecision(sessionId, decision) {
-  if (!decision.bustedThisPass) {
-    pendingDecisionBySession.delete(sessionId);
-    return;
-  }
-  pendingDecisionBySession.set(sessionId, decision);
-}
-
 // src/hooks/magic-context/compaction-off-transition.ts
 import { existsSync } from "node:fs";
 var loggedUnverifiedMarkerCleanupRetry = false;
@@ -11359,7 +11575,7 @@ function createPassOutcome() {
 }
 
 // src/hooks/magic-context/rust-mode-transform.ts
-import { createHash as createHash5, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID2 } from "node:crypto";
 
 // src/features/magic-context/memory/single-store-embedding-drain.ts
 function isWatermarkRow(row) {
@@ -11423,7 +11639,7 @@ function advanceEmbeddedWatermark(db, projectPath, upTo) {
 }
 
 // src/features/magic-context/mural/source-revision.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash } from "node:crypto";
 var statements = new WeakMap;
 function muralSourceRevision(db, projectPath) {
   let statement = statements.get(db);
@@ -11440,7 +11656,7 @@ function muralSourceRevision(db, projectPath) {
     statements.set(db, statement);
   }
   const row = statement.get(projectPath, Date.now());
-  return createHash2("sha256").update(row.revision).digest("hex");
+  return createHash("sha256").update(row.revision).digest("hex");
 }
 
 // src/features/magic-context/install-instance-id.ts
@@ -13814,7 +14030,7 @@ function noteExternalLkgReplay(participant, sessionId, inputMessages, servedMess
 }
 
 // src/hooks/magic-context/rust-served-raw.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 class RustServedRawConflict extends EmergencyFailClosedError {
   reason;
   messageIds;
@@ -13828,7 +14044,7 @@ class RustServedRawConflict extends EmergencyFailClosedError {
 }
 function partDigest(part) {
   const serialized = JSON.stringify(part);
-  return createHash4("sha256").update(stableStringify(serialized === undefined ? undefined : JSON.parse(serialized))).digest("hex");
+  return createHash3("sha256").update(stableStringify(serialized === undefined ? undefined : JSON.parse(serialized))).digest("hex");
 }
 function records(doc) {
   if (doc.rustServedRaw === undefined)
@@ -14316,10 +14532,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 `${messageIdOf(message) ?? ""}:${parts.length}:${Buffer.byteLength(serializedParts)}:${createHash5("sha256").update(serializedMessage).digest("hex")}`;
+  return `${messageIdOf(message) ?? ""}:${parts.length}:${Buffer.byteLength(serializedParts)}:${createHash4("sha256").update(serializedMessage).digest("hex")}`;
 }
 function advanceWireFingerprint(previous, encoded) {
-  return createHash5("sha256").update(previous).update("\\0").update(JSON.stringify(encoded) ?? "null").digest("hex");
+  return createHash4("sha256").update(previous).update("\\0").update(JSON.stringify(encoded) ?? "null").digest("hex");
 }
 function buildWireFingerprint(encoded) {
   let fingerprint = "rust-wire-v1";
@@ -16100,7 +16316,7 @@ function createRustModeTransform(deps, options) {
         const id = messageIdOf(message) ?? `index:${todoStart + offset}`;
         const parts = message.parts?.filter((part) => isRecord4(part) && part.type === "tool" && part.tool === "todowrite");
         if (parts?.length) {
-          todoCalls.set(id, createHash5("sha256").update(JSON.stringify(parts)).digest("hex"));
+          todoCalls.set(id, createHash4("sha256").update(JSON.stringify(parts)).digest("hex"));
         } else {
           todoCalls.delete(id);
         }
@@ -17790,7 +18006,7 @@ function createTransform(deps) {
       return historianRun?.toastDurationMs === undefined ? params : { ...params, toastDurationMs: historianRun.toastDurationMs };
     };
     beginLkgPass(sessionId);
-    clearOpenCodePendingTransformDecision(sessionId);
+    clearOpenCodePendingTransformDecision(sessionId, messages);
     const db = deps.db;
     try {
       const tPrepare = performance.now();
@@ -18157,9 +18373,10 @@ function createTransform(deps) {
     const persistedUsageFreshForBoundary = persistedUsageBeforeResets && Date.now() - persistedUsageBeforeResets.updatedAt <= 10 * 60 * 1000 && (persistedUsageBeforeResets.lastObservedModelKey === null || currentModelKeyForBoundary === undefined || piModelRefToCanonical(persistedUsageBeforeResets.lastObservedModelKey) === piModelRefToCanonical(currentModelKeyForBoundary)) && (resolvedContextLimit === undefined || persistedUsageBeforeResets.lastUsageContextLimit === 0 || persistedUsageBeforeResets.lastUsageContextLimit === resolvedContextLimit) ? persistedUsageBeforeResets.usage : null;
     const boundaryUsageForProtectedTail = persistedUsageFreshForBoundary ?? contextUsageEarly;
     const boundaryUsageSource = persistedUsageFreshForBoundary ? "persisted" : "live";
-    const historyPolicyIdentity = historyBudgetPolicyIdentity(deps.historyBudgetPercentage, deps.executeThresholdPercentage, currentModelKeyForBoundary, deps.executeThresholdTokens);
     const historyContextLimit = resolvedContextLimit ?? (currentModelKeyForBoundary && persistedUsageBeforeResets?.lastObservedModelKey && piModelRefToCanonical(currentModelKeyForBoundary) === piModelRefToCanonical(persistedUsageBeforeResets.lastObservedModelKey) && persistedUsageBeforeResets.lastUsageContextLimit > 0 ? persistedUsageBeforeResets.lastUsageContextLimit : undefined);
-    const historyBudgetTokens = resolveHistoryBudgetTokens(deps.historyBudgetPercentage, contextUsageEarly, deps.executeThresholdPercentage, deps.getModelKey?.(sessionId), deps.executeThresholdTokens, historyContextLimit);
+    const memoryProjectDirectory = compartmentDirectory || process.cwd();
+    const renderOptions = createM0RenderOptions(deps, contextUsageEarly, currentModelKeyForBoundary, historyContextLimit, deps.memoryConfig?.enabled ? resolveProjectIdentityForSession(memoryProjectDirectory, deps.allowHomeProject) : undefined);
+    const { historyBudgetTokens, projectPath: projectIdentity } = renderOptions;
     const emergencyCeilingLimit = thresholdContextLimit ?? 0;
     const emergencyCeilingTokens = Number.isFinite(emergencyCeilingLimit) && emergencyCeilingLimit > 0 ? Math.floor(emergencyCeilingLimit * (effectiveExecuteThresholdPercentage / 100)) : undefined;
     const schedulerDecision = compactionOff ? "defer" : resolveSchedulerDecision(deps.scheduler, sessionMeta, contextUsageEarly, sessionId, deps.getModelKey?.(sessionId), resolvedContextLimit);
@@ -18293,8 +18510,6 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       });
     }
     logTransformTiming(sessionId, "emergencyRecoveryBlock", tFirstPass);
-    const memoryProjectDirectory = compartmentDirectory || process.cwd();
-    const projectIdentity = deps.memoryConfig?.enabled ? resolveProjectIdentityForSession(memoryProjectDirectory, deps.allowHomeProject) : undefined;
     if (deps.memoryConfig?.enabled) {
       maybeSendProjectIdentityWarning(deps, sessionId, memoryProjectDirectory, notificationParams);
     }
@@ -18579,14 +18794,8 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       db,
       sessionId,
       state: sessionMeta,
-      projectPath: projectIdentity,
       projectDirectory: sessionDirectory,
-      injectDocs: deps.injectDocs,
-      memoryEnabled: deps.memoryConfig?.enabled,
-      muralEnabled: deps.muralEnabled,
-      memoryInjectionBudgetTokens: deps.memoryConfig?.injectionBudgetTokens,
-      historyBudgetTokens,
-      historyBudgetPolicyIdentity: historyPolicyIdentity,
+      ...renderOptions,
       hardSignals: m0HardSignals
     }).value;
     const protectionCacheBustingPass = !compactionOff && (schedulerDecision === "execute" || isCacheBusting || contextUsage.percentage >= forceMaterializationPercentage || deps.pendingMaterializationSessions.has(sessionId) || canConsumeDeferredLate && deferredMaterializationSessions.has(sessionId) || protectionFoldWillBust);
@@ -18727,16 +18936,9 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       passOutcome,
       historyRefreshSessions: deps.historyRefreshSessions,
       m0M1: {
-        projectPath: projectIdentity,
         projectDirectory: sessionDirectory,
-        injectDocs: deps.injectDocs,
-        memoryEnabled: deps.memoryConfig?.enabled,
-        memoryInjectionBudgetTokens: deps.memoryConfig?.injectionBudgetTokens,
-        historyBudgetTokens,
-        historyBudgetPolicyIdentity: historyPolicyIdentity,
-        temporalAwareness: deps.experimentalTemporalAwareness,
-        hardSignals: m0HardSignals,
-        muralEnabled: deps.muralEnabled
+        ...renderOptions,
+        hardSignals: m0HardSignals
       }
     });
     if (recovery.prefix && !recoveryNormalized) {
@@ -18980,6 +19182,24 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         bustedThisPass: true,
         lkgFrozenReleaseReason: recoveryReleaseReason
       });
+    } else {
+      noteOpenCodeUnbustedPass(sessionId, {
+        tsMs: Date.now(),
+        decision: schedulerDecision,
+        materialized: postTransformResult.materialized,
+        materializeReason: normalizeMaterializeReason("opencode", postTransformResult.materializeReason, postTransformResult.materialized),
+        systemHashPrev: postTransformResult.systemHashPrev,
+        systemHashNew: postTransformResult.systemHashNew,
+        m0ToolSetHashPrev: postTransformResult.m0ToolSetHashPrev,
+        m0ToolSetHashNew: postTransformResult.m0ToolSetHashNew,
+        m0ModelKeyPrev: postTransformResult.m0ModelKeyPrev,
+        m0ModelKeyNew: postTransformResult.m0ModelKeyNew,
+        emergency: postTransformResult.emergency,
+        droppedTokens: postTransformResult.droppedTokens,
+        droppedCount: postTransformResult.droppedCount,
+        inputTokens: contextUsage.inputTokens,
+        bustedThisPass: false
+      });
     }
     logTransformTiming(sessionId, "postTransformPhase", tPostProcess);
     const msgTokens = getMessageTokensCache(sessionId);
@@ -19110,24 +19330,14 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     }
   });
 }
-function resolveHistoryBudgetTokens(historyBudgetPercentage, contextUsage, executeThresholdPercentage, modelKey, executeThresholdTokens, resolvedContextLimit) {
-  if (!historyBudgetPercentage) {
-    return;
-  }
-  let contextLimit = resolvedContextLimit && resolvedContextLimit > 0 ? resolvedContextLimit : 0;
-  if (contextLimit <= 0) {
-    if (contextUsage.percentage <= 0) {
-      return;
-    }
-    contextLimit = contextUsage.inputTokens / (contextUsage.percentage / 100);
-  }
-  if (!Number.isFinite(contextLimit) || contextLimit <= 0) {
+
+// src/plugin/dream-timer-module-client.ts
+function createDreamTimerModuleClient(moduleClient) {
+  if (!moduleClient)
     return;
-  }
-  return Math.floor(contextLimit * (resolveExecuteThreshold(executeThresholdPercentage ?? 65, modelKey, 65, {
-    tokensConfig: executeThresholdTokens,
-    contextLimit
-  }) / 100) * historyBudgetPercentage);
+  return {
+    call: (args) => moduleClient.call(args)
+  };
 }
 
 // src/shared/recovery-reasoning-prefix.ts
@@ -20762,7 +20972,7 @@ function computeOpenCodeWorkMetricsIncremental(openCodeDb, sessionId, carry) {
 import { readFileSync, statSync } from "node:fs";
 
 // src/plugin/embedding-bootstrap-helpers.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 var EMBEDDING_AFFECTING_KEYS = new Set([
   "embedding.api_key",
   "embedding.endpoint",
@@ -20810,7 +21020,7 @@ var EMBEDDING_WARNING_TERMS = [
 ];
 var loggedFailureSignatures = new Map;
 function sha256Prefix(value, length = 16) {
-  return createHash6("sha256").update(value).digest("hex").slice(0, length);
+  return createHash5("sha256").update(value).digest("hex").slice(0, length);
 }
 function warningLooksEmbeddingRelated(message) {
   const lower = message.toLowerCase();
@@ -22316,8 +22526,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-s5tdpsbs.js"));
-    const { sendIgnoredMessage } = await importPluginModule(() => import("./send-session-notification-6n7chhyp.js"));
+    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-n0pq36f0.js"));
+    const { sendIgnoredMessage } = await importPluginModule(() => import("./send-session-notification-z5mcjdea.js"));
     log2(`[rpc] recomp requested for session ${sessionId}`);
     if (!args.client && !args.hiddenCompletionExecutor) {
       return {
@@ -22401,7 +22611,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-wg8dmmm9.js"));
+    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-87q9d5e2.js"));
     const model = liveSessionState.liveModelBySession.get(sessionId);
     const contextLimit = model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
     const ctx = {
@@ -23390,8 +23600,8 @@ function hostMediaFromEncoded(value) {
 import { randomUUID as randomUUID4 } from "node:crypto";
 
 // src/v2/fold/owner.ts
-import { createHash as createHash7 } from "node:crypto";
-var foldDigest = (value) => createHash7("sha256").update(value).digest("hex");
+import { createHash as createHash6 } from "node:crypto";
+var foldDigest = (value) => createHash6("sha256").update(value).digest("hex");
 
 class FoldOwner {
   storage;
@@ -23834,7 +24044,7 @@ function rebuildFileContent(value, output, attachments) {
     rebuilt.unshift({ type: "text", text: output });
   return { type: "content", value: rebuilt };
 }
-function adaptPayload(draft, admittedIDs = new Set) {
+function adaptPayload(draft, admittedIDs = new Set, messageTimes = new Map) {
   const existingHeads = new Map(draft.messages.filter((m) => HEAD_IDS.some((id) => m.id === id)).map((m) => [m.id, m]));
   const source = draft.messages.filter((m) => !existingHeads.has(m.id));
   const results = new Map;
@@ -23944,6 +24154,7 @@ function adaptPayload(draft, admittedIDs = new Set) {
         id: message.id,
         sessionID: draft.sessionID,
         role: message.role,
+        time: message.id ? messageTimes.get(message.id) : undefined,
         ...{
           providerID: draft.model.providerID,
           modelID: draft.model.id,
@@ -25999,11 +26210,11 @@ class DeletedSessionTombstones {
 }
 
 // src/features/magic-context/dreamer/task-executor.ts
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 import { existsSync as existsSync7, readFileSync as readFileSync8 } from "node:fs";
 
 // src/features/magic-context/mural/compress-cues.ts
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 
 // src/features/magic-context/dreamer/storage-dream-state.ts
 var getDreamStateStatements = new WeakMap;
@@ -26733,7 +26944,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}:${createHash8("sha256").update(chunk.map((candidate) => candidate.memory.id).join(",")).digest("hex").slice(0, 24)}`;
+  const commandId = `mural-cues:${route.moduleCommandId}:${createHash7("sha256").update(chunk.map((candidate) => candidate.memory.id).join(",")).digest("hex").slice(0, 24)}`;
   let response;
   try {
     response = await route.moduleClient.call({
@@ -27321,7 +27532,7 @@ function applyReviewVerdict(args, leaseKey, parsed, result) {
 }
 
 // src/features/magic-context/dreamer/classify.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 
 // src/plugin/rust-tool-backends.ts
 function isRustAuthorityDrainingError(error) {
@@ -27758,7 +27969,7 @@ async function runClassifyThroughModule(args, chunk, anchors, signal, runOnHost)
     if (entry.qualifier)
       modelVariants[entry.model] = entry.qualifier;
   }
-  const commandId = `classify:${args.moduleCommandId ?? Date.now()}:${createHash9("sha256").update(chunk.map((candidate) => candidate.id).join(",")).digest("hex").slice(0, 24)}`;
+  const commandId = `classify:${args.moduleCommandId ?? Date.now()}:${createHash8("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,
@@ -28033,7 +28244,7 @@ function takeCurateSafetyRefusalCount(sessionId) {
 
 // src/features/magic-context/dreamer/docs-proposals.ts
 import { execFileSync } from "node:child_process";
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 import {
   existsSync as existsSync4,
   mkdirSync,
@@ -28048,7 +28259,7 @@ import {
 import { tmpdir } from "node:os";
 import { join as join7 } from "node:path";
 var FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
-var hash = (text) => createHash10("sha256").update(text).digest("hex");
+var hash = (text) => createHash9("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) => [
@@ -28584,7 +28795,7 @@ function throwIfAborted2(signal) {
 }
 
 // src/features/magic-context/smart-notes/compiler.ts
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash10 } 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.
@@ -28923,7 +29134,7 @@ function manifestAdvisoryWarnings(code, manifest) {
   return warnings;
 }
 function hashCheck(surfaceCondition, compiledCheck, manifest, checkCron) {
-  return createHash11("sha256").update(surfaceCondition ?? "").update("\x00").update(compiledCheck).update("\x00").update(JSON.stringify(manifest)).update("\x00").update(checkCron).digest("hex");
+  return createHash10("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);
@@ -29689,7 +29900,7 @@ function snapshotMaintainDocsFiles(docsDir) {
 }
 
 // src/features/magic-context/dreamer/map-memories.ts
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 
 // src/features/magic-context/dreamer/map-memories-prompt.ts
 import { execFile as execFile2 } from "node:child_process";
@@ -29924,7 +30135,7 @@ function readRetries(db, project) {
   }
 }
 function contentKey2(memory) {
-  return createHash12("sha256").update(`${memory.category}
+  return createHash11("sha256").update(`${memory.category}
 ${memory.content}`).digest("hex");
 }
 function isDeferred(memory, retries) {
@@ -30323,7 +30534,7 @@ async function applyParsedBatchMappings(args, batch, parsed, budgetFinalized = f
           name: "memory.set_mapping",
           arguments: {
             memory_project: args.projectIdentity,
-            command_id: `${args.moduleRoute.moduleCommandId}:${createHash12("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
+            command_id: `${args.moduleRoute.moduleCommandId}:${createHash11("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
             rows
           }
         }
@@ -31604,7 +31815,7 @@ function insertDreamRun(db, run) {
 }
 
 // src/features/magic-context/dreamer/verify.ts
-import { createHash as createHash13 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 
 // src/features/magic-context/dreamer/verify-diff.ts
 import { execFile as execFile3 } from "node:child_process";
@@ -32348,7 +32559,7 @@ async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budg
           name: "memory.set_verification",
           arguments: {
             memory_project: args.projectIdentity,
-            command_id: `${args.moduleRoute.moduleCommandId}:${createHash13("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
+            command_id: `${args.moduleRoute.moduleCommandId}:${createHash12("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
             rows
           }
         }
@@ -33154,7 +33365,7 @@ function parseFrictionGateVerdict(verdict) {
 }
 function computeRetrospectiveWindowKey(flagged) {
   const anchors = flagged.map((message) => `${message.sessionId}:${message.ts}`).sort().join("|");
-  return createHash14("sha256").update(anchors).digest("hex").slice(0, 32);
+  return createHash13("sha256").update(anchors).digest("hex").slice(0, 32);
 }
 function renderFrictionWindow(messages, flaggedOrdinals, radius = 2) {
   const flagged = new Set(flaggedOrdinals);
@@ -34097,6 +34308,8 @@ async function runManualDream(deps) {
   } else {
     selected = deps.tasks.filter((t) => t.schedule.trim() !== "");
   }
+  if (!isProjectMemoryEnabled(deps.projectMemoryEnabled))
+    selected = selected.filter((config) => config.task === "evaluate-smart-notes");
   if (selected.length === 0)
     return result;
   const selectedTaskNames = selected.map((config) => config.task);
@@ -34162,7 +34375,7 @@ async function runManualDream(deps) {
 async function runDueTasksForProject(deps) {
   if (!isUsableProjectIdentity(deps.projectIdentity))
     return 0;
-  if (deps.projectMemoryEnabled === false)
+  if (!isProjectMemoryEnabled(deps.projectMemoryEnabled))
     return 0;
   const now = deps.now ?? Date.now();
   const due = planDueTasks(deps.db, deps.projectIdentity, deps.tasks, now);
@@ -34301,6 +34514,7 @@ async function runManualDreamNow(args) {
   const summary = await runManualDream({
     db: args.db,
     projectIdentity: args.projectIdentity,
+    projectMemoryEnabled: args.memoryEnabled,
     tasks: selection.runnable,
     executor,
     ...args.task !== undefined ? { task: args.task } : {}
@@ -34686,7 +34900,7 @@ function scheduleInitialProjectRun(reg, db) {
 async function runProjectMaintenance(reg, origin, db) {
   const sampled = reg.sampleDreamRun?.();
   const current = sampled ? { ...reg, ...sampled } : reg;
-  const projectMaintenanceEnabled = Boolean(current.dreamerConfig && current.dreamerConfig.disable !== true) || reg.memoryEnabled === true || reg.gitCommitIndexing?.enabled === true || reg.historianChildSweep !== undefined;
+  const projectMaintenanceEnabled = Boolean(current.dreamerConfig && current.dreamerConfig.disable !== true) || reg.memoryEnabled === true || current.gitCommitIndexing?.enabled === true || reg.historianChildSweep !== undefined;
   if (!projectMaintenanceEnabled)
     return;
   await reg.ensureRegistered(reg.directory, db);
@@ -34697,7 +34911,7 @@ async function runProjectMaintenance(reg, origin, db) {
       log2(`[magic-context] proactively embedded ${embeddedCount} ${embeddedCount === 1 ? "memory" : "memories"} for project ${reg.projectIdentity}`);
     }
   }
-  await sweepProject(current, origin, db);
+  await sweepProject(current, origin, db, current.gitCommitIndexing?.enabled === true);
 }
 async function sweepProject(reg, origin, db, gitCommitEnabled) {
   if (!directoryStillExists(reg.directory)) {
@@ -34934,7 +35148,11 @@ function registerV2DreamScheduleTimer(args) {
     dreamerConfig: dreamer,
     sampleDreamRun: () => {
       const current = dreamerRunConfig(config, args.liveConfig());
-      return { dreamerConfig: current.dreamer ?? dreamer, mural: current.mural };
+      return {
+        dreamerConfig: current.dreamer ?? dreamer,
+        mural: current.mural,
+        gitCommitIndexing: current.memory.git_commit_indexing
+      };
     },
     validateTaskModels: (tasks) => selectRunnableDreamTasks({ tasks, toolsSupported: executor.capabilities.tools }).runnable,
     language: config.language,
@@ -34944,6 +35162,8 @@ function registerV2DreamScheduleTimer(args) {
     retinaHandoff: config.smart_notes.retina_handoff,
     smartNotesEnabled: config.smart_notes.enabled,
     embeddingConfig: config.embedding,
+    transformMode: config.transform_mode,
+    moduleClient: createDreamTimerModuleClient(args.rustModeModuleClient),
     gitCommitIndexing: gitCommitIndexing?.enabled ? {
       enabled: true,
       since_days: gitCommitIndexing.since_days,
@@ -35019,6 +35239,10 @@ function startDreamTrigger(context, args) {
               retrospectiveRawProvider: (db) => new V2RetrospectiveRawProvider(db),
               language: args.language,
               mural: sampled?.mural ?? args.mural,
+              memoryInjectionBudgetTokens: args.memoryInjectionBudgetTokens,
+              retinaHandoff: args.retinaHandoff,
+              transformMode: args.transformMode,
+              moduleClient: args.moduleClient,
               smartNotesEnabled: args.smartNotesEnabled
             })
           });
@@ -35108,9 +35332,9 @@ function hiddenTerminalError(event) {
 }
 
 // src/v2/hooks/lkg-system.ts
-import { createHash as createHash15 } from "node:crypto";
+import { createHash as createHash14 } from "node:crypto";
 function identity(slot) {
-  return createHash15("sha256").update(JSON.stringify({
+  return createHash14("sha256").update(JSON.stringify({
     capturedAt: slot.capturedAt,
     captureSequence: slot.captureSequence,
     rowVersion: slot.rowVersion,
@@ -47938,7 +48162,7 @@ function resolveCtxExpandMode(args, domain) {
 }
 
 // src/tools/ctx-expand/render.ts
-import { createHash as createHash16 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 function isRecord6(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -48162,7 +48386,7 @@ function renderItemByTag(db, sessionId, number, textIndexDomain = "part") {
   const index = scoped ? Number(scoped[2]) : 0;
   const piText = message.parts.filter((part) => isRecord6(part) && part.type === "text");
   const part = message.parts[index];
-  const matching = derived ? piText.filter((part) => isRecord6(part) && typeof part.text === "string" && createHash16("sha256").update(part.text).digest("hex") === derived[3]) : [];
+  const matching = derived ? piText.filter((part) => isRecord6(part) && typeof part.text === "string" && createHash15("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.`;
 }
@@ -49738,7 +49962,7 @@ function formatCtxReduceReply(stampedCount, selfStampCount = 0) {
   return parts.join(" ");
 }
 // src/tools/ctx-reduce/tools.ts
-import { createHash as createHash17 } from "node:crypto";
+import { createHash as createHash16 } from "node:crypto";
 
 // src/features/magic-context/range-parser.ts
 function parseRangeString(input) {
@@ -49801,11 +50025,11 @@ function createCtxReduceTool(deps) {
       const stableId = `oc-${sessionId}-${callId}`;
       if (Buffer.byteLength(stableId) <= 128)
         return stableId;
-      return `oc-${createHash17("sha256").update(stableId).digest("hex")}`;
+      return `oc-${createHash16("sha256").update(stableId).digest("hex")}`;
     }
     fallbackCommandSequence += 1;
     const monotonicId = `oc-${sessionId}-${fallbackCommandSequence}`;
-    return Buffer.byteLength(monotonicId) <= 128 ? monotonicId : `oc-${createHash17("sha256").update(monotonicId).digest("hex")}`;
+    return Buffer.byteLength(monotonicId) <= 128 ? monotonicId : `oc-${createHash16("sha256").update(monotonicId).digest("hex")}`;
   };
   return tool({
     description: CTX_REDUCE_DESCRIPTION,
@@ -50186,6 +50410,112 @@ async function registerTools(context, db, config, rustToolBackends, isInternalCh
   return { dispose: () => controller.abort() };
 }
 
+// src/v2/hooks/transform-decision-binding.ts
+function bindV2TransformDecision(args) {
+  try {
+    return bindOpenCodeV2TransformDecision({
+      db: args.db,
+      sessionId: args.sessionId,
+      passStarting: args.passStarting,
+      firstAssistantAfter: (sequence) => {
+        const first = args.reader.assistantSince(args.sessionId, sequence)[0];
+        if (!first)
+          return;
+        const completion = {
+          completedAt: first.data.time?.completed,
+          finish: first.data.finish,
+          error: first.data.error
+        };
+        return {
+          id: first.id,
+          state: providerResponseFailed(completion) ? "failed" : isSuccessfulProviderCompletion(completion) ? "succeeded" : "running",
+          inputTokens: lkgProviderInputTotal(first.data.tokens)
+        };
+      }
+    });
+  } catch {
+    return false;
+  }
+}
+
+// src/v2/hooks/transform-features.ts
+function createV2TransformFeatureDeps(config, compactionOff, directory) {
+  return {
+    protectedTools: config.protected_tools,
+    commitClusterTrigger: config.commit_cluster_trigger,
+    allowHomeProject: config.allow_home_project,
+    injectDocs: config.dreamer?.inject_docs !== false,
+    memoryConfig: {
+      enabled: config.memory.enabled,
+      injectionBudgetTokens: config.memory.injection_budget_tokens,
+      autoPromote: config.memory.auto_promote
+    },
+    ensureProjectRegistered: ensureProjectRegisteredFromOpenCodeDirectory,
+    historyBudgetPercentage: config.history_budget_percentage,
+    experimentalUserMemories: userMemoryCollectionEnabled2(config.dreamer),
+    experimentalTemporalAwareness: config.temporal_awareness === true,
+    muralEnabled: config.mural?.enabled === true,
+    autoSearch: {
+      enabled: config.memory.auto_search?.enabled ?? true,
+      scoreThreshold: config.memory.auto_search?.score_threshold ?? 0.6,
+      minPromptChars: config.memory.auto_search?.min_prompt_chars ?? 20,
+      directory,
+      ensureProjectRegistered: ensureProjectRegisteredFromOpenCodeDirectory,
+      wordRules: cavemanWordRulesForLanguage(config.language)
+    },
+    cavemanTextCompression: compactionOff ? undefined : config.caveman_text_compression?.enabled === true ? {
+      enabled: true,
+      minChars: config.caveman_text_compression.min_chars ?? 500,
+      wordRules: cavemanWordRulesForLanguage(config.language)
+    } : undefined
+  };
+}
+function createV2AutoEmbedSession(deps) {
+  return (sessionId) => {
+    if (isEmbeddingHostBusy2())
+      return;
+    const directory = deps.resolveDirectory(sessionId);
+    const identity = resolveProjectIdentityForSession(directory, deps.allowHomeProject);
+    const snapshot = identity ? getProjectEmbeddingSnapshot2(identity) : undefined;
+    const embedIdentity = snapshot ? JSON.stringify([
+      snapshot.providerIdentity,
+      snapshot.chunkModelId,
+      snapshot.runtimeFingerprint
+    ]) : "off";
+    if (autoEmbedIdentityBySession.get(sessionId) !== embedIdentity)
+      invalidateAutoEmbedSession(sessionId);
+    if (autoEmbedAttemptedBySession.has(sessionId) || embedPauseBySession.has(sessionId))
+      return;
+    autoEmbedAttemptedBySession.add(sessionId);
+    autoEmbedIdentityBySession.set(sessionId, embedIdentity);
+    (async () => {
+      try {
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        if (isEmbeddingHostBusy2()) {
+          invalidateAutoEmbedSession(sessionId);
+          return;
+        }
+        await ensureProjectRegisteredFromOpenCodeDirectory(directory, deps.db);
+        const project = resolveProjectIdentityForSession(directory, deps.allowHomeProject);
+        if (!project) {
+          invalidateAutoEmbedSession(sessionId);
+          return;
+        }
+        const coverage = await getAutoEmbeddingSessionCoverage2(deps.db, project, sessionId);
+        if (!coverage.enabled) {
+          invalidateAutoEmbedSession(sessionId);
+          return;
+        }
+        if (coverage.total <= coverage.embedded)
+          return;
+        await runEmbedHistoryDrain(deps, sessionId, { silent: true });
+      } catch (error) {
+        log2("[magic-context] auto-embed drain failed:", error);
+      }
+    })();
+  };
+}
+
 // src/v2/hooks/usage-reading.ts
 function usageReadingMatchesDraft(reading, draftModel) {
   return reading.modelKey === undefined || reading.modelKey === `${draftModel.providerID}/${draftModel.id}`;
@@ -50636,29 +50966,39 @@ async function registerContext(context) {
       projectIdentity: () => resolveProjectIdentityForSession(directory, config.allow_home_project) ?? "",
       projectMemoryEnabled: config.memory.enabled,
       language: config.language,
-      mural: config.mural
+      mural: config.mural,
+      memoryInjectionBudgetTokens: config.memory.injection_budget_tokens,
+      retinaHandoff: config.smart_notes.retina_handoff,
+      transformMode: config.transform_mode,
+      moduleClient: createDreamTimerModuleClient(rustModeModuleClient)
     });
-    const timer = registerV2DreamScheduleTimer({
+    return trigger;
+  };
+  let hiddenCompletionExecutor = db && isDatabasePersisted(db) && resolveProjectIdentityForSession(directory, config.allow_home_project) ? await createHiddenExecutor(db) : undefined;
+  let dreamTrigger = hiddenCompletionExecutor ? startDreamer(hiddenCompletionExecutor) : undefined;
+  const lateHiddenExecutor = createLateHiddenExecutor(() => hiddenCompletionExecutor);
+  let maintenanceTimer;
+  const startMaintenance = () => {
+    const timerProjectIdentity = resolveProjectIdentityForSession(directory, config.allow_home_project);
+    if (!timerProjectIdentity || maintenanceTimer)
+      return;
+    maintenanceTimer = registerV2DreamScheduleTimer({
       directory,
-      projectIdentity,
+      projectIdentity: timerProjectIdentity,
       config,
       dreamer: dreamerAtBoot,
       liveConfig: () => liveConfigReader.poll().effective,
-      executor: cappedExecutor,
-      openReader: openStoreReader
+      executor: withLiveDreamerOutputCap(lateHiddenExecutor, config, () => liveConfigReader.poll().effective),
+      openReader: openStoreReader,
+      rustModeModuleClient
     });
-    return {
-      async dispose() {
-        await Promise.all([trigger.dispose(), timer.dispose()]);
-      }
-    };
   };
-  let hiddenCompletionExecutor = db && isDatabasePersisted(db) && resolveProjectIdentityForSession(directory, config.allow_home_project) ? await createHiddenExecutor(db) : undefined;
-  let dreamTrigger = hiddenCompletionExecutor ? startDreamer(hiddenCompletionExecutor) : undefined;
-  const lateHiddenExecutor = createLateHiddenExecutor(() => hiddenCompletionExecutor);
+  if (db && isDatabasePersisted(db))
+    startMaintenance();
   let hiddenWorkRecovery;
   const recoverHiddenWork = (database) => !resolveProjectIdentityForSession(directory, config.allow_home_project) ? Promise.resolve(false) : hiddenWorkRecovery ??= (async () => {
     try {
+      startMaintenance();
       hiddenCompletionExecutor ??= await createHiddenExecutor(database);
       dreamTrigger ??= startDreamer(hiddenCompletionExecutor);
       return true;
@@ -50693,6 +51033,7 @@ async function registerContext(context) {
   registerSystemDateRefresh(historyRefreshSessions);
   const pendingMaterializationSessions = new Set;
   const lastHeuristicsTurnId = new Map;
+  const commitSeenLastPass = new Map;
   const restoredRows = new RestoredRowCache;
   const rawProviders = new Map;
   let passDuties;
@@ -50802,7 +51143,7 @@ async function registerContext(context) {
     }
   };
   const latestLkgResponseIds = new BoundedSessionMap(1000);
-  const recordUsage = async (draft) => {
+  const recordUsage = async (draft, passStarting = false) => {
     let unsafe = false;
     try {
       await storage.probe();
@@ -50817,6 +51158,12 @@ async function registerContext(context) {
         } catch (error) {
           sessionLog2(draft.sessionID, "v2 response ownership unavailable; keeping system identity pending", error);
         }
+        bindV2TransformDecision({
+          db,
+          sessionId: draft.sessionID,
+          reader,
+          passStarting
+        });
         if (latest)
           noteLkgProviderResponse({
             sessionId: draft.sessionID,
@@ -50946,6 +51293,8 @@ async function registerContext(context) {
           variants.delete(sessionID);
           agents.delete(sessionID);
           channel1.delete(sessionID);
+          commitSeenLastPass.delete(sessionID);
+          clearEmbedSessionState(sessionID);
           historyRefreshSessions.delete(sessionID);
           clearPendingMaterialization(pendingMaterializationSessions, sessionID);
           lastHeuristicsTurnId.delete(sessionID);
@@ -50977,16 +51326,22 @@ async function registerContext(context) {
   const materialize = (draft) => {
     db = storage.require();
     const state = getOrCreateSessionMeta(db, draft.sessionID);
+    const modelKey = `${draft.model.providerID}/${draft.model.id}`;
+    const contextLimit = resolveContextLimit(draft.model.providerID, draft.model.id, {
+      db,
+      sessionID: draft.sessionID
+    }) || draft.model.limit?.context || (state.lastObservedModelKey === modelKey ? state.lastUsageContextLimit : undefined);
     return materializeM0({
+      ...createM0RenderOptions({
+        ...createV2TransformFeatureDeps(config, compactionOff, directory),
+        ...createV2ThresholdDeps(config)
+      }, usage.get(draft.sessionID)?.usage ?? { percentage: 0, inputTokens: 0 }, modelKey, contextLimit, resolveProjectIdentityForSession(directory, config.allow_home_project)),
       db,
       sessionId: draft.sessionID,
       state,
-      projectPath: resolveProjectIdentityForSession(directory, config.allow_home_project) ?? "",
       projectDirectory: directory,
-      memoryEnabled: config.memory.enabled && !!resolveProjectIdentityForSession(directory, config.allow_home_project),
-      memoryInjectionBudgetTokens: config.memory.injection_budget_tokens,
       hardSignals: {
-        systemHash: foldDigest(JSON.stringify(draft.system)),
+        systemHash: state.systemPromptHash ?? "",
         toolSetHash: getCurrentToolSetHash(draft.model.providerID, draft.model.id, draft.agent),
         modelKey: `${draft.model.providerID}/${draft.model.id}`,
         cacheExpired: false,
@@ -51006,6 +51361,7 @@ async function registerContext(context) {
       rememberHostMedia(draft.messages);
     const reader = openStoreReader();
     try {
+      await storage.probe();
       const watermark = reader.latestSequenceForIds(draft.sessionID, draft.messages.flatMap((message) => message.id ? [message.id] : []));
       const running = reader.latestRunningCompaction(draft.sessionID);
       const moduleBaseline = rustModeModuleClient ? servedModuleM0Text(draft.sessionID) : undefined;
@@ -51144,7 +51500,7 @@ async function registerContext(context) {
       if (admissionDb)
         hideSubagentTools(draft, admissionDb);
       recordV2ToolDefinitions(draft);
-      if (await recordUsage(draft) && !compactionOff) {
+      if (await recordUsage(draft, true) && !compactionOff) {
         const storageReason = storage.current() ? null : storage.reason();
         if (storageReason) {
           noticeStorageRefusal(draft.sessionID, storageReason);
@@ -51226,6 +51582,7 @@ async function registerContext(context) {
       await cacheV2SessionDirectory(context.session, draft.sessionID, sessionDirectories);
       prepareHistorySession(draft.sessionID);
       transform ??= createTransform({
+        ...createV2TransformFeatureDeps(config, compactionOff, directory),
         cacheTtlConfig: config.cache_ttl,
         cacheTtlConfigured: config.cacheTtlConfigured,
         sampleCacheTtlConfig: () => liveConfigReader.poll().effective,
@@ -51255,14 +51612,27 @@ async function registerContext(context) {
         historyRefreshSessions,
         pendingMaterializationSessions,
         lastHeuristicsTurnId,
+        commitSeenLastPass,
         variantBySession: variants,
         keepReasoningTokens: config.keep_reasoning_tokens,
         directory,
         sessionDirectoryBySession: sessionDirectories,
-        projectPath: directory,
+        projectPath: resolveProjectIdentityForSession(directory, config.allow_home_project),
+        getHistorianChunkTokens: () => sampleHistorian().chunkTokens,
+        getFallbackModelId: (sessionID) => {
+          const model = liveModels.get(sessionID);
+          return model ? `${model.providerID}/${model.modelID}` : undefined;
+        },
+        maybeAutoEmbedSession: createV2AutoEmbedSession({
+          db,
+          resolveDirectory: (sessionID) => sessionDirectories.get(sessionID) ?? directory,
+          allowHomeProject: config.allow_home_project,
+          recompProgressBySession: new Map
+        }),
         hiddenCompletionExecutor,
         historianRunnable: !compactionOff && hiddenCompletionExecutor !== undefined && config.historian?.disable !== true,
         historianModel: historianModels.primary,
+        historianContextLimit: sampleHistorian().contextLimit,
         fallbackModels: historianModels.fallbacks,
         resolveHistorianRun: sampleHistorian,
         historianTimeoutMs: config.historian_timeout_ms,
@@ -51290,14 +51660,10 @@ async function registerContext(context) {
         promptSurface: config.prompt_surface,
         promptSurfaceRuntime,
         onRustEngineReconnectRefusal: (refusal) => rustRefusalRecovery?.arm(refusal),
-        memoryConfig: {
-          enabled: config.memory.enabled,
-          injectionBudgetTokens: config.memory.injection_budget_tokens,
-          autoPromote: config.memory.auto_promote
-        },
         ...createHostSeams(context, readAllForConversion, pagedRead, liveModels)
       });
       const admitted = new Set;
+      let messageTimes;
       const reader = openStoreReader();
       let checkpoint;
       let submitted;
@@ -51368,6 +51734,8 @@ async function registerContext(context) {
           } : undefined));
           draft.messages.splice(0, draft.messages.length, ...restored, ...draft.messages.filter((message) => message !== incoming));
         }
+        if (config.temporal_awareness === true)
+          messageTimes = reader.messageTimes(draft.sessionID, draft.messages.flatMap((message) => message.id ? [message.id] : []));
       } finally {
         reader.close();
       }
@@ -51384,7 +51752,7 @@ async function registerContext(context) {
           nativeFoldReplay.invalidate(draft.sessionID, true);
         }
       }
-      const mapped = adaptPayload(draft, admitted);
+      const mapped = adaptPayload(draft, admitted, messageTimes);
       bindSystemDateRequestIdentity(mapped, draft);
       await createMessagesTransformHandler({
         magicContext: { "experimental.chat.messages.transform": transform },
@@ -51394,6 +51762,10 @@ async function registerContext(context) {
         rustReplayParticipant: () => transform?.getRustReplayParticipant() ?? null
       })({}, mapped);
       mapped.commit();
+      stageOpenCodeV2TransformDecision({
+        sessionId: draft.sessionID,
+        responseAfterSequence
+      });
       if (db) {
         await deliverPendingChannel2(context, db, draft.sessionID, channel1.get(draft.sessionID));
       }
@@ -51560,6 +51932,7 @@ ${baseline}
       db: runDb,
       dreamer: manualDreamer,
       smartNotesEnabled: config.smart_notes.enabled,
+      memoryEnabled: config.memory.enabled,
       projectIdentity: resolveProjectIdentityForSession(directory, config.allow_home_project) ?? "",
       directory,
       language: config.language,
@@ -51610,6 +51983,7 @@ ${baseline}
       await usageDone;
       deletedSessions.clear();
       await dreamTrigger?.dispose();
+      await maintenanceTimer?.dispose();
       for (const release of rawProviders.values())
         release();
       rawProviders.clear();