opencode-immune 1.0.48 → 1.0.51

package/dist/plugin.js

@@ -1,19 +1,19 @@
-"use strict";
 // .opencode/plugin.ts — opencode-immune plugin
 // Hybrid single-file architecture with factory functions, explicit state, error boundaries
 // See: memory-bank/creative/creative-plugin-architecture.md (Option C)
-Object.defineProperty(exports, "__esModule", { value: true });
-const client_1 = require("@opencode-ai/sdk/v2/client");
-const promises_1 = require("fs/promises");
-const path_1 = require("path");
-const crypto_1 = require("crypto");
-const os_1 = require("os");
-const child_process_1 = require("child_process");
+import { createOpencodeClient as createOpencodeClientV2 } from "@opencode-ai/sdk/v2/client";
+import { appendFile, mkdir, readFile, unlink, writeFile, stat, rm, rename, readdir, copyFile } from "fs/promises";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { createHash } from "crypto";
+import { tmpdir } from "os";
+import { execFile } from "child_process";
 // ═══════════════════════════════════════════════════════════════════════════════
 // PLUGIN VERSION CHECK
 // ═══════════════════════════════════════════════════════════════════════════════
-const PLUGIN_VERSION = "1.0.44";
+const PLUGIN_VERSION = "1.0.51";
 const PLUGIN_PACKAGE_NAME = "opencode-immune";
