@cortexkit/opencode-magic-context 0.49.10 → 0.49.12

package/dist/{context-ey3ap3cc.js → context-dam8p201.js}

@@ -1,14 +1,16 @@
 import {
   getMagicContextBuiltinCommands,
-  isDreamerRunnable,
-  isCompactionEnabled,
   getProtectedTokensTierOverrides,
   loadPluginConfigDetailed,
   historianRunConfig,
   dreamerRunConfig,
   pluginConfigReader,
   withLiveDreamerOutputCap,
+  embedPauseBySession,
+  autoEmbedAttemptedBySession,
+  autoEmbedIdentityBySession,
   invalidateAutoEmbedSession,
+  clearEmbedSessionState,
   acquireCompartmentLease,
   releaseCompartmentLeaseBestEffort,
   isCompartmentLeaseHeld,
@@ -59,7 +61,7 @@ import {
   rebaseSessionCoordinatesAsync,
   resolveOpenCodeProtectedTailBoundary,
   getActiveCompartmentRun
-} from "./index-3403gbzj.js";
+} from "./index-yx5kgp2x.js";
 import"./index-sd3egckz.js";
 import {
   getHarness2
@@ -67,11 +69,11 @@ import {
 import {
   getDataDir,
   getMagicContextStorageDir
-} from "./index-0sahzkwr.js";
+} from "./index-g2q4htwp.js";
 import {
   log2,
   sessionLog2
-} from "./index-mvvephtj.js";
+} from "./index-j75v2476.js";
 import {
   isSaneLimit,
   setOutputReserveConfig,
@@ -81,16 +83,74 @@ import {
   deriveHistorianChunkTokens2,
   resolveKnownHistorianContextLimit2,
   resolveHistorianContextLimit2
-} from "./index-jw4gbfkv.js";
-import"./index-w28y7d0z.js";
+} from "./index-8ketfacn.js";
+import"./index-1sarmj9z.js";
 import {
   CANONICAL_DREAM_TASKS,
   DREAM_TASK_CAPABILITIES,
   formatUnsupportedDreamTasks,
   isCanonicalDreamTask,
   buildDreamTaskRuntimeConfigs2,
-  userMemoryCollectionEnabled2
-} from "./index-ghc9f0n7.js";
+  userObservationCollectionEnabled2,
+  userObservationsRequested2
+} from "./index-p5y3k4g7.js";
+import {
+  logConfigDependencyNotesOnce,
+  runSessionProjectBackfill,
+  createLiveSessionState,
+  RETROSPECTIVE_MAX_USER_MESSAGE_CHARS,
+  RETROSPECTIVE_MESSAGE_TRUNCATION_MARKER,
+  createDreamTaskExecutor,
+  runManualDream,
+  runDueTasksForProject,
+  startDreamScheduleTimer,
+  createDreamTimerModuleClient,
+  ensureProjectRegisteredFromOpenCodeDirectory,
+  resolveContextLimit,
+  resolveModelKey,
+  createScheduler,
+  describeStorageUnavailability,
+  runEmbedHistoryDrain,
+  getSessionErrorInfo,
+  summarizeManualDream,
+  createChatMessageHook,
+  createToolExecuteAfterHook,
+  recordHiddenVariantWarning,
+  registerRpcHandlers,
+  stageOpenCodeV2TransformDecision,
+  bindOpenCodeV2TransformDecision,
+  armLatestThinkingRecoveryFromError,
+  createM0RenderOptions,
+  lkgReplayLimit,
+  measureLkgReplay,
+  STORAGE_BUSY_MESSAGE,
+  StorageBusyRefusalError,
+  bindSystemDateRequestIdentity,
+  bindSystemDateOutput,
+  registerSystemDateRefresh,
+  UnmanagedOverWindowError,
+  UnresolvedHistoryBoundaryError,
+  createTransform,
+  createSubcModuleClient,
+  createModuleToolBackends,
+  createRustRefusalRecovery,
+  createSystemPromptHashHandler,
+  tryMessagesTransformLkgReplay,
+  createMessagesTransformHandler,
+  subagentToolRefusal,
+  hideSubagentTools,
+  createCtxExpandTools,
+  createCtxMemoryTools,
+  createCtxMemoryListTools,
+  CTX_NOTE_DESCRIPTION,
+  withoutSmartNoteText,
+  createCtxNoteTools,
+  createCtxReduceTools,
+  createCtxSearchTools,
+  applyJsonSchemaParameterDescriptions,
+  MagicContextRpcServer,
+  subagentTemperature
+} from "./index-1wwh38fk.js";
 import {
   resolveHistorianModel2
 } from "./index-8cd2j99z.js";
