@cortexkit/opencode-magic-context 0.46.1 → 0.48.0

package/dist/index.js

@@ -1,15 +1,17 @@
 import {
-  setHarness,
+  setHarness2
+} from "./index-pavzsdc6.js";
+import {
   getOpenCodeStorageDir,
   getMagicContextStorageDir
-} from "./index-q6hef7fh.js";
+} from "./index-0sahzkwr.js";
 import {
   registerStalePluginBuildHost,
   importPluginModule,
-  log,
-  sessionLog,
-  flushLogger
-} from "./index-hybnrwq0.js";
+  log2,
+  sessionLog2,
+  flushLogger2
+} from "./index-8j7gqj40.js";
 import {
   withContentLanguageDirective,
   string,
@@ -21,7 +23,7 @@ import {
   record,
   DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE,
   DEFAULT_HISTORIAN_TIMEOUT_MS
-} from "./index-8x2v7gg9.js";
+} from "./index-bhvjj0ys.js";
 import {
   denyTaskRoutingToCallerAgents,
   buildHiddenAgentRegistrations,
@@ -40,9 +42,6 @@ import {
   dreamerRunConfig,
   pluginConfigReader,
   createDreamerOutputCapSampler,
-  observeSessionActivity,
-  backfillSessionActivity,
-  recordSessionProjectIdentity,
   COMPARTMENT_AGENT_SYSTEM_PROMPT,
   HISTORIAN_EDITOR_SYSTEM_PROMPT,
   COMPARTMENT_STRUCTURAL_SYSTEM_PROMPT,
@@ -52,7 +51,6 @@ import {
   invalidateAutoEmbedSession,
   getEmbedDrainUiStatus,
   clearEmbedSessionState,
-  deleteIndexedMessage,
   getProtectionWindowForSession,
   getPersistedReasoningWatermark,
   setPersistedReasoningWatermark,
@@ -68,7 +66,6 @@ import {
   clearDetectedContextLimit,
   getPersistedCompactionMarkerState,
   removeStrippedPlaceholderId,
-  armThinkingBindingRecovery,
   getPendingCompactionMarkerState,
   clearPendingCompactionMarkerStateIf,
   getSessionsWithPendingMarker,
@@ -84,16 +81,14 @@ import {
   markSessionCleanupPending,
   clearSession,
   recordPromptSessionError,
+  CTX_NOTE_LIGHT_DESCRIPTION,
   createPromptSurfaceRuntime,
   setKeepSubagents,
-  getProjectEmbeddingSnapshot,
-  getEmbeddingCoverageStatus,
-  getAutoEmbeddingSessionCoverage,
   removeCompactionMarkerForSession,
   checkCompactionMarkerConsistency,
   clearInjectionCache,
   clearNoteNudgeTriggerOnly
-} from "./index-sjthx78w.js";
+} from "./index-692jzy0p.js";
 import"./index-sd3egckz.js";
 import {
   reloadWindowOverlay,
@@ -104,19 +99,16 @@ import {
   deriveHistorianChunkTokens2,
   resolveKnownHistorianContextLimit2,
   resolveHistorianContextLimit2
-} from "./index-0d3g3461.js";
-import"./index-q4yp4b52.js";
+} from "./index-pdecwzrd.js";
+import"./index-mfkzp7qj.js";
 import {
   resolveOpenCodeDbPath,
   openCodeDbPathExists,
   formatOpenCodeDbMissingBanner,
-  claimOpenCodeDbDiagnosticOnce,
-  closeQuietly
-} from "./index-b35pxds2.js";
-import"./index-fg34g6a5.js";
+  claimOpenCodeDbDiagnosticOnce
+} from "./index-58e3y90n.js";
+import"./index-kb9nn0a0.js";
 import {
-  createSubcCheckoutClaimGate,
-  openCodeEventSessionId,
   openOpenCodeDb,
   DREAMER_SYSTEM_PROMPT,
   runSessionProjectBackfill,
@@ -131,6 +123,8 @@ import {
   createDbLkgPersistence,
   startDreamScheduleTimer,
   ensureProjectRegisteredFromOpenCodeDirectory,
+  recordOpenCodeProvenInputFloor,
+  resolveOpenCodeProvenInputFloor,
   resolveContextWindowGeometry,
   resolveContextLimit,
   resolveExecuteThresholdDetail,
@@ -161,6 +155,8 @@ import {
   clearTransformDecisionSession,
   scheduleOpenCodeTransformDecisionWrite,
   maybeDeliverChannel2,
+  armLatestThinkingRecovery,
+  armBindingRecoverySafely,
   clearMessageTokensCache,
   createTransform,
   createSubcModuleClient,
@@ -175,27 +171,19 @@ import {
   CTX_MEMORY_ACTIONS,
   createCtxMemoryTools,
   createCtxMemoryListTools,
+  withoutSmartNoteText,
   createCtxNoteTools,
   createCtxReduceTools,
   createCtxSearchTools,
   parameterDescriptionsFor,
   MagicContextRpcServer
-} from "./index-hpecdzec.js";
+} from "./index-0an7742d.js";
 import {
   formatFailClosedBlockingMessage,
   createFailClosedController,
   recordHookInitFailure,
   clearHookInitFailure,
   getLastHookInitFailure,
-  setHomeProjectPermission,
-  ProjectIdentityError,
-  resolveProjectIdentityStrict,
-  takeDubiousOwnershipProjectIdentityWarning,
-  resolveProjectIdentity,
-  resolveProjectIdentityForSession,
-  beginBootQuietPeriod,
-  bootQuietRemainingMs,
-  scheduleAfterBootQuiet,
   startBootDeadline,
   getSchemaFenceRejection,
   setSqlitePragmaConfig,
@@ -204,77 +192,123 @@ import {
   openDatabaseAsync,
   isDatabasePersisted,
   getDatabasePersistenceError
-} from "./index-r5hmbx3t.js";
+} from "./index-q7h7csab.js";
 import {
-  deleteTemporalDecision,
-  getCurrentToolSetHash,
-  recordToolDefinition
-} from "./index-5gq3b2ya.js";
+  setHomeProjectPermission,
+  ProjectIdentityError,
+  resolveProjectIdentityStrict,
+  takeDubiousOwnershipProjectIdentityWarning,
+  resolveProjectIdentity,
+  resolveProjectIdentityForSession,
+  beginBootQuietPeriod,
+  bootQuietRemainingMs,
+  scheduleAfterBootQuiet
+} from "./index-knh4y330.js";
+import {
+  deleteTemporalDecision
+} from "./index-db7zwa3v.js";
+import {
+  observeSessionActivity,
+  backfillSessionActivity,
+  deleteIndexedMessage
+} from "./index-14cjxt20.js";
+import {
+  recordSessionProjectIdentity,
+  getProjectEmbeddingSnapshot2,
+  getEmbeddingCoverageStatus2,
+  getAutoEmbeddingSessionCoverage2
+} from "./index-c43kr12f.js";
+import"./index-fb3zxn06.js";
+import"./index-fbv1dn35.js";
+import"./index-7mx8v0pw.js";
+import"./index-fr0wbhdn.js";
 import {
   preloadTokenizer
-} from "./index-5eqk6z3s.js";
+} from "./index-1qb0z7wa.js";
+import {
+  getCurrentToolSetHash,
+  recordToolDefinition
+} from "./index-0qhce371.js";
 import {
-  stripPersistedAssistantText,
-  deleteTagsByMessageId,
-  getMaxTagNumberBySession,
   invalidateTrueRawTokenCache,
   recordToolParameters,
   createDroppedInputToolExecuteBeforeHook,
   detectThinkingBindingMismatch,
+  detectLatestTurnThinkingMismatch,
   isPrefixBoundThinkingModel,
   detectOverflow,
+  isAnthropicFamilyRoute,
   readRawSessionMessages2
-} from "./index-3h0ybwah.js";
+} from "./index-bdckkfw6.js";
+import"./index-72nhv486.js";
 import {
-  isEmbeddingHostBusy,
-  sendCommandResult2,
-  sendStatusNotification2
-} from "./index-7qw742ev.js";
-import"./index-fzbvakh0.js";
+  isEmbeddingHostBusy2
+} from "./index-qt1qqasc.js";
+import"./index-jcbd3znx.js";
+import {
+  registerExitAbort,
+  unregisterExitAbort,
+  forgetRawSessionOrdinalWatermark2
+} from "./index-dhwzyd54.js";
 import {
   observeOpenCodeTurnEvent,
   clearTrackedOpenCodeSession,
   findLastAssistantModelFromOpenCodeDb
-} from "./index-majxda46.js";
+} from "./index-ty64eqcn.js";
+import {
+  sendCommandResult2,
+  sendStatusNotification2
+} from "./index-yq8n9qcb.js";
 import {
   detectConflicts,
   resolveCompactionForBoot
-} from "./index-8da2zjhz.js";
+} from "./index-eeezr5zz.js";
 import {
   sendConflictWarning2,
   cleanupConflictWarnings2
-} from "./index-sfnj6h8h.js";
+} from "./index-z8e0psj8.js";
 import"./index-1zx87sdm.js";
+import {
+  stripPersistedAssistantText,
+  deleteTagsByMessageId2,
+  getMaxTagNumberBySession2
+} from "./index-k9nnwad5.js";
 import {
   resolveHistorianModel2,
   resolveOpenCodeAgentOverrides2,
   resolveHistorianAgentOverrides2
-} from "./index-sfpzqvdz.js";
+} from "./index-8cd2j99z.js";
 import {
   buildDreamTaskRuntimeConfigs2,
   userMemoryCollectionEnabled2
-} from "./index-mc22ayvf.js";
+} from "./index-ghc9f0n7.js";
+import"./index-pg50n748.js";
+import"./index-cb7emxgj.js";
 import {
   pushNotification2
 } from "./index-x8a7jmkh.js";
