opencode-immune 1.0.45 → 1.0.47

package/dist/plugin.js

@@ -3,6 +3,7 @@
 // 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");
@@ -59,10 +60,10 @@ async function checkPluginUpdate(state) {
             state.pluginUpdateMessage =
                 `[PLUGIN UPDATE] opencode-immune ${currentVersion} → ${latest} is available. ` +
                     `Please inform the user: a plugin update is available. They should restart opencode to get the latest version.`;
-            console.warn(`[opencode-immune] Plugin update available: ${currentVersion} → ${latest}.`);
+            writePluginLog(state, "warn", `[opencode-immune] Plugin update available: ${currentVersion} → ${latest}.`);
         }
         else if (latest) {
-            console.log(`[opencode-immune] Plugin version ${currentVersion} is up to date.`);
+            writePluginLog(state, "info", `[opencode-immune] Plugin version ${currentVersion} is up to date.`);
         }
     }
     catch {
@@ -70,8 +71,14 @@ async function checkPluginUpdate(state) {
     }
 }
 function createState(input) {
+    activeLogDirectory = input.directory;
+    const { client: _client, ...runtimeInput } = input;
     return {
-        input,
+        input: runtimeInput,
+        client: (0, client_1.createOpencodeClient)({
+            baseUrl: input.serverUrl.toString(),
+            directory: input.directory,
+        }),
         recoveryContext: null,
         managedUltraworkSessions: new Map(),
         sessionRetryTimers: new Map(),
@@ -92,6 +99,25 @@ function createState(input) {
     };
 }
 const ULTRAWORK_AGENT = "0-ultrawork";
+const ULTRAWORK_SESSION_PERMISSION = [
+    { permission: "read", pattern: "*", action: "allow" },
+    { permission: "edit", pattern: "*", action: "allow" },
+    { permission: "glob", pattern: "*", action: "allow" },
+    { permission: "grep", pattern: "*", action: "allow" },
+    { permission: "list", pattern: "*", action: "allow" },
+    { permission: "bash", pattern: "*", action: "allow" },
+    { permission: "task", pattern: "*", action: "allow" },
+    { permission: "external_directory", pattern: "*", action: "allow" },
+    { permission: "todowrite", pattern: "*", action: "allow" },
+    { permission: "question", pattern: "*", action: "allow" },
+    { permission: "webfetch", pattern: "*", action: "allow" },
+    { permission: "websearch", pattern: "*", action: "allow" },
+    { permission: "codesearch", pattern: "*", action: "allow" },
+    { permission: "lsp", pattern: "*", action: "allow" },
+    { permission: "skill", pattern: "*", action: "allow" },
+];
+const DIAGNOSTIC_LOG_MAX_BYTES = 5 * 1024 * 1024;
+let activeLogDirectory = null;
 const MANAGED_SESSION_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 const PROVIDER_RETRY_WATCHDOG_MS = 30_000;
 const CHILD_FALLBACK_REQUEST_TTL_MS = 10 * 60 * 1000;
@@ -113,6 +139,38 @@ function isManagedRootUltraworkSession(state, sessionID) {
     const record = getManagedSession(state, sessionID);
     return !!record && record.kind === "root";
 }
+async function createManagedUltraworkSession(state, title) {
+    const result = await state.client.session.create({
+        directory: state.input.directory,
+        title,
+        permission: ULTRAWORK_SESSION_PERMISSION,
+    });
+    const sessionID = result?.data?.id;
+    if (!sessionID)
+        return null;
+    await addManagedUltraworkSession(state, sessionID);
+    return sessionID;
+}
+async function promptManagedSession(state, sessionID, text, options = {}) {
+    await state.client.session.promptAsync({
+        directory: state.input.directory,
+        sessionID,
+        ...(options.model ? { model: options.model } : {}),
+        agent: options.agent ?? ULTRAWORK_AGENT,
+        parts: [
+            {
+                type: "text",
+                text,
+            },
+        ],
+    });
+}
+async function abortManagedSession(state, sessionID) {
+    await state.client.session.abort({
+        directory: state.input.directory,
+        sessionID,
+    });
+}
 function pruneExpiredManagedSessions(state, now = Date.now()) {
     let removed = 0;
     for (const [sessionID, record] of state.managedUltraworkSessions.entries()) {
@@ -130,6 +188,7 @@ 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 });
+        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");
     }
@@ -137,6 +196,68 @@ async function writeDiagnosticLog(state, event, data = {}) {
         // diagnostics must never affect runtime behavior
     }
 }
