opencode-immune 1.0.74 → 1.0.76

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.74";
+var PLUGIN_VERSION = "1.0.76";
 var PLUGIN_PACKAGE_NAME = "opencode-immune";
 var PLUGIN_DIRNAME = dirname(fileURLToPath(import.meta.url));
 function getServerAuthHeaders() {
@@ -3948,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 {
@@ -5074,6 +5110,104 @@ async function fileHash(filePath) {
     return "";
   }
 }
+function parseImmunePluginSpec(value) {
+  const trimmed = value.trim();
+  const match = trimmed.match(/^opencode-immune(?:@(.+))?$/);
+  if (!match) return null;
+  return {
+    spec: trimmed,
+    version: match[1] ?? null
+  };
+}
+async function readProjectImmunePluginSpec(directory) {
+  try {
+    const raw = await readFile(join(directory, "opencode.json"), "utf-8");
+    const config = JSON.parse(raw);
+    const plugins = Array.isArray(config.plugin) ? config.plugin : [];
+    for (let index = plugins.length - 1; index >= 0; index--) {
+      const value = plugins[index];
+      if (typeof value !== "string") continue;
+      const parsed = parseImmunePluginSpec(value);
+      if (parsed) return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+function execFileAsync(command, args, options) {
+  return new Promise((resolve, reject) => {
+    execFile(command, args, options ?? {}, (err, stdout, stderr) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve({ stdout, stderr });
+    });
+  });
+}
+async function clearProjectPluginOverride(directory) {
+  const overridePath = join(directory, ".opencode", "opencode.json");
+  try {
+    const raw = await readFile(overridePath, "utf-8");
+    const config = JSON.parse(raw);
+    const keys = Object.keys(config ?? {});
+    const plugins = Array.isArray(config.plugin) ? config.plugin : [];
+    const isGeneratedVersionPin = plugins.length === 1 && typeof plugins[0] === "string" && /^opencode-immune@.+$/.test(plugins[0]) && keys.every((key) => key === "plugin" || key === "$schema");
+    if (!isGeneratedVersionPin) {
+      return false;
+    }
+    await unlink(overridePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installPinnedProjectPlugin(state, pluginSpec) {
+  if (!pluginSpec.version) return false;
+  const currentVersion = await getPluginVersion();
+  if (pluginSpec.version === currentVersion) {
+    const overrideRemoved = await clearProjectPluginOverride(state.input.directory);
+    if (overrideRemoved) {
+      pluginLog.info(
+        `[opencode-immune] Harness sync: removed stale local plugin override after confirming ${pluginSpec.spec}.`
+      );
+    }
+    return false;
+  }
+  try {
+    pluginLog.info(
+      `[opencode-immune] Harness sync: installing ${pluginSpec.spec} in ${state.input.directory}`
+    );
+    await execFileAsync("opencode", ["plugin", pluginSpec.spec, "--force"], {
+      cwd: state.input.directory,
+      env: process.env
+    });
+    const overrideRemoved = await clearProjectPluginOverride(state.input.directory);
+    if (overrideRemoved) {
+      pluginLog.info(
+        `[opencode-immune] Harness sync: removed local plugin override after installing ${pluginSpec.spec}.`
+      );
+    }
+    state.pluginUpdateMessage = `[PLUGIN UPDATE] Harness synced this project to ${pluginSpec.spec}. Restart opencode to load the new plugin version.`;
+    await writeDiagnosticLog(state, "harness-sync:plugin-install", {
+      pluginSpec: pluginSpec.spec,
+      status: "installed"
+    });
+    return true;
+  } catch (err) {
+    pluginLog.warn(
+      `[opencode-immune] Harness sync: automatic install failed for ${pluginSpec.spec}.`,
+      err instanceof Error ? err.message : String(err)
+    );
+    state.pluginUpdateMessage = `[PLUGIN UPDATE] Harness synced this project to ${pluginSpec.spec}, but automatic install failed. Run \`opencode plugin ${pluginSpec.spec} --force\` in this project, then restart opencode.`;
+    await writeDiagnosticLog(state, "harness-sync:plugin-install", {
+      pluginSpec: pluginSpec.spec,
+      status: "failed",
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return false;
+  }
+}
 async function syncHarness(state) {
   const token = await resolveEnvValue(state.input.directory, HARNESS_TOKEN_ENV);
   if (!token) {
@@ -5124,19 +5258,36 @@ async function syncHarness(state) {
         release.tagName + "\n",
         "utf-8"
       );
+      const projectPluginSpec = await readProjectImmunePluginSpec(state.input.directory);
+      const pluginInstalled = projectPluginSpec ? await installPinnedProjectPlugin(state, projectPluginSpec) : false;
+      if (!projectPluginSpec) {
+        const overrideRemoved = await clearProjectPluginOverride(state.input.directory);
+        if (overrideRemoved) {
+          pluginLog.info(
+            `[opencode-immune] Harness sync: removed local plugin override to keep project config authoritative.`
+          );
+        }
+      }
       const hashAfter = await fileHash(configPath);
       if (hashBefore && hashAfter && hashBefore !== hashAfter) {
         pluginLog.warn(
           `[opencode-immune] \u26A0 Harness sync: opencode.json was updated. Please restart opencode for the new agent configuration to take effect.`
         );
       }
+      if (pluginInstalled) {
+        pluginLog.warn(
+          `[opencode-immune] \u26A0 Harness sync: installed updated plugin from project config. Restart opencode to load the new plugin code.`
+        );
+      }
       pluginLog.info(
         `[opencode-immune] Harness sync: successfully updated to ${release.tagName}`
       );
       await writeDiagnosticLog(state, "harness-sync:success", {
         from: localVersion,
         to: release.tagName,
-        configChanged: hashBefore !== hashAfter
+        configChanged: hashBefore !== hashAfter,
+        pluginSpec: projectPluginSpec?.spec ?? null,
+        pluginInstalled
       });
     } finally {
       try {
@@ -5265,28 +5416,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);
       }
@@ -5836,15 +5984,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);
       }
@@ -5869,15 +6020,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;

package/package.json

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