opencode-immune 1.0.7 → 1.0.9

package/dist/plugin.js

@@ -12,7 +12,7 @@ function createState(input) {
         managedUltraworkSessions: new Map(),
         sessionRetryTimers: new Map(),
         sessionErrorRetryCount: new Map(),
-        managedSessionsCachePath: (0, path_1.join)(input.directory, ".opencode", "state", "opencode-immune-managed-sessions.json"),
+        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"),
         lastEditAttempt: null,
         toolCallCount: 0,
@@ -52,21 +52,6 @@ function pruneExpiredManagedSessions(state, now = Date.now()) {
     }
     return removed;
 }
-async function writeManagedSessionsCache(state) {
-    const removed = pruneExpiredManagedSessions(state);
-    const cacheDir = (0, path_1.join)(state.input.directory, ".opencode", "state");
-    const tempPath = `${state.managedSessionsCachePath}.tmp`;
-    const payload = {
-        version: 1,
-        sessions: Object.fromEntries(state.managedUltraworkSessions.entries()),
-    };
-    await (0, promises_1.mkdir)(cacheDir, { recursive: true });
-    await (0, promises_1.writeFile)(tempPath, JSON.stringify(payload, null, 2), "utf-8");
-    await (0, promises_1.rename)(tempPath, state.managedSessionsCachePath);
-    if (removed > 0) {
-        console.log(`[opencode-immune] Pruned ${removed} expired managed ultrawork session(s) while writing cache.`);
-    }
-}
 async function writeDiagnosticLog(state, event, data = {}) {
     try {
         const cacheDir = (0, path_1.join)(state.input.directory, ".opencode", "state");
@@ -78,46 +63,37 @@ async function writeDiagnosticLog(state, event, data = {}) {
         // diagnostics must never affect runtime behavior
     }
 }
-async function loadManagedSessionsCache(state) {
+// ── Ultrawork Marker File ──
+async function writeUltraworkMarker(state) {
+    try {
+        const dir = (0, path_1.join)(state.input.directory, ".opencode", "state");
+        await (0, promises_1.mkdir)(dir, { recursive: true });
+        const payload = JSON.stringify({
+            active: true,
+            updatedAt: new Date().toISOString(),
+        });
+        await (0, promises_1.writeFile)(state.ultraworkMarkerPath, payload, "utf-8");
+    }
+    catch {
+        // marker write must never affect runtime
+    }
+}
+async function clearUltraworkMarker(state) {
     try {
-        const raw = await (0, promises_1.readFile)(state.managedSessionsCachePath, "utf-8");
+        await (0, promises_1.unlink)(state.ultraworkMarkerPath);
+    }
+    catch {
+        // file may not exist — that's fine
+    }
+}
+async function isUltraworkMarkerActive(state) {
+    try {
+        const raw = await (0, promises_1.readFile)(state.ultraworkMarkerPath, "utf-8");
         const parsed = JSON.parse(raw);
-        if (parsed.version !== 1 || !parsed.sessions) {
-            console.warn(`[opencode-immune] Managed sessions cache at ${state.managedSessionsCachePath} has unsupported format. Ignoring.`);
-            return;
-        }
-        for (const [sessionID, record] of Object.entries(parsed.sessions)) {
-            if (!record)
-                continue;
-            state.managedUltraworkSessions.set(sessionID, {
-                kind: record.kind === "child" ? "child" : "root",
-                agent: typeof record.agent === "string" && record.agent.length > 0
-                    ? record.agent
-                    : ULTRAWORK_AGENT,
-                rootSessionID: typeof record.rootSessionID === "string" && record.rootSessionID.length > 0
-                    ? record.rootSessionID
-                    : sessionID,
-                createdAt: typeof record.createdAt === "number" ? record.createdAt : Date.now(),
-                updatedAt: typeof record.updatedAt === "number" ? record.updatedAt : Date.now(),
-                fallbackModel: record.fallbackModel &&
-                    typeof record.fallbackModel.providerID === "string" &&
-                    typeof record.fallbackModel.modelID === "string"
-                    ? record.fallbackModel
-                    : undefined,
-            });
-        }
-        const removed = pruneExpiredManagedSessions(state);
-        console.log(`[opencode-immune] Loaded ${state.managedUltraworkSessions.size} managed ultrawork session(s) from cache.`);
-        if (removed > 0) {
-            console.log(`[opencode-immune] Pruned ${removed} expired managed ultrawork session(s) on startup.`);
-            await writeManagedSessionsCache(state);
-        }
+        return parsed?.active === true;
     }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        if (message.includes("ENOENT"))
-            return;
-        console.warn(`[opencode-immune] Failed to read managed sessions cache. Starting fresh.`);
+    catch {
+        return false;
     }
 }
 async function addManagedUltraworkSession(state, sessionID, timestamp = Date.now()) {
@@ -137,7 +113,6 @@ async function addManagedUltraworkSession(state, sessionID, timestamp = Date.now
         return;
     }
     state.managedUltraworkSessions.set(sessionID, nextRecord);
-    await writeManagedSessionsCache(state);
 }
 async function addManagedChildSession(state, sessionID, parentSessionID, timestamp = Date.now()) {
     const parent = state.managedUltraworkSessions.get(parentSessionID);
@@ -152,7 +127,6 @@ async function addManagedChildSession(state, sessionID, parentSessionID, timesta
         updatedAt: timestamp,
         fallbackModel: existing?.fallbackModel ?? parent.fallbackModel,
     });
-    await writeManagedSessionsCache(state);
 }
 function cancelPendingSessionRetry(state, sessionID, reason) {
     const timer = state.sessionRetryTimers.get(sessionID);
@@ -168,7 +142,6 @@ async function removeManagedUltraworkSession(state, sessionID, reason) {
     const existed = state.managedUltraworkSessions.delete(sessionID);
     if (!existed)
         return;
-    await writeManagedSessionsCache(state);
     console.log(`[opencode-immune] Removed managed ultrawork session ${sessionID}: ${reason}`);
 }
 async function updateManagedSessionAgent(state, sessionID, agent) {
@@ -180,7 +153,6 @@ async function updateManagedSessionAgent(state, sessionID, agent) {
         agent,
         updatedAt: Date.now(),
     });
-    await writeManagedSessionsCache(state);
 }
 function markUltraworkSessionActive(state, sessionID) {
     const existing = state.managedUltraworkSessions.get(sessionID);
@@ -220,7 +192,6 @@ async function setSessionFallbackModel(state, sessionID, model) {
         updatedAt: Date.now(),
         fallbackModel: model,
     });
-    await writeManagedSessionsCache(state);
 }
 function getManagedSessionRetryContext(state, sessionID) {
     const managedSession = state.managedUltraworkSessions.get(sessionID);
@@ -461,6 +432,7 @@ function createTodoEnforcerChatMessage(state) {
         const record = getManagedSession(state, sessionID);
         if (sessionID && agent === ULTRAWORK_AGENT) {
             await addManagedUltraworkSession(state, sessionID);
+            await writeUltraworkMarker(state);
         }
         else if (sessionID && agent && record?.kind === "root") {
             await removeManagedUltraworkSession(state, sessionID, `session taken over by agent \"${agent}\"`);
@@ -496,23 +468,36 @@ function createSessionRecoveryEvent(state) {
             const sessionInfo = event.properties?.info;
             const sessionID = sessionInfo?.id ?? event.properties?.sessionID;
             const parentID = sessionInfo?.parentID;
+            // Register child sessions under their parent
             if (sessionID && parentID && isManagedUltraworkSession(state, parentID)) {
                 await addManagedChildSession(state, sessionID, parentID);
+                return;
             }
-            if (!isManagedRootUltraworkSession(state, sessionID)) {
+            // Skip child sessions that don't belong to a managed parent
+            if (parentID) {
+                return;
+            }
+            // For root sessions (no parentID): check ultrawork marker + tasks.md.
+            // If marker is active and an incomplete task exists, auto-resume.
+            // This covers the restart case where the session ID is new but work is pending.
+            if (!sessionID) {
                 return;
             }
-            console.log(`[opencode-immune] Managed ultrawork session created, checking for active task...`);
+            const markerActive = await isUltraworkMarkerActive(state);
+            if (!markerActive) {
+                console.log(`[opencode-immune] Root session created (${sessionID}), no ultrawork marker — skipping auto-resume.`);
+                return;
+            }
+            console.log(`[opencode-immune] Root session created (${sessionID}), ultrawork marker active — checking tasks.md...`);
             const recovery = await parseTasksFile(state.input.directory);
             if (recovery) {
                 state.recoveryContext = recovery;
                 console.log(`[opencode-immune] Active task found: "${recovery.task}" (Level ${recovery.level}, Phase: ${recovery.phase})`);
-                if (sessionID && recovery.phase !== "ARCHIVE: DONE") {
+                if (recovery.phase !== "ARCHIVE: DONE") {
+                    // Register this root session as managed so retry/recovery works
+                    await addManagedUltraworkSession(state, sessionID);
                     setTimeout(async () => {
                         try {
-                            if (!isManagedRootUltraworkSession(state, sessionID)) {
-                                return;
-                            }
                             await state.input.client.session.promptAsync({
                                 body: {
                                     agent: ULTRAWORK_AGENT,
@@ -722,6 +707,7 @@ function createFallbackModels(state) {
     return async (input, _output) => {
         if (input.agent === ULTRAWORK_AGENT) {
             await addManagedUltraworkSession(state, input.sessionID);
+            await writeUltraworkMarker(state);
         }
         else if (getManagedSession(state, input.sessionID)?.kind === "root") {
             await removeManagedUltraworkSession(state, input.sessionID, `session switched to agent \"${input.agent}\"`);
@@ -803,7 +789,7 @@ function createEventHandler(state) {
             cancelPendingSessionRetry(state, sessionID, "session updated");
             state.sessionErrorRetryCount.delete(sessionID);
             if (markUltraworkSessionActive(state, sessionID)) {
-                await writeManagedSessionsCache(state);
+                // session activity tracked in-memory only
             }
         }
         if (eventType === "session.deleted" && sessionID) {
@@ -831,6 +817,7 @@ const PRE_COMMIT_MARKER = "0-ULTRAWORK: PRE_COMMIT";
 const CYCLE_COMPLETE_MARKER = "0-ULTRAWORK: CYCLE_COMPLETE";
 const NEXT_TASK_PATTERN = /Next task:\s*(.+)/;
 const RATE_LIMIT_MESSAGE_PATTERN = /too many requests|rate_limit|rate limit/i;
+const ALL_CYCLES_COMPLETE_MARKER = "0-ULTRAWORK: ALL_CYCLES_COMPLETE";
 /**
  * chat.message part: scans assistant messages for PRE_COMMIT and CYCLE_COMPLETE markers.
  *
@@ -872,6 +859,11 @@ function createMultiCycleHandler(state) {
                 });
             }
         }
+        // ── ALL_CYCLES_COMPLETE: clear ultrawork marker ──
+        if (messageContent.includes(ALL_CYCLES_COMPLETE_MARKER)) {
+            await clearUltraworkMarker(state);
+            console.log("[opencode-immune] Multi-Cycle: ALL_CYCLES_COMPLETE detected, ultrawork marker cleared.");
+        }
         // ── PRE_COMMIT: execute /commit ──
         if (messageContent.includes(PRE_COMMIT_MARKER) && !state.commitPending) {
             state.commitPending = true;
@@ -901,6 +893,7 @@ function createMultiCycleHandler(state) {
             state.cycleCount++;
             if (state.cycleCount >= MAX_CYCLES) {
                 console.log(`[opencode-immune] Multi-Cycle: MAX_CYCLES (${MAX_CYCLES}) reached. Not creating new session.`);
+                await clearUltraworkMarker(state);
                 return;
             }
             // Extract next task description
@@ -953,7 +946,6 @@ function createMultiCycleHandler(state) {
 // ═══════════════════════════════════════════════════════════════════════════════
 async function server(input) {
     const state = createState(input);
-    await loadManagedSessionsCache(state);
     console.log(`[opencode-immune] Plugin initialized. Directory: ${input.directory}`);
     // Compose tool.execute.after handlers:
     // Todo Enforcer (counter) + Ralph Loop (edit error) + Comment Checker

package/package.json

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