opencode-immune 1.0.18 → 1.0.20

package/dist/plugin.js

@@ -467,12 +467,12 @@ function createTodoEnforcerChatMessage(state) {
             await addManagedUltraworkSession(state, sessionID);
             await writeUltraworkMarker(state);
         }
-        else if (sessionID && agent && record?.kind === "root") {
-            await removeManagedUltraworkSession(state, sessionID, `session taken over by agent \"${agent}\"`);
-        }
         else if (sessionID && agent && record?.kind === "child") {
             await updateManagedSessionAgent(state, sessionID, agent);
         }
+        // NOTE: Do NOT remove managed root sessions when agent changes.
+        // 0-ultrawork delegates to subagents (1-van, 7-backlog, etc.) which
+        // may appear as agent in chat.message but the session is still managed.
         // On user message, check previous assistant turn's counters
         // then reset for next turn
         if (state.toolCallCount > 3 && !state.todoWriteUsed) {
@@ -791,12 +791,11 @@ function createFallbackModels(state) {
                 }
             }
         }
-        else if (getManagedSession(state, input.sessionID)?.kind === "root") {
-            await removeManagedUltraworkSession(state, input.sessionID, `session switched to agent \"${input.agent}\"`);
-        }
         else if (getManagedSession(state, input.sessionID)?.kind === "child") {
             await updateManagedSessionAgent(state, input.sessionID, input.agent);
         }
+        // NOTE: Do NOT remove managed root sessions when agent changes in chat.params.
+        // Subagent calls from 0-ultrawork (1-van, 7-backlog, etc.) use the same session.
         // Log model and agent for observability
         const modelId = input.model && "id" in input.model
             ? input.model.id
@@ -903,64 +902,37 @@ function createEventHandler(state) {
 }
 // ═══════════════════════════════════════════════════════════════════════════════
 // HOOK 9: MULTI-CYCLE AUTOMATION (PRE_COMMIT + CYCLE_COMPLETE)
+// Uses experimental.text.complete to detect signal markers in assistant output.
+// chat.message only fires for user messages (output.message is UserMessage),
+// so signal detection MUST use text.complete which fires for assistant text.
 // ═══════════════════════════════════════════════════════════════════════════════
 const MAX_CYCLES = 10;
 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.
+ * experimental.text.complete: scans completed assistant text for signal markers.
  *
  * PRE_COMMIT → executes /commit via client.session.command()
  * CYCLE_COMPLETE → creates a new session and sends bootstrap prompt
+ * ALL_CYCLES_COMPLETE → clears ultrawork marker
  */
