@cortexkit/opencode-magic-context 0.15.2 → 0.15.4

package/dist/index.js

@@ -147829,7 +147829,15 @@ function readUserCompaction() {
 }
 function checkDcpPlugin(directory) {
   const plugins = collectPluginEntries(directory);
-  return plugins.some((p) => p.includes("opencode-dcp"));
+  return plugins.some((p) => matchesPackageName(p, DCP_PACKAGE_NAMES));
+}
+function matchesPackageName(entry, canonicalNames) {
+  if (entry.startsWith("file:") || entry.startsWith("http:") || entry.startsWith("https:") || entry.startsWith("/") || entry.startsWith("./") || entry.startsWith("../")) {
+    return false;
+  }
+  const lastAt = entry.lastIndexOf("@");
+  const nameOnly = lastAt > 0 ? entry.slice(0, lastAt) : entry;
+  return canonicalNames.has(nameOnly);
 }
 function collectPluginEntries(directory) {
   const plugins = [];
@@ -147862,7 +147870,7 @@ function checkOmoHooks(directory) {
     anthropicRecovery: false
   };
   const plugins = collectPluginEntries(directory);
-  const hasOmo = plugins.some((p) => p.includes("oh-my-opencode") || p.includes("oh-my-openagent") || p.includes("@code-yeongyu/"));
+  const hasOmo = plugins.some((p) => matchesPackageName(p, OMO_PACKAGE_NAMES));
   if (!hasOmo)
     return result;
   const disabledHooks = readOmoDisabledHooks(directory);
@@ -147914,9 +147922,12 @@ function formatConflictShort(result) {
   return lines.join(`
 `);
 }
+var DCP_PACKAGE_NAMES, OMO_PACKAGE_NAMES;
 var init_conflict_detector = __esm(() => {
   init_jsonc_parser();
   init_opencode_config_dir();
+  DCP_PACKAGE_NAMES = new Set(["@tarquinen/opencode-dcp"]);
+  OMO_PACKAGE_NAMES = new Set(["oh-my-opencode", "oh-my-openagent"]);
 });
 
 // src/plugin/conflict-warning-hook.ts
@@ -149462,7 +149473,21 @@ class OpenAICompatibleEmbeddingProvider {
         this.recordFailure(isProbe);
         return Array.from({ length: texts.length }, () => null);
       }
-      const body = await response.json();
+      const rawBody = await response.text();
+      if (rawBody.trim().length === 0) {
+        log(`[magic-context] openai-compatible embedding request returned empty body (status=${response.status}, content-type=${response.headers.get("content-type") ?? "none"})`);
+        this.recordFailure(isProbe);
+        return Array.from({ length: texts.length }, () => null);
+      }
+      let body;
+      try {
+        body = JSON.parse(rawBody);
+      } catch (parseError) {
+        const snippet = rawBody.slice(0, 200).replace(/\s+/g, " ");
+        log(`[magic-context] openai-compatible embedding response was not JSON (status=${response.status}, ${rawBody.length}B body, snippet="${snippet}"):`, parseError instanceof Error ? parseError.message : parseError);
+        this.recordFailure(isProbe);
+        return Array.from({ length: texts.length }, () => null);
+      }
       const items = Array.isArray(body.data) ? body.data : [];
       const results = Array.from({ length: texts.length }, (_, index) => {
         const embedding = items[index]?.embedding;
@@ -151291,6 +151316,14 @@ function recordOverflowDetected(db, sessionId, reportedLimit) {
     }
   })();
 }
