@cortexkit/opencode-magic-context 0.49.23 → 0.49.25

package/dist/index-cfaet9cg.js

@@ -0,0 +1,405 @@
+import {
+  estimateTokens
+} from "./index-b88dwwrh.js";
+import {
+  stableStringify
+} from "./index-x9k3mqrf.js";
+
+// 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;
+  }
+}
+
+// src/features/magic-context/tool-definition-tokens.ts
+import { createHash } from "node:crypto";
+var ACTIVITY_WINDOW_MS = 10 * 60000;
+var MAX_ACTIVITY_GAP_MS = 60000;
+var RETIRED_CACHE_LIMIT = 64;
+var WRITE_RETRY_MS = 5000;
+var WINDOWED_SINCE_KEY = "tool_definition_measurements:windowed_since";
+var routes = new Map;
+var sessionFlights = new BoundedSessionMap(1000);
+var persistenceDb = null;
+var windowedSince;
+var boundAt = 0;
+var cachedInsertStmt = null;
+var cachedDeleteStmt = null;
+function agentKey(agentName) {
+  return agentName && agentName.length > 0 ? agentName : "default";
+}
+function keyFor(providerID, modelID, agentName) {
+  return `${providerID}/${modelID}/${agentKey(agentName)}`;
+}
+function fingerprintFor(description, parameters) {
+  return createHash("sha256").update(description).update("\x00").update(stableStringify(parameters)).digest("hex");
+}
+function measure(description, parameters) {
+  let paramsText = "";
+  try {
+    paramsText = parameters === undefined ? "" : JSON.stringify(parameters);
+  } catch {
+    paramsText = "";
+  }
+  return estimateTokens(description) + estimateTokens(paramsText);
+}
+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 counts(route, slot) {
+  if (!route.live)
+    return true;
+  if (slot.legacy)
+    return false;
+  return slot.lastFireAt >= route.clock - ACTIVITY_WINDOW_MS;
+}
+function currentTools(route) {
+  return [...route.tools.entries()].filter(([, slot]) => counts(route, slot));
+}
+function summarize(entries, live) {
+  let total = 0;
+  for (const [, slot] of entries)
+    total += slot.tokens;
+  const ids = entries.map(([id]) => id).sort();
+  const fingerprints = new Map(entries.map(([id, slot]) => [
+    id,
+    slot.fingerprint ?? (live ? `stored:${slot.tokens}` : undefined)
+  ]));
+  const complete = ids.every((id) => fingerprints.get(id) !== undefined);
+  return {
+    total,
+    signature: complete ? createHash("sha256").update(JSON.stringify(ids.map((id) => [id, fingerprints.get(id)]))).digest("hex") : undefined,
+    hash: ids.length === 0 ? "" : createHash("sha256").update(ids.join("\x00")).digest("hex")
+  };
+}
+function resolve(providerID, modelID, agentName, sessionId) {
+  if (!providerID || !modelID)
+    return;
+  const key = keyFor(providerID, modelID, agentName);
+  if (sessionId) {
+    const flight = sessionFlights.peek(sessionId);
+    if (flight?.key === key && flight.exact)
+      return flight.exact;
+  }
+  const route = routes.get(key);
+  if (!route)
+    return;
+  const entries = currentTools(route);
+  if (!route.live && entries.length === 0)
+    return;
+  return summarize(entries, route.live);
+}
+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 persistInsert(route, toolID, tokens) {
+  if (!persistenceDb)
+    return false;
+  try {
+    cachedInsertStmt ??= persistenceDb.prepare(`INSERT OR REPLACE INTO tool_definition_measurements
+             (provider_id, model_id, agent_name, tool_id, token_count, recorded_at)
+             VALUES (?, ?, ?, ?, ?, ?)`);
+    cachedInsertStmt.run(route.providerID, route.modelID, route.agentName, toolID, tokens, Date.now());
+  } catch {
+    cachedInsertStmt = null;
+    return false;
+  }
+  if (route.legacyRows.delete(toolID) && route.legacyRows.size === 0)
+    markWindowed();
+  return true;
+}
+function persistDelete(route, toolIDs) {
+  if (!persistenceDb)
+    return false;
+  try {
+    cachedDeleteStmt ??= persistenceDb.prepare(`DELETE FROM tool_definition_measurements
+             WHERE provider_id = ? AND model_id = ? AND agent_name = ?
+               AND tool_id IN (SELECT value FROM json_each(?))`);
+    cachedDeleteStmt.run(route.providerID, route.modelID, route.agentName, JSON.stringify(toolIDs));
+  } catch {
+    cachedDeleteStmt = null;
+    return false;
+  }
+  for (const id of toolIDs)
+    route.legacyRows.delete(id);
+  markWindowed();
+  return true;
+}
+function writeSlot(route, toolID, slot) {
+  if (slot.persisted || !persistenceDb)
+    return;
+  const now = Date.now();
+  if (slot.writeFailedAt !== undefined && now - slot.writeFailedAt < WRITE_RETRY_MS)
+    return;
+  if (persistInsert(route, toolID, slot.tokens)) {
+    slot.persisted = true;
+    slot.writeFailedAt = undefined;
+  } else {
+    slot.writeFailedAt = now;
+  }
+}
+function retire(route, toolID, slot, rowDeleted) {
+  if (slot.fingerprint === undefined)
+    return;
+  route.retired.delete(toolID);
+  route.retired.set(toolID, {
+    fingerprint: slot.fingerprint,
+    tokens: slot.tokens,
+    rowKept: slot.persisted && !rowDeleted
+  });
+  if (route.retired.size > RETIRED_CACHE_LIMIT) {
+    const oldest = route.retired.keys().next().value;
+    if (oldest !== undefined)
+      route.retired.delete(oldest);
+  }
+}
+function freshSlot(route, toolID, description, parameters, fingerprint, now) {
+  const retired = route.retired.get(toolID);
+  if (retired)
+    route.retired.delete(toolID);
+  const reuse = retired?.fingerprint === fingerprint ? retired : undefined;
+  return {
+    tokens: reuse ? reuse.tokens : measure(description, parameters),
+    fingerprint,
+    lastFireAt: now,
+    legacy: false,
+    persisted: reuse?.rowKept === true
+  };
+}
+function expire(route) {
+  const cutoff = route.clock - ACTIVITY_WINDOW_MS;
+  if (route.oldestFireAt >= cutoff)
+    return;
+  const leaving = [];
+  let oldest = Number.POSITIVE_INFINITY;
+  for (const entry of route.tools) {
+    if (entry[1].lastFireAt >= cutoff)
+      oldest = Math.min(oldest, entry[1].lastFireAt);
+    else
+      leaving.push(entry);
+  }
+  route.oldestFireAt = oldest;
+  if (leaving.length === 0)
+    return;
+  const deleted = persistDelete(route, leaving.map(([id]) => id));
+  for (const [id, slot] of leaving) {
+    route.tools.delete(id);
+    retire(route, id, slot, deleted);
+  }
+}
+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, recorded_at FROM tool_definition_measurements").all();
+  } catch {
+    return;
+  }
+  const since = readWindowedSince(db);
+  const loadedAt = new Map;
+  for (const row of rows) {
+    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);
+  }
+}
+function recordToolDefinition(providerID, modelID, agentName, toolID, description, parameters, sessionId) {
+  if (!providerID || !modelID || !toolID)
+    return;
+  const { key, route } = routeFor(providerID, modelID, agentName);
+  const now = advanceClock(route);
+  if (!route.live) {
+    route.live = true;
+    for (const slot of route.tools.values())
+      if (slot.legacy)
+        slot.lastFireAt = now;
+  }
+  if (sessionId)
+    sessionFlights.set(sessionId, { key });
+  const fingerprint = fingerprintFor(description ?? "", parameters);
+  let slot = route.tools.get(toolID);
+  if (slot && slot.fingerprint === fingerprint) {
+    slot.lastFireAt = now;
+  } else {
+    slot = freshSlot(route, toolID, description ?? "", parameters, fingerprint, now);
+    route.tools.set(toolID, slot);
+    route.oldestFireAt = Math.min(route.oldestFireAt, now);
+  }
+  writeSlot(route, toolID, slot);
+  expire(route);
+}
+function recordToolDefinitionSet(providerID, modelID, agentName, tools, sessionId) {
+  if (!providerID || !modelID)
+    return;
+  const { key, route } = routeFor(providerID, modelID, agentName);
+  const now = advanceClock(route);
+  route.live = true;
+  const next = new Map;
+  for (const tool of tools) {
+    if (!tool.id)
+      continue;
+    const fingerprint = fingerprintFor(tool.description ?? "", tool.parameters);
+    const previous = route.tools.get(tool.id);
+    if (previous && previous.fingerprint === fingerprint) {
+      previous.lastFireAt = now;
+      next.set(tool.id, previous);
+      continue;
+    }
+    next.set(tool.id, freshSlot(route, tool.id, tool.description ?? "", tool.parameters, fingerprint, now));
+  }
+  const removed = [...route.tools].filter(([id]) => !next.has(id));
+  route.tools = next;
+  route.oldestFireAt = now;
+  if (removed.length > 0) {
+    const deleted = persistDelete(route, removed.map(([id]) => id));
+    for (const [id, slot] of removed)
+      retire(route, id, slot, deleted);
+  }
+  for (const [toolID, slot] of next)
+    writeSlot(route, toolID, slot);
+  if (sessionId)
+    sessionFlights.set(sessionId, { key, exact: summarize([...next.entries()], true) });
+}
+function getCurrentToolSetHash(providerID, modelID, agentName, sessionId) {
+  return resolve(providerID, modelID, agentName, sessionId)?.hash ?? "";
+}
+function getToolDefinitionMeasurementSignature(providerID, modelID, agentName, sessionId) {
+  return resolve(providerID, modelID, agentName, sessionId)?.signature;
+}
+function getMeasuredToolDefinitionTokens(providerID, modelID, agentName, sessionId) {
+  return resolve(providerID, modelID, agentName, sessionId)?.total;
+}
+function getSessionToolDefinitionTokens(sessionId) {
+  if (!sessionId)
+    return;
+  const flight = sessionFlights.peek(sessionId);
+  if (!flight)
+    return;
+  if (flight.exact)
+    return flight.exact.total;
+  const route = routes.get(flight.key);
+  return route ? summarize(currentTools(route), route.live).total : undefined;
+}
+
+export { BoundedSessionMap, setDatabase, loadToolDefinitionMeasurements, recordToolDefinition, recordToolDefinitionSet, getCurrentToolSetHash, getToolDefinitionMeasurementSignature, getMeasuredToolDefinitionTokens, getSessionToolDefinitionTokens };

