@codemem/opencode-plugin 0.44.0-alpha.1 → 0.44.0

package/.opencode/plugins/codemem.js

@@ -13,20 +13,28 @@ import {
   resolveAutoUpdatePlan,
   resolveUpgradeGuidance,
 } from "../lib/compat.js";
+import {
+  DEFAULT_DRAIN_LIMIT,
+  DEFAULT_MAX_ENTRIES,
+  RAW_EVENT_SPOOL_FULL_CODE,
+  loadRawEventSpoolEntries,
+  removeRawEventSpoolEntry,
+  resolveSpoolDirectory,
+  writeRawEventSpoolEntry,
+} from "../lib/raw-event-spool.js";
 
 const TRUTHY_VALUES = ["1", "true", "yes"];
 const DISABLED_VALUES = ["0", "false", "off"];
-const PINNED_BACKEND_VERSION = "0.44.0-alpha.1";
+const PINNED_BACKEND_VERSION = "0.44.0";
 const COMPAT_CHECK_DELAY_MS = 1500;
 const COMPAT_CHECK_CACHE_TTL_MS = 5 * 60 * 1000;
 const MAX_UPDATE_STATUS_BYTES = 16 * 1024;
 const MAX_UPDATE_ACTION_CHARS = 1000;
 const MAX_UPDATE_VERSION_CHARS = 128;
-const STABLE_RELEASE_VERSION =
-  /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+const RELEASE_VERSION =
+  /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
 const CODEMEM_CONTEXT_PART_ID_PREFIX = "codemem-context-";
 const MAX_MESSAGE_INJECTION_CACHE_SESSIONS = 20;
-const MAX_MESSAGE_INJECTION_CACHE_MESSAGES = 100;
 const COMPACTION_INJECTION_SKIP_TTL_MS = 30 * 1000;
 const MAX_WORKING_SET_PATH_CHARS = 400;
 const VIEWER_HEALTH_CHECK_INTERVAL_MS = 60_000;
@@ -34,12 +42,34 @@ const VIEWER_HEALTH_TIMEOUT_MS = 5_000;
 const VIEWER_HEALTH_RESTART_THRESHOLD = 3;
 const VIEWER_HEALTH_RESTART_COOLDOWN_MS = 5 * 60_000;
 const RAW_EVENTS_STATUS_TIMEOUT_MS = 5_000;
+const DEFAULT_INJECT_TOKEN_BUDGET = 800;
+const DEFAULT_RETAINED_TOKEN_BUDGET = Infinity;
+const CODEMEM_CONTEXT_PREFIX = "[codemem context]\n";
 const DEFAULT_EMBEDDING_MODEL = "Xenova/bge-small-en-v1.5";
 const DEFAULT_EMBEDDING_REVISION = "ea104dacec62c0de699686887e3f920caeb4f3e3";
+const PLUGIN_REGISTRATIONS_KEY = Symbol.for("codemem.opencode-plugin.registrations");
 
 let compatCheckCache = null;
 const notifiedReleaseVersions = new Set();
 
