opencode-immune 1.0.70 → 1.0.72

package/dist/plugin/server.js

@@ -3777,7 +3777,7 @@ import { fileURLToPath } from "url";
 import { createHash } from "crypto";
 import { tmpdir } from "os";
 import { execFile } from "child_process";
-var PLUGIN_VERSION = "1.0.70";
+var PLUGIN_VERSION = "1.0.72";
 var PLUGIN_PACKAGE_NAME = "opencode-immune";
 var PLUGIN_DIRNAME = dirname(fileURLToPath(import.meta.url));
 function getServerAuthHeaders() {
@@ -3848,6 +3848,7 @@ function createState(input) {
     recoveryContext: null,
     managedUltraworkSessions: /* @__PURE__ */ new Map(),
     sessionRetryTimers: /* @__PURE__ */ new Map(),
+    abortedMessageRetries: /* @__PURE__ */ new Set(),
     providerRetryWatchdogs: /* @__PURE__ */ new Map(),
     childFallbackRequests: /* @__PURE__ */ new Map(),
     sessionErrorRetryCount: /* @__PURE__ */ new Map(),
@@ -3918,11 +3919,15 @@ var CHILD_SESSION_FALLBACK_MODEL = {
   providerID: "claudehub",
   modelID: "claude-opus-4-7"
 };
+var HIGH_CAPABILITY_FALLBACK_MODELS = [
+  { providerID: "codexsale", modelID: "gpt-5.5" },
+  { providerID: "codexsale", modelID: "gpt-5.4" }
+];
 var AUTO_CYCLE_LOCK_TTL_MS = 30 * 60 * 1e3;
 var FALLBACK_MODEL_CANDIDATES = [
   CHILD_SESSION_FALLBACK_MODEL,
-  RATE_LIMIT_FALLBACK_MODEL,
-  { providerID: "codexsale", modelID: "gpt-5.5" }
+  ...HIGH_CAPABILITY_FALLBACK_MODELS,
+  RATE_LIMIT_FALLBACK_MODEL
 ];
 var FALLBACK_AGENT_SUFFIX = "-provider-fallback";
 function isManagedUltraworkSession(state, sessionID) {
@@ -4346,6 +4351,46 @@ function getRetryableErrorType(error) {
   if (action === "retry") return `transient provider error${statusSuffix}`;
   return "non-retryable provider error";
 }
+function compactUnknown(value, maxLength = 8e3) {
+  try {
+    const serialized = typeof value === "string" ? value : JSON.stringify(value);
+    return (serialized ?? "").slice(0, maxLength).toLowerCase();
+  } catch {
+    return String(value).slice(0, maxLength).toLowerCase();
+  }
+}
+function isAbortedMessageEvent(eventType, properties) {
+  if (eventType !== "message.updated" && eventType !== "message.part.updated") return false;
+  const text = compactUnknown(properties ?? {});
+  return text.includes("messageabortederror") || text.includes("tool execution aborted") || text.includes('"interrupted":true') || text.includes('"status":"error"') && text.includes('"aborted"');
+}
+function getMessageIDFromEvent(properties) {
+  const info = isRecord(properties?.info) ? properties.info : void 0;
+  const part = isRecord(properties?.part) ? properties.part : void 0;
+  return stringifyErrorField(properties?.messageID) ?? stringifyErrorField(info?.id) ?? stringifyErrorField(part?.messageID) ?? stringifyErrorField(properties?.id);
+}
+async function recoverUntrackedRootSessionForActiveTask(state, sessionID, reason) {
+  const markerActive = await isUltraworkMarkerActive(state);
+  if (!markerActive) return void 0;
+  const recovery = await parseTasksFile(state.input.directory);
+  if (!recovery || recovery.phase === "ARCHIVE: DONE") return void 0;
+  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,
+    reason
+  });
+  writePluginLog(
+    state,
+    "warn",
+    `[opencode-immune] Recovered untracked root session ${sessionID} for ${reason}.`
+  );
+  return recovered;
+}
 function recordChildFallbackRequest(state, managedSession, childSessionID, error) {
   const fallbackModel = selectFallbackModel(
     getFailedModelFromError(error) ?? managedSession.currentModel
@@ -4405,26 +4450,11 @@ async function setSessionFallbackModel(state, sessionID, model) {
 }
 async function recoverUntrackedRootSessionForRetry(state, sessionID, error) {
   if (!isRetryableApiError(error)) return void 0;
-  const markerActive = await isUltraworkMarkerActive(state);
-  if (!markerActive) return void 0;
-  const recovery = await parseTasksFile(state.input.directory);
-  if (!recovery || recovery.phase === "ARCHIVE: DONE") return void 0;
-  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(
+  return recoverUntrackedRootSessionForActiveTask(
     state,
-    "warn",
-    `[opencode-immune] Recovered untracked root session ${sessionID} for retry after plugin restart or state loss.`
+    sessionID,
+    `retry after ${getRetryableErrorType(error)}`
   );
-  return recovered;
 }
 function getManagedSessionRetryContext(state, sessionID) {
   const managedSession = state.managedUltraworkSessions.get(sessionID);
@@ -5412,9 +5442,50 @@ function createEventHandler(state) {
     await sessionRecovery(input);
     const event = input.event;
     const eventType = event.type ?? "unknown";
-    const info = event.properties?.info;
-    const sessionID = event.properties?.sessionID ?? info?.id;
-    const error = event.properties?.error;
+    const properties = event.properties;
+    const info = properties?.info;
+    const sessionID = properties?.sessionID ?? info?.sessionID ?? info?.id;
+    const error = properties?.error ?? info?.error;
+    if (sessionID && isAbortedMessageEvent(eventType, properties)) {
+      const messageID = getMessageIDFromEvent(properties) ?? `${sessionID}:unknown`;
+      const retryKey = `${sessionID}:${messageID}`;
+      if (state.abortedMessageRetries.has(retryKey)) {
+        return;
+      }
+      const managedSession = getManagedSession(state, sessionID) ?? await recoverUntrackedRootSessionForActiveTask(
+        state,
+        sessionID,
+        "aborted message recovery"
+      );
+      if (managedSession?.kind === "root") {
+        state.abortedMessageRetries.add(retryKey);
+        await writeDiagnosticLog(state, "session-retry:aborted-message-observed", {
+          sessionID,
+          messageID,
+          eventType
+        });
+        const count = state.sessionErrorRetryCount.get(sessionID) ?? 0;
+        if (count < MAX_RETRIES) {
+          state.sessionErrorRetryCount.set(sessionID, count + 1);
+          const scheduled = scheduleManagedSessionRetry(state, sessionID, {
+            delayMs: Math.min(BASE_DELAY_MS * Math.pow(2, count), MAX_DELAY_MS),
+            reason: "aborted message",
+            attemptLabel: `aborted attempt ${count + 1}/${MAX_RETRIES}`,
+            countAgainstBudget: true
+          });
+          if (!scheduled) {
+            state.sessionErrorRetryCount.set(sessionID, count);
+          }
+        }
+      } else if (managedSession?.kind === "child") {
+        await writeDiagnosticLog(state, "session-retry:aborted-child-observed", {
+          sessionID,
+          messageID,
+          rootSessionID: managedSession.rootSessionID,
+          eventType
+        });
+      }
+    }
     if (eventType === "session.error") {
       await writeDiagnosticLog(state, "session-error:observed", {
         sessionID,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-immune",
-  "version": "1.0.70",
+  "version": "1.0.72",
   "type": "module",
   "description": "OpenCode plugin: session recovery, auto-retry, multi-cycle automation, context monitoring",
   "exports": {