@cortexkit/opencode-magic-context 0.49.10 → 0.49.12

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

@@ -1,15 +1,12 @@
 import {
   getMagicContextBuiltinCommands,
   readJsoncFile,
-  COMPACTION_ENABLED_PATH,
-  isDreamerRunnable,
-  isCompactionEnabled,
   cortexKitUserConfigBasePath,
   cortexKitProjectConfigBasePath,
   resolveLegacyConfigSources,
   getProtectedTokensTierOverrides,
   loadPluginConfigDetailed
-} from "./server-4qr18rfg.js";
+} from "./server-37ngj8qw.js";
 import {
   getHarness2,
   harnessOwnsOpenCodeStore2
@@ -24,7 +21,7 @@ import {
   log2,
   sessionLog2,
   getLoggerDiagnostics2
-} from "./server-9e5r8y60.js";
+} from "./server-f2xf5gcb.js";
 import {
   hasTrustedAbsoluteWall,
   applyProvenInputFloor,
@@ -36,8 +33,9 @@ import {
   getSdkContextLimit,
   getSdkOutputLimit,
   getModelsDevCacheState
-} from "./server-nveratm5.js";
+} from "./server-kn9n2qgd.js";
 import {
+  isValidLanguageCode,
   withContentLanguageDirective,
   parseCron,
   nextOccurrence,
@@ -48,7 +46,25 @@ import {
   DEFAULT_HISTORIAN_TIMEOUT_MS,
   DEFAULT_LOCAL_EMBEDDING_MODEL,
   DREAM_TASK_PROMOTION_DEFAULTS
-} from "./server-7e087rvk.js";
+} from "./server-th4y11y7.js";
+import {
+  CANONICAL_DREAM_TASKS,
+  DREAM_TASK_CAPABILITIES,
+  toolLoopDreamTasks,
+  formatUnsupportedDreamTasks,
+  formatDreamTaskBacklogs,
+  processedDreamTaskItems,
+  PROJECT_MEMORY_DREAM_TASKS,
+  dreamTaskAllowedBySettings,
+  leaseKindFor,
+  leaseKeyFor,
+  isCanonicalDreamTask,
+  compareTaskOrder,
+  buildDreamTaskRuntimeConfigs2,
+  userMemoryCollectionEnabled2,
+  userObservationCollectionEnabled2,
+  userObservationsRequested2
+} from "./server-qd11g795.js";
 import {
   historianRunConfig,
   dreamerRunConfig,
@@ -57,8 +73,11 @@ import {
   withLiveDreamerOutputCap,
   embedPauseBySession,
   embedRunStateBySession,
+  autoEmbedAttemptedBySession,
+  autoEmbedIdentityBySession,
   invalidateAutoEmbedSession,
   getEmbedDrainUiStatus,
+  clearEmbedSessionState,
   acquireCompartmentLease,
   releaseCompartmentLeaseBestEffort,
   isCompartmentLeaseHeld,
@@ -87,6 +106,7 @@ import {
   clearSession,
   requestPendingMaterialization,
   pendingMaterializationOrigin,
+  hasPendingMaterializationOrigin,
   clearPendingMaterialization,
   recordSystemPromptForRequest,
   recordHeldHeadForRequest,
@@ -201,7 +221,7 @@ import {
   createPromptAsyncTransport,
   CTX_NOTE_LIGHT_DESCRIPTION,
   ACTIVE_TOOL_IDS,
-  promptSurfaceHashMaterial,
+  systemPromptFingerprint,
   createPromptSurfaceRuntime,
   createPromptSurfaceGuidanceEpochCache,
   MARKER_SUMMARY_TEXT,
@@ -261,25 +281,12 @@ import {
   getRawHistoryEligibility,
   hasRunnableCompartmentWindow,
   recordHighPressureNoEligibleHead,
+  noteTransformPassForExactOrdinalReads,
   getActiveCompartmentRun,
   startCompartmentAgent,
   setRecompStarting2,
   setRecompTerminal2
-} from "./server-c9w52qss.js";
-import {
-  CANONICAL_DREAM_TASKS,
-  DREAM_TASK_CAPABILITIES,
-  toolLoopDreamTasks,
-  formatUnsupportedDreamTasks,
-  formatDreamTaskBacklogs,
-  processedDreamTaskItems,
-  leaseKindFor,
-  leaseKeyFor,
-  isCanonicalDreamTask,
-  compareTaskOrder,
-  buildDreamTaskRuntimeConfigs2,
-  userMemoryCollectionEnabled2
-} from "./server-r5p3b1wy.js";
+} from "./server-5gvkzzrf.js";
 import {
   resolveHistorianModel2
 } from "./server-8cd2j99z.js";
@@ -296,6 +303,7 @@ import {
   getMigrationOnOpenRefusal,
   LATEST_SUPPORTED_VERSION,
   BOOT_SQLITE_BUSY_TIMEOUT_MS,
+  getDatabasePath,
   getPersistedSchemaVersion,
   runSqliteOptimize,
   openDatabase,
@@ -303,7 +311,7 @@ import {
   openDatabaseAsync,
   isDatabasePersisted,
   getDatabasePersistenceError
-} from "./server-23znwjqk.js";
+} from "./server-50mkkhy1.js";
 import {
   setHomeProjectPermission,
   shouldSkipHomeProjectMemory,
@@ -319,7 +327,7 @@ import {
   storedPathBelongsToIdentity,
   beginBootQuietPeriod,
   scheduleAfterBootQuiet
-} from "./server-njnx39q2.js";
+} from "./server-gvkm8xaj.js";
 import {
   detectLatestTurnThinkingMismatch,
   isPrefixBoundThinkingModel,
@@ -506,7 +514,7 @@ import {
   readRawSessionMessageById2,
   readSessionChunk2,
   readRawSessionSeedTail2
-} from "./server-gc8x2xdb.js";
+} from "./server-m97brnat.js";
 import {
   textMentionsRecentCommit,
   hasMeaningfulUserText2,
@@ -517,7 +525,7 @@ import {
   estimateTokens,
   estimateFixedPromptTokens,
   normalizeText
-} from "./server-s6jqh8bj.js";
+} from "./server-0ppsweh6.js";
 import {
   SubcClient,
   connectionFileExists,
@@ -525,7 +533,7 @@ import {
   toSynapseLaneDescriptor,
   formatSynapseLaneDescriptor,
   SynapseEmbeddingProvider
-} from "./server-988cqjme.js";
+} from "./server-rrqpvwqd.js";
 import {
   inRootAsyncContext2,
   getTagIdentityWriteGeneration2,
@@ -540,17 +548,17 @@ import {
   SqliteAcquisitionBusyError2,
   withAsyncPrivilegedWriter2
 } from "./server-wafzvyhg.js";
-import"./server-63ha7f0f.js";
+import"./server-yrvqaswb.js";
 import {
   deleteChunkEmbedBackoffForSession
-} from "./server-9a6bwc12.js";
+} from "./server-vknbt0gq.js";
 import {
   registerOwnRpcServerInstance,
   rpcPortDir,
   rpcPortFilePath,
   parseRpcPortFile,
   inspectProcessesAsync
-} from "./server-cxsr0ng6.js";
+} from "./server-da07v4xp.js";
 import {
   BoundedSessionMap,
   LkgRecoveryFenceError,
@@ -569,14 +577,14 @@ import {
   isMessageIndexReconciledThrough2,
   indexMessagesAfterOrdinal2,
   sweepOrphanedOpenCodeMessageIndexes2
-} from "./server-z0rjemg1.js";
+} from "./server-nmrm2rjy.js";
 import {
   stableStringify,
   getTemporalDecisions,
   observeTemporalDecisions,
   freezeTemporalDecisions,
   tagIdentityRevisionKey
-} from "./server-89fcbe37.js";
+} from "./server-pwv4ezb0.js";
 import {
   resolveModelCalibration,
   calibrateBuckets,
@@ -643,6 +651,7 @@ import {
   backfillTagTokenCounts2,
   insertTag2,
   updateTagStatus2,
+  markTagDropped2,
   markWhitespaceAssistantTagInert2,
   getInertWhitespaceAssistantTags2,
   getInertWhitespaceAssistantTagsByNumbers2,
@@ -668,14 +677,15 @@ import {
   adoptNullOwnerToolTag2,
   getCandidateToolOwners2,
   pickNearestPriorOwner2
-} from "./server-kmapq3v0.js";
+} from "./server-bxpwy6fy.js";
 import"./server-51779zs2.js";
 import {
   isRawCompactionSummaryInfo2,
   extractInMemoryMessageViews2,
   buildInMemoryTailRawMessages2,
+  RawOrdinalsNotReady2,
   runSessionWarmupWorker
-} from "./server-bx59ezg6.js";
+} from "./server-prg55b7k.js";
 import {
   resolveOpenCodeDbPath,
   assertOpenCodeStoreGeneration,
@@ -691,12 +701,12 @@ import {
   latestRealUserTurnIdFromOpenCodeDb,
   getMessageTimesFromOpenCodeDb,
   findLastAssistantModelFromOpenCodeDb
-} from "./server-zrwaj29a.js";
+} from "./server-d8tj10db.js";
 import {
   getCurrentToolSetHash,
   recordToolDefinition,
   getMeasuredToolDefinitionTokens
-} from "./server-xqf2d2mg.js";
+} from "./server-zs8d0s3b.js";
 import {
   V2_MEMORY_CATEGORIES,
   CATEGORY_PRIORITY
@@ -709,7 +719,7 @@ import {
   resolveStoredPathWorkspaceIdentity,
   storedPathBelongsToWorkspace,
   computeWorkspaceEpochFingerprint
-} from "./server-f27he3j1.js";
+} from "./server-fa75w6gp.js";
 import {
   GIT_SWEEP_LEASE_RENEWAL_MS,
   acquireGitSweepLease,
@@ -735,9 +745,12 @@ import {
   embedUnembeddedMemoriesForProjectOutcome2,
   drainCommitBacklogForProject2,
   embedSessionCompartmentChunks2,
-  getEmbeddingCoverageStatus2
-} from "./server-4easnf78.js";
-import"./server-fb3zxn06.js";
+  getEmbeddingCoverageStatus2,
+  getAutoEmbeddingSessionCoverage2
+} from "./server-sz8jj92q.js";
+import {
+  configureContextDatabasePragmas2
+} from "./server-fb3zxn06.js";
 import {
   SESSION_NOTE_CONDITION_ERROR,
   getNoteByIdInScope,
@@ -780,15 +793,15 @@ import {
   readGitFileChangeTimesSince,
   verificationFileExists,
   normalizeVerificationFiles
-} from "./server-4zwx20yg.js";
+} from "./server-4c10404h.js";
 import {
   deriveTriggerBudget2,
   deriveHistorianChunkTokens2,
   resolveKnownHistorianContextLimit2,
   resolveHistorianProducerLimits2,
   resolveHistorianContextLimit2
-} from "./server-hn9fb3v0.js";
-import"./server-npm52h2q.js";
+} from "./server-f7jfmrrz.js";
+import"./server-05xjtq6c.js";
 import {
   isEmbeddingHostBusy2
 } from "./server-qt1qqasc.js";