@@ -105,12 +165,12 @@ import {
   openDatabaseAsync,
   isDatabasePersisted,
   getDatabasePersistenceError
-} from "./index-swgpe402.js";
+} from "./index-x2xjyq8f.js";
 import {
   setHomeProjectPermission,
   resolveProjectIdentityForSession,
   scheduleAfterBootQuiet
-} from "./index-0jz47061.js";
+} from "./index-a8bvhwqs.js";
 import {
   needsBlockedRead,
   markHostUnservedRow,
@@ -142,13 +202,13 @@ import {
   cleanUserText2,
   readRawSessionMessageIdOrdinalsForRange2,
   readRawSessionMessageOrdinalById2
-} from "./index-wpwpn7nj.js";
+} from "./index-b16gpywn.js";
 import {
   hasMeaningfulUserText2,
   preloadTokenizer,
   estimateTokens
-} from "./index-gjvjh960.js";
-import"./index-kvw6xew3.js";
+} from "./index-hqkczed7.js";
+import"./index-fkx2qnvw.js";
 import {
   inRootAsyncContext2,
   withSqliteTransformPass2,
@@ -156,17 +216,17 @@ import {
   isTransientSqliteError2,
   withAsyncPrivilegedWriter2
 } from "./index-wafzvyhg.js";
-import"./index-mp2kghkv.js";
+import"./index-dyvbsvga.js";
 import {
   deleteChunkEmbedBackoffForSession
-} from "./index-7bjgyaj1.js";
-import"./index-q28hsbpg.js";
+} from "./index-gf0psee3.js";
+import"./index-nj7yykkx.js";
 import {
   BoundedSessionMap,
   advanceSessionActivity,
   backfillSessionActivity
-} from "./index-0x9cn9w1.js";
-import"./index-g7jkrz0x.js";
+} from "./index-wqs4q74r.js";
+import"./index-bp5083x2.js";
 import"./index-1zx87sdm.js";
 import {
   stripPersistedAssistantText,
@@ -174,108 +234,68 @@ import {
   isDroppedToolOutput,
   evaluateChannel2,
   buildChannel2Reminder
-} from "./index-f8cn4xqa.js";
+} from "./index-fwefky9w.js";
 import"./index-v0p37hm2.js";
-import"./index-angx1s0k.js";
+import"./index-mmfa86mt.js";
 import"./index-58e3y90n.js";
-import"./index-q76br5zn.js";
+import"./index-1d289pq2.js";
 import {
   getCurrentToolSetHash,
   recordToolDefinition
-} from "./index-9jvab89d.js";
+} from "./index-n6m03s3n.js";
 import"./index-fr0wbhdn.js";
-import"./index-a865mj02.js";
-import"./index-rg1cezmj.js";
+import"./index-tdn0zkw4.js";
+import {
+  getProjectEmbeddingSnapshot2,
+  getAutoEmbeddingSessionCoverage2
+} from "./index-7zd5asz9.js";
 import"./index-fb3zxn06.js";
 import {
   renderUserFacingFailure,
   userFacingFailureCode
-} from "./index-16vwdyy5.js";
-import {
-  runSessionProjectBackfill,
-  createLiveSessionState,
-  RETROSPECTIVE_MAX_USER_MESSAGE_CHARS,
-  RETROSPECTIVE_MESSAGE_TRUNCATION_MARKER,
-  createDreamTaskExecutor,
-  runManualDream,
-  runDueTasksForProject,
-  startDreamScheduleTimer,
-  ensureProjectRegisteredFromOpenCodeDirectory,
-  resolveContextLimit,
-  resolveModelKey,
-  createScheduler,
-  describeStorageUnavailability,
-  getSessionErrorInfo,
-  summarizeManualDream,
-  createChatMessageHook,
-  createToolExecuteAfterHook,
-  recordHiddenVariantWarning,
-  registerRpcHandlers,
-  armLatestThinkingRecoveryFromError,
-  lkgReplayLimit,
-  measureLkgReplay,
-  STORAGE_BUSY_MESSAGE,
-  StorageBusyRefusalError,
-  bindSystemDateRequestIdentity,
-  bindSystemDateOutput,
-  registerSystemDateRefresh,
-  UnmanagedOverWindowError,
-  UnresolvedHistoryBoundaryError,
-  createTransform,
-  createSubcModuleClient,
-  createModuleToolBackends,
-  createRustRefusalRecovery,
-  createSystemPromptHashHandler,
-  tryMessagesTransformLkgReplay,
-  createMessagesTransformHandler,
-  subagentToolRefusal,
-  hideSubagentTools,
-  createCtxExpandTools,
-  createCtxMemoryTools,
-  createCtxMemoryListTools,
-  CTX_NOTE_DESCRIPTION,
-  withoutSmartNoteText,
-  createCtxNoteTools,
-  createCtxReduceTools,
-  createCtxSearchTools,
-  applyJsonSchemaParameterDescriptions,
-  MagicContextRpcServer,
-  subagentTemperature
-} from "./index-x57ep4fp.js";
+} from "./index-6sz25c3s.js";
 import {
   createTagger,
+  cavemanWordRulesForLanguage,
   setCtxReduceRegisteredGlobally,
   resolveCtxReduceAvailabilityFromMessages,
   EmergencyFailClosedError,
   DegradedPassRefusalError,
   isSyntheticHeadMessage2
-} from "./index-6k86es2p.js";
-import"./index-s178h9z8.js";
-import"./index-qt1qqasc.js";
+} from "./index-qtbdx42g.js";
+import"./index-f71thw8j.js";
+import {
+  isEmbeddingHostBusy2
+} from "./index-qt1qqasc.js";
 import"./index-4dhv7mqz.js";
