opencode-immune 1.0.40 → 1.0.42

package/dist/plugin.js

@@ -11,7 +11,7 @@ const child_process_1 = require("child_process");
 // ═══════════════════════════════════════════════════════════════════════════════
 // PLUGIN VERSION CHECK
 // ═══════════════════════════════════════════════════════════════════════════════
-const PLUGIN_VERSION = "1.0.40";
+const PLUGIN_VERSION = "1.0.42";
 const PLUGIN_PACKAGE_NAME = "opencode-immune";
 /**
  * Read plugin version from package.json at runtime.
@@ -75,6 +75,7 @@ function createState(input) {
         recoveryContext: null,
         managedUltraworkSessions: new Map(),
         sessionRetryTimers: new Map(),
+        providerRetryWatchdogs: new Map(),
         sessionErrorRetryCount: new Map(),
         ultraworkMarkerPath: (0, path_1.join)(input.directory, ".opencode", "state", "ultrawork-active.json"),
         diagnosticsLogPath: (0, path_1.join)(input.directory, ".opencode", "state", "opencode-immune-debug.log"),
@@ -91,6 +92,7 @@ function createState(input) {
 }
 const ULTRAWORK_AGENT = "0-ultrawork";
 const MANAGED_SESSION_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const PROVIDER_RETRY_WATCHDOG_MS = 30_000;
 const RATE_LIMIT_FALLBACK_MODEL = {
     providerID: "externcash",
     modelID: "gpt-5.5",
@@ -206,8 +208,17 @@ function cancelPendingSessionRetry(state, sessionID, reason) {
     state.sessionRetryTimers.delete(sessionID);
     console.log(`[opencode-immune] Cancelled pending retry for session ${sessionID}: ${reason}`);
 }
+function cancelProviderRetryWatchdog(state, sessionID, reason) {
+    const timer = state.providerRetryWatchdogs.get(sessionID);
+    if (!timer)
+        return;
+    clearTimeout(timer);
+    state.providerRetryWatchdogs.delete(sessionID);
+    console.log(`[opencode-immune] Cancelled provider retry watchdog for session ${sessionID}: ${reason}`);
+}
 async function removeManagedUltraworkSession(state, sessionID, reason) {
     cancelPendingSessionRetry(state, sessionID, reason);
+    cancelProviderRetryWatchdog(state, sessionID, reason);
     state.sessionErrorRetryCount.delete(sessionID);
     const existed = state.managedUltraworkSessions.delete(sessionID);
     if (!existed)
@@ -353,6 +364,31 @@ function isCertificateApiError(error) {
 function isProviderRetryBanner(text) {
     return /(?:<none>\s*)?retrying in \d+s\s*-\s*attempt #\d+/i.test(text);
 }
+function scheduleProviderRetryWatchdog(state, sessionID, model) {
+    if (!isManagedRootUltraworkSession(state, sessionID))
+        return;
+    if (state.providerRetryWatchdogs.has(sessionID))
+        return;
+    const timer = setTimeout(async () => {
+        state.providerRetryWatchdogs.delete(sessionID);
+        if (!isManagedRootUltraworkSession(state, sessionID))
+            return;
+        if (state.sessionRetryTimers.has(sessionID))
+            return;
+        await setSessionFallbackModel(state, sessionID, model);
+        await writeDiagnosticLog(state, "provider-retry-watchdog:fired", {
+            sessionID,
+            fallbackModel: model,
+        });
+        scheduleManagedSessionRetry(state, sessionID, {
+            delayMs: 1_000,
+            reason: "provider retry watchdog",
+            countAgainstBudget: false,
+            abortBeforePrompt: true,
+        });
+    }, PROVIDER_RETRY_WATCHDOG_MS);
+    state.providerRetryWatchdogs.set(sessionID, timer);
+}
 async function setSessionFallbackModel(state, sessionID, model) {
     const existing = state.managedUltraworkSessions.get(sessionID);
     if (!existing)
@@ -1175,6 +1211,7 @@ function createFallbackModels(state) {
             const wasAlreadyManaged = isManagedUltraworkSession(state, input.sessionID);
             await addManagedUltraworkSession(state, input.sessionID);
             await writeUltraworkMarker(state);
+            scheduleProviderRetryWatchdog(state, input.sessionID, RATE_LIMIT_FALLBACK_MODEL);
             // First contact with 0-ultrawork after plugin restart:
             // if marker is active and tasks.md has incomplete work, send AUTO-RESUME prompt.
             if (!wasAlreadyManaged && !state.autoResumeAttempted) {
@@ -1294,12 +1331,13 @@ function createEventHandler(state) {
             if (count < MAX_RETRIES) {
                 const delay = Math.min(BASE_DELAY_MS * Math.pow(2, count), MAX_DELAY_MS);
                 state.sessionErrorRetryCount.set(sessionID, count + 1);
-                // Pin fallback model: for child sessions always, for root provider-level failures.
+                // Child/subagent failures are owned by the router. Auto-resuming a failed
+                // child after the router advances can create two writers in one pipeline.
                 if (isChild) {
-                    await setSessionFallbackModel(state, sessionID, CHILD_SESSION_FALLBACK_MODEL);
-                    const errorType = isModelAccessError(error) ? "model access error" : isRateLimitApiError(error) ? "rate limit" : isCertificateApiError(error) ? "certificate error" : "retryable error";
-                    console.log(`[opencode-immune] Child session ${sessionID}: ${errorType} detected. ` +
-                        `Retry will use fallback model ${CHILD_SESSION_FALLBACK_MODEL.providerID}/${CHILD_SESSION_FALLBACK_MODEL.modelID}.`);
+                    console.log(`[opencode-immune] Child session ${sessionID}: retryable error detected. ` +
+                        `Skipping plugin auto-retry; router owns sequential fallback decisions.`);
+                    state.sessionErrorRetryCount.set(sessionID, count);
+                    return;
                 }
                 else if (isRoot && (isRateLimitApiError(error) || isCertificateApiError(error))) {
                     await setSessionFallbackModel(state, sessionID, RATE_LIMIT_FALLBACK_MODEL);
@@ -1324,6 +1362,7 @@ function createEventHandler(state) {
         // Reset retry counter on successful activity
         if (eventType === "session.updated" && sessionID) {
             cancelPendingSessionRetry(state, sessionID, "session updated");
+            cancelProviderRetryWatchdog(state, sessionID, "session updated");
             state.sessionErrorRetryCount.delete(sessionID);
             if (markUltraworkSessionActive(state, sessionID)) {
                 // session activity tracked in-memory only
@@ -1473,13 +1512,11 @@ function createTextCompleteHandler(state) {
         const text = output.text ?? "";
         if (!text)
             return;
+        cancelProviderRetryWatchdog(state, sessionID, "assistant text completed");
         // Some provider/SDK failures render as a retry banner instead of a
         // session.error event, leaving the UI waiting for long internal backoff.
-        if (isProviderRetryBanner(text) && isManagedUltraworkSession(state, sessionID)) {
-            const managedSession = getManagedSession(state, sessionID);
-            const fallbackModel = managedSession?.kind === "child"
-                ? CHILD_SESSION_FALLBACK_MODEL
-                : RATE_LIMIT_FALLBACK_MODEL;
+        if (isProviderRetryBanner(text) && isManagedRootUltraworkSession(state, sessionID)) {
+            const fallbackModel = RATE_LIMIT_FALLBACK_MODEL;
             await setSessionFallbackModel(state, sessionID, fallbackModel);
             scheduleManagedSessionRetry(state, sessionID, {
                 delayMs: 1_000,

package/package.json

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