opencode-immune 1.0.72 → 1.0.75

package/dist/plugin/server.js

@@ -3777,7 +3777,7 @@ import { fileURLToPath } from "url";
 import { createHash } from "crypto";
 import { tmpdir } from "os";
 import { execFile } from "child_process";
-var PLUGIN_VERSION = "1.0.72";
+var PLUGIN_VERSION = "1.0.75";
 var PLUGIN_PACKAGE_NAME = "opencode-immune";
 var PLUGIN_DIRNAME = dirname(fileURLToPath(import.meta.url));
 function getServerAuthHeaders() {
@@ -3855,6 +3855,7 @@ function createState(input) {
     ultraworkPermissionSessions: /* @__PURE__ */ new Set(),
     fallbackAgentByAgent: /* @__PURE__ */ new Map(),
     baseAgentByFallbackAgent: /* @__PURE__ */ new Map(),
+    fallbackModelCandidates: [],
     ultraworkMarkerPath: join(
       input.directory,
       ".opencode",
@@ -3911,24 +3912,15 @@ var MANAGED_SESSION_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
 var PROVIDER_RETRY_WATCHDOG_MS = 3e4;
 var RETRY_PROMPT_DELIVERY_ATTEMPTS = 3;
 var CHILD_FALLBACK_REQUEST_TTL_MS = 10 * 60 * 1e3;
-var RATE_LIMIT_FALLBACK_MODEL = {
-  providerID: "codexsale",
-  modelID: "gpt-5.4-mini"
-};
-var CHILD_SESSION_FALLBACK_MODEL = {
-  providerID: "claudehub",
-  modelID: "claude-opus-4-7"
-};
-var HIGH_CAPABILITY_FALLBACK_MODELS = [
-  { providerID: "codexsale", modelID: "gpt-5.5" },
-  { providerID: "codexsale", modelID: "gpt-5.4" }
-];
 var AUTO_CYCLE_LOCK_TTL_MS = 30 * 60 * 1e3;
-var FALLBACK_MODEL_CANDIDATES = [
-  CHILD_SESSION_FALLBACK_MODEL,
-  ...HIGH_CAPABILITY_FALLBACK_MODELS,
-  RATE_LIMIT_FALLBACK_MODEL
-];
+var MODEL_NAME_CAPABILITY_SCORE = {
+  "claude-opus-4-7": 100,
+  "gpt-5.5": 100,
+  "gpt-5.4": 90,
+  "claude-sonnet-4-6": 90,
+  "gpt-5.4-mini": 50,
+  "claude-haiku-4-5": 50
+};
 var FALLBACK_AGENT_SUFFIX = "-provider-fallback";
 function isManagedUltraworkSession(state, sessionID) {
   return !!sessionID && state.managedUltraworkSessions.has(sessionID);
@@ -3956,6 +3948,42 @@ async function createManagedUltraworkSession(state, title) {
   await addManagedUltraworkSession(state, sessionID);
   return sessionID;
 }
+async function startAutoCycleInNewSession(state, options) {
+  const nextTask = options.nextTask?.trim() || "Continue processing task backlog";
+  const title = `AUTO-CYCLE: ${nextTask}`;
+  state.autoResumeInFlight = true;
+  try {
+    const newSessionID = await createManagedUltraworkSession(state, title);
+    if (!newSessionID) {
+      throw new Error("session.create returned no session ID");
+    }
+    await refreshAutoCycleLock(state, newSessionID);
+    await promptManagedSession(
+      state,
+      newSessionID,
+      `[AUTO-CYCLE] Continue processing task backlog. Read memory-bank/tasks.md and memory-bank/backlog.md, pick the next pending task, and run the full pipeline.`
+    );
+    state.autoResumeAttempted = true;
+    if (options.retireSourceSession && isManagedUltraworkSession(state, options.sourceSessionID)) {
+      await removeManagedUltraworkSession(
+        state,
+        options.sourceSessionID,
+        "auto-cycle moved to a new session"
+      );
+    }
+    pluginLog.info(
+      `[opencode-immune] ${options.logContext}: Bootstrap prompt sent to ${newSessionID}`
+    );
+    return newSessionID;
+  } catch (err) {
+    if (options.clearLockOnFailureReason) {
+      await clearAutoCycleLock(state, options.clearLockOnFailureReason);
+    }
+    throw err;
+  } finally {
+    state.autoResumeInFlight = false;
+  }
+}
 async function applyUltraworkSessionPermissions(state, sessionID) {
   if (state.ultraworkPermissionSessions.has(sessionID)) return;
   try {
@@ -4212,15 +4240,57 @@ function isSameModel(a, b) {
   if (!a || !b) return false;
   return a.providerID === b.providerID && a.modelID === b.modelID;
 }
-function selectFallbackModel(currentModel) {
+function getModelCapabilityScore(model) {
+  if (!model) return 90;
+  const modelID = model.modelID.toLowerCase();
+  const explicitScore = MODEL_NAME_CAPABILITY_SCORE[modelID];
+  if (explicitScore !== void 0) return explicitScore;
+  if (/\b(mini|nano|small|lite|haiku|flash)\b/i.test(modelID)) return 50;
+  if (/\b(opus|gpt-5\.5|gpt-5\.4|o3|o4|gpt-4\.1|gpt-4o)\b/i.test(modelID)) return 90;
+  return 70;
+}
+function getMinimumFallbackCapabilityScore(currentModel) {
+  const currentScore = getModelCapabilityScore(currentModel);
+  if (currentScore >= 90) return 90;
+  if (currentScore >= 70) return 70;
+  return 0;
+}
+function sortFallbackModelsByCapability(candidates, currentModel) {
+  const currentScore = getModelCapabilityScore(currentModel);
+  const minimumScore = getMinimumFallbackCapabilityScore(currentModel);
+  return [...candidates].sort((a, b) => {
+    const aScore = getModelCapabilityScore(a);
+    const bScore = getModelCapabilityScore(b);
+    const aAllowed = aScore >= minimumScore ? 0 : 1;
+    const bAllowed = bScore >= minimumScore ? 0 : 1;
+    if (aAllowed !== bAllowed) return aAllowed - bAllowed;
+    const aDirectionPenalty = aScore >= currentScore ? 0 : 1;
+    const bDirectionPenalty = bScore >= currentScore ? 0 : 1;
+    if (aDirectionPenalty !== bDirectionPenalty) {
+      return aDirectionPenalty - bDirectionPenalty;
+    }
+    const aSameModelName = currentModel && a.modelID === currentModel.modelID ? 0 : 1;
+    const bSameModelName = currentModel && b.modelID === currentModel.modelID ? 0 : 1;
+    if (aSameModelName !== bSameModelName) return aSameModelName - bSameModelName;
+    const aDistance = Math.abs(aScore - currentScore);
+    const bDistance = Math.abs(bScore - currentScore);
+    if (aDistance !== bDistance) return aDistance - bDistance;
+    return bScore - aScore;
+  });
+}
+function selectFallbackModel(state, currentModel) {
   const currentProviderID = getModelProviderID(currentModel);
-  const otherProviderModel = FALLBACK_MODEL_CANDIDATES.find(
-    (candidate) => !isSameModel(candidate, currentModel) && getModelProviderID(candidate) !== currentProviderID
+  const fallbackCandidates = state.fallbackModelCandidates.filter(
+    (candidate) => !isSameModel(candidate, currentModel)
   );
+  const otherProviderModel = sortFallbackModelsByCapability(
+    fallbackCandidates.filter(
+      (candidate) => getModelProviderID(candidate) !== currentProviderID
+    ),
+    currentModel
+  )[0];
   if (otherProviderModel) return otherProviderModel;
-  return FALLBACK_MODEL_CANDIDATES.find(
-    (candidate) => !isSameModel(candidate, currentModel)
-  ) ?? RATE_LIMIT_FALLBACK_MODEL;
+  return sortFallbackModelsByCapability(fallbackCandidates, currentModel)[0];
 }
 function getFailedModelFromError(error) {
   if (!error || typeof error !== "object") return void 0;
@@ -4233,13 +4303,6 @@ function getFailedModelFromError(error) {
       modelID: providerModelMatch[2].toLowerCase()
     };
   }
-  const unsupportedModelMatch = message.match(/["']([^"']+)["']\s+model\s+is\s+not\s+supported/i);
-  if (unsupportedModelMatch?.[1] && /\bcodex\b/i.test(message)) {
-    return {
-      providerID: "codexsale",
-      modelID: unsupportedModelMatch[1].toLowerCase()
-    };
-  }
   return void 0;
 }
 async function updateManagedSessionModel(state, sessionID, model) {
@@ -4256,7 +4319,7 @@ function getSessionFallbackModel(state, sessionID, preferredModel) {
   if (preferredModel && !isSameModel(preferredModel, currentModel)) {
     return preferredModel;
   }
-  return selectFallbackModel(currentModel);
+  return selectFallbackModel(state, currentModel);
 }
 function getFallbackAgentForAgent(state, agent) {
   return state.fallbackAgentByAgent.get(agent) ?? agent;
@@ -4393,8 +4456,10 @@ async function recoverUntrackedRootSessionForActiveTask(state, sessionID, reason
 }
 function recordChildFallbackRequest(state, managedSession, childSessionID, error) {
   const fallbackModel = selectFallbackModel(
+    state,
     getFailedModelFromError(error) ?? managedSession.currentModel
   );
+  if (!fallbackModel) return;
   const routerSessionID = getRouterSessionIDForChild(managedSession);
   const request = {
     childSessionID,
@@ -4425,6 +4490,7 @@ function scheduleProviderRetryWatchdog(state, sessionID, model) {
     if (!isManagedRootUltraworkSession(state, sessionID)) return;
     if (state.sessionRetryTimers.has(sessionID)) return;
     const fallbackModel = getSessionFallbackModel(state, sessionID, model);
+    if (!fallbackModel) return;
     await setSessionFallbackModel(state, sessionID, fallbackModel);
     await writeDiagnosticLog(state, "provider-retry-watchdog:fired", {
       sessionID,
@@ -4656,6 +4722,36 @@ function parseModelRef(model) {
   if (!providerID || !modelID) return void 0;
   return { providerID, modelID };
 }
+function addFallbackModelCandidate(candidates, model) {
+  const parsed = parseModelRef(model);
+  if (!parsed) return;
+  candidates.set(modelRefToString(parsed).toLowerCase(), parsed);
+}
+function collectFallbackModelCandidates(config) {
+  const candidates = /* @__PURE__ */ new Map();
+  addFallbackModelCandidate(candidates, config.model);
+  addFallbackModelCandidate(candidates, config.small_model);
+  for (const agentConfig of Object.values(config.agent ?? {})) {
+    if (!isRecord(agentConfig)) continue;
+    const model = agentConfig.model;
+    if (typeof model === "string") addFallbackModelCandidate(candidates, model);
+  }
+  const enabledProviders = new Set(config.enabled_providers ?? []);
+  const disabledProviders = new Set(config.disabled_providers ?? []);
+  const isProviderEnabled = (providerID) => {
+    if (enabledProviders.size > 0 && !enabledProviders.has(providerID)) return false;
+    return !disabledProviders.has(providerID);
+  };
+  for (const [providerID, providerConfig] of Object.entries(config.provider ?? {})) {
+    if (!isProviderEnabled(providerID) || !isRecord(providerConfig)) continue;
+    const models = providerConfig.models;
+    if (!isRecord(models)) continue;
+    for (const modelID of Object.keys(models)) {
+      addFallbackModelCandidate(candidates, `${providerID}/${modelID}`);
+    }
+  }
+  return sortFallbackModelsByCapability([...candidates.values()]);
+}
 function canCreateFallbackForAgent(agentID, agentConfig) {
   if (agentID.endsWith(FALLBACK_AGENT_SUFFIX)) return false;
   if (!isRecord(agentConfig)) return false;
@@ -4686,11 +4782,12 @@ function allowFallbackAgentInTaskPermissions(config, baseAgentID, fallbackAgentI
 function createConfigHandler(state) {
   return async (config) => {
     if (!config.agent) return;
+    state.fallbackModelCandidates = collectFallbackModelCandidates(config);
     for (const [agentID, agentConfig] of Object.entries(config.agent)) {
       if (!canCreateFallbackForAgent(agentID, agentConfig)) continue;
       const baseModel = parseModelRef(agentConfig.model);
-      const fallbackModel = selectFallbackModel(baseModel);
-      if (!baseModel || isSameModel(baseModel, fallbackModel)) continue;
+      const fallbackModel = selectFallbackModel(state, baseModel);
+      if (!baseModel || !fallbackModel || isSameModel(baseModel, fallbackModel)) continue;
       const fallbackAgentID = `${agentID}${FALLBACK_AGENT_SUFFIX}`;
       if (config.agent[fallbackAgentID]) continue;
       config.agent[fallbackAgentID] = {
@@ -5204,28 +5301,25 @@ function createSessionRecoveryEvent(state) {
           sessionID
         );
         if (!lockAcquired) return;
-        await addManagedUltraworkSession(state, sessionID);
         await refreshAutoCycleLock(state, sessionID);
-        state.autoResumeInFlight = true;
         setTimeout(async () => {
           try {
-            await promptManagedSession(
+            const newSessionID = await startAutoCycleInNewSession(
               state,
-              sessionID,
-              `[AUTO-CYCLE] Continue processing task backlog. Read memory-bank/tasks.md and memory-bank/backlog.md, pick the next pending task, and run the full pipeline.`
+              {
+                sourceSessionID: sessionID,
+                logContext: "Auto-cycle",
+                clearLockOnFailureReason: "root session auto-cycle failed"
+              }
             );
-            state.autoResumeAttempted = true;
             pluginLog.info(
-              `[opencode-immune] Auto-cycle prompt sent to root ultrawork session ${sessionID}`
+              `[opencode-immune] Auto-cycle prompt sent to new session ${newSessionID}`
             );
           } catch (err) {
-            await clearAutoCycleLock(state, "root session auto-cycle failed");
             pluginLog.error(
               `[opencode-immune] Auto-cycle prompt failed for root session ${sessionID}:`,
               err
             );
-          } finally {
-            state.autoResumeInFlight = false;
           }
         }, 3e3);
       }
@@ -5503,9 +5597,12 @@ function createEventHandler(state) {
           state.sessionErrorRetryCount.set(fallbackSessionID, count + 1);
           if (shouldUseFallbackForManagedError(error, managedSession, count)) {
             const fallbackModel = selectFallbackModel(
+              state,
               getFailedModelFromError(error) ?? managedSession.currentModel
             );
-            await setSessionFallbackModel(state, fallbackSessionID, fallbackModel);
+            if (fallbackModel) {
+              await setSessionFallbackModel(state, fallbackSessionID, fallbackModel);
+            }
           }
           pluginLog.warn(
             `[opencode-immune] session.error without sessionID matched retryable error. Retrying sole managed root session ${fallbackSessionID}.`
@@ -5561,8 +5658,10 @@ function createEventHandler(state) {
           return;
         } else if (isRoot && shouldUseFallbackForManagedError(error, managedSession, count)) {
           const selectedFallbackModel = selectFallbackModel(
+            state,
             getFailedModelFromError(error) ?? managedSession.currentModel
           );
+          if (!selectedFallbackModel) return;
           await setSessionFallbackModel(state, sessionID, selectedFallbackModel);
           const errorType = getRetryableErrorType(error);
           pluginLog.info(
@@ -5709,6 +5808,7 @@ function createTextCompleteHandler(state) {
     cancelProviderRetryWatchdog(state, sessionID, "assistant text completed");
     if (isProviderRetryBanner(text) && isManagedRootSession) {
       const fallbackModel = getSessionFallbackModel(state, sessionID);
+      if (!fallbackModel) return;
       await setSessionFallbackModel(state, sessionID, fallbackModel);
       scheduleManagedSessionRetry(state, sessionID, {
         delayMs: 1e3,
@@ -5769,15 +5869,18 @@ function createTextCompleteHandler(state) {
       const taskMatch = text.match(NEXT_TASK_PATTERN);
       const nextTask = taskMatch?.[1]?.trim() ?? "Continue processing task backlog";
       pluginLog.info(
-        `[opencode-immune] Multi-Cycle: Starting next cycle in current session (cycle ${state.cycleCount}/${MAX_CYCLES}) for: "${nextTask}"`
+        `[opencode-immune] Multi-Cycle: Starting next cycle in a new session (cycle ${state.cycleCount}/${MAX_CYCLES}) for: "${nextTask}"`
       );
       try {
-        await promptManagedSession(
+        await startAutoCycleInNewSession(
           state,
-          sessionID,
-          `[AUTO-CYCLE] Continue processing task backlog. Read memory-bank/tasks.md and memory-bank/backlog.md, pick the next pending task, and run the full pipeline.`
+          {
+            sourceSessionID: sessionID,
+            nextTask,
+            logContext: "Multi-Cycle",
+            retireSourceSession: true
+          }
         );
-        pluginLog.info(`[opencode-immune] Multi-Cycle: Bootstrap prompt sent to ${sessionID}`);
       } catch (err) {
         pluginLog.error("[opencode-immune] Multi-Cycle: Failed to send prompt:", err);
       }
@@ -5802,15 +5905,17 @@ function createTextCompleteHandler(state) {
     );
     try {
       await refreshAutoCycleLock(state, sessionID);
-      await promptManagedSession(
+      await startAutoCycleInNewSession(
         state,
-        sessionID,
-        `[AUTO-CYCLE] Continue processing task backlog. Read memory-bank/tasks.md and memory-bank/backlog.md, pick the next pending task, and run the full pipeline.`
+        {
+          sourceSessionID: sessionID,
+          logContext: "Multi-Cycle fallback",
+          clearLockOnFailureReason: "fallback bootstrap failed",
+          retireSourceSession: true
+        }
       );
-      pluginLog.info(`[opencode-immune] Multi-Cycle fallback: Bootstrap prompt sent to ${sessionID}`);
     } catch (err) {
       state.autoCycleSourceSessions.delete(sessionID);
-      await clearAutoCycleLock(state, "fallback bootstrap failed");
       pluginLog.error("[opencode-immune] Multi-Cycle fallback: Failed to send prompt:", err);
     } finally {
       state.autoCycleInFlight = false;
@@ -5835,6 +5940,7 @@ function createMultiCycleHandler(state) {
     if (sessionID && RATE_LIMIT_MESSAGE_PATTERN.test(messageContent)) {
       if (managedSession && !managedSession.fallbackModel) {
         const fallbackModel = getSessionFallbackModel(state, sessionID);
+        if (!fallbackModel) return;
         await setSessionFallbackModel(state, sessionID, fallbackModel);
         pluginLog.info(
           `[opencode-immune] Rate limit message detected in chat output for session ${sessionID}. Fallback model pinned to ${fallbackModel.providerID}/${fallbackModel.modelID}.`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-immune",
-  "version": "1.0.72",
+  "version": "1.0.75",
   "type": "module",
   "description": "OpenCode plugin: session recovery, auto-retry, multi-cycle automation, context monitoring",
   "exports": {