opencode-immune 1.0.59 → 1.0.61

package/dist/plugin.js

@@ -96,6 +96,7 @@ function createState(input) {
         providerRetryWatchdogs: new Map(),
         childFallbackRequests: new Map(),
         sessionErrorRetryCount: new Map(),
+        ultraworkPermissionSessions: new Set(),
         fallbackAgentByAgent: new Map(),
         baseAgentByFallbackAgent: new Map(),
         ultraworkMarkerPath: join(input.directory, ".opencode", "state", "ultrawork-active.json"),
@@ -106,6 +107,7 @@ function createState(input) {
         approximateTokens: 0,
         sessionActive: false,
         autoResumeAttempted: false,
+        autoResumeInFlight: false,
         cycleCount: 0,
         commitPending: false,
         pluginUpdateMessage: null,
@@ -174,6 +176,25 @@ async function createManagedUltraworkSession(state, title) {
     await addManagedUltraworkSession(state, sessionID);
     return sessionID;
 }
+async function applyUltraworkSessionPermissions(state, sessionID) {
+    if (state.ultraworkPermissionSessions.has(sessionID))
+        return;
+    try {
+        const result = await state.client.session.update({
+            directory: state.input.directory,
+            sessionID,
+            permission: ULTRAWORK_SESSION_PERMISSION,
+        });
+        if (result.error || !result.response.ok) {
+            pluginLog.warn(`[opencode-immune] Failed to apply ultrawork permissions to session ${sessionID}:`, result.error ?? result.response.status);
+            return;
+        }
+        state.ultraworkPermissionSessions.add(sessionID);
+    }
+    catch (err) {
+        pluginLog.warn(`[opencode-immune] Failed to apply ultrawork permissions to session ${sessionID}:`, err);
+    }
+}
 async function promptManagedSession(state, sessionID, text, options = {}) {
     const result = await state.client.session.promptAsync({
         directory: state.input.directory,
@@ -336,6 +357,7 @@ async function addManagedUltraworkSession(state, sessionID, timestamp = Date.now
         return;
     }
     state.managedUltraworkSessions.set(sessionID, nextRecord);
+    await applyUltraworkSessionPermissions(state, sessionID);
 }
 async function addManagedChildSession(state, sessionID, parentSessionID, timestamp = Date.now()) {
     const parent = state.managedUltraworkSessions.get(parentSessionID);
@@ -379,6 +401,7 @@ async function removeManagedUltraworkSession(state, sessionID, reason) {
     cancelPendingSessionRetry(state, sessionID, reason);
     cancelProviderRetryWatchdog(state, sessionID, reason);
     state.sessionErrorRetryCount.delete(sessionID);
+    state.ultraworkPermissionSessions.delete(sessionID);
     const existed = state.managedUltraworkSessions.delete(sessionID);
     if (!existed)
         return;
@@ -1377,18 +1400,23 @@ function createSessionRecoveryEvent(state) {
                     // Register this root session as managed so retry/recovery works
                     await addManagedUltraworkSession(state, sessionID);
                     // Skip sending AUTO-RESUME if already sent from plugin init
-                    if (state.autoResumeAttempted) {
-                        pluginLog.info(`[opencode-immune] Auto-resume already sent from plugin init, skipping duplicate for session ${sessionID}.`);
+                    if (state.autoResumeAttempted || state.autoResumeInFlight) {
+                        pluginLog.info(`[opencode-immune] Auto-resume already sent or in flight, skipping duplicate for session ${sessionID}.`);
                         return;
                     }
+                    state.autoResumeInFlight = true;
                     setTimeout(async () => {
                         try {
                             await promptManagedSession(state, sessionID, `[AUTO-RESUME] Previous session was interrupted. Read memory-bank/tasks.md, check the Phase Status block, and continue the pipeline. Use ONLY the Phase Status block to determine the next phase. Do NOT analyze or evaluate the content of tasks.md. Call the appropriate router with the exact neutral prompt from your Step 5 table.`);
+                            state.autoResumeAttempted = true;
                             pluginLog.info(`[opencode-immune] Auto-resume prompt sent to managed ultrawork session ${sessionID}`);
                         }
                         catch (err) {
                             pluginLog.info(`[opencode-immune] Auto-resume failed (session may have been taken over):`, err);
                         }
+                        finally {
+                            state.autoResumeInFlight = false;
+                        }
                     }, 3_000);
                 }
             }
@@ -1614,8 +1642,7 @@ function createFallbackModels(state) {
             scheduleProviderRetryWatchdog(state, input.sessionID);
             // First contact with 0-ultrawork after plugin restart:
             // if marker is active and tasks.md has incomplete work, send AUTO-RESUME prompt.
-            if (!wasAlreadyManaged && !state.autoResumeAttempted) {
-                state.autoResumeAttempted = true;
+            if (!wasAlreadyManaged && !state.autoResumeAttempted && !state.autoResumeInFlight) {
                 const markerActive = await isUltraworkMarkerActive(state);
                 if (markerActive) {
                     const recovery = await parseTasksFile(state.input.directory);
@@ -1625,14 +1652,19 @@ function createFallbackModels(state) {
                             `task="${recovery.task}", level=${recovery.level}, phase=${recovery.phase}. ` +
                             `Sending AUTO-RESUME prompt in 3s...`);
                         const sid = input.sessionID;
+                        state.autoResumeInFlight = true;
                         setTimeout(async () => {
                             try {
                                 await promptManagedSession(state, sid, `[AUTO-RESUME] Previous session was interrupted. Read memory-bank/tasks.md, check the Phase Status block, and continue the pipeline. Use ONLY the Phase Status block to determine the next phase. Do NOT analyze or evaluate the content of tasks.md. Call the appropriate router with the exact neutral prompt from your Step 5 table.`);
+                                state.autoResumeAttempted = true;
                                 pluginLog.info(`[opencode-immune] Auto-resume prompt sent to session ${sid}`);
                             }
                             catch (err) {
                                 pluginLog.info(`[opencode-immune] Auto-resume prompt failed:`, err);
                             }
+                            finally {
+                                state.autoResumeInFlight = false;
+                            }
                         }, 3_000);
                     }
                 }
@@ -2066,8 +2098,17 @@ function createMultiCycleHandler(state) {
 function createPermissionAskHandler(state) {
     return async (input, output) => {
         const sessionID = input.sessionID;
-        if (!isManagedUltraworkSession(state, sessionID))
+        if (!sessionID)
             return;
+        if (!isManagedUltraworkSession(state, sessionID)) {
+            const markerActive = await isUltraworkMarkerActive(state);
+            const recovery = markerActive ? await parseTasksFile(state.input.directory) : null;
+            if (!recovery || recovery.phase === "ARCHIVE: DONE")
+                return;
+            state.recoveryContext = recovery;
+            await addManagedUltraworkSession(state, sessionID);
+            pluginLog.info(`[opencode-immune] Permission request recovered AUTO-RESUME session ${sessionID}; applying managed ultrawork auto-allow.`);
+        }
         output.status = "allow";
         await writeDiagnosticLog(state, "permission:auto-allow", {
             sessionID,
@@ -2097,12 +2138,12 @@ async function server(input) {
         if (recovery && recovery.phase !== "ARCHIVE: DONE") {
             // Active task exists with incomplete phases — resume it
             state.recoveryContext = recovery;
-            state.autoResumeAttempted = true;
             pluginLog.info(`[opencode-immune] Plugin init: ultrawork marker active, recovery context loaded: ` +
                 `task="${recovery.task}", level=${recovery.level}, phase=${recovery.phase}. ` +
                 `Will create new session and send AUTO-RESUME.`);
             // Create a new session and send AUTO-RESUME prompt (same pattern as CYCLE_COMPLETE).
             // Delay to let opencode fully initialize.
+            state.autoResumeInFlight = true;
             setTimeout(async () => {
                 try {
                     const newSessionID = await createManagedUltraworkSession(state, `AUTO-RESUME: ${recovery.task}`);
@@ -2112,11 +2153,15 @@ async function server(input) {
                     }
                     pluginLog.info(`[opencode-immune] Auto-resume: New session created: ${newSessionID}`);
                     await promptManagedSession(state, newSessionID, `[AUTO-RESUME] Previous session was interrupted. Read memory-bank/tasks.md, check the Phase Status block, and continue the pipeline. Use ONLY the Phase Status block to determine the next phase. Do NOT analyze or evaluate the content of tasks.md. Call the appropriate router with the exact neutral prompt from your Step 5 table.`);
+                    state.autoResumeAttempted = true;
                     pluginLog.info(`[opencode-immune] Auto-resume prompt sent to new session ${newSessionID}`);
                 }
                 catch (err) {
                     pluginLog.error("[opencode-immune] Auto-resume: Failed to create session or send prompt:", err);
                 }
+                finally {
+                    state.autoResumeInFlight = false;
+                }
             }, 5_000);
         }
         else {
@@ -2126,9 +2171,9 @@ async function server(input) {
                 const backlogContent = await readFile(backlogPath, "utf-8");
                 const hasPendingTasks = /- \[ \]/.test(backlogContent);
                 if (hasPendingTasks) {
-                    state.autoResumeAttempted = true;
                     pluginLog.info(`[opencode-immune] Plugin init: no active task but backlog has pending items. ` +
                         `Will create new session to start next cycle.`);
+                    state.autoResumeInFlight = true;
                     setTimeout(async () => {
                         try {
                             const newSessionID = await createManagedUltraworkSession(state, `AUTO-CYCLE: next backlog task`);
@@ -2138,11 +2183,15 @@ async function server(input) {
                             }
                             pluginLog.info(`[opencode-immune] Auto-cycle: New session created: ${newSessionID}`);
                             await promptManagedSession(state, newSessionID, `[AUTO-CYCLE] Continue processing task backlog. Read memory-bank/tasks.md and memory-bank/backlog.md, pick the next pending task, and run the full pipeline.`);
+                            state.autoResumeAttempted = true;
                             pluginLog.info(`[opencode-immune] Auto-cycle prompt sent to new session ${newSessionID}`);
                         }
                         catch (err) {
                             pluginLog.error("[opencode-immune] Auto-cycle: Failed to create session or send prompt:", err);
                         }
+                        finally {
+                            state.autoResumeInFlight = false;
+                        }
                     }, 5_000);
                 }
                 else {

package/package.json

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