@cortexkit/pi-magic-context 0.49.30 → 0.49.32

package/dist/{index-0cq3g9y5.js → index-e59j3yq5.js}

@@ -3,7 +3,10 @@ import {
 } from "./index-0h2mkab2.js";
 import {
   inRootAsyncContext2,
-  isTransientSqliteError2
+  getSqliteDatabasePath2,
+  withSqliteBackgroundWriter2,
+  isTransientSqliteError2,
+  indexCoordinationInput2
 } from "./index-2qtx0q6h.js";
 import {
   PROMOTABLE_CATEGORIES,
@@ -22,19 +25,22 @@ import {
   resolveStoredPathWorkspaceIdentity,
   sourceNameForMemory,
   managedAuthorityNoteRow
-} from "./index-0s14xaca.js";
+} from "./index-pb3ea2tq.js";
 import {
-  isKnownAutocommit
-} from "./index-g026ztby.js";
+  scheduleAfterBootQuiet
+} from "./index-48twbev2.js";
 import {
   SubcClient
 } from "./index-gwxaz0z5.js";
+import {
+  runSessionWarmupWorker
+} from "./index-6981g1xv.js";
 import {
   buildCanonicalChunkTextFromFts2,
   loadCompartmentChunkEmbeddingsForSearch2,
   peekCompartmentChunkSearchPool2,
   warmCompartmentChunkSearchPool2
-} from "./index-kmk3xpf9.js";
+} from "./index-0gymvr5j.js";
 import {
   recordEmbeddingMeasurement,
   saveCommitEmbedding,
@@ -52,7 +58,7 @@ import {
   getProjectEmbeddingSnapshot2,
   embedTextForProject2,
   embedItemsForProject2
-} from "./index-0jykn0dw.js";
+} from "./index-xn5yh0pn.js";
 import {
   saveEmbeddingIfHashMatches,
   getProjectEmbeddings2
@@ -62,7 +68,7 @@ import {
   isEmbeddingEnabled,
   embedText,
   ensureMemoryEmbeddings2
-} from "./index-4nny4r40.js";
+} from "./index-9xd7qveg.js";
 import {
   getMemorySelectColumns2,
   isMemoryRow2,
@@ -81,8 +87,16 @@ import {
   cleanSearchText,
   keywordRelevance,
   matchedSearchSnippet,
-  getIndexedMessageCorpusSize
-} from "./index-74bc8ts8.js";
+  getMessageIndexSourceIdentity,
+  isMessageIndexSourceCurrent,
+  getLastIndexedOrdinal,
+  getIndexedMessageCorpusSize,
+  getMessageIndexReconciliationStartOrdinal,
+  isMessageIndexReconciledThrough,
+  clearIndexedMessages,
+  indexSingleMessage,
+  indexMessagesAfterOrdinal
+} from "./index-wpazxe9x.js";
 import {
   MESSAGE_FTS_SESSION_FILTER_SQL,
   withMessageFtsSessionFilter
@@ -90,6 +104,9 @@ import {
 import {
   computeNormalizedHash
 } from "./index-9x1f96r8.js";
+import {
+  isKnownAutocommit
+} from "./index-nrzkqte4.js";
 
 // ../plugin/src/features/magic-context/storage-notes.ts
 var NOTE_TYPES = new Set(["session", "smart"]);
@@ -1811,6 +1828,385 @@ function searchGitCommitsSync(db, projectPath, query, options) {
   });
   return results.slice(0, options.limit);
 }
+// ../plugin/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 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 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);
+  }
+}
+
 // ../plugin/src/features/magic-context/literal-probes.ts
 var MAX_PROBES = 5;
 var MIN_PROBE_LENGTH = 3;
