@cortexkit/opencode-magic-context 0.47.0 → 0.49.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-nsjyysj0.js";
 import {
   withContentLanguageDirective,
   string,
@@ -21,7 +23,7 @@ import {
   record,
   DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE,
   DEFAULT_HISTORIAN_TIMEOUT_MS
-} from "./index-m5fe6jch.js";
+} from "./index-kq57tdf0.js";
 import {
   denyTaskRoutingToCallerAgents,
   buildHiddenAgentRegistrations,
@@ -74,18 +76,20 @@ import {
   noteLkgProviderResponse,
   registerLkgPersistence,
   dropSlot,
+  forgetUnpublishedAutoSearchNoHint,
   getOrCreateSessionMeta,
   updateSessionMeta,
   markSessionCleanupPending,
   clearSession,
   recordPromptSessionError,
+  CTX_NOTE_LIGHT_DESCRIPTION,
   createPromptSurfaceRuntime,
   setKeepSubagents,
   removeCompactionMarkerForSession,
   checkCompactionMarkerConsistency,
   clearInjectionCache,
   clearNoteNudgeTriggerOnly
-} from "./index-6d9e1m08.js";
+} from "./index-2jcbj7r1.js";
 import"./index-sd3egckz.js";
 import {
   reloadWindowOverlay,
@@ -96,26 +100,21 @@ import {
   deriveHistorianChunkTokens2,
   resolveKnownHistorianContextLimit2,
   resolveHistorianContextLimit2
-} from "./index-0c82743p.js";
-import"./index-rrbbspwh.js";
+} from "./index-57mrqed8.js";
+import"./index-mfkzp7qj.js";
 import {
   resolveOpenCodeDbPath,
   openCodeDbPathExists,
   formatOpenCodeDbMissingBanner,
-  claimOpenCodeDbDiagnosticOnce,
-  closeQuietly
-} from "./index-b35pxds2.js";
-import"./index-wx8a6bw3.js";
+  claimOpenCodeDbDiagnosticOnce
+} from "./index-58e3y90n.js";
+import"./index-kb9nn0a0.js";
 import {
-  createSubcCheckoutClaimGate,
-  openCodeEventSessionId,
   openOpenCodeDb,
   DREAMER_SYSTEM_PROMPT,
   runSessionProjectBackfill,
   SMART_NOTE_COMPILER_SYSTEM_PROMPT,
   createLiveSessionState,
-  getDefaultSubcConnectionFile,
-  SubcModuleTransport,
   OpenCodeRetrospectiveRawProvider,
   createDreamTaskExecutor,
   runManualDream,
@@ -157,6 +156,7 @@ import {
   maybeDeliverChannel2,
   armLatestThinkingRecovery,
   armBindingRecoverySafely,
+  rustWrapupHistorianFields,
   clearMessageTokensCache,
   createTransform,
   createSubcModuleClient,
@@ -171,12 +171,14 @@ import {
   CTX_MEMORY_ACTIONS,
   createCtxMemoryTools,
   createCtxMemoryListTools,
+  withoutSmartNoteText,
   createCtxNoteTools,
   createCtxReduceTools,
   createCtxSearchTools,
   parameterDescriptionsFor,
-  MagicContextRpcServer
-} from "./index-w2t4ah5j.js";
+  MagicContextRpcServer,
+  applyHiddenSubagentTemperature
+} from "./index-h2py7207.js";
 import {
   formatFailClosedBlockingMessage,
   createFailClosedController,
@@ -191,7 +193,7 @@ import {
   openDatabaseAsync,
   isDatabasePersisted,
   getDatabasePersistenceError
-} from "./index-rrrsepyw.js";
+} from "./index-s4j7t92z.js";
 import {
   setHomeProjectPermission,
   ProjectIdentityError,
@@ -202,28 +204,33 @@ import {
   beginBootQuietPeriod,
   bootQuietRemainingMs,
   scheduleAfterBootQuiet
-} from "./index-x3kwrmqk.js";
+} from "./index-pxwp2hjk.js";
+import {
+  deleteTemporalDecision
+} from "./index-1bt88epp.js";
 import {
   observeSessionActivity,
   backfillSessionActivity,
+  deleteIndexedMessage
+} from "./index-hj2q50k0.js";
+import {
   recordSessionProjectIdentity,
-  deleteIndexedMessage,
-  getProjectEmbeddingSnapshot,
-  getEmbeddingCoverageStatus,
-  getAutoEmbeddingSessionCoverage
-} from "./index-fnn5pjtt.js";
+  getProjectEmbeddingSnapshot2,
+  getEmbeddingCoverageStatus2,
+  getAutoEmbeddingSessionCoverage2
+} from "./index-kp5qe690.js";
+import"./index-fb3zxn06.js";
+import"./index-gzcmtmar.js";
+import"./index-nm6a8xpd.js";
+import"./index-fr0wbhdn.js";
+import {
+  preloadTokenizer
+} from "./index-qx53vezw.js";
 import {
-  deleteTemporalDecision,
   getCurrentToolSetHash,
   recordToolDefinition
-} from "./index-5gq3b2ya.js";
-import {
-  preloadTokenizer
-} from "./index-5eqk6z3s.js";
+} from "./index-h2wc01qk.js";
 import {
-  stripPersistedAssistantText,
-  deleteTagsByMessageId,
-  getMaxTagNumberBySession,
   invalidateTrueRawTokenCache,
   recordToolParameters,
   createDroppedInputToolExecuteBeforeHook,
@@ -233,60 +240,79 @@ import {
   detectOverflow,
   isAnthropicFamilyRoute,
   readRawSessionMessages2
-} from "./index-bb36vgr3.js";
+} from "./index-2jgwttpt.js";
+import"./index-vkbqdnkj.js";
+import {
+  getDefaultSubcConnectionFile,
+  SubcModuleTransport
+} from "./index-ha87j7a8.js";
+import {
+  isEmbeddingHostBusy2
+} from "./index-qt1qqasc.js";
+import"./index-tqf7yg27.js";
 import {
-  isEmbeddingHostBusy
-} from "./index-yr3zj7e7.js";
-import"./index-fzbvakh0.js";
+  registerExitAbort,
+  unregisterExitAbort,
+  forgetRawSessionOrdinalWatermark2
+} from "./index-h5zfkjyk.js";
 import {
   observeOpenCodeTurnEvent,
   clearTrackedOpenCodeSession,
   findLastAssistantModelFromOpenCodeDb
-} from "./index-6wkcswft.js";
+} from "./index-9qjqq45k.js";
 import {
   sendCommandResult2,
   sendStatusNotification2
-} from "./index-adwfkpex.js";
+} from "./index-9rt53q79.js";
 import {
   detectConflicts,
   resolveCompactionForBoot
-} from "./index-8da2zjhz.js";
+} from "./index-z1tjp257.js";
 import {
   sendConflictWarning2,
   cleanupConflictWarnings2
-} from "./index-9pk9exrb.js";
+} from "./index-stbr4ce6.js";
 import"./index-1zx87sdm.js";