+import"./index-4dhv7mqz.js";
+import"./index-5zygecde.js";
+import"./index-7jzrrxap.js";
+import"./index-q2tqeqde.js";
 import {
   createTagger,
   cavemanWordRulesForLanguage,
   setCtxReduceRegisteredGlobally,
   clearToolPermissionDenied,
   resetDegradedCacheCount2
-} from "./index-pkbcrdqs.js";
+} from "./index-f0h6xwqm.js";
 import {
   runManagedRecomp2
-} from "./index-sgthv3f7.js";
+} from "./index-mmyh6d8f.js";
 import {
   isValidSemver,
   compareSemverCore
-} from "./index-k5bdx1bx.js";
+} from "./index-0w56v4fm.js";
 import"./index-fmsr7v69.js";
 import {
   runManagedWrapup2
-} from "./index-5p8jdswx.js";
+} from "./index-k1xb52kd.js";
 import {
   __toESM,
   __commonJS
@@ -291,7 +325,10 @@ import {
 import {
   piModelRefToCanonical
 } from "./index-avwt563y.js";
-import"./index-sj29b3z2.js";
+import {
+  closeQuietly
+} from "./index-8ajstryz.js";
+import"./index-2y0s2hep.js";
 
 // ../../node_modules/.bun/esprima@4.0.1/node_modules/esprima/dist/esprima.js
 var require_esprima = __commonJS(function(exports, module) {
@@ -8347,9 +8384,9 @@ async function runDeferredV22Backfill(db, options = {}) {
   const status = updateFinalBackfillStatus(db);
   const failureCount = countFailures(db);
   if (failureCount > 0) {
-    log(`[v22-backfill] completed with ${failureCount} unresolved failure(s); run doctor --retry-v22-backfill`);
+    log2(`[v22-backfill] completed with ${failureCount} unresolved failure(s); run doctor --retry-v22-backfill`);
   } else {
-    log(`[v22-backfill] completed; processed=${processedRows}, changed=${changedRows}`);
+    log2(`[v22-backfill] completed; processed=${processedRows}, changed=${changedRows}`);
   }
   return {
     status,
@@ -8448,7 +8485,7 @@ var PackageJsonSchema = object({
 
 // src/hooks/auto-update-checker/checker.ts
 function warn(message) {
-  log(`WARN: ${message}`);
+  log2(`WARN: ${message}`);
 }
 function isString(value) {
   return typeof value === "string";
@@ -8518,7 +8555,7 @@ function getWinningConfig(directory, surface) {
       const entries = getPluginEntries(parsed);
       if (entries.some((entry) => entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`))) {
         if (winner) {
-          log(`[auto-update-checker] ${surface} config ${winner.path} is shadowed by ${path}`);
+          log2(`[auto-update-checker] ${surface} config ${winner.path} is shadowed by ${path}`);
         }
         winner = { path, entries };
       }
@@ -8818,7 +8855,7 @@ var DEFAULT_INIT_DELAY_MS = 5000;
 var PENDING_UPDATE_FILENAME = "pending-plugin-update.json";
 var PENDING_UPDATE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 function warn2(message) {
-  log(`WARN: ${message}`);
+  log2(`WARN: ${message}`);
 }
 function createAutoUpdateCheckerHook(ctx, options = {}) {
   const {
@@ -8861,7 +8898,7 @@ async function maybeRunCheck(ctx, options) {
   if (options.signal.aborted)
     return;
   if (!claimCheckSlot(options.storageDir, options.checkIntervalMs)) {
-    log("[auto-update-checker] Skipping check (another instance ran one recently)");
+    log2("[auto-update-checker] Skipping check (another instance ran one recently)");
     return;
   }
   await runStartupCheck(ctx, options);
@@ -8925,7 +8962,7 @@ function consumePendingUpdateMarker(storageDir, loadedVersion) {
     const olderThanLoaded = typeof marker.version === "string" && typeof loadedVersion === "string" && (compareSemverCore(marker.version, loadedVersion) ?? 0) < 0;
     if (marker.version === loadedVersion && marker.spec === `${PACKAGE_NAME}@${loadedVersion}` && Array.isArray(marker.configPaths) && marker.configPaths.length === 2) {
       rmSync(path, { force: true });
-      log(`[auto-update-checker] Pending update applied: ${marker.spec}`);
+      log2(`[auto-update-checker] Pending update applied: ${marker.spec}`);
     } else if (age > PENDING_UPDATE_MAX_AGE_MS || olderThanLoaded) {
       rmSync(path, { force: true });
       warn2("[auto-update-checker] Discarded stale or mismatched pending update marker");
@@ -8948,7 +8985,7 @@ async function runStartupCheck(ctx, options) {
     if (options.showStartupToast) {
       showToast(ctx, `Magic Context ${displayVersion} (dev)`, "Running in local development mode.", "info");
     }
-    log("[auto-update-checker] Local development mode");
+    log2("[auto-update-checker] Local development mode");
     return;
   }
   if (options.showStartupToast) {
@@ -8961,19 +8998,19 @@ async function runBackgroundUpdateCheck(ctx, options) {
     return;
   const pluginInfo = findPluginEntry(ctx.directory);
   if (!pluginInfo) {
-    log("[auto-update-checker] Plugin not found in config");
+    log2("[auto-update-checker] Plugin not found in config");
     return;
   }
   if (hasExplicitNonExactPluginVersion(pluginInfo.entry)) {
     if (pluginInfo.entry === `${PACKAGE_NAME}@latest`) {
-      log("[auto-update-checker] Explicit @latest leaves the active package unpinned; OpenCode may delete it mid-session.");
+      log2("[auto-update-checker] Explicit @latest leaves the active package unpinned; OpenCode may delete it mid-session.");
     }
     return;
   }
   const cachedVersion = getCachedVersion(pluginInfo.entry);
   const currentVersion = cachedVersion ?? pluginInfo.pinnedVersion;
   if (!currentVersion) {
-    log("[auto-update-checker] No version found (cached or pinned)");
+    log2("[auto-update-checker] No version found (cached or pinned)");
     return;
   }
   const channel = extractChannel(pluginInfo.pinnedVersion ?? currentVersion);
@@ -8988,22 +9025,22 @@ async function runBackgroundUpdateCheck(ctx, options) {
     return;
   }
   if (currentVersion === latestVersion) {
-    log(`[auto-update-checker] Already on latest version for channel: ${channel}`);
+    log2(`[auto-update-checker] Already on latest version for channel: ${channel}`);
     return;
   }
-  log(`[auto-update-checker] Update available (${channel}): ${currentVersion} → ${latestVersion}`);
+  log2(`[auto-update-checker] Update available (${channel}): ${currentVersion} → ${latestVersion}`);
   const updaterOwnedPin = pluginInfo.isPinned && isUpdaterPinnedSpec(readAutoUpdateCheckState(checkStatePath(options.storageDir)), pluginInfo.entry);
   if (pluginInfo.isPinned && !updaterOwnedPin) {
     showToast(ctx, `Magic Context ${latestVersion}`, `v${latestVersion} available. This version was pinned by you; update your OpenCode plugin config to upgrade.`, "info", 8000);
-    log("[auto-update-checker] Version was pinned by you; skipping auto-update");
+    log2("[auto-update-checker] Version was pinned by you; skipping auto-update");
     return;
   }
   if (updaterOwnedPin) {
-    log("[auto-update-checker] Version was pinned by the updater; continuing auto-update");
+    log2("[auto-update-checker] Version was pinned by the updater; continuing auto-update");
   }
   if (!options.autoUpdate) {
     showToast(ctx, `Magic Context ${latestVersion}`, `v${latestVersion} available. Auto-update is disabled.`, "info", 8000);
-    log("[auto-update-checker] Auto-update disabled, notification only");
+    log2("[auto-update-checker] Auto-update disabled, notification only");
     return;
   }
   const preparedUpdate = await preparePluginUpdate(ctx.directory, pluginInfo, latestVersion, {
@@ -9013,7 +9050,7 @@ async function runBackgroundUpdateCheck(ctx, options) {
     writePendingUpdateMarker(options.storageDir, preparedUpdate, latestVersion);
     showToast(ctx, "Magic Context Update Ready", `v${currentVersion} → v${latestVersion}
 Restart OpenCode to apply.`, "success", 8000);
-    log(`[auto-update-checker] Update ready: ${currentVersion} → ${latestVersion}`);
+    log2(`[auto-update-checker] Update ready: ${currentVersion} → ${latestVersion}`);
     return;
   }
   showToast(ctx, `Magic Context ${latestVersion}`, `v${latestVersion} available, but auto-update failed to update both plugin configs.`, "error", 8000);
@@ -9264,7 +9301,7 @@ function recordSwallowedWrite(error) {
   try {
     swallowedWriteCount++;
     lastErrorMessage = error instanceof Error ? error.message : String(error);
-    log("[magic-context] window report ledger write failed:", error);
+    log2("[magic-context] window report ledger write failed:", error);
   } catch {}
 }
 function positiveFiniteNumber(value) {
@@ -9398,14 +9435,6 @@ function captureWindowReport(input) {
 }
 
 // src/hooks/magic-context/context-limit-resolution.ts
-function provenFloorForModel(storedFloor, storedModelKey, modelKey) {
-  if (typeof storedFloor !== "number" || !Number.isFinite(storedFloor) || storedFloor <= 0) {
-    return 0;
-  }
-  if (!storedModelKey || !modelKey)
-    return 0;
-  return piModelRefToCanonical(storedModelKey) === piModelRefToCanonical(modelKey) ? storedFloor : 0;
-}
 function describeContextLimitChange(previous, next) {
   if (previous.limit === next.limit && previous.modelKey === next.modelKey)
     return null;
@@ -9429,12 +9458,12 @@ function noteContextLimitResolution(sessionId, resolution) {
   const previous = lastResolutionBySession.get(sessionId);
   lastResolutionBySession.set(sessionId, resolution);
   if (!previous) {
-    sessionLog(sessionId, `context limit resolved: ${resolution.limit} for ${resolution.modelKey ?? "unknown model"} (catalog ${resolution.catalog ?? "unknown"}, overflow-detected ${resolution.detected}, proven accepted input ${resolution.provenFloor})`);
+    sessionLog2(sessionId, `context limit resolved: ${resolution.limit} for ${resolution.modelKey ?? "unknown model"} (catalog ${resolution.catalog ?? "unknown"}, overflow-detected ${resolution.detected}, proven accepted input ${resolution.provenFloor})`);
     return;
   }
   const change = describeContextLimitChange(previous, resolution);
   if (change)
-    sessionLog(sessionId, change);
+    sessionLog2(sessionId, change);
 }
 
 // src/hooks/magic-context/event-handler.ts
@@ -9468,16 +9497,16 @@ async function deliverChannel2IfPending(deps, sessionId) {
       deps.channel2DirectiveTextBySession?.delete(sessionId);
     }
   } catch (error) {
-    sessionLog(sessionId, "channel2 delivery wrapper failed (ignored):", error);
+    sessionLog2(sessionId, "channel2 delivery wrapper failed (ignored):", error);
   }
 }
 function cleanupRemovedMessageState(deps, sessionId, messageId) {
   return deps.db.transaction(() => {
-    const removedTagNumbers = deleteTagsByMessageId(deps.db, sessionId, messageId);
+    const removedTagNumbers = deleteTagsByMessageId2(deps.db, sessionId, messageId);
     deleteTemporalDecision(deps.db, sessionId, messageId);
-    sessionLog(sessionId, `event message.removed: deleted ${removedTagNumbers.length} tag(s) for message ${messageId}`);
+    sessionLog2(sessionId, `event message.removed: deleted ${removedTagNumbers.length} tag(s) for message ${messageId}`);
     const strippedPlaceholderRemoved = removeStrippedPlaceholderId(deps.db, sessionId, messageId);
-    sessionLog(sessionId, strippedPlaceholderRemoved ? `event message.removed: removed ${messageId} from stripped placeholder ids` : `event message.removed: stripped placeholder ids unchanged for ${messageId}`);
+    sessionLog2(sessionId, strippedPlaceholderRemoved ? `event message.removed: removed ${messageId} from stripped placeholder ids` : `event message.removed: stripped placeholder ids unchanged for ${messageId}`);
     const removedNoteNudgeAnchor = removeNoteNudgeAnchorByMessageId(deps.db, sessionId, messageId);
     const removedAutoSearchDecision = removeAutoSearchHintDecisionByMessageId(deps.db, sessionId, messageId);
     const persistedNoteNudge = getPersistedNoteNudge(deps.db, sessionId);
@@ -9486,18 +9515,18 @@ function cleanupRemovedMessageState(deps, sessionId, messageId) {
       clearNoteNudgeTriggerOnly(deps.db, sessionId);
     }
     const clearedNoteNudge = removedNoteNudgeAnchor || clearedNoteNudgeTrigger;
-    sessionLog(sessionId, clearedNoteNudge ? `event message.removed: pruned note nudge state for ${messageId}` : `event message.removed: note nudge state unchanged for ${messageId}`);
-    sessionLog(sessionId, removedAutoSearchDecision ? `event message.removed: pruned auto-search decision for ${messageId}` : `event message.removed: auto-search decision unchanged for ${messageId}`);
+    sessionLog2(sessionId, clearedNoteNudge ? `event message.removed: pruned note nudge state for ${messageId}` : `event message.removed: note nudge state unchanged for ${messageId}`);
+    sessionLog2(sessionId, removedAutoSearchDecision ? `event message.removed: pruned auto-search decision for ${messageId}` : `event message.removed: auto-search decision unchanged for ${messageId}`);
     const currentWatermark = getPersistedReasoningWatermark(deps.db, sessionId);
-    const maxRemainingTag = getMaxTagNumberBySession(deps.db, sessionId);
+    const maxRemainingTag = getMaxTagNumberBySession2(deps.db, sessionId);
     if (currentWatermark > maxRemainingTag) {
       setPersistedReasoningWatermark(deps.db, sessionId, maxRemainingTag);
-      sessionLog(sessionId, `event message.removed: reset reasoning watermark ${currentWatermark}→${maxRemainingTag}`);
+      sessionLog2(sessionId, `event message.removed: reset reasoning watermark ${currentWatermark}→${maxRemainingTag}`);
     } else {
-      sessionLog(sessionId, `event message.removed: reasoning watermark unchanged at ${currentWatermark} (max tag ${maxRemainingTag})`);
+      sessionLog2(sessionId, `event message.removed: reasoning watermark unchanged at ${currentWatermark} (max tag ${maxRemainingTag})`);
     }
     const removedIndexedMessages = deleteIndexedMessage(deps.db, sessionId, messageId);
-    sessionLog(sessionId, `event message.removed: deleted ${removedIndexedMessages} indexed message row(s) for ${messageId}`);
+    sessionLog2(sessionId, `event message.removed: deleted ${removedIndexedMessages} indexed message row(s) for ${messageId}`);
     return {
       clearedNoteNudge
     };
@@ -9516,7 +9545,7 @@ function createEventHandler2(deps) {
       }
       if (deps.internalChildSessions && info.parentID.length > 0 && typeof info.title === "string" && info.title.startsWith(INTERNAL_CHILD_TITLE_PREFIX)) {
         deps.internalChildSessions.add(info.id);
-        sessionLog(info.id, `marked internal magic-context child (title="${info.title}") — exempt from transform + injection`);
+        sessionLog2(info.id, `marked internal magic-context child (title="${info.title}") — exempt from transform + injection`);
       }
       try {
         if (info.directory) {
@@ -9529,7 +9558,7 @@ function createEventHandler2(deps) {
           cacheTtl: resolveSessionCacheTtl(deps.db, info.id, ttlConfig.cache_ttl, modelKey, ttlConfig.cacheTtlConfigured).value
         });
       } catch (error) {
-        sessionLog(info.id, "event session.created persistence failed:", error);
+        sessionLog2(info.id, "event session.created persistence failed:", error);
       }
       return;
     }
@@ -9540,12 +9569,21 @@ function createEventHandler2(deps) {
       }
       recordPromptSessionError(errInfo.sessionID, errInfo.error);
       try {
+        if (detectLatestTurnThinkingMismatch(errInfo.error)) {
+          const model = findLastAssistantModelFromOpenCodeDb(errInfo.sessionID);
+          if (!deps.compactionOff && isAnthropicFamilyRoute(model?.providerID, model?.modelID)) {
+            armLatestThinkingRecovery(deps.db, errInfo.sessionID);
+            dropSlot(errInfo.sessionID, "latest-thinking-recovery-arm");
+            deps.onSessionCacheInvalidated?.(errInfo.sessionID);
+          }
+          return;
+        }
         const bindingMismatch = detectThinkingBindingMismatch(errInfo.error);
         if (bindingMismatch.isBindingMismatch) {
           const model = findLastAssistantModelFromOpenCodeDb(errInfo.sessionID);
           if (deps.thinkingBindingRecoveryEnabled !== false && !deps.compactionOff && isPrefixBoundThinkingModel(model?.providerID, model?.modelID)) {
-            armThinkingBindingRecovery(deps.db, errInfo.sessionID);
-            sessionLog(errInfo.sessionID, `thinking binding recovery armed from session.error (provider paths: failing=${bindingMismatch.failingBlockPath ?? "?"} firstChanged=${bindingMismatch.firstChangedPath ?? "?"})`);
+            armBindingRecoverySafely(deps.db, errInfo.sessionID);
+            sessionLog2(errInfo.sessionID, `thinking binding recovery armed from session.error (provider paths: failing=${bindingMismatch.failingBlockPath ?? "?"} firstChanged=${bindingMismatch.firstChangedPath ?? "?"})`);
             dropSlot(errInfo.sessionID, "thinking-binding-recovery-arm");
             deps.onSessionCacheInvalidated?.(errInfo.sessionID);
           }
@@ -9571,7 +9609,7 @@ function createEventHandler2(deps) {
           if (typeof detection.reportedLimit === "number" && detection.reportedLimit > 0) {
             recordDetectedContextLimit(deps.db, errInfo.sessionID, detection.reportedLimit, overflowModelKey, detection.reportedLimitProvenance);
           }
-          sessionLog(errInfo.sessionID, `overflow detected on subagent: reportedLimit=${detection.reportedLimit ?? "unknown"} provenance=${detection.reportedLimitProvenance ?? "n/a"} pattern=${detection.matchedPattern ?? "n/a"} — recorded limit only (subagents cannot run historian)`);
+          sessionLog2(errInfo.sessionID, `overflow detected on subagent: reportedLimit=${detection.reportedLimit ?? "unknown"} provenance=${detection.reportedLimitProvenance ?? "n/a"} pattern=${detection.matchedPattern ?? "n/a"} — recorded limit only (subagents cannot run historian)`);
           return;
         }
         const existing = getOverflowState(deps.db, errInfo.sessionID);
@@ -9579,7 +9617,7 @@ function createEventHandler2(deps) {
           if (typeof detection.reportedLimit === "number" && detection.reportedLimit > 0) {
             recordDetectedContextLimit(deps.db, errInfo.sessionID, detection.reportedLimit, overflowModelKey, detection.reportedLimitProvenance);
           }
-          sessionLog(errInfo.sessionID, `overflow detected in compaction-off mode: reportedLimit=${detection.reportedLimit ?? "unknown"} provenance=${detection.reportedLimitProvenance ?? "n/a"} pattern=${detection.matchedPattern ?? "n/a"} — recorded limit only (recovery disarmed; native compaction owns the window)`);
+          sessionLog2(errInfo.sessionID, `overflow detected in compaction-off mode: reportedLimit=${detection.reportedLimit ?? "unknown"} provenance=${detection.reportedLimitProvenance ?? "n/a"} pattern=${detection.matchedPattern ?? "n/a"} — recorded limit only (recovery disarmed; native compaction owns the window)`);
           return;
         }
         dropSlot(errInfo.sessionID, "overflow-recovery-arm");
@@ -9595,10 +9633,10 @@ function createEventHandler2(deps) {
             updatedAt: Date.now()
           });
         }
-        sessionLog(errInfo.sessionID, `overflow detected via session.error: reportedLimit=${detection.reportedLimit ?? "unknown"} provenance=${detection.reportedLimitProvenance ?? "n/a"} pattern=${detection.matchedPattern ?? "n/a"} (previousRecovery=${existing.needsEmergencyRecovery})`);
+        sessionLog2(errInfo.sessionID, `overflow detected via session.error: reportedLimit=${detection.reportedLimit ?? "unknown"} provenance=${detection.reportedLimitProvenance ?? "n/a"} pattern=${detection.matchedPattern ?? "n/a"} (previousRecovery=${existing.needsEmergencyRecovery})`);
         deps.onSessionCacheInvalidated?.(errInfo.sessionID);
       } catch (error) {
-        sessionLog(errInfo.sessionID, "event session.error handling failed:", error);
+        sessionLog2(errInfo.sessionID, "event session.error handling failed:", error);
       }
       return;
     }
@@ -9610,7 +9648,7 @@ function createEventHandler2(deps) {
           const time = rawInfo && typeof rawInfo === "object" && "time" in rawInfo ? rawInfo.time?.created : undefined;
           observeSessionActivity(deps.db, message.sessionID, typeof time === "number" ? time : Date.now());
         } catch (error) {
-          sessionLog(message.sessionID, "event message.updated activity persistence failed:", error);
+          sessionLog2(message.sessionID, "event message.updated activity persistence failed:", error);
         }
       }
       const info = getMessageUpdatedAssistantInfo(input.event.properties);
@@ -9620,9 +9658,9 @@ function createEventHandler2(deps) {
           return;
         const sessionId = properties ? resolveSessionId(properties) : null;
         if (sessionId) {
-          sessionLog(sessionId, "event message.updated: no assistant info extracted from event");
+          sessionLog2(sessionId, "event message.updated: no assistant info extracted from event");
         } else {
-          log("[magic-context] event message.updated: no assistant info extracted from event");
+          log2("[magic-context] event message.updated: no assistant info extracted from event");
         }
         return;
       }
@@ -9651,15 +9689,21 @@ function createEventHandler2(deps) {
       }
       let messageHadOverflowError = false;
       if (info.error !== undefined && info.error !== null) {
+        if (detectLatestTurnThinkingMismatch(info.error) && !deps.compactionOff && isAnthropicFamilyRoute(info.providerID, info.modelID)) {
+          armLatestThinkingRecovery(deps.db, info.sessionID);
+          dropSlot(info.sessionID, "latest-thinking-recovery-arm");
+          deps.onSessionCacheInvalidated?.(info.sessionID);
+          return;
+        }
         const bindingMismatch = detectThinkingBindingMismatch(info.error);
         if (bindingMismatch.isBindingMismatch && deps.thinkingBindingRecoveryEnabled !== false && !deps.compactionOff && isPrefixBoundThinkingModel(info.providerID, info.modelID)) {
           try {
-            armThinkingBindingRecovery(deps.db, info.sessionID);
-            sessionLog(info.sessionID, `thinking binding recovery armed from message.updated (provider paths: failing=${bindingMismatch.failingBlockPath ?? "?"} firstChanged=${bindingMismatch.firstChangedPath ?? "?"})`);
+            armBindingRecoverySafely(deps.db, info.sessionID);
+            sessionLog2(info.sessionID, `thinking binding recovery armed from message.updated (provider paths: failing=${bindingMismatch.failingBlockPath ?? "?"} firstChanged=${bindingMismatch.firstChangedPath ?? "?"})`);
             dropSlot(info.sessionID, "thinking-binding-recovery-arm");
             deps.onSessionCacheInvalidated?.(info.sessionID);
           } catch (error) {
-            sessionLog(info.sessionID, "event message.updated thinking binding recovery persistence failed:", error);
+            sessionLog2(info.sessionID, "event message.updated thinking binding recovery persistence failed:", error);
           }
         }
       }
@@ -9685,12 +9729,12 @@ function createEventHandler2(deps) {
               if (typeof detection.reportedLimit === "number" && detection.reportedLimit > 0) {
                 recordDetectedContextLimit(deps.db, info.sessionID, detection.reportedLimit, overflowModelKey, detection.reportedLimitProvenance);
               }
-              sessionLog(info.sessionID, `overflow detected on subagent via message.updated: reportedLimit=${detection.reportedLimit ?? "unknown"} provenance=${detection.reportedLimitProvenance ?? "n/a"} pattern=${detection.matchedPattern ?? "n/a"} — recorded limit only`);
+              sessionLog2(info.sessionID, `overflow detected on subagent via message.updated: reportedLimit=${detection.reportedLimit ?? "unknown"} provenance=${detection.reportedLimitProvenance ?? "n/a"} pattern=${detection.matchedPattern ?? "n/a"} — recorded limit only`);
             } else if (deps.compactionOff) {
               if (typeof detection.reportedLimit === "number" && detection.reportedLimit > 0) {
                 recordDetectedContextLimit(deps.db, info.sessionID, detection.reportedLimit, overflowModelKey, detection.reportedLimitProvenance);
               }
-              sessionLog(info.sessionID, `overflow detected in compaction-off mode via message.updated: reportedLimit=${detection.reportedLimit ?? "unknown"} provenance=${detection.reportedLimitProvenance ?? "n/a"} pattern=${detection.matchedPattern ?? "n/a"} — recorded limit only`);
+              sessionLog2(info.sessionID, `overflow detected in compaction-off mode via message.updated: reportedLimit=${detection.reportedLimit ?? "unknown"} provenance=${detection.reportedLimitProvenance ?? "n/a"} pattern=${detection.matchedPattern ?? "n/a"} — recorded limit only`);
             } else {
               dropSlot(info.sessionID, "overflow-recovery-arm");
               recordOverflowDetected(deps.db, info.sessionID, detection.reportedLimit, overflowModelKey, "provider_overflow", detection.reportedLimitProvenance, detection.reportedInputTokens);
@@ -9705,11 +9749,11 @@ function createEventHandler2(deps) {
                   updatedAt: Date.now()
                 });
               }
-              sessionLog(info.sessionID, `overflow detected via message.updated: reportedLimit=${detection.reportedLimit ?? "unknown"} provenance=${detection.reportedLimitProvenance ?? "n/a"} pattern=${detection.matchedPattern ?? "n/a"}`);
+              sessionLog2(info.sessionID, `overflow detected via message.updated: reportedLimit=${detection.reportedLimit ?? "unknown"} provenance=${detection.reportedLimitProvenance ?? "n/a"} pattern=${detection.matchedPattern ?? "n/a"}`);
               deps.onSessionCacheInvalidated?.(info.sessionID);
             }
           } catch (error) {
-            sessionLog(info.sessionID, "event message.updated overflow persistence failed:", error);
+            sessionLog2(info.sessionID, "event message.updated overflow persistence failed:", error);
           }
         }
       }
@@ -9739,7 +9783,7 @@ function createEventHandler2(deps) {
           inputTokens: (info.tokens?.input ?? 0) + (info.tokens?.cache?.read ?? 0) + (info.tokens?.cache?.write ?? 0)
         });
       }
-      sessionLog(info.sessionID, `event message.updated: provider=${info.providerID} model=${info.modelID} hasUsageTokens=${hasUsageTokens} tokens.input=${info.tokens?.input} cache.read=${info.tokens?.cache?.read} cache.write=${info.tokens?.cache?.write} message.id=${info.messageID} session.id=${info.sessionID}`);
+      sessionLog2(info.sessionID, `event message.updated: provider=${info.providerID} model=${info.modelID} hasUsageTokens=${hasUsageTokens} tokens.input=${info.tokens?.input} cache.read=${info.tokens?.cache?.read} cache.write=${info.tokens?.cache?.write} message.id=${info.messageID} session.id=${info.sessionID}`);
       const hasKnownUsage = hasUsageTokens || deps.contextUsageMap.has(info.sessionID);
       if (successfulCompletion && !hasUsageTokens) {
         try {
@@ -9751,11 +9795,11 @@ function createEventHandler2(deps) {
             });
           }
         } catch (error) {
-          sessionLog(info.sessionID, "event completion clock persistence failed:", error);
+          sessionLog2(info.sessionID, "event completion clock persistence failed:", error);
         }
       }
       if (!hasKnownUsage) {
-        sessionLog(info.sessionID, "event message.updated: skipping — no usage tokens and no known usage");
+        sessionLog2(info.sessionID, "event message.updated: skipping — no usage tokens and no known usage");
         return;
       }
       try {
@@ -9778,7 +9822,7 @@ function createEventHandler2(deps) {
         if (hasUsageTokens && aboveTrustedWall) {
           if (!usageAboveWallLogSeen.has(aboveWallLogKey)) {
             usageAboveWallLogSeen.add(aboveWallLogKey);
-            sessionLog(info.sessionID, `provider usage ${totalInputTokens} exceeds configured window ${trustedAbsoluteWall}; counted as real pressure against the configured limit`);
+            sessionLog2(info.sessionID, `provider usage ${totalInputTokens} exceeds configured window ${trustedAbsoluteWall}; counted as real pressure against the configured limit`);
           }
         } else {
           usageAboveWallLogSeen.delete(aboveWallLogKey);
@@ -9786,14 +9830,14 @@ function createEventHandler2(deps) {
         let refreshLimitsAfterRecording;
         if (hasUsageTokens) {
           const pressureInputTokens = totalInputTokens;
-          const requestSucceeded = !messageHadOverflowError;
+          const requestSucceeded = !messageHadOverflowError && !responseFailed;
           const successfulUsageProof = requestSucceeded && !aboveTrustedWall;
           if (requestSucceeded) {
             const rawOverflow = getOverflowState(deps.db, info.sessionID);
             const detectedLimitMatchesModel = rawOverflow.detectedContextLimitModelKey === null || modelKey !== undefined && rawOverflow.detectedContextLimitModelKey === modelKey;
             if (rawOverflow.detectedContextLimit > 0 && detectedLimitMatchesModel && pressureInputTokens > rawOverflow.detectedContextLimit) {
               clearDetectedContextLimit(deps.db, info.sessionID);
-              sessionLog(info.sessionID, `detected limit ${rawOverflow.detectedContextLimit} invalidated by a successful ${pressureInputTokens}-token request; using catalog/default`);
+              sessionLog2(info.sessionID, `detected limit ${rawOverflow.detectedContextLimit} invalidated by a successful ${pressureInputTokens}-token request; using catalog/default`);
               deps.onSessionCacheInvalidated?.(info.sessionID);
             }
           }
@@ -9801,7 +9845,7 @@ function createEventHandler2(deps) {
           if (!responseFailed) {
             updates.lastResponseTime = Math.max(sessionMeta.lastResponseTime, responseTime);
           }
-          const observedSafeInputTokens = provenFloorForModel(sessionMeta.observedSafeInputTokens, sessionMeta.lastObservedModelKey, modelKey);
+          const observedSafeInputTokens = resolveOpenCodeProvenInputFloor(deps.db, info.sessionID, modelKey);
           const provenSafeInputTokens = successfulUsageProof ? Math.max(observedSafeInputTokens, pressureInputTokens) : observedSafeInputTokens;
           const readCatalogLimit = () => info.providerID && info.modelID ? getSdkContextLimit(info.providerID, info.modelID) : undefined;
           const resolvePressure = () => {
@@ -9818,7 +9862,7 @@ function createEventHandler2(deps) {
           };
           const newestMessageId = newestUsageMessageIdBySession.get(info.sessionID);
           if (info.messageID !== undefined && newestMessageId !== undefined && info.messageID < newestMessageId) {
-            sessionLog(info.sessionID, `event message.updated: usage ${pressureInputTokens} from ${info.messageID} arrived after newer message ${newestMessageId}; keeping the newer reading`);
+            sessionLog2(info.sessionID, `event message.updated: usage ${pressureInputTokens} from ${info.messageID} arrived after newer message ${newestMessageId}; keeping the newer reading`);
             return;
           }
           if (info.messageID !== undefined) {
@@ -9832,7 +9876,7 @@ function createEventHandler2(deps) {
               detected: getOverflowState(deps.db, info.sessionID, modelKey).detectedContextLimit,
               provenFloor: successfulUsageProof ? provenSafeInputTokens : observedSafeInputTokens
             });
-            sessionLog(info.sessionID, `event message.updated: totalInputTokens=${pressureInputTokens} contextLimit=${pressure.contextLimit} percentage=${pressure.percentage.toFixed(1)}%`);
+            sessionLog2(info.sessionID, `event message.updated: totalInputTokens=${pressureInputTokens} contextLimit=${pressure.contextLimit} percentage=${pressure.percentage.toFixed(1)}%`);
             const entry = {
               usage: {
                 percentage: pressure.percentage,
@@ -9846,7 +9890,7 @@ function createEventHandler2(deps) {
             const historianFailureState = getHistorianFailureState(deps.db, info.sessionID);
             if (historianFailureState.failureCount > 0 && pressure.percentage < 90) {
               clearHistorianFailureState(deps.db, info.sessionID);
-              sessionLog(info.sessionID, `event message.updated: cleared historian failure state at ${pressure.percentage.toFixed(1)}%`);
+              sessionLog2(info.sessionID, `event message.updated: cleared historian failure state at ${pressure.percentage.toFixed(1)}%`);
             }
             return entry;
           };
@@ -9868,7 +9912,7 @@ function createEventHandler2(deps) {
               await refreshModelLimitsFromApi(deps.client);
               catalogLimit = readCatalogLimit();
               if (catalogLimit !== undefined && catalogLimit >= provenSafeInputTokens) {
-                sessionLog(info.sessionID, `models-dev-cache: regression recovered for ${info.providerID}/${info.modelID} via refresh (was=${oldLimit}, now=${catalogLimit})`);
+                sessionLog2(info.sessionID, `models-dev-cache: regression recovered for ${info.providerID}/${info.modelID} via refresh (was=${oldLimit}, now=${catalogLimit})`);
               }
             }
             const refreshedUpdates = {};
@@ -9890,11 +9934,14 @@ function createEventHandler2(deps) {
           };
         }
         updateSessionMeta(deps.db, info.sessionID, updates);
+        if (modelKey && updates.observedSafeInputTokens !== undefined) {
+          recordOpenCodeProvenInputFloor(deps.db, info.sessionID, modelKey, updates.observedSafeInputTokens);
+        }
         if (refreshLimitsAfterRecording) {
           await refreshLimitsAfterRecording();
         }
       } catch (error) {
-        sessionLog(info.sessionID, "event message.updated persistence failed:", error);
+        sessionLog2(info.sessionID, "event message.updated persistence failed:", error);
       }
       if ((info.finish === "stop" || info.finish === "tool-calls") && deps.client && deps.channel1StateBySession && !deps.compactionOff) {
         deliverChannel2IfPending(deps, info.sessionID);
@@ -9906,24 +9953,25 @@ function createEventHandler2(deps) {
       if (!info) {
         const sessionId = properties ? resolveSessionId(properties) : null;
         if (sessionId) {
-          sessionLog(sessionId, "event message.removed: no message removal info extracted from event");
+          sessionLog2(sessionId, "event message.removed: no message removal info extracted from event");
         } else {
-          log("[magic-context] event message.removed: no message removal info extracted from event");
+          log2("[magic-context] event message.removed: no message removal info extracted from event");
         }
         return;
       }
       dropSlot(info.sessionID, "message.removed");
+      forgetRawSessionOrdinalWatermark2(info.sessionID);
       deps.onRustWireInvalidated?.(info.sessionID);
-      sessionLog(info.sessionID, `event message.removed: invalidating state for message ${info.messageID}`);
+      sessionLog2(info.sessionID, `event message.removed: invalidating state for message ${info.messageID}`);
       try {
         cleanupRemovedMessageState(deps, info.sessionID, info.messageID);
         scheduleClearAndReindex(deps.db, info.sessionID, readRawSessionMessages2);
         deps.tagger.cleanup(info.sessionID);
-        sessionLog(info.sessionID, "event message.removed: invalidated tagger session cache");
+        sessionLog2(info.sessionID, "event message.removed: invalidated tagger session cache");
         const markerState = getPersistedCompactionMarkerState(deps.db, info.sessionID);
         if (markerState && (markerState.boundaryMessageId === info.messageID || markerState.summaryMessageId === info.messageID)) {
           removeCompactionMarkerForSession(deps.db, info.sessionID);
-          sessionLog(info.sessionID, `event message.removed: cleared compaction marker (boundary or summary message removed)`);
+          sessionLog2(info.sessionID, `event message.removed: cleared compaction marker (boundary or summary message removed)`);
         }
         clearMessageTokensCache(info.sessionID, info.messageID);
         invalidateTrueRawTokenCache({
@@ -9932,9 +9980,9 @@ function createEventHandler2(deps) {
           reason: "message.removed"
         });
         deps.onSessionCacheInvalidated?.(info.sessionID);
-        sessionLog(info.sessionID, "event message.removed: cleared session injection cache");
+        sessionLog2(info.sessionID, "event message.removed: cleared session injection cache");
       } catch (error) {
-        sessionLog(info.sessionID, "event message.removed cleanup failed:", error);
+        sessionLog2(info.sessionID, "event message.removed cleanup failed:", error);
       }
       return;
     }
@@ -9947,12 +9995,12 @@ function createEventHandler2(deps) {
       try {
         deps.compactionHandler.onCompacted(sessionId, deps.db);
       } catch (error) {
-        sessionLog(sessionId, "event session.compacted handling failed:", error);
+        sessionLog2(sessionId, "event session.compacted handling failed:", error);
       }
       try {
         removeCompactionMarkerForSession(deps.db, sessionId);
       } catch (error) {
-        sessionLog(sessionId, "event session.compacted marker cleanup failed:", error);
+        sessionLog2(sessionId, "event session.compacted marker cleanup failed:", error);
       }
       try {
         const pending = getPendingCompactionMarkerState(deps.db, sessionId);
@@ -9960,7 +10008,7 @@ function createEventHandler2(deps) {
           clearPendingCompactionMarkerStateIf(deps.db, sessionId, pending);
         }
       } catch (error) {
-        sessionLog(sessionId, "event session.compacted pending-marker cleanup failed:", error);
+        sessionLog2(sessionId, "event session.compacted pending-marker cleanup failed:", error);
       }
       resetDegradedCacheCount2(sessionId);
       clearMessageTokensCache(sessionId);
@@ -9983,7 +10031,7 @@ function createEventHandler2(deps) {
           clearSession(deps.db, sessionId, deps.rustSessionCleanup === true);
         }
       } catch (error) {
-        sessionLog(sessionId, "event session.deleted persistence failed:", error);
+        sessionLog2(sessionId, "event session.deleted persistence failed:", error);
       }
       resetDegradedCacheCount2(sessionId);
       deps.onSessionCacheInvalidated?.(sessionId);
@@ -10052,7 +10100,7 @@ function notifyMagicContextDisabled(client, reason) {
       duration: 8000
     }
   }).catch((error) => {
-    log("[magic-context] failed to show disabled toast:", error);
+    log2("[magic-context] failed to show disabled toast:", error);
   });
 }
 function createMagicContextHook(deps) {
@@ -10064,7 +10112,7 @@ function createMagicContextHook(deps) {
     if (!opened || !isDatabasePersisted(opened)) {
       const reason = describeStorageUnavailability((opened ? getDatabasePersistenceError(opened) : null) ?? "Failed to initialize the persistent SQLite database.");
       const detail = formatFailClosedBlockingMessage(reason);
-      log("[magic-context] disabling feature because persistent storage is unavailable:", detail);
+      log2("[magic-context] disabling feature because persistent storage is unavailable:", detail);
       notifyMagicContextDisabled(deps.client, detail);
       recordHookInitFailure({ type: "storage", reason });
       return null;
@@ -10072,7 +10120,7 @@ function createMagicContextHook(deps) {
     db = opened;
   } catch (error) {
     const reason = getErrorMessage(error);
-    log("[magic-context] hook failed to open storage; disabling feature:", error);
+    log2("[magic-context] hook failed to open storage; disabling feature:", error);
     notifyMagicContextDisabled(deps.client, reason);
     clearHookInitFailure();
     recordHookInitFailure({
@@ -10083,7 +10131,7 @@ function createMagicContextHook(deps) {
   }
   const projectPath = resolveProjectIdentityForSession(deps.directory, deps.config.allow_home_project);
   if (!projectPath) {
-    log("[magic-context] not binding a project identity for this directory");
+    log2("[magic-context] not binding a project identity for this directory");
     clearHookInitFailure();
     recordHookInitFailure({ type: "no_project" });
     return null;
@@ -10091,7 +10139,7 @@ function createMagicContextHook(deps) {
   try {
     checkCompactionMarkerConsistency(db);
   } catch (error) {
-    log("[magic-context] startup compaction-marker consistency check failed:", error);
+    log2("[magic-context] startup compaction-marker consistency check failed:", error);
   }
   let lastScheduleCheckMs = 0;
   let dreamQueueQuietScheduled = false;
@@ -10127,10 +10175,10 @@ function createMagicContextHook(deps) {
         deferredHistoryRefreshSessions.add(sid);
         deferredMaterializationSessions.add(sid);
       }
-      log(`[magic-context] rehydrated ${sessionsWithPending.length} session(s) with pending compaction-marker drain at hook init`);
+      log2(`[magic-context] rehydrated ${sessionsWithPending.length} session(s) with pending compaction-marker drain at hook init`);
     }
   } catch (error) {
-    log("[magic-context] hook init: pending-marker rehydration failed:", error);
+    log2("[magic-context] hook init: pending-marker rehydration failed:", error);
   }
   const lastHeuristicsTurnId = new Map;
   const commitSeenLastPass = new Map;
@@ -10162,7 +10210,7 @@ function createMagicContextHook(deps) {
       return;
     const notificationParams = getLiveNotificationParams(sessionId, liveModelBySession, variantBySession, agentBySession, (deps.sampleDreamConfig?.() ?? deps.config).toast_duration_ms);
     sendStatusNotification2(deps.client, sessionId, warning, notificationParams).catch((error) => {
-      log(`[magic-context] failed to send project identity warning for ${directory}: ${getErrorMessage(error)}`);
+      log2(`[magic-context] failed to send project identity warning for ${directory}: ${getErrorMessage(error)}`);
     });
   };
   const dreamerRunnable = isDreamerRunnable(deps.config);
@@ -10243,7 +10291,7 @@ function createMagicContextHook(deps) {
     if (!sessionProjectIdentity)
       return "No project identity is bound for the home directory.";
     maybeSendProjectIdentitySessionWarning(sessionId, directory);
-    const coverage = getEmbeddingCoverageStatus(db, sessionProjectIdentity, sessionId);
+    const coverage = getEmbeddingCoverageStatus2(db, sessionProjectIdentity, sessionId);
     const progress = recompProgressBySession.get(sessionId);
     const drainUi = getEmbedDrainUiStatus(sessionId, progress);
     return formatEmbedStatusText(coverage, {
@@ -10253,11 +10301,11 @@ function createMagicContextHook(deps) {
     });
   };
   const maybeAutoEmbedSession = (sessionId) => {
-    if (isEmbeddingHostBusy())
+    if (isEmbeddingHostBusy2())
       return;
     const directory = sessionDirectoryBySession.get(sessionId) ?? deps.directory;
     const identity = resolveProjectIdentityForSession(directory, deps.config.allow_home_project);
-    const snapshot = identity ? getProjectEmbeddingSnapshot(identity) : undefined;
+    const snapshot = identity ? getProjectEmbeddingSnapshot2(identity) : undefined;
     const embedIdentity = snapshot ? JSON.stringify([
       snapshot.providerIdentity,
       snapshot.chunkModelId,
@@ -10275,7 +10323,7 @@ function createMagicContextHook(deps) {
     (async () => {
       try {
         await new Promise((resolve) => setTimeout(resolve, 0));
-        if (isEmbeddingHostBusy()) {
+        if (isEmbeddingHostBusy2()) {
           invalidateAutoEmbedSession(sessionId);
           return;
         }
@@ -10286,7 +10334,7 @@ function createMagicContextHook(deps) {
           return;
         }
         maybeSendProjectIdentitySessionWarning(sessionId, directory);
-        const coverage = await getAutoEmbeddingSessionCoverage(db, sessionProjectIdentity, sessionId);
+        const coverage = await getAutoEmbeddingSessionCoverage2(db, sessionProjectIdentity, sessionId);
         if (!coverage.enabled) {
           invalidateAutoEmbedSession(sessionId);
           return;
@@ -10296,7 +10344,7 @@ function createMagicContextHook(deps) {
           return;
         await executeEmbedHistory(sessionId, { silent: true });
       } catch (error) {
-        log("[magic-context] auto-embed drain failed:", error);
+        log2("[magic-context] auto-embed drain failed:", error);
       }
     })();
   };
@@ -10325,7 +10373,7 @@ function createMagicContextHook(deps) {
         variant: "warning",
         duration: 8000
       }
-    }).catch((error) => log(`[magic-context] rust park toast failed for ${sessionId}:`, error));
+    }).catch((error) => log2(`[magic-context] rust park toast failed for ${sessionId}:`, error));
   };
   registerLkgPersistence(createDbLkgPersistence(db));
   const transform = createTransform({
@@ -10343,7 +10391,7 @@ function createMagicContextHook(deps) {
     protectedTokens: deps.config.protected_tokens,
     protectedTokenTierOverrides: deps.config.protectedTokenTierOverrides,
     protectedTools: deps.config.protected_tools,
-    clearReasoningAge: deps.config.clear_reasoning_age ?? 50,
+    keepReasoningTokens: deps.config.keep_reasoning_tokens,
     commitClusterTrigger: bootHistorian.commitClusterTrigger,
     historyRefreshSessions,
     deferredHistoryRefreshSessions,
@@ -10491,7 +10539,7 @@ function createMagicContextHook(deps) {
       return;
     }
     lastScheduleCheckMs = now;
-    const runtimeConfigs = buildDreamTaskRuntimeConfigs2(dreaming, "opencode", deps.config.language, sampledDream.mural?.model);
+    const runtimeConfigs = buildDreamTaskRuntimeConfigs2(dreaming, "opencode", deps.config.language, deps.config.smart_notes?.enabled);
     const executor = createDreamTaskExecutor({
       client: deps.client,
       sessionDirectory: deps.directory,
@@ -10503,6 +10551,7 @@ function createMagicContextHook(deps) {
       userMemoryCollectionEnabled: userMemoryCollectionEnabled2(dreaming),
       language: deps.config.language,
       retinaHandoff: deps.config.smart_notes?.retina_handoff === true,
+      smartNotesEnabled: deps.config.smart_notes?.enabled,
       transformMode: deps.config.transform_mode,
       moduleClient: rustModeModuleClient,
       onProgress: (progress, completedTask) => {
@@ -10520,10 +10569,11 @@ function createMagicContextHook(deps) {
       executor,
       projectMemoryEnabled: deps.config.memory?.enabled !== false
     }).catch((error) => {
-      log("[dreamer] scheduled task run failed:", error);
+      log2("[dreamer] scheduled task run failed:", error);
     });
   };
   const commandHandler = createMagicContextCommandHandler({
+    smartNotesEnabled: deps.config.smart_notes?.enabled,
     db,
     compactionOff,
     toastDurationMs: deps.config.toast_duration_ms,
@@ -10580,7 +10630,7 @@ function createMagicContextHook(deps) {
         return runManualDream({
           db,
           projectIdentity: projectPath,
-          tasks: buildDreamTaskRuntimeConfigs2(currentDreamer, "opencode", deps.config.language, sampledDream.mural?.model),
+          tasks: buildDreamTaskRuntimeConfigs2(currentDreamer, "opencode", deps.config.language, deps.config.smart_notes?.enabled),
           executor: createDreamTaskExecutor({
             client: deps.client,
             sessionDirectory: deps.directory,
@@ -10594,6 +10644,7 @@ function createMagicContextHook(deps) {
             mural: sampledDream.mural,
             memoryInjectionBudgetTokens: deps.config.memory?.injection_budget_tokens,
             retinaHandoff: deps.config.smart_notes?.retina_handoff === true,
+            smartNotesEnabled: deps.config.smart_notes?.enabled,
             transformMode: deps.config.transform_mode,
             moduleClient: rustModeModuleClient,
             onProgress: (progress, completedTask) => {
@@ -10612,6 +10663,7 @@ function createMagicContextHook(deps) {
   const systemPromptHash = createSystemPromptHashHandler({
     db,
     dreamerEnabled: dreamerRunnable,
+    smartNotesEnabled: deps.config.smart_notes?.enabled,
     memoryEnabled: deps.config.memory?.enabled !== false,
     language: deps.config.language,
     promptSurface: deps.config.prompt_surface,
@@ -10737,7 +10789,7 @@ async function createMagicContextHookAsync(deps) {
     database = await openDatabaseAsync({ onBootTimings: deps.onStorageBootTimings });
   } catch (error) {
     const reason = getErrorMessage(error);
-    log("[magic-context] hook failed to open storage; disabling feature:", error);
+    log2("[magic-context] hook failed to open storage; disabling feature:", error);
     notifyMagicContextDisabled(deps.client, reason);
     clearHookInitFailure();
     recordHookInitFailure({
@@ -10794,10 +10846,803 @@ async function createSessionHooksAsync(args) {
   };
 }
 
+// src/shared/host-stall-profiler.ts
+import * as path7 from "node:path";
+
+// src/shared/host-stall-profiler-bun.ts
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "node:fs";
+import * as path5 from "node:path";
+
+// src/shared/host-stall-profiler-common.ts
+import { chmodSync, existsSync as existsSync5, readdirSync, unlinkSync } from "node:fs";
+import * as path4 from "node:path";
+
+// src/shared/host-stall-profiler-report.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+import * as path3 from "node:path";
+var MAX_STACK_DEPTH = 64;
+var TOP_STACK_COUNT = 30;
+var TOP_FRAME_COUNT = 30;
+var UNKNOWN_POSITION = 4294967295;
+var BACKGROUND_OWNERS = new Set(["native", "runtime", "opencode", "pi", "omp"]);
+var packageNameCache = new Map;
+function urlToPath(url) {
+  if (url.startsWith("file://")) {
+    try {
+      return decodeURIComponent(new URL(url).pathname);
+    } catch {
+      return url.slice("file://".length);
+    }
+  }
+  return url;
+}
+function nearestPackageName(filePath) {
+  let dir = path3.dirname(filePath);
+  const visited = [];
+  for (let depth = 0;depth < 12; depth++) {
+    const cached = packageNameCache.get(dir);
+    if (cached !== undefined) {
+      for (const seen of visited)
+        packageNameCache.set(seen, cached);
+      return cached;
+    }
+    visited.push(dir);
+    try {
+      const parsed = JSON.parse(readFileSync4(path3.join(dir, "package.json"), "utf8"));
+      const name = typeof parsed.name === "string" && parsed.name ? parsed.name : null;
+      if (name) {
+        for (const seen of visited)
+          packageNameCache.set(seen, name);
+        return name;
+      }
+    } catch {}
+    const parent = path3.dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  for (const seen of visited)
+    packageNameCache.set(seen, null);
+  return null;
+}
+function sourceOwner(sourceURL) {
+  if (!sourceURL)
+    return "native";
+  if (/^(?:node|bun|builtin|internal):/.test(sourceURL))
+    return "runtime";
+  if (sourceURL.includes("$bunfs") || sourceURL.includes("~BUN"))
+    return "opencode";
+  const filePath = urlToPath(sourceURL).replaceAll("\\", "/");
+  const modules = [...filePath.matchAll(/\/node_modules\/((?:@[^/]+\/)?[^/]+)/g)];
+  const innermost = modules.at(-1);
+  if (innermost) {
+    const name = innermost[1];
+    if (name === "@cortexkit/pi-magic-context")
+      return `pkg:${name}`;
+    if (/^@(?:earendil-works|mariozechner)\/pi-(?:coding-agent|agent-core|ai|tui)$/.test(name))
+      return "pi";
+    if (/^@oh-my-pi\/pi-(?:coding-agent|agent-core|ai|tui)$/.test(name))
+      return "omp";
+    return `npm:${name}`;
+  }
+  const extension = filePath.match(/\/(?:\.pi|\.omp)\/agent\/extensions\/([^/]+)/);
+  if (extension) {
+    const name = nearestPackageName(filePath);
+    return name ? `pkg:${name}` : `extension:${extension[1]}`;
+  }
+  const pluginDir = filePath.match(/\/plugins?\/([^/]+)$/);
+  if (pluginDir && /\/(?:\.?opencode)\/plugins?\//.test(filePath)) {
+    return `plugin:${pluginDir[1]}`;
+  }
+  const name = nearestPackageName(filePath);
+  return name ? `pkg:${name}` : `file:${filePath}`;
+}
+function frameLabel(frame) {
+  const name = frame.name && frame.name.length > 0 ? frame.name : "(anonymous)";
+  if (!frame.sourceURL)
+    return `${name} [native]`;
+  const line = typeof frame.line === "number" && frame.line !== UNKNOWN_POSITION ? `:${frame.line}` : "";
+  return `${name} ${frame.sourceURL}${line}`;
+}
+function attributeSample(frames) {
+  for (const frame of frames) {
+    if (!BACKGROUND_OWNERS.has(frame.owner))
+      return frame.owner;
+  }
+  for (const frame of frames) {
+    if (frame.owner !== "native")
+      return frame.owner;
+  }
+  return "native";
+}
+function bump(map, key, init) {
+  const existing = map.get(key);
+  if (existing)
+    existing.samples += 1;
+  else
+    map.set(key, { ...init(), samples: 1 });
+}
+function topBySamples(values, limit) {
+  return [...values].sort((a, b) => b.samples - a.samples).slice(0, limit);
+}
+function aggregateTraces(traces) {
+  const ownerOf = new Map;
+  const owned = (frame) => {
+    const url = frame.sourceURL ?? "";
+    let owner = ownerOf.get(url);
+    if (owner === undefined) {
+      owner = sourceOwner(frame.sourceURL);
+      ownerOf.set(url, owner);
+    }
+    return { label: frameLabel(frame), owner };
+  };
+  const owners = new Map;
+  const topFrames = new Map;
+  const topJsFrames = new Map;
+  const stacks = new Map;
+  let samples = 0;
+  for (const trace of traces) {
+    const raw = Array.isArray(trace.frames) ? trace.frames : [];
+    if (raw.length === 0)
+      continue;
+    samples += 1;
+    const frames = raw.slice(0, MAX_STACK_DEPTH).map(owned);
+    const owner = attributeSample(frames);
+    bump(owners, owner, () => ({ owner }));
+    const leaf = frames[0];
+    bump(topFrames, `${leaf.owner}\x00${leaf.label}`, () => ({
+      frame: leaf.label,
+      owner: leaf.owner
+    }));
+    const jsIndex = raw.findIndex((frame, index) => index < MAX_STACK_DEPTH && !!frame.sourceURL);
+    if (jsIndex >= 0) {
+      const js = frames[jsIndex];
+      bump(topJsFrames, `${js.owner}\x00${js.label}`, () => ({
+        frame: js.label,
+        owner: js.owner
+      }));
+    }
+    const labels = frames.map((frame) => `${frame.label} (${frame.owner})`);
+    if (raw.length > MAX_STACK_DEPTH) {
+      labels.push(`… ${raw.length - MAX_STACK_DEPTH} outer frames omitted`);
+    }
+    bump(stacks, labels.join(`
+`), () => ({ owner, frames: labels }));
+  }
+  return {
+    samples,
+    owners: topBySamples(owners.values(), Number.POSITIVE_INFINITY).map((entry) => ({
+      ...entry,
+      percent: samples === 0 ? 0 : Math.round(entry.samples / samples * 1000) / 10
+    })),
+    top_frames: topBySamples(topFrames.values(), TOP_FRAME_COUNT),
+    top_js_frames: topBySamples(topJsFrames.values(), TOP_FRAME_COUNT),
+    top_stacks: topBySamples(stacks.values(), TOP_STACK_COUNT)
+  };
+}
+
+// src/shared/host-stall-profiler-common.ts
+var HOST_PROFILER_DIRNAME = "host-profiler";
+var HOST_PROFILER_ENABLE_FILENAME = "enable";
+var SWITCH_POLL_MS = 5000;
+var WATCHDOG_INTERVAL_MS = 250;
+var DEFAULT_STALL_THRESHOLD_MS = 3000;
+var DEFAULT_SAMPLE_INTERVAL_MS = 10;
+var MAX_REPORT_FILES = 50;
+var MAX_SAMPLES_PER_WINDOW = 20000;
+var PROFILE_WINDOW_MS = 1e4;
+function parseEnableFile(content) {
+  const options = {
+    thresholdMs: DEFAULT_STALL_THRESHOLD_MS,
+    sampleIntervalMs: DEFAULT_SAMPLE_INTERVAL_MS
+  };
+  if (!content.trim())
+    return { options, error: null };
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { options, error: "enable file is not a JSON object" };
+    }
+    if (typeof parsed.threshold_ms === "number" && Number.isFinite(parsed.threshold_ms)) {
+      options.thresholdMs = Math.min(600000, Math.max(500, parsed.threshold_ms));
+    }
+    if (typeof parsed.sample_interval_ms === "number" && Number.isFinite(parsed.sample_interval_ms)) {
+      options.sampleIntervalMs = Math.min(100, Math.max(1, parsed.sample_interval_ms));
+    }
+    return { options, error: null };
+  } catch (error) {
+    return {
+      options,
+      error: `enable file is not valid JSON (${error instanceof Error ? error.message : String(error)})`
+    };
+  }
+}
+function emitStallReport(deps, input) {
+  const { traces, windowed, options, startMs, endMs } = input;
+  const stride = windowed.length / MAX_SAMPLES_PER_WINDOW;
+  const kept = windowed.length <= MAX_SAMPLES_PER_WINDOW ? windowed : Array.from({ length: MAX_SAMPLES_PER_WINDOW }, (_, i) => windowed[Math.floor(i * stride)]);
+  const aggregate = aggregateTraces(kept);
+  const gapMs = endMs - startMs;
+  const endWallMs = deps.wallNow();
+  const report = {
+    kind: "magic-context-host-stall",
+    schema_version: 1,
+    pid: deps.pid,
+    bun_version: deps.bunVersion,
+    node_version: input.backend === "v8" ? process.versions.node : undefined,
+    backend: input.backend,
+    platform: process.platform,
+    window: {
+      start: new Date(endWallMs - gapMs).toISOString(),
+      end: new Date(endWallMs).toISOString(),
+      duration_ms: Math.round(gapMs),
+      lag_ms: Math.round(gapMs - WATCHDOG_INTERVAL_MS),
+      threshold_ms: options.thresholdMs
+    },
+    sampling: {
+      interval_ms: options.sampleIntervalMs,
+      samples_collected: traces.length,
+      samples_in_window: windowed.length,
+      samples_aggregated: kept.length,
+      window_filter: input.windowFilter,
+      note: aggregate.samples === 0 ? "No JavaScript samples in the window: the main thread was not executing inside the JavaScript VM (idle wait, process suspension, or native work outside any JS call)." : undefined
+    },
+    memory: { before: input.before, after: input.after },
+    owners: aggregate.owners,
+    top_frames: aggregate.top_frames,
+    top_js_frames: aggregate.top_js_frames,
+    top_stacks: aggregate.top_stacks
+  };
+  const dir = deps.profilerDir();
+  ensureStorageDirectorySync(dir, true);
+  chmodSync(dir, 448);
+  const stamp = new Date(endWallMs).toISOString().replaceAll(":", "-");
+  let name = `stall-${stamp}.json`;
+  for (let n = 1;existsSync5(path4.join(dir, name)); n++)
+    name = `stall-${stamp}-${n}.json`;
+  const file = path4.join(dir, name);
+  writeStorageFileAtomicSync(file, `${JSON.stringify(report, null, 2)}
+`, true);
+  const reports = readdirSync(dir).filter((entry) => /^stall-.*\.json$/.test(entry)).sort();
+  for (const stale of reports.slice(0, Math.max(0, reports.length - MAX_REPORT_FILES))) {
+    try {
+      unlinkSync(path4.join(dir, stale));
+    } catch {}
+  }
+  const top = aggregate.owners[0];
+  deps.log(`[magic-context] host stall profiler: ${Math.round(gapMs)}ms main-thread stall, ${aggregate.samples} samples, top owner ${top ? `${top.owner} (${top.percent}%)` : "none"} → ${file}`);
+}
+
+// src/shared/host-stall-profiler-bun.ts
+var MEMORY_SNAPSHOT_EVERY_TICKS = 4;
+var CALIBRATION_CHUNK_MS = 3;
+var CALIBRATION_MAX_CHUNKS = 30;
+function asJscApi(module) {
+  const candidate = module ?? null;
+  for (const value of [candidate, candidate?.default]) {
+    const api = value;
+    if (api && typeof api.startSamplingProfiler === "function" && typeof api.samplingProfilerStackTraces === "function" && typeof api.profile === "function") {
+      return api;
+    }
+  }
+  return null;
+}
+function createHostStallProfiler(deps) {
+  let jsc = null;
+  let unavailable = false;
+  let pollTimer = null;
+  let watchdog = null;
+  let options = {
+    thresholdMs: DEFAULT_STALL_THRESHOLD_MS,
+    sampleIntervalMs: DEFAULT_SAMPLE_INTERVAL_MS
+  };
+  let lastTickAt = 0;
+  let tickCount = 0;
+  let memoryBefore = null;
+  let clockOffsetMs = null;
+  let checking = null;
+  const loggedOnce = new Set;
+  const safeLog = (message) => {
+    try {
+      deps.log(message);
+    } catch {}
+  };
+  const logOnce = (key, message, error) => {
+    if (loggedOnce.has(key))
+      return;
+    loggedOnce.add(key);
+    const detail = error === undefined ? "" : `: ${error instanceof Error ? error.message : String(error)}`;
+    safeLog(`[magic-context] host stall profiler: ${message}${detail}`);
+  };
+  const drain = (api) => {
+    const raw = api.samplingProfilerStackTraces();
+    return Array.isArray(raw?.traces) ? raw.traces : [];
+  };
+  const pauseSampler = (api, intervalMs) => {
+    try {
+      drain(api);
+    } catch {}
+    api.profile(() => {
+      return;
+    }, Math.round(intervalMs * 1000));
+    drain(api);
+  };
+  const calibrate = (api) => {
+    pauseSampler(api, 1);
+    api.startSamplingProfiler();
+    let offset = null;
+    for (let chunk = 0;chunk < CALIBRATION_MAX_CHUNKS && offset === null; chunk++) {
+      const start = deps.now();
+      let end = start;
+      for (let i = 0;i < 50000000 && end - start < CALIBRATION_CHUNK_MS; i++) {
+        end = deps.now();
+      }
+      const stamps = drain(api).map((trace) => trace.timestamp).filter((value) => typeof value === "number" && Number.isFinite(value)).map((seconds) => seconds * 1000);
+      if (stamps.length >= 2) {
+        offset = (Math.max(...stamps) - end + (Math.min(...stamps) - start)) / 2;
+      }
+    }
+    pauseSampler(api, 1);
+    return offset;
+  };
+  const snapshot = (api) => {
+    const read = (fn) => {
+      try {
+        return fn();
+      } catch {
+        return null;
+      }
+    };
+    return {
+      at: new Date(deps.wallNow()).toISOString(),
+      heap_size_bytes: read(() => api.heapSize?.() ?? null),
+      jsc_memory: read(() => api.memoryUsage?.() ?? null),
+      rss_bytes: read(() => deps.rss()),
+      percent_available_memory_in_use: read(() => api.percentAvailableMemoryInUse?.() ?? null)
+    };
+  };
+  const recordStall = (api, startMs, endMs, traces) => {
+    const after = snapshot(api);
+    let windowed = traces;
+    let windowFilter = "since-last-collection";
+    if (clockOffsetMs !== null) {
+      const slackMs = 2 * options.sampleIntervalMs + 20;
+      const lo = startMs + clockOffsetMs - slackMs;
+      const hi = endMs + clockOffsetMs + slackMs;
+      const inWindow = traces.filter((trace) => {
+        const at = typeof trace.timestamp === "number" ? trace.timestamp * 1000 : Number.NaN;
+        return at >= lo && at <= hi;
+      });
+      if (inWindow.length > 0 || traces.length === 0) {
+        windowed = inWindow;
+        windowFilter = "timestamp";
+      } else {
+        windowFilter = "since-last-collection (timestamp filter matched no sample)";
+      }
+    }
+    emitStallReport(deps, {
+      startMs,
+      endMs,
+      traces,
+      windowed,
+      windowFilter,
+      options,
+      before: memoryBefore,
+      after,
+      backend: "jsc"
+    });
+    memoryBefore = after;
+  };
+  const tick = () => {
+    const api = jsc;
+    if (!api || watchdog === null)
+      return;
+    try {
+      const now = deps.now();
+      const startMs = lastTickAt;
+      lastTickAt = now;
+      const traces = drain(api);
+      if (now - startMs - WATCHDOG_INTERVAL_MS >= options.thresholdMs) {
+        try {
+          recordStall(api, startMs, now, traces);
+        } catch (error) {
+          logOnce("report", "could not write a stall report", error);
+        }
+      }
+      tickCount += 1;
+      if (tickCount % MEMORY_SNAPSHOT_EVERY_TICKS === 0)
+        memoryBefore = snapshot(api);
+    } catch (error) {
+      logOnce("tick", "watchdog tick failed", error);
+    }
+  };
+  const enable = (api, next) => {
+    const startedAt = deps.now();
+    try {
+      options = next;
+      clockOffsetMs = calibrate(api);
+      pauseSampler(api, options.sampleIntervalMs);
+      api.startSamplingProfiler();
+      lastTickAt = deps.now();
+      tickCount = 0;
+      memoryBefore = snapshot(api);
+      watchdog = deps.setInterval(tick, WATCHDOG_INTERVAL_MS);
+      safeLog(`[magic-context] host stall profiler enabled: threshold ${options.thresholdMs}ms, sample interval ${options.sampleIntervalMs}ms, clock calibration ${clockOffsetMs === null ? "unavailable" : "ok"}, setup ${Math.round(deps.now() - startedAt)}ms, reports in ${deps.profilerDir()}`);
+    } catch (error) {
+      watchdog = null;
+      try {
+        pauseSampler(api, options.sampleIntervalMs);
+      } catch {}
+      logOnce("enable", "could not start", error);
+    }
+  };
+  const disable = (reason) => {
+    if (watchdog !== null)
+      deps.clearInterval(watchdog);
+    watchdog = null;
+    memoryBefore = null;
+    if (jsc) {
+      try {
+        pauseSampler(jsc, options.sampleIntervalMs);
+      } catch (error) {
+        logOnce("disable", "could not pause the sampler", error);
+      }
+    }
+    safeLog(`[magic-context] host stall profiler disabled: ${reason}`);
+  };
+  const ensureJsc = async () => {
+    if (jsc)
+      return jsc;
+    try {
+      const api = asJscApi(await deps.loadJsc());
+      if (!api)
+        throw new Error("bun:jsc lacks the sampling profiler API");
+      jsc = api;
+      return api;
+    } catch (error) {
+      unavailable = true;
+      if (pollTimer !== null)
+        deps.clearInterval(pollTimer);
+      pollTimer = null;
+      logOnce("jsc", "bun:jsc is unavailable, profiler disabled for this process", error);
+      return null;
+    }
+  };
+  const runCheck = async () => {
+    if (unavailable)
+      return;
+    try {
+      const enablePath = path5.join(deps.profilerDir(), HOST_PROFILER_ENABLE_FILENAME);
+      if (!existsSync6(enablePath)) {
+        if (watchdog !== null)
+          disable("enable file removed");
+        return;
+      }
+      const parsed = parseEnableFile(readFileSync5(enablePath, "utf8"));
+      if (parsed.error)
+        logOnce(`options:${parsed.error}`, parsed.error);
+      if (watchdog !== null) {
+        if (jsc && parsed.options.sampleIntervalMs !== options.sampleIntervalMs) {
+          pauseSampler(jsc, parsed.options.sampleIntervalMs);
+          jsc.startSamplingProfiler();
+        }
+        options = parsed.options;
+        return;
+      }
+      const api = await ensureJsc();
+      if (!api || watchdog !== null || !existsSync6(enablePath))
+        return;
+      enable(api, parsed.options);
+    } catch (error) {
+      logOnce("check", "enable-file check failed", error);
+    }
+  };
+  const checkNow = () => {
+    if (!checking) {
+      checking = runCheck().finally(() => {
+        checking = null;
+      });
+    }
+    return checking;
+  };
+  return {
+    start() {
+      if (pollTimer !== null || unavailable)
+        return;
+      pollTimer = deps.setInterval(() => void checkNow(), SWITCH_POLL_MS);
+      checkNow();
+    },
+    checkNow,
+    stop() {
+      if (pollTimer !== null)
+        deps.clearInterval(pollTimer);
+      pollTimer = null;
+      if (watchdog !== null)
+        disable("stopped");
+    },
+    isActive: () => watchdog !== null,
+    isUnavailable: () => unavailable
+  };
+}
+
+// src/shared/host-stall-profiler-node.ts
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
+import * as path6 from "node:path";
+function v8ProfileTraces(profile, windowStartMs) {
+  const nodes = new Map(profile.nodes.map((node) => [node.id, node]));
+  const parents = new Map;
+  for (const node of profile.nodes)
+    for (const child of node.children ?? [])
+      parents.set(child, node.id);
+  const stacks = new Map;
+  const stackFor = (id) => {
+    const cached = stacks.get(id);
+    if (cached)
+      return cached;
+    const frames = [];
+    const seen = new Set;
+    let next = id;
+    while (next !== undefined && !seen.has(next)) {
+      seen.add(next);
+      const node = nodes.get(next);
+      if (!node)
+        break;
+      const frame = node.callFrame;
+      if (frame.functionName !== "(root)" && frame.functionName !== "(idle)") {
+        frames.push({
+          name: frame.functionName,
+          sourceURL: frame.url || undefined,
+          line: frame.lineNumber >= 0 ? frame.lineNumber + 1 : undefined,
+          column: frame.columnNumber >= 0 ? frame.columnNumber + 1 : undefined
+        });
+      }
+      next = parents.get(next);
+    }
+    stacks.set(id, frames);
+    return frames;
+  };
+  let elapsedMicros = 0;
+  return (profile.samples ?? []).flatMap((id, index) => {
+    const delta = profile.timeDeltas?.[index];
+    if (typeof delta !== "number" || !Number.isFinite(delta))
+      return [];
+    elapsedMicros += delta;
+    return [{ timestamp: (windowStartMs + elapsedMicros / 1000) / 1000, frames: stackFor(id) }];
+  });
+}
+function createNodeHostStallProfiler(deps) {
+  let session = null;
+  let pollTimer = null;
+  let watchdog = null;
+  let stopped = false;
+  let unavailable = false;
+  let options = {
+    thresholdMs: DEFAULT_STALL_THRESHOLD_MS,
+    sampleIntervalMs: DEFAULT_SAMPLE_INTERVAL_MS
+  };
+  let lastTickAt = 0;
+  let windowStartMs = 0;
+  let memoryBefore = null;
+  let work = Promise.resolve();
+  const logged = new Set;
+  const safeLog = (message) => {
+    try {
+      deps.log(message);
+    } catch {}
+  };
+  const fail = (key, error) => {
+    if (logged.has(key))
+      return;
+    logged.add(key);
+    safeLog(`[magic-context] host stall profiler: ${key}: ${error instanceof Error ? error.message : String(error)}`);
+  };
+  const post = (api, method, params = {}) => new Promise((resolve, reject) => {
+    api.post(method, params, (error, result) => error ? reject(error) : resolve(result ?? {}));
+  });
+  const snapshot = () => {
+    const memory = deps.memoryUsage();
+    return {
+      at: new Date(deps.wallNow()).toISOString(),
+      heap_size_bytes: memory.heapUsed,
+      rss_bytes: memory.rss,
+      jsc_memory: null,
+      percent_available_memory_in_use: null
+    };
+  };
+  const disable = async (reason) => {
+    if (watchdog !== null)
+      deps.clearInterval(watchdog);
+    watchdog = null;
+    const api = session;
+    session = null;
+    memoryBefore = null;
+    if (!api)
+      return;
+    try {
+      await post(api, "Profiler.stop");
+    } catch (error) {
+      fail("stop failed", error);
+    } finally {
+      try {
+        api.disconnect();
+      } catch (error) {
+        fail("disconnect failed", error);
+      }
+    }
+    safeLog(`[magic-context] host stall profiler disabled: ${reason}`);
+  };
+  const startWindow = async (api) => {
+    windowStartMs = deps.now();
+    await post(api, "Profiler.start");
+  };
+  const tick = async () => {
+    const api = session;
+    if (!api || watchdog === null)
+      return;
+    const now = deps.now();
+    const startMs = lastTickAt;
+    lastTickAt = now;
+    const stall = now - startMs - WATCHDOG_INTERVAL_MS >= options.thresholdMs;
+    if (!stall && now - windowStartMs < PROFILE_WINDOW_MS)
+      return;
+    try {
+      const { profile } = await post(api, "Profiler.stop");
+      const profileStartMs = windowStartMs;
+      if (session !== api || stopped)
+        return;
+      await startWindow(api);
+      const after = snapshot();
+      if (stall && profile) {
+        const traces = v8ProfileTraces(profile, profileStartMs);
+        const slackMs = 2 * options.sampleIntervalMs + 20;
+        const windowed = traces.filter((trace) => {
+          const at = (trace.timestamp ?? 0) * 1000;
+          return at >= startMs - slackMs && at <= now + slackMs;
+        });
+        try {
+          emitStallReport(deps, {
+            startMs,
+            endMs: now,
+            traces,
+            windowed,
+            windowFilter: "timestamp",
+            options,
+            before: memoryBefore,
+            after,
+            backend: "v8"
+          });
+        } catch (error) {
+          fail("could not write a stall report", error);
+        }
+      }
+      memoryBefore = after;
+    } catch (error) {
+      fail("watchdog tick failed", error);
+      await disable("sampling failed");
+    }
+  };
+  const enqueue = (fn) => {
+    work = work.then(fn).catch((error) => fail("profiler operation failed", error));
+    return work;
+  };
+  const runCheck = async () => {
+    if (stopped || unavailable)
+      return;
+    const enablePath = path6.join(deps.profilerDir(), HOST_PROFILER_ENABLE_FILENAME);
+    if (!existsSync7(enablePath)) {
+      await disable("enable file removed");
+      return;
+    }
+    const parsed = parseEnableFile(readFileSync6(enablePath, "utf8"));
+    if (parsed.error)
+      fail("enable options", parsed.error);
+    if (session && parsed.options.sampleIntervalMs === options.sampleIntervalMs) {
+      options = parsed.options;
+      return;
+    }
+    if (session)
+      await disable("sample interval changed");
+    options = parsed.options;
+    try {
+      const api = await deps.createSession();
+      if (stopped || !existsSync7(enablePath))
+        return;
+      session = api;
+      api.connect();
+      await post(api, "Profiler.enable");
+      await post(api, "Profiler.setSamplingInterval", {
+        interval: Math.round(options.sampleIntervalMs * 1000)
+      });
+      await startWindow(api);
+      if (stopped || !existsSync7(enablePath)) {
+        await disable("enable file removed");
+        return;
+      }
+      lastTickAt = deps.now();
+      memoryBefore = snapshot();
+      watchdog = deps.setInterval(() => {
+        enqueue(tick);
+      }, WATCHDOG_INTERVAL_MS);
+      safeLog(`[magic-context] host stall profiler enabled: threshold ${options.thresholdMs}ms, sample interval ${options.sampleIntervalMs}ms, backend v8, rotation ${PROFILE_WINDOW_MS}ms, reports in ${deps.profilerDir()}`);
+    } catch (error) {
+      fail("could not start inspector profiler", error);
+      await disable("inspector unavailable");
+      unavailable = true;
+      if (pollTimer !== null)
+        deps.clearInterval(pollTimer);
+      pollTimer = null;
+    }
+  };
+  return {
+    start() {
+      if (pollTimer !== null || unavailable)
+        return;
+      stopped = false;
+      pollTimer = deps.setInterval(() => {
+        enqueue(runCheck);
+      }, SWITCH_POLL_MS);
+      enqueue(runCheck);
+    },
+    checkNow: () => enqueue(runCheck),
+    stop() {
+      stopped = true;
+      if (pollTimer !== null)
+        deps.clearInterval(pollTimer);
+      pollTimer = null;
+      if (watchdog !== null)
+        deps.clearInterval(watchdog);
+      watchdog = null;
+      enqueue(() => disable("stopped"));
+    },
+    isActive: () => watchdog !== null,
+    isUnavailable: () => unavailable
+  };
+}
+
+// src/shared/host-stall-profiler.ts
+function hostStallProfilerDir() {
+  return path7.join(getMagicContextStorageDir(), HOST_PROFILER_DIRNAME);
+}
+var PROCESS_PROFILER_KEY = Symbol.for("cortexkit.magic-context.host-stall-profiler");
+var jscModule = "bun:jsc";
+function startHostStallProfilerSwitch() {
+  try {
+    const holder = globalThis;
+    if (holder[PROCESS_PROFILER_KEY])
+      return;
+    const deps = {
+      profilerDir: hostStallProfilerDir,
+      now: () => performance.now(),
+      wallNow: () => Date.now(),
+      setInterval: (callback, ms) => {
+        const handle = setInterval(callback, ms);
+        handle.unref?.();
+        return handle;
+      },
+      clearInterval: (handle) => clearInterval(handle),
+      rss: () => process.memoryUsage.rss(),
+      log: log2,
+      pid: process.pid,
+      bunVersion: process.versions.bun ?? null
+    };
+    const handle = process.versions.bun ? createHostStallProfiler({ ...deps, loadJsc: () => import(jscModule) }) : createNodeHostStallProfiler({
+      ...deps,
+      createSession: async () => {
+        const { Session } = await import("node:inspector");
+        return new Session;
+      },
+      memoryUsage: () => process.memoryUsage()
+    });
+    holder[PROCESS_PROFILER_KEY] = handle;
+    handle.start();
+  } catch (error) {
+    log2("[magic-context] host stall profiler: could not start the enable-file switch", error);
+  }
+}
 // src/plugin/instance-disposal.ts
-import path3 from "node:path";
+import path8 from "node:path";
 function isDisposedInstanceDirectory(ownDirectory, disposedDirectory) {
-  return path3.resolve(disposedDirectory) === path3.resolve(ownDirectory);
+  return path8.resolve(disposedDirectory) === path8.resolve(ownDirectory);
 }
 
 // src/plugin/native-compaction-guard.ts
@@ -10806,7 +11651,7 @@ function disableNativeAutoCompaction(config) {
   if (target.compaction?.auto === false)
     return false;
   target.compaction = { ...target.compaction ?? {}, auto: false };
-  log("[magic-context] OpenCode auto-compaction was not disabled in any config layer; turned it off for this instance because Magic Context manages compaction");
+  log2("[magic-context] OpenCode auto-compaction was not disabled in any config layer; turned it off for this instance because Magic Context manages compaction");
   return true;
 }
 
@@ -10877,7 +11722,7 @@ function createToolRegistry(args) {
     return {};
   }
   ensureProjectRegisteredFromOpenCodeDirectory(ctx.directory, db).catch((error) => {
-    log(`[magic-context] embedding registration skipped: ${getErrorMessage(error)}`);
+    log2(`[magic-context] embedding registration skipped: ${getErrorMessage(error)}`);
   });
   const resolveProjectPath = (directory) => resolveProjectIdentityForSession(directory, pluginConfig.allow_home_project);
   const memoryEnabled = pluginConfig.memory?.enabled !== false;
@@ -10892,6 +11737,7 @@ function createToolRegistry(args) {
     ...createCtxNoteTools({
       db,
       dreamerEnabled: isDreamerRunnable(pluginConfig),
+      smartNotesEnabled: pluginConfig.smart_notes?.enabled,
       resolveProjectPath,
       rustToolBackends
     }),
@@ -10917,11 +11763,11 @@ function createToolRegistry(args) {
   const promptSurfaceRuntime = args.promptSurfaceRuntime ?? createPromptSurfaceRuntime({
     harness: "opencode",
     directory: ctx.directory,
-    warn: (message) => log(`[magic-context] config warning: ${message}`)
+    warn: (message) => log2(`[magic-context] config warning: ${message}`)
   });
   const registration = promptSurfaceRuntime.resolveRegistration(args.registrationPromptSurface ?? pluginConfig.prompt_surface);
   const surfacedTools = Object.fromEntries(Object.entries(allTools).map(([toolId, definition]) => {
-    const parameterDescriptions = parameterDescriptionsFor(toolId, registration.preset);
+    const parameterDescriptions = parameterDescriptionsFor(toolId, registration.preset, pluginConfig.smart_notes?.enabled);
     const argsWithPresetDescriptions = parameterDescriptions ? Object.fromEntries(Object.entries(definition.args).map(([name, schema]) => [
       name,
       parameterDescriptions[name] ? schema.describe(parameterDescriptions[name]) : schema
@@ -10931,7 +11777,7 @@ function createToolRegistry(args) {
       {
         ...definition,
         args: argsWithPresetDescriptions,
-        description: registration.descriptionFor(toolId, definition.description ?? "")
+        description: toolId === "ctx_note" && pluginConfig.smart_notes?.enabled === false ? withoutSmartNoteText(registration.preset === "light" ? CTX_NOTE_LIGHT_DESCRIPTION : definition.description ?? "") : registration.descriptionFor(toolId, definition.description ?? "")
       }
     ];
   }));
@@ -10959,48 +11805,27 @@ function buildOpenCodeConfigWarningBanner(warnings, parseFailures, allParseFailu
 `);
 }
 
-// src/shared/exit-abort-registry.ts
-var controllers = new Set;
-var listenerRegistered = false;
-function abortAll() {
-  for (const controller of controllers) {
-    try {
-      controller.abort();
-    } catch {}
-  }
-}
-function registerExitAbort(controller) {
-  controllers.add(controller);
-  if (listenerRegistered)
-    return;
-  listenerRegistered = true;
-  process.once("exit", abortAll);
-}
-function unregisterExitAbort(controller) {
-  controllers.delete(controller);
-}
-
 // src/v2/hooks/update-check.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
-import { dirname as dirname3, join as join5 } from "node:path";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "node:fs";
+import { dirname as dirname4, join as join10 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var cachedPackageInfo;
 function packageInfo() {
   if (cachedPackageInfo)
     return cachedPackageInfo;
-  let directory = dirname3(fileURLToPath2(import.meta.url));
+  let directory = dirname4(fileURLToPath2(import.meta.url));
   for (;; ) {
     try {
-      const pkg = JSON.parse(readFileSync4(join5(directory, "package.json"), "utf8"));
+      const pkg = JSON.parse(readFileSync7(join10(directory, "package.json"), "utf8"));
       if (pkg.name === "@cortexkit/opencode-magic-context" && typeof pkg.version === "string") {
         cachedPackageInfo = {
           version: pkg.version,
-          development: existsSync5(join5(directory, "src/v2/server.ts"))
+          development: existsSync8(join10(directory, "src/v2/server.ts"))
         };
         return cachedPackageInfo;
       }
     } catch {}
-    const parent = dirname3(directory);
+    const parent = dirname4(directory);
     if (parent === directory)
       throw new Error("Magic Context package manifest is unavailable");
     directory = parent;
@@ -11041,7 +11866,7 @@ function startUpdateChecks(context, check = (signal) => {
       }
     } catch (error) {
       if (!controller.signal.aborted)
-        log("[magic-context] v2 update check unavailable", error);
+        log2("[magic-context] v2 update check unavailable", error);
     }
   })();
   return {
@@ -11062,16 +11887,16 @@ function isOpenCode2HostContext(context) {
 }
 async function setup(context) {
   if (!isOpenCode2HostContext(context)) {
-    log("v2 setup() called on a host without session.hook; v1 server lane owns this host, v2 lane inert");
+    log2("v2 setup() called on a host without session.hook; v1 server lane owns this host, v2 lane inert");
     return async () => {};
   }
-  const { registerContext } = await import("./context-sh2m2vde.js");
-  setHarness("opencode2");
+  const { registerContext } = await import("./context-m0cy262m.js");
+  setHarness2("opencode2");
   bindStaleBuildNotice({}, import.meta.url, "opencode2");
   const duties = await registerContext(context);
   const checks = loadPluginConfigDetailed(context.location.directory).config.auto_update === false ? undefined : startUpdateChecks(context);
-  log("[magic-context] @cortexkit/opencode-magic-context v2 setup");
-  flushLogger();
+  log2("[magic-context] @cortexkit/opencode-magic-context v2 setup");
+  flushLogger2();
   return async () => {
     await checks?.dispose();
     await duties?.dispose();
@@ -11091,13 +11916,14 @@ var server = async (ctx) => {
   let rpcMs = 0;
   let hooksDeadlineReason = null;
   let deadlinePhase = null;
-  emitBootEnteringBreadcrumb(process.pid, ctx.directory, log, flushLogger);
-  setHarness("opencode");
+  emitBootEnteringBreadcrumb(process.pid, ctx.directory, log2, flushLogger2);
+  setHarness2("opencode");
+  startHostStallProfilerSwitch();
   const configStartedAt = performance.now();
   beginBootQuietPeriod();
   const configMigrationWarnings = migrateMagicContextConfigLocations(ctx.directory, {
-    warn: (m) => log(`[magic-context] ${m}`),
-    info: (m) => log(`[magic-context] ${m}`)
+    warn: (m) => log2(`[magic-context] ${m}`),
+    info: (m) => log2(`[magic-context] ${m}`)
   });
   const loadedPluginConfig = loadPluginConfigDetailed(ctx.directory);
   const pluginConfig = loadedPluginConfig.config;
@@ -11108,7 +11934,7 @@ var server = async (ctx) => {
   const promptSurfaceRuntime = createPromptSurfaceRuntime({
     harness: "opencode",
     directory: ctx.directory,
-    warn: (message) => log(`[magic-context] config warning: ${message}`)
+    warn: (message) => log2(`[magic-context] config warning: ${message}`)
   });
   if (configMigrationWarnings.length > 0) {
     pluginConfig.configWarnings = [
@@ -11126,7 +11952,7 @@ var server = async (ctx) => {
   registerExitAbort(autoUpdateAbort);
   if (pluginConfig.configWarnings?.length) {
     for (const w of pluginConfig.configWarnings) {
-      log(`[magic-context] config warning: ${w}`);
+      log2(`[magic-context] config warning: ${w}`);
     }
     const allParseFailures = loadedPluginConfig.configParseFailures;
     const parseFailuresToShow = claimConfigParseFailuresOnce("opencode", allParseFailures);
@@ -11135,7 +11961,7 @@ var server = async (ctx) => {
     if (hasBannerEntries)
       setTimeout(async () => {
         try {
-          const { sendStatusNotification } = await importPluginModule(() => import("./send-session-notification-dyw42dtr.js"));
+          const { sendStatusNotification } = await importPluginModule(() => import("./send-session-notification-erecz4y4.js"));
           const clientWithSessions = ctx.client;
           const sessions = await Promise.resolve(clientWithSessions.session?.list?.()).catch(() => null);
           const sessionList = Array.isArray(sessions) ? sessions : sessions?.data;
@@ -11149,10 +11975,10 @@ var server = async (ctx) => {
   const openCodeDbResolution = resolveOpenCodeDbPath();
   if (!openCodeDbPathExists(openCodeDbResolution) && claimOpenCodeDbDiagnosticOnce("boot-banner", openCodeDbResolution)) {
     const missingDbBanner = formatOpenCodeDbMissingBanner(openCodeDbResolution);
-    log(`[magic-context] opencode_db_missing path=${openCodeDbResolution.path} source=${openCodeDbResolution.source}`);
+    log2(`[magic-context] opencode_db_missing path=${openCodeDbResolution.path} source=${openCodeDbResolution.source}`);
     setTimeout(async () => {
       try {
-        const { sendStatusNotification } = await importPluginModule(() => import("./send-session-notification-dyw42dtr.js"));
+        const { sendStatusNotification } = await importPluginModule(() => import("./send-session-notification-erecz4y4.js"));
         const clientWithSessions = ctx.client;
         const sessions = await Promise.resolve(clientWithSessions.session?.list?.()).catch(() => null);
         const sessionList = Array.isArray(sessions) ? sessions : sessions?.data;
@@ -11169,7 +11995,7 @@ var server = async (ctx) => {
     const resolvedConfigTimeoutMs = Math.min(RESOLVED_CONFIG_TIMEOUT_MS, remainingBootBudgetMs(bootBudget));
     const resolvedCompaction = resolvedConfigTimeoutMs > 0 ? await resolveCompactionForBoot(ctx.client, resolvedConfigTimeoutMs) : null;
     if (resolvedCompaction === null) {
-      log("[magic-context] resolved-config fetch failed; using file-based compaction detection (the running server's resolved config may differ — `opencode debug config` is authoritative)");
+      log2("[magic-context] resolved-config fetch failed; using file-based compaction detection (the running server's resolved config may differ — `opencode debug config` is authoritative)");
     }
     conflictResult = detectConflicts(ctx.directory, {
       compactionEnabled: isCompactionEnabled(pluginConfig),
@@ -11177,9 +12003,9 @@ var server = async (ctx) => {
     });
     if (conflictResult.hasConflict) {
       pluginConfig.enabled = false;
-      log(`[magic-context] disabled due to conflicts: ${conflictResult.reasons.join("; ")}`);
+      log2(`[magic-context] disabled due to conflicts: ${conflictResult.reasons.join("; ")}`);
     } else {
-      log("[magic-context] no conflicts detected, plugin enabled");
+      log2("[magic-context] no conflicts detected, plugin enabled");
     }
   }
   conflictMs = performance.now() - conflictStartedAt;
@@ -11195,7 +12021,7 @@ var server = async (ctx) => {
     rustModeModuleClient,
     promptSurfaceRuntime,
     onStorageBootTimings: (timings) => Object.assign(storageBootTimings, timings)
-  }), log);
+  }), log2);
   const hooks = hooksPhase.status === "completed" ? hooksPhase.value : { magicContext: null, rustToolBackends: undefined };
   if (hooksPhase.status === "timed_out") {
     deadlinePhase = "hooks";
@@ -11213,7 +12039,7 @@ var server = async (ctx) => {
     const storageFailureReason = hooksDeadlineReason ? { kind: "storage_failure", cause: hooksDeadlineReason } : initFailure?.type === "storage" ? initFailure.reason : null;
     if (storageFailureReason) {
       failClosed.arm(storageFailureReason);
-      log(`[magic-context] fail-closed blocking armed (${storageFailureReason.kind}); primary sessions will error until storage recovers or the build is upgraded`);
+      log2(`[magic-context] fail-closed blocking armed (${storageFailureReason.kind}); primary sessions will error until storage recovers or the build is upgraded`);
     }
   }
   if (hooksPhase.status === "timed_out") {
@@ -11223,7 +12049,7 @@ var server = async (ctx) => {
       magicContextRuntime.magicContext = late.magicContext;
       magicContextRuntime.rustToolBackends = late.rustToolBackends;
       failClosed.clear();
-      log("[magic-context] boot hooks phase settled after its deadline; Magic Context runtime installed and fail-closed cleared");
+      log2("[magic-context] boot hooks phase settled after its deadline; Magic Context runtime installed and fail-closed cleared");
     });
   }
   const tryReopenStorage = async () => {
@@ -11245,10 +12071,10 @@ var server = async (ctx) => {
       magicContextRuntime.magicContext = reopened.magicContext;
       magicContextRuntime.rustToolBackends = reopened.rustToolBackends;
       failClosed.clear();
-      log("[magic-context] storage re-probe succeeded; Magic Context runtime restored");
+      log2("[magic-context] storage re-probe succeeded; Magic Context runtime restored");
       return true;
     } catch (error) {
-      log(`[magic-context] storage re-probe failed: ${error}`);
+      log2(`[magic-context] storage re-probe failed: ${error}`);
       return false;
     }
   };
@@ -11267,12 +12093,12 @@ var server = async (ctx) => {
       if (db && isDatabasePersisted(db)) {
         scheduleAfterBootQuiet(() => {
           runDeferredV22Backfill(db).catch((err) => {
-            log(`[v22-backfill] background runner failed: ${err}`);
+            log2(`[v22-backfill] background runner failed: ${err}`);
           });
         });
       }
     } catch (err) {
-      log(`[v22-backfill] failed to start background runner: ${err}`);
+      log2(`[v22-backfill] failed to start background runner: ${err}`);
     }
   }
   if (pluginConfig.enabled && magicContextRuntime.magicContext) {
@@ -11310,7 +12136,7 @@ var server = async (ctx) => {
           closeQuietly(ocDb);
         }
       })().catch((err) => {
-        log(`[session-projects] background runner failed: ${err}`);
+        log2(`[session-projects] background runner failed: ${err}`);
       });
     }, 0);
   }
@@ -11322,7 +12148,7 @@ var server = async (ctx) => {
     const classifyModuleClient = createDreamTimerModuleClient(rustModeModuleClient);
     const timerProjectIdentity = resolveProjectIdentityForSession(ctx.directory, pluginConfig.allow_home_project);
     if (!timerProjectIdentity) {
-      log("[magic-context] dream timer skipped: no project identity is bound for this directory");
+      log2("[magic-context] dream timer skipped: no project identity is bound for this directory");
     } else {
       const timerRegistration = {
         directory: ctx.directory,
@@ -11360,6 +12186,7 @@ var server = async (ctx) => {
         },
         mural: pluginConfig.mural,
         retinaHandoff: pluginConfig.smart_notes.retina_handoff,
+        smartNotesEnabled: pluginConfig.smart_notes.enabled,
         gitCommitIndexing: pluginConfig.memory.git_commit_indexing?.enabled ? {
           enabled: true,
           since_days: pluginConfig.memory.git_commit_indexing.since_days,
@@ -11380,7 +12207,7 @@ var server = async (ctx) => {
         startDreamScheduleTimer(timerRegistration).then((stop) => {
           stopDreamTimerRegistration = stop;
         }).catch((err) => {
-          log(`[magic-context] dream timer registration failed (continuing without it): ${err}`);
+          log2(`[magic-context] dream timer registration failed (continuing without it): ${err}`);
         });
       }, 0);
     }
@@ -11398,9 +12225,9 @@ var server = async (ctx) => {
     setTimeout(() => {
       const rpcStartedAt = performance.now();
       rpcServer?.start().then(() => {
-        log(`[magic-context] boot deferred phase: rpc=${Math.round(performance.now() - rpcStartedAt)}ms`);
+        log2(`[magic-context] boot deferred phase: rpc=${Math.round(performance.now() - rpcStartedAt)}ms`);
       }).catch((err) => {
-        log(`[magic-context] RPC server failed to start: ${err}`);
+        log2(`[magic-context] RPC server failed to start: ${err}`);
       });
     }, 0);
     rpcMs = performance.now() - rpcScheduledAt;
@@ -11420,21 +12247,21 @@ var server = async (ctx) => {
     });
     setTimeout(() => {
       rpcServer?.start().catch((err) => {
-        log(`[magic-context] debug-only RPC server failed to start: ${err}`);
+        log2(`[magic-context] debug-only RPC server failed to start: ${err}`);
       });
     }, 0);
   }
   {
     const fence = getSchemaFenceRejection();
     if (fence) {
-      importPluginModule(() => import("./conflict-warning-hook-7fj2b9jw.js")).then(({ sendSchemaFenceWarning }) => sendSchemaFenceWarning(ctx.client, ctx.directory, fence)).catch((error) => log("[magic-context] schema-fence warning unavailable:", error));
+      importPluginModule(() => import("./conflict-warning-hook-w8cykrnf.js")).then(({ sendSchemaFenceWarning }) => sendSchemaFenceWarning(ctx.client, ctx.directory, fence)).catch((error) => log2("[magic-context] schema-fence warning unavailable:", error));
     }
   }
   const serverUrl = ctx.serverUrl;
   const serverUrlStr = serverUrl instanceof URL ? serverUrl.toString().replace(/\/$/, "") : typeof serverUrl === "string" ? serverUrl.replace(/\/$/, "") : undefined;
-  importPluginModule(() => import("./send-session-notification-dyw42dtr.js")).then(({ setNotificationServerUrl }) => {
+  importPluginModule(() => import("./send-session-notification-erecz4y4.js")).then(({ setNotificationServerUrl }) => {
     setNotificationServerUrl(serverUrlStr);
-  }).catch((error) => log("[magic-context] notification transport unavailable:", error));
+  }).catch((error) => log2("[magic-context] notification transport unavailable:", error));
   if (conflictResult?.hasConflict) {
     setTimeout(() => {
       sendConflictWarning2(ctx.client, ctx.directory, conflictResult);
@@ -11446,7 +12273,7 @@ var server = async (ctx) => {
   }
   if (pluginConfig.enabled && !conflictResult?.hasConflict) {
     setTimeout(() => {
-      importPluginModule(() => import("./announcement-y35wzg2r.js")).then(({
+      importPluginModule(() => import("./announcement-fp14dw0n.js")).then(({
         shouldShowAnnouncement,
         ANNOUNCEMENT_VERSION,
         ANNOUNCEMENT_FEATURES,
@@ -11455,7 +12282,7 @@ var server = async (ctx) => {
       }) => {
         if (!shouldShowAnnouncement())
           return;
-        return importPluginModule(() => import("./conflict-warning-hook-7fj2b9jw.js")).then(({ sendStartupAnnouncement }) => sendStartupAnnouncement(ctx.client, ctx.directory, ANNOUNCEMENT_VERSION, ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER, markAnnouncementSeen));
+        return importPluginModule(() => import("./conflict-warning-hook-w8cykrnf.js")).then(({ sendStartupAnnouncement }) => sendStartupAnnouncement(ctx.client, ctx.directory, ANNOUNCEMENT_VERSION, ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER, markAnnouncementSeen));
       }).catch(() => {});
     }, 8000);
   }
@@ -11465,7 +12292,7 @@ var server = async (ctx) => {
   const measuredStorageMs = storageBootTimings.openMs + storageBootTimings.guardMs + storageBootTimings.migrateMs;
   const hooksMs = Math.max(0, hooksPhase.elapsedMs - measuredStorageMs);
   const postMs = Math.max(0, performance.now() - postStartedAt - rpcMs);
-  log(formatBootPhaseDiagnostics({
+  log2(formatBootPhaseDiagnostics({
     configMs,
     conflictMs,
     guardMs: storageBootTimings.guardMs,
@@ -11478,14 +12305,6 @@ var server = async (ctx) => {
     budgetMs: BOOT_SERVER_DEADLINE_MS,
     deadlinePhase
   }));
-  const checkoutClaimGate = pluginConfig.enabled ? createSubcCheckoutClaimGate("opencode", () => pluginConfig.subc?.connection_file ?? getDefaultSubcConnectionFile()) : undefined;
-  const isCheckoutClaimRefused = async (sessionId) => {
-    if (!checkoutClaimGate || !sessionId)
-      return false;
-    if (liveSessionState.internalChildSessions.has(sessionId))
-      return false;
-    return await checkoutClaimGate.refusal(sessionId, ctx.directory) !== null;
-  };
   return {
     tool: tools,
     event: createEventHandler({
@@ -11495,8 +12314,6 @@ var server = async (ctx) => {
             const properties = input.event.properties;
             if (properties.info?.id)
               dreamerCap.delete(properties.info.id);
-          } else if (await isCheckoutClaimRefused(openCodeEventSessionId(input.event))) {
-            return;
           }
           await magicContextRuntime.magicContext?.event?.(input);
         }
@@ -11522,7 +12339,7 @@ var server = async (ctx) => {
         try {
           magicContextRuntime.magicContext?.disposeRustAdapter?.();
         } catch {}
-        log("[magic-context] instance disposed — stopped RPC server, dream timer, auto-update, Rust replay registration");
+        log2("[magic-context] instance disposed — stopped RPC server, dream timer, auto-update, Rust replay registration");
       }
     }),
     "chat.params": async (input, output) => {
@@ -11533,25 +12350,13 @@ var server = async (ctx) => {
       getMagicContext: () => magicContextRuntime.magicContext,
       failClosed,
       failClosedBlockingEnabled,
-      checkoutClaim: checkoutClaimGate ? {
-        gate: checkoutClaimGate,
-        projectRoot: ctx.directory,
-        onRefusal: async (sessionId, message) => {
-          const { sendStatusNotification } = await importPluginModule(() => import("./send-session-notification-dyw42dtr.js"));
-          const { abortSessionFailClosed } = await importPluginModule(() => import("./transform-postprocess-phase-bqhz6vdr.js"));
-          await sendStatusNotification(ctx.client, sessionId, message, {
-            toastDurationMs: 15000
-          });
-          await abortSessionFailClosed(ctx.client, sessionId);
-        }
-      } : undefined,
       compactionOff: !isCompactionEnabled(pluginConfig),
       internalChildSessions: liveSessionState.internalChildSessions,
       tryReopenStorage,
       rustReplayParticipant: () => magicContextRuntime.magicContext?.getRustReplayParticipant?.() ?? null,
       onStorageBusyRefusal: async (sessionId, message) => {
-        const { sendStatusNotification } = await importPluginModule(() => import("./send-session-notification-dyw42dtr.js"));
-        const { abortSessionFailClosed } = await importPluginModule(() => import("./transform-postprocess-phase-bqhz6vdr.js"));
+        const { sendStatusNotification } = await importPluginModule(() => import("./send-session-notification-erecz4y4.js"));
+        const { abortSessionFailClosed } = await importPluginModule(() => import("./transform-postprocess-phase-spcy2qre.js"));
         await sendStatusNotification(ctx.client, sessionId, message, {
           toastDurationMs: 15000
         });
@@ -11559,8 +12364,6 @@ var server = async (ctx) => {
       }
     }),
     "experimental.chat.system.transform": async (input, output) => {
-      if (await isCheckoutClaimRefused(input.sessionID))
-        return;
       await magicContextRuntime.magicContext?.["experimental.chat.system.transform"]?.(input, output);
     },
     "command.execute.before": async (input, output) => {
@@ -11573,8 +12376,6 @@ var server = async (ctx) => {
       const modId = typed.model?.modelID;
       const agent = typed.agent;
       lastChatContext = provId && modId ? { providerID: provId, modelID: modId, agentName: agent || "default" } : null;
-      if (await isCheckoutClaimRefused(input.sessionID))
-        return;
       await magicContextRuntime.magicContext?.["chat.message"]?.(input, output);
     },
     "tool.definition": async (input, output) => {
@@ -11650,7 +12451,7 @@ var server = async (ctx) => {
         const internalAgentIds = registrations.map((registration) => registration.id);
         for (const reg of registrations) {
           if (typeof reg.prompt !== "string" || reg.prompt.length === 0) {
-            log(`[magic-context] skipping hidden agent '${reg.id}' — prompt unavailable at config time (dir=${ctx.directory}); will re-register on a later complete pass`);
+            log2(`[magic-context] skipping hidden agent '${reg.id}' — prompt unavailable at config time (dir=${ctx.directory}); will re-register on a later complete pass`);
             continue;
           }
           agentConfigRecord[reg.id] = buildHiddenAgentConfig(reg.prompt, reg.allowedTools, reg.maxSteps, reg.overrides, reg.id, reg.lockPermissions === true, reg.description);
@@ -11659,7 +12460,7 @@ var server = async (ctx) => {
         config.agent = callerAgentConfig;
       } catch (error) {
         const e = error;
-        log(`[magic-context] config hook failed (commands/agents NOT registered; transform still active): ${e?.message ?? error}`, e?.stack ? { stackHead: e.stack.split(`
+        log2(`[magic-context] config hook failed (commands/agents NOT registered; transform still active): ${e?.message ?? error}`, e?.stack ? { stackHead: e.stack.split(`
 `).slice(0, 6).join(`
 `) } : undefined);
       }