+async function rotateDiagnosticLogIfNeeded(logPath) {
+    try {
+        const current = await (0, promises_1.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);
+    }
+    catch {
+        // missing log or rotation failure must never affect runtime behavior
+    }
+}
+function normalizeLogValue(value) {
+    if (value instanceof Error) {
+        return {
+            name: value.name,
+            message: value.message,
+            stack: value.stack,
+        };
+    }
+    return value;
+}
+function writePluginLog(state, level, message, extra = {}) {
+    void writeDiagnosticLog(state, `log:${level}`, {
+        message,
+        ...extra,
+    });
+}
+function writePluginLogForDirectory(directory, level, message, extra = {}) {
+    const diagnosticsLogPath = (0, path_1.join)(directory, ".opencode", "state", "opencode-immune-debug.log");
+    void (async () => {
+        try {
+            await (0, promises_1.mkdir)((0, path_1.dirname)(diagnosticsLogPath), { recursive: true });
+            await rotateDiagnosticLogIfNeeded(diagnosticsLogPath);
+            const line = JSON.stringify({
+                ts: new Date().toISOString(),
+                event: `log:${level}`,
+                message,
+                ...extra,
+            });
+            await (0, promises_1.appendFile)(diagnosticsLogPath, `${line}\n`, "utf-8");
+        }
+        catch {
+            // file logging must never affect runtime behavior
+        }
+    })();
+}
+function writePluginLogFromArgs(level, values) {
+    if (!activeLogDirectory)
+        return;
+    const [first, ...rest] = values;
+    const message = typeof first === "string" ? first : JSON.stringify(normalizeLogValue(first));
+    writePluginLogForDirectory(activeLogDirectory, level, message, {
+        args: rest.map(normalizeLogValue),
+    });
+}
+const pluginLog = {
+    info: (...values) => writePluginLogFromArgs("info", values),
+    warn: (...values) => writePluginLogFromArgs("warn", values),
+    error: (...values) => writePluginLogFromArgs("error", values),
+};
 // ── Ultrawork Marker File ──
 async function writeUltraworkMarker(state) {
     try {
@@ -214,7 +335,7 @@ function cancelPendingSessionRetry(state, sessionID, reason) {
         return;
     clearTimeout(timer);
     state.sessionRetryTimers.delete(sessionID);
-    console.log(`[opencode-immune] Cancelled pending retry for session ${sessionID}: ${reason}`);
+    writePluginLog(state, "info", `[opencode-immune] Cancelled pending retry for session ${sessionID}: ${reason}`);
 }
 function cancelProviderRetryWatchdog(state, sessionID, reason) {
     const timer = state.providerRetryWatchdogs.get(sessionID);
@@ -222,7 +343,7 @@ function cancelProviderRetryWatchdog(state, sessionID, reason) {
         return;
     clearTimeout(timer);
     state.providerRetryWatchdogs.delete(sessionID);
-    console.log(`[opencode-immune] Cancelled provider retry watchdog for session ${sessionID}: ${reason}`);
+    writePluginLog(state, "info", `[opencode-immune] Cancelled provider retry watchdog for session ${sessionID}: ${reason}`);
 }
 async function removeManagedUltraworkSession(state, sessionID, reason) {
     cancelPendingSessionRetry(state, sessionID, reason);
@@ -231,7 +352,7 @@ async function removeManagedUltraworkSession(state, sessionID, reason) {
     const existed = state.managedUltraworkSessions.delete(sessionID);
     if (!existed)
         return;
-    console.log(`[opencode-immune] Removed managed ultrawork session ${sessionID}: ${reason}`);
+    writePluginLog(state, "info", `[opencode-immune] Removed managed ultrawork session ${sessionID}: ${reason}`);
 }
 async function updateManagedSessionAgent(state, sessionID, agent) {
     const existing = state.managedUltraworkSessions.get(sessionID);
@@ -468,9 +589,7 @@ async function sendManagedSessionRetryPrompt(state, sessionID, reason, options =
     });
     if (options.abortBeforePrompt) {
         try {
-            await state.input.client.session.abort({
-                path: { id: sessionID },
-            });
+            await abortManagedSession(state, sessionID);
             await writeDiagnosticLog(state, "session-retry:abort-success", { sessionID });
         }
         catch (err) {
@@ -480,20 +599,11 @@ async function sendManagedSessionRetryPrompt(state, sessionID, reason, options =
             });
         }
     }
-    await state.input.client.session.promptAsync({
-        body: {
-            ...(fallbackModel ? { model: fallbackModel } : {}),
-            agent: retryAgent,
-            parts: [
-                {
-                    type: "text",
-                    text: retryText,
-                },
-            ],
-        },
-        path: { id: sessionID },
+    await promptManagedSession(state, sessionID, retryText, {
+        agent: retryAgent,
+        model: fallbackModel,
     });
-    console.log(`[opencode-immune] Retry prompt sent to session ${sessionID} (${reason})` +
+    writePluginLog(state, "info", `[opencode-immune] Retry prompt sent to session ${sessionID} (${reason})` +
         (fallbackModel
             ? ` using fallback model ${fallbackModel.providerID}/${fallbackModel.modelID}`
             : ""));
@@ -510,11 +620,11 @@ function scheduleManagedSessionRetry(state, sessionID, options) {
         return false;
     }
     if (state.sessionRetryTimers.has(sessionID)) {
-        console.log(`[opencode-immune] Retry already pending for session ${sessionID}, skipping duplicate.`);
+        writePluginLog(state, "info", `[opencode-immune] Retry already pending for session ${sessionID}, skipping duplicate.`);
         return false;
     }
     const attemptInfo = options.attemptLabel ? ` (${options.attemptLabel})` : "";
-    console.log(`[opencode-immune] Scheduling retry for session ${sessionID}${attemptInfo}. ` +
+    writePluginLog(state, "info", `[opencode-immune] Scheduling retry for session ${sessionID}${attemptInfo}. ` +
         `Waiting ${options.delayMs / 1000}s before retry...`);
     const timer = setTimeout(async () => {
         state.sessionRetryTimers.delete(sessionID);
@@ -530,7 +640,7 @@ function scheduleManagedSessionRetry(state, sessionID, options) {
             if (options.countAgainstBudget) {
                 state.sessionErrorRetryCount.set(sessionID, Math.max((state.sessionErrorRetryCount.get(sessionID) ?? 1) - 1, 0));
             }
-            console.log(`[opencode-immune] Retry prompt failed for session ${sessionID}. ` +
+            writePluginLog(state, "warn", `[opencode-immune] Retry prompt failed for session ${sessionID}. ` +
                 `Will wait for the next retry signal.`);
         }
     }, options.delayMs);
@@ -544,13 +654,17 @@ function scheduleManagedSessionRetry(state, sessionID, options) {
  * Wraps a hook handler in a try/catch to prevent any single hook failure
  * from crashing the entire agent session.
  */
-function withErrorBoundary(hookName, handler) {
+function withErrorBoundary(state, hookName, handler) {
     return (async (...args) => {
         try {
             return await handler(...args);
         }
         catch (err) {
-            console.error(`[opencode-immune] Hook "${hookName}" error:`, err);
+            const hookInput = args.find((arg) => !!arg && typeof arg === "object" && "sessionID" in arg);
+            writePluginLog(state, "error", `[opencode-immune] Hook "${hookName}" error.`, {
+                error: normalizeLogValue(err),
+                sessionID: hookInput?.sessionID,
+            });
             // Error is swallowed — hook failure must not crash agent session
         }
     });
@@ -714,7 +828,7 @@ async function resolveEnvValue(directory, key) {
  * Fetch latest release info from the harness GitHub repo.
  * Returns null if token is missing, network fails, or no release found.
  */
-async function fetchLatestHarnessRelease(repo, token) {
+async function fetchLatestHarnessRelease(directory, repo, token) {
     try {
         const url = `https://api.github.com/repos/${repo}/releases/latest`;
         const resp = await fetch(url, {
@@ -726,10 +840,10 @@ async function fetchLatestHarnessRelease(repo, token) {
         });
         if (!resp.ok) {
             if (resp.status === 404) {
-                console.log(`[opencode-immune] Harness sync: no releases found in ${repo}`);
+                writePluginLogForDirectory(directory, "info", `[opencode-immune] Harness sync: no releases found in ${repo}`);
             }
             else {
-                console.warn(`[opencode-immune] Harness sync: GitHub API returned ${resp.status} ${resp.statusText}`);
+                writePluginLogForDirectory(directory, "warn", `[opencode-immune] Harness sync: GitHub API returned ${resp.status} ${resp.statusText}`);
             }
             return null;
         }
@@ -742,7 +856,7 @@ async function fetchLatestHarnessRelease(repo, token) {
         const assetName = isWindows ? "harness-windows.tar.gz" : "harness.tar.gz";
         const asset = data.assets?.find((a) => a.name === assetName);
         if (!asset) {
-            console.warn(`[opencode-immune] Harness sync: release ${tagName} has no ${assetName} asset`);
+            writePluginLogForDirectory(directory, "warn", `[opencode-immune] Harness sync: release ${tagName} has no ${assetName} asset`);
             return null;
         }
         return {
@@ -752,7 +866,7 @@ async function fetchLatestHarnessRelease(repo, token) {
         };
     }
     catch (err) {
-        console.warn(`[opencode-immune] Harness sync: failed to fetch release info:`, err instanceof Error ? err.message : String(err));
+        writePluginLogForDirectory(directory, "warn", `[opencode-immune] Harness sync: failed to fetch release info.`, { error: normalizeLogValue(err) });
         return null;
     }
 }
@@ -817,7 +931,7 @@ async function copyDirRecursive(src, dest, skipRootFiles, rootDest) {
     for (const entry of entries) {
         // Skip files only at the root destination level
         if (skipRootFiles && dest === effectiveRoot && entry.name === ".gitignore") {
-            console.log(`[opencode-immune] Harness sync: skipping root .gitignore`);
+            pluginLog.info(`[opencode-immune] Harness sync: skipping root .gitignore`);
             continue;
         }
         const srcPath = (0, path_1.join)(src, entry.name);
@@ -868,16 +982,16 @@ async function syncHarness(state) {
         || DEFAULT_HARNESS_REPO;
     try {
         // 1. Fetch latest release
-        const release = await fetchLatestHarnessRelease(repo, token);
+        const release = await fetchLatestHarnessRelease(state.input.directory, repo, token);
         if (!release)
             return;
         // 2. Compare versions
         const localVersion = await readLocalHarnessVersion(state.input.directory);
         if (localVersion === release.tagName) {
-            console.log(`[opencode-immune] Harness sync: already up to date (${release.tagName})`);
+            pluginLog.info(`[opencode-immune] Harness sync: already up to date (${release.tagName})`);
             return;
         }
-        console.log(`[opencode-immune] Harness sync: updating ${localVersion ?? "(none)"} → ${release.tagName}`);
+        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 hashBefore = await fileHash(configPath);
@@ -899,10 +1013,10 @@ async function syncHarness(state) {
             // 8. Check if opencode.json changed
             const hashAfter = await fileHash(configPath);
             if (hashBefore && hashAfter && hashBefore !== hashAfter) {
-                console.warn(`[opencode-immune] ⚠ Harness sync: opencode.json was updated. ` +
+                pluginLog.warn(`[opencode-immune] ⚠ Harness sync: opencode.json was updated. ` +
                     `Please restart opencode for the new agent configuration to take effect.`);
             }
-            console.log(`[opencode-immune] Harness sync: successfully updated to ${release.tagName}`);
+            pluginLog.info(`[opencode-immune] Harness sync: successfully updated to ${release.tagName}`);
             await writeDiagnosticLog(state, "harness-sync:success", {
                 from: localVersion,
                 to: release.tagName,
@@ -923,7 +1037,7 @@ async function syncHarness(state) {
     }
     catch (err) {
         // Sync failure must never prevent plugin from working
-        console.warn(`[opencode-immune] Harness sync failed:`, err instanceof Error ? err.message : String(err));
+        pluginLog.warn(`[opencode-immune] Harness sync failed:`, err instanceof Error ? err.message : String(err));
         await writeDiagnosticLog(state, "harness-sync:error", {
             error: err instanceof Error ? err.message : String(err),
         });
@@ -966,7 +1080,7 @@ function createTodoEnforcerChatMessage(state) {
         // On user message, check previous assistant turn's counters
         // then reset for next turn
         if (state.toolCallCount > 3 && !state.todoWriteUsed) {
-            console.warn(`[opencode-immune] Todo Enforcer: ${state.toolCallCount} tool calls without TodoWrite. ` +
+            pluginLog.warn(`[opencode-immune] Todo Enforcer: ${state.toolCallCount} tool calls without TodoWrite. ` +
                 `Consider using todo list for multi-step tasks.`);
         }
         // Reset per-message counters for the next assistant turn
@@ -1008,47 +1122,36 @@ function createSessionRecoveryEvent(state) {
             }
             const markerActive = await isUltraworkMarkerActive(state);
             if (!markerActive) {
-                console.log(`[opencode-immune] Root session created (${sessionID}), no ultrawork marker — skipping auto-resume.`);
+                pluginLog.info(`[opencode-immune] Root session created (${sessionID}), no ultrawork marker — skipping auto-resume.`);
                 return;
             }
-            console.log(`[opencode-immune] Root session created (${sessionID}), ultrawork marker active — checking tasks.md...`);
+            pluginLog.info(`[opencode-immune] Root session created (${sessionID}), ultrawork marker active — checking tasks.md...`);
             const recovery = await parseTasksFile(state.input.directory);
             if (recovery) {
                 state.recoveryContext = recovery;
-                console.log(`[opencode-immune] Active task found: "${recovery.task}" (Level ${recovery.level}, Phase: ${recovery.phase})`);
+                pluginLog.info(`[opencode-immune] Active task found: "${recovery.task}" (Level ${recovery.level}, Phase: ${recovery.phase})`);
                 if (recovery.phase !== "ARCHIVE: DONE") {
                     // Register this root session as managed so retry/recovery works
                     await addManagedUltraworkSession(state, sessionID);
                     // Skip sending AUTO-RESUME if already sent from plugin init
                     if (state.autoResumeAttempted) {
-                        console.log(`[opencode-immune] Auto-resume already sent from plugin init, skipping duplicate for session ${sessionID}.`);
+                        pluginLog.info(`[opencode-immune] Auto-resume already sent from plugin init, skipping duplicate for session ${sessionID}.`);
                         return;
                     }
                     setTimeout(async () => {
                         try {
-                            await state.input.client.session.promptAsync({
-                                body: {
-                                    agent: ULTRAWORK_AGENT,
-                                    parts: [
-                                        {
-                                            type: "text",
-                                            text: `[AUTO-RESUME] Previous session was interrupted. Read memory-bank/tasks.md, check the Phase Status block, and continue the pipeline. Use ONLY the Phase Status block to determine the next phase. Do NOT analyze or evaluate the content of tasks.md. Call the appropriate router with the exact neutral prompt from your Step 5 table.`,
-                                        },
-                                    ],
-                                },
-                                path: { id: sessionID },
-                            });
-                            console.log(`[opencode-immune] Auto-resume prompt sent to managed ultrawork session ${sessionID}`);
+                            await promptManagedSession(state, sessionID, `[AUTO-RESUME] Previous session was interrupted. Read memory-bank/tasks.md, check the Phase Status block, and continue the pipeline. Use ONLY the Phase Status block to determine the next phase. Do NOT analyze or evaluate the content of tasks.md. Call the appropriate router with the exact neutral prompt from your Step 5 table.`);
+                            pluginLog.info(`[opencode-immune] Auto-resume prompt sent to managed ultrawork session ${sessionID}`);
                         }
                         catch (err) {
-                            console.log(`[opencode-immune] Auto-resume failed (session may have been taken over):`, err);
+                            pluginLog.info(`[opencode-immune] Auto-resume failed (session may have been taken over):`, err);
                         }
                     }, 3_000);
                 }
             }
             else {
                 state.recoveryContext = null;
-                console.log("[opencode-immune] No active task found.");
+                pluginLog.info("[opencode-immune] No active task found.");
             }
         }
     };
@@ -1130,7 +1233,7 @@ function createRalphLoopToolAfter(state) {
                 newString: input.args?.newString ?? "",
                 timestamp: Date.now(),
             };
-            console.warn(`[opencode-immune] Ralph Loop: Edit failed for "${state.lastEditAttempt.filePath}". ` +
+            pluginLog.warn(`[opencode-immune] Ralph Loop: Edit failed for "${state.lastEditAttempt.filePath}". ` +
                 `Recovery hint will be injected in next system transform.`);
         }
         else {
@@ -1157,7 +1260,7 @@ function createContextMonitorChatMessage(state) {
             if (state.approximateTokens >
                 ESTIMATED_CONTEXT_LIMIT * CONTEXT_WARNING_THRESHOLD) {
                 const pct = Math.round((state.approximateTokens / ESTIMATED_CONTEXT_LIMIT) * 100);
-                console.warn(`[opencode-immune] Context Monitor: ~${state.approximateTokens} tokens estimated (${pct}% of ~${ESTIMATED_CONTEXT_LIMIT}). ` +
+                pluginLog.warn(`[opencode-immune] Context Monitor: ~${state.approximateTokens} tokens estimated (${pct}% of ~${ESTIMATED_CONTEXT_LIMIT}). ` +
                     `Consider compacting the session.`);
             }
         }
@@ -1180,7 +1283,7 @@ function createCompactionHandler(state) {
             "After compaction, the agent should still be able to resume the current phase without re-reading all Memory Bank files.");
         // Reset token counter after compaction
         state.approximateTokens = 0;
-        console.log("[opencode-immune] Context Monitor: Compaction triggered, token counter reset.");
+        pluginLog.info("[opencode-immune] Context Monitor: Compaction triggered, token counter reset.");
     };
 }
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -1204,13 +1307,13 @@ function createCommentCheckerToolAfter(state) {
             return;
         // Check for emoji
         if (EMOJI_PATTERN.test(content)) {
-            console.warn(`[opencode-immune] Comment Checker: Emoji detected in ${input.tool} operation. ` +
+            pluginLog.warn(`[opencode-immune] Comment Checker: Emoji detected in ${input.tool} operation. ` +
                 `Avoid emojis in code unless the user explicitly requested them.`);
         }
         // Check for TODO/FIXME/HACK
         const todoMatch = content.match(TODO_PATTERN);
         if (todoMatch) {
-            console.warn(`[opencode-immune] Comment Checker: "${todoMatch[0]}" comment found in ${input.tool} operation. ` +
+            pluginLog.warn(`[opencode-immune] Comment Checker: "${todoMatch[0]}" comment found in ${input.tool} operation. ` +
                 `Consider resolving it or tracking it in the todo list.`);
         }
     };
@@ -1241,11 +1344,11 @@ function createKeywordDetectorChatMessage(_state) {
         if (!messageContent)
             return;
         if (ERROR_KEYWORDS.test(messageContent)) {
-            console.log(`[opencode-immune] Keyword Detector: Error-related keywords found. ` +
+            pluginLog.info(`[opencode-immune] Keyword Detector: Error-related keywords found. ` +
                 `Consider using 1-van to analyze the issue systematically.`);
         }
         if (DEPLOY_KEYWORDS.test(messageContent)) {
-            console.log(`[opencode-immune] Keyword Detector: Deploy/release keywords found. ` +
+            pluginLog.info(`[opencode-immune] Keyword Detector: Deploy/release keywords found. ` +
                 `Consider running 5-reflect first to verify implementation quality.`);
         }
     };
@@ -1274,28 +1377,17 @@ function createFallbackModels(state) {
                     const recovery = await parseTasksFile(state.input.directory);
                     if (recovery && recovery.phase !== "ARCHIVE: DONE") {
                         state.recoveryContext = recovery;
-                        console.log(`[opencode-immune] Auto-recovery on existing session: ` +
+                        pluginLog.info(`[opencode-immune] Auto-recovery on existing session: ` +
                             `task="${recovery.task}", level=${recovery.level}, phase=${recovery.phase}. ` +
                             `Sending AUTO-RESUME prompt in 3s...`);
                         const sid = input.sessionID;
                         setTimeout(async () => {
                             try {
-                                await state.input.client.session.promptAsync({
-                                    body: {
-                                        agent: ULTRAWORK_AGENT,
-                                        parts: [
-                                            {
-                                                type: "text",
-                                                text: `[AUTO-RESUME] Previous session was interrupted. Read memory-bank/tasks.md, check the Phase Status block, and continue the pipeline. Use ONLY the Phase Status block to determine the next phase. Do NOT analyze or evaluate the content of tasks.md. Call the appropriate router with the exact neutral prompt from your Step 5 table.`,
-                                            },
-                                        ],
-                                    },
-                                    path: { id: sid },
-                                });
-                                console.log(`[opencode-immune] Auto-resume prompt sent to session ${sid}`);
+                                await promptManagedSession(state, sid, `[AUTO-RESUME] Previous session was interrupted. Read memory-bank/tasks.md, check the Phase Status block, and continue the pipeline. Use ONLY the Phase Status block to determine the next phase. Do NOT analyze or evaluate the content of tasks.md. Call the appropriate router with the exact neutral prompt from your Step 5 table.`);
+                                pluginLog.info(`[opencode-immune] Auto-resume prompt sent to session ${sid}`);
                             }
                             catch (err) {
-                                console.log(`[opencode-immune] Auto-resume prompt failed:`, err);
+                                pluginLog.info(`[opencode-immune] Auto-resume prompt failed:`, err);
                             }
                         }, 3_000);
                     }
@@ -1314,7 +1406,7 @@ function createFallbackModels(state) {
         const providerId = input.provider?.info && "id" in input.provider.info
             ? input.provider.info.id
             : "unknown";
-        console.log(`[opencode-immune] Model Observer: agent="${input.agent}", ` +
+        pluginLog.info(`[opencode-immune] Model Observer: agent="${input.agent}", ` +
             `model="${modelId}", provider="${providerId}"`);
     };
 }
@@ -1352,7 +1444,7 @@ function createEventHandler(state) {
                 if (count < MAX_RETRIES && !state.sessionRetryTimers.has(fallbackSessionID)) {
                     const delay = Math.min(BASE_DELAY_MS * Math.pow(2, count), MAX_DELAY_MS);
                     state.sessionErrorRetryCount.set(fallbackSessionID, count + 1);
-                    console.warn(`[opencode-immune] session.error without sessionID matched retryable error. ` +
+                    pluginLog.warn(`[opencode-immune] session.error without sessionID matched retryable error. ` +
                         `Retrying sole managed root session ${fallbackSessionID}.`);
                     scheduleManagedSessionRetry(state, fallbackSessionID, {
                         delayMs: delay,
@@ -1377,7 +1469,7 @@ function createEventHandler(state) {
                 return;
             }
             if (state.sessionRetryTimers.has(sessionID)) {
-                console.log(`[opencode-immune] Retry already pending for ${isChild ? "child" : "root"} session ${sessionID}, skipping duplicate.`);
+                pluginLog.info(`[opencode-immune] Retry already pending for ${isChild ? "child" : "root"} session ${sessionID}, skipping duplicate.`);
                 return;
             }
             const count = state.sessionErrorRetryCount.get(sessionID) ?? 0;
@@ -1388,7 +1480,7 @@ function createEventHandler(state) {
                 // child after the router advances can create two writers in one pipeline.
                 if (isChild) {
                     recordChildFallbackRequest(state, managedSession, sessionID, error);
-                    console.log(`[opencode-immune] Child session ${sessionID}: retryable error detected. ` +
+                    pluginLog.info(`[opencode-immune] Child session ${sessionID}: retryable error detected. ` +
                         `Recorded router-owned fallback request and skipped plugin auto-retry.`);
                     state.sessionErrorRetryCount.set(sessionID, count);
                     return;
@@ -1396,7 +1488,7 @@ function createEventHandler(state) {
                 else if (isRoot && (isRateLimitApiError(error) || isCertificateApiError(error))) {
                     await setSessionFallbackModel(state, sessionID, RATE_LIMIT_FALLBACK_MODEL);
                     const errorType = isCertificateApiError(error) ? "certificate error" : "rate limit";
-                    console.log(`[opencode-immune] ${errorType} detected for root session ${sessionID}. ` +
+                    pluginLog.info(`[opencode-immune] ${errorType} detected for root session ${sessionID}. ` +
                         `Retry will use fallback model ${RATE_LIMIT_FALLBACK_MODEL.providerID}/${RATE_LIMIT_FALLBACK_MODEL.modelID}.`);
                 }
                 const scheduled = scheduleManagedSessionRetry(state, sessionID, {
@@ -1410,7 +1502,7 @@ function createEventHandler(state) {
                 }
             }
             else {
-                console.log(`[opencode-immune] Max retries (${MAX_RETRIES}) reached for ${isChild ? "child" : "root"} session ${sessionID}. Not retrying.`);
+                pluginLog.info(`[opencode-immune] Max retries (${MAX_RETRIES}) reached for ${isChild ? "child" : "root"} session ${sessionID}. Not retrying.`);
             }
         }
         // Reset retry counter on successful activity
@@ -1440,7 +1532,7 @@ function createEventHandler(state) {
             "file.edited",
         ];
         if (significantEvents.includes(eventType)) {
-            console.log(`[opencode-immune] Event: ${eventType}`);
+            pluginLog.info(`[opencode-immune] Event: ${eventType}`);
         }
     };
 }
@@ -1466,7 +1558,7 @@ async function archiveProgress(directory) {
         const content = await (0, promises_1.readFile)(progressPath, "utf-8");
         // Skip if empty or trivially empty
         if (!content.trim() || content.trim() === "# Progress") {
-            console.log("[opencode-immune] Archive progress: nothing to archive (empty).");
+            pluginLog.info("[opencode-immune] Archive progress: nothing to archive (empty).");
             return;
         }
         const archiveDir = (0, path_1.join)(directory, "memory-bank", "archive");
@@ -1477,13 +1569,13 @@ async function archiveProgress(directory) {
         const archiveName = `progress-${dateStr}-${ts}.md`;
         const archivePath = (0, path_1.join)(archiveDir, archiveName);
         await (0, promises_1.rename)(progressPath, archivePath);
-        console.log(`[opencode-immune] Archive progress: moved to ${archiveName}`);
+        pluginLog.info(`[opencode-immune] Archive progress: moved to ${archiveName}`);
     }
     catch (err) {
         // File doesn't exist or move failed — not critical
         const msg = err instanceof Error ? err.message : String(err);
         if (!msg.includes("ENOENT")) {
-            console.warn("[opencode-immune] Archive progress failed:", msg);
+            pluginLog.warn("[opencode-immune] Archive progress failed:", msg);
         }
     }
 }
@@ -1529,7 +1621,7 @@ function runGitCommit(directory) {
         // Stage all changes
         (0, child_process_1.execFile)("git", ["add", "-A"], { cwd: directory }, (addErr) => {
             if (addErr) {
-                console.error("[opencode-immune] git add failed:", addErr.message);
+                pluginLog.error("[opencode-immune] git add failed:", addErr.message);
                 resolve(false);
                 return;
             }
@@ -1540,15 +1632,15 @@ function runGitCommit(directory) {
                 (0, child_process_1.execFile)("git", ["commit", "-m", message], { cwd: directory }, (commitErr, stdout, stderr) => {
                     if (commitErr) {
                         if (stderr?.includes("nothing to commit") || stdout?.includes("nothing to commit")) {
-                            console.log("[opencode-immune] git commit: nothing to commit (clean tree).");
+                            pluginLog.info("[opencode-immune] git commit: nothing to commit (clean tree).");
                             resolve(true);
                             return;
                         }
-                        console.error("[opencode-immune] git commit failed:", commitErr.message, stderr);
+                        pluginLog.error("[opencode-immune] git commit failed:", commitErr.message, stderr);
                         resolve(false);
                         return;
                     }
-                    console.log("[opencode-immune] git commit succeeded:", stdout?.trim());
+                    pluginLog.info("[opencode-immune] git commit succeeded:", stdout?.trim());
                     resolve(true);
                 });
             });
@@ -1583,25 +1675,25 @@ function createTextCompleteHandler(state) {
                 countAgainstBudget: false,
                 abortBeforePrompt: true,
             });
-            console.log(`[opencode-immune] Provider retry banner detected for session ${sessionID}. ` +
+            pluginLog.info(`[opencode-immune] Provider retry banner detected for session ${sessionID}. ` +
                 `Fallback model pinned to ${fallbackModel.providerID}/${fallbackModel.modelID}.`);
         }
         // ── ALL_CYCLES_COMPLETE: clear ultrawork marker ──
         if (text.includes(ALL_CYCLES_COMPLETE_MARKER)) {
             await clearUltraworkMarker(state);
-            console.log("[opencode-immune] Multi-Cycle: ALL_CYCLES_COMPLETE detected, marker cleared.");
+            pluginLog.info("[opencode-immune] Multi-Cycle: ALL_CYCLES_COMPLETE detected, marker cleared.");
             return;
         }
         // ── PRE_COMMIT only (without CYCLE_COMPLETE in same part): run commit ──
         if (text.includes(PRE_COMMIT_MARKER) && !text.includes(CYCLE_COMPLETE_MARKER)) {
             if (!state.commitPending) {
                 state.commitPending = true;
-                console.log("[opencode-immune] Multi-Cycle: PRE_COMMIT detected (standalone), running git commit...");
+                pluginLog.info("[opencode-immune] Multi-Cycle: PRE_COMMIT detected (standalone), running git commit...");
                 try {
                     await runGitCommit(state.input.directory);
                 }
                 catch (err) {
-                    console.error("[opencode-immune] Multi-Cycle: git commit failed (standalone):", err);
+                    pluginLog.error("[opencode-immune] Multi-Cycle: git commit failed (standalone):", err);
                 }
                 finally {
                     state.commitPending = false;
@@ -1616,18 +1708,18 @@ function createTextCompleteHandler(state) {
                 await archiveProgress(state.input.directory);
             }
             catch (err) {
-                console.warn("[opencode-immune] Multi-Cycle: archive progress failed:", err);
+                pluginLog.warn("[opencode-immune] Multi-Cycle: archive progress failed:", err);
             }
             // Step 1: Always commit first
             if (!state.commitPending) {
                 state.commitPending = true;
-                console.log("[opencode-immune] Multi-Cycle: CYCLE_COMPLETE detected, running git commit first...");
+                pluginLog.info("[opencode-immune] Multi-Cycle: CYCLE_COMPLETE detected, running git commit first...");
                 try {
                     await runGitCommit(state.input.directory);
-                    console.log("[opencode-immune] Multi-Cycle: git commit completed before new cycle.");
+                    pluginLog.info("[opencode-immune] Multi-Cycle: git commit completed before new cycle.");
                 }
                 catch (err) {
-                    console.error("[opencode-immune] Multi-Cycle: git commit failed (continuing anyway):", err);
+                    pluginLog.error("[opencode-immune] Multi-Cycle: git commit failed (continuing anyway):", err);
                 }
                 finally {
                     state.commitPending = false;
@@ -1636,43 +1728,25 @@ function createTextCompleteHandler(state) {
             // Step 2: Create new session
             state.cycleCount++;
             if (state.cycleCount >= MAX_CYCLES) {
-                console.log(`[opencode-immune] Multi-Cycle: MAX_CYCLES (${MAX_CYCLES}) reached. Not creating new session.`);
+                pluginLog.info(`[opencode-immune] Multi-Cycle: MAX_CYCLES (${MAX_CYCLES}) reached. Not creating new session.`);
                 await clearUltraworkMarker(state);
                 return;
             }
             const taskMatch = text.match(NEXT_TASK_PATTERN);
             const nextTask = taskMatch?.[1]?.trim() ?? "Continue processing task backlog";
-            console.log(`[opencode-immune] Multi-Cycle: Creating new session (cycle ${state.cycleCount}/${MAX_CYCLES}) for: "${nextTask}"`);
+            pluginLog.info(`[opencode-immune] Multi-Cycle: Creating new session (cycle ${state.cycleCount}/${MAX_CYCLES}) for: "${nextTask}"`);
             try {
-                const createResult = await state.input.client.session.create({
-                    body: {
-                        title: `Ultrawork Cycle ${state.cycleCount + 1}`,
-                    },
-                });
-                const newSessionData = createResult?.data;
-                const newSessionID = newSessionData?.id;
+                const newSessionID = await createManagedUltraworkSession(state, `Ultrawork Cycle ${state.cycleCount + 1}`);
                 if (!newSessionID) {
-                    console.error("[opencode-immune] Multi-Cycle: Failed to create new session — no ID returned.");
+                    pluginLog.error("[opencode-immune] Multi-Cycle: Failed to create new session — no ID returned.");
                     return;
                 }
-                console.log(`[opencode-immune] Multi-Cycle: New session created: ${newSessionID}`);
-                await addManagedUltraworkSession(state, newSessionID);
-                await state.input.client.session.promptAsync({
-                    body: {
-                        agent: ULTRAWORK_AGENT,
-                        parts: [
-                            {
-                                type: "text",
-                                text: `[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.`,
-                            },
-                        ],
-                    },
-                    path: { id: newSessionID },
-                });
-                console.log(`[opencode-immune] Multi-Cycle: Bootstrap prompt sent to ${newSessionID}`);
+                pluginLog.info(`[opencode-immune] Multi-Cycle: New session created: ${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.`);
+                pluginLog.info(`[opencode-immune] Multi-Cycle: Bootstrap prompt sent to ${newSessionID}`);
             }
             catch (err) {
-                console.error("[opencode-immune] Multi-Cycle: Failed to create session or send prompt:", err);
+                pluginLog.error("[opencode-immune] Multi-Cycle: Failed to create session or send prompt:", err);
             }
         }
     };
@@ -1705,7 +1779,7 @@ function createMultiCycleHandler(state) {
             RATE_LIMIT_MESSAGE_PATTERN.test(messageContent)) {
             if (managedSession && !managedSession.fallbackModel) {
                 await setSessionFallbackModel(state, sessionID, RATE_LIMIT_FALLBACK_MODEL);
-                console.log(`[opencode-immune] Rate limit message detected in chat output for session ${sessionID}. ` +
+                pluginLog.info(`[opencode-immune] Rate limit message detected in chat output for session ${sessionID}. ` +
                     `Fallback model pinned to ${RATE_LIMIT_FALLBACK_MODEL.providerID}/${RATE_LIMIT_FALLBACK_MODEL.modelID}.`);
             }
             if (managedSession) {
@@ -1719,6 +1793,19 @@ function createMultiCycleHandler(state) {
         }
     };
 }
+function createPermissionAskHandler(state) {
+    return async (input, output) => {
+        const sessionID = input.sessionID;
+        if (!isManagedUltraworkSession(state, sessionID))
+            return;
+        output.status = "allow";
+        await writeDiagnosticLog(state, "permission:auto-allow", {
+            sessionID,
+            permission: input.permission,
+            patterns: input.patterns,
+        });
+    };
+}
 // ═══════════════════════════════════════════════════════════════════════════════
 // PLUGIN MODULE EXPORT
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -1730,7 +1817,7 @@ async function server(input) {
     // Runs in background so it doesn't delay plugin initialization.
     // If sync fails, plugin continues normally with existing config.
     syncHarness(state).catch((err) => {
-        console.warn(`[opencode-immune] Harness sync background error:`, err instanceof Error ? err.message : String(err));
+        pluginLog.warn(`[opencode-immune] Harness sync background error:`, err instanceof Error ? err.message : String(err));
     });
     // Eagerly load recovery context at plugin init so it's available
     // for the very first system.transform call (before chat.params fires).
@@ -1741,42 +1828,24 @@ async function server(input) {
             // Active task exists with incomplete phases — resume it
             state.recoveryContext = recovery;
             state.autoResumeAttempted = true;
-            console.log(`[opencode-immune] Plugin init: ultrawork marker active, recovery context loaded: ` +
+            pluginLog.info(`[opencode-immune] Plugin init: ultrawork marker active, recovery context loaded: ` +
                 `task="${recovery.task}", level=${recovery.level}, phase=${recovery.phase}. ` +
                 `Will create new session and send AUTO-RESUME.`);
             // Create a new session and send AUTO-RESUME prompt (same pattern as CYCLE_COMPLETE).
             // Delay to let opencode fully initialize.
             setTimeout(async () => {
                 try {
-                    const createResult = await state.input.client.session.create({
-                        body: {
-                            title: `AUTO-RESUME: ${recovery.task}`,
-                        },
-                    });
-                    const newSessionData = createResult?.data;
-                    const newSessionID = newSessionData?.id;
+                    const newSessionID = await createManagedUltraworkSession(state, `AUTO-RESUME: ${recovery.task}`);
                     if (!newSessionID) {
-                        console.error("[opencode-immune] Auto-resume: Failed to create session — no session ID returned.");
+                        pluginLog.error("[opencode-immune] Auto-resume: Failed to create session — no session ID returned.");
                         return;
                     }
-                    console.log(`[opencode-immune] Auto-resume: New session created: ${newSessionID}`);
-                    await addManagedUltraworkSession(state, newSessionID);
-                    await state.input.client.session.promptAsync({
-                        body: {
-                            agent: ULTRAWORK_AGENT,
-                            parts: [
-                                {
-                                    type: "text",
-                                    text: `[AUTO-RESUME] Previous session was interrupted. Read memory-bank/tasks.md, check the Phase Status block, and continue the pipeline. Use ONLY the Phase Status block to determine the next phase. Do NOT analyze or evaluate the content of tasks.md. Call the appropriate router with the exact neutral prompt from your Step 5 table.`,
-                                },
-                            ],
-                        },
-                        path: { id: newSessionID },
-                    });
-                    console.log(`[opencode-immune] Auto-resume prompt sent to new session ${newSessionID}`);
+                    pluginLog.info(`[opencode-immune] Auto-resume: New session created: ${newSessionID}`);
+                    await promptManagedSession(state, newSessionID, `[AUTO-RESUME] Previous session was interrupted. Read memory-bank/tasks.md, check the Phase Status block, and continue the pipeline. Use ONLY the Phase Status block to determine the next phase. Do NOT analyze or evaluate the content of tasks.md. Call the appropriate router with the exact neutral prompt from your Step 5 table.`);
+                    pluginLog.info(`[opencode-immune] Auto-resume prompt sent to new session ${newSessionID}`);
                 }
                 catch (err) {
-                    console.error("[opencode-immune] Auto-resume: Failed to create session or send prompt:", err);
+                    pluginLog.error("[opencode-immune] Auto-resume: Failed to create session or send prompt:", err);
                 }
             }, 5_000);
         }
@@ -1788,56 +1857,38 @@ async function server(input) {
                 const hasPendingTasks = /- \[ \]/.test(backlogContent);
                 if (hasPendingTasks) {
                     state.autoResumeAttempted = true;
-                    console.log(`[opencode-immune] Plugin init: no active task but backlog has pending items. ` +
+                    pluginLog.info(`[opencode-immune] Plugin init: no active task but backlog has pending items. ` +
                         `Will create new session to start next cycle.`);
                     setTimeout(async () => {
                         try {
-                            const createResult = await state.input.client.session.create({
-                                body: {
-                                    title: `AUTO-CYCLE: next backlog task`,
-                                },
-                            });
-                            const newSessionData = createResult?.data;
-                            const newSessionID = newSessionData?.id;
+                            const newSessionID = await createManagedUltraworkSession(state, `AUTO-CYCLE: next backlog task`);
                             if (!newSessionID) {
-                                console.error("[opencode-immune] Auto-cycle: Failed to create session — no session ID returned.");
+                                pluginLog.error("[opencode-immune] Auto-cycle: Failed to create session — no session ID returned.");
                                 return;
                             }
-                            console.log(`[opencode-immune] Auto-cycle: New session created: ${newSessionID}`);
-                            await addManagedUltraworkSession(state, newSessionID);
-                            await state.input.client.session.promptAsync({
-                                body: {
-                                    agent: ULTRAWORK_AGENT,
-                                    parts: [
-                                        {
-                                            type: "text",
-                                            text: `[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.`,
-                                        },
-                                    ],
-                                },
-                                path: { id: newSessionID },
-                            });
-                            console.log(`[opencode-immune] Auto-cycle prompt sent to new session ${newSessionID}`);
+                            pluginLog.info(`[opencode-immune] Auto-cycle: New session created: ${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.`);
+                            pluginLog.info(`[opencode-immune] Auto-cycle prompt sent to new session ${newSessionID}`);
                         }
                         catch (err) {
-                            console.error("[opencode-immune] Auto-cycle: Failed to create session or send prompt:", err);
+                            pluginLog.error("[opencode-immune] Auto-cycle: Failed to create session or send prompt:", err);
                         }
                     }, 5_000);
                 }
                 else {
                     // No active task and no pending backlog — clear marker
                     await clearUltraworkMarker(state);
-                    console.log(`[opencode-immune] Plugin init: no active task and no pending backlog. Marker cleared.`);
+                    pluginLog.info(`[opencode-immune] Plugin init: no active task and no pending backlog. Marker cleared.`);
                 }
             }
             catch {
                 // backlog.md doesn't exist or can't be read — clear marker
                 await clearUltraworkMarker(state);
-                console.log(`[opencode-immune] Plugin init: no active task, backlog unreadable. Marker cleared.`);
+                pluginLog.info(`[opencode-immune] Plugin init: no active task, backlog unreadable. Marker cleared.`);
             }
         }
     }
-    console.log(`[opencode-immune] Plugin initialized. Directory: ${input.directory}`);
+    pluginLog.info(`[opencode-immune] Plugin initialized. Directory: ${input.directory}`);
     // Compose tool.execute.after handlers:
     // Todo Enforcer (counter) + Ralph Loop (edit error) + Comment Checker
     const toolAfterHandlers = [
@@ -1854,13 +1905,14 @@ async function server(input) {
         createMultiCycleHandler(state),
     ];
     return {
-        event: withErrorBoundary("event", createEventHandler(state)),
-        "chat.message": withErrorBoundary("chat.message", compositeChatMessage(chatMessageHandlers)),
-        "chat.params": withErrorBoundary("chat.params", createFallbackModels(state)),
-        "tool.execute.after": withErrorBoundary("tool.execute.after", compositeToolAfter(toolAfterHandlers)),
-        "experimental.chat.system.transform": withErrorBoundary("experimental.chat.system.transform", createSystemTransform(state)),
-        "experimental.session.compacting": withErrorBoundary("experimental.session.compacting", createCompactionHandler(state)),
-        "experimental.text.complete": withErrorBoundary("experimental.text.complete", createTextCompleteHandler(state)),
+        event: withErrorBoundary(state, "event", createEventHandler(state)),
+        "chat.message": withErrorBoundary(state, "chat.message", compositeChatMessage(chatMessageHandlers)),
+        "chat.params": withErrorBoundary(state, "chat.params", createFallbackModels(state)),
+        "tool.execute.after": withErrorBoundary(state, "tool.execute.after", compositeToolAfter(toolAfterHandlers)),
+        "experimental.chat.system.transform": withErrorBoundary(state, "experimental.chat.system.transform", createSystemTransform(state)),
+        "experimental.session.compacting": withErrorBoundary(state, "experimental.session.compacting", createCompactionHandler(state)),
+        "experimental.text.complete": withErrorBoundary(state, "experimental.text.complete", createTextCompleteHandler(state)),
+        "permission.ask": withErrorBoundary(state, "permission.ask", createPermissionAskHandler(state)),
     };
 }
 exports.default = {

package/package.json

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