@codemem/opencode-plugin 0.40.2 → 0.42.0

package/.opencode/lib/compat.js

@@ -106,9 +106,17 @@ const isPinnedGitSource = (runnerFrom) => {
   }
 };
 
-export const resolveAutoUpdatePlan = ({ runner, runnerFrom }) => {
-  const normalizedRunner = String(runner || "").trim();
-  const source = String(runnerFrom || "").trim();
+export const resolveAutoUpdatePlan = ({ runner, runnerFrom, runnerFromExplicit = false }) => {
+	const normalizedRunner = String(runner || "").trim();
+	const source = String(runnerFrom || "").trim();
+	if (isPinnedGitSource(source) || /^codemem@(?!latest$|next$|\*$)[^\s]+$/i.test(source)) {
+		return {
+			allowed: false,
+			reason: "pinned-source",
+			command: null,
+			commandText: null,
+		};
+	}
 
   if (normalizedRunner === "node") {
     return {
@@ -119,8 +127,16 @@ export const resolveAutoUpdatePlan = ({ runner, runnerFrom }) => {
     };
   }
 
-  if (normalizedRunner === "npx") {
-    return {
+	if (normalizedRunner === "npx") {
+		if (!runnerFromExplicit || !/^(?:codemem|codemem@(?:latest|next|\*))$/i.test(source)) {
+			return {
+				allowed: false,
+				reason: !runnerFromExplicit ? "implicit-pinned-source" : "custom-source",
+				command: null,
+				commandText: null,
+			};
+		}
+		return {
       allowed: true,
       reason: null,
       command: ["npm", "install", "-g", "codemem@latest"],
@@ -146,10 +162,14 @@ export const resolveAutoUpdatePlan = ({ runner, runnerFrom }) => {
     };
   }
 
-  return {
-    allowed: true,
-    reason: null,
-    command: ["npm", "install", "-g", "codemem@latest"],
-    commandText: "npm install -g codemem@latest",
-  };
+	if (normalizedRunner === "codemem") {
+		return {
+			allowed: true,
+			reason: null,
+			command: ["npm", "install", "-g", "codemem@latest"],
+			commandText: "npm install -g codemem@latest",
+		};
+	}
+
+	return { allowed: false, reason: "unknown-runner", command: null, commandText: null };
 };

package/.opencode/plugins/codemem.js

@@ -1,6 +1,7 @@
 import { appendFile, mkdir } from "node:fs/promises";
 import { existsSync, readFileSync } from "node:fs";
 import { basename, dirname, join, posix, resolve, win32 } from "node:path";
+import { homedir } from "node:os";
 import { createHash } from "node:crypto";
 import { spawn as nodeSpawn, execSync } from "node:child_process";
 import { tool } from "@opencode-ai/plugin";
@@ -15,16 +16,48 @@ import {
 
 const TRUTHY_VALUES = ["1", "true", "yes"];
 const DISABLED_VALUES = ["0", "false", "off"];
-const PINNED_BACKEND_VERSION = "0.40.2";
+const PINNED_BACKEND_VERSION = "0.42.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 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;
+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;
 
 let compatCheckCache = null;
+const notifiedReleaseVersions = new Set();
+
+// Release an unread response body without surfacing cancellation failures.
+const discardResponseBody = (response) => {
+  try {
+    const cancelled = response?.body?.cancel?.();
+    if (cancelled && typeof cancelled.catch === "function") {
+      cancelled.catch(() => {});
+    }
+  } catch {
+    // Best effort — a locked or already-errored stream is fine to abandon.
+  }
+};
+
+// Bounded ingest-availability preflight: a hung viewer socket must not stall
+// raw-event delivery indefinitely. Failures fall into the existing stream
+// backoff + CLI enqueue fallback path.
+const fetchRawEventsStatus = (url, fetchFn = fetch) =>
+  fetchFn(url, {
+    method: "GET",
+    signal: AbortSignal.timeout(RAW_EVENTS_STATUS_TIMEOUT_MS),
+  });
 
 const normalizeEnvValue = (value) => (value || "").toLowerCase();
 const envHasValue = (value, truthyValues) =>
@@ -32,6 +65,149 @@ const envHasValue = (value, truthyValues) =>
 const envNotDisabled = (value) =>
   !DISABLED_VALUES.includes(normalizeEnvValue(value));
 
+const createViewerHealthMonitor = ({
+  viewerHealthUrl,
+  legacyStatusUrl,
+  isActive,
+  restartViewer,
+  logLine,
+  fetchFn = fetch,
+  now = Date.now,
+  setIntervalFn = setInterval,
+  clearIntervalFn = clearInterval,
+  timeoutSignal = (timeoutMs) => AbortSignal.timeout(timeoutMs),
+}) => {
+  let timer = null;
+  let consecutiveFailures = 0;
+  let lastRestartAttempt = 0;
+
+  const boundedFetch = (url) => fetchFn(url, {
+    method: "GET",
+    signal: timeoutSignal(VIEWER_HEALTH_TIMEOUT_MS),
+  });
+
+  const probe = async () => {
+    let response;
+    try {
+      response = await boundedFetch(viewerHealthUrl);
+    } catch (error) {
+      return { live: false, detail: `error: ${String(error).slice(0, 200)}` };
+    }
+
+    if (response.status === 404) {
+      discardResponseBody(response);
+      try {
+        // Old-viewer compatibility: released viewers serving this route
+        // always include the `ingest` availability object, so require that
+        // identifying evidence rather than trusting any 2xx from an
+        // arbitrary local service.
+        const fallbackResponse = await boundedFetch(legacyStatusUrl);
+        if (!fallbackResponse.ok) {
+          discardResponseBody(fallbackResponse);
+          return { live: false, detail: `fallback status=${fallbackResponse.status}` };
+        }
+        const fallbackPayload = await fallbackResponse.json();
+        const looksLikeViewer =
+          fallbackPayload &&
+          typeof fallbackPayload === "object" &&
+          fallbackPayload.ingest &&
+          typeof fallbackPayload.ingest === "object";
+        return looksLikeViewer
+          ? { live: true }
+          : { live: false, detail: "fallback unexpected payload" };
+      } catch (error) {
+        return { live: false, detail: `fallback error: ${String(error).slice(0, 200)}` };
+      }
+    }
+
+    if (!response.ok) {
+      // Release the unread body so a persistently failing viewer does not
+      // pin connections across the 60s monitor interval.
+      discardResponseBody(response);
+      return { live: false, detail: `status=${response.status}` };
+    }
+
+    let payload;
+    try {
+      payload = await response.json();
+    } catch (error) {
+      return { live: false, detail: `invalid JSON: ${String(error).slice(0, 200)}` };
+    }
+    if (!payload || typeof payload !== "object" || payload.service !== "codemem-viewer") {
+      return { live: false, detail: "unexpected service" };
+    }
+    return { live: true };
+  };
+
+  const check = async () => {
+    if (!isActive()) return;
+    const result = await probe();
+    if (result.live) {
+      if (consecutiveFailures > 0) {
+        await logLine(`viewer.health recovered after ${consecutiveFailures} failure(s)`);
+      }
+      consecutiveFailures = 0;
+      return;
+    }
+
+    consecutiveFailures += 1;
+    await logLine(
+      `viewer.health check failed (${result.detail}, consecutive=${consecutiveFailures})`
+    );
+    if (
+      consecutiveFailures < VIEWER_HEALTH_RESTART_THRESHOLD ||
+      now() - lastRestartAttempt < VIEWER_HEALTH_RESTART_COOLDOWN_MS
+    ) {
+      return;
+    }
+
+    // Re-check after the awaited probe: a stop requested while the probe was
+    // in flight must not be undone by a restart.
+    if (!isActive()) return;
+
+    lastRestartAttempt = now();
+    await logLine(`viewer.health restarting viewer after ${consecutiveFailures} consecutive failures`);
+    try {
+      const restartResult = await restartViewer();
+      const restarted = restartResult?.exitCode === 0;
+      await logLine(
+        `viewer.health restart ${restarted ? "succeeded" : "failed"} (exit=${restartResult?.exitCode ?? "unknown"})`
+      );
+      if (restarted) consecutiveFailures = 0;
+    } catch (error) {
+      await logLine(`viewer.health restart error: ${String(error).slice(0, 200)}`);
+    }
+  };
+
+  const start = () => {
+    if (timer) return;
+    consecutiveFailures = 0;
+    timer = setIntervalFn(() => {
+      check().catch(() => {});
+    }, VIEWER_HEALTH_CHECK_INTERVAL_MS);
+    if (timer?.unref) timer.unref();
+  };
+
+  const stop = () => {
+    if (timer) {
+      clearIntervalFn(timer);
+      timer = null;
+    }
+    consecutiveFailures = 0;
+  };
+
+  return {
+    check,
+    start,
+    stop,
+    state: () => ({
+      consecutiveFailures,
+      lastRestartAttempt,
+      running: timer !== null,
+    }),
+  };
+};
+
 const resolveInjectSurface = (value) => {
   const normalized = String(value || "message").trim().toLowerCase();
   if (normalized === "system") {
@@ -176,6 +352,40 @@ 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 parseReleaseNotification = (result) => {
+  if (result?.exitCode !== 0) return null;
+  const stdout = String(result?.stdout || "").trim();
+  if (!stdout || Buffer.byteLength(stdout, "utf8") > MAX_UPDATE_STATUS_BYTES) return null;
+  try {
+    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)) {
+      return null;
+    }
+    if (
+      typeof status.recommended_action !== "string"
+      || !status.recommended_action.trim()
+      || status.recommended_action.length > MAX_UPDATE_ACTION_CHARS
+    ) {
+      return null;
+    }
+    return {
+      latestVersion: status.latest_version,
+      recommendedAction: status.recommended_action.trim(),
+      autoUpdateEligible: status.auto_update_eligible === true,
+    };
+  } catch {
+    return null;
+  }
+};
+
 const createLogLine = (logPath) => async (line) => {
   if (!logPath) {
     return;
@@ -413,6 +623,31 @@ const parsePackMetrics = (stdout) => {
   }
 };
 
+const buildViewerIdentityTarget = (env = process.env, cwd = process.cwd()) => {
+  const normalizeIdentityPath = (value) => {
+    const trimmed = String(value || "").trim();
+    if (!trimmed) return null;
+    const expanded = trimmed.startsWith("~/")
+      ? join(env.HOME?.trim() || homedir(), trimmed.slice(2))
+      : trimmed;
+    return resolve(cwd, expanded);
+  };
+  return {
+    device_id: env.CODEMEM_DEVICE_ID?.trim() || null,
+    actor_id_present: Object.hasOwn(env, "CODEMEM_ACTOR_ID"),
+    actor_id: env.CODEMEM_ACTOR_ID?.trim() || null,
+    config_path: normalizeIdentityPath(env.CODEMEM_CONFIG),
+    runtime_root: normalizeIdentityPath(env.CODEMEM_RUNTIME_ROOT),
+    workspace_id: env.CODEMEM_WORKSPACE_ID?.trim() || null,
+    home_dir: normalizeIdentityPath(env.HOME || homedir()),
+    pack_compression: env.CODEMEM_PACK_COMPRESSION?.trim() || null,
+    embedding_disabled: ["1", "true", "yes"].includes(
+      String(env.CODEMEM_EMBEDDING_DISABLED || "").toLowerCase(),
+    ),
+    embedding_model: env.CODEMEM_EMBEDDING_MODEL || "Xenova/bge-small-en-v1.5",
+  };
+};
+
 const parsePackOutput = (result) => {
   const succeeded = result?.exitCode === 0;
   let payload = null;
@@ -445,6 +680,229 @@ const parsePackOutput = (result) => {
   };
 };
 
+const isRecord = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+
+const isValidPackHttpPayload = (payload) => {
+  if (!isRecord(payload) || typeof payload.pack_text !== "string" || !isRecord(payload.metrics)) {
+    return false;
+  }
+  const itemCount = payload.metrics.total_items;
+  if (!Number.isInteger(itemCount) || itemCount < 0) {
+    return false;
+  }
+  if (
+    payload.ledger_artifact_fingerprint != null
+    && !/^[0-9a-f]{64}$/i.test(payload.ledger_artifact_fingerprint)
+  ) {
+    return false;
+  }
+  if (payload.ledger_outcome != null) {
+    return isRecord(payload.ledger_outcome)
+      && payload.ledger_outcome.ok === false
+      && payload.ledger_outcome.errorCode === "retrieval_ledger_write_failed"
+      && payload.ledger_outcome.reason === "idempotency_conflict";
+  }
+  return true;
+};
+
+const isValidLedgerHttpPayload = (payload) => isRecord(payload) && payload.ok === true;
+
+const isValidLedgerFailureHttpPayload = (payload) =>
+  isRecord(payload)
+  && payload.ok === false
+  && (
+    payload.errorCode === "retrieval_ledger_write_failed"
+    || payload.errorCode === "retrieval_ledger_delivery_write_failed"
+  )
+  && typeof payload.reason === "string";
+
+const isViewerDbMismatchPayload = (payload) =>
+  isRecord(payload)
+  && isRecord(payload.error)
+  && payload.error.code === "viewer_db_mismatch";
+
+const isViewerIdentityMismatchPayload = (payload) =>
+  isRecord(payload)
+  && isRecord(payload.error)
+  && payload.error.code === "viewer_identity_mismatch";
+
+const isViewerContractUnsupportedPayload = (payload) =>
+  isRecord(payload)
+  && isRecord(payload.error)
+  && payload.error.code === "viewer_contract_unsupported";
+
+const isViewerInvalidRequestPayload = (payload) =>
+  isRecord(payload)
+  && isRecord(payload.error)
+  && payload.error.code === "invalid_request";
+
+// 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({
+  minSupportedProtocolVersion: 1,
+  protocolVersion: 1,
+});
+
+const normalizePromptTransportProtocolRange = (
+  protocolVersion,
+  minSupportedProtocolVersion = undefined,
+) => {
+  if (!Number.isSafeInteger(protocolVersion) || protocolVersion < 1) return null;
+  const minimum = minSupportedProtocolVersion === undefined
+    ? protocolVersion
+    : minSupportedProtocolVersion;
+  if (!Number.isSafeInteger(minimum) || minimum < 1 || minimum > protocolVersion) return null;
+  return { minSupportedProtocolVersion: minimum, protocolVersion };
+};
+
+const arePromptTransportProtocolRangesCompatible = (left, right) =>
+  left.minSupportedProtocolVersion <= right.protocolVersion
+  && right.minSupportedProtocolVersion <= left.protocolVersion;
+
+const classifyPromptTransportFailure = ({ kind, compatibleProfile = false }) => {
+  if (kind === "database_mismatch" || kind === "runtime_identity_mismatch") {
+    return "local_fallback";
+  }
+  if (kind === "invalid_request") {
+    return compatibleProfile ? "terminal" : "fallback";
+  }
+  if (kind === "policy_failure" || kind === "authorization_failure") {
+    return "terminal";
+  }
+  if (kind === "viewer_contract_unsupported") {
+    return compatibleProfile ? "terminal" : "fallback";
+  }
+  return "fallback";
+};
+
+const isViewerPolicyOrAuthFailurePayload = (payload) => {
+  const code = isRecord(payload) && isRecord(payload.error)
+    ? payload.error.code
+    : isRecord(payload)
+    ? payload.error
+    : null;
+  return typeof code === "string" && [
+    "authorization_failed",
+    "forbidden",
+    "policy_denied",
+    "policy_disabled",
+    "unauthorized",
+  ].includes(code);
+};
+
+const viewerFailureClassification = (cause, disposition) => ({
+  cause,
+  disposition,
+  retryable: disposition !== "terminal",
+});
+
+const classifyViewerHttpFailure = ({
+  operation,
+  status = null,
+  error = null,
+  malformed = false,
+  body = null,
+  compatibleProfile = false,
+}) => {
+  if (malformed) {
+    return viewerFailureClassification(
+      `${operation} returned malformed success`,
+      classifyPromptTransportFailure({ kind: "malformed_response" }),
+    );
+  }
+  if (isViewerDbMismatchPayload(body)) {
+    return viewerFailureClassification(
+      `${operation} viewer database mismatch`,
+      classifyPromptTransportFailure({ kind: "database_mismatch" }),
+    );
+  }
+  if (isViewerIdentityMismatchPayload(body)) {
+    return viewerFailureClassification(
+      `${operation} viewer runtime identity mismatch`,
+      classifyPromptTransportFailure({ kind: "runtime_identity_mismatch" }),
+    );
+  }
+  if (isViewerContractUnsupportedPayload(body)) {
+    return viewerFailureClassification(
+      `${operation} viewer contract unsupported`,
+      classifyPromptTransportFailure({
+        kind: "viewer_contract_unsupported",
+        compatibleProfile,
+      }),
+    );
+  }
+  if (operation === "prompt-pack-ledger" && isValidLedgerFailureHttpPayload(body)) {
+    return viewerFailureClassification(`${operation} request rejected (${status})`, "terminal");
+  }
+  if (status === 401 || status === 403 || isViewerPolicyOrAuthFailurePayload(body)) {
+    return viewerFailureClassification(
+      `${operation} policy or authorization failure (${status})`,
+      classifyPromptTransportFailure({
+        kind: status === 401 || status === 403 ? "authorization_failure" : "policy_failure",
+      }),
+    );
+  }
+  if (isViewerInvalidRequestPayload(body)) {
+    return viewerFailureClassification(
+      `${operation} request rejected (${status})`,
+      classifyPromptTransportFailure({ kind: "invalid_request", compatibleProfile }),
+    );
+  }
+  if (status === 404 || status === 405) {
+    return viewerFailureClassification(`${operation} endpoint unavailable (${status})`, "fallback");
+  }
+  if (Number.isInteger(status) && status >= 500) {
+    return viewerFailureClassification(`${operation} server failure (${status})`, "fallback");
+  }
+  if (Number.isInteger(status)) {
+    return viewerFailureClassification(`${operation} unexpected response (${status})`, "fallback");
+  }
+  const diagnostic = [
+    error?.name,
+    error?.code,
+    error?.cause?.code,
+    error?.message,
+    error,
+  ].filter(Boolean).join(" ");
+  const timedOut = /AbortError|TimeoutError|timeout|timed out|ETIMEDOUT/i.test(diagnostic);
+  return viewerFailureClassification(
+    timedOut ? `${operation} request timeout` : `${operation} connection failed`,
+    "fallback",
+  );
+};
+
+const buildPackHttpBody = ({
+  query,
+  filesModified,
+  injectLimit,
+  injectTokenBudget,
+  projectName,
+  cwd,
+  dbPath,
+  identityTarget,
+  attempt,
+}) => ({
+  context: query,
+  limit: injectLimit !== null && Number.isFinite(injectLimit) && injectLimit > 0
+    ? Math.trunc(injectLimit)
+    : 10,
+  token_budget:
+    injectTokenBudget !== null
+    && Number.isFinite(injectTokenBudget)
+    && injectTokenBudget > 0
+      ? Math.trunc(injectTokenBudget)
+      : null,
+  ...(projectName ? { project: projectName } : {}),
+  ...(cwd ? { cwd } : {}),
+  db_path: dbPath,
+  identity_target: identityTarget,
+  working_set_files: Array.from(filesModified || [])
+    .slice(-8)
+    .map((value) => String(value || "").trim())
+    .filter((value) => value && value.length <= MAX_WORKING_SET_PATH_CHARS),
+  attempt,
+});
+
 const canonicalJson = (value) => {
   if (Array.isArray(value)) {
     return `[${value.map((item) => canonicalJson(item)).join(",")}]`;
@@ -491,7 +949,7 @@ const applyInjectedContextToOutput = async ({
   // lastPromptText hadn't yet been captured by the time
   // experimental.chat.system.transform fired) would silently re-serve
   // the first turn's pack. Recompute on every call instead — the chat
-  // path tolerates the runCli round trip, and correctness beats the
+  // path tolerates the transport round trip, and correctness beats the
   // O(1) hit when the cache key isn't tied to the prompt that produced
   // the pack.
   const query = resolveInjectQuery();
@@ -1264,7 +1722,7 @@ const buildRunnerArgs = ({ runner, runnerFrom, runnerFromExplicit }) => {
   return runnerFromExplicit ? [runnerFrom] : [];
 };
 
-export const OpencodeMemPlugin = async ({
+export const CodememPlugin = async ({
   project,
   client,
   directory,
@@ -1323,6 +1781,14 @@ export const OpencodeMemPlugin = async ({
   const viewerHost = process.env.CODEMEM_VIEWER_HOST || "127.0.0.1";
   const viewerPort = process.env.CODEMEM_VIEWER_PORT || "38888";
   const viewerDbPath = process.env.CODEMEM_DB || "";
+  const expandedViewerDbPath = viewerDbPath.startsWith("~/")
+    ? join(process.env.HOME?.trim() || homedir(), viewerDbPath.slice(2))
+    : viewerDbPath;
+  const promptPackDbPath = resolve(
+    cwd,
+    expandedViewerDbPath || join(homedir(), ".codemem", "mem.sqlite"),
+  );
+  const promptPackIdentityTarget = buildViewerIdentityTarget(process.env, cwd);
   const viewerConfigPath = process.env.CODEMEM_CONFIG || "";
   // A malformed value (e.g. "abc", "", "-1") falls back to the 20s default
   // instead of NaN, which would silently disable the timeout. An explicit "0"
@@ -1332,6 +1798,8 @@ export const OpencodeMemPlugin = async ({
   const rawCommandTimeout = String(process.env.CODEMEM_PLUGIN_CMD_TIMEOUT ?? "").trim();
   const commandTimeout =
     rawCommandTimeout === "0" ? 0 : parsePositiveInt(rawCommandTimeout, 20000);
+  const promptPackHttpTimeout =
+    parsePositiveInt(process.env.CODEMEM_INJECT_HTTP_MAX_TIME_S || "2", 2) * 1000;
   const backendUpdatePolicy = parseBackendUpdatePolicy(
     process.env.CODEMEM_BACKEND_UPDATE_POLICY || "notify"
   );
@@ -1359,6 +1827,8 @@ export const OpencodeMemPlugin = async ({
   let sessionStartedAt = null;
   let activeSessionID = null;
   let viewerStarted = false;
+  let viewerStartInFlight = false;
+  let compatibilityAutoUpdateAttempted = false;
   let promptCounter = 0;
   let skippedAttemptCounter = 0;
   let lastPromptText = null;
@@ -1373,8 +1843,15 @@ export const OpencodeMemPlugin = async ({
   const rawEventsEnabled = envNotDisabled(
     process.env.CODEMEM_RAW_EVENTS || "1"
   );
-  const rawEventsUrl = `http://${viewerHost}:${viewerPort}/api/raw-events`;
-  const rawEventsStatusUrl = `http://${viewerHost}:${viewerPort}/api/raw-events/status?limit=1`;
+  const viewerUrlHost = viewerHost.includes(":") && !viewerHost.startsWith("[")
+    ? `[${viewerHost}]`
+    : viewerHost;
+  const rawEventsUrl = `http://${viewerUrlHost}:${viewerPort}/api/raw-events`;
+  const rawEventsStatusUrl = `http://${viewerUrlHost}:${viewerPort}/api/raw-events/status?limit=1`;
+  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`;
+  const viewerHealthUrl = `http://${viewerUrlHost}:${viewerPort}/api/health`;
   const rawEventsBackoffMs = parseNumber(
     process.env.CODEMEM_RAW_EVENTS_BACKOFF_MS || "10000",
     10000
@@ -1392,14 +1869,8 @@ export const OpencodeMemPlugin = async ({
   let fallbackFailureNoted = false;
   let lastStatusCheckAt = 0;
   let lastStatusAvailable = true;
+  let promptPackTransportUnavailableUntil = 0;
 
-  // Viewer health-check state
-  const HEALTH_CHECK_INTERVAL_MS = 60_000;
-  const HEALTH_CONSECUTIVE_FAILURES_BEFORE_RESTART = 3;
-  const HEALTH_RESTART_COOLDOWN_MS = 5 * 60_000;
-  let healthCheckTimer = null;
-  let healthConsecutiveFailures = 0;
-  let healthLastRestartAttempt = 0;
   const nextEventId = () => {
     if (typeof crypto !== "undefined" && crypto.randomUUID) {
       return crypto.randomUUID();
@@ -1525,8 +1996,10 @@ export const OpencodeMemPlugin = async ({
     }
     try {
       if (now - lastStatusCheckAt >= Math.max(1000, rawEventsStatusCheckMs)) {
-        const statusResp = await fetch(rawEventsStatusUrl, { method: "GET" });
+        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();
@@ -1540,10 +2013,27 @@ export const OpencodeMemPlugin = async ({
       const postResp = await fetch(rawEventsUrl, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body),
+        body: JSON.stringify({
+          ...body,
+          db_path: promptPackDbPath,
+          identity_target: promptPackIdentityTarget,
+        }),
       });
       if (!postResp.ok) {
-        throw new Error(`raw-events post failed (${postResp.status})`);
+        let responseBody = null;
+        if (postResp.status === 409) {
+          try {
+            responseBody = await postResp.json();
+          } catch {
+            // Generic failure handling 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;
+        throw postError;
       }
       streamUnavailableUntil = 0;
       streamErrorNoted = false;
@@ -1566,6 +2056,7 @@ export const OpencodeMemPlugin = async ({
             type,
             viewerHost,
             viewerPort,
+            viewerTargetMismatch: err?.viewerTargetMismatch === true,
             error: String(err),
           },
         });
@@ -1881,12 +2372,28 @@ export const OpencodeMemPlugin = async ({
     return { usage, id: info.id };
   };
 
-  const startViewer = () => {
-    if (!viewerEnabled || !viewerAutoStart || viewerStarted) {
+  const startViewer = async () => {
+    if (!viewerEnabled || !viewerAutoStart || viewerStarted || viewerStartInFlight) {
       if (viewerStarted) logLine("viewer already started, skipping auto-start").catch(() => {});
       return;
     }
-    viewerStarted = true;
+    viewerStartInFlight = true;
+    let existingViewer = false;
+    try {
+      const existing = await fetch(viewerHealthUrl, {
+        method: "GET",
+        redirect: "manual",
+        signal: AbortSignal.timeout(1_000),
+      });
+      existingViewer = existing.ok;
+    } catch {
+      // No live viewer responded; proceed with the plugin-owned start.
+    }
+    if (existingViewer) {
+      viewerStartInFlight = false;
+      logLine("viewer already running, skipping plugin-owned auto-start").catch(() => {});
+      return;
+    }
     const viewerArgs = buildViewerCliArgs("start");
     const cmd = [runner, ...runnerArgs, ...viewerArgs];
     logLine(`auto-starting viewer: ${cmd.join(" ")}`).catch(() => {});
@@ -1897,18 +2404,24 @@ export const OpencodeMemPlugin = async ({
         detached: true,
         stdio: "ignore",
       });
+      child.once("spawn", () => {
+        viewerStarted = true;
+        viewerStartInFlight = false;
+        startHealthCheck();
+      });
       child.on("error", (err) => {
+        viewerStartInFlight = false;
         logLine(`viewer spawn error: ${err.message}`).catch(() => {});
       });
       child.unref();
     } catch (err) {
+      viewerStartInFlight = false;
       logLine(`viewer spawn failed: ${err}`).catch(() => {});
     }
-    startHealthCheck();
   };
 
   const runCommand = async (cmd, options = {}) => {
-    const { stdinText = null } = options;
+    const { stdinText = null, timeoutMs = commandTimeout } = options;
     const [command, ...args] = cmd;
     return new Promise((resolve) => {
       const proc = nodeSpawn(command, args, {
@@ -1947,19 +2460,31 @@ export const OpencodeMemPlugin = async ({
         return;
       }
       let timer = null;
-      if (Number.isFinite(commandTimeout) && commandTimeout > 0) {
+      let killTimer = null;
+      let timedOut = false;
+      let settled = false;
+      const finish = (result) => {
+        if (settled) return;
+        settled = true;
+        if (timer) clearTimeout(timer);
+        if (killTimer) clearTimeout(killTimer);
+        resolve(result);
+      };
+      if (Number.isFinite(timeoutMs) && timeoutMs > 0) {
         timer = setTimeout(() => {
-          try { proc.kill(); } catch { /* ignore */ }
-          resolve({ exitCode: null, stdout, stderr: "timeout" });
-        }, commandTimeout);
+          timedOut = true;
+          try { proc.kill("SIGTERM"); } catch { /* ignore */ }
+          killTimer = setTimeout(() => {
+            try { proc.kill("SIGKILL"); } catch { /* ignore */ }
+          }, 5_000);
+          if (killTimer.unref) killTimer.unref();
+        }, timeoutMs);
       }
       proc.once("exit", (exitCode) => {
-        if (timer) clearTimeout(timer);
-        resolve({ exitCode, stdout, stderr });
+        finish({ exitCode: timedOut ? null : exitCode, stdout, stderr: timedOut ? "timeout" : stderr });
       });
       proc.once("error", (err) => {
-        if (timer) clearTimeout(timer);
-        resolve({ exitCode: 1, stdout: "", stderr: String(err) });
+        finish({ exitCode: 1, stdout: "", stderr: String(err) });
       });
     });
   };
@@ -1967,6 +2492,140 @@ export const OpencodeMemPlugin = async ({
   const runCli = async (args, options = {}) =>
     runCommand([runner, ...runnerArgs, ...args], options);
 
+  const postViewerJson = async ({ url, operation, payload, validate }) => {
+    if (!viewerEnabled) {
+      return {
+        ok: false,
+        classification: viewerFailureClassification(
+          `${operation} viewer transport disabled`,
+          "fallback",
+        ),
+      };
+    }
+    if (Date.now() < promptPackTransportUnavailableUntil) {
+      return {
+        ok: false,
+        classification: viewerFailureClassification(
+          `${operation} viewer transport in backoff`,
+          "fallback",
+        ),
+      };
+    }
+
+    let response;
+    try {
+      const profileResponse = await fetch(promptPackProfileUrl, {
+        method: "GET",
+        redirect: "manual",
+        signal: AbortSignal.timeout(promptPackHttpTimeout),
+      });
+      let profileBody;
+      try {
+        profileBody = await profileResponse.json();
+      } catch {
+        profileBody = null;
+      }
+      if (!profileResponse.ok) {
+        const classification = classifyViewerHttpFailure({
+          operation: `${operation} profile`,
+          status: profileResponse.status,
+          body: profileBody,
+        });
+        if (classification.retryable) {
+          promptPackTransportUnavailableUntil = Date.now() + Math.max(1000, rawEventsBackoffMs);
+        }
+        return { ok: false, classification };
+      }
+      const viewerProtocolRange = isRecord(profileBody)
+        ? normalizePromptTransportProtocolRange(
+            profileBody.protocol_version,
+            profileBody.min_supported_protocol_version,
+          )
+        : null;
+      let profileFailure = null;
+      if (!isRecord(profileBody) || profileBody.service !== "codemem-viewer") {
+        profileFailure = viewerFailureClassification(
+          `${operation} viewer profile malformed`,
+          classifyPromptTransportFailure({ kind: "profile_malformed" }),
+        );
+      } else if (!viewerProtocolRange) {
+        profileFailure = viewerFailureClassification(
+          `${operation} viewer protocol range malformed`,
+          classifyPromptTransportFailure({ kind: "profile_malformed" }),
+        );
+      } else if (!arePromptTransportProtocolRangesCompatible(
+        PROMPT_TRANSPORT_PROTOCOL_RANGE,
+        viewerProtocolRange,
+      )) {
+        profileFailure = viewerFailureClassification(
+          `${operation} viewer protocol range unsupported`,
+          classifyPromptTransportFailure({ kind: "protocol_range_mismatch" }),
+        );
+      } else if (profileBody.db_path !== promptPackDbPath) {
+        profileFailure = viewerFailureClassification(
+          `${operation} viewer database mismatch`,
+          classifyPromptTransportFailure({ kind: "database_mismatch" }),
+        );
+      } else if (
+        canonicalJson(profileBody.identity_target) !== canonicalJson(promptPackIdentityTarget)
+      ) {
+        profileFailure = viewerFailureClassification(
+          `${operation} viewer runtime identity mismatch`,
+          classifyPromptTransportFailure({ kind: "runtime_identity_mismatch" }),
+        );
+      }
+      if (profileFailure) {
+        promptPackTransportUnavailableUntil = Date.now() + Math.max(1000, rawEventsBackoffMs);
+        return {
+          ok: false,
+          classification: profileFailure,
+        };
+      }
+      response = await fetch(url, {
+        method: "POST",
+        redirect: "manual",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(promptPackHttpTimeout),
+      });
+    } catch (error) {
+      const classification = classifyViewerHttpFailure({ operation, error });
+      promptPackTransportUnavailableUntil =
+        Date.now() + Math.max(1000, rawEventsBackoffMs);
+      return { ok: false, classification };
+    }
+
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      body = null;
+    }
+    if (!response.ok) {
+      const classification = classifyViewerHttpFailure({
+        operation,
+        status: response.status,
+        body,
+        compatibleProfile: true,
+      });
+      if (classification.retryable) {
+        promptPackTransportUnavailableUntil =
+          Date.now() + Math.max(1000, rawEventsBackoffMs);
+      }
+      return { ok: false, classification };
+    }
+
+    if (!validate(body)) {
+      const classification = classifyViewerHttpFailure({ operation, malformed: true });
+      promptPackTransportUnavailableUntil =
+        Date.now() + Math.max(1000, rawEventsBackoffMs);
+      return { ok: false, classification };
+    }
+
+    promptPackTransportUnavailableUntil = 0;
+    return { ok: true, body };
+  };
+
   const attemptMetadata = (identity, sessionID = null, promptNumber = promptCounter) => ({
     attempt_id: identity.attemptId,
     started_at: (() => {
@@ -1988,10 +2647,39 @@ export const OpencodeMemPlugin = async ({
   });
 
   const runPromptPackLedger = async (payload) => {
+    const viewerPayload = {
+      ...payload,
+      db_path: promptPackDbPath,
+      identity_target: promptPackIdentityTarget,
+    };
+    const httpResult = await postViewerJson({
+      url: promptPackLedgerUrl,
+      operation: "prompt-pack-ledger",
+      payload: viewerPayload,
+      validate: isValidLedgerHttpPayload,
+    });
+    if (httpResult.ok) {
+      return {
+        exitCode: 0,
+        stdout: JSON.stringify(httpResult.body),
+        stderr: "",
+        transport: "viewer",
+      };
+    }
+
+    const { cause, 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" };
+    }
+
     try {
-      return await runCli(["prompt-pack-ledger"], {
+      const result = await runCli(["prompt-pack-ledger"], {
         stdinText: JSON.stringify(payload),
       });
+      return { ...result, transport: "cli" };
     } catch {
       return null;
     }
@@ -2077,7 +2765,7 @@ export const OpencodeMemPlugin = async ({
     if (!viewerEnabled || !viewerAutoStart || !viewerStarted) {
       return { attempted: false, ok: false };
     }
-    const restartResult = await runCli(buildViewerCliArgs("restart"));
+    const restartResult = await runCli(buildViewerCliArgs("restart"), { timeoutMs: 60_000 });
     if (restartResult?.exitCode === 0) {
       await logLine("compat.auto_update_viewer_restart ok");
       return { attempted: true, ok: true };
@@ -2157,12 +2845,14 @@ export const OpencodeMemPlugin = async ({
       `compat.version_mismatch current=${currentVersion} required=${minVersion} mode=${guidance.mode} note=${redactLog(guidance.note)}`
     );
 
-    const autoPlan = resolveAutoUpdatePlan({ runner, runnerFrom });
     if (backendUpdatePolicy === "auto") {
-      if (autoPlan.allowed && Array.isArray(autoPlan.command) && autoPlan.command.length > 0) {
-        const commandText = autoPlan.commandText || autoPlan.command.join(" ");
-        await logLine(`compat.auto_update_start cmd=${redactLog(commandText)}`);
-        const updateResult = await runCommand(autoPlan.command);
+      compatibilityAutoUpdateAttempted = true;
+      await logLine("compat.auto_update_start cmd=codemem update install --json");
+      const updateResult = await runCli(
+        ["update", "install", "--json"],
+        { timeoutMs: 420_000 }
+      );
+      if (updateResult?.exitCode === 0) {
         await logLine(
           `compat.auto_update_result exit=${updateResult?.exitCode ?? "unknown"} stderr=${redactLog(
             (updateResult?.stderr || "").trim()
@@ -2172,8 +2862,7 @@ export const OpencodeMemPlugin = async ({
         const refreshedResult = await runCli(["version"]);
         const refreshedVersion = (refreshedResult?.stdout || "").trim();
         if (
-          updateResult?.exitCode === 0
-          && refreshedResult?.exitCode === 0
+          refreshedResult?.exitCode === 0
           && isVersionAtLeast(refreshedVersion, minVersion)
         ) {
           writeCompatCheckCache(cacheKey, refreshedVersion);
@@ -2193,19 +2882,31 @@ export const OpencodeMemPlugin = async ({
           }
           return;
         }
-
+        await logLine(
+          `compat.auto_update_verification_failed current=${redactLog(refreshedVersion || "unknown")} required=${redactLog(minVersion)}`
+        );
         await showToast(
-          `${message}. Auto-update did not resolve it. Suggested action: ${guidance.action}`,
+          `${message}. Auto-update completed, but the active CLI failed verification. Suggested action: ${guidance.action}`,
           "warning"
         );
         return;
       }
-
+      let installError = null;
+      try {
+        installError = JSON.parse((updateResult?.stdout || "").trim())?.error || null;
+      } catch {
+        // Non-JSON output is treated as an installation failure.
+      }
+      const failureReason = installError === "update_install_locked"
+        ? "another update is already running"
+        : installError === "update_install_refused"
+          ? "not eligible"
+          : "installation failed";
       await logLine(
-        `compat.auto_update_skipped reason=${autoPlan.reason || "not-eligible"}`
+        `compat.auto_update_skipped reason=${installError || "update_install_failed"} exit=${updateResult?.exitCode ?? "unknown"} stderr=${redactLog((updateResult?.stderr || "").trim())}`
       );
       await showToast(
-        `${message}. Auto-update skipped (${autoPlan.reason || "not eligible"}). Suggested action: ${guidance.action}`,
+        `${message}. Auto-update skipped (${failureReason}). Suggested action: ${guidance.action}`,
         "warning"
       );
       return;
@@ -2214,6 +2915,53 @@ export const OpencodeMemPlugin = async ({
     await showToast(`${message}. Suggested action: ${guidance.action}`, "warning");
   };
 
+  const checkForReleaseUpdate = async () => {
+    if (backendUpdatePolicy === "off") return;
+    const notification = parseReleaseNotification(
+      await runCli(["update", "check", "--json"])
+    );
+    if (
+      !notification
+      || notifiedReleaseVersions.has(notification.latestVersion)
+    ) {
+      return;
+    }
+    notifiedReleaseVersions.add(notification.latestVersion);
+    if (
+      backendUpdatePolicy === "auto"
+      && notification.autoUpdateEligible
+      && !compatibilityAutoUpdateAttempted
+    ) {
+      const autoPlan = resolveAutoUpdatePlan({ runner, runnerFrom, runnerFromExplicit });
+      if (autoPlan.allowed) {
+        const installation = await runCli(
+          ["update", "install", "--json"],
+          { timeoutMs: 420_000 }
+        );
+        if (installation?.exitCode === 0) {
+          const viewerRestart = await restartViewerAfterAutoUpdate();
+          await showToast(`Updated codemem to ${notification.latestVersion}.`, "success");
+          if (viewerRestart.attempted && !viewerRestart.ok) {
+            await showToast(
+              "Backend updated, but viewer restart failed. Run `codemem serve restart`.",
+              "warning"
+            );
+          }
+          return;
+        }
+        await logLine(
+          `release.auto_update_failed exit=${installation?.exitCode ?? "unknown"} stderr=${redactLog(
+            (installation?.stderr || "").trim()
+          )}`
+        );
+      }
+    }
+    await showToast(
+      `codemem ${notification.latestVersion} is available. ${notification.recommendedAction}`,
+      "warning"
+    );
+  };
+
   const resolveInjectQuery = (overrides = {}) => {
     const firstPrompt = hasOwn(overrides, "firstPrompt")
       ? overrides.firstPrompt
@@ -2317,12 +3065,51 @@ export const OpencodeMemPlugin = async ({
         injectTokenBudget,
         internalLedger: true,
       });
+      const httpResult = await postViewerJson({
+        url: packUrl,
+        operation: "pack",
+        payload: buildPackHttpBody({
+          query,
+          filesModified: sessionContext.filesModified,
+          injectLimit,
+          injectTokenBudget,
+          projectName: normalizeProjectLabel(process.env.CODEMEM_PROJECT),
+          cwd,
+          dbPath: promptPackDbPath,
+          identityTarget: promptPackIdentityTarget,
+          attempt: metadata,
+        }),
+        validate: isValidPackHttpPayload,
+      });
+      if (httpResult.ok) {
+        return {
+          packArgs,
+          result: {
+            exitCode: 0,
+            stdout: JSON.stringify(httpResult.body),
+            stderr: "",
+            transport: "viewer",
+          },
+        };
+      }
+
+      const { cause, retryable } = httpResult.classification;
+      await logLine(
+        `inject.pack.http_error cause=${JSON.stringify(redactLog(cause, 200))} retryable=${retryable}`
+      );
+      if (!retryable) {
+        return {
+          packArgs,
+          result: { exitCode: 1, stdout: "", stderr: cause, transport: "viewer" },
+        };
+      }
+
       let result = await runCli(packArgs, { stdinText: JSON.stringify(metadata) });
       if (rejectsInternalLedgerFlag(result)) {
         packArgs = packArgs.filter((arg) => arg !== "--internal-ledger");
         result = await runCli(packArgs);
       }
-      return { packArgs, result };
+      return { packArgs, result: { ...result, transport: "cli" } };
     };
     let { packArgs, result } = await runPack();
     let { packText, conflictPackText, metrics, itemCount, ledgerConflict } = parsePackOutput(result);
@@ -2333,7 +3120,7 @@ export const OpencodeMemPlugin = async ({
     let repairFallbackUsed = false;
     if (ledgerConflict) {
       // A restarted plugin has no artifact cache to predict this conflict. The
-      // CLI marker is authoritative: never attribute delivery to the stale
+      // ledger marker is authoritative: never attribute delivery to the stale
       // identity, and retry once with a fresh deterministic identity.
       await log("warn", "codemem prompt-pack ledger conflict; retrying with fresh identity", {
         sessionID,
@@ -2606,62 +3393,15 @@ export const OpencodeMemPlugin = async ({
     await runCli(buildViewerCliArgs("stop"));
   };
 
-  const checkViewerHealth = async () => {
-    if (!viewerStarted || !viewerEnabled) return;
-    try {
-      const resp = await fetch(rawEventsStatusUrl, {
-        method: "GET",
-        signal: AbortSignal.timeout(5000),
-      });
-      if (resp.ok) {
-        if (healthConsecutiveFailures > 0) {
-          await logLine(`viewer.health recovered after ${healthConsecutiveFailures} failure(s)`);
-        }
-        healthConsecutiveFailures = 0;
-        return;
-      }
-      healthConsecutiveFailures++;
-      await logLine(`viewer.health check failed (status=${resp.status}, consecutive=${healthConsecutiveFailures})`);
-    } catch (err) {
-      healthConsecutiveFailures++;
-      await logLine(`viewer.health check error (consecutive=${healthConsecutiveFailures}): ${String(err).slice(0, 200)}`);
-    }
-
-    if (
-      healthConsecutiveFailures >= HEALTH_CONSECUTIVE_FAILURES_BEFORE_RESTART &&
-      Date.now() - healthLastRestartAttempt >= HEALTH_RESTART_COOLDOWN_MS
-    ) {
-      healthLastRestartAttempt = Date.now();
-      await logLine(`viewer.health restarting viewer after ${healthConsecutiveFailures} consecutive failures`);
-      try {
-        const result = await runCli(buildViewerCliArgs("restart"));
-        const ok = result?.exitCode === 0;
-        await logLine(`viewer.health restart ${ok ? "succeeded" : "failed"} (exit=${result?.exitCode ?? "unknown"})`);
-        if (ok) {
-          healthConsecutiveFailures = 0;
-        }
-      } catch (restartErr) {
-        await logLine(`viewer.health restart error: ${String(restartErr).slice(0, 200)}`);
-      }
-    }
-  };
-
-  const startHealthCheck = () => {
-    if (healthCheckTimer) return;
-    healthConsecutiveFailures = 0;
-    healthCheckTimer = setInterval(() => {
-      checkViewerHealth().catch(() => {});
-    }, HEALTH_CHECK_INTERVAL_MS);
-    if (healthCheckTimer.unref) healthCheckTimer.unref();
-  };
-
-  const stopHealthCheck = () => {
-    if (healthCheckTimer) {
-      clearInterval(healthCheckTimer);
-      healthCheckTimer = null;
-    }
-    healthConsecutiveFailures = 0;
-  };
+  const viewerHealthMonitor = createViewerHealthMonitor({
+    viewerHealthUrl,
+    legacyStatusUrl: rawEventsStatusUrl,
+    isActive: () => viewerStarted && viewerEnabled,
+    restartViewer: () => runCli(buildViewerCliArgs("restart")),
+    logLine,
+  });
+  const startHealthCheck = viewerHealthMonitor.start;
+  const stopHealthCheck = viewerHealthMonitor.stop;
 
   // Get version info (commit hash) for debugging
   let version = "unknown";
@@ -2680,15 +3420,26 @@ export const OpencodeMemPlugin = async ({
 
   await log("info", "codemem plugin initialized", { cwd, version });
   await logLine(`plugin initialized cwd=${cwd} version=${version}`);
-  startViewer();
-  const compatCheckTimer = setTimeout(() => {
-    void verifyCliCompatibility().catch(async (err) => {
-      await logLine(
-        `compat.version_check_error message=${String(err?.message || err || "unknown")}`
-      );
-    });
+  void startViewer();
+  const updateCheckTimer = setTimeout(() => {
+    void (async () => {
+      try {
+        await verifyCliCompatibility();
+      } catch (err) {
+        await logLine(
+          `compat.version_check_error message=${String(err?.message || err || "unknown")}`
+        );
+      }
+      try {
+        await checkForReleaseUpdate();
+      } catch (err) {
+        await logLine(
+          `release.update_check_error message=${String(err?.message || err || "unknown")}`
+        );
+      }
+    })();
   }, COMPAT_CHECK_DELAY_MS);
-  if (compatCheckTimer.unref) compatCheckTimer.unref();
+  if (updateCheckTimer.unref) updateCheckTimer.unref();
 
   const truncate = (value) => {
     if (value === undefined || value === null) {
@@ -2937,9 +3688,9 @@ export const OpencodeMemPlugin = async ({
           } inject_enabled=${injectEnabled} tui_toast=${Boolean(client.tui?.showToast)} query=${JSON.stringify(safeQuery)} first_prompt_len=${firstPromptLen} last_prompt_len=${lastPromptLen} project=${JSON.stringify(projectName)} files_modified=${filesModifiedCount}`
         );
       }
-      // Without the old per-session cache, every transform call shells out
-      // through `runCli`. Swallow rejections here so a single failed pack
-      // build (CLI crash, sqlite locked, network blip on HTTP fallback)
+      // Without the old per-session cache, every transform call rebuilds the
+      // pack. Swallow rejections here so a single failed build (viewer failure,
+      // CLI fallback crash, sqlite lock, or network blip)
       // can't take down the chat path.
       let applied = false;
       try {
@@ -3217,7 +3968,7 @@ export const OpencodeMemPlugin = async ({
           const stats = await runCli(["stats"]);
           const recent = await runCli(["recent", "--limit", "5"]);
           const lines = [
-            `viewer: http://${viewerHost}:${viewerPort}`,
+            `viewer: http://${viewerUrlHost}:${viewerPort}`,
             `log: ${logPath || "disabled"}`,
           ];
           if (stats.exitCode === 0 && stats.stdout.trim()) {
@@ -3262,9 +4013,16 @@ export const OpencodeMemPlugin = async ({
   };
 };
 
-export default OpencodeMemPlugin;
+export default CodememPlugin;
+
+/**
+ * @deprecated Use CodememPlugin.
+ * Keep this reference-identical: OpenCode deduplicates plugin exports by identity.
+ */
+export const OpencodeMemPlugin = CodememPlugin;
 export const __testUtils = {
   PINNED_BACKEND_VERSION,
+  fetchRawEventsStatus,
   inferProjectFromCwd,
   normalizeProjectLabel,
   resolveProjectName,
@@ -3276,8 +4034,17 @@ export const __testUtils = {
   redactPackCommand,
   rejectsInternalLedgerFlag,
   classifyFallbackCommandResult,
+  PROMPT_TRANSPORT_PROTOCOL_RANGE,
+  normalizePromptTransportProtocolRange,
+  arePromptTransportProtocolRangesCompatible,
+  classifyPromptTransportFailure,
+  classifyViewerHttpFailure,
+  isValidPackHttpPayload,
+  isValidLedgerHttpPayload,
+  buildPackHttpBody,
   parsePackText,
   parsePackMetrics,
+  buildViewerIdentityTarget,
   resolveInjectSurface,
   applyInjectedContextToOutput,
   applyInjectedContextToMessages,
@@ -3296,4 +4063,5 @@ export const __testUtils = {
   buildRawEventEnvelope,
   trimEventQueue,
   parsePositiveInt,
+  createViewerHealthMonitor,
 };

package/README.md

@@ -21,6 +21,13 @@ Manual config also works. Add the package name to your OpenCode config:
 
 OpenCode installs npm plugins automatically with Bun at startup.
 
+## Exports
+
+`CodememPlugin` is the canonical named export and the package default export.
+`OpencodeMemPlugin` remains available as a deprecated, reference-identical alias
+for compatibility with integrations created before the Codemem rename. No removal
+version is currently scheduled.
+
 ## Documentation
 
 - Repository: https://github.com/kunickiaj/codemem

package/index.js

@@ -1,2 +1,5 @@
-export { OpencodeMemPlugin as default } from "./.opencode/plugins/codemem.js";
-export { OpencodeMemPlugin } from "./.opencode/plugins/codemem.js";
+export {
+	CodememPlugin as default,
+	CodememPlugin,
+	OpencodeMemPlugin,
+} from "./.opencode/plugins/codemem.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codemem/opencode-plugin",
-  "version": "0.40.2",
+  "version": "0.42.0",
   "description": "CodeMem plugin for OpenCode",
   "type": "module",
   "main": "./index.js",
@@ -18,7 +18,7 @@
     ".opencode/lib/"
   ],
   "dependencies": {
-    "@opencode-ai/plugin": "1.18.12"
+    "@opencode-ai/plugin": "1.18.18"
   },
   "repository": {
     "type": "git",