@cortexkit/opencode-magic-context 0.49.31 → 0.49.33

package/dist/v2/{server-42nebt63.js → server-n14edf07.js}

@@ -1,3 +1,31 @@
+import {
+  getHarness2
+} from "./server-pavzsdc6.js";
+import {
+  getDataDir,
+  log2,
+  sessionLog2
+} from "./server-6495nmn9.js";
+import {
+  inRootAsyncContext2,
+  withSqliteBackgroundWriter2
+} from "./server-gzy5w8ya.js";
+import {
+  scheduleAfterBootQuiet
+} from "./server-qjvk4a9t.js";
+import {
+  isRecord
+} from "./server-nxas8v1d.js";
+import {
+  cleanSearchText,
+  keywordRelevance,
+  matchedSearchSnippet,
+  getIndexedMessageCorpusSize,
+  getMessageIndexReconciliationStartOrdinal,
+  isMessageIndexReconciledThrough,
+  clearIndexedMessages,
+  indexMessagesAfterOrdinal
+} from "./server-hwag0khr.js";
 import {
   Priority,
   AdmissionClass,
@@ -7,22 +35,12 @@ import {
   SubcClient,
   isConsumerReconnectTransient
 } from "./server-ab1g0wn9.js";
-import {
-  getHarness2
-} from "./server-pavzsdc6.js";
-import {
-  getDataDir,
-  log2
-} from "./server-6495nmn9.js";
-import {
-  inRootAsyncContext2
-} from "./server-gzy5w8ya.js";
 import {
   buildCanonicalChunkTextFromFts2,
   loadCompartmentChunkEmbeddingsForSearch2,
   peekCompartmentChunkSearchPool2,
   warmCompartmentChunkSearchPool2
-} from "./server-4sn3at8p.js";
+} from "./server-h1byrhwx.js";
 import {
   recordEmbeddingMeasurement,
   saveCommitEmbedding,
@@ -39,7 +57,7 @@ import {
   enqueueShadowEmbeddingItems2,
   getProjectEmbeddingSnapshot2,
   embedItemsForProject2
-} from "./server-zh3esb0z.js";
+} from "./server-ab8017gw.js";
 import {
   getProjectEmbeddings2
 } from "./server-4dhv7mqz.js";
@@ -48,7 +66,7 @@ import {
   isEmbeddingEnabled,
   embedText,
   ensureMemoryEmbeddings2
-} from "./server-p0snacz3.js";
+} from "./server-2aasmpsp.js";
 import {
   ModuleMemoryAuthorityError2,
   getMemoriesByProject2,
@@ -63,20 +81,11 @@ import {
   sanitizeFtsQuery,
   searchMemoriesFTS,
   searchMemoriesFTSUnion
-} from "./server-ph300d6m.js";
-import {
-  cleanSearchText,
-  keywordRelevance,
-  matchedSearchSnippet,
-  getIndexedMessageCorpusSize
-} from "./server-hwag0khr.js";
+} from "./server-tkdabx8q.js";
 import {
   MESSAGE_FTS_SESSION_FILTER_SQL,
   withMessageFtsSessionFilter
 } from "./server-kaqs6h31.js";
