opencode-immune 1.0.6 → 1.0.7

package/dist/plugin.js

@@ -10,8 +10,8 @@ function createState(input) {
         input,
         recoveryContext: null,
         managedUltraworkSessions: new Map(),
-        retryTimers: new Map(),
-        retryCount: new Map(),
+        sessionRetryTimers: new Map(),
+        sessionErrorRetryCount: new Map(),
         managedSessionsCachePath: (0, path_1.join)(input.directory, ".opencode", "state", "opencode-immune-managed-sessions.json"),
         diagnosticsLogPath: (0, path_1.join)(input.directory, ".opencode", "state", "opencode-immune-debug.log"),
         lastEditAttempt: null,
@@ -45,8 +45,8 @@ function pruneExpiredManagedSessions(state, now = Date.now()) {
         if (now - record.updatedAt <= MANAGED_SESSION_TTL_MS) {
             continue;
         }
-        cancelRetry(state, sessionID, "managed session TTL expired");
-        state.retryCount.delete(sessionID);
+        cancelPendingSessionRetry(state, sessionID, "managed session TTL expired");
+        state.sessionErrorRetryCount.delete(sessionID);
         state.managedUltraworkSessions.delete(sessionID);
         removed++;
     }
@@ -154,17 +154,17 @@ async function addManagedChildSession(state, sessionID, parentSessionID, timesta
     });
     await writeManagedSessionsCache(state);
 }
-function cancelRetry(state, sessionID, reason) {
-    const timer = state.retryTimers.get(sessionID);
+function cancelPendingSessionRetry(state, sessionID, reason) {
+    const timer = state.sessionRetryTimers.get(sessionID);
     if (!timer)
         return;
     clearTimeout(timer);
-    state.retryTimers.delete(sessionID);
+    state.sessionRetryTimers.delete(sessionID);
     console.log(`[opencode-immune] Cancelled pending retry for session ${sessionID}: ${reason}`);
 }
 async function removeManagedUltraworkSession(state, sessionID, reason) {
-    cancelRetry(state, sessionID, reason);
-    state.retryCount.delete(sessionID);
+    cancelPendingSessionRetry(state, sessionID, reason);
+    state.sessionErrorRetryCount.delete(sessionID);
     const existed = state.managedUltraworkSessions.delete(sessionID);
     if (!existed)
         return;
@@ -222,16 +222,28 @@ async function setSessionFallbackModel(state, sessionID, model) {
     });
     await writeManagedSessionsCache(state);
 }