package/dist/{index-jmq8kfe7.js → index-ebsvmc5s.js}

@@ -15,7 +15,7 @@ import {
   getActiveCompartmentRun,
   markActiveCompartmentRunPublished,
   registerActiveCompartmentRun
-} from "./index-y76rhsnr.js";
+} from "./index-0s8454t2.js";
 import {
   inRootAsyncContext2
 } from "./index-gzy5w8ya.js";
@@ -27,17 +27,17 @@ import {
   getHistorianFailureState,
   clearEmergencyRecovery,
   prepareRawSessionOrdinals2
-} from "./index-mnhcdfxg.js";
+} from "./index-yrrsp47d.js";
 import {
   pushNotification2
 } from "./index-x8a7jmkh.js";
 import {
   sendStatusNotification2
-} from "./index-66eby7hx.js";
+} from "./index-jcr6pe7z.js";
 import {
   setRecompStarting2,
   setRecompTerminal2
-} from "./index-ffzhwfzy.js";
+} from "./index-zzrzjnx5.js";
 
 // src/hooks/magic-context/wrapup-orchestrator.ts
 import * as crypto from "node:crypto";

package/dist/{index-66eby7hx.js → index-jcr6pe7z.js}

@@ -10,7 +10,7 @@ import {
 } from "./index-rrv26qjz.js";
 import {
   shouldHoldIgnoredNotification
-} from "./index-ksq50rg0.js";
+} from "./index-c9zrgcnt.js";
 import {
   getErrorMessage
 } from "./index-y8v6yerm.js";

