@cortexkit/opencode-magic-context 0.49.31 → 0.49.33

package/dist/index-94ef0qe2.js

@@ -0,0 +1,429 @@
+import {
+  getHarness2
+} from "./index-pavzsdc6.js";
+import {
+  log2,
+  sessionLog2
+} from "./index-h7tgn49j.js";
+import {
+  inRootAsyncContext2,
+  getSqliteDatabasePath2,
+  withSqliteBackgroundWriter2,
+  indexCoordinationInput2
+} from "./index-gzy5w8ya.js";
+import {
+  runSessionWarmupWorker
+} from "./index-rverk2vz.js";
+import {
+  scheduleAfterBootQuiet
+} from "./index-kq5w68dp.js";
+import {
+  getMessageIndexSourceIdentity,
+  isMessageIndexSourceCurrent,
+  getLastIndexedOrdinal,
+  getMessageIndexReconciliationStartOrdinal,
+  isMessageIndexReconciledThrough,
+  clearIndexedMessages,
+  indexSingleMessage,
+  indexMessagesAfterOrdinal
+} from "./index-4s4zq97n.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 INCREMENTAL_DEBOUNCE_MS = 100;
+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 scheduleIncrementalIndex(db, sessionId, messageId, messageSource) {
+  const schedulingKey = `${sessionId}\x00${messageId}`;
+  const epoch = sessionEpochs.get(sessionId) ?? 0;
+  if (heapHolder.pendingIncrementalKeys.has(schedulingKey))
+    return;
+  const activeTimer = heapHolder.incrementalTimers.get(schedulingKey);
+  if (activeTimer)
+    clearTimeout(activeTimer);
+  const timer = inRootAsyncContext2(() => setTimeout(() => {
+    heapHolder.incrementalTimers.delete(schedulingKey);
+    heapHolder.pendingIncrementalKeys.add(schedulingKey);
+    const indexMessage = async () => {
+      if ((sessionEpochs.get(sessionId) ?? 0) !== epoch || !heapHolder.pendingIncrementalKeys.has(schedulingKey))
+        return;
+      const message = typeof messageSource === "function" ? messageSource(sessionId, messageId) : messageSource;
+      if (!message)
+        return;
+      const revisionKey = `${schedulingKey}\x00${getMessageIndexSourceIdentity(message)}`;
+      if (heapHolder.completedIncrementalKeys.has(revisionKey))
+        return;
+      const currentWatermark = getLastIndexedOrdinal(db, sessionId);
+      if (message.ordinal <= currentWatermark && isMessageIndexSourceCurrent(db, sessionId, message)) {
+        heapHolder.completedIncrementalKeys.add(revisionKey);
+        return;
+      }
+      const wasReconciled = heapHolder.reconciledSessions.delete(sessionId);
+      await indexSingleMessageOffThread(db, sessionId, message);
+      if ((sessionEpochs.get(sessionId) ?? 0) !== epoch || !heapHolder.pendingIncrementalKeys.has(schedulingKey))
+        return;
+      const finalWatermark = getLastIndexedOrdinal(db, sessionId);
+      if (wasReconciled && isMessageIndexReconciledThrough(db, sessionId, finalWatermark)) {
+        heapHolder.reconciledSessions.add(sessionId);
+      }
+      heapHolder.completedIncrementalKeys.add(revisionKey);
+    };
+    sourceReady(messageSource, sessionId).then((ready) => {
+      if ((sessionEpochs.get(sessionId) ?? 0) !== epoch)
+        return;
+      if (ready)
+        return runWithSessionLock(sessionId, indexMessage);
+      setTimeout(() => {
+        if (getMessageIndexEpoch(sessionId) === epoch)
+          scheduleIncrementalIndex(db, sessionId, messageId, messageSource);
+      }, PREPARE_RETRY_MS).unref?.();
+    }).catch((error) => {
+      if ((sessionEpochs.get(sessionId) ?? 0) !== epoch)
+        return;
+      heapHolder.reconciledSessions.delete(sessionId);
+      logIndexingError(sessionId, `incremental index for ${messageId}`, error);
+      if (isDatabaseLockedError(error))
+        setTimeout(() => {
+          if (getMessageIndexEpoch(sessionId) === epoch)
+            scheduleIncrementalIndex(db, sessionId, messageId, messageSource);
+        }, 1000).unref();
+    }).finally(() => {
+      if ((sessionEpochs.get(sessionId) ?? 0) === epoch)
+        heapHolder.pendingIncrementalKeys.delete(schedulingKey);
+    });
+  }, INCREMENTAL_DEBOUNCE_MS));
+  heapHolder.incrementalTimers.set(schedulingKey, timer);
+}
+async function indexSingleMessageOffThread(db, sessionId, message) {
+  const path = getSqliteDatabasePath2(db);
+  if (!path)
+    return withSqliteBackgroundWriter2(() => indexSingleMessage(db, sessionId, message));
+  const cancellation = new Int32Array(new SharedArrayBuffer(4));
+  const active = indexCancellations.get(sessionId) ?? new Set;
+  active.add(cancellation);
+  indexCancellations.set(sessionId, active);
+  const result = await runSessionWarmupWorker({
+    path,
+    sessionId,
+    indexMessage: message,
+    harness: getHarness2(),
+    indexCancellation: cancellation.buffer,
+    ...indexCoordinationInput2()
+  }, {}).finally(() => {
+    active.delete(cancellation);
+    if (active.size === 0)
+      indexCancellations.delete(sessionId);
+  });
+  if (!("inserted" in result))
+    throw new Error("failure" in result ? result.detail : "unexpected indexing worker reply");
+  if (result.measurements) {
+    const sessions = workerMeasurements.get(db) ?? new Map;
+    sessions.set(sessionId, result.measurements);
+    workerMeasurements.set(db, sessions);
+    if (result.measurements.skipped)
+      log2(`[magic-context] incremental FTS skipped oversized source ${message.id} (${result.measurements.sourceBytes} bytes); identity and progress persisted`);
+  }
+  return result.inserted;
+}
+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 clearSessionTracking(sessionId) {
+  invalidateIncrementalWork(sessionId);
+  heapHolder.clearAndReindexScheduledSessions.delete(sessionId);
+  heapHolder.reconciledSessions.delete(sessionId);
+  heapHolder.reconciledSnapshots.delete(sessionId);
+  heapHolder.stalledSessions.delete(sessionId);
+  heapHolder.reconciliationScheduledSessions.delete(sessionId);
+  heapHolder.sessionLocks.delete(sessionId);
+  heapHolder.activeReconcilerBuffers.delete(sessionId);
+}
+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);
+  }
+}
+
+export { getMessageIndexEpoch, isMessageIndexSearchable, scheduleReconciliation, scheduleIncrementalIndex, scheduleClearAndReindex, getMessageIndexQueueHeapStats, clearSessionTracking };