@@ -799,10 +812,10 @@ import {
 } from "./server-4dhv7mqz.js";
 import {
   getLocalEmbeddingNativeMemoryStats
-} from "./server-44ryn9rb.js";
+} from "./server-2x42esxd.js";
 import {
   cosineSimilarity
-} from "./server-4rs8sm06.js";
+} from "./server-9ewkzqgd.js";
 import {
   computeCueContentHash,
   hasMuralCueColumns,
@@ -835,11 +848,11 @@ import {
   drainNotifications2,
   isTuiConnected2
 } from "./server-x8a7jmkh.js";
-import"./server-ckrb5rm8.js";
+import"./server-h0410h0v.js";
 import {
   flushIgnoredMessages2,
   sendStatusNotification2
-} from "./server-ak7w74j9.js";
+} from "./server-83ygfha2.js";
 import {
   renderSingleStoreMigrationRequiredRefusal,
   SingleStoreMigrationRequiredError,
@@ -860,13 +873,19 @@ import {
   resolveMemoriesByIdsForSearch2,
   unifiedSearch2,
   formatSearchResults2
-} from "./server-2hxypdx5.js";
+} from "./server-25tg45b4.js";
 import {
   resolvePromptContext2
 } from "./server-fmsr7v69.js";
 import {
   compareSemverCore
 } from "./server-84w6rvvf.js";