+import {
+  stripPersistedAssistantText,
+  deleteTagsByMessageId2,
+  getMaxTagNumberBySession2
+} from "./index-nydv6g8r.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-b7mv1jx3.js";
+import"./index-kmpvemph.js";
 import {
   pushNotification2
 } from "./index-x8a7jmkh.js";
-import"./index-92bp57hg.js";
+import"./index-4dhv7mqz.js";
+import"./index-peshmj6h.js";
+import"./index-7jzrrxap.js";
 import {
   createTagger,
   cavemanWordRulesForLanguage,
   setCtxReduceRegisteredGlobally,
   clearToolPermissionDenied,
   resetDegradedCacheCount2
-} from "./index-cwf6s3ay.js";
+} from "./index-1g30axtz.js";
 import {
   runManagedRecomp2
-} from "./index-gg8j07zz.js";
+} from "./index-ezmszwbd.js";
 import {
   isValidSemver,
   compareSemverCore
-} from "./index-k5bdx1bx.js";
+} from "./index-0w56v4fm.js";
 import"./index-fmsr7v69.js";
 import {
   runManagedWrapup2
-} from "./index-5a2r0p9f.js";
+} from "./index-1r0k9js3.js";
 import {
   __toESM,
   __commonJS
@@ -303,7 +329,10 @@ import {
 import {
   piModelRefToCanonical
 } from "./index-avwt563y.js";
-import"./index-sj29b3z2.js";
+import {
+  closeQuietly
+} from "./index-8ajstryz.js";
+import"./index-4mjhqadz.js";
 
 // ../../node_modules/.bun/esprima@4.0.1/node_modules/esprima/dist/esprima.js
 var require_esprima = __commonJS(function(exports, module) {
@@ -8359,9 +8388,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,
@@ -8460,7 +8489,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";
@@ -8530,7 +8559,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 };
       }
@@ -8830,7 +8859,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 {
@@ -8873,7 +8902,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);
@@ -8937,7 +8966,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");
@@ -8960,7 +8989,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) {
@@ -8973,19 +9002,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);
@@ -9000,22 +9029,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, {
@@ -9025,7 +9054,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);
@@ -9276,7 +9305,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) {
@@ -9433,12 +9462,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
@@ -9472,16 +9501,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 result = deps.db.transaction(() => {
+    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);
@@ -9490,22 +9519,24 @@ 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
     };
   }).immediate();
