@codemem/opencode-plugin 0.45.0-rc.2 → 0.46.0-alpha.1

package/.opencode/lib/runtime.js

@@ -1,9 +1,9 @@
-import { appendFile, mkdir } from "node:fs/promises";
+import { execSync, spawn as nodeSpawn } from "node:child_process";
+import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
-import { basename, dirname, join, posix, resolve, win32 } from "node:path";
+import { appendFile, mkdir } from "node:fs/promises";
 import { homedir } from "node:os";
-import { createHash } from "node:crypto";
-import { spawn as nodeSpawn, execSync } from "node:child_process";
+import { basename, dirname, join, posix, resolve, win32 } from "node:path";
 import {
   isVersionAtLeast,
   parseBackendUpdatePolicy,
@@ -11,20 +11,26 @@ import {
   resolveAutoUpdatePlan,
   resolveUpgradeGuidance,
 } from "./compat.js";
+import { V2_ADAPTER_DIAGNOSTICS } from "./host-contract.js";
+import {
+  classifyRawEventTransportCause,
+  createRawEventDelivery,
+  describeRawEventViewerFailure,
+} from "./raw-event-delivery.js";
 import {
   DEFAULT_DRAIN_LIMIT,
   DEFAULT_MAX_ENTRIES,
-  RAW_EVENT_SPOOL_FULL_CODE,
-  loadRawEventSpoolEntries,
-  removeRawEventSpoolEntry,
-  resolveSpoolDirectory,
-  writeRawEventSpoolEntry,
 } from "./raw-event-spool.js";
-import { V2_ADAPTER_DIAGNOSTICS } from "./host-contract.js";
+import {
+  createRecallLifecycle,
+  getSessionMessageInjectionCache,
+  MAX_MESSAGE_INJECTION_CACHE_ENTRIES,
+  setSessionMessageInjectionCacheEntry,
+} from "./recall-lifecycle.js";
 
 const TRUTHY_VALUES = ["1", "true", "yes"];
 const DISABLED_VALUES = ["0", "false", "off"];
-const PINNED_BACKEND_VERSION = "0.45.0-rc.2";
+const PINNED_BACKEND_VERSION = "0.46.0-alpha.1";
 const COMPAT_CHECK_DELAY_MS = 1500;
 const COMPAT_CHECK_CACHE_TTL_MS = 5 * 60 * 1000;
 const MAX_UPDATE_STATUS_BYTES = 16 * 1024;
@@ -33,8 +39,6 @@ const MAX_UPDATE_VERSION_CHARS = 128;
 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_ENTRIES = 100;
 const COMPACTION_INJECTION_SKIP_TTL_MS = 30 * 1000;
 const MAX_WORKING_SET_PATH_CHARS = 400;
 const VIEWER_HEALTH_CHECK_INTERVAL_MS = 60_000;
@@ -69,8 +73,6 @@ const claimPluginRegistration = (cwd) => {
     }
   };
 };