-import {
-  isRecord
-} from "./server-nxas8v1d.js";
 import {
   resolveWorkspaceShareCategories,
   resolveWorkspaceIdentitySet,
@@ -88,6 +97,301 @@ import {
   isKnownAutocommit
 } from "./server-8ajstryz.js";
 
+// src/features/magic-context/message-index-async.ts
+var indexCancellations = new Map;
+var sessionEpochs = new Map;
+var rebuildingSessions = new Set;
+function getMessageIndexEpoch(sessionId) {
+  return sessionEpochs.get(sessionId) ?? 0;
+}
+function isMessageIndexSearchable(sessionId) {
+  return !rebuildingSessions.has(sessionId);
+}
+var workerMeasurements = new WeakMap;
+function isDatabaseLockedError(error) {
+  if (!error || typeof error !== "object")
+    return false;
+  const e = error;
+  if (typeof e.code === "string") {
+    if (e.code === "SQLITE_BUSY" || e.code === "SQLITE_LOCKED")
+      return true;
+  }
+  if (typeof e.message === "string") {
+    if (/database is locked/i.test(e.message))
+      return true;
+    if (/sqlite_(busy|locked)/i.test(e.message))
+      return true;
+  }
+  return false;
+}
+var RECONCILIATION_BATCH_SIZE = 100;
+
+class MagicContextMessageIndexHeapHolder {
+  reconciledSessions = new Set;
+  reconciledSnapshots = new Map;
+  stalledSessions = new Set;
+  reconciliationScheduledSessions = new Set;
+  clearAndReindexScheduledSessions = new Map;
+  sessionLocks = new Map;
+  incrementalTimers = new Map;
+  pendingIncrementalKeys = new Set;
+  completedIncrementalKeys = new Set;
+  activeReconcilerBuffers = new Map;
+}
+var heapHolder = new MagicContextMessageIndexHeapHolder;
+function clearCompletedIncrementalKeys(sessionId) {
+  const prefix = `${sessionId}\x00`;
+  for (const key of heapHolder.completedIncrementalKeys) {
+    if (key.startsWith(prefix))
+      heapHolder.completedIncrementalKeys.delete(key);
+  }
+}
+var PREPARE_RETRY_MS = 60000;
+async function sourceReady(source, sessionId) {
+  const prepare = source?.prepare;
+  return typeof prepare === "function" ? prepare(sessionId) : true;
+}
+function defer(fn) {
+  const immediate = globalThis.setImmediate;
+  if (typeof immediate === "function") {
+    inRootAsyncContext2(() => immediate(fn));
+    return;
+  }
+  inRootAsyncContext2(() => setTimeout(fn, 0));
+}
+function yieldToEventLoop() {
+  return new Promise((resolve) => defer(resolve));
+}
+function runWithSessionLock(sessionId, operation) {
+  const previous = heapHolder.sessionLocks.get(sessionId) ?? Promise.resolve();
+  const run = previous.catch(() => {
+    return;
+  }).then(async () => {
+    await operation();
+  });
+  heapHolder.sessionLocks.set(sessionId, run);
+  run.finally(() => {
+    if (heapHolder.sessionLocks.get(sessionId) === run) {
+      heapHolder.sessionLocks.delete(sessionId);
+    }
+  }).catch(() => {
+    return;
+  });
+  return run;
+}
+function logIndexingError(sessionId, action, error) {
+  if (isDatabaseLockedError(error)) {
+    sessionLog2(sessionId, `message FTS async ${action} skipped (database busy; will retry on next reconciliation)`);
+    return;
+  }
+  sessionLog2(sessionId, `message FTS async ${action} failed: ${error instanceof Error ? error.message : String(error)}`);
+  log2(`[message-index-async] ${action} failed for ${sessionId}:`, error);
+}
+function serializedMessageBytes(messages) {
+  try {
+    return Buffer.byteLength(JSON.stringify(messages));
+  } catch {
+    return 0;
+  }
+}
+function logReconciliationStall(sessionId, reason) {
+  if (heapHolder.stalledSessions.has(sessionId))
+    return;
+  heapHolder.stalledSessions.add(sessionId);
+  sessionLog2(sessionId, `message FTS reconciliation stalled: ${reason}; will retry`);
+}
+async function reconcileSessionIndex(db, sessionId, readMessages, epoch = getMessageIndexEpoch(sessionId)) {
+  if (!await sourceReady(readMessages, sessionId)) {
+    logReconciliationStall(sessionId, "raw message reader is not ready");
+    return false;
+  }
+  await runWithSessionLock(sessionId, async () => {
+    if (getMessageIndexEpoch(sessionId) !== epoch)
+      return;
+    if (!readMessages.getRevision && heapHolder.reconciledSessions.has(sessionId))
+      return;
+    let fallbackSnapshot = null;
+    try {
+      const fullReader = typeof readMessages === "function" ? readMessages : null;
+      const revision = readMessages.getRevision?.(sessionId);
+      const previous = heapHolder.reconciledSnapshots.get(sessionId);
+      const finalWatermark = previous && revision === previous.revision ? previous.count : revision !== undefined && readMessages.getCountAfterRevision ? previous && revision > previous.revision ? previous.count + readMessages.getCountAfterRevision(sessionId, previous.revision, revision) : readMessages.getCountAfterRevision(sessionId, -1, revision) : readMessages.getCount ? readMessages.getCount(sessionId) : (fallbackSnapshot = fullReader?.(sessionId) ?? []).length;
+      let cursor = getMessageIndexReconciliationStartOrdinal(db, sessionId);
+      let after = cursor === previous?.count ? previous.after : undefined;
+      while (cursor < finalWatermark) {
+        if (getMessageIndexEpoch(sessionId) !== epoch)
+          return;
+        const pageEnd = Math.min(finalWatermark, cursor + RECONCILIATION_BATCH_SIZE);
+        const messages = readMessages.readPage ? readMessages.readPage(sessionId, cursor, RECONCILIATION_BATCH_SIZE, finalWatermark, after) : (fallbackSnapshot ?? []).filter((message) => message.ordinal > cursor && message.ordinal <= pageEnd);
+        const retainedMessages = fallbackSnapshot ?? messages;
+        heapHolder.activeReconcilerBuffers.set(sessionId, retainedMessages);
+        if (getMessageIndexEpoch(sessionId) !== epoch)
+          return;
+        withSqliteBackgroundWriter2(() => indexMessagesAfterOrdinal(db, sessionId, messages, cursor, pageEnd));
+        const nextCursor = getMessageIndexReconciliationStartOrdinal(db, sessionId);
+        if (nextCursor <= cursor)
+          break;
+        cursor = nextCursor;
+        const last = messages.at(-1);
+        after = last?.ordinal === cursor && typeof last.createdAt === "number" ? { timeCreated: last.createdAt, id: last.id } : undefined;
+        if (cursor < finalWatermark) {
+          await yieldToEventLoop();
+        }
+      }
+      if (getMessageIndexEpoch(sessionId) !== epoch)
+        return;
+      if (isMessageIndexReconciledThrough(db, sessionId, finalWatermark)) {
+        heapHolder.reconciledSessions.add(sessionId);
+        rebuildingSessions.delete(sessionId);
+        if (revision !== undefined) {
+          if (!after && finalWatermark > 0 && readMessages.readPage) {
+            const last = readMessages.readPage(sessionId, finalWatermark - 1, 1, finalWatermark).at(-1);
+            if (last?.ordinal === finalWatermark && typeof last.createdAt === "number")
+              after = { timeCreated: last.createdAt, id: last.id };
+          }
+          heapHolder.reconciledSnapshots.set(sessionId, {
+            revision,
+            count: finalWatermark,
+            after
+          });
+        }
+      } else {
+        logReconciliationStall(sessionId, `gap after ordinal ${cursor} (store count ${finalWatermark})`);
+      }
+    } finally {
+      heapHolder.activeReconcilerBuffers.delete(sessionId);
+    }
+  });
+  return true;
+}
+function scheduleReconciliation(db, sessionId, readMessages) {
+  if (rebuildingSessions.has(sessionId)) {
+    if (!heapHolder.clearAndReindexScheduledSessions.has(sessionId))
+      scheduleClearAndReindex(db, sessionId, readMessages);
+    return;
+  }
+  const epoch = getMessageIndexEpoch(sessionId);
+  if (!readMessages.getRevision && heapHolder.reconciledSessions.has(sessionId) || heapHolder.reconciliationScheduledSessions.has(sessionId)) {
+    return;
+  }
+  heapHolder.reconciliationScheduledSessions.add(sessionId);
+  scheduleAfterBootQuiet(() => {
+    defer(() => {
+      let appendedDuringReconciliation = false;
+      const previousSnapshot = heapHolder.reconciledSnapshots.get(sessionId);
+      if (getMessageIndexEpoch(sessionId) !== epoch)
+        return;
+      reconcileSessionIndex(db, sessionId, readMessages, epoch).then((ran) => {
+        if (getMessageIndexEpoch(sessionId) !== epoch)
+          return;
+        if (ran) {
+          const snapshot = heapHolder.reconciledSnapshots.get(sessionId);
+          appendedDuringReconciliation = snapshot !== undefined && snapshot !== previousSnapshot && readMessages.getRevision !== undefined && readMessages.getRevision(sessionId) !== snapshot.revision;
+          return;
+        }
+        inRootAsyncContext2(() => setTimeout(() => {
+          if (getMessageIndexEpoch(sessionId) !== epoch)
+            return;
+          heapHolder.reconciliationScheduledSessions.delete(sessionId);
+          scheduleReconciliation(db, sessionId, readMessages);
+        }, PREPARE_RETRY_MS)).unref?.();
+      }).catch((error) => {
+        if (getMessageIndexEpoch(sessionId) !== epoch)
+          return;
+        logReconciliationStall(sessionId, error instanceof Error ? error.message : String(error));
+        if (isDatabaseLockedError(error))
+          inRootAsyncContext2(() => setTimeout(() => {
+            if (getMessageIndexEpoch(sessionId) === epoch)
+              scheduleReconciliation(db, sessionId, readMessages);
+          }, 1000)).unref();
+      }).finally(() => {
+        if (getMessageIndexEpoch(sessionId) !== epoch)
+          return;
+        heapHolder.reconciliationScheduledSessions.delete(sessionId);
+        if (appendedDuringReconciliation)
+          scheduleReconciliation(db, sessionId, readMessages);
+      });
+    });
+  });
+}
+function scheduleClearAndReindex(db, sessionId, readMessages) {
+  rebuildingSessions.add(sessionId);
+  invalidateIncrementalWork(sessionId);
+  heapHolder.reconciledSessions.delete(sessionId);
+  heapHolder.reconciledSnapshots.delete(sessionId);
+  heapHolder.reconciliationScheduledSessions.add(sessionId);
+  clearCompletedIncrementalKeys(sessionId);
+  const existing = heapHolder.clearAndReindexScheduledSessions.get(sessionId);
+  if (existing) {
+    existing.source = readMessages;
+    return;
+  }
+  const pending = { source: readMessages };
+  heapHolder.clearAndReindexScheduledSessions.set(sessionId, pending);
+  scheduleAfterBootQuiet(() => {
+    defer(() => {
+      let cleared = false;
+      let ownsSchedule = false;
+      let epoch = getMessageIndexEpoch(sessionId);
+      runWithSessionLock(sessionId, () => {
+        if (heapHolder.clearAndReindexScheduledSessions.get(sessionId) !== pending)
+          return;
+        ownsSchedule = true;
+        epoch = getMessageIndexEpoch(sessionId);
+        heapHolder.clearAndReindexScheduledSessions.delete(sessionId);
+        heapHolder.reconciledSessions.delete(sessionId);
+        heapHolder.reconciledSnapshots.delete(sessionId);
+        clearCompletedIncrementalKeys(sessionId);
+        clearIndexedMessages(db, sessionId);
+        cleared = true;
+      }).then(() => cleared && getMessageIndexEpoch(sessionId) === epoch ? reconcileSessionIndex(db, sessionId, pending.source, epoch) : undefined).catch((error) => {
+        if (getMessageIndexEpoch(sessionId) !== epoch)
+          return;
+        heapHolder.reconciledSessions.delete(sessionId);
+        if (heapHolder.clearAndReindexScheduledSessions.get(sessionId) === pending)
+          heapHolder.clearAndReindexScheduledSessions.delete(sessionId);
+        logIndexingError(sessionId, "clear and reindex", error);
+      }).finally(() => {
+        if (ownsSchedule && getMessageIndexEpoch(sessionId) === epoch)
+          heapHolder.reconciliationScheduledSessions.delete(sessionId);
+      });
+    });
+  });
+}
+function getMessageIndexQueueHeapStats() {
+  return {
+    queueLength: heapHolder.reconciliationScheduledSessions.size + heapHolder.incrementalTimers.size + heapHolder.pendingIncrementalKeys.size,
+    reconciliationScheduled: heapHolder.reconciliationScheduledSessions.size,
+    incrementalTimers: heapHolder.incrementalTimers.size,
+    pendingIncremental: heapHolder.pendingIncrementalKeys.size,
+    activeSessionLocks: heapHolder.sessionLocks.size,
+    completedIncrementalKeys: heapHolder.completedIncrementalKeys.size,
+    activeBufferMessages: [...heapHolder.activeReconcilerBuffers.values()].reduce((sum, messages) => sum + messages.length, 0),
+    activeBufferBytes: [...heapHolder.activeReconcilerBuffers.values()].reduce((sum, messages) => sum + serializedMessageBytes(messages), 0)
+  };
+}
+function invalidateIncrementalWork(sessionId) {
+  sessionEpochs.set(sessionId, (sessionEpochs.get(sessionId) ?? 0) + 1);
+  for (const cancellation of indexCancellations.get(sessionId) ?? [])
+    Atomics.store(cancellation, 0, 1);
+  const prefix = `${sessionId}\x00`;
+  for (const [key, timer] of heapHolder.incrementalTimers) {
+    if (key.startsWith(prefix)) {
+      clearTimeout(timer);
+      heapHolder.incrementalTimers.delete(key);
+    }
+  }
+  for (const key of heapHolder.pendingIncrementalKeys) {
+    if (key.startsWith(prefix)) {
+      heapHolder.pendingIncrementalKeys.delete(key);
+    }
+  }
+  for (const key of heapHolder.completedIncrementalKeys) {
+    if (key.startsWith(prefix))
+      heapHolder.completedIncrementalKeys.delete(key);
+  }
+}
+
 // src/hooks/magic-context/module-transport.ts
 import { realpathSync } from "node:fs";
 import { join } from "node:path";
@@ -1799,6 +2103,8 @@ function createUnifiedSearchDiagnostics2() {
   };
 }
 function searchMessageHistory2(db, request) {
+  if (!isMessageIndexSearchable(request.sessionId))
+    return { results: [], suppressedLiveMessageMatches: 0 };
   const diagnostics = request.collectDiagnostics ? createUnifiedSearchDiagnostics2() : undefined;
   const capture = request.captureLimit ? { limit: request.captureLimit, results: [] } : undefined;
   const results = searchMessages({
@@ -3021,6 +3327,9 @@ function resolveMemoriesByIdsForSearch2(args) {
   });
 }
 async function unifiedSearch2(db, sessionId, projectPath, query, options = {}) {
+  const messageIndexEpoch = getMessageIndexEpoch(sessionId);
+  const messageIndexWasSearchable = isMessageIndexSearchable(sessionId);
+  const messageIndexStillCurrent = () => messageIndexWasSearchable && isMessageIndexSearchable(sessionId) && getMessageIndexEpoch(sessionId) === messageIndexEpoch;
   const trimmedQuery = query.trim();
   const measurementStartedAt = Date.now();
   if (trimmedQuery.length === 0 || options.signal?.aborted) {
@@ -3063,7 +3372,7 @@ async function unifiedSearch2(db, sessionId, projectPath, query, options = {}) {
   const timings = options.stepTimings;
   let stepStartedAt = performance.now();
   let messageResults = [];
-  if (runMessages) {
+  if (runMessages && messageIndexStillCurrent()) {
     const messageRequest = {
       sessionId,
       query: trimmedQuery,
@@ -3237,6 +3546,8 @@ async function unifiedSearch2(db, sessionId, projectPath, query, options = {}) {
       }).immediate();
     }
   }
+  if (!messageIndexStillCurrent())
+    results = results.filter((result) => result.source !== "message");
   if (options.autoHint) {
     return results.map((result) => ({
       ...result,
@@ -3363,4 +3674,4 @@ ${bodyParts.join(`
 `)}`;
 }
 
-export { renderSingleStoreMigrationRequiredRefusal, SingleStoreMigrationRequiredError, singleStoreMigrationRequiredFailure, projectNeedsSingleStoreMigration, STORE_AHEAD_OF_BINARY_CODE, storeAheadOfBinaryFailure, TRANSFORM_PAGE_UPLOAD_TIMEOUT_MS, transformColdStartExecuteTimeoutMs, getDefaultSubcConnectionFile, isModuleTransportGenerationChangedResult, SubcModuleTransport, indexCommitsForProject, embedUnembeddedCommits, createUnifiedSearchDiagnostics2, searchMessageHistory2, parseIdShapedQuery2, resolveMemoriesByIdsForSearch2, unifiedSearch2, formatSearchResults2 };
+export { getMessageIndexEpoch, isMessageIndexSearchable, scheduleReconciliation, scheduleClearAndReindex, getMessageIndexQueueHeapStats, renderSingleStoreMigrationRequiredRefusal, SingleStoreMigrationRequiredError, singleStoreMigrationRequiredFailure, projectNeedsSingleStoreMigration, STORE_AHEAD_OF_BINARY_CODE, storeAheadOfBinaryFailure, TRANSFORM_PAGE_UPLOAD_TIMEOUT_MS, transformColdStartExecuteTimeoutMs, getDefaultSubcConnectionFile, isModuleTransportGenerationChangedResult, SubcModuleTransport, indexCommitsForProject, embedUnembeddedCommits, createUnifiedSearchDiagnostics2, searchMessageHistory2, parseIdShapedQuery2, resolveMemoriesByIdsForSearch2, unifiedSearch2, formatSearchResults2 };

package/dist/v2/{server-ph300d6m.js → server-tkdabx8q.js}

@@ -17,7 +17,7 @@ import {
 } from "./server-6g98c227.js";
 import {
   embedTextForProject2
-} from "./server-zh3esb0z.js";
+} from "./server-ab8017gw.js";
 import {
   saveEmbeddingIfHashMatches
 } from "./server-4dhv7mqz.js";

package/dist/v2/server.js

@@ -7874,7 +7874,7 @@ var require_src2 = __commonJS(function(exports, module) {
 // package.json
 var package_default = {
   name: "@cortexkit/opencode-magic-context",
-  version: "0.49.31",
+  version: "0.49.33",
   type: "module",
   description: "OpenCode plugin for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -8195,7 +8195,7 @@ async function setup(context) {
   if (claimStorageBackupWarningCheck() && isMagicContextStorageOutsideEngram(storageDir)) {
     log2(`[magic-context] Magic Context storage is at ${storageDir}, outside the folder Engram backs up (~/.local/share/cortexkit/magic-context). It is not included in CortexKit backups.`);
   }
-  const { registerContext } = await import("./context-cdqw9jex.js");
+  const { registerContext } = await import("./context-3c4z2wj5.js");
   setHarness2("opencode2");
   bindStaleBuildNotice({}, import.meta.url, "opencode2");
   const duties = await registerContext(context);

package/dist/v2/{wrapup-orchestrator-prfvyqbb.js → wrapup-orchestrator-ga5vfmwr.js}

@@ -19,8 +19,8 @@ import {
   registerActiveCompartmentRun,
   setRecompStarting2,
   setRecompTerminal2
-} from "./server-rdjgz95f.js";
-import"./server-zh3esb0z.js";
+} from "./server-aqbm9c8d.js";
+import"./server-ab8017gw.js";
 import"./server-3mz2qh5a.js";
 import"./server-ab1g0wn9.js";
 import {
@@ -30,7 +30,7 @@ import"./server-51779zs2.js";
 import"./server-cpjk5jd2.js";
 import"./server-6vd2n183.js";
 import"./server-awr8qa4c.js";
-import"./server-4sn3at8p.js";
+import"./server-h1byrhwx.js";
 import"./server-hwag0khr.js";
 import {
   getWrapupInProgressState,
@@ -53,7 +53,7 @@ import"./server-fr0wbhdn.js";
 import"./server-6g98c227.js";
 import"./server-qjvk4a9t.js";
 import"./server-fb3zxn06.js";
-import"./server-ph300d6m.js";
+import"./server-tkdabx8q.js";
 import {
   pushNotification2
 } from "./server-x8a7jmkh.js";
@@ -62,7 +62,7 @@ import"./server-qt1qqasc.js";
 import"./server-bsgd4dk1.js";
 import"./server-4dhv7mqz.js";
 import"./server-vr4szghm.js";
-import"./server-p0snacz3.js";
+import"./server-2aasmpsp.js";
 import"./server-jjvbk92s.js";
 import"./server-835q39kd.js";
 import"./server-29qp8nz4.js";

package/dist/{wrapup-orchestrator-4zhkcsz0.js → wrapup-orchestrator-dy8r3gp8.js}

@@ -1,14 +1,14 @@
 import {
   runManagedWrapup2
-} from "./index-0bjktrjt.js";
-import"./index-y6ynjghv.js";
-import"./index-kmayq4kq.js";
+} from "./index-43vqx0za.js";
+import"./index-dq5xzeb9.js";
+import"./index-2xh37qn5.js";
 import"./index-qgh1qwjj.js";
-import"./index-pe6b4bhs.js";
+import"./index-as2amvn3.js";
 import"./index-4s4zq97n.js";
 import"./index-sd3egckz.js";
-import"./index-vnn5405n.js";
-import"./index-gxkhzmjq.js";
+import"./index-rfxzazzy.js";
+import"./index-2743x98y.js";
 import"./index-jjvbk92s.js";
 import"./index-4dhv7mqz.js";
 import"./index-spwjbkc7.js";
@@ -23,7 +23,7 @@ import"./index-rrv26qjz.js";
 import"./index-51rdvtkz.js";
 import"./index-nxrsns5x.js";
 import"./index-kfyb3k6n.js";
-import"./index-mm93m7y6.js";
+import"./index-v7287tzq.js";
 import"./index-wfybj1dw.js";
 import"./index-hbt0sbv2.js";
 import"./index-fb3zxn06.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/opencode-magic-context",
-  "version": "0.49.31",
+  "version": "0.49.33",
   "type": "module",
   "description": "OpenCode plugin for Magic Context — cross-session memory and context management",
   "main": "dist/index.js",