+import {
+  COMPACTION_ENABLED_PATH,
+  isDreamerRunnable,
+  isSmartNoteSurfaceAvailable,
+  isCompactionEnabled
+} from "./server-0s95v3en.js";
 import {
   __toESM,
   __export
@@ -904,7 +923,7 @@ import {
 } from "./server-8ajstryz.js";
 import {
   logSlowWriteTransaction
-} from "./server-7dv9wt9r.js";
+} from "./server-6pmqg9m4.js";
 
 // ../../node_modules/.bun/zod@4.1.8/node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -1604,6 +1623,39 @@ __export(exports_coerce, {
   string: () => string3
 });
 
+// src/config/dependency-notes.ts
+function scheduledTasks(config) {
+  const tasks = config.dreamer?.tasks ?? {};
+  return Object.entries(tasks).filter(([, task]) => typeof task?.schedule === "string" && task.schedule.trim() !== "").map(([name]) => name);
+}
+function configDependencyNotes(config) {
+  const notes = [];
+  const dreamerRunnable = isDreamerRunnable(config);
+  const dreamerDisabled = config.dreamer?.disable === true;
+  const memoryOff = config.memory?.enabled === false;
+  const memoryTasks = scheduledTasks(config).filter((task) => PROJECT_MEMORY_DREAM_TASKS.includes(task));
+  if (dreamerRunnable && memoryOff && memoryTasks.length > 0) {
+    notes.push(`memory.enabled is false, so these scheduled dreamer tasks do not run for this project, on schedule or through /ctx-dream: ${memoryTasks.join(", ")}. maintain-docs, evaluate-smart-notes and review-user-memories still run.`);
+  }
+  if (dreamerDisabled && config.smart_notes?.enabled !== false) {
+    notes.push("dreamer.disable is true, so smart_notes.enabled has no effect: ctx_note does not offer surface_condition and pending smart notes are not evaluated.");
+  }
+  const reviewSchedule = config.dreamer?.tasks?.["review-user-memories"]?.schedule;
+  if (dreamerDisabled && typeof reviewSchedule === "string" && reviewSchedule.trim() !== "") {
+    notes.push("dreamer.disable is true, so dreamer.tasks.review-user-memories.schedule has no effect: the historian does not collect user observations and the <user-profile> block gets no new entries.");
+  }
+  return notes;
+}
+var loggedNotes = new Set;
+function logConfigDependencyNotesOnce(config, log) {
+  const fresh = configDependencyNotes(config).filter((note) => !loggedNotes.has(note));
+  for (const note of fresh) {
+    loggedNotes.add(note);
+    log(`[magic-context] config note: ${note}`);
+  }
+  return fresh;
+}
+
 // src/features/magic-context/dreamer/manual-summary.ts
 function summarizeManualDream(summary) {
   const lines = ["## /ctx-dream", ""];
@@ -2416,6 +2468,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 +3949,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 +6821,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) {
@@ -6560,13 +6917,20 @@ function foldBustsServedPrefix(reason, before, after) {
   return CACHE_LOSING_FOLD_REASONS.has(reason ?? "") || foldChangesServedPrefix(before, after);
 }
 function prepareLegacyToolSkeletonConversions(db, sessionId, targets, options = {}) {
-  const readRows = (connection) => connection.prepare(`SELECT tag_number AS tagNumber, drop_mode AS dropMode, message_id AS callId
-               FROM tags
-              WHERE session_id = ? AND type = 'tool' AND status = 'dropped'
-                AND drop_mode IN ('truncated', 'full')
-              ORDER BY tag_number`).all(sessionId);
+  const candidates = [...targets.keys()].sort((a, b) => a - b);
+  const readRows = (connection) => {
+    if (candidates.length === 0)
+      return [];
+    const statement = connection.prepare(`SELECT tag_number AS tagNumber, drop_mode AS dropMode, message_id AS callId
+             FROM tags WHERE session_id = ? AND tag_number = ?
+               AND type = 'tool' AND status = 'dropped'
+               AND drop_mode IN ('truncated', 'full')`);
+    return candidates.flatMap((tagNumber) => {
+      const row = statement.get(sessionId, tagNumber);
+      return row ? [row] : [];
+    });
+  };
   const rows = readRows(db);
-  const identity = JSON.stringify(rows);
   const converted = new Map;
   for (const row of rows) {
     const target = targets.get(row.tagNumber);
@@ -6587,7 +6951,10 @@ function prepareLegacyToolSkeletonConversions(db, sessionId, targets, options =
   }
   return {
     converted,
-    isCurrent: (connection) => JSON.stringify(readRows(connection)) === identity,
+    isCurrent: (connection) => {
+      const current = readRows(connection);
+      return current.length === rows.length && current.every((row, index) => row.tagNumber === rows[index].tagNumber && row.dropMode === rows[index].dropMode && row.callId === rows[index].callId);
+    },
     persist: (connection) => {
       for (const [tagNumber, mode] of converted)
         updateTagDropMode2(connection, sessionId, tagNumber, mode);
@@ -6674,9 +7041,7 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
           try {
             db.transaction(() => {
               startedAt = performance.now();
-              if (mode)
-                updateTagDropMode2(db, sessionId, pendingOp.tagId, mode);
-              updateTagStatus2(db, sessionId, pendingOp.tagId, "dropped");
+              markTagDropped2(db, sessionId, pendingOp.tagId, mode);
               if (!synthetic)
                 removePendingOp(db, sessionId, pendingOp.tagId);
             }).immediate();
@@ -9215,6 +9580,25 @@ function finalizeMessageRepresentation(messages, resolvedProviderID, options) {
   }
   return { clearedParts, mergedReasoningParts };
 }
+function legacyPublishedHeadChanged(args) {
+  if (!args.pendingCompartmentInjection || !args.readLastServedMessages)
+    return false;
+  const served = args.readLastServedMessages();
+  if (served === null)
+    return true;
+  const previous = served[0];
+  if (!Array.isArray(previous?.parts) || !args.pendingCompartmentInjection)
+    return false;
+  const text = previous.parts.find((part) => typeof part === "object" && part !== null && ("type" in part) && part.type === "text" && ("text" in part))?.text;
+  if (typeof text !== "string")
+    return false;
+  const block = `<session-history>
+${args.pendingCompartmentInjection.block}
+</session-history>`;
+  return text !== block && !text.startsWith(`${block}
+
+`);
+}
 async function runPostTransformPhase(args) {
   const tPostprocessSetup = performance.now();
   const compactionOff = args.compactionOff === true;
@@ -9456,8 +9840,8 @@ async function runPostTransformPhase(args) {
     subagentExecute: !args.fullFeatureMode && args.schedulerDecision === "execute",
     hardFold: foldBustsServedPrefixThisPass || firstRenderBust || idleExpiryRebuild,
     force: emergencyDropEligible && (args.contextUsage.percentage >= 95 || getEmergencyInputSample(args.db, args.sessionId) === 0),
-    explicitFlush: isExplicitFlush || deferredMaterialize && !prefixPreflightFailed,
-    publishedHistory: publishedM1RefreshedThisPass || !m0M1EnabledForFold && (args.pendingCompartmentInjection?.compartmentCount ?? 0) > 0 && (args.historyRebuiltThisPass || args.rebuiltHistoryFromInitialPrepare || args.canConsumeDeferredLate && args.deferredHistoryWasPendingAtPassStart)
+    explicitFlush: isExplicitFlush && hasPendingMaterializationOrigin(args.pendingMaterializationSessions, args.sessionId, "user_flush"),
+    publishedHistory: !prefixPreflightFailed && (publishedM1RefreshedThisPass || !m0M1EnabledForFold && (args.pendingCompartmentInjection?.compartmentCount ?? 0) > 0 && legacyPublishedHeadChanged(args))
   };
   const publishedWorkDrainAllowed = !compactionOff && (!activeThinkingPrefixHold || firstRenderBust || idleExpiryRebuild || emergencyDropEligible) && hasReclaimRide(rideSignals);
   const shouldApplyPendingOps = publishedWorkDrainAllowed;
@@ -10691,9 +11075,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 +11321,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 +11335,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 +11375,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 +11383,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 +11436,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;
@@ -11296,6 +11582,16 @@ function commitCompactionModeRecord(db, sessionId, record) {
   setCompactionModeRecord(db, sessionId, record);
 }
 
+// src/hooks/magic-context/compartment-trigger-error.ts
+function recordCompartmentTriggerError(passOutcome, sessionId, error, log = sessionLog2) {
+  passOutcome.record("compartment-trigger-failure");
+  if (error instanceof RawOrdinalsNotReady2) {
+    log(sessionId, "compartment trigger deferred: raw ordinals not ready; the next pass evaluates it again");
+    return;
+  }
+  log(sessionId, "compartment trigger failed (non-fatal):", error);
+}
+
 // src/hooks/magic-context/pass-outcome.ts
 var PASS_DEGRADATION_EFFECTS = {
   "store-generation-rebase-failure": "changes-request",
@@ -11359,7 +11655,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 +11719,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 +11736,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 +14110,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 +14124,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 +14612,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 +16396,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);
         }
@@ -17522,6 +17818,7 @@ async function runCompartmentPhaseImpl(args) {
         ensureProjectRegistered: args.ensureProjectRegistered,
         getNotificationParams: args.getNotificationParams,
         experimentalUserMemories: args.experimentalUserMemories,
+        userObservationsRequested: args.userObservationsRequested,
         historianTwoPass: args.historianTwoPass,
         historianExpandTools: args.historianExpandTools,
         memoryEnabled: args.memoryEnabled,
@@ -17563,6 +17860,7 @@ async function runCompartmentPhaseImpl(args) {
         ensureProjectRegistered: args.ensureProjectRegistered,
         getNotificationParams: args.getNotificationParams,
         experimentalUserMemories: args.experimentalUserMemories,
+        userObservationsRequested: args.userObservationsRequested,
         historianTwoPass: args.historianTwoPass,
         historianExpandTools: args.historianExpandTools,
         memoryEnabled: args.memoryEnabled,
@@ -17790,7 +18088,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 +18455,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);
@@ -18257,6 +18556,7 @@ function createTransform(deps) {
         fallbackModelId,
         getNotificationParams: () => notificationParams,
         experimentalUserMemories: historianRun?.userMemoriesEnabled ?? deps.experimentalUserMemories,
+        userObservationsRequested: historianRun?.userObservationsRequested ?? deps.userObservationsRequested,
         experimentalTemporalAwareness: deps.experimentalTemporalAwareness,
         historianTwoPass: historianRun?.twoPass ?? deps.historianTwoPass,
         historianExpandTools: historianRun?.expandTools ?? deps.historianExpandTools,
@@ -18293,8 +18593,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);
     }
@@ -18314,6 +18612,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       sessionLog2(sessionId, `tag floor: 0 (full-scan fallback) — no leading wire message resolved a tag across ${messages.length} msgs`);
     }
     const ownerRatio = sessionDecisionCalibration(db, sessionId).proseRatio;
+    noteTransformPassForExactOrdinalReads(sessionId);
     prewarmTagOwners(db, sessionId, ownerRatio);
     const tagOwnersReady = isTagOwnerSummaryReady2(db, sessionId, ownerRatio);
     let triggerBoundarySnapshot;
@@ -18337,8 +18636,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           triggerBoundarySnapshot = triggerResult.boundarySnapshot;
         }
       } catch (error) {
-        passOutcome.record("compartment-trigger-failure");
-        sessionLog2(sessionId, "compartment trigger failed (non-fatal):", error);
+        recordCompartmentTriggerError(passOutcome, sessionId, error);
       }
       logTransformTiming(sessionId, "compartmentTrigger", tTrigger);
     }
@@ -18529,6 +18827,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       safeForBackgroundCompression: historianRunnable && (isCacheBusting || schedulerDecision === "execute"),
       deferredHistoryRefreshSessions,
       experimentalUserMemories: historianRun?.userMemoriesEnabled ?? deps.experimentalUserMemories,
+      userObservationsRequested: historianRun?.userObservationsRequested ?? deps.userObservationsRequested,
       experimentalTemporalAwareness: deps.experimentalTemporalAwareness,
       historianTwoPass: historianRun?.twoPass ?? deps.historianTwoPass,
       historianExpandTools: historianRun?.expandTools ?? deps.historianExpandTools,
@@ -18579,14 +18878,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 +19020,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 +19266,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 +19414,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 +21056,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 +21104,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();
@@ -22265,9 +22559,9 @@ function registerRpcHandlers(rpcServer, args) {
     return { count: buildCompartmentCount(db, sessionId, moduleStatus) };
   });
   const buildManagedCtx = async (db) => {
-    const { deriveHistorianChunkTokens, resolveHistorianContextLimit } = await importPluginModule(() => import("./derive-budgets-0rmpmxjw.js"));
+    const { deriveHistorianChunkTokens, resolveHistorianContextLimit } = await importPluginModule(() => import("./derive-budgets-z25jw3py.js"));
     const { resolveHistorianModel } = await importPluginModule(() => import("./model-resolution-nx97z3x7.js"));
-    const { userMemoryCollectionEnabled } = await importPluginModule(() => import("./task-config-x0hq3qfd.js"));
+    const { userObservationCollectionEnabled, userObservationsRequested } = await importPluginModule(() => import("./task-config-nvz8mapa.js"));
     const DEFAULT_HISTORIAN_TIMEOUT_MS = 10 * 60 * 1000;
     const runConfig = historianRunConfig(config, currentPluginConfigReader(directory)?.poll().effective ?? config);
     const historianModel = resolveHistorianModel(runConfig, "opencode");
@@ -22285,7 +22579,8 @@ function registerRpcHandlers(rpcServer, args) {
       autoPromote: runConfig.memory?.auto_promote ?? true,
       historianModel: historianModel.primary,
       fallbackModels: historianModel.fallbacks,
-      userMemoriesEnabled: userMemoryCollectionEnabled(runConfig.dreamer),
+      userMemoriesEnabled: userObservationCollectionEnabled(runConfig.dreamer),
+      userObservationsRequested: userObservationsRequested(runConfig.dreamer),
       historianTwoPass: runConfig.historian?.two_pass === true,
       historianExpandTools: runConfig.historian?.expand_tools,
       getNotificationParams: (sessionId) => getLiveNotificationParams(sessionId, liveSessionState.liveModelBySession, liveSessionState.variantBySession, liveSessionState.agentBySession, runConfig.toast_duration_ms)
@@ -22297,7 +22592,7 @@ function registerRpcHandlers(rpcServer, args) {
       return { ok: false, error: "no session" };
     const readDirectory = args.readSessionDirectory;
     if (readDirectory) {
-      const { handoffHistoryWork } = await import("./history-owner-2cr9py37.js");
+      const { handoffHistoryWork } = await import("./history-owner-42e16w0n.js");
       const handed = await handoffHistoryWork({
         storageDir: args.storageDir ?? getMagicContextStorageDir(),
         directory,
@@ -22316,8 +22611,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-8w3449eb.js"));
+    const { sendIgnoredMessage } = await importPluginModule(() => import("./send-session-notification-jevgj9fe.js"));
     log2(`[rpc] recomp requested for session ${sessionId}`);
     if (!args.client && !args.hiddenCompletionExecutor) {
       return {
@@ -22375,7 +22670,7 @@ function registerRpcHandlers(rpcServer, args) {
   rpcServer.handle("wrapup", async (params) => {
     const readDirectory = args.readSessionDirectory;
     if (readDirectory && params.sessionId) {
-      const { handoffHistoryWork } = await import("./history-owner-2cr9py37.js");
+      const { handoffHistoryWork } = await import("./history-owner-42e16w0n.js");
       const sessionId = String(params.sessionId);
       const handed = await handoffHistoryWork({
         storageDir: args.storageDir ?? getMagicContextStorageDir(),
@@ -22401,7 +22696,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-r82y780v.js"));
     const model = liveSessionState.liveModelBySession.get(sessionId);
     const contextLimit = model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
     const ctx = {
@@ -23390,8 +23685,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 +24129,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 +24239,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 +26295,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 +27029,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 +27617,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 +28054,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 +28329,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 +28344,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 +28880,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 +29219,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 +29985,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 +30220,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 +30619,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 +31900,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 +32644,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 +33450,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);
@@ -33868,6 +34164,12 @@ function pruneIdleScheduleIdentities(db, now) {
 
 // src/features/magic-context/dreamer/task-scheduler.ts
 var MAX_TASK_RETRIES = 3;
+function tasksAllowedBySettings(deps) {
+  return deps.tasks.filter((config) => dreamTaskAllowedBySettings(config.task, {
+    projectMemoryEnabled: deps.projectMemoryEnabled,
+    smartNotesEnabled: deps.smartNotesEnabled
+  }));
+}
 function ensureSeeded(db, projectIdentity, config, now) {
   if (getTaskScheduleState(db, projectIdentity, config.task))
     return;
@@ -34086,16 +34388,17 @@ async function runManualDream(deps) {
   };
   if (!isUsableProjectIdentity(deps.projectIdentity))
     return result;
+  const allowed = tasksAllowedBySettings(deps);
   let selected;
   let forceGate = false;
   if (deps.task) {
-    const cfg = deps.tasks.find((t) => t.task === deps.task);
+    const cfg = allowed.find((t) => t.task === deps.task);
     if (!cfg)
       return result;
     selected = [cfg];
     forceGate = true;
   } else {
-    selected = deps.tasks.filter((t) => t.schedule.trim() !== "");
+    selected = allowed.filter((t) => t.schedule.trim() !== "");
   }
   if (selected.length === 0)
     return result;
@@ -34162,10 +34465,11 @@ async function runManualDream(deps) {
 async function runDueTasksForProject(deps) {
   if (!isUsableProjectIdentity(deps.projectIdentity))
     return 0;
-  if (deps.projectMemoryEnabled === false)
+  const tasks = tasksAllowedBySettings(deps);
+  if (tasks.length === 0)
     return 0;
   const now = deps.now ?? Date.now();
-  const due = planDueTasks(deps.db, deps.projectIdentity, deps.tasks, now);
+  const due = planDueTasks(deps.db, deps.projectIdentity, tasks, now);
   if (due.length === 0)
     return 0;
   const gated = [];
@@ -34301,6 +34605,8 @@ async function runManualDreamNow(args) {
   const summary = await runManualDream({
     db: args.db,
     projectIdentity: args.projectIdentity,
+    projectMemoryEnabled: args.memoryEnabled,
+    smartNotesEnabled: args.smartNotesEnabled,
     tasks: selection.runnable,
     executor,
     ...args.task !== undefined ? { task: args.task } : {}
@@ -34686,7 +34992,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 +35003,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)) {
@@ -34778,7 +35084,8 @@ async function sweepProject(reg, origin, db, gitCommitEnabled) {
       projectIdentity: reg.projectIdentity,
       tasks: runtimeConfigs,
       executor,
-      projectMemoryEnabled: reg.memoryEnabled !== false
+      projectMemoryEnabled: reg.memoryEnabled !== false,
+      smartNotesEnabled: reg.smartNotesEnabled
     });
     if (ran > 0) {
       log2(`[dreamer] timer tick (${origin}) ${reg.projectIdentity} — ran ${ran} task(s)`);
@@ -34934,7 +35241,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 +35255,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,
@@ -35010,6 +35323,7 @@ function startDreamTrigger(context, args) {
             db,
             projectIdentity: args.projectIdentity(),
             projectMemoryEnabled: args.projectMemoryEnabled,
+            smartNotesEnabled: args.smartNotesEnabled,
             tasks: runnable,
             executor: createDreamTaskExecutor({
               hiddenCompletionExecutor: args.executor,
@@ -35019,6 +35333,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 +35426,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 +48256,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 +48480,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.`;
 }
@@ -49553,12 +49871,13 @@ function parseNoteIds(action, value) {
 }
 function createCtxNoteTool(deps) {
   const { surface_condition: _condition, ...plainArgs } = ctxNoteArgsShape;
+  const smartNoteSurface = deps.smartNotesEnabled !== false && deps.dreamerEnabled !== false;
   return tool({
-    description: deps.smartNotesEnabled === false ? withoutSmartNoteText(CTX_NOTE_DESCRIPTION) : CTX_NOTE_DESCRIPTION,
-    args: deps.smartNotesEnabled === false ? {
+    description: smartNoteSurface ? CTX_NOTE_DESCRIPTION : withoutSmartNoteText(CTX_NOTE_DESCRIPTION),
+    args: smartNoteSurface ? ctxNoteArgsShape : {
       ...plainArgs,
       filter: ctxNoteArgsShape.filter.describe(NOTES_FILTER_DESCRIPTION)
-    } : ctxNoteArgsShape,
+    },
     async execute(rawArgs, toolContext) {
       const parsedArgs = ctxNoteArgsSchema.safeParse(rawArgs);
       let args = parsedArgs.success ? parsedArgs.data : rawArgs;
@@ -49738,7 +50057,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 +50120,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 +50505,113 @@ 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: userObservationCollectionEnabled2(config.dreamer),
+    userObservationsRequested: userObservationsRequested2(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}`;
@@ -50500,6 +50926,7 @@ async function registerContext(context) {
     directory,
     warn: (message) => log2(`[magic-context] config warning: ${message}`)
   });
+  logConfigDependencyNotesOnce(config, log2);
   const storage = createV2StorageGate({
     onUnavailable: (reason) => {
       const message = formatFailClosedBlockingMessage(reason);
@@ -50636,29 +51063,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;
@@ -50679,7 +51116,8 @@ async function registerContext(context) {
       twoPass: fresh.historian?.two_pass === true,
       expandTools: fresh.historian?.expand_tools,
       autoPromote: fresh.memory?.auto_promote ?? true,
-      userMemoriesEnabled: userMemoryCollectionEnabled2(fresh.dreamer),
+      userMemoriesEnabled: userObservationCollectionEnabled2(fresh.dreamer),
+      userObservationsRequested: userObservationsRequested2(fresh.dreamer),
       commitClusterTrigger: fresh.commit_cluster_trigger,
       chunkTokens: deriveHistorianChunkTokens2(resolveHistorianContextLimit2(models.primary?.model))
     };
@@ -50693,6 +51131,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 +51241,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 +51256,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 +51391,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 +51424,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 +51459,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;
@@ -51080,7 +51534,7 @@ async function registerContext(context) {
     if (!modelLimitCacheWarm())
       withoutSqliteTransformPass2(() => warmModelLimitCacheFromCatalog(context));
     agents.set(draft.sessionID, draft.agent);
-    applyV2PromptSurfaceTools(draft, promptSurfaceRuntime, config.prompt_surface, config.smart_notes.enabled);
+    applyV2PromptSurfaceTools(draft, promptSurfaceRuntime, config.prompt_surface, isSmartNoteSurfaceAvailable(config));
     const admissionDb = db ?? storage.current();
     const replayFits = (messages) => {
       const system = structuredClone(draft.system);
@@ -51144,7 +51598,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 +51680,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 +51710,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 +51758,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 +51832,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 +51850,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 +51860,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 +52030,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 +52081,7 @@ ${baseline}
       await usageDone;
       deletedSessions.clear();
       await dreamTrigger?.dispose();
+      await maintenanceTimer?.dispose();
       for (const release of rawProviders.values())
         release();
       rawProviders.clear();