+function recordDetectedContextLimit(db, sessionId, reportedLimit) {
+  if (!(reportedLimit > 0))
+    return;
+  db.transaction(() => {
+    ensureSessionMetaRow(db, sessionId);
+    db.prepare("UPDATE session_meta SET detected_context_limit = ? WHERE session_id = ?").run(reportedLimit, sessionId);
+  })();
+}
 function clearEmergencyRecovery(db, sessionId) {
   db.transaction(() => {
     ensureSessionMetaRow(db, sessionId);
@@ -151351,6 +151384,25 @@ var init_storage_meta_persisted = __esm(() => {
   init_storage_meta_shared();
 });
 
+// src/features/magic-context/resolve-subagent-fallback.ts
+function resolveIsSubagentFromOpenCodeDb(sessionId) {
+  try {
+    return withReadOnlySessionDb((openCodeDb) => {
+      const row = openCodeDb.prepare("SELECT parent_id FROM session WHERE id = ?").get(sessionId);
+      if (!row)
+        return null;
+      return typeof row.parent_id === "string" && row.parent_id.length > 0;
+    });
+  } catch (error48) {
+    log(`[magic-context] resolveIsSubagentFromOpenCodeDb failed for ${sessionId}:`, error48);
+    return null;
+  }
+}
+var init_resolve_subagent_fallback = __esm(() => {
+  init_read_session_db();
+  init_logger();
+});
+
 // src/features/magic-context/storage-meta-session.ts
 function getOrCreateSessionMeta(db, sessionId) {
   const result = db.prepare("SELECT session_id, last_response_time, cache_ttl, counter, last_nudge_tokens, last_nudge_band, last_transform_error, is_subagent, last_context_percentage, last_input_tokens, times_execute_threshold_reached, compartment_in_progress, system_prompt_hash, system_prompt_tokens, conversation_tokens, tool_call_tokens, cleared_reasoning_through_tag FROM session_meta WHERE session_id = ?").get(sessionId);
@@ -151358,7 +151410,14 @@ function getOrCreateSessionMeta(db, sessionId) {
     return toSessionMeta(result);
   }
   const defaults = getDefaultSessionMeta(sessionId);
+  const fallbackSubagent = resolveIsSubagentFromOpenCodeDb(sessionId);
+  if (fallbackSubagent === true) {
+    defaults.isSubagent = true;
+  }
   ensureSessionMetaRow(db, sessionId);
+  if (fallbackSubagent === true) {
+    db.prepare("UPDATE session_meta SET is_subagent = 1 WHERE session_id = ?").run(sessionId);
+  }
   return defaults;
 }
 function updateSessionMeta(db, sessionId, updates) {
@@ -151406,6 +151465,7 @@ function clearSession(db, sessionId) {
 var init_storage_meta_session = __esm(() => {
   init_compression_depth_storage();
   init_message_index();
+  init_resolve_subagent_fallback();
   init_storage_meta_shared();
 });
 
@@ -154552,7 +154612,7 @@ No new compartments or facts were written. Check the historian model/output and
     })();
     clearInjectionCache(sessionId);
     deps.onInjectionCacheCleared?.(sessionId);
-    if (deps.directory) {
+    if (deps.directory && deps.memoryEnabled !== false && deps.autoPromote !== false) {
       promoteSessionFactsToMemory(db, sessionId, resolveProjectIdentity(deps.directory), validatedPass.facts ?? []);
     }
     const lastCompartmentEnd = lastNewEnd;
@@ -154658,7 +154718,7 @@ async function executeContextRecompInternal(deps) {
       clearCompressionDepth(db, sessionId);
       clearInjectionCache(sessionId);
       deps.onInjectionCacheCleared?.(sessionId);
-      if (deps.directory) {
+      if (deps.directory && deps.memoryEnabled !== false && deps.autoPromote !== false) {
         promoteSessionFactsToMemory(db, sessionId, resolveProjectIdentity(deps.directory), promoted2.facts);
       }
       const lastCompartmentEnd2 = promoted2.compartments[promoted2.compartments.length - 1]?.endMessage ?? 0;
@@ -154829,7 +154889,7 @@ Nothing was written.`;
     deps.onInjectionCacheCleared?.(sessionId);
     const finalCompartments = promoted?.compartments ?? candidateCompartments;
     const finalFacts = promoted?.facts ?? candidateFacts;
-    if (deps.directory) {
+    if (deps.directory && deps.memoryEnabled !== false && deps.autoPromote !== false) {
       promoteSessionFactsToMemory(db, sessionId, resolveProjectIdentity(deps.directory), finalFacts);
     }
     const lastCompartmentEnd = finalCompartments[finalCompartments.length - 1]?.endMessage ?? 0;
@@ -163561,7 +163621,10 @@ function createLiveSessionState() {
   return {
     liveModelBySession: new Map,
     variantBySession: new Map,
-    agentBySession: new Map
+    agentBySession: new Map,
+    historyRefreshSessions: new Set,
+    systemPromptRefreshSessions: new Set,
+    pendingMaterializationSessions: new Set
   };
 }
 
@@ -167438,6 +167501,8 @@ async function runCompartmentPhase(args) {
         historianTwoPass: args.historianTwoPass,
         compressorMinCompartmentRatio: args.compressorMinCompartmentRatio,
         compressorMaxMergeDepth: args.compressorMaxMergeDepth,
+        memoryEnabled: args.memoryEnabled,
+        autoPromote: args.autoPromote,
         onInjectionCacheCleared: args.onInjectionCacheCleared
       });
       compartmentInProgress = true;
@@ -167463,6 +167528,8 @@ async function runCompartmentPhase(args) {
         historianTwoPass: args.historianTwoPass,
         compressorMinCompartmentRatio: args.compressorMinCompartmentRatio,
         compressorMaxMergeDepth: args.compressorMaxMergeDepth,
+        memoryEnabled: args.memoryEnabled,
+        autoPromote: args.autoPromote,
         onInjectionCacheCleared: args.onInjectionCacheCleared
       });
       activeRun = getActiveCompartmentRun(args.sessionId);
@@ -169227,7 +169294,7 @@ function logTransformTiming(sessionId, stage, startMs, extra) {
 // src/hooks/magic-context/transform-postprocess-phase.ts
 async function runPostTransformPhase(args) {
   let didMutateFromPendingOperations = false;
-  const isExplicitFlush = args.flushedSessions.has(args.sessionId);
+  const isExplicitFlush = args.pendingMaterializationSessions.has(args.sessionId);
   const alreadyRanThisTurn = args.currentTurnId !== null && args.lastHeuristicsTurnId.get(args.sessionId) === args.currentTurnId;
   const forceMaterialization = args.fullFeatureMode && args.contextUsage.percentage >= args.forceMaterializationPercentage;
   const activeCompartmentRun = args.canRunCompartments ? getActiveCompartmentRun(args.sessionId) : undefined;
@@ -169237,8 +169304,8 @@ async function runPostTransformPhase(args) {
   const pendingOps = shouldReadPendingOps ? getPendingOps(args.db, args.sessionId) : [];
   const hasPendingUserOps = pendingOps.length > 0;
   const shouldApplyPendingOps = (args.schedulerDecision === "execute" || isExplicitFlush || forceMaterialization) && (!compartmentRunning || emergencyBypassCompartmentGate);
-  const isCacheBustingPass = isExplicitFlush || shouldApplyPendingOps;
   const shouldRunHeuristics = (!compartmentRunning || emergencyBypassCompartmentGate) && (isExplicitFlush || forceMaterialization || args.schedulerDecision === "execute" && !alreadyRanThisTurn);
+  const isCacheBustingPass = shouldApplyPendingOps || shouldRunHeuristics;
   if (shouldRunHeuristics) {
     const reason = isExplicitFlush ? "explicit_flush" : forceMaterialization ? `force_materialization (${args.contextUsage.percentage.toFixed(1)}% >= ${args.forceMaterializationPercentage}%)` : `scheduler_execute (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})`;
     sessionLog(args.sessionId, `heuristics WILL RUN \u2014 reason=${reason}, context=${args.contextUsage.percentage.toFixed(1)}%, turn=${args.currentTurnId}`);
@@ -169312,7 +169379,7 @@ async function runPostTransformPhase(args) {
         }
       }
       logTransformTiming(args.sessionId, "clearOldReasoning", t7);
-      args.flushedSessions.delete(args.sessionId);
+      args.pendingMaterializationSessions.delete(args.sessionId);
       if (args.currentTurnId) {
         args.lastHeuristicsTurnId.set(args.sessionId, args.currentTurnId);
       }
@@ -169381,7 +169448,14 @@ async function runPostTransformPhase(args) {
       }
     }
   }
-  const pendingUserTurnReminder = getPersistedStickyTurnReminder(args.db, args.sessionId);
+  const pendingUserTurnReminder = args.fullFeatureMode ? getPersistedStickyTurnReminder(args.db, args.sessionId) : null;
+  if (!args.fullFeatureMode && isCacheBustingPass) {
+    const stale = getPersistedStickyTurnReminder(args.db, args.sessionId);
+    if (stale) {
+      clearPersistedStickyTurnReminder(args.db, args.sessionId);
+      sessionLog(args.sessionId, "sticky turn reminder cleared \u2014 subagent should not have this state (cache-busting pass)");
+    }
+  }
   if (pendingUserTurnReminder) {
     if (args.hasRecentReduceCall && isCacheBustingPass) {
       clearPersistedStickyTurnReminder(args.db, args.sessionId);
@@ -169634,7 +169708,7 @@ function createTransform(deps) {
     }
     const historyBudgetTokens = resolveHistoryBudgetTokens(deps.historyBudgetPercentage, contextUsageEarly, deps.executeThresholdPercentage, deps.getModelKey?.(sessionId), deps.executeThresholdTokens);
     const schedulerDecisionEarly = resolveSchedulerDecision(deps.scheduler, sessionMeta, contextUsageEarly, sessionId, deps.getModelKey?.(sessionId));
-    const isCacheBusting = deps.flushedSessions.has(sessionId);
+    const isCacheBusting = deps.historyRefreshSessions.has(sessionId);
     if (historianFailureState.failureCount === 0) {
       lastEmergencyNotificationCount.delete(sessionId);
     }
@@ -169671,8 +169745,11 @@ function createTransform(deps) {
         historianTwoPass: deps.historianTwoPass,
         compressorMinCompartmentRatio: deps.compressorMinCompartmentRatio,
         compressorMaxMergeDepth: deps.compressorMaxMergeDepth,
+        memoryEnabled: deps.memoryConfig?.enabled,
+        autoPromote: deps.memoryConfig?.autoPromote,
         onInjectionCacheCleared: (sid) => {
-          deps.flushedSessions.add(sid);
+          deps.historyRefreshSessions.add(sid);
+          deps.pendingMaterializationSessions.add(sid);
         }
       });
       skipCompartmentAwaitForThisPass = true;
@@ -169709,6 +169786,9 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
       const tInj = performance.now();
       pendingCompartmentInjection = prepareCompartmentInjection(db, sessionId, messages, isCacheBusting, projectIdentity, deps.memoryConfig?.injectionBudgetTokens, deps.experimentalTemporalAwareness);
       logTransformTiming(sessionId, "prepareCompartmentInjection", tInj);
+      if (isCacheBusting) {
+        deps.historyRefreshSessions.delete(sessionId);
+      }
     }
     let targets = new Map;
     let reasoningByMessage = new Map;
@@ -169738,7 +169818,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
       hasRecentReduceCall = result.hasRecentReduceCall;
       const hadPriorCommitState = deps.commitSeenLastPass?.has(sessionId) ?? false;
       const sawCommitLastPass = deps.commitSeenLastPass?.get(sessionId) ?? false;
-      if (hadPriorCommitState && result.hasRecentCommit && !sawCommitLastPass) {
+      if (fullFeatureMode && hadPriorCommitState && result.hasRecentCommit && !sawCommitLastPass) {
         onNoteTrigger(db, sessionId, "commit_detected");
       }
       deps.commitSeenLastPass?.set(sessionId, result.hasRecentCommit);
@@ -169834,8 +169914,11 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
       compressorMinCompartmentRatio: deps.compressorMinCompartmentRatio,
       compressorMaxMergeDepth: deps.compressorMaxMergeDepth,
       compressorCooldownMs: deps.compressorCooldownMs,
+      memoryEnabled: deps.memoryConfig?.enabled,
+      autoPromote: deps.memoryConfig?.autoPromote,
       onInjectionCacheCleared: (sid) => {
-        deps.flushedSessions.add(sid);
+        deps.historyRefreshSessions.add(sid);
+        deps.pendingMaterializationSessions.add(sid);
       }
     });
     pendingCompartmentInjection = compartmentPhase.pendingCompartmentInjection;
@@ -169861,7 +169944,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
       compartmentInProgress,
       sessionMeta,
       currentTurnId,
-      flushedSessions: deps.flushedSessions,
+      pendingMaterializationSessions: deps.pendingMaterializationSessions,
       lastHeuristicsTurnId: deps.lastHeuristicsTurnId,
       autoDropToolAge: deps.autoDropToolAge,
       dropToolStructure: deps.dropToolStructure ?? true,
@@ -170107,6 +170190,14 @@ function createEventHandler2(deps) {
         if (!detection.isOverflow) {
           return;
         }
+        const sessionMeta = getOrCreateSessionMeta(deps.db, errInfo.sessionID);
+        if (sessionMeta.isSubagent) {
+          if (typeof detection.reportedLimit === "number" && detection.reportedLimit > 0) {
+            recordDetectedContextLimit(deps.db, errInfo.sessionID, detection.reportedLimit);
+          }
+          sessionLog(errInfo.sessionID, `overflow detected on subagent: reportedLimit=${detection.reportedLimit ?? "unknown"} pattern=${detection.matchedPattern ?? "n/a"} \u2014 recorded limit only (subagents cannot run historian)`);
+          return;
+        }
         const existing = getOverflowState(deps.db, errInfo.sessionID);
         recordOverflowDetected(deps.db, errInfo.sessionID, detection.reportedLimit);
         sessionLog(errInfo.sessionID, `overflow detected via session.error: reportedLimit=${detection.reportedLimit ?? "unknown"} pattern=${detection.matchedPattern ?? "n/a"} (previousRecovery=${existing.needsEmergencyRecovery})`);
@@ -170136,9 +170227,17 @@ function createEventHandler2(deps) {
         const detection = detectOverflow(info.error);
         if (detection.isOverflow) {
           try {
-            recordOverflowDetected(deps.db, info.sessionID, detection.reportedLimit);
-            sessionLog(info.sessionID, `overflow detected via message.updated: reportedLimit=${detection.reportedLimit ?? "unknown"} pattern=${detection.matchedPattern ?? "n/a"}`);
-            deps.onSessionCacheInvalidated?.(info.sessionID);
+            const metaForOverflow = getOrCreateSessionMeta(deps.db, info.sessionID);
+            if (metaForOverflow.isSubagent) {
+              if (typeof detection.reportedLimit === "number" && detection.reportedLimit > 0) {
+                recordDetectedContextLimit(deps.db, info.sessionID, detection.reportedLimit);
+              }
+              sessionLog(info.sessionID, `overflow detected on subagent via message.updated: reportedLimit=${detection.reportedLimit ?? "unknown"} pattern=${detection.matchedPattern ?? "n/a"} \u2014 recorded limit only`);
+            } else {
+              recordOverflowDetected(deps.db, info.sessionID, detection.reportedLimit);
+              sessionLog(info.sessionID, `overflow detected via message.updated: reportedLimit=${detection.reportedLimit ?? "unknown"} pattern=${detection.matchedPattern ?? "n/a"}`);
+              deps.onSessionCacheInvalidated?.(info.sessionID);
+            }
           } catch (error48) {
             sessionLog(info.sessionID, "event message.updated overflow persistence failed:", error48);
           }
@@ -170466,6 +170565,43 @@ init_compartment_runner();
 init_storage();
 init_storage_meta();
 init_storage_meta_persisted();
+
+// src/plugin/sidebar-snapshot-cache.ts
+var MAX_CACHED_SESSIONS = 100;
+var STALE_SNAPSHOT_AGE_MS = 5 * 60 * 1000;
+var cache = new BoundedSessionMap(MAX_CACHED_SESSIONS);
+function applyStickySnapshotCache(sessionId, fresh) {
+  const now = Date.now();
+  if (fresh.inputTokens > 0) {
+    cache.set(sessionId, { snapshot: fresh, cachedAt: now });
+    return fresh;
+  }
+  const cached2 = cache.peek(sessionId);
+  if (!cached2) {
+    return fresh;
+  }
+  if (now - cached2.cachedAt > STALE_SNAPSHOT_AGE_MS) {
+    cache.delete(sessionId);
+    return fresh;
+  }
+  return {
+    ...fresh,
+    usagePercentage: cached2.snapshot.usagePercentage,
+    inputTokens: cached2.snapshot.inputTokens,
+    systemPromptTokens: cached2.snapshot.systemPromptTokens,
+    compartmentTokens: cached2.snapshot.compartmentTokens,
+    factTokens: cached2.snapshot.factTokens,
+    memoryTokens: cached2.snapshot.memoryTokens,
+    conversationTokens: cached2.snapshot.conversationTokens,
+    toolCallTokens: cached2.snapshot.toolCallTokens,
+    toolDefinitionTokens: cached2.snapshot.toolDefinitionTokens
+  };
+}
+function clearSidebarSnapshotCache(sessionId) {
+  cache.delete(sessionId);
+}
+
+// src/hooks/magic-context/hook-handlers.ts
 init_logger();
 init_note_nudger();
 var TOOL_HEAVY_TURN_REMINDER_THRESHOLD = 5;
@@ -170509,7 +170645,9 @@ function createChatMessageHook(args) {
     }
     if (previousVariant !== undefined && input.variant !== undefined && previousVariant !== input.variant) {
       sessionLog(sessionId, `variant changed (${previousVariant} -> ${input.variant}), triggering flush`);
-      args.flushedSessions.add(sessionId);
+      args.historyRefreshSessions.add(sessionId);
+      args.systemPromptRefreshSessions.add(sessionId);
+      args.pendingMaterializationSessions.add(sessionId);
       args.lastHeuristicsTurnId.delete(sessionId);
     }
   };
@@ -170545,11 +170683,14 @@ function createEventHook(args) {
       args.agentBySession.delete(sessionId);
       args.recentReduceBySession.delete(sessionId);
       args.toolUsageSinceUserTurn.delete(sessionId);
-      args.flushedSessions.delete(sessionId);
+      args.historyRefreshSessions.delete(sessionId);
+      args.systemPromptRefreshSessions.delete(sessionId);
+      args.pendingMaterializationSessions.delete(sessionId);
       args.lastHeuristicsTurnId.delete(sessionId);
       args.commitSeenLastPass?.delete(sessionId);
       clearNoteNudgeState(args.db, sessionId);
       clearAutoSearchForSession(sessionId);
+      clearSidebarSnapshotCache(sessionId);
     }
   };
 }
@@ -170579,7 +170720,10 @@ function createToolExecuteAfterHook(args) {
       const todoArgs = typedInput.args;
       const todos = todoArgs?.todos;
       if (Array.isArray(todos) && todos.length > 0 && todos.every((t) => t.status === "completed" || t.status === "cancelled")) {
-        onNoteTrigger(args.db, typedInput.sessionID, "todos_complete");
+        const sessionMeta = getOrCreateSessionMeta(args.db, typedInput.sessionID);
+        if (!sessionMeta.isSubagent) {
+          onNoteTrigger(args.db, typedInput.sessionID, "todos_complete");
+        }
       }
     }
     if (typedInput.tool === "ctx_note") {
@@ -170868,8 +171012,8 @@ function createSystemPromptHashHandler(deps) {
       output.system.push(guidance);
       sessionLog(sessionId, `injected ${detectedAgent ?? "generic"} guidance into system prompt (ctxReduce=${effectiveCtxReduceEnabled}, subagent=${isSubagentSession})`);
     }
-    const isCacheBusting = deps.flushedSessions.has(sessionId);
-    if (shouldInjectDocs) {
+    const isCacheBusting = deps.systemPromptRefreshSessions.has(sessionId);
+    if (shouldInjectDocs && !isSubagentSession) {
       const hasCached = cachedDocsBySession.has(sessionId);
       if (!hasCached || isCacheBusting) {
         const docsContent = readProjectDocs(deps.directory);
@@ -170885,7 +171029,7 @@ function createSystemPromptHashHandler(deps) {
         output.system.push(docsBlock);
       }
     }
-    if (deps.experimentalUserMemories) {
+    if (deps.experimentalUserMemories && !isSubagentSession) {
       const hasCachedProfile = cachedUserProfileBySession.has(sessionId);
       if (!hasCachedProfile || isCacheBusting) {
         const memories = getActiveUserMemories(deps.db);
@@ -170907,7 +171051,7 @@ ${items}
         output.system.push(profileBlock);
       }
     }
-    if (deps.experimentalPinKeyFiles) {
+    if (deps.experimentalPinKeyFiles && !isSubagentSession) {
       const hasCachedKeyFiles = cachedKeyFilesBySession.has(sessionId);
       if (!hasCachedKeyFiles || isCacheBusting) {
         const keyFileEntries = getKeyFiles(deps.db, sessionId);
@@ -171005,7 +171149,9 @@ ${sections.join(`
     const previousHash = sessionMeta.systemPromptHash;
     if (previousHash !== "" && previousHash !== "0" && previousHash !== currentHash) {
       sessionLog(sessionId, `system prompt hash changed: ${previousHash} \u2192 ${currentHash} (len=${systemContent.length}), triggering flush`);
-      deps.flushedSessions.add(sessionId);
+      deps.historyRefreshSessions.add(sessionId);
+      deps.systemPromptRefreshSessions.add(sessionId);
+      deps.pendingMaterializationSessions.add(sessionId);
       deps.lastHeuristicsTurnId.delete(sessionId);
     } else if (previousHash === "" || previousHash === "0") {
       sessionLog(sessionId, `system prompt hash initialized: ${currentHash} (len=${systemContent.length})`);
@@ -171019,6 +171165,9 @@ ${sections.join(`
     } else if (Math.abs(sessionMeta.systemPromptTokens - systemPromptTokens) > 50) {
       updateSessionMeta(deps.db, sessionId, { systemPromptTokens });
     }
+    if (isCacheBusting) {
+      deps.systemPromptRefreshSessions.delete(sessionId);
+    }
   };
   return {
     handler,
@@ -171077,7 +171226,9 @@ function createMagicContextHook(deps) {
   let lastScheduleCheckMs = 0;
   const getHistorianChunkTokens = () => deriveHistorianChunkTokens(resolveHistorianContextLimit(deps.config.historian?.model));
   const nudgePlacements = createNudgePlacementStore(db);
-  const flushedSessions = new Set;
+  const historyRefreshSessions = deps.liveSessionState?.historyRefreshSessions ?? new Set;
+  const systemPromptRefreshSessions = deps.liveSessionState?.systemPromptRefreshSessions ?? new Set;
+  const pendingMaterializationSessions = deps.liveSessionState?.pendingMaterializationSessions ?? new Set;
   const lastHeuristicsTurnId = new Map;
   const commitSeenLastPass = new Map;
   const variantBySession = deps.liveSessionState?.variantBySession ?? new Map;
@@ -171116,14 +171267,16 @@ function createMagicContextHook(deps) {
     autoDropToolAge: deps.config.auto_drop_tool_age ?? 100,
     dropToolStructure: deps.config.drop_tool_structure ?? true,
     clearReasoningAge: deps.config.clear_reasoning_age ?? 50,
-    flushedSessions,
+    historyRefreshSessions,
+    pendingMaterializationSessions,
     lastHeuristicsTurnId,
     commitSeenLastPass,
     client: deps.client,
     directory: deps.directory,
     memoryConfig: deps.config.memory ? {
       enabled: deps.config.memory.enabled,
-      injectionBudgetTokens: deps.config.memory.injection_budget_tokens
+      injectionBudgetTokens: deps.config.memory.injection_budget_tokens,
+      autoPromote: deps.config.memory.auto_promote ?? true
     } : undefined,
     getHistorianChunkTokens,
     historyBudgetPercentage: deps.config.history_budget_percentage,
@@ -171229,7 +171382,11 @@ function createMagicContextHook(deps) {
         return;
       return resolveContextLimit(model.providerID, model.modelID);
     },
-    onFlush: (sessionId) => flushedSessions.add(sessionId),
+    onFlush: (sessionId) => {
+      historyRefreshSessions.add(sessionId);
+      systemPromptRefreshSessions.add(sessionId);
+      pendingMaterializationSessions.add(sessionId);
+    },
     executeRecomp: async (sessionId, options) => executeContextRecomp({
       client: deps.client,
       db,
@@ -171243,8 +171400,11 @@ function createMagicContextHook(deps) {
       })(),
       getNotificationParams: () => getLiveNotificationParams(sessionId, liveModelBySession, variantBySession, agentBySession),
       historianTwoPass: deps.config.historian?.two_pass === true,
+      memoryEnabled: deps.config.memory?.enabled,
+      autoPromote: deps.config.memory?.auto_promote ?? true,
       onInjectionCacheCleared: (sid) => {
-        flushedSessions.add(sid);
+        historyRefreshSessions.add(sid);
+        pendingMaterializationSessions.add(sid);
       }
     }, options),
     sendNotification: async (sessionId, text, params) => {
@@ -171283,7 +171443,9 @@ function createMagicContextHook(deps) {
     dreamerEnabled: deps.config.dreamer?.enabled === true,
     injectDocs: deps.config.dreamer?.inject_docs !== false,
     directory: deps.directory,
-    flushedSessions,
+    historyRefreshSessions,
+    systemPromptRefreshSessions,
+    pendingMaterializationSessions,
     lastHeuristicsTurnId,
     experimentalUserMemories: deps.config.dreamer?.user_memories?.enabled,
     experimentalPinKeyFiles: deps.config.dreamer?.pin_key_files?.enabled ?? false,
@@ -171300,7 +171462,9 @@ function createMagicContextHook(deps) {
     agentBySession,
     recentReduceBySession,
     toolUsageSinceUserTurn,
-    flushedSessions,
+    historyRefreshSessions,
+    systemPromptRefreshSessions,
+    pendingMaterializationSessions,
     lastHeuristicsTurnId,
     commitSeenLastPass,
     client: deps.client,
@@ -171318,7 +171482,9 @@ function createMagicContextHook(deps) {
       liveModelBySession,
       variantBySession,
       agentBySession,
-      flushedSessions,
+      historyRefreshSessions,
+      systemPromptRefreshSessions,
+      pendingMaterializationSessions,
       lastHeuristicsTurnId,
       ctxReduceEnabled
     }),
@@ -171436,6 +171602,166 @@ function truncateError(name2, code, message, maxLen = 240) {
 init_project_identity();
 init_storage();
 init_read_session_formatting();
+
+// src/hooks/magic-context/tokenizer-calibration.ts
+var CALIBRATION_TABLE = [
+  { prefix: "anthropic/claude-opus-4-7", systemRatio: 1.51, toolsRatio: 1.57 },
+  { prefix: "anthropic/claude-opus-4.7", systemRatio: 1.51, toolsRatio: 1.57 },
+  { prefix: "anthropic/claude-opus-4-5", systemRatio: 1.02, toolsRatio: 1.16 },
+  { prefix: "anthropic/claude-opus-4.5", systemRatio: 1.02, toolsRatio: 1.16 },
+  { prefix: "anthropic/claude-opus-4-6", systemRatio: 1.02, toolsRatio: 1.16 },
+  { prefix: "anthropic/claude-opus-4.6", systemRatio: 1.02, toolsRatio: 1.16 },
+  { prefix: "anthropic/claude-sonnet-4-5", systemRatio: 1.02, toolsRatio: 1.16 },
+  { prefix: "anthropic/claude-sonnet-4.5", systemRatio: 1.02, toolsRatio: 1.16 },
+  { prefix: "anthropic/claude-sonnet-4-6", systemRatio: 1.02, toolsRatio: 1.14 },
+  { prefix: "anthropic/claude-sonnet-4.6", systemRatio: 1.02, toolsRatio: 1.14 },
+  { prefix: "anthropic/claude-haiku-4-5", systemRatio: 1.02, toolsRatio: 1.16 },
+  { prefix: "anthropic/claude-haiku-4.5", systemRatio: 1.02, toolsRatio: 1.16 },
+  { prefix: "openrouter/anthropic/claude-opus-4-7", systemRatio: 1.51, toolsRatio: 1.57 },
+  { prefix: "openrouter/anthropic/claude-opus-4.7", systemRatio: 1.51, toolsRatio: 1.57 },
+  { prefix: "github-copilot/claude-opus-4-7", systemRatio: 1.51, toolsRatio: 1.57 },
+  { prefix: "github-copilot/claude-opus-4.7", systemRatio: 1.51, toolsRatio: 1.57 },
+  { prefix: "openrouter/anthropic/claude-sonnet-4.6", systemRatio: 1.02, toolsRatio: 1.14 },
+  { prefix: "github-copilot/claude-sonnet-4.6", systemRatio: 1.02, toolsRatio: 1.14 },
+  { prefix: "github-copilot/claude-sonnet-4.5", systemRatio: 1.02, toolsRatio: 1.16 },
+  { prefix: "github-copilot/claude-opus-4.5", systemRatio: 1.02, toolsRatio: 1.16 },
+  { prefix: "github-copilot/claude-haiku-4.5", systemRatio: 1.02, toolsRatio: 1.16 },
+  { prefix: "openai/gpt-5", systemRatio: 1, toolsRatio: 0.84 },
+  { prefix: "xai/grok-4", systemRatio: 0.82, toolsRatio: 0.88 },
+  { prefix: "xai/grok-code-fast", systemRatio: 0.82, toolsRatio: 0.89 },
+  { prefix: "cerebras/qwen-3-235b", systemRatio: 1, toolsRatio: 1.1 },
+  { prefix: "cerebras/zai-glm-4.7", systemRatio: 1, toolsRatio: 1.09 },
+  { prefix: "cerebras/gpt-oss-120b", systemRatio: 0.84, toolsRatio: 0.79 },
+  {
+    prefix: "fireworks-ai/accounts/fireworks/models/glm-5p1",
+    systemRatio: 1,
+    toolsRatio: 1.06
+  },
+  {
+    prefix: "fireworks-ai/accounts/fireworks/models/deepseek-v3p2",
+    systemRatio: 1.05,
+    toolsRatio: 1.09
+  },
+  { prefix: "opencode-go/glm-5.1", systemRatio: 1, toolsRatio: 1.06 },
+  { prefix: "opencode-go/glm-5", systemRatio: 1, toolsRatio: 1.06 },
+  { prefix: "opencode-go/kimi-k2.6", systemRatio: 0.87, toolsRatio: 0.86 }
+];
+var NEUTRAL = { systemRatio: 1, toolsRatio: 1 };
+function resolveModelCalibration(providerId, modelId) {
+  if (!providerId || !modelId)
+    return NEUTRAL;
+  const key = `${providerId}/${modelId}`.toLowerCase();
+  let best = null;
+  for (const entry of CALIBRATION_TABLE) {
+    const prefix = entry.prefix.toLowerCase();
+    if (!key.startsWith(prefix))
+      continue;
+    if (!best || prefix.length > best.prefix.length) {
+      best = entry;
+    }
+  }
+  return best ?? NEUTRAL;
+}
+function calibrateBuckets(input) {
+  const empty = {
+    systemTokens: 0,
+    toolDefinitionTokens: 0,
+    compartmentTokens: 0,
+    factTokens: 0,
+    memoryTokens: 0,
+    conversationTokens: 0,
+    toolCallTokens: 0
+  };
+  if (input.inputTokens <= 0)
+    return empty;
+  let calibratedSystem = Math.round(input.systemLocal * input.calibration.systemRatio);
+  let calibratedToolDefs = Math.round(input.toolDefsLocal * input.calibration.toolsRatio);
+  let compartments = Math.max(0, input.compartmentsLocal);
+  let facts = Math.max(0, input.factsLocal);
+  let memories = Math.max(0, input.memoriesLocal);
+  const nonResidualTotal = calibratedSystem + calibratedToolDefs + compartments + facts + memories;
+  if (nonResidualTotal > input.inputTokens) {
+    const ratio = input.inputTokens / nonResidualTotal;
+    calibratedSystem = Math.round(calibratedSystem * ratio);
+    calibratedToolDefs = Math.round(calibratedToolDefs * ratio);
+    compartments = Math.round(compartments * ratio);
+    facts = Math.round(facts * ratio);
+    memories = Math.round(memories * ratio);
+  }
+  const residualTarget = Math.max(0, input.inputTokens - calibratedSystem - calibratedToolDefs - compartments - facts - memories);
+  const residualLocalSum = input.conversationLocal + input.toolCallsLocal;
+  let conversation;
+  let toolCalls;
+  if (residualLocalSum <= 0) {
+    conversation = residualTarget;
+    toolCalls = 0;
+  } else {
+    const scale = residualTarget / residualLocalSum;
+    conversation = Math.round(input.conversationLocal * scale);
+    toolCalls = Math.round(input.toolCallsLocal * scale);
+  }
+  const provisionalSum = calibratedSystem + calibratedToolDefs + compartments + facts + memories + conversation + toolCalls;
+  let delta = input.inputTokens - provisionalSum;
+  if (delta !== 0) {
+    if (conversation >= toolCalls) {
+      const adjusted = Math.max(0, conversation + delta);
+      delta -= adjusted - conversation;
+      conversation = adjusted;
+    } else {
+      const adjusted = Math.max(0, toolCalls + delta);
+      delta -= adjusted - toolCalls;
+      toolCalls = adjusted;
+    }
+  }
+  if (delta < 0) {
+    const get = (name2) => {
+      if (name2 === "system")
+        return calibratedSystem;
+      if (name2 === "toolDefs")
+        return calibratedToolDefs;
+      if (name2 === "compartments")
+        return compartments;
+      if (name2 === "facts")
+        return facts;
+      return memories;
+    };
+    const subtract = (name2, amount) => {
+      if (name2 === "system")
+        calibratedSystem -= amount;
+      else if (name2 === "toolDefs")
+        calibratedToolDefs -= amount;
+      else if (name2 === "compartments")
+        compartments -= amount;
+      else if (name2 === "facts")
+        facts -= amount;
+      else
+        memories -= amount;
+    };
+    const buckets = ["system", "toolDefs", "compartments", "facts", "memories"];
+    buckets.sort((a, b) => get(b) - get(a));
+    for (const name2 of buckets) {
+      if (delta >= 0)
+        break;
+      const value = get(name2);
+      if (value <= 0)
+        continue;
+      const adjustment = Math.min(value, -delta);
+      subtract(name2, adjustment);
+      delta += adjustment;
+    }
+  }
+  return {
+    systemTokens: calibratedSystem,
+    toolDefinitionTokens: calibratedToolDefs,
+    compartmentTokens: compartments,
+    factTokens: facts,
+    memoryTokens: memories,
+    conversationTokens: conversation,
+    toolCallTokens: toolCalls
+  };
+}
+
+// src/plugin/rpc-handlers.ts
 init_logger();
 init_rpc_notifications();
 function getDb() {
@@ -171505,8 +171831,7 @@ function buildSidebarSnapshot(db, sessionId, directory, liveSessionState) {
     memoryTokens: 0,
     conversationTokens: 0,
     toolCallTokens: 0,
-    toolDefinitionTokens: 0,
-    overheadTokens: 0
+    toolDefinitionTokens: 0
   };
   try {
     const projectIdentity = resolveProjectIdentity(directory);
@@ -171580,23 +171905,37 @@ ${c.content}
       } catch {}
     }
     const injectedInMessages = compartmentTokens + factTokens + memoryTokens;
-    const conversationTokens = Math.max(0, messagesBlockTokens - injectedInMessages);
-    const toolCallTokens = Math.max(0, toolCallTokensRaw);
+    const conversationLocal = Math.max(0, messagesBlockTokens - injectedInMessages);
+    const toolCallsLocal = Math.max(0, toolCallTokensRaw);
     let measuredToolDefTokens = 0;
+    let activeProviderID;
+    let activeModelID;
     if (liveSessionState) {
       const model = liveSessionState.liveModelBySession.get(sessionId);
       const agent = liveSessionState.agentBySession.get(sessionId);
       if (model) {
+        activeProviderID = model.providerID;
+        activeModelID = model.modelID;
         measuredToolDefTokens = getMeasuredToolDefinitionTokens(model.providerID, model.modelID, agent) ?? 0;
       }
     }
-    const toolDefinitionTokens = measuredToolDefTokens;
-    const overheadTokens = Math.max(0, inputTokens - systemPromptTokens - messagesBlockTokens - toolCallTokens - measuredToolDefTokens);
-    return {
+    const calibration = resolveModelCalibration(activeProviderID, activeModelID);
+    const calibrated = calibrateBuckets({
+      inputTokens,
+      systemLocal: systemPromptTokens,
+      toolDefsLocal: measuredToolDefTokens,
+      compartmentsLocal: compartmentTokens,
+      factsLocal: factTokens,
+      memoriesLocal: memoryTokens,
+      conversationLocal,
+      toolCallsLocal,
+      calibration
+    });
+    const fresh = {
       sessionId,
       usagePercentage,
       inputTokens,
-      systemPromptTokens,
+      systemPromptTokens: calibrated.systemTokens,
       compartmentCount,
       factCount,
       memoryCount,
@@ -171609,14 +171948,14 @@ ${c.content}
       cacheTtl,
       lastDreamerRunAt,
       projectIdentity,
-      compartmentTokens,
-      factTokens,
-      memoryTokens,
-      conversationTokens,
-      toolCallTokens,
-      toolDefinitionTokens,
-      overheadTokens
+      compartmentTokens: calibrated.compartmentTokens,
+      factTokens: calibrated.factTokens,
+      memoryTokens: calibrated.memoryTokens,
+      conversationTokens: calibrated.conversationTokens,
+      toolCallTokens: calibrated.toolCallTokens,
+      toolDefinitionTokens: calibrated.toolDefinitionTokens
     };
+    return applyStickySnapshotCache(sessionId, fresh);
   } catch (err) {
     log("[rpc] sidebar-snapshot error:", err);
     return empty;
@@ -171788,7 +172127,13 @@ function registerRpcHandlers(rpcServer, args) {
       historianChunkTokens,
       historianTimeoutMs: config2.historian_timeout_ms ?? DEFAULT_HISTORIAN_TIMEOUT_MS2,
       directory,
-      getNotificationParams: () => getNotificationParams(sessionId)
+      memoryEnabled: config2.memory?.enabled,
+      autoPromote: config2.memory?.auto_promote ?? true,
+      getNotificationParams: () => getNotificationParams(sessionId),
+      onInjectionCacheCleared: (sid) => {
+        liveSessionState.historyRefreshSessions.add(sid);
+        liveSessionState.pendingMaterializationSessions.add(sid);
+      }
     }).then((result) => {
       sendIgnoredMessage2(args.client, sessionId, result, getNotificationParams(sessionId)).catch(() => {});
     }).catch((error48) => {