opencode-immune 1.0.41 → 1.0.43

package/dist/plugin.js

@@ -11,7 +11,7 @@ const child_process_1 = require("child_process");
 // ═══════════════════════════════════════════════════════════════════════════════
 // PLUGIN VERSION CHECK
 // ═══════════════════════════════════════════════════════════════════════════════
-const PLUGIN_VERSION = "1.0.41";
+const PLUGIN_VERSION = "1.0.43";
 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,6 +94,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 CHILD_FALLBACK_REQUEST_TTL_MS = 10 * 60 * 1000;
 const RATE_LIMIT_FALLBACK_MODEL = {
     providerID: "externcash",
     modelID: "gpt-5.5",
@@ -364,14 +366,44 @@ 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 (!isManagedUltraworkSession(state, sessionID))
+    if (!isManagedRootUltraworkSession(state, sessionID))
         return;
     if (state.providerRetryWatchdogs.has(sessionID))
         return;
     const timer = setTimeout(async () => {
         state.providerRetryWatchdogs.delete(sessionID);
-        if (!isManagedUltraworkSession(state, sessionID))
+        if (!isManagedRootUltraworkSession(state, sessionID))
             return;
         if (state.sessionRetryTimers.has(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;
@@ -1251,7 +1298,6 @@ function createFallbackModels(state) {
         }
         else if (getManagedSession(state, input.sessionID)?.kind === "child") {
             await updateManagedSessionAgent(state, input.sessionID, input.agent);
-            scheduleProviderRetryWatchdog(state, input.sessionID, CHILD_SESSION_FALLBACK_MODEL);
         }
         // NOTE: Do NOT remove managed root sessions when agent changes in chat.params.
         // Subagent calls from 0-ultrawork (1-van, 7-backlog, etc.) use the same session.
@@ -1332,12 +1378,14 @@ 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}.`);
+                    recordChildFallbackRequest(state, managedSession, sessionID, error);
+                    console.log(`[opencode-immune] Child session ${sessionID}: retryable error detected. ` +
+                        `Recorded router-owned fallback request and skipped plugin auto-retry.`);
+                    state.sessionErrorRetryCount.set(sessionID, count);
+                    return;
                 }
                 else if (isRoot && (isRateLimitApiError(error) || isCertificateApiError(error))) {
                     await setSessionFallbackModel(state, sessionID, RATE_LIMIT_FALLBACK_MODEL);
@@ -1515,11 +1563,8 @@ function createTextCompleteHandler(state) {
         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.41",
+  "version": "1.0.43",
   "description": "OpenCode plugin: session recovery, auto-retry, multi-cycle automation, context monitoring",
   "exports": {
     "./server": "./dist/plugin.js"