opencode-immune 1.0.42 → 1.0.44

package/dist/plugin.js

@@ -11,7 +11,7 @@ const child_process_1 = require("child_process");
 // ═══════════════════════════════════════════════════════════════════════════════
 // PLUGIN VERSION CHECK
 // ═══════════════════════════════════════════════════════════════════════════════
-const PLUGIN_VERSION = "1.0.42";
+const PLUGIN_VERSION = "1.0.44";
 const PLUGIN_PACKAGE_NAME = "opencode-immune";
 /**
  * Read plugin version from package.json at runtime.
@@ -76,6 +76,7 @@ function createState(input) {
         managedUltraworkSessions: new Map(),
         sessionRetryTimers: new Map(),
         providerRetryWatchdogs: new Map(),
+        childFallbackRequests: 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"),
@@ -93,12 +94,13 @@ 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 CHILD_FALLBACK_REQUEST_TTL_MS = 10 * 60 * 1000;
 const RATE_LIMIT_FALLBACK_MODEL = {
-    providerID: "externcash",
+    providerID: "codexsale",
     modelID: "gpt-5.5",
 };
 const CHILD_SESSION_FALLBACK_MODEL = {
-    providerID: "externcash",
+    providerID: "codexsale",
     modelID: "gpt-5.5",
 };
 function isManagedUltraworkSession(state, sessionID) {
@@ -364,6 +366,36 @@ function isCertificateApiError(error) {
 function isProviderRetryBanner(text) {
     return /(?:<none>\s*)?retrying in \d+s\s*-\s*attempt #\d+/i.test(text);
 }
+function getRetryableErrorType(error) {
+    if (isModelAccessError(error))
+        return "model access error";
+    if (isRateLimitApiError(error))
+        return "rate limit";
+    if (isCertificateApiError(error))
+        return "certificate error";
+    return "retryable provider error";
+}
+function recordChildFallbackRequest(state, managedSession, childSessionID, error) {
+    const request = {
+        childSessionID,
+        rootSessionID: managedSession.rootSessionID,
+        agent: managedSession.agent || "unknown",
+        errorType: getRetryableErrorType(error),
+        fallbackModel: CHILD_SESSION_FALLBACK_MODEL,
+        createdAt: Date.now(),
+    };
+    state.childFallbackRequests.set(managedSession.rootSessionID, request);
+}
+function getChildFallbackRequest(state, rootSessionID, now = Date.now()) {
+    const request = state.childFallbackRequests.get(rootSessionID);
+    if (!request)
+        return undefined;
+    if (now - request.createdAt > CHILD_FALLBACK_REQUEST_TTL_MS) {
+        state.childFallbackRequests.delete(rootSessionID);
+        return undefined;
+    }
+    return request;
+}
 function scheduleProviderRetryWatchdog(state, sessionID, model) {
     if (!isManagedRootUltraworkSession(state, sessionID))
         return;
@@ -1041,6 +1073,21 @@ function createSystemTransform(state) {
                     `Read memory-bank/tasks.md and memory-bank/activeContext.md to resume work.`);
             }
         }
+        const rootSessionID = input.sessionID;
+        if (rootSessionID && isManagedRootUltraworkSession(state, rootSessionID)) {
+            const childFallbackRequest = getChildFallbackRequest(state, rootSessionID);
+            if (childFallbackRequest) {
+                output.system.push(`[Router-Owned Child Retry Required]\n` +
+                    `A child/subagent session failed with a retryable provider/model error. ` +
+                    `Do not advance to the next sequential pipeline slot until this failed slot is explicitly resolved.\n` +
+                    `- Failed child session: ${childFallbackRequest.childSessionID}\n` +
+                    `- Agent: ${childFallbackRequest.agent}\n` +
+                    `- Error type: ${childFallbackRequest.errorType}\n` +
+                    `- Required fallback model: ${childFallbackRequest.fallbackModel.providerID}/${childFallbackRequest.fallbackModel.modelID}\n` +
+                    `Router action: retry the SAME agent/slot once using the fallback model if available; if it still fails or cannot be retried, record DECLINE/failed-provider-retry for that slot before continuing. ` +
+                    `Never resume the failed child session directly; create a router-owned replacement attempt instead.`);
+            }
+        }
         // Ralph Loop injection
         if (state.lastEditAttempt) {
             const edit = state.lastEditAttempt;
@@ -1334,8 +1381,9 @@ function createEventHandler(state) {
                 // 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) {
+                    recordChildFallbackRequest(state, managedSession, sessionID, error);
                     console.log(`[opencode-immune] Child session ${sessionID}: retryable error detected. ` +
-                        `Skipping plugin auto-retry; router owns sequential fallback decisions.`);
+                        `Recorded router-owned fallback request and skipped plugin auto-retry.`);
                     state.sessionErrorRetryCount.set(sessionID, count);
                     return;
                 }

package/package.json

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