+const PLUGIN_DIRNAME = dirname(fileURLToPath(import.meta.url));
 /**
  * Read plugin version from package.json at runtime.
  * Falls back to PLUGIN_VERSION constant if read fails.
@@ -24,12 +24,12 @@ async function getPluginVersion() {
         // dist/plugin.js → ../package.json
         // Also try direct path for when loaded from npm cache.
         const candidates = [
-            (0, path_1.join)(__dirname, "..", "package.json"),
-            (0, path_1.join)(__dirname, "package.json"),
+            join(PLUGIN_DIRNAME, "..", "package.json"),
+            join(PLUGIN_DIRNAME, "package.json"),
         ];
         for (const pkgPath of candidates) {
             try {
-                const content = await (0, promises_1.readFile)(pkgPath, "utf-8");
+                const content = await readFile(pkgPath, "utf-8");
                 const pkg = JSON.parse(content);
                 if (pkg.version)
                     return pkg.version;
@@ -77,7 +77,7 @@ function createState(input) {
     const { client: _client, ...runtimeInput } = input;
     return {
         input: runtimeInput,
-        client: (0, client_1.createOpencodeClient)({
+        client: createOpencodeClientV2({
             baseUrl: input.serverUrl.toString(),
             directory: input.directory,
         }),
@@ -87,8 +87,8 @@ function createState(input) {
         providerRetryWatchdogs: new Map(),
         childFallbackRequests: new Map(),
         sessionErrorRetryCount: new Map(),
-        ultraworkMarkerPath: (0, path_1.join)(input.directory, ".opencode", "state", "ultrawork-active.json"),
-        diagnosticsLogPath: (0, path_1.join)(input.directory, ".opencode", "state", "opencode-immune-debug.log"),
+        ultraworkMarkerPath: join(input.directory, ".opencode", "state", "ultrawork-active.json"),
+        diagnosticsLogPath: join(input.directory, ".opencode", "state", "opencode-immune-debug.log"),
         lastEditAttempt: null,
         toolCallCount: 0,
         todoWriteUsed: false,
@@ -188,11 +188,11 @@ function pruneExpiredManagedSessions(state, now = Date.now()) {
 }
 async function writeDiagnosticLog(state, event, data = {}) {
     try {
-        const cacheDir = (0, path_1.join)(state.input.directory, ".opencode", "state");
-        await (0, promises_1.mkdir)(cacheDir, { recursive: true });
+        const cacheDir = join(state.input.directory, ".opencode", "state");
+        await mkdir(cacheDir, { recursive: true });
         await rotateDiagnosticLogIfNeeded(state.diagnosticsLogPath);
         const line = JSON.stringify({ ts: new Date().toISOString(), event, ...data });
-        await (0, promises_1.appendFile)(state.diagnosticsLogPath, `${line}\n`, "utf-8");
+        await appendFile(state.diagnosticsLogPath, `${line}\n`, "utf-8");
     }
     catch {
         // diagnostics must never affect runtime behavior
@@ -200,12 +200,12 @@ async function writeDiagnosticLog(state, event, data = {}) {
 }
 async function rotateDiagnosticLogIfNeeded(logPath) {
     try {
-        const current = await (0, promises_1.stat)(logPath);
+        const current = await stat(logPath);
         if (current.size < DIAGNOSTIC_LOG_MAX_BYTES)
             return;
         const rotatedPath = `${logPath}.1`;
-        await (0, promises_1.rm)(rotatedPath, { force: true });
-        await (0, promises_1.rename)(logPath, rotatedPath);
+        await rm(rotatedPath, { force: true });
+        await rename(logPath, rotatedPath);
     }
     catch {
         // missing log or rotation failure must never affect runtime behavior
@@ -228,10 +228,10 @@ function writePluginLog(state, level, message, extra = {}) {
     });
 }
 function writePluginLogForDirectory(directory, level, message, extra = {}) {
-    const diagnosticsLogPath = (0, path_1.join)(directory, ".opencode", "state", "opencode-immune-debug.log");
+    const diagnosticsLogPath = join(directory, ".opencode", "state", "opencode-immune-debug.log");
     void (async () => {
         try {
-            await (0, promises_1.mkdir)((0, path_1.dirname)(diagnosticsLogPath), { recursive: true });
+            await mkdir(dirname(diagnosticsLogPath), { recursive: true });
             await rotateDiagnosticLogIfNeeded(diagnosticsLogPath);
             const line = JSON.stringify({
                 ts: new Date().toISOString(),
@@ -239,7 +239,7 @@ function writePluginLogForDirectory(directory, level, message, extra = {}) {
                 message,
                 ...extra,
             });
-            await (0, promises_1.appendFile)(diagnosticsLogPath, `${line}\n`, "utf-8");
+            await appendFile(diagnosticsLogPath, `${line}\n`, "utf-8");
         }
         catch {
             // file logging must never affect runtime behavior
@@ -263,13 +263,13 @@ const pluginLog = {
 // ── Ultrawork Marker File ──
 async function writeUltraworkMarker(state) {
     try {
-        const dir = (0, path_1.join)(state.input.directory, ".opencode", "state");
-        await (0, promises_1.mkdir)(dir, { recursive: true });
+        const dir = join(state.input.directory, ".opencode", "state");
+        await mkdir(dir, { recursive: true });
         const payload = JSON.stringify({
             active: true,
             updatedAt: new Date().toISOString(),
         });
-        await (0, promises_1.writeFile)(state.ultraworkMarkerPath, payload, "utf-8");
+        await writeFile(state.ultraworkMarkerPath, payload, "utf-8");
     }
     catch {
         // marker write must never affect runtime
@@ -277,7 +277,7 @@ async function writeUltraworkMarker(state) {
 }
 async function clearUltraworkMarker(state) {
     try {
-        await (0, promises_1.unlink)(state.ultraworkMarkerPath);
+        await unlink(state.ultraworkMarkerPath);
     }
     catch {
         // file may not exist — that's fine
@@ -285,7 +285,7 @@ async function clearUltraworkMarker(state) {
 }
 async function isUltraworkMarkerActive(state) {
     try {
-        const raw = await (0, promises_1.readFile)(state.ultraworkMarkerPath, "utf-8");
+        const raw = await readFile(state.ultraworkMarkerPath, "utf-8");
         const parsed = JSON.parse(raw);
         return parsed?.active === true;
     }
@@ -390,7 +390,7 @@ function isRetryableApiError(error) {
         return true;
     }
     // HTTP status code based detection (retryable server/gateway errors + rate limits)
-    const status = maybeError.status ?? maybeError.statusCode ?? maybeError.data?.status;
+    const status = maybeError.status ?? maybeError.statusCode ?? maybeError.data?.status ?? maybeError.error?.status;
     if (status && (status === 404 || // transient endpoint not found (API gateway issues)
         status === 429 || // rate limit
         status === 500 || // internal server error
@@ -402,8 +402,18 @@ function isRetryableApiError(error) {
     }
     // Text-based detection for model access errors (not marked as retryable
     // by the API but retryable with a fallback model)
-    const message = `${maybeError.message ?? ""} ${maybeError.data?.message ?? ""}`.toLowerCase();
-    if (message.includes("не разрешен") ||
+    const message = [
+        maybeError.message,
+        maybeError.code,
+        maybeError.data?.message,
+        maybeError.data?.type,
+        maybeError.data?.code,
+        maybeError.error?.message,
+        maybeError.error?.type,
+        maybeError.error?.code,
+    ].filter((value) => value !== undefined && value !== null).join(" ").toLowerCase();
+    if (message.includes("api_error") ||
+        message.includes("не разрешен") ||
         message.includes("not allowed") ||
         message.includes("internal error") ||
         message.includes("internal server error") ||
@@ -439,6 +449,7 @@ function isRetryableApiError(error) {
         // Certificate/TLS provider failures must pass this primary retry gate
         // before the managed-session fallback model branch can run.
         message.includes("unknown certificate verification error") ||
+        message.includes("unknown_certificate_verification_error") ||
         message.includes("certificate has expired") ||
         message.includes("certificate verification") ||
         message.includes("tls") ||
@@ -468,23 +479,25 @@ 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();
+    const message = `${maybeError.message ?? ""} ${maybeError.data?.message ?? ""} ${maybeError.error?.message ?? ""}`.toLowerCase();
+    const type = `${maybeError.data?.type ?? ""} ${maybeError.error?.type ?? ""}`.toLowerCase();
     return ((type.includes("rate_limit") || message.includes("too many requests") || message.includes("rate limit")));
 }
 function isCertificateApiError(error) {
     if (!error || typeof error !== "object")
         return false;
     const maybeError = error;
-    const message = `${maybeError.message ?? ""} ${maybeError.data?.message ?? ""}`.toLowerCase();
-    const code = `${maybeError.code ?? ""} ${maybeError.data?.code ?? ""}`.toLowerCase();
-    const type = `${maybeError.data?.type ?? ""}`.toLowerCase();
+    const message = `${maybeError.message ?? ""} ${maybeError.data?.message ?? ""} ${maybeError.error?.message ?? ""}`.toLowerCase();
+    const code = `${maybeError.code ?? ""} ${maybeError.data?.code ?? ""} ${maybeError.error?.code ?? ""}`.toLowerCase();
+    const type = `${maybeError.data?.type ?? ""} ${maybeError.error?.type ?? ""}`.toLowerCase();
     return (message.includes("unknown certificate verification error") ||
+        message.includes("unknown_certificate_verification_error") ||
         message.includes("certificate has expired") ||
         message.includes("certificate verification") ||
         message.includes("tls") ||
         message.includes("ssl") ||
         code.includes("cert_has_expired") ||
+        code.includes("unknown_certificate_verification_error") ||
         code.includes("unable_to_verify_leaf_signature") ||
         code.includes("self_signed_cert") ||
         code.includes("tls") ||
@@ -560,6 +573,28 @@ async function setSessionFallbackModel(state, sessionID, model) {
         fallbackModel: model,
     });
 }
+async function recoverUntrackedRootSessionForRetry(state, sessionID, error) {
+    if (!isRetryableApiError(error))
+        return undefined;
+    const markerActive = await isUltraworkMarkerActive(state);
+    if (!markerActive)
+        return undefined;
+    const recovery = await parseTasksFile(state.input.directory);
+    if (!recovery || recovery.phase === "ARCHIVE: DONE")
+        return undefined;
+    state.recoveryContext = recovery;
+    await addManagedUltraworkSession(state, sessionID);
+    const recovered = getManagedSession(state, sessionID);
+    await writeDiagnosticLog(state, "session-retry:recovered-untracked-root", {
+        sessionID,
+        task: recovery.task,
+        level: recovery.level,
+        phase: recovery.phase,
+        errorType: getRetryableErrorType(error),
+    });
+    writePluginLog(state, "warn", `[opencode-immune] Recovered untracked root session ${sessionID} for retry after plugin restart or state loss.`);
+    return recovered;
+}
 function getManagedSessionRetryContext(state, sessionID) {
     const managedSession = state.managedUltraworkSessions.get(sessionID);
     if (!managedSession)
@@ -707,8 +742,8 @@ function compositeChatMessage(handlers) {
  */
 async function parseTasksFile(directory) {
     try {
-        const tasksPath = (0, path_1.join)(directory, "memory-bank", "tasks.md");
-        const content = await (0, promises_1.readFile)(tasksPath, "utf-8");
+        const tasksPath = join(directory, "memory-bank", "tasks.md");
+        const content = await readFile(tasksPath, "utf-8");
         // Check for active task
         if (!content.includes("## Active Task") ||
             content.includes("No active tasks")) {
@@ -780,7 +815,7 @@ const DEFAULT_HARNESS_REPO = "gendoor/opencode-immune-harness";
 async function parseDotEnv(filePath) {
     const result = {};
     try {
-        const content = await (0, promises_1.readFile)(filePath, "utf-8");
+        const content = await readFile(filePath, "utf-8");
         for (const line of content.split("\n")) {
             const trimmed = line.trim();
             if (!trimmed || trimmed.startsWith("#"))
@@ -814,13 +849,13 @@ async function resolveEnvValue(directory, key) {
     if (process.env[key])
         return process.env[key];
     // 2. Per-project .env
-    const projectEnv = await parseDotEnv((0, path_1.join)(directory, ".env"));
+    const projectEnv = await parseDotEnv(join(directory, ".env"));
     if (projectEnv[key])
         return projectEnv[key];
     // 3. Global config
     const home = process.env.HOME || process.env.USERPROFILE || "";
     if (home) {
-        const globalEnv = await parseDotEnv((0, path_1.join)(home, ".config", "opencode-immune", ".env"));
+        const globalEnv = await parseDotEnv(join(home, ".config", "opencode-immune", ".env"));
         if (globalEnv[key])
             return globalEnv[key];
     }
@@ -878,8 +913,8 @@ async function fetchLatestHarnessRelease(directory, repo, token) {
  */
 async function readLocalHarnessVersion(directory) {
     try {
-        const versionPath = (0, path_1.join)(directory, ".opencode", HARNESS_VERSION_FILE);
-        const content = await (0, promises_1.readFile)(versionPath, "utf-8");
+        const versionPath = join(directory, ".opencode", HARNESS_VERSION_FILE);
+        const content = await readFile(versionPath, "utf-8");
         return content.trim() || null;
     }
     catch {
@@ -903,8 +938,8 @@ async function downloadHarnessAsset(assetUrl, token) {
         throw new Error(`Download failed: ${resp.status} ${resp.statusText}`);
     }
     const buffer = Buffer.from(await resp.arrayBuffer());
-    const tempPath = (0, path_1.join)((0, os_1.tmpdir)(), `harness-${Date.now()}.tar.gz`);
-    await (0, promises_1.writeFile)(tempPath, buffer);
+    const tempPath = join(tmpdir(), `harness-${Date.now()}.tar.gz`);
+    await writeFile(tempPath, buffer);
     return tempPath;
 }
 /**
@@ -913,7 +948,7 @@ async function downloadHarnessAsset(assetUrl, token) {
  */
 function extractTarGz(archivePath, destDir) {
     return new Promise((resolve, reject) => {
-        (0, child_process_1.execFile)("tar", ["xzf", archivePath, "-C", destDir], (err) => {
+        execFile("tar", ["xzf", archivePath, "-C", destDir], (err) => {
             if (err)
                 reject(err);
             else
@@ -928,22 +963,22 @@ function extractTarGz(archivePath, destDir) {
  */
 async function copyDirRecursive(src, dest, skipRootFiles, rootDest) {
     const effectiveRoot = rootDest ?? dest;
-    const entries = await (0, promises_1.readdir)(src, { withFileTypes: true });
-    await (0, promises_1.mkdir)(dest, { recursive: true });
+    const entries = await readdir(src, { withFileTypes: true });
+    await mkdir(dest, { recursive: true });
     for (const entry of entries) {
         // Skip files only at the root destination level
         if (skipRootFiles && dest === effectiveRoot && entry.name === ".gitignore") {
             pluginLog.info(`[opencode-immune] Harness sync: skipping root .gitignore`);
             continue;
         }
-        const srcPath = (0, path_1.join)(src, entry.name);
-        const destPath = (0, path_1.join)(dest, entry.name);
+        const srcPath = join(src, entry.name);
+        const destPath = join(dest, entry.name);
         if (entry.isDirectory()) {
             await copyDirRecursive(srcPath, destPath, skipRootFiles, effectiveRoot);
         }
         else {
-            await (0, promises_1.mkdir)((0, path_1.dirname)(destPath), { recursive: true });
-            await (0, promises_1.copyFile)(srcPath, destPath);
+            await mkdir(dirname(destPath), { recursive: true });
+            await copyFile(srcPath, destPath);
         }
     }
 }
@@ -952,8 +987,8 @@ async function copyDirRecursive(src, dest, skipRootFiles, rootDest) {
  */
 async function fileHash(filePath) {
     try {
-        const content = await (0, promises_1.readFile)(filePath);
-        return (0, crypto_1.createHash)("sha256").update(content).digest("hex");
+        const content = await readFile(filePath);
+        return createHash("sha256").update(content).digest("hex");
     }
     catch {
         return "";
@@ -995,13 +1030,13 @@ async function syncHarness(state) {
         }
         pluginLog.info(`[opencode-immune] Harness sync: updating ${localVersion ?? "(none)"} → ${release.tagName}`);
         // 3. Hash opencode.json before update
-        const configPath = (0, path_1.join)(state.input.directory, "opencode.json");
+        const configPath = join(state.input.directory, "opencode.json");
         const hashBefore = await fileHash(configPath);
         // 4. Download asset
         const archivePath = await downloadHarnessAsset(release.assetUrl, token);
         // 5. Extract to temp dir
-        const extractDir = (0, path_1.join)((0, os_1.tmpdir)(), `harness-extract-${Date.now()}`);
-        await (0, promises_1.mkdir)(extractDir, { recursive: true });
+        const extractDir = join(tmpdir(), `harness-extract-${Date.now()}`);
+        await mkdir(extractDir, { recursive: true });
         try {
             await extractTarGz(archivePath, extractDir);
             // 6. Copy extracted files to project root (skip .gitignore — project owns its own)
@@ -1009,9 +1044,9 @@ async function syncHarness(state) {
             const SKIP_ROOT_FILES = new Set([".gitignore"]);
             await copyDirRecursive(extractDir, state.input.directory, SKIP_ROOT_FILES);
             // 7. Write version marker
-            const versionDir = (0, path_1.join)(state.input.directory, ".opencode");
-            await (0, promises_1.mkdir)(versionDir, { recursive: true });
-            await (0, promises_1.writeFile)((0, path_1.join)(versionDir, HARNESS_VERSION_FILE), release.tagName + "\n", "utf-8");
+            const versionDir = join(state.input.directory, ".opencode");
+            await mkdir(versionDir, { recursive: true });
+            await writeFile(join(versionDir, HARNESS_VERSION_FILE), release.tagName + "\n", "utf-8");
             // 8. Check if opencode.json changed
             const hashAfter = await fileHash(configPath);
             if (hashBefore && hashAfter && hashBefore !== hashAfter) {
@@ -1028,11 +1063,11 @@ async function syncHarness(state) {
         finally {
             // 9. Cleanup temp files
             try {
-                await (0, promises_1.unlink)(archivePath);
+                await unlink(archivePath);
             }
             catch { /* ignore */ }
             try {
-                await (0, promises_1.rm)(extractDir, { recursive: true, force: true });
+                await rm(extractDir, { recursive: true, force: true });
             }
             catch { /* ignore */ }
         }
@@ -1459,10 +1494,18 @@ function createEventHandler(state) {
         }
         // ── Auto-retry on retryable API error for managed ultrawork sessions ──
         if (eventType === "session.error" && sessionID) {
-            const managedSession = getManagedSession(state, sessionID);
+            const managedSession = getManagedSession(state, sessionID) ??
+                await recoverUntrackedRootSessionForRetry(state, sessionID, error);
             const isRoot = managedSession?.kind === "root";
             const isChild = managedSession?.kind === "child";
             if (!managedSession) {
+                if (isRetryableApiError(error)) {
+                    await writeDiagnosticLog(state, "session-retry:unmanaged-retryable-error", {
+                        sessionID,
+                        eventType,
+                        errorType: getRetryableErrorType(error),
+                    });
+                }
                 return;
             }
             if (!isRetryableApiError(error)) {
@@ -1555,22 +1598,22 @@ const ALL_CYCLES_COMPLETE_MARKER = "0-ULTRAWORK: ALL_CYCLES_COMPLETE";
  * Skips silently if progress.md doesn't exist or is trivially empty.
  */
 async function archiveProgress(directory) {
-    const progressPath = (0, path_1.join)(directory, "memory-bank", "progress.md");
+    const progressPath = join(directory, "memory-bank", "progress.md");
     try {
-        const content = await (0, promises_1.readFile)(progressPath, "utf-8");
+        const content = await readFile(progressPath, "utf-8");
         // Skip if empty or trivially empty
         if (!content.trim() || content.trim() === "# Progress") {
             pluginLog.info("[opencode-immune] Archive progress: nothing to archive (empty).");
             return;
         }
-        const archiveDir = (0, path_1.join)(directory, "memory-bank", "archive");
-        await (0, promises_1.mkdir)(archiveDir, { recursive: true });
+        const archiveDir = join(directory, "memory-bank", "archive");
+        await mkdir(archiveDir, { recursive: true });
         const now = new Date();
         const dateStr = now.toISOString().slice(0, 10); // YYYY-MM-DD
         const ts = Math.floor(now.getTime() / 1000);
         const archiveName = `progress-${dateStr}-${ts}.md`;
-        const archivePath = (0, path_1.join)(archiveDir, archiveName);
-        await (0, promises_1.rename)(progressPath, archivePath);
+        const archivePath = join(archiveDir, archiveName);
+        await rename(progressPath, archivePath);
         pluginLog.info(`[opencode-immune] Archive progress: moved to ${archiveName}`);
     }
     catch (err) {
@@ -1621,17 +1664,17 @@ async function buildCommitMessage(directory, diffStat) {
 function runGitCommit(directory) {
     return new Promise((resolve) => {
         // Stage all changes
-        (0, child_process_1.execFile)("git", ["add", "-A"], { cwd: directory }, (addErr) => {
+        execFile("git", ["add", "-A"], { cwd: directory }, (addErr) => {
             if (addErr) {
                 pluginLog.error("[opencode-immune] git add failed:", addErr.message);
                 resolve(false);
                 return;
             }
             // Get diff stat for commit body
-            (0, child_process_1.execFile)("git", ["diff", "--cached", "--stat"], { cwd: directory }, async (_diffErr, diffOut) => {
+            execFile("git", ["diff", "--cached", "--stat"], { cwd: directory }, async (_diffErr, diffOut) => {
                 const stat = (diffOut ?? "").trim();
                 const message = await buildCommitMessage(directory, stat);
-                (0, child_process_1.execFile)("git", ["commit", "-m", message], { cwd: directory }, (commitErr, stdout, stderr) => {
+                execFile("git", ["commit", "-m", message], { cwd: directory }, (commitErr, stdout, stderr) => {
                     if (commitErr) {
                         if (stderr?.includes("nothing to commit") || stdout?.includes("nothing to commit")) {
                             pluginLog.info("[opencode-immune] git commit: nothing to commit (clean tree).");
@@ -1854,8 +1897,8 @@ async function server(input) {
         else {
             // No active task — check if backlog has pending work to start a new cycle
             try {
-                const backlogPath = (0, path_1.join)(state.input.directory, "memory-bank", "backlog.md");
-                const backlogContent = await (0, promises_1.readFile)(backlogPath, "utf-8");
+                const backlogPath = join(state.input.directory, "memory-bank", "backlog.md");
+                const backlogContent = await readFile(backlogPath, "utf-8");
                 const hasPendingTasks = /- \[ \]/.test(backlogContent);
                 if (hasPendingTasks) {
                     state.autoResumeAttempted = true;
@@ -1917,7 +1960,7 @@ async function server(input) {
         "permission.ask": withErrorBoundary(state, "permission.ask", createPermissionAskHandler(state)),
     };
 }
-exports.default = {
+export default {
     id: "opencode-immune",
     server,
 };

package/package.json

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