@cortexkit/magic-context 0.49.23 → 0.49.25

package/dist/index.js

@@ -25260,6 +25260,29 @@ function getOpenCodeV2ActiveGeneration(slot) {
     return;
   }
 }
+function openCodeV2SlotSpec(spec, platform = process.platform) {
+  if (platform !== "win32")
+    return spec;
+  return Array.from(spec, (char) => '<>:"|?*'.includes(char) || char.charCodeAt(0) < 32 ? "_" : char).join("");
+}
+function getOpenCodePluginInstallRoots(hostGeneration, config, npmCacheDir = getOpenCodeV2NpmCacheDir(), platform = process.platform) {
+  const configured = openCodeV2SlotSpec(readConfiguredOpenCodePluginSpec(config), platform);
+  const v2 = listOpenCodeV2PluginCacheSlots(npmCacheDir).sort((a, b) => Number(b.spec === configured) - Number(a.spec === configured)).map((slot) => getOpenCodeV2ActiveGeneration(slot.slot)).filter((generation) => generation !== undefined);
+  const v1 = getOpenCodePluginCacheRoots();
+  return hostGeneration === "v2" ? [...v2, ...v1] : [...v1, ...v2];
+}
+function getOpenCodeLoadedPluginInstallRoots(hostGeneration, config, npmCacheDir = getOpenCodeV2NpmCacheDir(), platform = process.platform) {
+  let loaded;
+  if (hostGeneration === "v2") {
+    const configured = openCodeV2SlotSpec(readConfiguredOpenCodePluginSpec(config), platform);
+    const generation = getOpenCodeV2ActiveGeneration(getOpenCodeV2PluginCacheSlot(npmCacheDir, configured));
+    loaded = generation === undefined ? [] : [generation];
+  } else {
+    loaded = getOpenCodePluginCacheRoots();
+  }
+  const others = getOpenCodePluginInstallRoots(hostGeneration, config, npmCacheDir, platform).filter((root) => !loaded.includes(root));
+  return { loaded, others };
+}
 function readOpenCodeV2CachedPluginVersion(slot) {
   const generation = getOpenCodeV2ActiveGeneration(slot);
   if (!generation)
@@ -33114,6 +33137,51 @@ var init_read_session_formatting = __esm(() => {
   PROMPT_TOKEN_COUNT_BYTES = 8 * 1024 * 1024;
 });
 
+// ../plugin/src/shared/bounded-session-map.ts
+class BoundedSessionMap {
+  maxEntries;
+  store = new Map;
+  constructor(maxEntries) {
+    if (!Number.isFinite(maxEntries) || maxEntries < 1) {
+      throw new Error(`BoundedSessionMap: maxEntries must be >= 1, got ${maxEntries}`);
+    }
+    this.maxEntries = maxEntries;
+  }
+  get(sessionId) {
+    const value = this.store.get(sessionId);
+    if (value === undefined)
+      return;
+    this.store.delete(sessionId);
+    this.store.set(sessionId, value);
+    return value;
+  }
+  peek(sessionId) {
+    return this.store.get(sessionId);
+  }
+  has(sessionId) {
+    return this.store.has(sessionId);
+  }
+  set(sessionId, value) {
+    if (this.store.has(sessionId)) {
+      this.store.delete(sessionId);
+    } else if (this.store.size >= this.maxEntries) {
+      const oldest = this.store.keys().next().value;
+      if (oldest !== undefined)
+        this.store.delete(oldest);
+    }
+    this.store.set(sessionId, value);
+  }
+  delete(sessionId) {
+    return this.store.delete(sessionId);
+  }
+  clear() {
+    this.store.clear();
+  }
+  get size() {
+    return this.store.size;
+  }
+}
+
 // ../plugin/src/shared/stable-json.ts
 function stableStringify(value, seen = new WeakSet) {
   const pieces = [];
@@ -33168,36 +33236,122 @@ function writeStable(value, seen, write) {
 }
 
 // ../plugin/src/features/magic-context/tool-definition-tokens.ts
+function agentKey(agentName) {
+  return agentName && agentName.length > 0 ? agentName : "default";
+}
 function keyFor(providerID, modelID, agentName) {
-  const agent = agentName && agentName.length > 0 ? agentName : "default";
-  return `${providerID}/${modelID}/${agent}`;
+  return `${providerID}/${modelID}/${agentKey(agentName)}`;
+}
+function routeFor(providerID, modelID, agentName) {
+  const key = keyFor(providerID, modelID, agentName);
+  let route = routes.get(key);
+  if (!route) {
+    route = {
+      providerID,
+      modelID,
+      agentName: agentKey(agentName),
+      tools: new Map,
+      live: false,
+      clock: 0,
+      lastWallAt: Date.now(),
+      oldestFireAt: Number.POSITIVE_INFINITY,
+      retired: new Map,
+      legacyRows: new Set
+    };
+    routes.set(key, route);
+  }
+  return { key, route };
+}
+function advanceClock(route) {
+  const now = Date.now();
+  const gap = Math.min(Math.max(now - route.lastWallAt, 0), MAX_ACTIVITY_GAP_MS);
+  route.clock += gap;
+  route.lastWallAt = Math.max(route.lastWallAt, now);
+  return route.clock;
+}
+function readWindowedSince(db) {
+  try {
+    const row = db.prepare("SELECT value FROM schema_migrations_meta WHERE key = ?").get(WINDOWED_SINCE_KEY);
+    if (!row)
+      return;
+    const value = Number(row.value);
+    return Number.isFinite(value) ? value : undefined;
+  } catch {
+    return;
+  }
+}
+function markWindowed() {
+  if (windowedSince !== undefined || !persistenceDb)
+    return;
+  try {
+    persistenceDb.prepare("INSERT OR IGNORE INTO schema_migrations_meta (key, value) VALUES (?, ?)").run(WINDOWED_SINCE_KEY, String(boundAt));
+    windowedSince = readWindowedSince(persistenceDb);
+  } catch {}
 }
 function setDatabase(db) {
+  const rebound = persistenceDb !== null && persistenceDb !== db;
   persistenceDb = db;
+  boundAt = Date.now();
   cachedInsertStmt = null;
+  cachedDeleteStmt = null;
+  if (rebound) {
+    for (const route of routes.values()) {
+      for (const slot of route.tools.values()) {
+        slot.persisted = false;
+        slot.writeFailedAt = undefined;
+      }
+      for (const retired of route.retired.values())
+        retired.rowKept = false;
+      route.legacyRows.clear();
+    }
+  }
+  windowedSince = readWindowedSince(db);
+  if (windowedSince !== undefined)
+    return;
+  try {
+    if (!db.prepare("SELECT 1 FROM tool_definition_measurements LIMIT 1").get())
+      markWindowed();
+  } catch {}
 }
 function loadToolDefinitionMeasurements(db) {
   let rows = [];
   try {
-    rows = db.prepare("SELECT provider_id, model_id, agent_name, tool_id, token_count FROM tool_definition_measurements").all();
+    rows = db.prepare("SELECT provider_id, model_id, agent_name, tool_id, token_count, recorded_at FROM tool_definition_measurements").all();
   } catch {
     return;
   }
+  const since = readWindowedSince(db);
+  const loadedAt = new Map;
   for (const row of rows) {
-    const key = keyFor(row.provider_id, row.model_id, row.agent_name);
-    let inner = measurements.get(key);
-    if (!inner) {
-      inner = new Map;
-      measurements.set(key, inner);
-    }
-    inner.set(row.tool_id, row.token_count);
+    const { route } = routeFor(row.provider_id, row.model_id, row.agent_name);
+    if (route.live)
+      continue;
+    let now = loadedAt.get(route);
+    if (now === undefined) {
+      now = advanceClock(route);
+      loadedAt.set(route, now);
+    }
+    const legacy = since === undefined || !(Number(row.recorded_at) >= since);
+    route.tools.set(row.tool_id, {
+      tokens: row.token_count,
+      fingerprint: undefined,
+      lastFireAt: now,
+      legacy,
+      persisted: !legacy
+    });
+    route.oldestFireAt = Math.min(route.oldestFireAt, now);
+    if (legacy)
+      route.legacyRows.add(row.tool_id);
+    else
+      route.legacyRows.delete(row.tool_id);
   }
 }
-var measurements, fingerprints, persistenceDb = null, cachedInsertStmt = null;
+var ACTIVITY_WINDOW_MS, MAX_ACTIVITY_GAP_MS = 60000, WINDOWED_SINCE_KEY = "tool_definition_measurements:windowed_since", routes, sessionFlights, persistenceDb = null, windowedSince, boundAt = 0, cachedInsertStmt = null, cachedDeleteStmt = null;
 var init_tool_definition_tokens = __esm(() => {
   init_read_session_formatting();
-  measurements = new Map;
-  fingerprints = new Map;
+  ACTIVITY_WINDOW_MS = 10 * 60000;
+  routes = new Map;
+  sessionFlights = new BoundedSessionMap(1000);
 });
 
 // ../plugin/src/features/magic-context/tool-owner-backfill.ts
@@ -34245,6 +34399,73 @@ var init_historian_tool_expansions = __esm(() => {
   init_historian_tool_template();
 });
 
+// ../plugin/src/hooks/magic-context/ask-answer-notice.ts
+function reminderBodies(text) {
+  reminderEnvelopePattern.lastIndex = 0;
+  const bodies = [];
+  for (const match of text.matchAll(reminderEnvelopePattern)) {
+    const body = match[1];
+    if (body !== undefined)
+      bodies.push(body);
+  }
+  return bodies;
+}
+function parseAnswerBody(body) {
+  const lines = body.replace(/\r\n/g, `
+`).replace(/^\n+|\n+$/g, "");
+  if (!ANSWER_HEADER_PREFIX.test(lines))
+    return null;
+  if (lines.includes("The user dismissed this question"))
+    return null;
+  const framed = ANSWER_TRAILER.exec(lines);
+  if (framed === null)
+    return null;
+  const content = framed[1] ?? "";
+  const narrated = ANSWER_ANSWER_LINE.exec(content);
+  if (narrated !== null) {
+    const question = narrated[2] ?? "";
+    const answer = content.slice(narrated[0].length);
+    return closedAnswer(question, answer);
+  }
+  const bare = ANSWER_QUESTION_LINE.exec(content);
+  if (bare !== null) {
+    const question = bare[1] ?? "";
+    const answer = content.slice(bare[0].length);
+    return closedAnswer(question, answer);
+  }
+  return null;
+}
+function closedAnswer(question, answer) {
+  if (question.trim().length === 0)
+    return null;
+  if (answer.trim().length === 0)
+    return null;
+  return { question, answer };
+}
+function extractAskAnswerNotices(text) {
+  const notices = [];
+  for (const body of reminderBodies(text)) {
+    const notice = parseAnswerBody(body);
+    if (notice !== null)
+      notices.push(notice);
+  }
+  return notices;
+}
+function formatAskAnswerNotice(notice) {
+  return `U (answered "${notice.question}"): ${notice.answer}`;
+}
+function askAnswerLines(text) {
+  return extractAskAnswerNotices(text).map(formatAskAnswerNotice);
+}
+var ANSWER_HEADER_PREFIX, ANSWER_TRAILER, ANSWER_ANSWER_LINE, ANSWER_QUESTION_LINE, reminderEnvelopePattern;
+var init_ask_answer_notice = __esm(() => {
+  ANSWER_HEADER_PREFIX = /^Inbox [^\n]* notice from user via user_answer \(user_answer\)/;
+  ANSWER_TRAILER = /\n([\s\S]*?)\nThis ask is now closed; no dismiss is needed\. Continue accordingly\.$/;
+  ANSWER_ANSWER_LINE = /^The user answered your parked question (\S+)\.\nQuestion: ([^\n]+)\nAnswer: /;
+  ANSWER_QUESTION_LINE = /^Question: ([^\n]+)\nAnswer: /;
+  reminderEnvelopePattern = /<system-reminder>([\s\S]*?)<\/system-reminder>/gi;
+});
+
 // ../plugin/src/hooks/magic-context/host-served-rows.ts
 function markHostUnservedRow(target) {
   Object.defineProperty(target, HOST_UNSERVED_ROW, {
@@ -34939,6 +35160,9 @@ function withRawMessageProvider(sessionId, provider, fn) {
 function cleanUserText(text) {
   return stripOutsideSteeringWrappers(text, (segment) => removeSystemReminders(segment).replace(OMO_INTERNAL_INITIATOR_MARKER, "")).trim();
 }
+function answerLineParts(rawText) {
+  return askAnswerLines(rawText).map(normalizeText).filter((value) => value.length > 0);
+}
 function hasMeaningfulChunkUserText(parts) {
   for (const part of parts) {
     if (part === null || typeof part !== "object")
@@ -34955,7 +35179,7 @@ function hasMeaningfulChunkUserText(parts) {
       continue;
     return true;
   }
-  return false;
+  return parts.some((part) => part !== null && typeof part === "object" && part.type === "text" && typeof part.text === "string" && part.ignored !== true && askAnswerLines(part.text).length > 0);
 }
 function withRawSessionMessageCache(fn) {
   const outerCache = activeRawMessageCache;
@@ -35701,8 +35925,10 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
     }
     const role = compactRole(msg.role);
     const textParts = extractTexts(msg.parts).map((t) => msg.role === "user" ? cleanUserText(t) : t).map(normalizeText).filter((value) => value.length > 0);
+    const answerParts = msg.role === "user" ? extractTexts(msg.parts).flatMap((text) => answerLineParts(text)) : [];
+    const userParts = answerParts.length > 0 ? [...textParts, ...answerParts] : textParts;
     const allParts = options.expand === false ? [
-      ...textParts,
+      ...userParts,
       ...textParts.length === 0 ? extractToolCallSummaries(msg.parts) : []
     ] : msg.parts.flatMap((part) => {
       if (expandedResults.has(part))
@@ -35711,6 +35937,9 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
       if (expansion !== null)
         return [`TC: ${expansion}`];
       const texts = extractTexts([part]).map((t) => msg.role === "user" ? cleanUserText(t) : t).map(normalizeText).filter(Boolean);
+      if (msg.role === "user") {
+        texts.push(...extractTexts([part]).flatMap((text) => answerLineParts(text)));
+      }
       return texts.length ? texts : textParts.length === 0 ? extractToolCallSummaries([part]) : [];
     });
     const compacted = compactTextForSummary(allParts.join(" / "), msg.role);
@@ -35719,7 +35948,7 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
       recordFilteredNoise(meta);
       continue;
     }
-    const msgHasNarrative = textParts.length > 0;
+    const msgHasNarrative = userParts.length > 0;
     if (currentBlock && currentBlock.role === role) {
       currentBlock.endOrdinal = msg.ordinal;
       currentBlock.parts.push(text);
@@ -35824,6 +36053,7 @@ var BLOCK_TOKEN_MEMO_MAX = 2048, blockTokenMemo, activeRawMessageCache = null, a
 var init_read_session_chunk = __esm(async () => {
   init_historian_tool_expansions();
   init_logger();
+  init_ask_answer_notice();
   init_read_session_formatting();
   init_read_session_true_raw_tokens();
   init_system_injection_stripper();
@@ -52462,8 +52692,8 @@ async function runIssueFlow2(options = {}, deps = { collectDiagnostics }) {
     return 1;
   }
 }
-function checkLocalEmbeddingRuntimeForDoctor(runtimePreference = "auto") {
-  const runtime = checkLocalEmbeddingRuntime(getOpenCodePluginCacheRoots(), process.platform, process.arch, runtimePreference);
+function checkLocalEmbeddingRuntimeForDoctor(installRoots, runtimePreference = "auto") {
+  const runtime = checkLocalEmbeddingRuntime(installRoots, process.platform, process.arch, runtimePreference);
   if (runtime.state === "wasm-selected") {
     log3.warn(formatLocalEmbeddingRuntimeWasmSelected(runtime));
     return { issues: 0 };
@@ -52483,15 +52713,15 @@ function checkLocalEmbeddingRuntimeForDoctor(runtimePreference = "auto") {
   log3.success("Embedding provider: local (native runtime selected and OK; Xenova/all-MiniLM-L6-v2 bundled)");
   return { issues: 0 };
 }
-async function checkEmbeddingConfig(magicContextConfigPath) {
+async function checkEmbeddingConfig(magicContextConfigPath, installRoots) {
   if (!existsSync49(magicContextConfigPath)) {
-    return checkLocalEmbeddingRuntimeForDoctor();
+    return checkLocalEmbeddingRuntimeForDoctor(installRoots);
   }
   let rawText;
   try {
     const raw = loadRawConfigFile({ configPath: magicContextConfigPath, tier: "user" });
     if (!raw)
-      return checkLocalEmbeddingRuntimeForDoctor();
+      return checkLocalEmbeddingRuntimeForDoctor(installRoots);
     rawText = raw.text;
   } catch {
     log3.warn("Could not read magic-context.jsonc for embedding check");
@@ -52516,7 +52746,7 @@ async function checkEmbeddingConfig(magicContextConfigPath) {
   }
   if (provider === undefined || provider === "local") {
     const runtimePreference = embedding?.local_runtime === "native" || embedding?.local_runtime === "wasm" ? embedding.local_runtime : "auto";
-    return checkLocalEmbeddingRuntimeForDoctor(runtimePreference);
+    return checkLocalEmbeddingRuntimeForDoctor(installRoots, runtimePreference);
   }
   if (provider === "synapse") {
     const loaded = loadPluginConfig(process.cwd());
@@ -53195,7 +53425,16 @@ async function runDoctor2(options = {}) {
       }
     } catch {}
   }
-  const embeddingCheck = await checkEmbeddingConfig(paths.magicContextConfig);
+  let embeddingHostConfig = null;
+  try {
+    if (paths.opencodeConfigFormat !== "none")
+      embeddingHostConfig = import_comment_json11.parse(readFileSync32(paths.opencodeConfig, "utf-8"));
+  } catch {}
+  const embeddingInstalls = getOpenCodeLoadedPluginInstallRoots(hostGeneration, embeddingHostConfig);
+  const unusedInstalls = embeddingInstalls.others.filter((root) => existsSync49(root));
+  if (unusedInstalls.length > 0)
+    log3.info(`Local embedding runtime: checked only the copy ${hostGeneration === "v2" ? "OpenCode 2" : "OpenCode 1"} loads; other installed copies (not loaded, not checked): ${unusedInstalls.join(", ")}`);
+  const embeddingCheck = await checkEmbeddingConfig(paths.magicContextConfig, embeddingInstalls.loaded);
   issues += embeddingCheck.issues;
   if (embeddingCheck.issues > 0)
     failCount += embeddingCheck.issues;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cortexkit/magic-context",
-    "version": "0.49.23",
+    "version": "0.49.25",
     "description": "Unified CLI for Magic Context — setup, doctor, and migration across OpenCode, Pi, and OMP",
     "keywords": [
         "opencode",