opencode-immune 1.0.47 → 1.0.49

package/dist/plugin.js

@@ -12,7 +12,7 @@ const child_process_1 = require("child_process");
 // ═══════════════════════════════════════════════════════════════════════════════
 // PLUGIN VERSION CHECK
 // ═══════════════════════════════════════════════════════════════════════════════
-const PLUGIN_VERSION = "1.0.44";
+const PLUGIN_VERSION = "1.0.49";
 const PLUGIN_PACKAGE_NAME = "opencode-immune";
 /**
  * Read plugin version from package.json at runtime.
@@ -59,7 +59,9 @@ async function checkPluginUpdate(state) {
         if (latest && latest !== currentVersion) {
             state.pluginUpdateMessage =
                 `[PLUGIN UPDATE] opencode-immune ${currentVersion} → ${latest} is available. ` +
-                    `Please inform the user: a plugin update is available. They should restart opencode to get the latest version.`;
+                    `Please inform the user: run \`opencode plugin opencode-immune@latest --force\`, ` +
+                    `then restart opencode. If opencode still loads the old package, clear its package cache with ` +
+                    `\`rm -rf ~/.cache/opencode/packages/opencode-immune@latest\` and run the update command again.`;
             writePluginLog(state, "warn", `[opencode-immune] Plugin update available: ${currentVersion} → ${latest}.`);
         }
         else if (latest) {
@@ -388,7 +390,7 @@ function isRetryableApiError(error) {
         return true;
     }
     // HTTP status code based detection (retryable server/gateway errors + rate limits)
-    const status = maybeError.status ?? maybeError.statusCode ?? maybeError.data?.status;
+    const status = maybeError.status ?? maybeError.statusCode ?? maybeError.data?.status ?? maybeError.error?.status;
     if (status && (status === 404 || // transient endpoint not found (API gateway issues)
         status === 429 || // rate limit
         status === 500 || // internal server error
@@ -400,8 +402,18 @@ function isRetryableApiError(error) {
     }
     // Text-based detection for model access errors (not marked as retryable
     // by the API but retryable with a fallback model)
-    const message = `${maybeError.message ?? ""} ${maybeError.data?.message ?? ""}`.toLowerCase();
-    if (message.includes("не разрешен") ||
+    const message = [
+        maybeError.message,
+        maybeError.code,
+        maybeError.data?.message,
+        maybeError.data?.type,
+        maybeError.data?.code,
+        maybeError.error?.message,
+        maybeError.error?.type,
+        maybeError.error?.code,
+    ].filter((value) => value !== undefined && value !== null).join(" ").toLowerCase();
+    if (message.includes("api_error") ||
+        message.includes("не разрешен") ||
         message.includes("not allowed") ||
         message.includes("internal error") ||
         message.includes("internal server error") ||
@@ -437,6 +449,7 @@ function isRetryableApiError(error) {
         // Certificate/TLS provider failures must pass this primary retry gate
         // before the managed-session fallback model branch can run.
         message.includes("unknown certificate verification error") ||
+        message.includes("unknown_certificate_verification_error") ||
         message.includes("certificate has expired") ||
         message.includes("certificate verification") ||
         message.includes("tls") ||
@@ -466,23 +479,25 @@ function isRateLimitApiError(error) {
     if (!error || typeof error !== "object")
         return false;
     const maybeError = error;
-    const message = `${maybeError.message ?? ""} ${maybeError.data?.message ?? ""}`.toLowerCase();
-    const type = `${maybeError.data?.type ?? ""}`.toLowerCase();
+    const message = `${maybeError.message ?? ""} ${maybeError.data?.message ?? ""} ${maybeError.error?.message ?? ""}`.toLowerCase();
+    const type = `${maybeError.data?.type ?? ""} ${maybeError.error?.type ?? ""}`.toLowerCase();
     return ((type.includes("rate_limit") || message.includes("too many requests") || message.includes("rate limit")));
 }
 function isCertificateApiError(error) {
     if (!error || typeof error !== "object")
         return false;
     const maybeError = error;
-    const message = `${maybeError.message ?? ""} ${maybeError.data?.message ?? ""}`.toLowerCase();
-    const code = `${maybeError.code ?? ""} ${maybeError.data?.code ?? ""}`.toLowerCase();
-    const type = `${maybeError.data?.type ?? ""}`.toLowerCase();
+    const message = `${maybeError.message ?? ""} ${maybeError.data?.message ?? ""} ${maybeError.error?.message ?? ""}`.toLowerCase();
+    const code = `${maybeError.code ?? ""} ${maybeError.data?.code ?? ""} ${maybeError.error?.code ?? ""}`.toLowerCase();
+    const type = `${maybeError.data?.type ?? ""} ${maybeError.error?.type ?? ""}`.toLowerCase();
     return (message.includes("unknown certificate verification error") ||
+        message.includes("unknown_certificate_verification_error") ||
         message.includes("certificate has expired") ||
         message.includes("certificate verification") ||
         message.includes("tls") ||
         message.includes("ssl") ||
         code.includes("cert_has_expired") ||
+        code.includes("unknown_certificate_verification_error") ||
         code.includes("unable_to_verify_leaf_signature") ||
         code.includes("self_signed_cert") ||
         code.includes("tls") ||
@@ -558,6 +573,28 @@ async function setSessionFallbackModel(state, sessionID, model) {
         fallbackModel: model,
     });
 }
+async function recoverUntrackedRootSessionForRetry(state, sessionID, error) {
+    if (!isRetryableApiError(error))
+        return undefined;
+    const markerActive = await isUltraworkMarkerActive(state);
+    if (!markerActive)
+        return undefined;
+    const recovery = await parseTasksFile(state.input.directory);
+    if (!recovery || recovery.phase === "ARCHIVE: DONE")
+        return undefined;
+    state.recoveryContext = recovery;
+    await addManagedUltraworkSession(state, sessionID);
+    const recovered = getManagedSession(state, sessionID);
+    await writeDiagnosticLog(state, "session-retry:recovered-untracked-root", {
+        sessionID,
+        task: recovery.task,
+        level: recovery.level,
+        phase: recovery.phase,
+        errorType: getRetryableErrorType(error),
+    });
+    writePluginLog(state, "warn", `[opencode-immune] Recovered untracked root session ${sessionID} for retry after plugin restart or state loss.`);
+    return recovered;
+}
 function getManagedSessionRetryContext(state, sessionID) {
     const managedSession = state.managedUltraworkSessions.get(sessionID);
     if (!managedSession)
@@ -1457,10 +1494,18 @@ function createEventHandler(state) {
         }
         // ── Auto-retry on retryable API error for managed ultrawork sessions ──
         if (eventType === "session.error" && sessionID) {
-            const managedSession = getManagedSession(state, sessionID);
+            const managedSession = getManagedSession(state, sessionID) ??
+                await recoverUntrackedRootSessionForRetry(state, sessionID, error);
             const isRoot = managedSession?.kind === "root";
             const isChild = managedSession?.kind === "child";
             if (!managedSession) {
+                if (isRetryableApiError(error)) {
+                    await writeDiagnosticLog(state, "session-retry:unmanaged-retryable-error", {
+                        sessionID,
+                        eventType,
+                        errorType: getRetryableErrorType(error),
+                    });
+                }
                 return;
             }
             if (!isRetryableApiError(error)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-immune",
-  "version": "1.0.47",
+  "version": "1.0.49",
   "description": "OpenCode plugin: session recovery, auto-retry, multi-cycle automation, context monitoring",
   "exports": {
     "./server": "./dist/plugin.js"