opencode-immune 1.0.78 → 1.0.80

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.78";
+var PLUGIN_VERSION = "1.0.80";
 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,7 @@ 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 MODEL_NAME_CAPABILITY_SCORE = {
   "claude-opus-4-7": 100,
   "gpt-5.5": 100,
@@ -3914,6 +3916,13 @@ 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;
+}
 async function createManagedUltraworkSession(state, title) {
   const result = await state.client.session.create({
     directory: state.input.directory,
@@ -4110,6 +4119,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 +4169,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;
@@ -5760,7 +5779,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 +5829,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,47 +5988,64 @@ 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 lockAcquired = await acquireAutoCycleLock(
+        state,
+        "cycle-complete",
+        sessionID
+      );
+      if (!lockAcquired) return;
+      state.autoCycleSourceSessions.add(sessionID);
+      state.autoCycleInFlight = true;
       try {
-        await archiveProgress(state.input.directory);
-      } catch (err) {
-        pluginLog.warn("[opencode-immune] Multi-Cycle: archive progress failed:", err);
-      }
-      await commitCycleChanges(state, "CYCLE_COMPLETE detected");
-      state.cycleCount++;
-      if (state.cycleCount >= MAX_CYCLES) {
+        try {
+          await archiveProgress(state.input.directory);
+        } catch (err) {
+          pluginLog.warn("[opencode-immune] Multi-Cycle: archive progress failed:", err);
+        }
+        await commitCycleChanges(state, "CYCLE_COMPLETE detected");
+        state.cycleCount++;
+        if (state.cycleCount >= MAX_CYCLES) {
+          pluginLog.info(
+            `[opencode-immune] Multi-Cycle: MAX_CYCLES (${MAX_CYCLES}) reached. Not creating new session.`
+          );
+          await clearUltraworkMarker(state);
+          await clearAutoCycleLock(state, "max cycles reached");
+          return;
+        }
+        const taskMatch = text.match(NEXT_TASK_PATTERN);
+        const nextTask = taskMatch?.[1]?.trim() ?? "Continue processing task backlog";
         pluginLog.info(
-          `[opencode-immune] Multi-Cycle: MAX_CYCLES (${MAX_CYCLES}) reached. Not creating new session.`
+          `[opencode-immune] Multi-Cycle: Starting next cycle in a new session (cycle ${state.cycleCount}/${MAX_CYCLES}) for: "${nextTask}"`
         );
-        await clearUltraworkMarker(state);
-        return;
-      }
-      const taskMatch = text.match(NEXT_TASK_PATTERN);
-      const nextTask = taskMatch?.[1]?.trim() ?? "Continue processing task backlog";
-      pluginLog.info(
-        `[opencode-immune] Multi-Cycle: Starting next cycle in a new session (cycle ${state.cycleCount}/${MAX_CYCLES}) for: "${nextTask}"`
-      );
-      try {
         await startAutoCycleInNewSession(
           state,
           {
             sourceSessionID: sessionID,
             nextTask,
             logContext: "Multi-Cycle",
+            clearLockOnFailureReason: "cycle complete bootstrap failed",
             retireSourceSession: true
           }
         );
       } catch (err) {
+        state.autoCycleSourceSessions.delete(sessionID);
         pluginLog.error("[opencode-immune] Multi-Cycle: Failed to send prompt:", err);
+      } finally {
+        state.autoCycleInFlight = false;
       }
       return;
     }
@@ -5952,36 +6054,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.78",
+  "version": "1.0.80",
   "type": "module",
   "description": "OpenCode plugin: session recovery, auto-retry, multi-cycle automation, context monitoring",
   "exports": {