-import"./index-bmwfzz28.js";
-import"./index-a43xq1pg.js";
+import"./index-9vqb5p1s.js";
+import"./index-fx90bvjd.js";
 import"./index-n78avt2p.js";
 import {
   pushNotification2,
   isTuiConnected2
 } from "./index-x8a7jmkh.js";
-import"./index-a4b0gbyg.js";
-import"./index-pgy3h49n.js";
-import"./index-ffa8x2as.js";
-import"./index-21919gcq.js";
-import"./index-mw7c950g.js";
+import"./index-y9f76s3f.js";
+import"./index-2pgxcncf.js";
+import"./index-6sytd5w3.js";
+import"./index-05n6ykca.js";
+import"./index-gp3kcpc4.js";
 import {
   detectConflicts
-} from "./index-b64n4d0h.js";
+} from "./index-kee4kn5j.js";
 import"./index-fmsr7v69.js";
+import {
+  isDreamerRunnable,
+  isSmartNoteSurfaceAvailable,
+  isCompactionEnabled
+} from "./index-ksdyrrav.js";
 import {
   sameProjectDirectory
 } from "./index-knvkbfvh.js";
 import {
   getErrorMessage
 } from "./index-y8v6yerm.js";
-import"./index-150zz6fh.js";
+import"./index-k29z4aqh.js";
 
 // src/hooks/magic-context/history-boundary-repair.ts
 function readBaseline(db, sessionId) {
@@ -1137,7 +1157,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;
@@ -1247,6 +1267,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,
@@ -3301,6 +3322,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 } : {}
@@ -3340,7 +3363,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,
@@ -3350,6 +3377,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,
@@ -3416,6 +3445,7 @@ function startDreamTrigger(context, args) {
             db,
             projectIdentity: args.projectIdentity(),
             projectMemoryEnabled: args.projectMemoryEnabled,
+            smartNotesEnabled: args.smartNotesEnabled,
             tasks: runnable,
             executor: createDreamTaskExecutor({
               hiddenCompletionExecutor: args.executor,
@@ -3425,6 +3455,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
             })
           });
@@ -4152,6 +4186,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}`;
@@ -4466,6 +4607,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);
@@ -4602,29 +4744,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;
@@ -4645,7 +4797,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))
     };
@@ -4659,6 +4812,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;
@@ -4768,7 +4922,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();
@@ -4783,6 +4937,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,
@@ -4912,6 +5072,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);
@@ -4943,16 +5105,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,
@@ -4972,6 +5140,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;
@@ -5046,7 +5215,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);
@@ -5110,7 +5279,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);
@@ -5192,6 +5361,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,
@@ -5221,14 +5391,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,
@@ -5256,14 +5439,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;
@@ -5334,6 +5513,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();
       }
@@ -5350,7 +5531,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 },
@@ -5360,6 +5541,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));
       }
@@ -5526,6 +5711,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,
@@ -5576,6 +5762,7 @@ ${baseline}
       await usageDone;
       deletedSessions.clear();
       await dreamTrigger?.dispose();
+      await maintenanceTimer?.dispose();
       for (const release of rawProviders.values())
         release();
       rawProviders.clear();