@cortexkit/opencode-magic-context 0.49.30 → 0.49.32

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.30",
+  version: "0.49.32",
   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-wx4sfhgr.js");
+  const { registerContext } = await import("./context-ehews84p.js");
   setHarness2("opencode2");
   bindStaleBuildNotice({}, import.meta.url, "opencode2");
   const duties = await registerContext(context);

package/dist/v2/{wrapup-orchestrator-2t0pdqzm.js → wrapup-orchestrator-ddmvbkra.js}

@@ -19,8 +19,8 @@ import {
   registerActiveCompartmentRun,
   setRecompStarting2,
   setRecompTerminal2
-} from "./server-k33t88h3.js";
-import"./server-zh3esb0z.js";
+} from "./server-4n176b5m.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-kjmkms5g.js → wrapup-orchestrator-fyvyzcbm.js}

@@ -1,14 +1,14 @@
 import {
   runManagedWrapup2
-} from "./index-69gd2scx.js";
-import"./index-adr4vfys.js";
-import"./index-k0dpkyn7.js";
+} from "./index-t6b3px80.js";
+import"./index-2agkcr3y.js";
+import"./index-bzwh06cp.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.30",
+  "version": "0.49.32",
   "type": "module",
   "description": "OpenCode plugin for Magic Context — cross-session memory and context management",
   "main": "dist/index.js",

package/src/shared/tag-transcript.ts

@@ -76,6 +76,8 @@ import type { Transcript, TranscriptMessage, TranscriptPart } from "./transcript
 export { TEXT_TAG_IDENTITY_MARKER };
 
 export interface TagTranscriptOptions {
+    /** Independently validated text sources; does not authorize tool accounting reuse. */
+    reuseTextMessageIds?: ReadonlySet<string>;
     /** Keep tag-only assistant slots inert when their original text must survive stripping. */
     preserveTagOnlyAssistantText?: boolean;
     /**
@@ -125,6 +127,8 @@ export interface TagTranscriptResult {
     targets: Map<number, TagTarget>;
 }
 
+type PersistedDropTag = Pick<TagEntry, "tagNumber" | "messageId" | "type" | "toolOwnerMessageId">;
+
 /**
  * Bind durable drops to a saved request without tagging it again. Recovery must
  * not allocate identities, inject prefixes, or write accounting while the store
@@ -132,7 +136,7 @@ export interface TagTranscriptResult {
  */
 export function buildPersistedDropTargets(
     transcript: Transcript,
-    tags: readonly TagEntry[],
+    tags: readonly PersistedDropTag[],
     options: { allowReasoningPrefixRewrite?: boolean } = {},
 ): Map<number, TagTarget> {
     const targets = new Map<number, TagTarget>();
@@ -147,7 +151,7 @@ export function buildPersistedDropTargets(
     const byNumber = new Map(tags.map((tag) => [tag.tagNumber, tag]));
     const aggregates = new Map<
         string,
-        { tag?: TagEntry; occurrences: ToolOccurrence[]; reasoning: boolean }
+        { tag?: PersistedDropTag; occurrences: ToolOccurrence[]; reasoning: boolean }
     >();
     const pending = new Map<string, string[]>();
     const resolved = new Map<string, string>();
@@ -421,7 +425,10 @@ export function tagTranscript(
                     skipPrefixInjection,
                     preserveTagOnlyAssistantText: options.preserveTagOnlyAssistantText,
                     entryFingerprint: options.entryFingerprintByMessageId?.get(messageId) ?? null,
-                    reuseIdentity: reuseIdentity || contentDerivedTextIds !== undefined,
+                    reuseIdentity:
+                        reuseIdentity ||
+                        options.reuseTextMessageIds?.has(messageId) === true ||
+                        contentDerivedTextIds !== undefined,
                     timing,
                     textIdentitySourceCache: options.textIdentitySourceCache,
                     textTokenCache: options.textTokenCache,
@@ -512,6 +519,11 @@ export function tagTranscript(
                             timing,
                             options.toolTokenCache,
                             tokenCacheKey,
+                            {
+                                byteSize: existing.maxByteSize,
+                                tokenCount: existing.maxTokenCount,
+                                inputTokenCount: existing.inputTokenCount,
+                            },
                         );
                         text = accounting.text;
                         if (part.kind === "tool_result") {
@@ -627,6 +639,7 @@ export function tagTranscript(
                         timing,
                         options.toolTokenCache,
                         tokenCacheKey,
+                        tagger.getToolTagAccounting(sessionId, callId, messageId),
                     );
                     text = accounting.text;
                     const outputByteSize = part.kind === "tool_result" ? accounting.byteSize : 0;
@@ -784,12 +797,23 @@ function readAggregateToolAccounting(
     timing: TagTranscriptTiming | undefined,
     tokenCache?: Map<string, { text: string; tokenCount: number }>,
     tokenCacheKey?: string,
+    persisted?: { byteSize: number; tokenCount: number | null; inputTokenCount: number | null },
 ): AggregateToolAccounting {
     const text = part.getText() ?? "";
     const byteSize = getToolPartByteSize(part, text);
-    const metadata = part.getToolMetadata();
+    // Persisted tool-result accounting tracks the largest byte size seen. Skip
+    // output tokenization when that size has not grown and a count is stored;
+    // known input counts also need no tokenization. Growth and missing counts still
+    // use the counting path, even if the owning message ID was not eligible for
+    // tag reuse through options.reuseMessageIds.
+    const metadata = part.getToolMetadata({
+        skipInputTokenCount: persisted?.inputTokenCount != null,
+    });
     let tokenCount = 0;
-    if (part.kind === "tool_result") {
+    if (
+        part.kind === "tool_result" &&
+        (!persisted || persisted.tokenCount === null || byteSize > persisted.byteSize)
+    ) {
         const tokenStart = timing ? performance.now() : 0;
         tokenCount = getCachedToolPartTokenCount(part, text, tokenCache, tokenCacheKey);
         if (timing) timing.tokenCounting += performance.now() - tokenStart;
@@ -1423,6 +1447,11 @@ function buildAggregateTarget(
         },
         // Open invocations still belong to the current turn; only complete arcs reclaim.
         prepareDrop: () => !occurrences.some((occ) => occ.part.canRemove?.() === "defer"),
+        prepareReplayDrop: () => {
+            if (complete() && !requiresToolArcSkeleton) {
+                for (const occ of occurrences) occ.part.canRemove?.();
+            }
+        },
         canDrop: () => complete() && !occurrences.some((occ) => occ.part.hasUserAnswer?.()),
         requiresToolArcSkeleton,
         // Non-mutating read of the invocation input (the tool_use occurrence

package/src/shared/transcript.ts

@@ -139,7 +139,7 @@ export interface TranscriptPart {
      *
      * For non-tool parts both byte fields are undefined/0.
      */
-    getToolMetadata(): {
+    getToolMetadata(options?: { skipInputTokenCount?: boolean }): {
         toolName: string | undefined;
         inputByteSize: number;
         inputTokenCount: number;