@cortexkit/magic-context 0.49.24 → 0.49.26

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)
@@ -27266,6 +27289,9 @@ function readStoreStamp(db) {
 function sameStoreStamp(left, right) {
   return left !== null && right !== null && left.dataVersion === right.dataVersion && left.totalChanges === right.totalChanges && left.schemaVersion === right.schemaVersion;
 }
+function forgetRawSessionOrdinalWatermark(sessionId) {
+  ordinalWatermarkEpochs.set(sessionId, (ordinalWatermarkEpochs.get(sessionId) ?? 0) + 1);
+}
 function compareOrdinalKeys(left, right) {
   if (left.timeCreated !== right.timeCreated)
     return left.timeCreated < right.timeCreated ? -1 : 1;
@@ -27283,12 +27309,31 @@ function countEligibleOrdinals(db, sessionId, after, through) {
   ordinalJsonRowsRead += visited;
   return typeof row?.eligible === "number" ? row.eligible : 0;
 }
+function forgetRawSessionSummaryRows(sessionId) {
+  summaryCandidateEpochs.set(sessionId, (summaryCandidateEpochs.get(sessionId) ?? 0) + 1);
+  writtenSummaryIds.delete(sessionId);
+  forgetRawSessionOrdinalWatermark(sessionId);
+}
 function survivingAnchor(db, set) {
   if (set.anchors.length === 0)
     return null;
   const current = new Map(db.prepare(ANCHOR_CHECK_SQL).all(JSON.stringify(set.anchors.map((anchor) => anchor.rowid))).map((row) => [row.rid, row.id]));
   return set.anchors.find((anchor) => current.get(anchor.rowid) === anchor.id);
 }
+function hasLateCommitBehindCheckpoint(db, sessionId, scan) {
+  const tail = scan.checkpoints?.at(-1);
+  if (!tail || scan.maxRowid === undefined)
+    return false;
+  const row = db.prepare(`SELECT COUNT(*) AS count FROM message
+             WHERE rowid > ? AND +session_id = ?
+               AND (time_created, id) <= (?, ?)
+               AND NOT (${EXCLUDED_ROW_SQL})`).get(scan.maxRowid, sessionId, tail.timeCreated, tail.id);
+  return typeof row?.count === "number" && row.count > 0;
+}
+function discardRetainedOrdinalRanks(db, sessionId) {
+  ordinalCheckpoints.get(db)?.delete(sessionId);
+  ordinalSummarySeeds.get(db)?.delete(sessionId);
+}
 function currentOrdinalCheckpoints(db, sessionId) {
   const cached = ordinalCheckpoints.get(db)?.get(sessionId);
   if (!cached)
@@ -27318,10 +27363,16 @@ function extendOrdinalCheckpoints(db, sessionId, scan, limit) {
     scan.sessionRows = points.at(-1)?.storedCount ?? 0;
   }
   const tail = points.at(-1);
-  const rows = db.prepare(`SELECT id, time_created AS timeCreated, ${EXCLUDED_ROW_SQL} AS excluded FROM message
+  const rows = db.prepare(`SELECT id, time_created AS timeCreated, rowid AS rowid, ${EXCLUDED_ROW_SQL} AS excluded FROM message
         WHERE session_id=?${tail ? " AND (time_created,id) > (?,?)" : ""}
         ORDER BY time_created,id${limit === undefined ? "" : ` LIMIT ${limit + 1}`}`).all(sessionId, ...tail ? [tail.timeCreated, tail.id] : []);
   ordinalJsonRowsRead += rows.length;
+  if (hasLateCommitBehindCheckpoint(db, sessionId, scan)) {
+    discardRetainedOrdinalRanks(db, sessionId);
+    if (isMainThread)
+      forgetRawSessionSummaryRows(sessionId);
+    return false;
+  }
   if (limit !== undefined && rows.length > limit)
     return false;
   let total = scan.total ?? 0;
@@ -27338,6 +27389,13 @@ function extendOrdinalCheckpoints(db, sessionId, scan, limit) {
   scan.checkpoints = points;
   scan.sessionRows += rows.length;
   scan.total = total;
+  if (rows.length > 0) {
+    let maxRowid = scan.maxRowid ?? -1;
+    for (const row of rows)
+      if (row.rowid > maxRowid)
+        maxRowid = row.rowid;
+    scan.maxRowid = maxRowid;
+  }
   return true;
 }
 function rawOrdinalSummarySeed(db, sessionId) {
@@ -27390,8 +27448,7 @@ function boundedOrdinalPrefix(db, sessionId, through) {
 }
 function scanRawSessionSummaryRows(db, sessionId, previous) {
   return withReadSnapshot(db, () => {
-    if (previous?.checkpoints) {
-      extendOrdinalCheckpoints(db, sessionId, previous);
+    if (previous?.checkpoints && extendOrdinalCheckpoints(db, sessionId, previous)) {
       return previous;
     }
     if (previous) {
@@ -27423,12 +27480,15 @@ function scanRawSessionSummaryRows(db, sessionId, previous) {
     }
     anchors.sort((left, right) => right.rowid - left.rowid);
     anchors.length = Math.min(anchors.length, SUMMARY_ANCHOR_LIMIT);
-    const keys = db.prepare(`SELECT id, time_created AS timeCreated, ${EXCLUDED_ROW_SQL} AS excluded FROM message WHERE session_id = ?
+    const keys = db.prepare(`SELECT id, time_created AS timeCreated, rowid AS rowid, ${EXCLUDED_ROW_SQL} AS excluded FROM message WHERE session_id = ?
         ORDER BY time_created, id`).all(sessionId);
     const checkpoints = [];
     let total = 0;
+    let maxRowid;
     for (let index = 0;index < keys.length; index++) {
       const key = keys[index];
+      if (typeof key.rowid === "number")
+        maxRowid = maxRowid === undefined ? key.rowid : Math.max(maxRowid, key.rowid);
       if (key.excluded !== 1)
         total++;
       if (index % 256 === 255 || index === keys.length - 1)
@@ -27439,7 +27499,7 @@ function scanRawSessionSummaryRows(db, sessionId, previous) {
           storedCount: index + 1
         });
     }
-    return { anchors, ids, sessionRows, checkpoints, total };
+    return { anchors, ids, sessionRows, checkpoints, total, maxRowid };
   });
 }
 function getRawSessionSummaryEpoch(sessionId) {
@@ -33114,6 +33174,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 +33273,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
@@ -34927,6 +35118,7 @@ __export(exports_read_session_chunk, {
   readRawSessionMessages: () => readRawSessionMessages,
   readRawSessionSeedTail: () => readRawSessionSeedTail,
   readSessionChunk: () => readSessionChunk,
+  resolveHistorianChunkStart: () => resolveHistorianChunkStart,
   resolveHostServedBoundaryId: () => resolveHostServedBoundaryId,
   setBoundedRawMessageProvider: () => setBoundedRawMessageProvider,
   setRawMessageProvider: () => setRawMessageProvider,
@@ -35399,6 +35591,20 @@ function readRawSessionMessageOrdinalById(sessionId, messageId) {
     return null;
   return withReadOnlySessionDb((db) => readRawSessionMessageOrdinalByIdFromDb(db, sessionId, messageId));
 }
+function resolveHistorianChunkStart(sessionId, newest) {
+  if (!newest)
+    return 1;
+  const fallback = newest.endMessage + 1;
+  if (hasRawMessageProvider(sessionId))
+    return fallback;
+  const endId = newest.endMessageId;
+  if (typeof endId !== "string" || endId.length === 0)
+    return fallback;
+  const ordinal = readRawSessionMessageOrdinalById(sessionId, endId);
+  if (typeof ordinal !== "number" || !Number.isFinite(ordinal) || ordinal < 1)
+    return fallback;
+  return ordinal + 1;
+}
 function readRawSessionMessageOrderPosition(sessionId, messageId) {
   const provider = sessionProviders.get(sessionId)?.provider;
   if (provider) {
@@ -52538,8 +52744,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 };
@@ -52559,15 +52765,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");
@@ -52592,7 +52798,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());
@@ -53271,7 +53477,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.24",
+    "version": "0.49.26",
     "description": "Unified CLI for Magic Context — setup, doctor, and migration across OpenCode, Pi, and OMP",
     "keywords": [
         "opencode",