@@ -2342,6 +2738,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({
@@ -3564,6 +3962,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) {
@@ -3606,7 +4007,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,
@@ -3780,6 +4181,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,
@@ -3906,4 +4309,4 @@ ${bodyParts.join(`
 `)}`;
 }
 
-export { getNoteByIdInScope, getNotes, addNote, getSessionNotes, getPendingSmartNotes, getReadySmartNotes, updateNote, dismissNotes, dismissNote, markNoteReady, markNoteChecked, PRIMER_CANDIDATE_TTL_MS, PRIMER_CANDIDATE_MAX_AGE_MS, primerOccurrenceKey, primerOccurrenceUtcDay, insertPrimerCandidates, updatePrimerCandidateEmbedding, getPrimerCandidatesByIds, getPrimerCandidatesForPromotion, countPrimerCandidatesForProject, getActivePrimers, createPrimer, updatePrimerSupport, updatePrimerAnswer, USER_FACING_FAILURES, renderUserFacingFailure, userFacingFailureCode, renderCapabilityRefusal, renderDreamFailure, dreamFailureCode, renderEmbeddingFailure, renderSingleStoreMigrationRequiredRefusal, SingleStoreMigrationRequiredError, projectNeedsSingleStoreMigration, promoteSessionFactsDurable, embedPromotedFacts, recordMemoryMapping, recordMemoryVerifications, getUnmappedMemoryIds, clearMemoryVerifications, getMemoryVerifications, resolveGitTopLevel, readGitHead, readGitChangedFilesSince, readGitFileChangeTimesSince, verificationFileExists, normalizeVerificationFiles, indexCommitsForProject, embedUnembeddedCommits, createUnifiedSearchDiagnostics2, searchMessageHistory2, parseIdShapedQuery2, resolveMemoriesByIdsForSearch2, unifiedSearch2, formatSearchResults2 };
+export { getNoteByIdInScope, getNotes, addNote, getSessionNotes, getPendingSmartNotes, getReadySmartNotes, updateNote, dismissNotes, dismissNote, markNoteReady, markNoteChecked, PRIMER_CANDIDATE_TTL_MS, PRIMER_CANDIDATE_MAX_AGE_MS, primerOccurrenceKey, primerOccurrenceUtcDay, insertPrimerCandidates, updatePrimerCandidateEmbedding, getPrimerCandidatesByIds, getPrimerCandidatesForPromotion, countPrimerCandidatesForProject, getActivePrimers, createPrimer, updatePrimerSupport, updatePrimerAnswer, USER_FACING_FAILURES, renderUserFacingFailure, userFacingFailureCode, renderCapabilityRefusal, renderDreamFailure, dreamFailureCode, renderEmbeddingFailure, renderSingleStoreMigrationRequiredRefusal, SingleStoreMigrationRequiredError, projectNeedsSingleStoreMigration, promoteSessionFactsDurable, embedPromotedFacts, recordMemoryMapping, recordMemoryVerifications, getUnmappedMemoryIds, clearMemoryVerifications, getMemoryVerifications, resolveGitTopLevel, readGitHead, readGitChangedFilesSince, readGitFileChangeTimesSince, verificationFileExists, normalizeVerificationFiles, indexCommitsForProject, embedUnembeddedCommits, getMessageIndexEpoch, isMessageIndexSearchable, scheduleReconciliation, scheduleIncrementalIndex, scheduleClearAndReindex, clearSessionTracking, createUnifiedSearchDiagnostics2, searchMessageHistory2, parseIdShapedQuery2, resolveMemoriesByIdsForSearch2, unifiedSearch2, formatSearchResults2 };

package/dist/{index-0x1c054v.js → index-eqw9t2ty.js}

@@ -15,7 +15,7 @@ import {
   jsonHashSink,
   tagOrderConstraintIndex,
   tagIdentityRevisionKey
-} from "./index-g026ztby.js";
+} from "./index-c474g0gj.js";
 import {
   DEFAULT_PROTECTED_TOOLS,
   normalizeProtectedToolName,

package/dist/index-nrzkqte4.js

@@ -0,0 +1,18 @@
+// ../plugin/src/shared/sqlite-helpers.ts
+function closeQuietly(db) {
+  if (!db)
+    return;
+  try {
+    db.close();
+  } catch {}
+}
+function isKnownAutocommit(db) {
+  const state = db;
+  try {
+    return state.inTransaction === false || state.isTransaction === false;
+  } catch {
+    return false;
+  }
+}
+
+export { closeQuietly, isKnownAutocommit };

package/dist/{index-0s14xaca.js → index-pb3ea2tq.js}

@@ -8,7 +8,7 @@ import {
   ensureColumn,
   healAllNullColumns,
   installV95PerfSchema
-} from "./index-g026ztby.js";
+} from "./index-c474g0gj.js";
 import {
   resolveOpenCodeDbPath,
   openCodeDbPathExists,

package/dist/{index-y5x5wt5t.js → index-r9y6tbbm.js}

@@ -41,19 +41,21 @@ import {
   hasPendingMigrations,
   getMainThreadMigrationBodyCount,
   runMigrations
-} from "./index-0s14xaca.js";
+} from "./index-pb3ea2tq.js";
 import {
-  closeQuietly,
   ensureColumn,
   installV95PerfSchema,
   installTagIdentityRevisionTrigger
-} from "./index-g026ztby.js";
+} from "./index-c474g0gj.js";
 import {
   resolveOpenCodeDbPath,
   hasV1MessageTables,
   setDatabase,
   loadToolDefinitionMeasurements
 } from "./index-23t8ryqw.js";
+import {
+  closeQuietly
+} from "./index-nrzkqte4.js";
 import {
   logSlowWriteTransaction
 } from "./index-hqw0rt9k.js";
@@ -2003,7 +2005,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-73kd0ans.js"));
+        const { readRawSessionMessagePage, readRawSessionMessages } = await importPluginModule(() => import("./read-session-chunk-ka6dhc77.js"));
         const { startMessageTimeBackfill } = await importPluginModule(() => import("./message-time-backfill-e3r8ddh1.js"));
         if (signal.aborted)
           return;