opencode-immune 1.0.1 → 1.0.3

package/dist/plugin.js

@@ -31,6 +31,13 @@ const RATE_LIMIT_FALLBACK_MODEL = {
 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()) {
@@ -68,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);
@@ -93,7 +111,9 @@ 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,
@@ -107,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)
@@ -124,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)
@@ -151,9 +197,7 @@ function isRateLimitApiError(error) {
     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")));
+    return ((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);
@@ -302,12 +346,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) {
@@ -335,7 +383,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...`);
@@ -346,7 +398,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({
@@ -383,7 +435,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}` : "";
@@ -559,9 +611,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
@@ -617,7 +672,12 @@ function createEventHandler(state) {
                     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 fallbackModel = state.managedUltraworkSessions.get(sessionID)?.fallbackModel;
+                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 () => {
@@ -629,11 +689,11 @@ function createEventHandler(state) {
                         await state.input.client.session.promptAsync({
                             body: {
                                 ...(fallbackModel ? { model: fallbackModel } : {}),
-                                agent: ULTRAWORK_AGENT,
+                                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,
                                     },
                                 ],
                             },
@@ -696,7 +756,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.1",
+  "version": "1.0.3",
   "description": "OpenCode plugin: session recovery, auto-retry, multi-cycle automation, context monitoring",
   "exports": {
     "./server": "./dist/plugin.js"