+const claimPluginRegistration = (cwd) => {
+  let registrations = globalThis[PLUGIN_REGISTRATIONS_KEY];
+  if (!(registrations instanceof Map)) {
+    registrations = new Map();
+    globalThis[PLUGIN_REGISTRATIONS_KEY] = registrations;
+  }
+  const projectPath = resolve(cwd);
+  if (registrations.has(projectPath)) return null;
+  const registration = Symbol(projectPath);
+  registrations.set(projectPath, registration);
+  return () => {
+    if (registrations.get(projectPath) === registration) {
+      registrations.delete(projectPath);
+    }
+  };
+};
+const rawEventSpoolDrainsInFlight = new Map();
+
 // Release an unread response body without surfacing cancellation failures.
 const discardResponseBody = (response) => {
   try {
@@ -354,10 +384,74 @@ const clearCompatCheckCache = () => {
   compatCheckCache = null;
 };
 
-const isStableReleaseVersion = (value) => {
-  if (typeof value !== "string" || value.length > MAX_UPDATE_VERSION_CHARS) return false;
-  const match = STABLE_RELEASE_VERSION.exec(value);
-  return Boolean(match && match.slice(1, 4).map(Number).every(Number.isSafeInteger));
+const parseReleaseVersion = (value) => {
+  if (typeof value !== "string" || value.length > MAX_UPDATE_VERSION_CHARS) return null;
+  const match = RELEASE_VERSION.exec(value);
+  if (!match || !match.slice(1, 4).map(Number).every(Number.isSafeInteger)) return null;
+  const prerelease = match[4]?.split(".") || [];
+  if (prerelease.some((identifier) => /^0\d+$/.test(identifier))) return null;
+  return { core: match.slice(1, 4).map(Number), prerelease };
+};
+
+const releaseChannelForVersion = (value) => {
+  const parsed = parseReleaseVersion(value);
+  if (!parsed) return null;
+  if (parsed.prerelease.length === 0) return "latest";
+  const channel = parsed.prerelease[0];
+  return channel === "alpha" || channel === "beta" || channel === "rc" ? channel : null;
+};
+
+const comparePrereleaseIdentifier = (left, right) => {
+  if (left === undefined) return right === undefined ? 0 : -1;
+  if (right === undefined) return 1;
+  if (left === right) return 0;
+  const leftNumeric = /^\d+$/.test(left);
+  const rightNumeric = /^\d+$/.test(right);
+  if (leftNumeric && rightNumeric && left.length !== right.length) {
+    return Math.sign(left.length - right.length);
+  }
+  if (leftNumeric !== rightNumeric) return leftNumeric ? -1 : 1;
+  return left < right ? -1 : 1;
+};
+
+const compareReleaseVersions = (left, right) => {
+  const leftVersion = parseReleaseVersion(left);
+  const rightVersion = parseReleaseVersion(right);
+  if (!leftVersion || !rightVersion) return null;
+  for (let index = 0; index < leftVersion.core.length; index += 1) {
+    const difference = leftVersion.core[index] - rightVersion.core[index];
+    if (difference !== 0) return Math.sign(difference);
+  }
+  if (leftVersion.prerelease.length === 0) {
+    return rightVersion.prerelease.length === 0 ? 0 : 1;
+  }
+  if (rightVersion.prerelease.length === 0) return -1;
+  const length = Math.max(leftVersion.prerelease.length, rightVersion.prerelease.length);
+  for (let index = 0; index < length; index += 1) {
+    const comparison = comparePrereleaseIdentifier(
+      leftVersion.prerelease[index],
+      rightVersion.prerelease[index],
+    );
+    if (comparison !== 0) return comparison;
+  }
+  return 0;
+};
+
+const isSameChannelVersionAtLeast = (currentVersion, minimumVersion) => {
+  const currentChannel = releaseChannelForVersion(currentVersion);
+  if (!currentChannel || currentChannel !== releaseChannelForVersion(minimumVersion)) return false;
+  const comparison = compareReleaseVersions(currentVersion, minimumVersion);
+  return comparison !== null && comparison >= 0;
+};
+
+const PINNED_RELEASE_CHANNEL = releaseChannelForVersion(PINNED_BACKEND_VERSION);
+
+const guidanceMatchesRelease = (guidance, latestVersion) => {
+  const versions =
+    String(guidance || "").match(
+      /\b\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?/g,
+    ) || [];
+  return versions.length === 0 || versions.every((version) => version === latestVersion);
 };
 
 const parseReleaseNotification = (result) => {
@@ -368,18 +462,24 @@ const parseReleaseNotification = (result) => {
     const status = JSON.parse(stdout);
     if (!status || typeof status !== "object" || Array.isArray(status)) return null;
     if (status.update_available !== true) return null;
-    if (!isStableReleaseVersion(status.latest_version)) {
+    if (
+      !PINNED_RELEASE_CHANNEL
+      || status.channel !== PINNED_RELEASE_CHANNEL
+      || releaseChannelForVersion(status.latest_version) !== PINNED_RELEASE_CHANNEL
+    ) {
       return null;
     }
     if (
       typeof status.recommended_action !== "string"
       || !status.recommended_action.trim()
       || status.recommended_action.length > MAX_UPDATE_ACTION_CHARS
+      || !guidanceMatchesRelease(status.recommended_action, status.latest_version)
     ) {
       return null;
     }
     return {
       latestVersion: status.latest_version,
+      channel: PINNED_RELEASE_CHANNEL,
       recommendedAction: status.recommended_action.trim(),
       autoUpdateEligible: status.auto_update_eligible === true,
     };
@@ -691,7 +791,7 @@ const parsePackOutput = (result) => {
     ? Number(metrics.total_items)
     : null;
   const candidatePackText = succeeded && itemCount !== 0
-    ? String(payload?.pack_text || "").trim()
+    ? String(payload?.pack_text || "")
     : "";
   return {
     conflictPackText: ledgerConflict ? candidatePackText : "",
@@ -738,6 +838,7 @@ const isValidLedgerFailureHttpPayload = (payload) =>
   && (
     payload.errorCode === "retrieval_ledger_write_failed"
     || payload.errorCode === "retrieval_ledger_delivery_write_failed"
+    || payload.errorCode === "automatic_recall_write_failed"
   )
   && typeof payload.reason === "string";
 
@@ -761,6 +862,20 @@ const isViewerInvalidRequestPayload = (payload) =>
   && isRecord(payload.error)
   && payload.error.code === "invalid_request";
 
+const classifyRawEventViewerFailure = (payload) => {
+  if (isViewerDbMismatchPayload(payload)) return "database";
+  if (isViewerIdentityMismatchPayload(payload)) return "identity";
+  if (isViewerContractUnsupportedPayload(payload)) return "contract";
+  return "connection";
+};
+
+const RAW_EVENT_FAILURE_ACTIONS = Object.freeze({
+  database: "restart the viewer from the same workspace/config",
+  identity: "restart Codemem and OpenCode with the same environment",
+  contract: "update Codemem on the installed channel, then restart OpenCode",
+  connection: "check or restart the viewer",
+});
+
 // Dependency-free port of @codemem/core prompt-transport semantics. Keep the
 // range and classifier parity pinned by the plugin injection tests.
 const PROMPT_TRANSPORT_PROTOCOL_RANGE = Object.freeze({
@@ -815,9 +930,10 @@ const isViewerPolicyOrAuthFailurePayload = (payload) => {
   ].includes(code);
 };
 
-const viewerFailureClassification = (cause, disposition) => ({
+const viewerFailureClassification = (cause, disposition, kind = null) => ({
   cause,
   disposition,
+  kind,
   retryable: disposition !== "terminal",
 });
 
@@ -854,6 +970,7 @@ const classifyViewerHttpFailure = ({
         kind: "viewer_contract_unsupported",
         compatibleProfile,
       }),
+      "viewer_contract_unsupported",
     );
   }
   if (operation === "prompt-pack-ledger" && isValidLedgerFailureHttpPayload(body)) {
@@ -906,6 +1023,7 @@ const buildPackHttpBody = ({
   dbPath,
   identityTarget,
   attempt,
+  automaticContext,
 }) => ({
   context: query,
   limit: injectLimit !== null && Number.isFinite(injectLimit) && injectLimit > 0
@@ -926,6 +1044,7 @@ const buildPackHttpBody = ({
     .map((value) => String(value || "").trim())
     .filter((value) => value && value.length <= MAX_WORKING_SET_PATH_CHARS),
   attempt,
+  ...(automaticContext !== undefined ? { automatic_context: automaticContext } : {}),
 });
 
 const canonicalJson = (value) => {
@@ -1114,16 +1233,11 @@ const getSessionMessageInjectionCache = (messageInjectionCache, sessionID) => {
   return sessionCache;
 };
 
-const trimSessionMessageInjectionCache = (sessionCache) => {
-  if (!sessionCache) return;
-  while (sessionCache.size > MAX_MESSAGE_INJECTION_CACHE_MESSAGES) {
-    const oldestKey = sessionCache.keys().next().value;
-    if (!oldestKey) break;
-    sessionCache.delete(oldestKey);
+const normalizeInjectedMessageParts = (messages, sessionCache, { pruneAbsent = true } = {}) => {
+  const presentIds = new Set(messages.map(resolveEntryMessageId).filter(Boolean));
+  for (const id of sessionCache?.keys() || []) {
+    if (pruneAbsent && !presentIds.has(id)) sessionCache.delete(id);
   }
-};
-
-const normalizeInjectedMessageParts = (messages, sessionCache) => {
   for (let index = 0; index < messages.length; index += 1) {
     const entry = messages[index];
     if (!isUserMessageEntry(entry) || !Array.isArray(entry.parts)) {
@@ -1131,24 +1245,19 @@ const normalizeInjectedMessageParts = (messages, sessionCache) => {
     }
 
     const messageId = resolveEntryMessageId(entry);
-    const retainedParts = [];
-    let existingText = null;
-    for (const part of entry.parts) {
-      if (isCodememContextPart(part)) {
-        const text = String(part?.text || "");
-        if (text.trim()) {
-          existingText = text;
-        }
-      } else {
-        retainedParts.push(part);
-      }
-    }
-    if (existingText && sessionCache && messageId && !sessionCache.has(messageId)) {
-      sessionCache.set(messageId, { text: existingText, attemptId: null, reconstructed: true });
-      trimSessionMessageInjectionCache(sessionCache);
-    }
-    if (retainedParts.length !== entry.parts.length) {
-      entry.parts.splice(0, entry.parts.length, ...retainedParts);
+    const parts = entry.parts.filter(isCodememContextPart);
+    if (parts.length && sessionCache && messageId) {
+      const cached = sessionCache.get(messageId);
+      sessionCache.set(messageId, {
+        ...cached,
+        text: parts[0].text,
+        parts: parts.map((part) => {
+          const recall = retainedPartRecall(part, cached?.parts);
+          return recall
+            ? { ...part, metadata: { ...part.metadata, codemem: recall } }
+            : { ...part };
+        }),
+      });
     }
   }
 };
@@ -1163,6 +1272,7 @@ const buildInjectedContextPart = (entry, index, text, options = {}) => {
     type: "text",
     text,
     synthetic: true,
+    ...(options.recall ? { metadata: { codemem: options.recall } } : {}),
   };
 };
 
@@ -1203,7 +1313,10 @@ const appendCachedInjectedContextParts = async (
       cacheReuseReady = typeof reuse === "object" ? reuse?.ready : null;
     }
     try {
-      entry.parts.push(buildInjectedContextPart(entry, index, text, { messageId, sessionID }));
+      if (!entry.parts.some(isCodememContextPart)) {
+        const parts = cached?.parts || [buildInjectedContextPart(entry, index, text, { messageId, sessionID })];
+        entry.parts.push(...parts.map((part) => ({ ...part })));
+      }
     } catch (error) {
       if (messageId === options.latestMessageId && attemptId && options.confirmDelivery) {
         if (cacheReuseReady) {
@@ -1230,6 +1343,11 @@ const appendCachedInjectedContextParts = async (
   return appended;
 };
 
+const scopeMessagesToSession = (messages, sessionID) => messages.filter((entry) => {
+  const entrySession = resolveEntrySessionID(entry);
+  return !entrySession || !sessionID || entrySession === sessionID;
+});
+
 const applyInjectedContextToMessages = async ({
   injectEnabled,
   input,
@@ -1243,40 +1361,82 @@ const applyInjectedContextToMessages = async ({
   confirmDelivery,
   recordCacheReuse,
   recordSkipped,
+  injectTokenBudget = DEFAULT_INJECT_TOKEN_BUDGET,
+  retainedTokenBudget = DEFAULT_RETAINED_TOKEN_BUDGET,
+  workingSet = [],
+  recordMeasurement,
 }) => {
   const hasMessages = Array.isArray(output?.messages);
-  const latestUser = hasMessages ? findLatestUserMessage(output.messages) : null;
-  const sessionID = latestUser
-    ? resolveEntrySessionID(latestUser.entry) || input?.sessionID || null
-    : input?.sessionID || null;
+  const hookSessionID = input?.sessionID || null;
+  const hookMessages = hasMessages ? scopeMessagesToSession(output.messages, hookSessionID) : [];
+  const latestUser = findLatestUserMessage(hookMessages);
+  const sessionID = hookSessionID || (latestUser ? resolveEntrySessionID(latestUser.entry) : null);
+  // Both transforms use the hook session when an entry omits session identity.
+  const messages = scopeMessagesToSession(hookMessages, sessionID);
+  const report = (reason, newTokens = 0, duplicates = 0) => {
+    const measurement = {
+      new_tokens: newTokens,
+      retained_tokens: countRetainedInjectionTokens(messages),
+      duplicates_omitted: duplicates,
+      reason,
+    };
+    try { void Promise.resolve(recordMeasurement?.(measurement)).catch(() => {}); } catch { /* best effort */ }
+  };
   if (!injectEnabled) {
     recordSkipped?.("injection_disabled", sessionID);
+    report("injection_disabled");
     return false;
   }
   if (!hasMessages) {
+    report("missing_history");
     return false;
   }
-
   if (consumeCompactionInjectionSkip(compactionInjectionSkips, sessionID)) {
-    normalizeInjectedMessageParts(output.messages, null);
+    const cache = getSessionMessageInjectionCache(messageInjectionCache, sessionID);
+    normalizeInjectedMessageParts(messages, cache, { pruneAbsent: false });
     recordSkipped?.("compaction_skipped", sessionID);
+    report("compaction_skipped");
     return false;
   }
 
   if (!latestUser) {
+    report("missing_user");
     return false;
   }
 
   const sessionCache = getSessionMessageInjectionCache(messageInjectionCache, sessionID);
-  normalizeInjectedMessageParts(output.messages, sessionCache);
+  normalizeInjectedMessageParts(messages, sessionCache);
 
   const latestMessageId = resolveEntryMessageId(latestUser.entry);
   const canReplay = Boolean(sessionCache && latestMessageId);
   const latestCached = canReplay ? sessionCache.get(latestMessageId) : null;
-  const latestWasCached = Boolean(latestCached) && latestCached?.reconstructed !== true;
+  const latestWasCached = Boolean(latestCached) || latestUser.entry.parts?.some(isCodememContextPart);
+  if (sessionCache) {
+    try {
+      await appendCachedInjectedContextParts(messages, sessionCache, sessionID, {
+        latestMessageId, confirmDelivery, recordCacheReuse,
+      });
+    } catch (error) {
+      report("delivery_failed");
+      throw error;
+    }
+  }
+  const retainedTokens = countRetainedInjectionTokens(messages);
+  const fullBudget = Math.min(injectTokenBudget, Math.max(0, retainedTokenBudget - retainedTokens));
   let latestWasBuilt = false;
+  let newlyDelivered = 0;
+  let duplicates = 0;
+  let reason = latestWasCached ? "replay" : "no_context";
   if (!latestWasCached) {
-    const firstUser = findFirstUserMessage(output.messages);
+    if (reserveContextPrefixBudget(fullBudget) === null) {
+      if (reserveContextPrefixBudget(injectTokenBudget) !== null) {
+        recordSkipped?.("allowance_exhausted", sessionID);
+      }
+      report("allowance_exhausted");
+      return retainedTokens > 0;
+    }
+    const firstUser = findFirstUserMessage(messages);
+    const workingContext = workingContextDigest(messages, workingSet);
     const query = resolveInjectQuery({
       firstPrompt: firstUser ? extractMessageText(firstUser.entry) : null,
       lastPromptText: extractMessageText(latestUser.entry),
@@ -1284,36 +1444,62 @@ const applyInjectedContextToMessages = async ({
     const injected = await buildInjectedContext(query, {
       sessionID,
       requestKey: latestMessageId || fallbackEntryMessageId(latestUser.entry, latestUser.index),
+      fallbackTurn: sessionID && latestMessageId ? null : latestUser.index,
       surface: "message",
+      tokenBudget: fullBudget,
+      retainedItems: retainedMemoryFingerprints(messages, sessionCache),
+      retainedMetadata: retainedMetadataGaps(messages, sessionCache),
+      workingContext,
+      continuationOnly: isContinuationOnly(extractMessageText(latestUser.entry), messages, workingContext, sessionCache),
     });
-    if (injected?.text) {
+    // Another transform may have delivered while retrieval was awaiting I/O.
+    if (sessionCache) {
+      await appendCachedInjectedContextParts(messages, sessionCache, sessionID, {
+        latestMessageId, confirmDelivery, recordCacheReuse,
+      });
+    }
+    if (latestUser.entry.parts?.some(isCodememContextPart)) {
+      duplicates = injected?.duplicates || 0;
+      if (injected?.attemptId) {
+        confirmDelivery?.(injected.attemptId, "unknown", injected.evaluation);
+      }
+      report("replay", 0, duplicates);
+      return true;
+    }
+    const deliveryBudget = Math.min(fullBudget, Math.max(
+      0, retainedTokenBudget - countRetainedInjectionTokens(messages),
+    ));
+    duplicates = injected?.duplicates || 0;
+    reason = injected?.skipReason || "no_context";
+    if (injected?.text && estimateTokens(injected.text) <= deliveryBudget) {
       latestWasBuilt = true;
-      if (canReplay) {
-        sessionCache.set(latestMessageId, {
-          text: injected.text,
-          attemptId: injected.attemptId || null,
-          requestId: injected.requestId || null,
-          queryHash: injected.queryHash || null,
-          promptNumber: injected.promptNumber || 0,
-          reuseCount: 0,
-        });
-        trimSessionMessageInjectionCache(sessionCache);
-      } else if (Array.isArray(latestUser.entry.parts)) {
+      if (Array.isArray(latestUser.entry.parts)) {
         try {
           latestUser.entry.parts.push(
             buildInjectedContextPart(latestUser.entry, latestUser.index, injected.text, {
               messageId: latestMessageId || undefined,
               sessionID: sessionID || undefined,
+              recall: injected.recall,
             })
           );
         } catch (error) {
           if (injected.attemptId) {
-            confirmDelivery?.(injected.attemptId, "failed");
+            confirmDelivery?.(injected.attemptId, "failed", injected.evaluation);
           }
+          report("delivery_failed", 0, duplicates);
           throw error;
         }
+        newlyDelivered = estimateTokens(injected.text);
+        reason = "delivered";
         if (injected.attemptId) {
-          confirmDelivery?.(injected.attemptId);
+          confirmDelivery?.(injected.attemptId, "handed_off", injected.evaluation);
+        }
+        if (canReplay) {
+          sessionCache.set(latestMessageId, {
+            ...injected,
+            parts: latestUser.entry.parts.filter(isCodememContextPart).map((part) => ({ ...part })),
+            reuseCount: 0,
+          });
         }
       }
 
@@ -1326,10 +1512,15 @@ const applyInjectedContextToMessages = async ({
           // best-effort only
         }
       }
-    } else if (canReplay && latestCached?.reconstructed === true) {
-      sessionCache.delete(latestMessageId);
+    } else if (injected?.skipReason) {
+      // The retrieval already has an attempt. Withheld output is not a second retrieval.
+      if (injected.attemptId) confirmDelivery?.(injected.attemptId, "unknown", injected.evaluation);
+    } else if (injected?.text) {
+      reason = "budget_rejected";
+      if (injected.attemptId) confirmDelivery?.(injected.attemptId, "failed", injected.evaluation);
     }
   }
+  report(reason, newlyDelivered, duplicates);
 
   if (!canReplay) {
     return Boolean(
@@ -1338,13 +1529,136 @@ const applyInjectedContextToMessages = async ({
     );
   }
 
-  const appended = await appendCachedInjectedContextParts(output.messages, sessionCache, sessionID, {
-    latestMessageId,
-    latestWasBuilt,
-    confirmDelivery,
-    recordCacheReuse,
-  });
-  return appended > 0;
+  return latestWasBuilt || retainedTokens > 0;
+};
+
+const countRetainedInjectionTokens = (messages) => messages.reduce(
+  (sum, entry) => sum + (entry.parts || []).filter(isCodememContextPart)
+    .reduce((tokens, part) => tokens + estimateTokens(part.text), 0),
+  0,
+);
+
+const injectionDigest = (text) => createHash("sha256").update(text).digest("hex");
+
+const retainedPartRecall = (part, cachedParts = []) => {
+  const valid = (candidate) => candidate?.metadata?.codemem?.v === 1
+    && candidate.metadata.codemem.digest === injectionDigest(String(part.text || ""));
+  if (valid(part)) return part.metadata.codemem;
+  const cached = cachedParts.find((candidate) => candidate.id === part.id && candidate.text === part.text && valid(candidate));
+  return cached?.metadata?.codemem;
+};
+
+const workingContextDigest = (messages, workingSet) => {
+  const scalar = (value) => typeof value === "string" ? value.slice(0, 256) : null;
+  const hash = createHash("sha256");
+  for (const path of [...workingSet].filter((value) => typeof value === "string").sort()) {
+    hash.update(JSON.stringify(["file", path.slice(0, MAX_WORKING_SET_PATH_CHARS)]));
+  }
+  for (const entry of messages) {
+    for (const part of entry.parts || []) {
+      if (part.type === "text") continue;
+      // Never traverse args, output, attachments, or arbitrary tool-state payloads.
+      hash.update(JSON.stringify([
+        scalar(entry.info?.id), scalar(part.type), scalar(part.id),
+        scalar(part.callID), scalar(part.state?.status),
+      ]));
+    }
+  }
+  return hash.digest("hex");
+};
+
+const isContinuationOnly = (prompt, messages, workingContext, sessionCache) => {
+  if (!/^(continue|proceed|go on|keep going)[.!]?$/i.test(prompt.trim())) return false;
+  const latest = findLatestUserMessage(messages);
+  for (let index = (latest?.index ?? 0) - 1; index >= 0; index -= 1) {
+    const entry = messages[index];
+    if (!isUserMessageEntry(entry)) continue;
+    return (entry.parts || []).some((part) => {
+      const recall = retainedPartRecall(part, sessionCache?.get(resolveEntryMessageId(entry))?.parts);
+      return isCodememContextPart(part) && recall?.v === 1
+        && recall.digest === injectionDigest(String(part.text || ""))
+        && recall.workingContext === workingContext;
+    });
+  }
+  return false;
+};
+
+const retainedMemoryFingerprints = (messages, sessionCache) => {
+  const retained = new Set();
+  for (const entry of messages) {
+    for (const part of (entry.parts || []).filter(isCodememContextPart)) {
+      const recall = retainedPartRecall(part, sessionCache?.get(resolveEntryMessageId(entry))?.parts);
+      if (recall?.v !== 1 || recall.digest !== injectionDigest(String(part.text || ""))) continue;
+      for (const item of Array.isArray(recall.items) ? recall.items : []) {
+        if (isRecord(item) && Number.isSafeInteger(item.id) && item.id > 0 && /^[a-f0-9]{64}$/.test(item.fingerprint)) {
+          retained.add(`${item.id}:${item.fingerprint}`);
+        }
+      }
+    }
+  }
+  return retained;
+};
+
+const filterRetainedPack = (stdout, packText, retained = new Set()) => {
+  const fallback = { text: packText, items: [], duplicates: 0, packMetadata: "missing" };
+  let payload;
+  try { payload = JSON.parse(stdout); } catch { return fallback; }
+  const items = payload?.rendered_items;
+  if (items != null) fallback.packMetadata = "invalid";
+  // Old transports and malformed metadata remain eligible rather than guessing from prose.
+  if (payload?.pack_text !== packText || !Array.isArray(items) || !items.length) return fallback;
+  if (payload.metrics?.total_items !== items.length) return fallback;
+  const spans = [];
+  const seen = new Set();
+  for (const item of items) {
+    if (!isRecord(item) || !Number.isSafeInteger(item.id) || item.id <= 0 || seen.has(item.id)
+      || !/^[a-f0-9]{64}$/.test(item.fingerprint) || !Array.isArray(item.spans) || !item.spans.length) return fallback;
+    seen.add(item.id);
+    for (const span of item.spans) {
+      if (!isRecord(span) || !Number.isSafeInteger(span.start) || !Number.isSafeInteger(span.end)
+        || span.start < 0 || span.end <= span.start || span.end > packText.length) return fallback;
+      spans.push({ ...span, omit: retained.has(`${item.id}:${item.fingerprint}`) });
+    }
+  }
+  if (payload.items != null) {
+    if (!Array.isArray(payload.items) || payload.items.length !== seen.size) return fallback;
+    const selectedIds = new Set(payload.items.map((item) => item?.id));
+    if (selectedIds.size !== seen.size || [...selectedIds].some((id) => !seen.has(id))) return fallback;
+  }
+  for (const ids of [payload.item_ids, payload.metrics?.pack_item_ids]) {
+    if (ids == null) continue;
+    if (!Array.isArray(ids) || new Set(ids).size !== ids.length
+      || ids.some((id) => !Number.isSafeInteger(id) || id <= 0)
+      || [...seen].some((id) => !ids.includes(id))) return fallback;
+  }
+  spans.sort((a, b) => a.start - b.start);
+  if (spans.some((span, index) => index > 0 && span.start < spans[index - 1].end)) return fallback;
+  const kept = items.filter((item) => !retained.has(`${item.id}:${item.fingerprint}`));
+  let text = packText;
+  for (const span of spans.reverse()) {
+    if (span.omit) text = text.slice(0, span.start) + text.slice(span.end);
+  }
+  return {
+    text: kept.length ? text : "",
+    items: kept.map(({ id, fingerprint }) => ({ id, fingerprint })),
+    duplicates: items.length - kept.length,
+    packMetadata: "valid",
+  };
+};
+
+const retainedMetadataGaps = (messages, sessionCache) => {
+  let missingRetainedMetadata = false;
+  let invalidRetainedMetadata = false;
+  for (const entry of messages) {
+    for (const part of (entry.parts || []).filter(isCodememContextPart)) {
+      const recall = retainedPartRecall(part, sessionCache?.get(resolveEntryMessageId(entry))?.parts);
+      if (recall?.v === 1 && Array.isArray(recall.items) && recall.items.length > 0
+        && recall.items.every((item) => isRecord(item) && Number.isSafeInteger(item.id) && item.id > 0 && /^[a-f0-9]{64}$/.test(item.fingerprint))) continue;
+      if (part.metadata?.codemem != null || recall != null) invalidRetainedMetadata = true;
+      else missingRetainedMetadata = true;
+    }
+  }
+  return { missingRetainedMetadata, invalidRetainedMetadata };
 };
 
 const mapOpencodeEventTypeToAdapterType = (eventType) => {
@@ -1594,7 +1908,11 @@ const trimEventQueue = ({ events, maxEvents, hardMaxEvents, onUnsentPressure, on
       hardMaxEvents > 0 &&
       events.length > hardMaxEvents
     ) {
-      const dropped = events.shift();
+      const durableIndex = events.findIndex(
+        (queued) => queued && typeof queued === "object" && queued._raw_spooled
+      );
+      const dropIndex = durableIndex >= 0 ? durableIndex : 0;
+      const [dropped] = events.splice(dropIndex, 1);
       if (typeof onForcedDrop === "function") {
         onForcedDrop(dropped, events.length, hardMaxEvents);
       }
@@ -1651,6 +1969,25 @@ const parsePositiveInt = (value, fallback) => {
   return parsed;
 };
 
+const estimateTokens = (text) => Math.ceil(String(text || "").length / 4);
+
+const resolveInjectTokenBudget = (value) =>
+  parsePositiveInt(value, DEFAULT_INJECT_TOKEN_BUDGET);
+
+const resolveRetainedTokenBudget = (value) => {
+  const text = String(value ?? "").trim();
+  const parsed = Number(text);
+  return /^\d+$/.test(text) && Number.isSafeInteger(parsed) && parsed > 0
+    ? parsed : DEFAULT_RETAINED_TOKEN_BUDGET;
+};
+
+const reserveContextPrefixBudget = (tokenBudget) => {
+  const packBudget = tokenBudget - estimateTokens(CODEMEM_CONTEXT_PREFIX);
+  return packBudget > 0 ? packBudget : null;
+};
+
+const wrapInjectedContext = (packText) => `${CODEMEM_CONTEXT_PREFIX}${packText}`;
+
 export const buildInjectionToastMessage = (metrics) => {
   const items = asFiniteNonNegativeInt(metrics?.items) ?? asFiniteNonNegativeInt(metrics?.total_items);
   const packTokens = asFiniteNonNegativeInt(metrics?.pack_tokens);
@@ -1693,22 +2030,10 @@ const detectRunner = ({ cwd, envRunner }) => {
       // terminal on every OpenCode startup for npx-only installs.
       stdio: ["ignore", "pipe", "ignore"],
     }).trim();
-    // Accept any global codemem at or above the pinned backend version, so a
-    // newer global install is used instead of silently downgrading to
-    // `npx codemem@<pin>` (the old check only matched the exact pin or the
-    // long-obsolete 0.2x series).
-    // Accept a global codemem only when it is the EXACT pinned version, or a
-    // clean (non-prerelease) release at least as new as the pin. isVersionAtLeast
-    // ignores prerelease suffixes, so without this a prerelease like
-    // "0.36.1-alpha.0" would wrongly compare >= the "0.36.1" release even though
-    // SemVer orders it below. Requiring an exact match for prereleases also
-    // handles a prerelease PIN correctly (the release script can set one): only
-    // the identical prerelease is trusted, never an older/different one.
-    const isPrerelease = versionOutput.includes("-");
-    const matchesOrCleanNewer =
-      versionOutput === PINNED_BACKEND_VERSION ||
-      (!isPrerelease && isVersionAtLeast(versionOutput, PINNED_BACKEND_VERSION));
-    if (matchesOrCleanNewer) {
+    // Use a newer global CLI only when it remains on the plugin's release
+    // channel. This prevents both channel crossing and fallback to an older pin
+    // immediately after a successful prerelease auto-update.
+    if (isSameChannelVersionAtLeast(versionOutput, PINNED_BACKEND_VERSION)) {
       return "codemem";
     }
   } catch {
@@ -1822,6 +2147,13 @@ export const CodememPlugin = async ({
   if (pluginIgnored) {
     return {};
   }
+  const releasePluginRegistration = claimPluginRegistration(cwd);
+  if (!releasePluginRegistration) {
+    await log("warn", "codemem duplicate plugin registration skipped", {
+      next_action: "remove either the configured npm plugin or the project-local Codemem plugin",
+    });
+    return {};
+  }
 
   const runner = detectRunner({
     cwd,
@@ -1871,15 +2203,30 @@ export const CodememPlugin = async ({
     process.env.CODEMEM_INJECT_CONTEXT || "1"
   );
   const injectSurface = resolveInjectSurface(process.env.CODEMEM_INJECT_SURFACE);
-  // Only use env overrides if explicitly set; otherwise CLI uses config defaults
+  // The item limit remains optional so the CLI can use its configured default.
   const injectLimitEnv = process.env.CODEMEM_INJECT_LIMIT;
   const injectLimit = injectLimitEnv ? parseNumber(injectLimitEnv, null) : null;
-  const injectTokenBudgetEnv = process.env.CODEMEM_INJECT_TOKEN_BUDGET;
-  const injectTokenBudget = injectTokenBudgetEnv ? parseNumber(injectTokenBudgetEnv, null) : null;
+  const injectTokenBudget = resolveInjectTokenBudget(
+    process.env.CODEMEM_INJECT_TOKEN_BUDGET
+  );
+  const injectPackTokenBudget = reserveContextPrefixBudget(injectTokenBudget);
+  const retainedTokenBudget = resolveRetainedTokenBudget(process.env.CODEMEM_INJECT_RETAINED_TOKEN_BUDGET);
+  if (injectEnabled && injectPackTokenBudget === null) {
+    await log(
+      "warn",
+      "codemem context injection skipped: token budget is too small",
+      {
+        inject_token_budget: injectTokenBudget,
+        required_prefix_tokens: estimateTokens(CODEMEM_CONTEXT_PREFIX),
+        next_action: "increase CODEMEM_INJECT_TOKEN_BUDGET or unset it to use the default",
+      }
+    );
+  }
   const injectionToastShown = new Set();
   const messageInjectionCache = new Map();
   const compactionInjectionSkips = new Map();
   const disabledInjectionRecorded = new Set();
+  const latestPolicySkips = new Map();
   const attemptStartedAt = new Map();
   const promptPackRetryCounts = new Map();
   const successfulPromptPackArtifacts = new Map();
@@ -1923,9 +2270,22 @@ export const CodememPlugin = async ({
     process.env.CODEMEM_RAW_EVENTS_HARD_MAX || "2000",
     2000
   );
+  const rawEventSpoolDrainLimit = parsePositiveInt(
+    process.env.CODEMEM_RAW_EVENT_SPOOL_DRAIN_LIMIT,
+    DEFAULT_DRAIN_LIMIT,
+  );
+  const rawEventSpoolMaxEntries = parsePositiveInt(
+    process.env.CODEMEM_RAW_EVENT_SPOOL_MAX_ENTRIES,
+    DEFAULT_MAX_ENTRIES,
+  );
+  const rawEventSpoolHome = process.env.HOME?.trim() || homedir();
+  const rawEventSpoolDirectory = resolveSpoolDirectory(rawEventSpoolHome);
+  // Memoize the exact serialized envelope by queued-object identity so retries
+  // cannot drift in timestamp, ID, property order, or bytes.
+  const rawEventEnvelopes = new WeakMap();
   let streamUnavailableUntil = 0;
-  let streamErrorNoted = false;
-  let fallbackFailureNoted = false;
+  let spoolPersistenceFailureNoted = null;
+  let spoolLoadFailureNoted = false;
   let lastStatusCheckAt = 0;
   let lastStatusAvailable = true;
   let promptPackTransportUnavailableUntil = 0;
@@ -1937,9 +2297,9 @@ export const CodememPlugin = async ({
     return `${Date.now()}-${Math.random()}`;
   };
 
-  const queueRawEventViaCli = async (body) => {
+  const queueRawEventViaCli = async (body, serialized = JSON.stringify(body)) => {
     const runFallback = () => runCli(["enqueue-raw-event"], {
-      stdinText: JSON.stringify(body),
+      stdinText: serialized,
     });
     let result = await runFallback();
     let classification = classifyFallbackCommandResult(result);
@@ -1954,23 +2314,191 @@ export const CodememPlugin = async ({
       const error = new Error(
         retryExhausted ? `${classification.cause} after retry` : classification.cause
       );
-      error.retryable = classification.retryable && !attemptedRetry;
+      error.retryable = classification.retryable;
       throw error;
     }
     return true;
   };
 
   const lastToastAtBySession = new Map();
-  const shouldToast = (sessionID) => {
+  const shouldToast = (sessionID, category = "general") => {
     const now = Date.now();
-    const last = lastToastAtBySession.get(sessionID) || 0;
+    const key = `${sessionID || "unknown"}:${category}`;
+    const last = lastToastAtBySession.get(key) || 0;
     if (now - last < 60000) {
       return false;
     }
-    lastToastAtBySession.set(sessionID, now);
+    lastToastAtBySession.set(key, now);
     return true;
   };
 
+  const warnSpoolPersistenceFailure = async (sessionID, reason) => {
+    const message = reason === "spool_full"
+      ? "codemem raw-event retry spool is full; repair Codemem, then archive retained entries"
+      : "codemem could not save a raw event for retry; it remains queued in memory";
+    try {
+      await client.app.log({
+        service: "codemem",
+        level: "error",
+        message,
+        extra: { category: "persistence", reason },
+      });
+    } catch {
+      // Best-effort app logging only.
+    }
+    if (spoolPersistenceFailureNoted === reason) return;
+    spoolPersistenceFailureNoted = reason;
+    if (!client.tui?.showToast || !shouldToast(sessionID, `persistence:${reason}`)) return;
+    try {
+      await client.tui.showToast({
+        body: { message: `codemem: ${message}`, variant: "error" },
+      });
+    } catch {
+      // Best-effort toast only.
+    }
+  };
+
+  const persistRawEventForRetry = async ({ body, serialized, payload, sessionID }) => {
+    try {
+      await writeRawEventSpoolEntry({
+        envelope: body,
+        serialized,
+        homeDir: rawEventSpoolHome,
+        maxEntries: rawEventSpoolMaxEntries,
+      });
+      spoolPersistenceFailureNoted = null;
+      if (payload && typeof payload === "object") {
+        payload._raw_spooled = true;
+      }
+      return true;
+    } catch (error) {
+      const reason = error?.code === RAW_EVENT_SPOOL_FULL_CODE ? "spool_full" : "write_failed";
+      await logLine(`raw_events.spool.${reason} category=persistence`);
+      await warnSpoolPersistenceFailure(sessionID, reason);
+      return false;
+    }
+  };
+
+  const removeRawEventFromSpool = async ({ eventId, payload }) => {
+    try {
+      await removeRawEventSpoolEntry({ eventId, homeDir: rawEventSpoolHome });
+      if (payload && typeof payload === "object") {
+        payload._raw_spooled = false;
+      }
+    } catch {
+      await logLine("raw_events.spool.cleanup_failed category=persistence");
+    }
+  };
+
+  const notifyRawEventDelivery = async ({ category, delivered, durable, sessionID }) => {
+    const action = RAW_EVENT_FAILURE_ACTIONS[category] || RAW_EVENT_FAILURE_ACTIONS.connection;
+    let outcome = "was saved for retry";
+    if (delivered) {
+      outcome = "was queued via CLI";
+    } else if (!durable) {
+      outcome = "was not saved for retry; still queued in memory";
+    }
+    const message = `codemem raw event ${outcome}; ${action}`;
+    let delivery = "memory";
+    if (delivered) {
+      delivery = "cli";
+    } else if (durable) {
+      delivery = "spool";
+    }
+    try {
+      await client.app.log({
+        service: "codemem",
+        level: delivered ? "warn" : "error",
+        message,
+        extra: {
+          category,
+          delivery,
+        },
+      });
+    } catch {
+      // Best-effort app logging only.
+    }
+    if (!client.tui?.showToast || !shouldToast(sessionID, `${category}:${delivery}`)) return;
+    try {
+      await client.tui.showToast({
+        body: { message: `codemem: ${message}`, variant: delivered ? "warning" : "error" },
+      });
+    } catch {
+      // Best-effort toast only.
+    }
+  };
+
+  const drainRawEventSpool = () => {
+    if (!rawEventsEnabled) {
+      return Promise.resolve();
+    }
+    const existingDrain = rawEventSpoolDrainsInFlight.get(rawEventSpoolDirectory);
+    if (existingDrain) {
+      return existingDrain;
+    }
+    const drainPromise = (async () => {
+      let loaded;
+      try {
+        loaded = await loadRawEventSpoolEntries({
+          homeDir: rawEventSpoolHome,
+          limit: rawEventSpoolDrainLimit,
+        });
+      } catch {
+        await logLine("raw_events.spool.load_failed category=persistence");
+        const message = "codemem could not read saved raw events; spool entries were left untouched";
+        try {
+          await client.app.log({
+            service: "codemem",
+            level: "error",
+            message,
+            extra: { category: "persistence", delivery: "load" },
+          });
+        } catch {
+          // Best-effort app logging only.
+        }
+        if (!spoolLoadFailureNoted) {
+          spoolLoadFailureNoted = true;
+          if (client.tui?.showToast && shouldToast(null, "persistence:load")) {
+            try {
+              await client.tui.showToast({
+                body: { message: `codemem: ${message}`, variant: "error" },
+              });
+            } catch {
+              // Best-effort toast only.
+            }
+          }
+        }
+        return;
+      }
+      spoolLoadFailureNoted = false;
+      if (loaded.corruptCount > 0) {
+        await logLine(`raw_events.spool.corrupt_retained count=${loaded.corruptCount}`);
+      }
+      for (const entry of loaded.entries) {
+        try {
+          await queueRawEventViaCli(entry.envelope, entry.serialized);
+          await removeRawEventFromSpool({ eventId: entry.eventId });
+        } catch (error) {
+          await logLine("raw_events.spool.drain_deferred category=fallback");
+          if (error?.retryable === true) {
+            break;
+          }
+        }
+      }
+    })();
+    const trackedDrain = drainPromise
+      .catch(async () => {
+        await logLine("raw_events.spool.drain_failed category=persistence");
+      })
+      .finally(() => {
+        if (rawEventSpoolDrainsInFlight.get(rawEventSpoolDirectory) === trackedDrain) {
+          rawEventSpoolDrainsInFlight.delete(rawEventSpoolDirectory);
+        }
+      });
+    rawEventSpoolDrainsInFlight.set(rawEventSpoolDirectory, trackedDrain);
+    return trackedDrain;
+  };
+
   const buildViewerCliArgs = (action) => {
     const args = ["serve", action, "--host", viewerHost, "--port", viewerPort];
     if (String(viewerDbPath || "").trim()) {
@@ -1990,66 +2518,54 @@ export const CodememPlugin = async ({
       return false;
     }
     const now = Date.now();
-    const body = buildRawEventEnvelope({
-      sessionID,
-      type,
-      payload,
-      cwd,
-      project: resolveProjectName(project, cwd),
-      startedAt: sessionStartedAt,
-      nowMs: now,
-      nowMono:
-        typeof performance !== "undefined" && performance.now
-          ? performance.now()
-          : null,
-      nextEventId,
-    });
-
+    let cachedEnvelope = payload && typeof payload === "object"
+      ? rawEventEnvelopes.get(payload)
+      : null;
+    if (!cachedEnvelope) {
+      const builtEnvelope = buildRawEventEnvelope({
+        sessionID,
+        type,
+        payload,
+        cwd,
+        project: resolveProjectName(project, cwd),
+        startedAt: sessionStartedAt,
+        nowMs: now,
+        nowMono:
+          typeof performance !== "undefined" && performance.now
+            ? performance.now()
+            : null,
+        nextEventId,
+      });
+      const serialized = JSON.stringify(builtEnvelope);
+      cachedEnvelope = { body: JSON.parse(serialized), serialized };
+      if (payload && typeof payload === "object") {
+        rawEventEnvelopes.set(payload, cachedEnvelope);
+      }
+    }
+    const { body, serialized } = cachedEnvelope;
     if (now < streamUnavailableUntil) {
+      const durable = await persistRawEventForRetry({ body, serialized, payload, sessionID });
       try {
-        await queueRawEventViaCli(body);
-        fallbackFailureNoted = false;
+        await queueRawEventViaCli(body, serialized);
+        await removeRawEventFromSpool({ eventId: body.event_id, payload });
         if (payload && typeof payload === "object") {
           payload._raw_enqueued = true;
         }
+        await notifyRawEventDelivery({
+          category: "connection",
+          delivered: true,
+          durable,
+          sessionID,
+        });
         return true;
-      } catch (fallbackErr) {
-        if (payload && typeof payload === "object") {
-          payload._raw_fallback_terminal = fallbackErr?.retryable !== true;
-        }
-        await logLine(
-          `raw_events.fallback.error sessionID=${sessionID} type=${type} err=${String(
-            fallbackErr
-          ).slice(0, 200)}`
-        );
-        if (!fallbackFailureNoted) {
-          fallbackFailureNoted = true;
-          try {
-            await client.app.log({
-              service: "codemem",
-              level: "error",
-              message: "codemem fallback enqueue failed during stream backoff",
-              extra: {
-                sessionID,
-                backoffMs: rawEventsBackoffMs,
-              },
-            });
-          } catch (logErr) {
-            // best-effort logging only
-          }
-          if (client.tui?.showToast && shouldToast(sessionID)) {
-            try {
-              await client.tui.showToast({
-                body: {
-                  message: "codemem: fallback enqueue failed while stream is down",
-                  variant: "error",
-                },
-              });
-            } catch (toastErr) {
-              // best-effort only
-            }
-          }
-        }
+      } catch {
+        await logLine("raw_events.fallback.error category=connection");
+        await notifyRawEventDelivery({
+          category: "connection",
+          delivered: false,
+          durable,
+          sessionID,
+        });
         return false;
       }
     }
@@ -2080,130 +2596,46 @@ export const CodememPlugin = async ({
       });
       if (!postResp.ok) {
         let responseBody = null;
-        if (postResp.status === 409) {
-          try {
-            responseBody = await postResp.json();
-          } catch {
-            // Generic failure handling below remains the safe fallback.
-          }
+        try {
+          responseBody = await postResp.json();
+        } catch {
+          // Generic connection guidance below remains the safe fallback.
         }
-        const targetMismatch = isViewerDbMismatchPayload(responseBody)
-          || isViewerIdentityMismatchPayload(responseBody)
-          || isViewerContractUnsupportedPayload(responseBody);
         const postError = new Error(`raw-events post failed (${postResp.status})`);
-        postError.viewerTargetMismatch = targetMismatch;
+        postError.rawEventFailureCategory = classifyRawEventViewerFailure(responseBody);
         throw postError;
       }
       streamUnavailableUntil = 0;
-      streamErrorNoted = false;
-      fallbackFailureNoted = false;
       lastStatusAvailable = true;
+      await removeRawEventFromSpool({ eventId: body.event_id, payload });
       if (payload && typeof payload === "object") {
         payload._raw_enqueued = true;
       }
       return true;
     } catch (err) {
+      const category = err?.rawEventFailureCategory || "connection";
       streamUnavailableUntil = Date.now() + Math.max(1000, rawEventsBackoffMs);
-      await logLine(`raw_events.error sessionID=${sessionID} type=${type} err=${String(err).slice(0, 200)}`);
-      try {
-        await client.app.log({
-          service: "codemem",
-          level: "error",
-          message: "Failed to stream raw events to codemem viewer",
-          extra: {
-            sessionID,
-            type,
-            viewerHost,
-            viewerPort,
-            viewerTargetMismatch: err?.viewerTargetMismatch === true,
-            error: String(err),
-          },
-        });
-      } catch (logErr) {
-        // best-effort logging only
-      }
+      await logLine(`raw_events.error category=${category}`);
+      const durable = await persistRawEventForRetry({ body, serialized, payload, sessionID });
 
       let fallbackOk = false;
       try {
-        await queueRawEventViaCli(body);
+        await queueRawEventViaCli(body, serialized);
+        await removeRawEventFromSpool({ eventId: body.event_id, payload });
         fallbackOk = true;
-      } catch (fallbackErr) {
-        if (payload && typeof payload === "object") {
-          payload._raw_fallback_terminal = fallbackErr?.retryable !== true;
-        }
-        await logLine(
-          `raw_events.fallback.error sessionID=${sessionID} type=${type} err=${String(
-            fallbackErr
-          ).slice(0, 200)}`
-        );
+      } catch {
+        await logLine(`raw_events.fallback.error category=${category}`);
       }
 
       if (fallbackOk) {
-        fallbackFailureNoted = false;
         if (payload && typeof payload === "object") {
           payload._raw_enqueued = true;
         }
-        if (!streamErrorNoted) {
-          streamErrorNoted = true;
-          try {
-            await client.app.log({
-              service: "codemem",
-              level: "warn",
-              message: "codemem stream unavailable; queued raw event via CLI fallback",
-              extra: {
-                sessionID,
-                backoffMs: rawEventsBackoffMs,
-              },
-            });
-          } catch (logErr) {
-            // best-effort logging only
-          }
-        }
-        if (client.tui?.showToast && shouldToast(sessionID)) {
-          try {
-            await client.tui.showToast({
-              body: {
-                message: "codemem: viewer stream unavailable; queue fallback active",
-                variant: "warning",
-              },
-            });
-          } catch (toastErr) {
-            // best-effort only
-          }
-        }
+        await notifyRawEventDelivery({ category, delivered: true, durable, sessionID });
         return true;
       }
 
-      if (!streamErrorNoted) {
-        streamErrorNoted = true;
-        fallbackFailureNoted = true;
-        try {
-          await client.app.log({
-            service: "codemem",
-            level: "error",
-            message: "codemem stream unavailable; fallback enqueue failed",
-            extra: {
-              sessionID,
-              backoffMs: rawEventsBackoffMs,
-            },
-          });
-        } catch (logErr) {
-          // best-effort logging only
-        }
-      }
-
-      if (client.tui?.showToast && shouldToast(sessionID)) {
-        try {
-            await client.tui.showToast({
-              body: {
-                message: `codemem: stream unavailable (${viewerHost}:${viewerPort}); fallback failed`,
-                variant: "error",
-              },
-            });
-        } catch (toastErr) {
-          // best-effort only
-        }
-      }
+      await notifyRawEventDelivery({ category, delivered: false, durable, sessionID });
       return false;
     }
   };
@@ -2709,7 +3141,7 @@ export const CodememPlugin = async ({
     request_id: identity.requestId,
   });
 
-  const runPromptPackLedger = async (payload) => {
+  const runPromptPackLedger = async (payload, { viewerOnly = false } = {}) => {
     const viewerPayload = {
       ...payload,
       db_path: promptPackDbPath,
@@ -2730,12 +3162,12 @@ export const CodememPlugin = async ({
       };
     }
 
-    const { cause, retryable } = httpResult.classification;
+    const { cause, kind, retryable } = httpResult.classification;
     await logLine(
       `inject.ledger.http_error cause=${JSON.stringify(redactLog(cause, 200))} retryable=${retryable}`
     );
-    if (!retryable) {
-      return { exitCode: 1, stdout: "", stderr: cause, transport: "viewer" };
+    if (!retryable || viewerOnly) {
+      return { exitCode: 1, stdout: "", stderr: cause, transport: "viewer", failureKind: kind };
     }
 
     try {
@@ -2757,9 +3189,18 @@ export const CodememPlugin = async ({
       queryHash: hashPromptPackQuery(""),
     });
 
-  const recordSkippedPromptPack = (failureCode, sessionID = null, surface = injectSurface) => {
+  const recordSkippedPromptPack = (failureCode, sessionID = null, surface = injectSurface, requestKey = null) => {
     const sessionKey = String(sessionID || "unknown");
     const memoKey = `${surface}:${sessionKey}`;
+    if (requestKey) {
+      const signature = `${requestKey}:${failureCode}`;
+      if (latestPolicySkips.get(memoKey) === signature) return null;
+      latestPolicySkips.delete(memoKey);
+      latestPolicySkips.set(memoKey, signature);
+      while (latestPolicySkips.size > MAX_MESSAGE_INJECTION_CACHE_SESSIONS) {
+        latestPolicySkips.delete(latestPolicySkips.keys().next().value);
+      }
+    }
     if (failureCode === "injection_disabled" && disabledInjectionRecorded.has(memoKey)) {
       return null;
     }
@@ -2768,7 +3209,7 @@ export const CodememPlugin = async ({
       failureCode,
       sessionID,
       surface,
-      failureCode === "injection_disabled" ? "once" : `event-${++skippedAttemptCounter}`,
+      requestKey || (failureCode === "injection_disabled" ? "once" : `event-${++skippedAttemptCounter}`),
     );
     void runPromptPackLedger({
       action: "record",
@@ -2797,12 +3238,28 @@ export const CodememPlugin = async ({
     return { attemptId: identity.attemptId, ready };
   };
 
-  const confirmPromptPackDelivery = (attemptId, deliveryStatus = "handed_off") => {
+  const confirmPromptPackDelivery = (attemptId, deliveryStatus = "handed_off", evaluation) => {
+    const delivery = {
+      action: "delivery", attempt_id: attemptId, delivery_status: deliveryStatus,
+    };
     void runPromptPackLedger({
-      action: "delivery",
-      attempt_id: attemptId,
-      delivery_status: deliveryStatus,
-    });
+      ...delivery,
+      ...evaluation,
+    }).then((result) => {
+      // Retry additive fields only after the transport identifies that exact compatibility case.
+      if (
+        evaluation
+        && result?.transport === "viewer"
+        && result.failureKind === "viewer_contract_unsupported"
+      ) {
+        return runPromptPackLedger(delivery, { viewerOnly: true });
+      }
+      // Older CLI fallbacks can reject optional fields. Preserve the original receipt;
+      // never retry a Viewer policy/auth rejection through a different transport.
+      if (evaluation && result?.transport === "cli" && result.exitCode !== 0) {
+        return runPromptPackLedger(delivery);
+      }
+    }).catch(() => {});
   };
 
   const showToast = async (message, variant = "warning") => {
@@ -3126,11 +3583,44 @@ export const CodememPlugin = async ({
     }
   };
 
+  let fallbackEvaluationSessionId = nextEventId();
   const buildInjectedContext = async (query, context = {}) => {
+    const requestPackBudget = reserveContextPrefixBudget(context.tokenBudget ?? injectTokenBudget);
     const queryHash = hashPromptPackQuery(query);
-    const sessionID = context.sessionID || activeSessionID || "unknown";
+    // Requester eligibility comes only from the transform's own session identity.
+    // activeSessionID tracks the latest event stream, which can belong to another
+    // overlapping session; inferring from it would authorize the wrong summaries.
+    const requesterHostSessionID = context.sessionID || null;
+    const sessionID = requesterHostSessionID || "unknown";
     const surface = context.surface || injectSurface;
-    const requestKey = context.requestKey || "unknown";
+    let requestKey = context.requestKey || "unknown";
+    if (context.fallbackTurn != null) {
+      requestKey = JSON.stringify([requestKey, fallbackEvaluationSessionId, promptCounter, context.fallbackTurn]);
+    }
+    const evaluationFields = (
+      beforeText,
+      afterText,
+      candidateItems,
+      duplicatesOmitted,
+      packMetadata,
+      artifactFingerprint,
+    ) => ({
+      evaluation_key: injectionDigest(JSON.stringify([
+        sessionID,
+        requestKey,
+        surface,
+        queryHash,
+        artifactFingerprint,
+      ])),
+      automatic_recall: {
+        v: 1, candidateItems, duplicatesOmitted,
+        beforeTokens: beforeText ? estimateTokens(wrapInjectedContext(beforeText)) : 0,
+        afterTokens: afterText ? estimateTokens(wrapInjectedContext(afterText)) : 0,
+        missingRetainedMetadata: context.retainedMetadata?.missingRetainedMetadata === true,
+        invalidRetainedMetadata: context.retainedMetadata?.invalidRetainedMetadata === true,
+        packMetadata,
+      },
+    });
     const attemptKey = JSON.stringify([
       sessionID,
       requestKey,
@@ -3151,14 +3641,23 @@ export const CodememPlugin = async ({
     let identity = resolveIdentity();
     let metadata = attemptMetadata(
       identity,
-      context.sessionID || activeSessionID || null,
+      requesterHostSessionID,
     );
+    if (requestPackBudget === null) {
+      return {
+        text: "",
+        attemptId: identity.attemptId,
+        requestId: identity.requestId,
+        queryHash,
+        promptNumber: promptCounter,
+      };
+    }
     const runPack = async () => {
       let packArgs = buildPackArgs({
         query,
         filesModified: sessionContext.filesModified,
         injectLimit,
-        injectTokenBudget,
+        injectTokenBudget: requestPackBudget,
         internalLedger: true,
       });
       const httpResult = await postViewerJson({
@@ -3168,12 +3667,15 @@ export const CodememPlugin = async ({
           query,
           filesModified: sessionContext.filesModified,
           injectLimit,
-          injectTokenBudget,
+          injectTokenBudget: requestPackBudget,
           projectName: normalizeProjectLabel(process.env.CODEMEM_PROJECT),
           cwd,
           dbPath: promptPackDbPath,
           identityTarget: promptPackIdentityTarget,
           attempt: metadata,
+          automaticContext: requesterHostSessionID
+            ? { source: "opencode", host_session_id: requesterHostSessionID }
+            : null,
         }),
         validate: isValidPackHttpPayload,
       });
@@ -3200,16 +3702,17 @@ export const CodememPlugin = async ({
         };
       }
 
-      let result = await runCli(packArgs, { stdinText: JSON.stringify(metadata) });
+      const result = await runCli(packArgs, { stdinText: JSON.stringify(metadata) });
       if (rejectsInternalLedgerFlag(result)) {
-        packArgs = packArgs.filter((arg) => arg !== "--internal-ledger");
-        result = await runCli(packArgs);
+        // An older CLI cannot enforce requester-session continuity. Do not retry
+        // through its generic pack path, which may inject an unrelated summary.
+        await logLine("inject.pack.cli_legacy_unsafe_fallback_blocked");
       }
       return { packArgs, result: { ...result, transport: "cli" } };
     };
     let { packArgs, result } = await runPack();
     let { packText, conflictPackText, metrics, itemCount, ledgerConflict } = parsePackOutput(result);
-    let artifactFingerprint = packText
+    let artifactFingerprint = packText || itemCount === 0
       ? promptPackArtifactFingerprint(result.stdout, packText)
       : "";
     let injectedIdentity = identity;
@@ -3236,14 +3739,11 @@ export const CodememPlugin = async ({
       advancePromptPackRetryIdentity(attemptKey);
       retryCount = promptPackRetryCounts.get(attemptKey) || 0;
       identity = resolveIdentity();
-      metadata = attemptMetadata(
-        identity,
-        context.sessionID || activeSessionID || null,
-      );
+      metadata = attemptMetadata(identity, requesterHostSessionID);
       ({ packArgs, result } = await runPack());
       // Repair-conflict bytes are never preferred over the original preserved pack.
       ({ packText, metrics, itemCount, ledgerConflict } = parsePackOutput(result));
-      artifactFingerprint = packText
+      artifactFingerprint = packText || itemCount === 0
         ? promptPackArtifactFingerprint(result.stdout, packText)
         : "";
       const repairFailed = ledgerConflict
@@ -3322,13 +3822,10 @@ export const CodememPlugin = async ({
         advancePromptPackRetryIdentity(attemptKey);
         retryCount = promptPackRetryCounts.get(attemptKey) || 0;
         identity = resolveIdentity();
-        metadata = attemptMetadata(
-          identity,
-          context.sessionID || activeSessionID || null,
-        );
+        metadata = attemptMetadata(identity, requesterHostSessionID);
         ({ packArgs, result } = await runPack());
         ({ packText, metrics, itemCount, ledgerConflict } = parsePackOutput(result));
-        artifactFingerprint = packText
+        artifactFingerprint = packText || itemCount === 0
           ? promptPackArtifactFingerprint(result.stdout, packText)
           : "";
 
@@ -3428,6 +3925,10 @@ export const CodememPlugin = async ({
     }
     if (!packText) {
       if (itemCount === 0) {
+        if (surface === "message") {
+          void runPromptPackLedger({ action: "recall", attempt_id: identity.attemptId,
+            ...evaluationFields("", "", 0, 0, "valid", artifactFingerprint) }).catch(() => {});
+        }
         advancePromptPackRetryIdentity(attemptKey);
       }
       if (debug) {
@@ -3460,9 +3961,34 @@ export const CodememPlugin = async ({
         artifactFingerprint || promptPackArtifactFingerprint(result.stdout, packText)
       );
     }
+    const filtered = context.surface === "message"
+      ? filterRetainedPack(result.stdout, packText, context.retainedItems)
+      : { text: packText, items: [], duplicates: 0 };
+    const text = filtered.text ? wrapInjectedContext(filtered.text) : "";
+    const evaluation = surface === "message"
+      ? evaluationFields(
+          packText,
+          filtered.text,
+          itemCount,
+          filtered.duplicates,
+          filtered.packMetadata,
+          artifactFingerprint,
+        )
+      : undefined;
+    const recall = filtered.items.length
+      ? { v: 1, digest: injectionDigest(text), items: filtered.items, workingContext: context.workingContext }
+      : undefined;
+    let skipReason = null;
+    if (!text && filtered.duplicates > 0) {
+      skipReason = context.continuationOnly ? "continuation_only" : "unchanged_memories";
+    }
     if (metrics) {
       return {
-        text: `[codemem context]\n${packText}`,
+        text,
+        recall,
+        duplicates: filtered.duplicates,
+        evaluation,
+        skipReason,
         metrics,
         attemptId: injectedIdentity?.attemptId || null,
         requestId: injectedIdentity?.requestId || null,
@@ -3471,7 +3997,11 @@ export const CodememPlugin = async ({
       };
     }
     return {
-      text: `[codemem context]\n${packText}`,
+      text,
+      recall,
+      duplicates: filtered.duplicates,
+      evaluation,
+      skipReason,
       attemptId: injectedIdentity?.attemptId || null,
       requestId: injectedIdentity?.requestId || null,
       queryHash,
@@ -3575,9 +4105,17 @@ export const CodememPlugin = async ({
         void logLine(`queue.pressure unsent_preserved queued=${queuedCount} max_events=${cap}`);
       },
       onForcedDrop: (dropped, queuedCount, hardCap) => {
+        const durableSpoolCoverage = dropped?._raw_spooled === true;
         void logLine(
-          `queue.drop hard_cap event_id=${dropped?._raw_event_id || "unknown"} queued=${queuedCount} hard_max=${hardCap}`
+          `queue.drop hard_cap durable_spool_coverage=${durableSpoolCoverage} queued=${queuedCount} hard_max=${hardCap}`
         );
+        void log("error", "codemem raw event dropped at in-memory hard cap", {
+          category: "queue_capacity",
+          delivery: durableSpoolCoverage ? "spool" : "memory",
+          durable_spool_coverage: durableSpoolCoverage,
+          queued_count: queuedCount,
+          hard_max_events: hardCap,
+        });
       },
     });
   };
@@ -3607,7 +4145,6 @@ export const CodememPlugin = async ({
       ...adapterAnnotatedEvent,
       _raw_event_id: rawEventId,
       _raw_session_id: resolvedSessionID,
-      _raw_retry_count: 0,
     };
     recordEvent(queuedEvent);
     void emitRawEvent({
@@ -3619,6 +4156,7 @@ export const CodememPlugin = async ({
 
   const flushEvents = async () => {
     if (!events.length) {
+      await drainRawEventSpool();
       await logLine("flush.skip empty");
       return;
     }
@@ -3630,18 +4168,10 @@ export const CodememPlugin = async ({
     }
 
     const failed = [];
-    let droppedCount = 0;
     for (const queuedEvent of batch) {
       if (queuedEvent && typeof queuedEvent === "object" && queuedEvent._raw_enqueued) {
         continue;
       }
-      if (queuedEvent && typeof queuedEvent === "object" && queuedEvent._raw_fallback_terminal) {
-        droppedCount += 1;
-        await logLine(
-          `flush.drop terminal_fallback event_id=${queuedEvent?._raw_event_id || "unknown"}`
-        );
-        continue;
-      }
       const queuedSessionID =
         queuedEvent?._raw_session_id ||
         queuedEvent?.properties?.sessionID ||
@@ -3652,27 +4182,13 @@ export const CodememPlugin = async ({
         payload: queuedEvent,
       });
       if (!ok) {
-        if (queuedEvent?._raw_fallback_terminal) {
-          droppedCount += 1;
-          await logLine(
-            `flush.drop terminal_fallback event_id=${queuedEvent?._raw_event_id || "unknown"}`
-          );
-          continue;
-        }
-        const currentRetry =
-          typeof queuedEvent?._raw_retry_count === "number" && Number.isFinite(queuedEvent._raw_retry_count)
-            ? queuedEvent._raw_retry_count
-            : 0;
-        const nextRetry = currentRetry + 1;
-        failed.push({
-          ...queuedEvent,
-          _raw_retry_count: nextRetry,
-        });
+        failed.push(queuedEvent);
       }
     }
     if (failed.length) {
       events.unshift(...failed);
       await logLine(`flush.retry_deferred count=${failed.length}`);
+      await drainRawEventSpool();
       return;
     }
 
@@ -3683,12 +4199,20 @@ export const CodememPlugin = async ({
     await logLine(
       `flush.stream_only finalize count=${batch.length} tools=${sessionContext.toolCount} prompts=${sessionContext.promptCount} duration=${Math.round(durationMs / 1000)}s`
     );
-    await logLine(`flush.ok count=${batch.length - droppedCount} dropped=${droppedCount}`);
+    await logLine(`flush.ok count=${batch.length} dropped=0`);
     sessionStartedAt = null;
     resetSessionContext();
+    await drainRawEventSpool();
   };
 
+  void drainRawEventSpool();
+
   return {
+    dispose: () => {
+      clearTimeout(updateCheckTimer);
+      stopHealthCheck();
+      releasePluginRegistration();
+    },
     "experimental.session.compacting": async (input) => {
       const sessionID = extractHookSessionID(input) || activeSessionID;
       markCompactionInjectionSkip(compactionInjectionSkips, sessionID);
@@ -3702,10 +4226,12 @@ export const CodememPlugin = async ({
       if (injectSurface === "system") {
         return;
       }
-      const latestUser = Array.isArray(output?.messages)
-        ? findLatestUserMessage(output.messages)
-        : null;
-      const sessionID = latestUser ? resolveEntrySessionID(latestUser.entry) : input?.sessionID;
+      const hookMessages = Array.isArray(output?.messages)
+        ? scopeMessagesToSession(output.messages, input?.sessionID || null)
+        : [];
+      const latestUser = findLatestUserMessage(hookMessages);
+      const sessionID = input?.sessionID
+        || (latestUser ? resolveEntrySessionID(latestUser.entry) : null);
       const latestPromptText = latestUser ? extractMessageText(latestUser.entry) : "";
       if (debug) {
         const query = resolveInjectQuery({ lastPromptText: latestPromptText });
@@ -3738,10 +4264,16 @@ export const CodememPlugin = async ({
           resolveInjectQuery,
           buildInjectedContext,
           messageInjectionCache,
+          injectTokenBudget,
+          retainedTokenBudget,
+          workingSet: [...sessionContext.filesModified, ...sessionContext.filesRead],
+          recordMeasurement: (measurement) => logLine(`inject.recall ${JSON.stringify(measurement)}`),
           compactionInjectionSkips,
           confirmDelivery: confirmPromptPackDelivery,
           recordCacheReuse: recordCachedPromptPack,
-          recordSkipped: recordSkippedPromptPack,
+          recordSkipped: (reason, sessionID) => recordSkippedPromptPack(
+            reason, sessionID, "message", latestUser ? resolveEntryMessageId(latestUser.entry) : null,
+          ),
         });
       } catch (err) {
         await logLine(
@@ -3993,6 +4525,7 @@ export const CodememPlugin = async ({
         activeSessionID = sessionID || null;
         sessionStartedAt = new Date().toISOString();
         promptCounter = 0;
+        fallbackEvaluationSessionId = nextEventId();
         skippedAttemptCounter = 0;
         disabledInjectionRecorded.delete("message:unknown");
         disabledInjectionRecorded.delete("system:unknown");
@@ -4004,11 +4537,18 @@ export const CodememPlugin = async ({
       if (eventType === "session.deleted") {
         activeSessionID = null;
         if (sessionID) {
+          for (const key of lastToastAtBySession.keys()) {
+            if (key.startsWith(`${sessionID}:`)) {
+              lastToastAtBySession.delete(key);
+            }
+          }
           injectionToastShown.delete(sessionID);
           messageInjectionCache.delete(sessionID);
           compactionInjectionSkips.delete(sessionID);
           disabledInjectionRecorded.delete(`message:${sessionID}`);
           disabledInjectionRecorded.delete(`system:${sessionID}`);
+          latestPolicySkips.delete(`message:${sessionID}`);
+          latestPolicySkips.delete(`system:${sessionID}`);
         }
         await stopViewer();
       }
@@ -4130,6 +4670,8 @@ export const __testUtils = {
   redactPackCommand,
   rejectsInternalLedgerFlag,
   classifyFallbackCommandResult,
+  classifyRawEventViewerFailure,
+  detectRunner,
   PROMPT_TRANSPORT_PROTOCOL_RANGE,
   normalizePromptTransportProtocolRange,
   arePromptTransportProtocolRangesCompatible,
@@ -4159,5 +4701,18 @@ export const __testUtils = {
   buildRawEventEnvelope,
   trimEventQueue,
   parsePositiveInt,
+  resolveInjectTokenBudget,
+  reserveContextPrefixBudget,
+  wrapInjectedContext,
+  estimateTokens,
+  countRetainedInjectionTokens,
+  retainedMemoryFingerprints,
+  retainedMetadataGaps,
+  filterRetainedPack,
+  isContinuationOnly,
+  resolveRetainedTokenBudget,
+  workingContextDigest,
+  DEFAULT_INJECT_TOKEN_BUDGET,
+  CODEMEM_CONTEXT_PREFIX,
   createViewerHealthMonitor,
 };