-const rawEventSpoolDrainsInFlight = new Map();
-
 // Release an unread response body without surfacing cancellation failures.
 const discardResponseBody = (response) => {
   try {
@@ -249,7 +251,7 @@ const resolveInjectSurface = (value) => {
   return "message";
 };
 
-const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value || {}, key);
+const hasOwn = (value, key) => Object.hasOwn(value || {}, key);
 
 const deterministicUuid = (namespace, components) => {
   const hex = createHash("sha256")
@@ -332,7 +334,7 @@ const classifyFallbackCommandResult = (result) => {
   if (structured.code === "validation_error" || /invalid raw event|session id required/i.test(diagnostic)) {
     return { retryable: false, cause: "enqueue-raw-event validation failed" };
   }
-  if (/unknown command ['\"]?enqueue-raw-event|command not found|\bENOENT\b/i.test(diagnostic)) {
+  if (/unknown command ['"]?enqueue-raw-event|command not found|\bENOENT\b/i.test(diagnostic)) {
     return { retryable: false, cause: "enqueue-raw-event command unavailable" };
   }
   const exitCode = result?.exitCode ?? "unknown";
@@ -388,7 +390,7 @@ const clearCompatCheckCache = () => {
 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;
+  if (!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 };
@@ -504,7 +506,7 @@ const createLogLine = (logPath) => async (line) => {
   try {
     await mkdir(dirname(logPath), { recursive: true });
     await appendFile(logPath, `${new Date().toISOString()} ${line}\n`);
-  } catch (err) {
+  } catch {
     // ignore logging failures
   }
 };
@@ -544,7 +546,7 @@ const createDebugLogger = ({ debug, host, logTimeoutMs, getLogLine, getErrorLogL
       if (timedOut) {
         await getLogLine()("debug log timed out");
       }
-    } catch (err) {
+    } catch {
       // ignore debug logging failures
     }
   };
@@ -711,7 +713,7 @@ const buildPackArgs = ({ query, filesModified, injectLimit, injectTokenBudget, i
 };
 
 const parsePackText = (stdout) => {
-  if (!stdout || !stdout.trim()) {
+  if (!stdout?.trim()) {
     return "";
   }
   try {
@@ -723,7 +725,7 @@ const parsePackText = (stdout) => {
 };
 
 const parsePackMetrics = (stdout) => {
-  if (!stdout || !stdout.trim()) {
+  if (!stdout?.trim()) {
     return null;
   }
   try {
@@ -867,6 +869,11 @@ const classifyRawEventViewerFailure = (payload) => {
   if (isViewerDbMismatchPayload(payload)) return "database";
   if (isViewerIdentityMismatchPayload(payload)) return "identity";
   if (isViewerContractUnsupportedPayload(payload)) return "contract";
+  if (
+    isRecord(payload)
+    && isRecord(payload.error)
+    && ["raw_event_queue_full", "raw_event_queue_write_failed"].includes(payload.error.code)
+  ) return "queue";
   return "connection";
 };
 
@@ -874,6 +881,7 @@ 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",
+  queue: "repair or archive the viewer raw-event queue",
   connection: "check or restart the viewer",
 });
 
@@ -917,11 +925,11 @@ const classifyPromptTransportFailure = ({ kind, compatibleProfile = false }) =>
 };
 
 const isViewerPolicyOrAuthFailurePayload = (payload) => {
-  const code = isRecord(payload) && isRecord(payload.error)
-    ? payload.error.code
-    : isRecord(payload)
-    ? payload.error
-    : null;
+  let code = null;
+  if (isRecord(payload)) {
+    if (isRecord(payload.error)) code = payload.error.code;
+    else code = payload.error;
+  }
   return typeof code === "string" && [
     "authorization_failed",
     "forbidden",
@@ -1213,68 +1221,8 @@ const consumeCompactionInjectionSkip = (compactionInjectionSkips, sessionID, now
 // session ID and a real message ID; unidentified messages still receive current
 // turn context, but are not cached because positional fallbacks can drift across
 // turns or sessions. Do not "simplify" this into recomputing previous turns.
-const getSessionMessageInjectionCache = (messageInjectionCache, sessionID) => {
-  if (!sessionID) {
-    return null;
-  }
-  const cacheKey = sessionID;
-  let sessionCache = messageInjectionCache.get(cacheKey);
-  if (sessionCache) {
-    // Refresh recency so the bounded cache behaves like a small LRU.
-    messageInjectionCache.delete(cacheKey);
-  } else {
-    sessionCache = new Map();
-  }
-  messageInjectionCache.set(cacheKey, sessionCache);
-  while (messageInjectionCache.size > MAX_MESSAGE_INJECTION_CACHE_SESSIONS) {
-    const oldestKey = messageInjectionCache.keys().next().value;
-    if (!oldestKey) break;
-    messageInjectionCache.delete(oldestKey);
-  }
-  return sessionCache;
-};
-
-const setSessionMessageInjectionCacheEntry = (
-  sessionCache,
-  messageID,
-  value,
-  { preserveMessageIDs = new Set(), evictionSnapshot = null } = {},
-) => {
-  sessionCache.delete(messageID);
-  sessionCache.set(messageID, value);
-  while (sessionCache.size > MAX_MESSAGE_INJECTION_CACHE_ENTRIES) {
-    // Protect host-visible blocks and entries published after this transform began.
-    const oldestMessageID = [...sessionCache.keys()].find((id) =>
-      !preserveMessageIDs.has(id)
-      && (!evictionSnapshot || (evictionSnapshot.has(id) && evictionSnapshot.get(id) === sessionCache.get(id))),
-    );
-    if (!oldestMessageID) break;
-    sessionCache.delete(oldestMessageID);
-  }
-};
-
 const commitImmediateDelivery = (commit) => commit();
 
-const createSessionFinalizationMutex = () => {
-  const tails = new Map();
-  return async (sessionID) => {
-    if (!sessionID) return () => {};
-    const key = String(sessionID);
-    const previous = tails.get(key) || Promise.resolve();
-    let releaseOwner = () => {};
-    const owner = new Promise((resolve) => { releaseOwner = resolve; });
-    tails.set(key, owner);
-    await previous;
-    let released = false;
-    return () => {
-      if (released) return;
-      released = true;
-      releaseOwner();
-      if (tails.get(key) === owner) tails.delete(key);
-    };
-  };
-};
-
 const normalizeInjectedMessageParts = (
   messages,
   sessionCache,
@@ -2056,7 +2004,7 @@ const attachAdapterEvent = ({ sessionID, event }) => {
   let adapterEvent = null;
   try {
     adapterEvent = buildOpencodeAdapterEvent({ sessionID, event });
-  } catch (err) {
+  } catch {
     return event;
   }
   if (!adapterEvent) {
@@ -2169,18 +2117,6 @@ const detectRunner = ({ cwd, envRunner }) => {
   return "npx";
 };
 
-/**
- * Check if the TS CLI is available at the given path.
- * Used by the "node" runner to verify the built CLI exists.
- */
-const tsCliAvailable = (cliPath) => {
-  try {
-    return require("fs").existsSync(cliPath);
-  } catch {
-    return false;
-  }
-};
-
 // When an explicit npx override targets the codemem package, pair it with the
 // matching @codemem/embeddings spec so the detached Viewer can resolve the
 // optional runtime instead of silently falling back to lexical search. Returns
@@ -2354,16 +2290,7 @@ export const createCodememRuntime = async ({ location, host }) => {
       }
     );
   }
-  const injectionToastShown = new Set();
-  const messageInjectionCache = new Map();
-  const emptyRecallCache = new Map();
-  const acquireSessionFinalization = createSessionFinalizationMutex();
   const compactionInjectionSkips = new Map();
-  const disabledInjectionRecorded = new Set();
-  const latestPolicySkips = new Map();
-  const attemptStartedAt = new Map();
-  const promptPackRetryCounts = new Map();
-  const successfulPromptPackArtifacts = new Map();
   let sessionStartedAt = null;
   let sessionStartSessionID = null;
   let activeSessionID = null;
@@ -2371,7 +2298,6 @@ export const createCodememRuntime = async ({ location, host }) => {
   let viewerStartInFlight = false;
   let compatibilityAutoUpdateAttempted = false;
   let promptCounter = 0;
-  let skippedAttemptCounter = 0;
   let lastPromptText = null;
   const capturedPrompts = new Set();
   const pendingPrompts = new Map();
@@ -2383,8 +2309,6 @@ export const createCodememRuntime = async ({ location, host }) => {
   const messageRoles = new Map();
   const messageTexts = new Map();
   const promptPartsByMessage = new Map();
-  let debugLogCount = 0;
-
   const rawEventsEnabled = envNotDisabled(
     process.env.CODEMEM_RAW_EVENTS || "1"
   );
@@ -2392,7 +2316,7 @@ export const createCodememRuntime = async ({ location, host }) => {
     ? `[${viewerHost}]`
     : viewerHost;
   const rawEventsUrl = `http://${viewerUrlHost}:${viewerPort}/api/raw-events`;
-  const rawEventsStatusUrl = `http://${viewerUrlHost}:${viewerPort}/api/raw-events/status?limit=1`;
+  const rawEventsStatusUrl = `http://${viewerUrlHost}:${viewerPort}/api/raw-events/status?limit=0`;
   const packUrl = `http://${viewerUrlHost}:${viewerPort}/api/pack`;
   const promptPackProfileUrl = `http://${viewerUrlHost}:${viewerPort}/api/prompt-pack-profile`;
   const promptPackLedgerUrl = `http://${viewerUrlHost}:${viewerPort}/api/prompt-pack-ledger`;
@@ -2419,27 +2343,15 @@ export const createCodememRuntime = async ({ location, host }) => {
     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();
-  const rawEventCaptureContexts = new WeakMap();
+  let runtimeActive = true;
+  let rawEventDelivery = null;
   const rawEventPreparations = new WeakMap();
   const rawEventDeliveries = new WeakMap();
-  const rawEventStartedAts = new WeakMap();
   const capacityDeferredEvents = new Set();
-  let rawEventDeliveryCount = 0;
   let rawEventDeliveryTail = Promise.resolve();
+  let rawEventDeliveryCount = 0;
   let flushDeliveryTail = Promise.resolve();
-  let streamUnavailableUntil = 0;
-  let spoolPersistenceFailureNoted = null;
-  let spoolLoadFailureNoted = false;
-  let lastStatusCheckAt = 0;
-  let lastStatusAvailable = true;
   let promptPackTransportUnavailableUntil = 0;
-  const rawEventAbortController = new AbortController();
-  let runtimeActive = true;
-
   const nextEventId = () => {
     if (typeof crypto !== "undefined" && crypto.randomUUID) {
       return crypto.randomUUID();
@@ -2447,202 +2359,6 @@ export const createCodememRuntime = async ({ location, host }) => {
     return `${Date.now()}-${Math.random()}`;
   };
 
-  const queueRawEventViaCli = async (body, serialized = JSON.stringify(body)) => {
-    const runFallback = () => runCli(["enqueue-raw-event"], {
-      stdinText: serialized,
-    });
-    let result = await runFallback();
-    let classification = classifyFallbackCommandResult(result);
-    let attemptedRetry = false;
-    if (result?.exitCode !== 0 && classification.retryable) {
-      attemptedRetry = true;
-      result = await runFallback();
-      classification = classifyFallbackCommandResult(result);
-    }
-    if (result?.exitCode !== 0) {
-      const retryExhausted = attemptedRetry && classification.retryable;
-      const error = new Error(
-        retryExhausted ? `${classification.cause} after retry` : classification.cause
-      );
-      error.retryable = classification.retryable;
-      throw error;
-    }
-    return true;
-  };
-
-  const lastToastAtBySession = new Map();
-  const shouldToast = (sessionID, category = "general") => {
-    const now = Date.now();
-    const key = `${sessionID || "unknown"}:${category}`;
-    const last = lastToastAtBySession.get(key) || 0;
-    if (now - last < 60000) {
-      return false;
-    }
-    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 hostLog({
-        service: "codemem",
-        level: "error",
-        message,
-        extra: { category: "persistence", reason },
-      });
-    } catch {
-      // Best-effort app logging only.
-    }
-    if (spoolPersistenceFailureNoted === reason) return;
-    spoolPersistenceFailureNoted = reason;
-    if (!hostNotify || !shouldToast(sessionID, `persistence:${reason}`)) return;
-    try {
-      await hostNotify({ 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 hostLog({
-        service: "codemem",
-        level: delivered ? "warn" : "error",
-        message,
-        extra: {
-          category,
-          delivery,
-        },
-      });
-    } catch {
-      // Best-effort app logging only.
-    }
-    if (!hostNotify || !shouldToast(sessionID, `${category}:${delivery}`)) return;
-    try {
-      await hostNotify({ 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 hostLog({
-            service: "codemem",
-            level: "error",
-            message,
-            extra: { category: "persistence", delivery: "load" },
-          });
-        } catch {
-          // Best-effort app logging only.
-        }
-        if (!spoolLoadFailureNoted) {
-          spoolLoadFailureNoted = true;
-          if (hostNotify && shouldToast(null, "persistence:load")) {
-            try {
-              await hostNotify({ 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()) {
@@ -2654,150 +2370,6 @@ export const createCodememRuntime = async ({ location, host }) => {
     return args;
   };
 
-  const deliverRawEvent = async ({ sessionID, type, payload }) => {
-    if (!rawEventsEnabled) {
-      return true;
-    }
-    if (!sessionID || !type) {
-      return false;
-    }
-    if (payload?._raw_enqueued) return true;
-    const now = Date.now();
-    let cachedEnvelope = payload && typeof payload === "object"
-      ? rawEventEnvelopes.get(payload)
-      : null;
-    if (!cachedEnvelope) {
-      const builtEnvelope = buildRawEventEnvelope({
-        sessionID,
-        type,
-        payload,
-        cwd,
-        project: resolveProjectName(project, cwd),
-        startedAt: rawEventStartedAts.has(payload)
-          ? rawEventStartedAts.get(payload)
-          : sessionStartedAt,
-        nowMs: now,
-        nowMono:
-          typeof performance !== "undefined" && performance.now
-            ? performance.now()
-            : null,
-        nextEventId,
-        captureContext: rawEventCaptureContexts.get(payload),
-      });
-      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 (!runtimeActive) {
-      return persistRawEventForRetry({ body, serialized, payload, sessionID });
-    }
-    if (now < streamUnavailableUntil) {
-      const durable = await persistRawEventForRetry({ body, serialized, payload, sessionID });
-      try {
-        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 {
-        await logLine("raw_events.fallback.error category=connection");
-        await notifyRawEventDelivery({
-          category: "connection",
-          delivered: false,
-          durable,
-          sessionID,
-        });
-        return false;
-      }
-    }
-    try {
-      if (now - lastStatusCheckAt >= Math.max(1000, rawEventsStatusCheckMs)) {
-        const statusResp = await fetchRawEventsStatus(rawEventsStatusUrl);
-        if (!statusResp.ok) {
-          // Release the unread body before bailing into the backoff path.
-          discardResponseBody(statusResp);
-          throw new Error(`raw-events status failed (${statusResp.status})`);
-        }
-        const statusJson = await statusResp.json();
-        lastStatusAvailable = statusJson?.ingest?.available !== false;
-        lastStatusCheckAt = now;
-      }
-      if (!lastStatusAvailable) {
-        throw new Error("raw-events ingest unavailable");
-      }
-
-      const postResp = await fetch(rawEventsUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        signal: AbortSignal.any([
-          rawEventAbortController.signal,
-          AbortSignal.timeout(RAW_EVENTS_STATUS_TIMEOUT_MS),
-        ]),
-        body: JSON.stringify({
-          ...body,
-          db_path: promptPackDbPath,
-          identity_target: promptPackIdentityTarget,
-        }),
-      });
-      if (!postResp.ok) {
-        let responseBody = null;
-        try {
-          responseBody = await postResp.json();
-        } catch {
-          // Generic connection guidance below remains the safe fallback.
-        }
-        const postError = new Error(`raw-events post failed (${postResp.status})`);
-        postError.rawEventFailureCategory = classifyRawEventViewerFailure(responseBody);
-        throw postError;
-      }
-      streamUnavailableUntil = 0;
-      lastStatusAvailable = true;
-      await removeRawEventFromSpool({ eventId: body.event_id, payload });
-      if (payload && typeof payload === "object") {
-        payload._raw_enqueued = true;
-      }
-      return true;
-    } catch (err) {
-      if (!runtimeActive) {
-        return persistRawEventForRetry({ body, serialized, payload, sessionID });
-      }
-      const category = err?.rawEventFailureCategory || "connection";
-      streamUnavailableUntil = Date.now() + Math.max(1000, rawEventsBackoffMs);
-      await logLine(`raw_events.error category=${category}`);
-      const durable = await persistRawEventForRetry({ body, serialized, payload, sessionID });
-
-      let fallbackOk = false;
-      try {
-        await queueRawEventViaCli(body, serialized);
-        await removeRawEventFromSpool({ eventId: body.event_id, payload });
-        fallbackOk = true;
-      } catch {
-        await logLine(`raw_events.fallback.error category=${category}`);
-      }
-
-      if (fallbackOk) {
-        if (payload && typeof payload === "object") {
-          payload._raw_enqueued = true;
-        }
-        await notifyRawEventDelivery({ category, delivered: true, durable, sessionID });
-        return true;
-      }
-
-      await notifyRawEventDelivery({ category, delivered: false, durable, sessionID });
-      return false;
-    }
-  };
-
   // Session context tracking for comprehensive memories
   const createSessionContext = () => ({
     firstPrompt: null,
@@ -3084,7 +2656,7 @@ export const createCodememRuntime = async ({ location, host }) => {
   };
 
   const extractAssistantUsage = (event) => {
-    if (!event || event.type !== "message.updated" || !event.messageInfo) {
+    if (event?.type !== "message.updated" || !event.messageInfo) {
       return null;
     }
     const info = event.messageInfo;
@@ -3229,6 +2801,33 @@ export const createCodememRuntime = async ({ location, host }) => {
   const runCli = async (args, options = {}) =>
     runCommand([runner, ...runnerArgs, ...args], options);
 
+  rawEventDelivery = createRawEventDelivery({
+    backoffMs: rawEventsBackoffMs,
+    buildEnvelope: buildRawEventEnvelope,
+    classifyViewerFailure: classifyRawEventViewerFailure,
+    cwd,
+    discardResponseBody,
+    enabled: rawEventsEnabled,
+    failureActions: RAW_EVENT_FAILURE_ACTIONS,
+    fetchRawEventsStatus,
+    hostLog,
+    hostNotify,
+    identityTarget: promptPackIdentityTarget,
+    isActive: () => runtimeActive,
+    logLine,
+    nextEventId,
+    projectName: resolveProjectName(project, cwd),
+    promptPackDbPath,
+    rawEventsStatusTimeoutMs: RAW_EVENTS_STATUS_TIMEOUT_MS,
+    rawEventsStatusUrl,
+    rawEventsUrl,
+    sessionStartedAt: () => sessionStartedAt,
+    statusCheckMs: rawEventsStatusCheckMs,
+    spoolDrainLimit: rawEventSpoolDrainLimit,
+    spoolHome: rawEventSpoolHome,
+    spoolMaxEntries: rawEventSpoolMaxEntries,
+  });
+
   const postViewerJson = async ({ url, operation, payload, validate }) => {
     if (!viewerEnabled) {
       return {
@@ -3363,26 +2962,6 @@ export const createCodememRuntime = async ({ location, host }) => {
     return { ok: true, body };
   };
 
-  const attemptMetadata = (identity, sessionID = null, promptNumber = promptCounter) => ({
-    attempt_id: identity.attemptId,
-    started_at: (() => {
-      const existing = attemptStartedAt.get(identity.attemptId);
-      if (existing) return existing;
-      const created = new Date().toISOString();
-      attemptStartedAt.set(identity.attemptId, created);
-      while (attemptStartedAt.size > 2000) {
-        const oldest = attemptStartedAt.keys().next().value;
-        if (!oldest) break;
-        attemptStartedAt.delete(oldest);
-      }
-      return created;
-    })(),
-    source: "opencode",
-    ...(sessionID ? { stream_id: String(sessionID), source_session_id: String(sessionID) } : {}),
-    ...(promptNumber > 0 ? { prompt_number: promptNumber } : {}),
-    request_id: identity.requestId,
-  });
-
   const runPromptPackLedger = async (payload, { viewerOnly = false } = {}) => {
     const viewerPayload = {
       ...payload,
@@ -3422,152 +3001,28 @@ export const createCodememRuntime = async ({ location, host }) => {
     }
   };
 
-  const skippedIdentity = (failureCode, sessionID, surface, eventKey) =>
-    promptPackIdentity({
-      sessionID: sessionID || "unknown",
-      requestKey: `${failureCode}:${eventKey}`,
-      surface,
-      promptNumber: promptCounter,
-      queryHash: hashPromptPackQuery(""),
-    });
-
-  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;
-    }
-    if (failureCode === "injection_disabled") disabledInjectionRecorded.add(memoKey);
-    const identity = skippedIdentity(
-      failureCode,
-      sessionID,
-      surface,
-      requestKey || (failureCode === "injection_disabled" ? "once" : `event-${++skippedAttemptCounter}`),
-    );
-    void runPromptPackLedger({
-      action: "record",
-      ...attemptMetadata(identity, sessionID),
-      retrieval_status: "skipped",
-      failure_code: failureCode,
-      failure_stage: "policy",
-    });
-    return identity.attemptId;
-  };
-
-  const recordCachedPromptPack = (cached, { messageId, sessionID, surface = "message" } = {}) => {
-    cached.reuseCount = (cached.reuseCount || 0) + 1;
-    const identity = promptPackIdentity({
-      sessionID: sessionID || "unknown",
-      requestKey: `${messageId || "unknown"}:cache:${cached.reuseCount}`,
-      surface,
-      promptNumber: cached.promptNumber || promptCounter,
-      queryHash: cached.queryHash || hashPromptPackQuery(""),
-    });
-    const ready = runPromptPackLedger({
-      action: "cache_reuse",
-      ...attemptMetadata(identity, sessionID, cached.promptNumber || promptCounter),
-      original_attempt_id: cached.attemptId,
-    });
-    return { attemptId: identity.attemptId, ready };
-  };
-
-  const confirmPromptPackDelivery = (attemptId, deliveryStatus = "handed_off", evaluation) => {
-    const delivery = {
-      action: "delivery", attempt_id: attemptId, delivery_status: deliveryStatus,
-    };
-    void runPromptPackLedger({
-      ...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 createTransformDelivery = (deferred) => {
-    const recordMeasurement = (measurement) => logLine(`inject.recall ${JSON.stringify(measurement)}`);
-    if (!deferred) {
-      return {
-        complete: undefined,
-        finish: async () => {},
-        beginFinalization: async () => {},
-        confirm: confirmPromptPackDelivery,
-        recordMeasurement,
-      };
-    }
-    let completion = null;
-    let finalizationReady = null;
-    let releaseFinalization = null;
-    const pending = [];
-    const commits = [];
-    const measurements = [];
-    const dispatch = ([attemptId, status, evaluation]) => {
-      const deliveryStatus = completion === "failed" && (!status || status === "handed_off")
-        ? "failed"
-        : status;
-      confirmPromptPackDelivery(attemptId, deliveryStatus, evaluation);
-    };
-    const beginFinalization = async (sessionID) => {
-      if (!finalizationReady) {
-        finalizationReady = acquireSessionFinalization(sessionID).then((release) => {
-          releaseFinalization = release;
-        });
-      }
-      await finalizationReady;
-    };
-    const finish = async (status = "handed_off") => {
-      if (completion) return;
-      completion = status;
-      const tasks = [];
-      try {
-        for (const commit of commits.splice(0)) {
-          if (status === "handed_off") tasks.push(commit());
-        }
-        for (const confirmation of pending.splice(0)) dispatch(confirmation);
-        for (const measurement of measurements.splice(0)) {
-          const finalized = status === "handed_off" ? measurement : {
-            ...measurement, reason: "delivery_failed", new_tokens: 0, retained_tokens: 0,
-          };
-          tasks.push(recordMeasurement(finalized));
-        }
-        await Promise.all(tasks);
-      } finally {
-        releaseFinalization?.();
-        releaseFinalization = null;
-      }
-    };
-    return {
-      commit: (commit) => { commits.push(commit); },
-      recordMeasurement: (measurement) => { measurements.push(measurement); },
-      beginFinalization,
-      finish,
-      complete: finish,
-      confirm: (...confirmation) => {
-        if (completion) dispatch(confirmation);
-        else pending.push(confirmation);
-      },
-    };
-  };
+  const recallLifecycle = createRecallLifecycle({
+    createIdentity: promptPackIdentity,
+    emptyQueryHash: hashPromptPackQuery(""),
+    runPromptPackLedger,
+    logLine,
+    getPromptCounter: () => promptCounter,
+    defaultSurface: injectSurface,
+  });
+  const {
+    injectionToastShown,
+    messageInjectionCache,
+    emptyRecallCache,
+    attemptMetadata,
+    recordSkippedPromptPack,
+    recordCachedPromptPack,
+    confirmPromptPackDelivery,
+    createTransformDelivery,
+    advancePromptPackRetryIdentity,
+    getPromptPackRetryCount,
+    getSuccessfulPromptPackArtifact,
+    rememberSuccessfulPromptPackArtifact,
+  } = recallLifecycle;
 
   const showToast = async (message, variant = "warning") => {
     if (backendUpdatePolicy === "off") {
@@ -3578,7 +3033,7 @@ export const createCodememRuntime = async ({ location, host }) => {
     }
     try {
       await hostNotify({ message, variant });
-    } catch (toastErr) {
+    } catch {
       // best-effort only
     }
   };
@@ -3615,7 +3070,7 @@ export const createCodememRuntime = async ({ location, host }) => {
     }
 
     const versionResult = await runCli(["version"]);
-    if (!versionResult || versionResult.exitCode !== 0) {
+    if (versionResult?.exitCode !== 0) {
       await logLine(
         `compat.version_check_failed exit=${versionResult?.exitCode ?? "unknown"} stderr=${
           versionResult?.stderr ? redactLog(versionResult.stderr.trim()) : ""
@@ -3856,35 +3311,6 @@ export const createCodememRuntime = async ({ location, host }) => {
     return masked.length > limit ? `${masked.slice(0, limit)}…` : masked;
   };
 
-  const advancePromptPackRetryIdentity = (attemptKey) => {
-    promptPackRetryCounts.set(
-      attemptKey,
-      (promptPackRetryCounts.get(attemptKey) || 0) + 1
-    );
-    while (promptPackRetryCounts.size > 2000) {
-      const oldest = promptPackRetryCounts.keys().next().value;
-      if (!oldest) break;
-      promptPackRetryCounts.delete(oldest);
-    }
-  };
-
-  const rememberSuccessfulPromptPackArtifact = (
-    attemptKey,
-    retryCount,
-    fingerprint
-  ) => {
-    successfulPromptPackArtifacts.delete(attemptKey);
-    successfulPromptPackArtifacts.set(attemptKey, {
-      retryCount,
-      fingerprint,
-    });
-    while (successfulPromptPackArtifacts.size > 2000) {
-      const oldest = successfulPromptPackArtifacts.keys().next().value;
-      if (!oldest) break;
-      successfulPromptPackArtifacts.delete(oldest);
-    }
-  };
-
   let fallbackEvaluationSessionId = nextEventId();
   const buildInjectedContext = async (query, context = {}) => {
     const requestPackBudget = reserveContextPrefixBudget(context.tokenBudget ?? injectTokenBudget);
@@ -3930,7 +3356,7 @@ export const createCodememRuntime = async ({ location, host }) => {
       promptCounter,
       queryHash,
     ]);
-    let retryCount = promptPackRetryCounts.get(attemptKey) || 0;
+    let retryCount = getPromptPackRetryCount(attemptKey);
     const resolveIdentity = () => promptPackIdentity({
       sessionID,
       requestKey: retryCount > 0
@@ -3955,7 +3381,7 @@ export const createCodememRuntime = async ({ location, host }) => {
       };
     }
     const runPack = async () => {
-      let packArgs = buildPackArgs({
+      const packArgs = buildPackArgs({
         query,
         filesModified: sessionContext.filesModified,
         injectLimit,
@@ -4039,7 +3465,7 @@ export const createCodememRuntime = async ({ location, host }) => {
           }
         : null;
       advancePromptPackRetryIdentity(attemptKey);
-      retryCount = promptPackRetryCounts.get(attemptKey) || 0;
+      retryCount = getPromptPackRetryCount(attemptKey);
       identity = resolveIdentity();
       metadata = attemptMetadata(identity, requesterHostSessionID);
       ({ packArgs, result } = await runPack());
@@ -4082,7 +3508,7 @@ export const createCodememRuntime = async ({ location, host }) => {
           });
         }
         advancePromptPackRetryIdentity(attemptKey);
-        retryCount = promptPackRetryCounts.get(attemptKey) || 0;
+        retryCount = getPromptPackRetryCount(attemptKey);
         ({
           packArgs,
           result,
@@ -4102,7 +3528,7 @@ export const createCodememRuntime = async ({ location, host }) => {
       }
     }
     if (packText) {
-      const previous = successfulPromptPackArtifacts.get(attemptKey);
+      const previous = getSuccessfulPromptPackArtifact(attemptKey);
       if (
         previous?.retryCount === retryCount
         && previous.fingerprint !== artifactFingerprint
@@ -4122,7 +3548,7 @@ export const createCodememRuntime = async ({ location, host }) => {
           ledgerConflict,
         };
         advancePromptPackRetryIdentity(attemptKey);
-        retryCount = promptPackRetryCounts.get(attemptKey) || 0;
+        retryCount = getPromptPackRetryCount(attemptKey);
         identity = resolveIdentity();
         metadata = attemptMetadata(identity, requesterHostSessionID);
         ({ packArgs, result } = await runPack());
@@ -4142,7 +3568,7 @@ export const createCodememRuntime = async ({ location, host }) => {
           // recorded that terminal outcome; do not misclassify it as a decode
           // failure or fall back to stale non-empty context.
           injectedIdentity = identity;
-        } else if (!result || result.exitCode !== 0 || !packText) {
+        } else if (result?.exitCode !== 0 || !packText) {
           const malformedSuccess = result?.exitCode === 0;
           const exitCode = result?.exitCode ?? "unknown";
           const stderr = redactLog(result?.stderr ? result.stderr.trim() : "");
@@ -4185,7 +3611,7 @@ export const createCodememRuntime = async ({ location, host }) => {
         }
       }
     }
-    if (!result || result.exitCode !== 0) {
+    if (result?.exitCode !== 0) {
       const exitCode = result?.exitCode ?? "unknown";
       const stderr = redactLog(result?.stderr ? result.stderr.trim() : "");
       const stdout = redactLog(result?.stdout ? result.stdout.trim() : "");
@@ -4336,7 +3762,7 @@ export const createCodememRuntime = async ({ location, host }) => {
       // not a git repo. The catch below leaves version as "unknown".
       stdio: ["ignore", "pipe", "ignore"],
     }).trim();
-  } catch (err) {
+  } catch {
     // Ignore - version will remain 'unknown'
   }
 
@@ -4386,7 +3812,7 @@ export const createCodememRuntime = async ({ location, host }) => {
     }
     try {
       return JSON.stringify(value);
-    } catch (err) {
+    } catch {
       return String(value);
     }
   };
@@ -4472,7 +3898,7 @@ export const createCodememRuntime = async ({ location, host }) => {
     rawEventDeliveryCount++;
     const delivery = rawEventDeliveryTail.then(async () => {
       await rawEventPreparations.get(input.payload);
-      return deliverRawEvent(input);
+      return rawEventDelivery.deliver(input);
     });
     rawEventDeliveries.set(input.payload, delivery);
     rawEventDeliveryTail = delivery.catch(() => {}).finally(() => {
@@ -4501,19 +3927,19 @@ export const createCodememRuntime = async ({ location, host }) => {
     });
     const rawEventId =
       adapterAnnotatedEvent?._adapter?.event_id ||
-      (adapterAnnotatedEvent && adapterAnnotatedEvent._raw_event_id) ||
+      adapterAnnotatedEvent?._raw_event_id ||
       nextEventId();
     const queuedEvent = {
       ...adapterAnnotatedEvent,
       _raw_event_id: rawEventId,
       _raw_session_id: resolvedSessionID,
     };
-    rawEventStartedAts.set(queuedEvent, sessionStartedAt);
+    rawEventDelivery.setStartedAt(queuedEvent, sessionStartedAt);
     recordEvent(queuedEvent);
     if (prompt && rawEventsEnabled && host.resolveCaptureContext) {
       const preparation = Promise.resolve().then(() => host.resolveCaptureContext(prompt))
         .then((context) => {
-          if (context) rawEventCaptureContexts.set(queuedEvent, context);
+          if (context) rawEventDelivery.setCaptureContext(queuedEvent, context);
         }).catch(() => {
           // Optional provenance must never discard an otherwise valid prompt.
         });
@@ -4635,7 +4061,7 @@ export const createCodememRuntime = async ({ location, host }) => {
         );
         await logLine(`flush.ok count=${batch.events.length} dropped=0`);
       }
-      if (runtimeActive) await drainRawEventSpool();
+      if (runtimeActive) await rawEventDelivery.drainSpool();
     } catch {
       // Flush delivery and diagnostics must not reject into OpenCode hooks.
     }
@@ -4668,7 +4094,7 @@ export const createCodememRuntime = async ({ location, host }) => {
 
   const flushEmptyQueue = async () => {
     try {
-      await drainRawEventSpool();
+      await rawEventDelivery.drainSpool();
       await logLine("flush.skip empty");
     } catch {
       // Empty flushes follow the same non-rejecting hook contract.
@@ -4747,14 +4173,14 @@ export const createCodememRuntime = async ({ location, host }) => {
     return scheduleQueuedEvents({ owner: activeSessionID });
   };
 
-  void drainRawEventSpool();
+  void rawEventDelivery.drainSpool();
 
   const deactivateRuntime = () => {
     if (!runtimeActive) return;
     runtimeActive = false;
     clearTimeout(updateCheckTimer);
     stopHealthCheck();
-    rawEventAbortController.abort();
+    rawEventDelivery.abort();
     releasePluginRegistration();
   };
 
@@ -5003,9 +4429,7 @@ export const createCodememRuntime = async ({ location, host }) => {
         sessionStartedAt = new Date().toISOString();
         promptCounter = 0;
         fallbackEvaluationSessionId = nextEventId();
-        skippedAttemptCounter = 0;
-        disabledInjectionRecorded.delete("message:unknown");
-        disabledInjectionRecorded.delete("system:unknown");
+        recallLifecycle.startSession();
         lastPromptText = null;
         if (sessionID) {
           await capturePendingPrompts({
@@ -5190,19 +4614,9 @@ export const createCodememRuntime = async ({ location, host }) => {
           sessionStartSessionID = null;
         }
         if (sessionID) {
-          for (const key of lastToastAtBySession.keys()) {
-            if (key.startsWith(`${sessionID}:`)) {
-              lastToastAtBySession.delete(key);
-            }
-          }
-          injectionToastShown.delete(sessionID);
-          messageInjectionCache.delete(sessionID);
-          emptyRecallCache.delete(sessionID);
+          rawEventDelivery.clearSession(sessionID);
+          recallLifecycle.clearSession(sessionID);
           compactionInjectionSkips.delete(sessionID);
-          disabledInjectionRecorded.delete(`message:${sessionID}`);
-          disabledInjectionRecorded.delete(`system:${sessionID}`);
-          latestPolicySkips.delete(`message:${sessionID}`);
-          latestPolicySkips.delete(`system:${sessionID}`);
           for (const key of failedToolCaptured) {
             if (key.startsWith(`${sessionID}:`)) {
               failedToolCaptured.delete(key);
@@ -5333,6 +4747,8 @@ export const __testUtils = {
   rejectsInternalLedgerFlag,
   classifyFallbackCommandResult,
   classifyRawEventViewerFailure,
+  classifyRawEventTransportCause,
+  describeRawEventViewerFailure,
   detectRunner,
   PROMPT_TRANSPORT_PROTOCOL_RANGE,
   normalizePromptTransportProtocolRange,