package/dist/{index-syaazvy2.js → index-n18sch77.js}

@@ -24,7 +24,7 @@ import {
   loadCompartmentChunkEmbeddingsForSearch2,
   peekCompartmentChunkSearchPool2,
   warmCompartmentChunkSearchPool2
-} from "./index-m32esgmj.js";
+} from "./index-3d5wnkq7.js";
 import {
   recordEmbeddingMeasurement,
   saveCommitEmbedding,
@@ -41,7 +41,7 @@ import {
   enqueueShadowEmbeddingItems2,
   getProjectEmbeddingSnapshot2,
   embedItemsForProject2
-} from "./index-zy67whjr.js";
+} from "./index-z05n7702.js";
 import {
   getProjectEmbeddings2
 } from "./index-4dhv7mqz.js";
@@ -50,7 +50,7 @@ import {
   isEmbeddingEnabled,
   embedText,
   ensureMemoryEmbeddings2
-} from "./index-rxqr723x.js";
+} from "./index-t6j3qxnd.js";
 import {
   ModuleMemoryAuthorityError2,
   getMemoriesByProject2,
@@ -65,13 +65,13 @@ import {
   sanitizeFtsQuery,
   searchMemoriesFTS,
   searchMemoriesFTSUnion
-} from "./index-3svaejkh.js";
+} from "./index-z928hmnp.js";
 import {
   cleanSearchText,
   keywordRelevance,
   matchedSearchSnippet,
   getIndexedMessageCorpusSize2
-} from "./index-mnnkgq0q.js";
+} from "./index-awcftgmx.js";
 import {
   MESSAGE_FTS_SESSION_FILTER_SQL,
   withMessageFtsSessionFilter

package/dist/{index-a9zvn5fe.js → index-q7ywt6xt.js}

@@ -44,7 +44,7 @@ import {
 } from "./index-fb3zxn06.js";
 import {
   startMessageFtsRowidMapBackfill2
-} from "./index-x6cbrv9h.js";
+} from "./index-szf8r0ba.js";
 import {
   LKG_SLOT_CHUNKS_DDL,
   SESSION_REPLAY_DECISIONS_DDL,
@@ -67,7 +67,7 @@ import {
 import {
   setDatabase,
   loadToolDefinitionMeasurements
-} from "./index-j76ah6d7.js";
+} from "./index-cfaet9cg.js";
 import {
   getErrorMessage
 } from "./index-y8v6yerm.js";
@@ -1279,7 +1279,7 @@ function finishDatabaseOpen(db, dbPath, explicitDbPath, latestSupportedVersion)
       state.running = startMessageFtsRowidMapBackfill2(db, signal).then(async () => {
         if (signal.aborted || !readsOpenCodeStore)
           return;
-        const { readRawSessionMessagePage, readRawSessionMessages } = await importPluginModule(() => import("./read-session-chunk-t039f0m5.js"));
+        const { readRawSessionMessagePage, readRawSessionMessages } = await importPluginModule(() => import("./read-session-chunk-z5gnc0zb.js"));
         const { startMessageTimeBackfill } = await importPluginModule(() => import("./message-time-backfill-4qva0b4f.js"));
         if (signal.aborted)
           return;

package/dist/{index-x6cbrv9h.js → index-szf8r0ba.js}

@@ -5,7 +5,7 @@ import {
 } from "./index-gzy5w8ya.js";
 import {
   runSessionWarmupWorker
-} from "./index-jfem3dgz.js";
+} from "./index-7tdtpqrg.js";
 import {
   logSlowWriteTransaction
 } from "./index-t5pck3ss.js";

package/dist/{index-rxqr723x.js → index-t6j3qxnd.js}

@@ -15,7 +15,7 @@ import {
   OpenAICompatibleEmbeddingProvider,
   getProjectEmbeddingSnapshot2,
   embedBatchForProject2
-} from "./index-zy67whjr.js";
+} from "./index-z05n7702.js";
 import {
   isEmbeddingHostBusy2
 } from "./index-qt1qqasc.js";