opencode-immune 1.0.8 → 1.0.10

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}\"`);
@@ -505,13 +477,18 @@ function createSessionRecoveryEvent(state) {
             if (parentID) {
                 return;
             }
-            // For root sessions (no parentID): check tasks.md for active work.
-            // If an active task exists, register this session as managed and auto-resume.
+            // 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] Root session created (${sessionID}), 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;
@@ -722,14 +699,29 @@ function createKeywordDetectorChatMessage(_state) {
 // ═══════════════════════════════════════════════════════════════════════════════
 /**
  * chat.params: observational logging of model and agent info.
- * NOTE: chat.params output does NOT expose the `model` field.
- * Primary model routing is handled by BUILD router + alias agents.
- * This hook only provides observability.
+ * Also handles session registration and auto-resume for existing sessions
+ * after server restart (when session.created doesn't fire).
  */
 function createFallbackModels(state) {
     return async (input, _output) => {
         if (input.agent === ULTRAWORK_AGENT) {
+            const wasAlreadyManaged = isManagedUltraworkSession(state, input.sessionID);
             await addManagedUltraworkSession(state, input.sessionID);
+            await writeUltraworkMarker(state);
+            // First contact with 0-ultrawork after plugin restart:
+            // if marker is active and tasks.md has incomplete work, populate recoveryContext
+            // so that system.transform injects recovery info into the conversation.
+            if (!wasAlreadyManaged && !state.recoveryContext) {
+                const markerActive = await isUltraworkMarkerActive(state);
+                if (markerActive) {
+                    const recovery = await parseTasksFile(state.input.directory);
+                    if (recovery && recovery.phase !== "ARCHIVE: DONE") {
+                        state.recoveryContext = recovery;
+                        console.log(`[opencode-immune] Auto-recovery on existing session: ` +
+                            `task="${recovery.task}", level=${recovery.level}, phase=${recovery.phase}`);
+                    }
+                }
+            }
         }
         else if (getManagedSession(state, input.sessionID)?.kind === "root") {
             await removeManagedUltraworkSession(state, input.sessionID, `session switched to agent \"${input.agent}\"`);
@@ -811,7 +803,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) {
@@ -839,6 +831,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.
  *
@@ -880,6 +873,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;
@@ -909,6 +907,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
@@ -961,7 +960,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.8",
+  "version": "1.0.10",
   "description": "OpenCode plugin: session recovery, auto-retry, multi-cycle automation, context monitoring",
   "exports": {
     "./server": "./dist/plugin.js"