+  forgetUnpublishedAutoSearchNoHint(sessionId, messageId);
+  return result;
 }
 function createEventHandler2(deps) {
   const newestUsageMessageIdBySession = new Map;
@@ -9520,7 +9551,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) {
@@ -9533,7 +9564,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;
     }
@@ -9558,7 +9589,7 @@ function createEventHandler2(deps) {
           const model = findLastAssistantModelFromOpenCodeDb(errInfo.sessionID);
           if (deps.thinkingBindingRecoveryEnabled !== false && !deps.compactionOff && isPrefixBoundThinkingModel(model?.providerID, model?.modelID)) {
             armBindingRecoverySafely(deps.db, errInfo.sessionID);
-            sessionLog(errInfo.sessionID, `thinking binding recovery armed from session.error (provider paths: failing=${bindingMismatch.failingBlockPath ?? "?"} firstChanged=${bindingMismatch.firstChangedPath ?? "?"})`);
+            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);
           }
@@ -9584,7 +9615,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);
@@ -9592,7 +9623,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");
@@ -9608,10 +9639,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;
     }
@@ -9623,7 +9654,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);
@@ -9633,9 +9664,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;
       }
@@ -9674,11 +9705,11 @@ function createEventHandler2(deps) {
         if (bindingMismatch.isBindingMismatch && deps.thinkingBindingRecoveryEnabled !== false && !deps.compactionOff && isPrefixBoundThinkingModel(info.providerID, info.modelID)) {
           try {
             armBindingRecoverySafely(deps.db, info.sessionID);
-            sessionLog(info.sessionID, `thinking binding recovery armed from message.updated (provider paths: failing=${bindingMismatch.failingBlockPath ?? "?"} firstChanged=${bindingMismatch.firstChangedPath ?? "?"})`);
+            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);
           }
         }
       }
@@ -9704,12 +9735,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);
@@ -9724,11 +9755,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);
           }
         }
       }
@@ -9758,7 +9789,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 {
@@ -9770,11 +9801,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 {
@@ -9797,7 +9828,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);
@@ -9812,7 +9843,7 @@ function createEventHandler2(deps) {
             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);
             }
           }
@@ -9837,7 +9868,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) {
@@ -9851,7 +9882,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,
@@ -9865,7 +9896,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;
           };
@@ -9887,7 +9918,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 = {};
@@ -9916,7 +9947,7 @@ function createEventHandler2(deps) {
           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);
@@ -9928,24 +9959,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({
@@ -9954,9 +9986,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;
     }
@@ -9969,12 +10001,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);
@@ -9982,7 +10014,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);
@@ -10002,10 +10034,10 @@ function createEventHandler2(deps) {
         await deps.onSessionDeleted?.(sessionId);
         if (!rustCleanupPending || deps.rustSessionCleanup === true) {
           removeCompactionMarkerForSession(deps.db, sessionId);
-          clearSession(deps.db, sessionId, deps.rustSessionCleanup === true);
+          clearSession(deps.db, sessionId, deps.rustSessionCleanup === true, true);
         }
       } catch (error) {
-        sessionLog(sessionId, "event session.deleted persistence failed:", error);
+        sessionLog2(sessionId, "event session.deleted persistence failed:", error);
       }
       resetDegradedCacheCount2(sessionId);
       deps.onSessionCacheInvalidated?.(sessionId);