-async function forceRetryManagedSession(state, sessionID, reason) {
+function getManagedSessionRetryContext(state, sessionID) {
     const managedSession = state.managedUltraworkSessions.get(sessionID);
     if (!managedSession)
-        return;
+        return null;
     const retryAgent = managedSession.agent || ULTRAWORK_AGENT;
     const fallbackModel = managedSession.fallbackModel;
     const retryText = retryAgent === ULTRAWORK_AGENT
         ? "[SYSTEM: Previous API call failed with a transient error. Re-read memory-bank/tasks.md, check the Phase Status block, and continue the pipeline. Use the exact neutral prompt from your Step 5 table for the next router call. Do NOT analyze or evaluate file contents.]"
         : `[SYSTEM: Previous API call failed with a transient error. Resume the current task in your current role as ${retryAgent}. Continue from the existing session state. Do not restart from scratch unless the current session state is missing.]`;
-    await writeDiagnosticLog(state, "force-retry:start", {
+    return {
+        managedSession,
+        retryAgent,
+        retryText,
+        fallbackModel,
+    };
+}
+async function sendManagedSessionRetryPrompt(state, sessionID, reason, options = {}) {
+    const retryContext = getManagedSessionRetryContext(state, sessionID);
+    if (!retryContext)
+        return false;
+    const { managedSession, retryAgent, retryText, fallbackModel } = retryContext;
+    await writeDiagnosticLog(state, "session-retry:start", {
         sessionID,
         reason,
         retryAgent,
@@ -239,17 +251,19 @@ async function forceRetryManagedSession(state, sessionID, reason) {
         rootSessionID: managedSession.rootSessionID,
         fallbackModel,
     });
-    try {
-        await state.input.client.session.abort({
-            path: { id: sessionID },
-        });
-        await writeDiagnosticLog(state, "force-retry:abort-success", { sessionID });
-    }
-    catch (err) {
-        await writeDiagnosticLog(state, "force-retry:abort-failed", {
-            sessionID,
-            error: err instanceof Error ? err.message : String(err),
-        });
+    if (options.abortBeforePrompt) {
+        try {
+            await state.input.client.session.abort({
+                path: { id: sessionID },
+            });
+            await writeDiagnosticLog(state, "session-retry:abort-success", { sessionID });
+        }
+        catch (err) {
+            await writeDiagnosticLog(state, "session-retry:abort-failed", {
+                sessionID,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
     }
     await state.input.client.session.promptAsync({
         body: {
@@ -264,16 +278,49 @@ async function forceRetryManagedSession(state, sessionID, reason) {
         },
         path: { id: sessionID },
     });
-    console.log(`[opencode-immune] Forced retry sent to session ${sessionID} (${reason})` +
+    console.log(`[opencode-immune] Retry prompt sent to session ${sessionID} (${reason})` +
         (fallbackModel
             ? ` using fallback model ${fallbackModel.providerID}/${fallbackModel.modelID}`
             : ""));
-    await writeDiagnosticLog(state, "force-retry:prompt-sent", {
+    await writeDiagnosticLog(state, "session-retry:prompt-sent", {
         sessionID,
         reason,
         retryAgent,
         fallbackModel,
     });
+    return true;
+}
+function scheduleManagedSessionRetry(state, sessionID, options) {
+    if (!isManagedRootUltraworkSession(state, sessionID)) {
+        return false;
+    }
+    if (state.sessionRetryTimers.has(sessionID)) {
+        console.log(`[opencode-immune] Retry already pending for session ${sessionID}, skipping duplicate.`);
+        return false;
+    }
+    const attemptInfo = options.attemptLabel ? ` (${options.attemptLabel})` : "";
+    console.log(`[opencode-immune] Scheduling retry for session ${sessionID}${attemptInfo}. ` +
+        `Waiting ${options.delayMs / 1000}s before retry...`);
+    const timer = setTimeout(async () => {
+        state.sessionRetryTimers.delete(sessionID);
+        if (!isManagedRootUltraworkSession(state, sessionID)) {
+            return;
+        }
+        try {
+            await sendManagedSessionRetryPrompt(state, sessionID, options.reason, {
+                abortBeforePrompt: options.abortBeforePrompt,
+            });
+        }
+        catch {
+            if (options.countAgainstBudget) {
+                state.sessionErrorRetryCount.set(sessionID, Math.max((state.sessionErrorRetryCount.get(sessionID) ?? 1) - 1, 0));
+            }
+            console.log(`[opencode-immune] Retry prompt failed for session ${sessionID}. ` +
+                `Will wait for the next retry signal.`);
+        }
+    }, options.delayMs);
+    state.sessionRetryTimers.set(sessionID, timer);
+    return true;
 }
 // ═══════════════════════════════════════════════════════════════════════════════
 // UTILITY: ERROR BOUNDARY
@@ -713,68 +760,39 @@ function createEventHandler(state) {
         const eventType = event.type ?? "unknown";
         const info = event.properties?.info;
         const sessionID = event.properties?.sessionID ?? info?.id;
-        // ── Auto-retry on retryable API error for managed ultrawork sessions ──
+        // ── Auto-retry on retryable API error for managed root ultrawork sessions ──
         if (eventType === "session.error" && sessionID) {
             const error = event.properties?.error;
-            if (!isManagedUltraworkSession(state, sessionID)) {
+            if (!isManagedRootUltraworkSession(state, sessionID)) {
                 return;
             }
             if (!isRetryableApiError(error)) {
-                cancelRetry(state, sessionID, "non-retryable or user-aborted error");
-                state.retryCount.delete(sessionID);
+                cancelPendingSessionRetry(state, sessionID, "non-retryable or user-aborted error");
+                state.sessionErrorRetryCount.delete(sessionID);
                 return;
             }
-            if (state.retryTimers.has(sessionID)) {
+            if (state.sessionRetryTimers.has(sessionID)) {
                 console.log(`[opencode-immune] Retry already pending for session ${sessionID}, skipping duplicate.`);
                 return;
             }
-            const count = state.retryCount.get(sessionID) ?? 0;
+            const count = state.sessionErrorRetryCount.get(sessionID) ?? 0;
             if (count < MAX_RETRIES) {
                 const delay = Math.min(BASE_DELAY_MS * Math.pow(2, count), MAX_DELAY_MS);
-                state.retryCount.set(sessionID, count + 1);
+                state.sessionErrorRetryCount.set(sessionID, count + 1);
                 if (isRateLimitApiError(error)) {
                     await setSessionFallbackModel(state, sessionID, RATE_LIMIT_FALLBACK_MODEL);
                     console.log(`[opencode-immune] Rate limit detected for session ${sessionID}. ` +
                         `Retry will use fallback model ${RATE_LIMIT_FALLBACK_MODEL.providerID}/${RATE_LIMIT_FALLBACK_MODEL.modelID}.`);
                 }
-                const managedSession = state.managedUltraworkSessions.get(sessionID);
-                const fallbackModel = managedSession?.fallbackModel;
-                const retryAgent = managedSession?.agent || ULTRAWORK_AGENT;
-                const retryText = retryAgent === ULTRAWORK_AGENT
-                    ? "[SYSTEM: Previous API call failed with a transient error. Re-read memory-bank/tasks.md, check the Phase Status block, and continue the pipeline. Use the exact neutral prompt from your Step 5 table for the next router call. Do NOT analyze or evaluate file contents.]"
-                    : `[SYSTEM: Previous API call failed with a transient error. Resume the current task in your current role as ${retryAgent}. Continue from the existing session state. Do not restart from scratch unless the current session state is missing.]`;
-                console.log(`[opencode-immune] Session error detected (attempt ${count + 1}/${MAX_RETRIES}). ` +
-                    `Waiting ${delay / 1000}s before retry...`);
-                const timer = setTimeout(async () => {
-                    state.retryTimers.delete(sessionID);
-                    if (!isManagedUltraworkSession(state, sessionID)) {
-                        return;
-                    }
-                    try {
-                        await state.input.client.session.promptAsync({
-                            body: {
-                                ...(fallbackModel ? { model: fallbackModel } : {}),
-                                agent: retryAgent,
-                                parts: [
-                                    {
-                                        type: "text",
-                                        text: retryText,
-                                    },
-                                ],
-                            },
-                            path: { id: sessionID },
-                        });
-                        console.log(`[opencode-immune] Auto-retry message sent to session ${sessionID}` +
-                            (fallbackModel
-                                ? ` using fallback model ${fallbackModel.providerID}/${fallbackModel.modelID}`
-                                : ""));
-                    }
-                    catch (err) {
-                        state.retryCount.set(sessionID, Math.max((state.retryCount.get(sessionID) ?? 1) - 1, 0));
-                        console.log(`[opencode-immune] Auto-retry failed (still offline?). Will retry on next error event.`);
-                    }
-                }, delay);
-                state.retryTimers.set(sessionID, timer);
+                const scheduled = scheduleManagedSessionRetry(state, sessionID, {
+                    delayMs: delay,
+                    reason: "session.error",
+                    attemptLabel: `attempt ${count + 1}/${MAX_RETRIES}`,
+                    countAgainstBudget: true,
+                });
+                if (!scheduled) {
+                    state.sessionErrorRetryCount.set(sessionID, count);
+                }
             }
             else {
                 console.log(`[opencode-immune] Max retries (${MAX_RETRIES}) reached for session ${sessionID}. Not retrying.`);
@@ -782,8 +800,8 @@ function createEventHandler(state) {
         }
         // Reset retry counter on successful activity
         if (eventType === "session.updated" && sessionID) {
-            cancelRetry(state, sessionID, "session updated");
-            state.retryCount.delete(sessionID);
+            cancelPendingSessionRetry(state, sessionID, "session updated");
+            state.sessionErrorRetryCount.delete(sessionID);
             if (markUltraworkSessionActive(state, sessionID)) {
                 await writeManagedSessionsCache(state);
             }
@@ -833,28 +851,27 @@ function createMultiCycleHandler(state) {
         messageContent = messageContent.trim();
         if (!messageContent)
             return;
-        if (sessionID && RATE_LIMIT_MESSAGE_PATTERN.test(messageContent)) {
-            const managedSession = getManagedSession(state, sessionID);
+        const messageRole = output.message?.role;
+        if (!isManagedRootUltraworkSession(state, sessionID))
+            return;
+        const managedSession = getManagedSession(state, sessionID);
+        if (sessionID &&
+            messageRole === "assistant" &&
+            RATE_LIMIT_MESSAGE_PATTERN.test(messageContent)) {
             if (managedSession && !managedSession.fallbackModel) {
                 await setSessionFallbackModel(state, sessionID, RATE_LIMIT_FALLBACK_MODEL);
                 console.log(`[opencode-immune] Rate limit message detected in chat output for session ${sessionID}. ` +
                     `Fallback model pinned to ${RATE_LIMIT_FALLBACK_MODEL.providerID}/${RATE_LIMIT_FALLBACK_MODEL.modelID}.`);
             }
-            if (managedSession && !state.retryTimers.has(sessionID)) {
-                const timer = setTimeout(async () => {
-                    state.retryTimers.delete(sessionID);
-                    try {
-                        await forceRetryManagedSession(state, sessionID, "rate-limit message fallback");
-                    }
-                    catch (err) {
-                        console.error(`[opencode-immune] Forced retry after rate-limit message failed for session ${sessionID}:`, err);
-                    }
-                }, 1_000);
-                state.retryTimers.set(sessionID, timer);
+            if (managedSession) {
+                scheduleManagedSessionRetry(state, sessionID, {
+                    delayMs: 1_000,
+                    reason: "rate-limit message fallback",
+                    countAgainstBudget: false,
+                    abortBeforePrompt: true,
+                });
             }
         }
-        if (!isManagedRootUltraworkSession(state, sessionID))
-            return;
         // ── PRE_COMMIT: execute /commit ──
         if (messageContent.includes(PRE_COMMIT_MARKER) && !state.commitPending) {
             state.commitPending = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-immune",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "OpenCode plugin: session recovery, auto-retry, multi-cycle automation, context monitoring",
   "exports": {
     "./server": "./dist/plugin.js"
@@ -29,4 +29,4 @@
     "retry"
   ],
   "license": "MIT"
-}
+}