package/dist/{index-pe6b4bhs.js → index-as2amvn3.js}

@@ -17,7 +17,7 @@ import {
 } from "./index-7kkphb6c.js";
 import {
   embedTextForProject2
-} from "./index-gxkhzmjq.js";
+} from "./index-2743x98y.js";
 import {
   saveEmbeddingIfHashMatches
 } from "./index-4dhv7mqz.js";

package/dist/{index-qathsvz2.js → index-b7w46fp2.js}

@@ -98,7 +98,7 @@ import {
   getProjectEmbeddingSnapshot2,
   embedTextForProject2,
   embedBatchForProject2
-} from "./index-gxkhzmjq.js";
+} from "./index-2743x98y.js";
 import {
   createWorkerShutdown
 } from "./index-cpjk5jd2.js";
@@ -140,7 +140,7 @@ import {
   peekNoteNudgeText,
   markNoteNudgeDelivered,
   getActiveCompartmentRun
-} from "./index-kmayq4kq.js";
+} from "./index-2xh37qn5.js";
 import {
   cleanSearchText,
   matchedSearchSnippet
@@ -257,9 +257,13 @@ import {
 import {
   BoundedSessionMap
 } from "./index-s1n8dd2n.js";
+import {
+  getMessageIndexEpoch,
+  isMessageIndexSearchable
+} from "./index-94ef0qe2.js";
 import {
   userFacingFailureCode
-} from "./index-pe6b4bhs.js";
+} from "./index-as2amvn3.js";
 import {
   normalizeProtectedToolName,
   mergeProtectedTools
@@ -1356,6 +1360,8 @@ class AutoSearchBusyError extends Error {
   }
 }
 async function searchAutoHint(db, sessionId, projectPath, query, options, entry = new URL(new URL(import.meta.url).pathname.endsWith(".ts") ? "./auto-search-worker.ts" : "./auto-search-worker.js", import.meta.url)) {
+  const messageIndexEpoch = getMessageIndexEpoch(sessionId);
+  const messageIndexWasSearchable = isMessageIndexSearchable(sessionId);
   const {
     rerankConfig: _rerankConfig,
     rerankClient: _rerankClient,
@@ -1364,7 +1370,8 @@ async function searchAutoHint(db, sessionId, projectPath, query, options, entry
     captureRerankLanes: _captureRerankLanes,
     ...hintOptions
   } = options;
-  return executeAutoSearchWorker(db, sessionId, projectPath, query, { ...hintOptions, explicitSearch: false, rerank: false }, entry, "search");
+  const results = await executeAutoSearchWorker(db, sessionId, projectPath, query, { ...hintOptions, explicitSearch: false, rerank: false }, entry, "search");
+  return messageIndexWasSearchable && isMessageIndexSearchable(sessionId) && getMessageIndexEpoch(sessionId) === messageIndexEpoch ? results : results.filter((result) => result.source !== "message");
 }
 var pendingBackfills = new WeakMap;
 var searchWorkers = new WeakMap;
@@ -3391,6 +3398,7 @@ function hasSmallToolInput(target) {
 var CACHE_LOSING_FOLD_REASONS = new Set([
   "model_change",
   "system_hash",
+  "tool_definitions",
   "ttl_idle",
   "host_compaction"
 ]);
@@ -6287,6 +6295,10 @@ async function runPostTransformPhase2(args) {
       sessionLog2(args.sessionId, "transform: m[0] HARD fold pre-execution failed:", getErrorMessage(error));
     }
     sessionLog2(args.sessionId, `m[0] HARD fold decision: reason=${m0MaterializeReason ?? foldDueDecision.reason ?? (foldExecutedThisPass ? "drift" : "soft_refresh")} executed=${foldExecutedThisPass} bustsServedPrefix=${foldBustsServedPrefixThisPass}`);
+    const toolChange = m0ComparisonDecision?.toolDefinitionsChange;
+    if (foldExecutedThisPass && toolChange) {
+      sessionLog2(args.sessionId, "m[0] request tool definitions changed:", JSON.stringify(toolChange));
+    }
   }
   logTransformTiming(args.sessionId, "pp.prefixPreflight", tPostprocessSetup, `foldExecuted=${foldExecutedThisPass} m1Refreshed=${publishedM1RefreshedThisPass}`);
   const tPassDecisions = performance.now();

package/dist/{index-y6ynjghv.js → index-dq5xzeb9.js}

@@ -8,11 +8,11 @@ import {
   requestPendingMaterialization,
   dropSlot,
   executeContextRecomp
-} from "./index-kmayq4kq.js";
+} from "./index-2xh37qn5.js";
 import {
   renderUserFacingFailure,
   userFacingFailureCode
-} from "./index-pe6b4bhs.js";
+} from "./index-as2amvn3.js";
 
 // src/hooks/magic-context/recomp-orchestrator.ts
 function resolveLiveModelKey(liveSessionState, sessionId) {

package/dist/{index-vtz789ex.js → index-qr2mb02j.js}

@@ -24,7 +24,7 @@ import {
   loadCompartmentChunkEmbeddingsForSearch2,
   peekCompartmentChunkSearchPool2,
   warmCompartmentChunkSearchPool2
-} from "./index-mm93m7y6.js";
+} from "./index-v7287tzq.js";
 import {
   recordEmbeddingMeasurement,
   saveCommitEmbedding,
@@ -41,7 +41,7 @@ import {
   enqueueShadowEmbeddingItems2,
   getProjectEmbeddingSnapshot2,
   embedItemsForProject2
-} from "./index-gxkhzmjq.js";
+} from "./index-2743x98y.js";
 import {
   getProjectEmbeddings2
 } from "./index-4dhv7mqz.js";
@@ -50,7 +50,7 @@ import {
   isEmbeddingEnabled,
   embedText,
   ensureMemoryEmbeddings2
-} from "./index-vnn5405n.js";
+} from "./index-rfxzazzy.js";
 import {
   ModuleMemoryAuthorityError2,
   getMemoriesByProject2,
@@ -65,7 +65,7 @@ import {
   sanitizeFtsQuery,
   searchMemoriesFTS,
   searchMemoriesFTSUnion
-} from "./index-pe6b4bhs.js";
+} from "./index-as2amvn3.js";
 import {
   cleanSearchText,
   keywordRelevance,
@@ -79,6 +79,10 @@ import {
 import {
   isRecord
 } from "./index-np3rgfw4.js";
+import {
+  getMessageIndexEpoch,
+  isMessageIndexSearchable
+} from "./index-94ef0qe2.js";
 import {
   resolveWorkspaceShareCategories,
   resolveWorkspaceIdentitySet,
@@ -1801,6 +1805,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({
@@ -3023,6 +3029,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) {
@@ -3065,7 +3074,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,
@@ -3239,6 +3248,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,

package/dist/{index-vnn5405n.js → index-rfxzazzy.js}

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