@@ -10074,7 +10106,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) {
@@ -10086,7 +10118,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;
@@ -10094,7 +10126,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({
@@ -10105,7 +10137,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;
@@ -10113,7 +10145,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;
@@ -10149,10 +10181,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;
@@ -10184,7 +10216,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);
@@ -10265,7 +10297,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, {
@@ -10275,11 +10307,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,
@@ -10297,7 +10329,7 @@ function createMagicContextHook(deps) {
     (async () => {
       try {
         await new Promise((resolve) => setTimeout(resolve, 0));
-        if (isEmbeddingHostBusy()) {
+        if (isEmbeddingHostBusy2()) {
           invalidateAutoEmbedSession(sessionId);
           return;
         }
@@ -10308,7 +10340,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;
@@ -10318,7 +10350,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);
       }
     })();
   };
@@ -10347,7 +10379,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({
@@ -10513,7 +10545,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,
@@ -10525,6 +10557,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) => {
@@ -10542,10 +10575,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,
@@ -10555,6 +10589,15 @@ function createMagicContextHook(deps) {
     historyBudgetPercentage: deps.config.history_budget_percentage,
     transformMode: deps.config.transform_mode,
     rustModeModuleClient,
+    resolveRustWrapupHistorianFields: () => {
+      const run = sampleHistorian();
+      return rustWrapupHistorianFields({
+        historianModel: run.model,
+        fallbackModels: run.fallbackModels,
+        timeoutMs: run.timeoutMs,
+        maxOutputTokens: run.maxOutputTokens
+      });
+    },
     projectRoot: deps.directory,
     commitClusterTrigger: deps.config.commit_cluster_trigger,
     sampleCommitClusterTrigger: () => (deps.sampleHistorianConfig?.() ?? deps.config).commit_cluster_trigger,
@@ -10602,7 +10645,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,
@@ -10616,6 +10659,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) => {
@@ -10634,6 +10678,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,
@@ -10759,7 +10804,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({
@@ -10816,18 +10861,25 @@ async function createSessionHooksAsync(args) {
   };
 }
 
-// src/plugin/host-stall-profiler.ts
-import { chmodSync, existsSync as existsSync5, readdirSync, readFileSync as readFileSync5, unlinkSync } from "node:fs";
+// 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/plugin/host-stall-profiler-report.ts
+// 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"]);
+var BACKGROUND_OWNERS = new Set(["native", "runtime", "opencode", "pi", "omp"]);
 var packageNameCache = new Map;
 function urlToPath(url) {
   if (url.startsWith("file://")) {
@@ -10878,8 +10930,21 @@ function sourceOwner(sourceURL) {
   const filePath = urlToPath(sourceURL).replaceAll("\\", "/");
   const modules = [...filePath.matchAll(/\/node_modules\/((?:@[^/]+\/)?[^/]+)/g)];
   const innermost = modules.at(-1);
-  if (innermost)
-    return `npm:${innermost[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]}`;
@@ -10971,39 +11036,33 @@ function aggregateTraces(traces) {
   };
 }
 
-// src/plugin/host-stall-profiler.ts
+// src/shared/host-stall-profiler-common.ts
 var HOST_PROFILER_DIRNAME = "host-profiler";
 var HOST_PROFILER_ENABLE_FILENAME = "enable";
-var SWITCH_POLL_MS = 30000;
+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 MEMORY_SNAPSHOT_EVERY_TICKS = 4;
-var CALIBRATION_CHUNK_MS = 3;
-var CALIBRATION_MAX_CHUNKS = 30;
-function clamp(value, min, max) {
-  return Math.min(max, Math.max(min, value));
-}
+var PROFILE_WINDOW_MS = 1e4;
 function parseEnableFile(content) {
   const options = {
     thresholdMs: DEFAULT_STALL_THRESHOLD_MS,
     sampleIntervalMs: DEFAULT_SAMPLE_INTERVAL_MS
   };
-  const trimmed = content.trim();
-  if (trimmed === "")
+  if (!content.trim())
     return { options, error: null };
   try {
-    const parsed = JSON.parse(trimmed);
+    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 = clamp(parsed.threshold_ms, 500, 600000);
+      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 = clamp(parsed.sample_interval_ms, 1, 100);
+      options.sampleIntervalMs = Math.min(100, Math.max(1, parsed.sample_interval_ms));
     }
     return { options, error: null };
   } catch (error) {
@@ -11013,6 +11072,66 @@ function parseEnableFile(content) {
     };
   }
 }
+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]) {
@@ -11023,18 +11142,6 @@ function asJscApi(module) {
   }
   return null;
 }
-function thin(items, limit) {
-  if (items.length <= limit)
-    return items;
-  const stride = items.length / limit;
-  const out = [];
-  for (let i = 0;i < limit; i++)
-    out.push(items[Math.floor(i * stride)]);
-  return out;
-}
-function reportFileStamp(epochMs) {
-  return new Date(epochMs).toISOString().replaceAll(":", "-");
-}
 function createHostStallProfiler(deps) {
   let jsc = null;
   let unavailable = false;
@@ -11109,30 +11216,8 @@ function createHostStallProfiler(deps) {
       percent_available_memory_in_use: read(() => api.percentAvailableMemoryInUse?.() ?? null)
     };
   };
-  const writeReport = (report, endWallMs) => {
-    const dir = deps.profilerDir();
-    ensureStorageDirectorySync(dir, true);
-    chmodSync(dir, 448);
-    const stamp = reportFileStamp(endWallMs);
-    let name = `stall-${stamp}.json`;
-    for (let n = 1;existsSync5(path4.join(dir, name)); n++)
-      name = `stall-${stamp}-${n}.json`;
-    const finalPath = path4.join(dir, name);
-    writeStorageFileAtomicSync(finalPath, `${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 (error) {
-        logOnce("prune", "could not prune an old report", error);
-      }
-    }
-    return finalPath;
-  };
   const recordStall = (api, startMs, endMs, traces) => {
     const after = snapshot(api);
-    const gapMs = endMs - startMs;
     let windowed = traces;
     let windowFilter = "since-last-collection";
     if (clockOffsetMs !== null) {
@@ -11150,40 +11235,17 @@ function createHostStallProfiler(deps) {
         windowFilter = "since-last-collection (timestamp filter matched no sample)";
       }
     }
-    const kept = thin(windowed, MAX_SAMPLES_PER_WINDOW);
-    const aggregate = aggregateTraces(kept);
-    const endWallMs = deps.wallNow();
-    const startWallMs = endWallMs - gapMs;
-    const report = {
-      kind: "magic-context-host-stall",
-      schema_version: 1,
-      pid: deps.pid,
-      bun_version: deps.bunVersion,
-      platform: process.platform,
-      window: {
-        start: new Date(startWallMs).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: 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: memoryBefore, after },
-      owners: aggregate.owners,
-      top_frames: aggregate.top_frames,
-      top_js_frames: aggregate.top_js_frames,
-      top_stacks: aggregate.top_stacks
-    };
-    const file = writeReport(report, endWallMs);
-    const top = aggregate.owners[0];
-    safeLog(`[magic-context] host stall profiler: ${Math.round(gapMs)}ms main-thread stall, ${aggregate.samples} samples, top owner ${top ? `${top.owner} (${top.percent}%)` : "none"} → ${file}`);
+    emitStallReport(deps, {
+      startMs,
+      endMs,
+      traces,
+      windowed,
+      windowFilter,
+      options,
+      before: memoryBefore,
+      after,
+      backend: "jsc"
+    });
     memoryBefore = after;
   };
   const tick = () => {
@@ -11195,7 +11257,7 @@ function createHostStallProfiler(deps) {
       const startMs = lastTickAt;
       lastTickAt = now;
       const traces = drain(api);
-      if (now - startMs > options.thresholdMs) {
+      if (now - startMs - WATCHDOG_INTERVAL_MS >= options.thresholdMs) {
         try {
           recordStall(api, startMs, now, traces);
         } catch (error) {
@@ -11265,8 +11327,8 @@ function createHostStallProfiler(deps) {
     if (unavailable)
       return;
     try {
-      const enablePath = path4.join(deps.profilerDir(), HOST_PROFILER_ENABLE_FILENAME);
-      if (!existsSync5(enablePath)) {
+      const enablePath = path5.join(deps.profilerDir(), HOST_PROFILER_ENABLE_FILENAME);
+      if (!existsSync6(enablePath)) {
         if (watchdog !== null)
           disable("enable file removed");
         return;
@@ -11283,7 +11345,7 @@ function createHostStallProfiler(deps) {
         return;
       }
       const api = await ensureJsc();
-      if (!api || watchdog !== null || !existsSync5(enablePath))
+      if (!api || watchdog !== null || !existsSync6(enablePath))
         return;
       enable(api, parsed.options);
     } catch (error) {
@@ -11317,45 +11379,285 @@ function createHostStallProfiler(deps) {
     isUnavailable: () => unavailable
   };
 }
-function hostStallProfilerDir() {
-  return path4.join(getMagicContextStorageDir(), HOST_PROFILER_DIRNAME);
+
+// 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 defaultDeps() {
+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 {
-    profilerDir: hostStallProfilerDir,
-    loadJsc: () => import("bun:jsc"),
-    now: () => performance.now(),
-    wallNow: () => Date.now(),
-    setInterval: (callback, ms) => {
-      const handle = setInterval(callback, ms);
-      handle.unref?.();
-      return handle;
+    start() {
+      if (pollTimer !== null || unavailable)
+        return;
+      stopped = false;
+      pollTimer = deps.setInterval(() => {
+        enqueue(runCheck);
+      }, SWITCH_POLL_MS);
+      enqueue(runCheck);
     },
-    clearInterval: (handle) => clearInterval(handle),
-    rss: () => process.memoryUsage.rss(),
-    log,
-    pid: process.pid,
-    bunVersion: process.versions.bun ?? null
+    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 handle = createHostStallProfiler(defaultDeps());
+    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) {
-    log("[magic-context] host stall profiler: could not start the enable-file switch", error);
+    log2("[magic-context] host stall profiler: could not start the enable-file switch", error);
   }
 }
-
 // src/plugin/instance-disposal.ts
-import path5 from "node:path";
+import path8 from "node:path";
 function isDisposedInstanceDirectory(ownDirectory, disposedDirectory) {
-  return path5.resolve(disposedDirectory) === path5.resolve(ownDirectory);
+  return path8.resolve(disposedDirectory) === path8.resolve(ownDirectory);
 }
 
 // src/plugin/native-compaction-guard.ts
@@ -11364,7 +11666,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;
 }
 
@@ -11435,7 +11737,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;
@@ -11450,11 +11752,13 @@ function createToolRegistry(args) {
     ...createCtxNoteTools({
       db,
       dreamerEnabled: isDreamerRunnable(pluginConfig),
+      smartNotesEnabled: pluginConfig.smart_notes?.enabled,
       resolveProjectPath,
       rustToolBackends
     }),
     ...createCtxSearchTools({
       db,
+      rerankConnectionFile: pluginConfig.subc?.connection_file,
       resolveProjectPath,
       ensureProjectRegistered: ensureProjectRegisteredFromOpenCodeDirectory
     }),
@@ -11475,11 +11779,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
@@ -11489,7 +11793,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 ?? "")
       }
     ];
   }));
@@ -11517,30 +11821,9 @@ 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 existsSync6, readFileSync as readFileSync6 } from "node:fs";
-import { dirname as dirname4, join as join7 } 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() {
@@ -11549,11 +11832,11 @@ function packageInfo() {
   let directory = dirname4(fileURLToPath2(import.meta.url));
   for (;; ) {
     try {
-      const pkg = JSON.parse(readFileSync6(join7(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: existsSync6(join7(directory, "src/v2/server.ts"))
+          development: existsSync8(join10(directory, "src/v2/server.ts"))
         };
         return cachedPackageInfo;
       }
@@ -11599,7 +11882,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 {
@@ -11620,16 +11903,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-wq4ffwyb.js");
-  setHarness("opencode2");
+  const { registerContext } = await import("./context-nj5f293n.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();
@@ -11649,14 +11932,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;
@@ -11667,7 +11950,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 = [
@@ -11685,7 +11968,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);
@@ -11694,7 +11977,7 @@ var server = async (ctx) => {
     if (hasBannerEntries)
       setTimeout(async () => {
         try {
-          const { sendStatusNotification } = await importPluginModule(() => import("./send-session-notification-0m68ms3n.js"));
+          const { sendStatusNotification } = await importPluginModule(() => import("./send-session-notification-38cd5dqt.js"));
           const clientWithSessions = ctx.client;
           const sessions = await Promise.resolve(clientWithSessions.session?.list?.()).catch(() => null);
           const sessionList = Array.isArray(sessions) ? sessions : sessions?.data;
@@ -11708,10 +11991,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-0m68ms3n.js"));
+        const { sendStatusNotification } = await importPluginModule(() => import("./send-session-notification-38cd5dqt.js"));
         const clientWithSessions = ctx.client;
         const sessions = await Promise.resolve(clientWithSessions.session?.list?.()).catch(() => null);
         const sessionList = Array.isArray(sessions) ? sessions : sessions?.data;
@@ -11728,7 +12011,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),
@@ -11736,9 +12019,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;
@@ -11754,7 +12037,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";
@@ -11772,7 +12055,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") {
@@ -11782,7 +12065,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 () => {
@@ -11804,10 +12087,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;
     }
   };
@@ -11826,12 +12109,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) {
@@ -11869,7 +12152,7 @@ var server = async (ctx) => {
           closeQuietly(ocDb);
         }
       })().catch((err) => {
-        log(`[session-projects] background runner failed: ${err}`);
+        log2(`[session-projects] background runner failed: ${err}`);
       });
     }, 0);
   }
@@ -11881,7 +12164,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,
@@ -11919,6 +12202,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,
@@ -11939,7 +12223,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);
     }
@@ -11957,9 +12241,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;
@@ -11979,21 +12263,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-z44ynfz7.js")).then(({ sendSchemaFenceWarning }) => sendSchemaFenceWarning(ctx.client, ctx.directory, fence)).catch((error) => log("[magic-context] schema-fence warning unavailable:", error));
+      importPluginModule(() => import("./conflict-warning-hook-kzx4dmk1.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-0m68ms3n.js")).then(({ setNotificationServerUrl }) => {
+  importPluginModule(() => import("./send-session-notification-38cd5dqt.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);
@@ -12005,7 +12289,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,
@@ -12014,7 +12298,7 @@ var server = async (ctx) => {
       }) => {
         if (!shouldShowAnnouncement())
           return;
-        return importPluginModule(() => import("./conflict-warning-hook-z44ynfz7.js")).then(({ sendStartupAnnouncement }) => sendStartupAnnouncement(ctx.client, ctx.directory, ANNOUNCEMENT_VERSION, ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER, markAnnouncementSeen));
+        return importPluginModule(() => import("./conflict-warning-hook-kzx4dmk1.js")).then(({ sendStartupAnnouncement }) => sendStartupAnnouncement(ctx.client, ctx.directory, ANNOUNCEMENT_VERSION, ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER, markAnnouncementSeen));
       }).catch(() => {});
     }, 8000);
   }
@@ -12024,7 +12308,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,
@@ -12037,14 +12321,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({
@@ -12054,8 +12330,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);
         }
@@ -12081,36 +12355,25 @@ 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) => {
       dreamerCap.apply(input, output);
+      applyHiddenSubagentTemperature(input, output, log2);
     },
     "experimental.chat.messages.transform": createMessagesTransformHandler({
       magicContext: magicContextRuntime.magicContext,
       getMagicContext: () => magicContextRuntime.magicContext,
       failClosed,
       failClosedBlockingEnabled,
-      checkoutClaim: checkoutClaimGate ? {
-        gate: checkoutClaimGate,
-        projectRoot: ctx.directory,
-        onRefusal: async (sessionId, message) => {
-          const { sendStatusNotification } = await importPluginModule(() => import("./send-session-notification-0m68ms3n.js"));
-          const { abortSessionFailClosed } = await importPluginModule(() => import("./transform-postprocess-phase-z5hzpsxv.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-0m68ms3n.js"));
-        const { abortSessionFailClosed } = await importPluginModule(() => import("./transform-postprocess-phase-z5hzpsxv.js"));
+        const { sendStatusNotification } = await importPluginModule(() => import("./send-session-notification-38cd5dqt.js"));
+        const { abortSessionFailClosed } = await importPluginModule(() => import("./transform-postprocess-phase-tck4g20s.js"));
         await sendStatusNotification(ctx.client, sessionId, message, {
           toastDurationMs: 15000
         });
@@ -12118,8 +12381,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) => {
@@ -12132,8 +12393,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) => {
@@ -12209,7 +12468,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);
@@ -12218,7 +12477,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);
       }