opencode-immune 1.0.0 → 1.0.2

package/dist/plugin.js

@@ -24,9 +24,20 @@ function createState(input) {
 }
 const ULTRAWORK_AGENT = "0-ultrawork";
 const MANAGED_SESSION_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const RATE_LIMIT_FALLBACK_MODEL = {
+    providerID: "externcash",
+    modelID: "gpt-5.4",
+};
 function isManagedUltraworkSession(state, sessionID) {
     return !!sessionID && state.managedUltraworkSessions.has(sessionID);
 }
+function getManagedSession(state, sessionID) {
+    return sessionID ? state.managedUltraworkSessions.get(sessionID) : undefined;
+}
+function isManagedRootUltraworkSession(state, sessionID) {
+    const record = getManagedSession(state, sessionID);
+    return !!record && record.kind === "root";
+}
 function pruneExpiredManagedSessions(state, now = Date.now()) {
     let removed = 0;
     for (const [sessionID, record] of state.managedUltraworkSessions.entries()) {
@@ -64,12 +75,23 @@ async function loadManagedSessionsCache(state) {
             return;
         }
         for (const [sessionID, record] of Object.entries(parsed.sessions)) {
-            if (!record || record.agent !== ULTRAWORK_AGENT)
+            if (!record)
                 continue;
             state.managedUltraworkSessions.set(sessionID, {
-                agent: ULTRAWORK_AGENT,
+                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);
@@ -89,9 +111,12 @@ async function loadManagedSessionsCache(state) {
 async function addManagedUltraworkSession(state, sessionID, timestamp = Date.now()) {
     const existing = state.managedUltraworkSessions.get(sessionID);
     const nextRecord = {
+        kind: existing?.kind ?? "root",
         agent: ULTRAWORK_AGENT,
+        rootSessionID: existing?.rootSessionID ?? sessionID,
         createdAt: existing?.createdAt ?? timestamp,
         updatedAt: timestamp,
+        fallbackModel: existing?.fallbackModel,
     };
     if (existing &&
         existing.agent === nextRecord.agent &&
@@ -102,6 +127,21 @@ async function addManagedUltraworkSession(state, sessionID, timestamp = Date.now
     state.managedUltraworkSessions.set(sessionID, nextRecord);
     await writeManagedSessionsCache(state);
 }
+async function addManagedChildSession(state, sessionID, parentSessionID, timestamp = Date.now()) {
+    const parent = state.managedUltraworkSessions.get(parentSessionID);
+    if (!parent)
+        return;
+    const existing = state.managedUltraworkSessions.get(sessionID);
+    state.managedUltraworkSessions.set(sessionID, {
+        kind: "child",
+        agent: existing?.agent ?? "unknown",
+        rootSessionID: parent.rootSessionID,
+        createdAt: existing?.createdAt ?? timestamp,
+        updatedAt: timestamp,
+        fallbackModel: existing?.fallbackModel ?? parent.fallbackModel,
+    });
+    await writeManagedSessionsCache(state);
+}
 function cancelRetry(state, sessionID, reason) {
     const timer = state.retryTimers.get(sessionID);
     if (!timer)
@@ -119,6 +159,17 @@ async function removeManagedUltraworkSession(state, sessionID, reason) {
     await writeManagedSessionsCache(state);
     console.log(`[opencode-immune] Removed managed ultrawork session ${sessionID}: ${reason}`);
 }
+async function updateManagedSessionAgent(state, sessionID, agent) {
+    const existing = state.managedUltraworkSessions.get(sessionID);
+    if (!existing || existing.agent === agent)
+        return;
+    state.managedUltraworkSessions.set(sessionID, {
+        ...existing,
+        agent,
+        updatedAt: Date.now(),
+    });
+    await writeManagedSessionsCache(state);
+}
 function markUltraworkSessionActive(state, sessionID) {
     const existing = state.managedUltraworkSessions.get(sessionID);
     if (!existing)
@@ -140,6 +191,27 @@ function isRetryableApiError(error) {
     return (maybeError.name === "APIError" &&
         maybeError.data?.isRetryable === true);
 }
+function isRateLimitApiError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const maybeError = error;
+    const message = `${maybeError.message ?? ""} ${maybeError.data?.message ?? ""}`.toLowerCase();
+    const type = `${maybeError.data?.type ?? ""}`.toLowerCase();
+    return (maybeError.name === "APIError" &&
+        maybeError.data?.isRetryable === true &&
+        (type.includes("rate_limit") || message.includes("too many requests") || message.includes("rate limit")));
+}
+async function setSessionFallbackModel(state, sessionID, model) {
+    const existing = state.managedUltraworkSessions.get(sessionID);
+    if (!existing)
+        return;
+    state.managedUltraworkSessions.set(sessionID, {
+        ...existing,
+        updatedAt: Date.now(),
+        fallbackModel: model,
+    });
+    await writeManagedSessionsCache(state);
+}
 // ═══════════════════════════════════════════════════════════════════════════════
 // UTILITY: ERROR BOUNDARY
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -276,12 +348,16 @@ function createTodoEnforcerChatMessage(state) {
     return async (input, _output) => {
         const sessionID = input.sessionID;
         const agent = input.agent;
+        const record = getManagedSession(state, sessionID);
         if (sessionID && agent === ULTRAWORK_AGENT) {
             await addManagedUltraworkSession(state, sessionID);
         }
-        else if (sessionID && agent && isManagedUltraworkSession(state, sessionID)) {
+        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);
+        }
         // On user message, check previous assistant turn's counters
         // then reset for next turn
         if (state.toolCallCount > 3 && !state.todoWriteUsed) {
@@ -309,7 +385,11 @@ function createSessionRecoveryEvent(state) {
             state.sessionActive = true;
             const sessionInfo = event.properties?.info;
             const sessionID = sessionInfo?.id ?? event.properties?.sessionID;
-            if (!isManagedUltraworkSession(state, sessionID)) {
+            const parentID = sessionInfo?.parentID;
+            if (sessionID && parentID && isManagedUltraworkSession(state, parentID)) {
+                await addManagedChildSession(state, sessionID, parentID);
+            }
+            if (!isManagedRootUltraworkSession(state, sessionID)) {
                 return;
             }
             console.log(`[opencode-immune] Managed ultrawork session created, checking for active task...`);
@@ -320,7 +400,7 @@ function createSessionRecoveryEvent(state) {
                 if (sessionID && recovery.phase !== "ARCHIVE: DONE") {
                     setTimeout(async () => {
                         try {
-                            if (!isManagedUltraworkSession(state, sessionID)) {
+                            if (!isManagedRootUltraworkSession(state, sessionID)) {
                                 return;
                             }
                             await state.input.client.session.promptAsync({
@@ -357,7 +437,7 @@ function createSessionRecoveryEvent(state) {
 function createSystemTransform(state) {
     return async (input, output) => {
         // Session Recovery injection
-        if (state.recoveryContext && isManagedUltraworkSession(state, input.sessionID)) {
+        if (state.recoveryContext && isManagedRootUltraworkSession(state, input.sessionID)) {
             const ctx = state.recoveryContext;
             const intentInfo = ctx.intent ? `, Intent: ${ctx.intent}` : "";
             const categoryInfo = ctx.category ? `, Category: ${ctx.category}` : "";
@@ -533,9 +613,12 @@ function createFallbackModels(state) {
         if (input.agent === ULTRAWORK_AGENT) {
             await addManagedUltraworkSession(state, input.sessionID);
         }
-        else if (isManagedUltraworkSession(state, input.sessionID)) {
+        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);
+        }
         // Log model and agent for observability
         const modelId = input.model && "id" in input.model
             ? input.model.id
@@ -586,6 +669,17 @@ function createEventHandler(state) {
             if (count < MAX_RETRIES) {
                 const delay = Math.min(BASE_DELAY_MS * Math.pow(2, count), MAX_DELAY_MS);
                 state.retryCount.set(sessionID, count + 1);
+                if (isRateLimitApiError(error)) {
+                    await setSessionFallbackModel(state, sessionID, RATE_LIMIT_FALLBACK_MODEL);
+                    console.log(`[opencode-immune] Rate limit detected for session ${sessionID}. ` +
+                        `Retry will use fallback model ${RATE_LIMIT_FALLBACK_MODEL.providerID}/${RATE_LIMIT_FALLBACK_MODEL.modelID}.`);
+                }
+                const managedSession = state.managedUltraworkSessions.get(sessionID);
+                const fallbackModel = managedSession?.fallbackModel;
+                const retryAgent = managedSession?.agent || ULTRAWORK_AGENT;
+                const retryText = retryAgent === ULTRAWORK_AGENT
+                    ? "[SYSTEM: Previous API call failed with a transient error. Re-read memory-bank/tasks.md, check the Phase Status block, and continue the pipeline. Use the exact neutral prompt from your Step 5 table for the next router call. Do NOT analyze or evaluate file contents.]"
+                    : `[SYSTEM: Previous API call failed with a transient error. Resume the current task in your current role as ${retryAgent}. Continue from the existing session state. Do not restart from scratch unless the current session state is missing.]`;
                 console.log(`[opencode-immune] Session error detected (attempt ${count + 1}/${MAX_RETRIES}). ` +
                     `Waiting ${delay / 1000}s before retry...`);
                 const timer = setTimeout(async () => {
@@ -596,17 +690,21 @@ function createEventHandler(state) {
                     try {
                         await state.input.client.session.promptAsync({
                             body: {
-                                agent: ULTRAWORK_AGENT,
+                                ...(fallbackModel ? { model: fallbackModel } : {}),
+                                agent: retryAgent,
                                 parts: [
                                     {
                                         type: "text",
-                                        text: "[SYSTEM: Previous API call failed with a transient error. Re-read memory-bank/tasks.md, check the Phase Status block, and continue the pipeline. Use the exact neutral prompt from your Step 5 table for the next router call. Do NOT analyze or evaluate file contents.]",
+                                        text: retryText,
                                     },
                                 ],
                             },
                             path: { id: sessionID },
                         });
-                        console.log(`[opencode-immune] Auto-retry message sent to session ${sessionID}`);
+                        console.log(`[opencode-immune] Auto-retry message sent to session ${sessionID}` +
+                            (fallbackModel
+                                ? ` using fallback model ${fallbackModel.providerID}/${fallbackModel.modelID}`
+                                : ""));
                     }
                     catch (err) {
                         state.retryCount.set(sessionID, Math.max((state.retryCount.get(sessionID) ?? 1) - 1, 0));
@@ -660,7 +758,7 @@ const NEXT_TASK_PATTERN = /Next task:\s*(.+)/;
 function createMultiCycleHandler(state) {
     return async (input, output) => {
         const sessionID = input.sessionID;
-        if (!isManagedUltraworkSession(state, sessionID))
+        if (!isManagedRootUltraworkSession(state, sessionID))
             return;
         // Extract text content from parts
         const parts = output.parts ?? [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-immune",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "OpenCode plugin: session recovery, auto-retry, multi-cycle automation, context monitoring",
   "exports": {
     "./server": "./dist/plugin.js"
@@ -14,7 +14,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@opencode-ai/plugin": "^1.4.1"
+    "@opencode-ai/plugin": "1.4.1"
   },
   "devDependencies": {
     "@types/node": "^25.5.2",