opencode-immune 1.0.79 → 1.0.81

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.79";
+var PLUGIN_VERSION = "1.0.81";
 var PLUGIN_PACKAGE_NAME = "opencode-immune";
 var PLUGIN_DIRNAME = dirname(fileURLToPath(import.meta.url));
 function getServerAuthHeaders() {
@@ -3876,6 +3876,7 @@ function createState(input) {
     autoResumeInFlight: false,
     autoCycleInFlight: false,
     autoCycleSourceSessions: /* @__PURE__ */ new Set(),
+    autoCycleFallbackTimers: /* @__PURE__ */ new Map(),
     autoCycleLockPath: join(
       input.directory,
       ".opencode",
@@ -3895,6 +3896,8 @@ var PROVIDER_RETRY_WATCHDOG_MS = 3e4;
 var RETRY_PROMPT_DELIVERY_ATTEMPTS = 3;
 var CHILD_FALLBACK_REQUEST_TTL_MS = 10 * 60 * 1e3;
 var AUTO_CYCLE_LOCK_TTL_MS = 30 * 60 * 1e3;
+var FALLBACK_AUTO_CYCLE_DELAY_MS = 6e4;
+var ROOT_RETRY_CHILD_ACTIVITY_SUPPRESSION_MS = 2 * 6e4;
 var MODEL_NAME_CAPABILITY_SCORE = {
   "claude-opus-4-7": 100,
   "gpt-5.5": 100,
@@ -3914,6 +3917,26 @@ function isManagedRootUltraworkSession(state, sessionID) {
   const record = getManagedSession(state, sessionID);
   return !!record && record.kind === "root";
 }
+function hasRecentManagedChildSessionForRoot(state, rootSessionID, sinceMs) {
+  const cutoff = Date.now() - sinceMs;
+  for (const record of state.managedUltraworkSessions.values()) {
+    if (record.kind === "child" && record.rootSessionID === rootSessionID && record.updatedAt >= cutoff) return true;
+  }
+  return false;
+}
+function hasPendingChildFallbackRequestForRoot(state, rootSessionID, now = Date.now()) {
+  for (const request of state.childFallbackRequests.values()) {
+    if (request.rootSessionID === rootSessionID && now - request.createdAt <= CHILD_FALLBACK_REQUEST_TTL_MS) return true;
+  }
+  return false;
+}
+function shouldSuppressRootRetryForChildActivity(state, rootSessionID) {
+  return hasPendingChildFallbackRequestForRoot(state, rootSessionID) || hasRecentManagedChildSessionForRoot(
+    state,
+    rootSessionID,
+    ROOT_RETRY_CHILD_ACTIVITY_SUPPRESSION_MS
+  );
+}
 async function createManagedUltraworkSession(state, title) {
   const result = await state.client.session.create({
     directory: state.input.directory,
@@ -4092,8 +4115,15 @@ async function isUltraworkMarkerActive(state) {
 }
 async function addManagedUltraworkSession(state, sessionID, timestamp = Date.now()) {
   const existing = state.managedUltraworkSessions.get(sessionID);
+  if (existing?.kind === "child") {
+    state.managedUltraworkSessions.set(sessionID, {
+      ...existing,
+      updatedAt: timestamp
+    });
+    return;
+  }
   const nextRecord = {
-    kind: existing?.kind ?? "root",
+    kind: "root",
     agent: ULTRAWORK_AGENT,
     rootSessionID: existing?.rootSessionID ?? sessionID,
     parentSessionID: existing?.parentSessionID,
@@ -4110,6 +4140,11 @@ async function addManagedUltraworkSession(state, sessionID, timestamp = Date.now
 async function addManagedChildSession(state, sessionID, parentSessionID, timestamp = Date.now()) {
   const parent = state.managedUltraworkSessions.get(parentSessionID);
   if (!parent) return;
+  cancelFallbackAutoCycle(
+    state,
+    parent.rootSessionID,
+    `child session ${sessionID} created`
+  );
   cancelProviderRetryWatchdog(
     state,
     parent.rootSessionID,
@@ -4155,8 +4190,13 @@ function cancelProviderRetryWatchdog(state, sessionID, reason) {
   );
 }
 async function removeManagedUltraworkSession(state, sessionID, reason) {
+  const existing = state.managedUltraworkSessions.get(sessionID);
   cancelPendingSessionRetry(state, sessionID, reason);
   cancelProviderRetryWatchdog(state, sessionID, reason);
+  cancelFallbackAutoCycle(state, sessionID, reason);
+  if (existing?.kind === "child") {
+    cancelFallbackAutoCycle(state, existing.rootSessionID, `child session ${sessionID} ${reason}`);
+  }
   state.sessionErrorRetryCount.delete(sessionID);
   const existed = state.managedUltraworkSessions.delete(sessionID);
   if (!existed) return;
@@ -5622,6 +5662,14 @@ function createEventHandler(state) {
         "aborted message recovery"
       );
       if (managedSession?.kind === "root") {
+        if (shouldSuppressRootRetryForChildActivity(state, sessionID)) {
+          await writeDiagnosticLog(state, "session-retry:root-suppressed-child-active", {
+            sessionID,
+            messageID,
+            eventType
+          });
+          return;
+        }
         state.abortedMessageRetries.add(retryKey);
         await writeDiagnosticLog(state, "session-retry:aborted-message-observed", {
           sessionID,
@@ -5715,6 +5763,17 @@ function createEventHandler(state) {
         );
         return;
       }
+      if (isRoot && shouldSuppressRootRetryForChildActivity(state, sessionID)) {
+        await writeDiagnosticLog(state, "session-retry:root-suppressed-child-active", {
+          sessionID,
+          eventType,
+          errorType: getRetryableErrorType(error)
+        });
+        pluginLog.info(
+          `[opencode-immune] Suppressed root retry for ${sessionID}: child session activity owns this failure.`
+        );
+        return;
+      }
       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);
@@ -5760,7 +5819,15 @@ function createEventHandler(state) {
       state.sessionErrorRetryCount.delete(sessionID);
       if (markUltraworkSessionActive(state, sessionID)) {
       }
+      if (managedSession?.kind === "root") {
+        cancelFallbackAutoCycle(state, sessionID, "root session updated");
+      }
       if (managedSession?.kind === "child") {
+        cancelFallbackAutoCycle(
+          state,
+          managedSession.rootSessionID,
+          `child session ${sessionID} updated`
+        );
         cancelProviderRetryWatchdog(
           state,
           managedSession.rootSessionID,
@@ -5802,6 +5869,64 @@ async function commitCycleChanges(state, reason) {
     state.commitPending = false;
   }
 }
+function cancelFallbackAutoCycle(state, sessionID, reason) {
+  const timer = state.autoCycleFallbackTimers.get(sessionID);
+  if (!timer) return;
+  clearTimeout(timer);
+  state.autoCycleFallbackTimers.delete(sessionID);
+  pluginLog.info(
+    `[opencode-immune] Cancelled fallback AUTO-CYCLE for session ${sessionID}: ${reason}`
+  );
+}
+function scheduleFallbackAutoCycle(state, sessionID) {
+  if (state.autoCycleFallbackTimers.has(sessionID)) return;
+  const timer = setTimeout(async () => {
+    state.autoCycleFallbackTimers.delete(sessionID);
+    if (!isManagedRootUltraworkSession(state, sessionID)) return;
+    if (state.autoCycleInFlight || state.autoCycleSourceSessions.has(sessionID)) return;
+    if (hasRecentManagedChildSessionForRoot(state, sessionID, FALLBACK_AUTO_CYCLE_DELAY_MS)) {
+      scheduleFallbackAutoCycle(state, sessionID);
+      return;
+    }
+    const recovery = await parseTasksFile(state.input.directory);
+    if (recovery) return;
+    const hasPendingTasks = await hasPendingBacklogTasks(state.input.directory);
+    if (!hasPendingTasks) return;
+    const lockAcquired = await acquireAutoCycleLock(
+      state,
+      "multi-cycle-fallback",
+      sessionID
+    );
+    if (!lockAcquired) return;
+    state.autoCycleSourceSessions.add(sessionID);
+    state.autoCycleInFlight = true;
+    pluginLog.warn(
+      `[opencode-immune] Multi-Cycle fallback: no CYCLE_COMPLETE marker detected for ${sessionID} after ${FALLBACK_AUTO_CYCLE_DELAY_MS}ms grace period. Starting AUTO-CYCLE.`
+    );
+    try {
+      await commitCycleChanges(state, "fallback AUTO-CYCLE before new session");
+      await refreshAutoCycleLock(state, sessionID);
+      await startAutoCycleInNewSession(
+        state,
+        {
+          sourceSessionID: sessionID,
+          logContext: "Multi-Cycle fallback",
+          clearLockOnFailureReason: "fallback bootstrap failed",
+          retireSourceSession: true
+        }
+      );
+    } catch (err) {
+      state.autoCycleSourceSessions.delete(sessionID);
+      pluginLog.error("[opencode-immune] Multi-Cycle fallback: Failed to send prompt:", err);
+    } finally {
+      state.autoCycleInFlight = false;
+    }
+  }, FALLBACK_AUTO_CYCLE_DELAY_MS);
+  state.autoCycleFallbackTimers.set(sessionID, timer);
+  pluginLog.info(
+    `[opencode-immune] Multi-Cycle fallback: scheduled delayed AUTO-CYCLE check for ${sessionID}.`
+  );
+}
 async function archiveProgress(directory) {
   const progressPath = join(directory, "memory-bank", "progress.md");
   try {
@@ -5903,23 +6028,26 @@ function createTextCompleteHandler(state) {
       );
     }
     if (text.includes(ALL_CYCLES_COMPLETE_MARKER)) {
+      cancelFallbackAutoCycle(state, sessionID, "ALL_CYCLES_COMPLETE detected");
       await clearUltraworkMarker(state);
       await clearAutoCycleLock(state, "all cycles complete");
       pluginLog.info("[opencode-immune] Multi-Cycle: ALL_CYCLES_COMPLETE detected, marker cleared.");
       return;
     }
     if (text.includes(PRE_COMMIT_MARKER) && !text.includes(CYCLE_COMPLETE_MARKER)) {
+      cancelFallbackAutoCycle(state, sessionID, "PRE_COMMIT detected");
       await commitCycleChanges(state, "PRE_COMMIT detected (standalone)");
       return;
     }
     if (text.includes(CYCLE_COMPLETE_MARKER)) {
+      cancelFallbackAutoCycle(state, sessionID, "CYCLE_COMPLETE detected");
       if (state.autoCycleInFlight || state.autoCycleSourceSessions.has(sessionID)) return;
-      const lockAcquired2 = await acquireAutoCycleLock(
+      const lockAcquired = await acquireAutoCycleLock(
         state,
         "cycle-complete",
         sessionID
       );
-      if (!lockAcquired2) return;
+      if (!lockAcquired) return;
       state.autoCycleSourceSessions.add(sessionID);
       state.autoCycleInFlight = true;
       try {
@@ -5966,36 +6094,7 @@ function createTextCompleteHandler(state) {
     if (recovery) return;
     const hasPendingTasks = await hasPendingBacklogTasks(state.input.directory);
     if (!hasPendingTasks) return;
-    if (state.autoCycleSourceSessions.has(sessionID)) return;
-    const lockAcquired = await acquireAutoCycleLock(
-      state,
-      "multi-cycle-fallback",
-      sessionID
-    );
-    if (!lockAcquired) return;
-    state.autoCycleSourceSessions.add(sessionID);
-    state.autoCycleInFlight = true;
-    pluginLog.warn(
-      `[opencode-immune] Multi-Cycle fallback: no CYCLE_COMPLETE marker detected for ${sessionID}, but tasks.md has no active task and backlog has pending items. Starting AUTO-CYCLE.`
-    );
-    try {
-      await commitCycleChanges(state, "fallback AUTO-CYCLE before new session");
-      await refreshAutoCycleLock(state, sessionID);
-      await startAutoCycleInNewSession(
-        state,
-        {
-          sourceSessionID: sessionID,
-          logContext: "Multi-Cycle fallback",
-          clearLockOnFailureReason: "fallback bootstrap failed",
-          retireSourceSession: true
-        }
-      );
-    } catch (err) {
-      state.autoCycleSourceSessions.delete(sessionID);
-      pluginLog.error("[opencode-immune] Multi-Cycle fallback: Failed to send prompt:", err);
-    } finally {
-      state.autoCycleInFlight = false;
-    }
+    scheduleFallbackAutoCycle(state, sessionID);
   };
 }
 function createMultiCycleHandler(state) {

package/package.json

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