-function createMultiCycleHandler(state) {
+function createTextCompleteHandler(state) {
     return async (input, output) => {
         const sessionID = input.sessionID;
-        // Extract text content from parts
-        const parts = output.parts ?? [];
-        let messageContent = "";
-        for (const p of parts) {
-            if ("type" in p && p.type === "text" && "text" in p) {
-                messageContent += " " + p.text;
-            }
-        }
-        messageContent = messageContent.trim();
-        if (!messageContent)
+        const text = output.text ?? "";
+        if (!text)
             return;
-        const messageRole = output.message?.role;
-        // ── ALL_CYCLES_COMPLETE: clear ultrawork marker (checked before managed session guard) ──
-        if (messageContent.includes(ALL_CYCLES_COMPLETE_MARKER)) {
+        // ── ALL_CYCLES_COMPLETE: clear ultrawork marker ──
+        if (text.includes(ALL_CYCLES_COMPLETE_MARKER)) {
             await clearUltraworkMarker(state);
-            console.log("[opencode-immune] Multi-Cycle: ALL_CYCLES_COMPLETE detected, ultrawork marker cleared.");
-        }
-        if (!isManagedRootUltraworkSession(state, sessionID))
-            return;
-        const managedSession = getManagedSession(state, sessionID);
-        if (sessionID &&
-            messageRole === "assistant" &&
-            RATE_LIMIT_MESSAGE_PATTERN.test(messageContent)) {
-            if (managedSession && !managedSession.fallbackModel) {
-                await setSessionFallbackModel(state, sessionID, RATE_LIMIT_FALLBACK_MODEL);
-                console.log(`[opencode-immune] Rate limit message detected in chat output for session ${sessionID}. ` +
-                    `Fallback model pinned to ${RATE_LIMIT_FALLBACK_MODEL.providerID}/${RATE_LIMIT_FALLBACK_MODEL.modelID}.`);
-            }
-            if (managedSession) {
-                scheduleManagedSessionRetry(state, sessionID, {
-                    delayMs: 1_000,
-                    reason: "rate-limit message fallback",
-                    countAgainstBudget: false,
-                    abortBeforePrompt: true,
-                });
-            }
+            console.log("[opencode-immune] Multi-Cycle: ALL_CYCLES_COMPLETE detected in text.complete, ultrawork marker cleared.");
         }
         // ── PRE_COMMIT: execute /commit ──
-        if (messageContent.includes(PRE_COMMIT_MARKER) && !state.commitPending) {
+        if (text.includes(PRE_COMMIT_MARKER) && !state.commitPending && sessionID) {
             state.commitPending = true;
-            console.log("[opencode-immune] Multi-Cycle: PRE_COMMIT detected, executing /commit...");
-            // Small delay to let the message finish rendering
+            console.log("[opencode-immune] Multi-Cycle: PRE_COMMIT detected in text.complete, executing /commit...");
             setTimeout(async () => {
                 try {
                     await state.input.client.session.command({
@@ -981,28 +953,25 @@ function createMultiCycleHandler(state) {
             }, 2_000);
         }
         // ── CYCLE_COMPLETE: create new session ──
-        if (messageContent.includes(CYCLE_COMPLETE_MARKER)) {
+        if (text.includes(CYCLE_COMPLETE_MARKER)) {
             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
-            const taskMatch = messageContent.match(NEXT_TASK_PATTERN);
+            const taskMatch = text.match(NEXT_TASK_PATTERN);
             const nextTask = taskMatch?.[1]?.trim() ?? "Continue processing task backlog";
-            console.log(`[opencode-immune] Multi-Cycle: CYCLE_COMPLETE detected (cycle ${state.cycleCount}/${MAX_CYCLES}). ` +
+            console.log(`[opencode-immune] Multi-Cycle: CYCLE_COMPLETE detected in text.complete (cycle ${state.cycleCount}/${MAX_CYCLES}). ` +
                 `Creating new session for: "${nextTask}"`);
             // Delay to let commit finish
             setTimeout(async () => {
                 try {
-                    // Create a new session
                     const createResult = await state.input.client.session.create({
                         body: {
                             title: `Ultrawork Cycle ${state.cycleCount + 1}`,
                         },
                     });
-                    // Extract new session ID from the response
                     const newSessionData = createResult?.data;
                     const newSessionID = newSessionData?.id;
                     if (!newSessionID) {
@@ -1011,7 +980,6 @@ function createMultiCycleHandler(state) {
                     }
                     console.log(`[opencode-immune] Multi-Cycle: New session created: ${newSessionID}`);
                     await addManagedUltraworkSession(state, newSessionID);
-                    // Send bootstrap prompt to the new session
                     await state.input.client.session.promptAsync({
                         body: {
                             agent: ULTRAWORK_AGENT,
@@ -1029,7 +997,49 @@ function createMultiCycleHandler(state) {
                 catch (err) {
                     console.error("[opencode-immune] Multi-Cycle: Failed to create new session or send prompt:", err);
                 }
-            }, 8_000); // 8s delay: let /commit finish first
+            }, 8_000);
+        }
+    };
+}
+/**
+ * chat.message part: handles rate-limit text detection in managed root sessions.
+ * NOTE: chat.message fires for user messages only (output.message = UserMessage).
+ * Signal detection (PRE_COMMIT/CYCLE_COMPLETE) moved to experimental.text.complete.
+ */
+function createMultiCycleHandler(state) {
+    return async (input, output) => {
+        const sessionID = input.sessionID;
+        // Extract text content from parts
+        const parts = output.parts ?? [];
+        let messageContent = "";
+        for (const p of parts) {
+            if ("type" in p && p.type === "text" && "text" in p) {
+                messageContent += " " + p.text;
+            }
+        }
+        messageContent = messageContent.trim();
+        if (!messageContent)
+            return;
+        if (!isManagedRootUltraworkSession(state, sessionID))
+            return;
+        const managedSession = getManagedSession(state, sessionID);
+        // Rate-limit message detection (only for managed root sessions)
+        const RATE_LIMIT_MESSAGE_PATTERN = /too many requests|rate_limit|rate limit/i;
+        if (sessionID &&
+            RATE_LIMIT_MESSAGE_PATTERN.test(messageContent)) {
+            if (managedSession && !managedSession.fallbackModel) {
+                await setSessionFallbackModel(state, sessionID, RATE_LIMIT_FALLBACK_MODEL);
+                console.log(`[opencode-immune] Rate limit message detected in chat output for session ${sessionID}. ` +
+                    `Fallback model pinned to ${RATE_LIMIT_FALLBACK_MODEL.providerID}/${RATE_LIMIT_FALLBACK_MODEL.modelID}.`);
+            }
+            if (managedSession) {
+                scheduleManagedSessionRetry(state, sessionID, {
+                    delayMs: 1_000,
+                    reason: "rate-limit message fallback",
+                    countAgainstBudget: false,
+                    abortBeforePrompt: true,
+                });
+            }
         }
     };
 }
@@ -1166,6 +1176,7 @@ async function server(input) {
         "tool.execute.after": withErrorBoundary("tool.execute.after", compositeToolAfter(toolAfterHandlers)),
         "experimental.chat.system.transform": withErrorBoundary("experimental.chat.system.transform", createSystemTransform(state)),
         "experimental.session.compacting": withErrorBoundary("experimental.session.compacting", createCompactionHandler(state)),
+        "experimental.text.complete": withErrorBoundary("experimental.text.complete", createTextCompleteHandler(state)),
     };
 }
 exports.default = {

package/package.json

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