opencode-immune 1.0.0

package/dist/plugin.js

@@ -0,0 +1,786 @@
+"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 promises_1 = require("fs/promises");
+const path_1 = require("path");
+function createState(input) {
+    return {
+        input,
+        recoveryContext: null,
+        managedUltraworkSessions: new Map(),
+        retryTimers: new Map(),
+        retryCount: new Map(),
+        managedSessionsCachePath: (0, path_1.join)(input.directory, ".opencode", "state", "opencode-immune-managed-sessions.json"),
+        lastEditAttempt: null,
+        toolCallCount: 0,
+        todoWriteUsed: false,
+        approximateTokens: 0,
+        sessionActive: false,
+        cycleCount: 0,
+        commitPending: false,
+    };
+}
+const ULTRAWORK_AGENT = "0-ultrawork";
+const MANAGED_SESSION_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+function isManagedUltraworkSession(state, sessionID) {
+    return !!sessionID && state.managedUltraworkSessions.has(sessionID);
+}
+function pruneExpiredManagedSessions(state, now = Date.now()) {
+    let removed = 0;
+    for (const [sessionID, record] of state.managedUltraworkSessions.entries()) {
+        if (now - record.updatedAt <= MANAGED_SESSION_TTL_MS) {
+            continue;
+        }
+        cancelRetry(state, sessionID, "managed session TTL expired");
+        state.retryCount.delete(sessionID);
+        state.managedUltraworkSessions.delete(sessionID);
+        removed++;
+    }
+    return removed;
+}
+async function writeManagedSessionsCache(state) {
+    const removed = pruneExpiredManagedSessions(state);
+    const cacheDir = (0, path_1.join)(state.input.directory, ".opencode", "state");
+    const tempPath = `${state.managedSessionsCachePath}.tmp`;
+    const payload = {
+        version: 1,
+        sessions: Object.fromEntries(state.managedUltraworkSessions.entries()),
+    };
+    await (0, promises_1.mkdir)(cacheDir, { recursive: true });
+    await (0, promises_1.writeFile)(tempPath, JSON.stringify(payload, null, 2), "utf-8");
+    await (0, promises_1.rename)(tempPath, state.managedSessionsCachePath);
+    if (removed > 0) {
+        console.log(`[opencode-immune] Pruned ${removed} expired managed ultrawork session(s) while writing cache.`);
+    }
+}
+async function loadManagedSessionsCache(state) {
+    try {
+        const raw = await (0, promises_1.readFile)(state.managedSessionsCachePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== 1 || !parsed.sessions) {
+            console.warn(`[opencode-immune] Managed sessions cache at ${state.managedSessionsCachePath} has unsupported format. Ignoring.`);
+            return;
+        }
+        for (const [sessionID, record] of Object.entries(parsed.sessions)) {
+            if (!record || record.agent !== ULTRAWORK_AGENT)
+                continue;
+            state.managedUltraworkSessions.set(sessionID, {
+                agent: ULTRAWORK_AGENT,
+                createdAt: typeof record.createdAt === "number" ? record.createdAt : Date.now(),
+                updatedAt: typeof record.updatedAt === "number" ? record.updatedAt : Date.now(),
+            });
+        }
+        const removed = pruneExpiredManagedSessions(state);
+        console.log(`[opencode-immune] Loaded ${state.managedUltraworkSessions.size} managed ultrawork session(s) from cache.`);
+        if (removed > 0) {
+            console.log(`[opencode-immune] Pruned ${removed} expired managed ultrawork session(s) on startup.`);
+            await writeManagedSessionsCache(state);
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes("ENOENT"))
+            return;
+        console.warn(`[opencode-immune] Failed to read managed sessions cache. Starting fresh.`);
+    }
+}
+async function addManagedUltraworkSession(state, sessionID, timestamp = Date.now()) {
+    const existing = state.managedUltraworkSessions.get(sessionID);
+    const nextRecord = {
+        agent: ULTRAWORK_AGENT,
+        createdAt: existing?.createdAt ?? timestamp,
+        updatedAt: timestamp,
+    };
+    if (existing &&
+        existing.agent === nextRecord.agent &&
+        existing.createdAt === nextRecord.createdAt &&
+        existing.updatedAt === nextRecord.updatedAt) {
+        return;
+    }
+    state.managedUltraworkSessions.set(sessionID, nextRecord);
+    await writeManagedSessionsCache(state);
+}
+function cancelRetry(state, sessionID, reason) {
+    const timer = state.retryTimers.get(sessionID);
+    if (!timer)
+        return;
+    clearTimeout(timer);
+    state.retryTimers.delete(sessionID);
+    console.log(`[opencode-immune] Cancelled pending retry for session ${sessionID}: ${reason}`);
+}
+async function removeManagedUltraworkSession(state, sessionID, reason) {
+    cancelRetry(state, sessionID, reason);
+    state.retryCount.delete(sessionID);
+    const existed = state.managedUltraworkSessions.delete(sessionID);
+    if (!existed)
+        return;
+    await writeManagedSessionsCache(state);
+    console.log(`[opencode-immune] Removed managed ultrawork session ${sessionID}: ${reason}`);
+}
+function markUltraworkSessionActive(state, sessionID) {
+    const existing = state.managedUltraworkSessions.get(sessionID);
+    if (!existing)
+        return false;
+    const nextUpdatedAt = Date.now();
+    if (existing.updatedAt === nextUpdatedAt) {
+        return false;
+    }
+    state.managedUltraworkSessions.set(sessionID, {
+        ...existing,
+        updatedAt: nextUpdatedAt,
+    });
+    return true;
+}
+function isRetryableApiError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const maybeError = error;
+    return (maybeError.name === "APIError" &&
+        maybeError.data?.isRetryable === true);
+}
+// ═══════════════════════════════════════════════════════════════════════════════
+// UTILITY: ERROR BOUNDARY
+// ═══════════════════════════════════════════════════════════════════════════════
+/**
+ * Wraps a hook handler in a try/catch to prevent any single hook failure
+ * from crashing the entire agent session.
+ */
+function withErrorBoundary(hookName, handler) {
+    return (async (...args) => {
+        try {
+            return await handler(...args);
+        }
+        catch (err) {
+            console.error(`[opencode-immune] Hook "${hookName}" error:`, err);
+            // Error is swallowed — hook failure must not crash agent session
+        }
+    });
+}
+// ═══════════════════════════════════════════════════════════════════════════════
+// UTILITY: HOOK COMPOSITION
+// ═══════════════════════════════════════════════════════════════════════════════
+/**
+ * Composes multiple tool.execute.after handlers into a single handler.
+ * Needed because the plugin API provides one slot per hook name,
+ * but we have Todo Enforcer + Ralph Loop + Comment Checker sharing it.
+ */
+function compositeToolAfter(handlers) {
+    return async (input, output) => {
+        for (const handler of handlers) {
+            await handler(input, output);
+        }
+    };
+}
+/**
+ * Composes multiple chat.message handlers into a single handler.
+ * Needed for Todo Enforcer check + Keyword Detector + Context Monitor.
+ */
+function compositeChatMessage(handlers) {
+    return async (input, output) => {
+        for (const handler of handlers) {
+            await handler(input, output);
+        }
+    };
+}
+// ═══════════════════════════════════════════════════════════════════════════════
+// UTILITY: TASKS.MD PARSER
+// ═══════════════════════════════════════════════════════════════════════════════
+/**
+ * Reads and parses memory-bank/tasks.md to extract active task metadata.
+ * Used by Session Recovery and potentially other hooks.
+ * Returns null if file doesn't exist or has no active task.
+ */
+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");
+        // Check for active task
+        if (!content.includes("## Active Task") ||
+            content.includes("No active tasks")) {
+            return null;
+        }
+        // Extract task name
+        const taskMatch = content.match(/- \*\*Task\*\*:\s*(.+)/);
+        const task = taskMatch?.[1]?.trim() ?? "Unknown task";
+        // Extract level
+        const levelMatch = content.match(/- \*\*Level\*\*:\s*(\d+)/);
+        const level = levelMatch?.[1] ?? "?";
+        // Extract intent (may not exist for legacy tasks)
+        const intentMatch = content.match(/- \*\*Intent\*\*:\s*(\w+)/);
+        const intent = intentMatch?.[1];
+        // Extract category (may not exist for legacy tasks)
+        const categoryMatch = content.match(/- \*\*Category\*\*:\s*(\w+)/);
+        const category = categoryMatch?.[1];
+        // Extract Phase Status block
+        const phaseStatusMatch = content.match(/<!-- PHASE_STATUS_START -->([\s\S]*?)<!-- PHASE_STATUS_END -->/);
+        const phaseStatus = phaseStatusMatch?.[1]?.trim() ?? "Unknown";
+        // Find current phase (first IN_PROGRESS or first NOT_STARTED)
+        let currentPhase = "UNKNOWN";
+        const phaseLines = phaseStatus.split("\n");
+        for (const line of phaseLines) {
+            if (line.includes("IN_PROGRESS")) {
+                const match = line.match(/- (\w+): IN_PROGRESS/);
+                if (match) {
+                    currentPhase = match[1];
+                    break;
+                }
+            }
+        }
+        if (currentPhase === "UNKNOWN") {
+            for (const line of phaseLines) {
+                if (line.includes("NOT_STARTED")) {
+                    const match = line.match(/- (\w+): NOT_STARTED/);
+                    if (match) {
+                        currentPhase = match[1];
+                        break;
+                    }
+                }
+            }
+        }
+        return {
+            task,
+            level,
+            phase: currentPhase,
+            phaseStatus,
+            intent,
+            category,
+        };
+    }
+    catch {
+        // File doesn't exist or can't be read — that's fine
+        return null;
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════════════
+// HOOK 1: TODO ENFORCER
+// ═══════════════════════════════════════════════════════════════════════════════
+/**
+ * tool.execute.after part: counts tool calls and flags todowrite usage.
+ * Per-message counters are reset by the chat.message handler.
+ */
+function createTodoEnforcerToolAfter(state) {
+    return async (input, _output) => {
+        state.toolCallCount++;
+        if (input.tool === "todowrite" || input.tool === "TodoWrite") {
+            state.todoWriteUsed = true;
+        }
+    };
+}
+/**
+ * chat.message part: checks if multi-step work happened without todo list.
+ * Also resets per-message counters for the next assistant turn.
+ */
+function createTodoEnforcerChatMessage(state) {
+    return async (input, _output) => {
+        const sessionID = input.sessionID;
+        const agent = input.agent;
+        if (sessionID && agent === ULTRAWORK_AGENT) {
+            await addManagedUltraworkSession(state, sessionID);
+        }
+        else if (sessionID && agent && isManagedUltraworkSession(state, sessionID)) {
+            await removeManagedUltraworkSession(state, sessionID, `session taken over by agent \"${agent}\"`);
+        }
+        // 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. ` +
+                `Consider using todo list for multi-step tasks.`);
+        }
+        // Reset per-message counters for the next assistant turn
+        state.toolCallCount = 0;
+        state.todoWriteUsed = false;
+    };
+}
+// ═══════════════════════════════════════════════════════════════════════════════
+// HOOK 2: SESSION RECOVERY
+// ═══════════════════════════════════════════════════════════════════════════════
+/**
+ * event handler: detects session.create and reads tasks.md for recovery context.
+ * If an active task with incomplete phases is found, automatically sends
+ * a resume prompt ONLY to managed ultrawork sessions.
+ */
+function createSessionRecoveryEvent(state) {
+    return async (input) => {
+        const event = input.event;
+        const eventType = event.type ?? "";
+        if (eventType === "session.created") {
+            state.sessionActive = true;
+            const sessionInfo = event.properties?.info;
+            const sessionID = sessionInfo?.id ?? event.properties?.sessionID;
+            if (!isManagedUltraworkSession(state, sessionID)) {
+                return;
+            }
+            console.log(`[opencode-immune] Managed ultrawork session created, checking for active task...`);
+            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})`);
+                if (sessionID && recovery.phase !== "ARCHIVE: DONE") {
+                    setTimeout(async () => {
+                        try {
+                            if (!isManagedUltraworkSession(state, sessionID)) {
+                                return;
+                            }
+                            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}`);
+                        }
+                        catch (err) {
+                            console.log(`[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.");
+            }
+        }
+    };
+}
+/**
+ * experimental.chat.system.transform: injects recovery context if active task exists.
+ * Also injects Ralph Loop hints if a previous edit failed.
+ */
+function createSystemTransform(state) {
+    return async (input, output) => {
+        // Session Recovery injection
+        if (state.recoveryContext && isManagedUltraworkSession(state, input.sessionID)) {
+            const ctx = state.recoveryContext;
+            const intentInfo = ctx.intent ? `, Intent: ${ctx.intent}` : "";
+            const categoryInfo = ctx.category ? `, Category: ${ctx.category}` : "";
+            output.system.push(`[Session Recovery] Active Memory Bank task detected:\n` +
+                `- Task: ${ctx.task}\n` +
+                `- Level: ${ctx.level}${intentInfo}${categoryInfo}\n` +
+                `- Current Phase: ${ctx.phase}\n` +
+                `- Phase Status:\n${ctx.phaseStatus}\n` +
+                `Read memory-bank/tasks.md and memory-bank/activeContext.md to resume work.`);
+        }
+        // Ralph Loop injection
+        if (state.lastEditAttempt) {
+            const edit = state.lastEditAttempt;
+            output.system.push(`[Edit Error Recovery] Previous edit failed for "${edit.filePath}". ` +
+                `The oldString was not found in the file. ` +
+                `Read the file first to get the correct content, then retry the edit with the exact oldString from the file.`);
+            // Clear after injection to avoid repeated hints
+            state.lastEditAttempt = null;
+        }
+    };
+}
+// ═══════════════════════════════════════════════════════════════════════════════
+// HOOK 3: RALPH LOOP (EDIT ERROR RECOVERY)
+// ═══════════════════════════════════════════════════════════════════════════════
+/**
+ * tool.execute.after: detects failed edit operations and stores context for recovery.
+ */
+function createRalphLoopToolAfter(state) {
+    return async (input, output) => {
+        if (input.tool !== "edit")
+            return;
+        // Check if the edit failed with "oldString not found"
+        const outputText = typeof output.output === "string" ? output.output : "";
+        if (outputText.includes("oldString not found") ||
+            outputText.includes("Found multiple matches")) {
+            state.lastEditAttempt = {
+                filePath: input.args?.filePath ?? "unknown",
+                oldString: input.args?.oldString ?? "",
+                newString: input.args?.newString ?? "",
+                timestamp: Date.now(),
+            };
+            console.warn(`[opencode-immune] Ralph Loop: Edit failed for "${state.lastEditAttempt.filePath}". ` +
+                `Recovery hint will be injected in next system transform.`);
+        }
+        else {
+            // Successful edit clears any pending recovery
+            state.lastEditAttempt = null;
+        }
+    };
+}
+// ═══════════════════════════════════════════════════════════════════════════════
+// HOOK 4: CONTEXT WINDOW MONITOR
+// ═══════════════════════════════════════════════════════════════════════════════
+const ESTIMATED_CONTEXT_LIMIT = 128000; // tokens (approximate for most models)
+const CONTEXT_WARNING_THRESHOLD = 0.8; // 80%
+/**
+ * chat.message part: estimates token count from message parts.
+ */
+function createContextMonitorChatMessage(state) {
+    return async (_input, output) => {
+        // Rough token estimate: stringify parts, divide by 4
+        try {
+            const partsStr = JSON.stringify(output.parts ?? []);
+            const estimatedTokens = Math.ceil(partsStr.length / 4);
+            state.approximateTokens += estimatedTokens;
+            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}). ` +
+                    `Consider compacting the session.`);
+            }
+        }
+        catch {
+            // Token estimation is best-effort
+        }
+    };
+}
+/**
+ * experimental.session.compacting: provides Memory Bank-aware compaction context.
+ */
+function createCompactionHandler(state) {
+    return async (_input, output) => {
+        output.context.push("IMPORTANT: During compaction, preserve the following Memory Bank context:\n" +
+            "1. The current task from memory-bank/tasks.md (task name, level, intent, category)\n" +
+            "2. The Phase Status block (which phases are DONE/IN_PROGRESS/NOT_STARTED)\n" +
+            "3. The active pipeline log entries from the current phase\n" +
+            "4. Any file paths that were recently modified or are actively being worked on\n" +
+            "5. Key architectural decisions from memory-bank/activeContext.md\n" +
+            "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.");
+    };
+}
+// ═══════════════════════════════════════════════════════════════════════════════
+// HOOK 5: COMMENT CHECKER
+// ═══════════════════════════════════════════════════════════════════════════════
+// Simple emoji detection regex (covers most common Unicode emoji ranges)
+const EMOJI_PATTERN = /[\u{1F600}-\u{1F64F}\u{1F300}-\u{1F5FF}\u{1F680}-\u{1F6FF}\u{1F1E0}-\u{1F1FF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}\u{FE00}-\u{FE0F}\u{1F900}-\u{1F9FF}\u{1FA00}-\u{1FA6F}\u{1FA70}-\u{1FAFF}\u{200D}\u{20E3}]/u;
+const TODO_PATTERN = /\b(TODO|FIXME|HACK|XXX)\b/i;
+/**
+ * tool.execute.after: checks edit/write content for emoji and TODO comments.
+ */
+function createCommentCheckerToolAfter(state) {
+    return async (input, _output) => {
+        if (input.tool !== "edit" && input.tool !== "write")
+            return;
+        // Get the content being written
+        const content = input.tool === "edit"
+            ? input.args?.newString ?? ""
+            : input.args?.content ?? "";
+        if (!content)
+            return;
+        // Check for emoji
+        if (EMOJI_PATTERN.test(content)) {
+            console.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. ` +
+                `Consider resolving it or tracking it in the todo list.`);
+        }
+    };
+}
+// ═══════════════════════════════════════════════════════════════════════════════
+// HOOK 6: KEYWORD DETECTOR
+// ═══════════════════════════════════════════════════════════════════════════════
+const ERROR_KEYWORDS = /\b(error|bug|broken|not working|не работает|сломал|ошибка|баг|починить)\b/i;
+const DEPLOY_KEYWORDS = /\b(deploy|release|деплой|релиз|выкатить|продакшен|production)\b/i;
+/**
+ * chat.message part: scans user messages for keywords suggesting specific workflows.
+ * Extracts text from output.parts (TextPart[]) since UserMessage has no content field.
+ */
+function createKeywordDetectorChatMessage(_state) {
+    return async (_input, output) => {
+        // Only scan user messages
+        if (output.message?.role !== "user")
+            return;
+        // Extract text content from parts (TextPart has type: "text" and text: string)
+        const parts = output.parts ?? [];
+        let messageContent = "";
+        for (const p of parts) {
+            if ("type" in p && p.type === "text" && "text" in p) {
+                messageContent += " " + p.text;
+            }
+        }
+        messageContent = messageContent.trim();
+        if (!messageContent)
+            return;
+        if (ERROR_KEYWORDS.test(messageContent)) {
+            console.log(`[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. ` +
+                `Consider running 5-reflect first to verify implementation quality.`);
+        }
+    };
+}
+// ═══════════════════════════════════════════════════════════════════════════════
+// HOOK 7: FALLBACK MODELS (OBSERVATIONAL)
+// ═══════════════════════════════════════════════════════════════════════════════
+/**
+ * chat.params: observational logging of model and agent info.
+ * NOTE: chat.params output does NOT expose the `model` field.
+ * Primary model routing is handled by BUILD router + alias agents.
+ * This hook only provides observability.
+ */
+function createFallbackModels(state) {
+    return async (input, _output) => {
+        if (input.agent === ULTRAWORK_AGENT) {
+            await addManagedUltraworkSession(state, input.sessionID);
+        }
+        else if (isManagedUltraworkSession(state, input.sessionID)) {
+            await removeManagedUltraworkSession(state, input.sessionID, `session switched to agent \"${input.agent}\"`);
+        }
+        // Log model and agent for observability
+        const modelId = input.model && "id" in input.model
+            ? input.model.id
+            : "unknown";
+        const providerId = input.provider?.info && "id" in input.provider.info
+            ? input.provider.info.id
+            : "unknown";
+        console.log(`[opencode-immune] Model Observer: agent="${input.agent}", ` +
+            `model="${modelId}", provider="${providerId}"`);
+    };
+}
+// ═══════════════════════════════════════════════════════════════════════════════
+// HOOK 8: EVENT LOGGER
+// ═══════════════════════════════════════════════════════════════════════════════
+/**
+ * Shared event handler: combines Session Recovery event detection,
+ * auto-retry on API errors with exponential backoff, and general event logging.
+ */
+function createEventHandler(state) {
+    const sessionRecovery = createSessionRecoveryEvent(state);
+    const MAX_RETRIES = 10;
+    // Base delay 5s, grows exponentially: 5s, 10s, 20s, 40s, 60s (capped)
+    const BASE_DELAY_MS = 5_000;
+    const MAX_DELAY_MS = 60_000;
+    return async (input) => {
+        // Session Recovery — detect session.create
+        await sessionRecovery(input);
+        const event = input.event;
+        const eventType = event.type ?? "unknown";
+        const info = event.properties?.info;
+        const sessionID = event.properties?.sessionID ?? info?.id;
+        // ── Auto-retry on retryable API error for managed ultrawork sessions ──
+        if (eventType === "session.error" && sessionID) {
+            const error = event.properties?.error;
+            if (!isManagedUltraworkSession(state, sessionID)) {
+                return;
+            }
+            if (!isRetryableApiError(error)) {
+                cancelRetry(state, sessionID, "non-retryable or user-aborted error");
+                state.retryCount.delete(sessionID);
+                return;
+            }
+            if (state.retryTimers.has(sessionID)) {
+                console.log(`[opencode-immune] Retry already pending for session ${sessionID}, skipping duplicate.`);
+                return;
+            }
+            const count = state.retryCount.get(sessionID) ?? 0;
+            if (count < MAX_RETRIES) {
+                const delay = Math.min(BASE_DELAY_MS * Math.pow(2, count), MAX_DELAY_MS);
+                state.retryCount.set(sessionID, count + 1);
+                console.log(`[opencode-immune] Session error detected (attempt ${count + 1}/${MAX_RETRIES}). ` +
+                    `Waiting ${delay / 1000}s before retry...`);
+                const timer = setTimeout(async () => {
+                    state.retryTimers.delete(sessionID);
+                    if (!isManagedUltraworkSession(state, sessionID)) {
+                        return;
+                    }
+                    try {
+                        await state.input.client.session.promptAsync({
+                            body: {
+                                agent: ULTRAWORK_AGENT,
+                                parts: [
+                                    {
+                                        type: "text",
+                                        text: "[SYSTEM: Previous API call failed with a transient error. Re-read memory-bank/tasks.md, check the Phase Status block, and continue the pipeline. Use the exact neutral prompt from your Step 5 table for the next router call. Do NOT analyze or evaluate file contents.]",
+                                    },
+                                ],
+                            },
+                            path: { id: sessionID },
+                        });
+                        console.log(`[opencode-immune] Auto-retry message sent to session ${sessionID}`);
+                    }
+                    catch (err) {
+                        state.retryCount.set(sessionID, Math.max((state.retryCount.get(sessionID) ?? 1) - 1, 0));
+                        console.log(`[opencode-immune] Auto-retry failed (still offline?). Will retry on next error event.`);
+                    }
+                }, delay);
+                state.retryTimers.set(sessionID, timer);
+            }
+            else {
+                console.log(`[opencode-immune] Max retries (${MAX_RETRIES}) reached for session ${sessionID}. Not retrying.`);
+            }
+        }
+        // Reset retry counter on successful activity
+        if (eventType === "session.updated" && sessionID) {
+            cancelRetry(state, sessionID, "session updated");
+            state.retryCount.delete(sessionID);
+            if (markUltraworkSessionActive(state, sessionID)) {
+                await writeManagedSessionsCache(state);
+            }
+        }
+        if (eventType === "session.deleted" && sessionID) {
+            await removeManagedUltraworkSession(state, sessionID, "session deleted");
+        }
+        // Log significant events (not all, to avoid noise)
+        const significantEvents = [
+            "session.created",
+            "session.updated",
+            "session.deleted",
+            "session.error",
+            "session.compacted",
+            "file.edited",
+        ];
+        if (significantEvents.includes(eventType)) {
+            console.log(`[opencode-immune] Event: ${eventType}`);
+        }
+    };
+}
+// ═══════════════════════════════════════════════════════════════════════════════
+// HOOK 9: MULTI-CYCLE AUTOMATION (PRE_COMMIT + CYCLE_COMPLETE)
+// ═══════════════════════════════════════════════════════════════════════════════
+const MAX_CYCLES = 10;
+const PRE_COMMIT_MARKER = "0-ULTRAWORK: PRE_COMMIT";
+const CYCLE_COMPLETE_MARKER = "0-ULTRAWORK: CYCLE_COMPLETE";
+const NEXT_TASK_PATTERN = /Next task:\s*(.+)/;
+/**
+ * chat.message part: scans assistant messages for PRE_COMMIT and CYCLE_COMPLETE markers.
+ *
+ * PRE_COMMIT → executes /commit via client.session.command()
+ * CYCLE_COMPLETE → creates a new session and sends bootstrap prompt
+ */
+function createMultiCycleHandler(state) {
+    return async (input, output) => {
+        const sessionID = input.sessionID;
+        if (!isManagedUltraworkSession(state, sessionID))
+            return;
+        // Extract text content from parts
+        const parts = output.parts ?? [];
+        let messageContent = "";
+        for (const p of parts) {
+            if ("type" in p && p.type === "text" && "text" in p) {
+                messageContent += " " + p.text;
+            }
+        }
+        messageContent = messageContent.trim();
+        if (!messageContent)
+            return;
+        // ── PRE_COMMIT: execute /commit ──
+        if (messageContent.includes(PRE_COMMIT_MARKER) && !state.commitPending) {
+            state.commitPending = true;
+            console.log("[opencode-immune] Multi-Cycle: PRE_COMMIT detected, executing /commit...");
+            // Small delay to let the message finish rendering
+            setTimeout(async () => {
+                try {
+                    await state.input.client.session.command({
+                        body: {
+                            command: "/commit",
+                            arguments: "",
+                        },
+                        path: { id: sessionID },
+                    });
+                    console.log("[opencode-immune] Multi-Cycle: /commit executed successfully.");
+                }
+                catch (err) {
+                    console.error("[opencode-immune] Multi-Cycle: /commit failed:", err);
+                }
+                finally {
+                    state.commitPending = false;
+                }
+            }, 2_000);
+        }
+        // ── CYCLE_COMPLETE: create new session ──
+        if (messageContent.includes(CYCLE_COMPLETE_MARKER)) {
+            state.cycleCount++;
+            if (state.cycleCount >= MAX_CYCLES) {
+                console.log(`[opencode-immune] Multi-Cycle: MAX_CYCLES (${MAX_CYCLES}) reached. Not creating new session.`);
+                return;
+            }
+            // Extract next task description
+            const taskMatch = messageContent.match(NEXT_TASK_PATTERN);
+            const nextTask = taskMatch?.[1]?.trim() ?? "Continue processing task backlog";
+            console.log(`[opencode-immune] Multi-Cycle: CYCLE_COMPLETE detected (cycle ${state.cycleCount}/${MAX_CYCLES}). ` +
+                `Creating new session for: "${nextTask}"`);
+            // Delay to let commit finish
+            setTimeout(async () => {
+                try {
+                    // Create a new session
+                    const createResult = await state.input.client.session.create({
+                        body: {
+                            title: `Ultrawork Cycle ${state.cycleCount + 1}`,
+                        },
+                    });
+                    // Extract new session ID from the response
+                    const newSessionData = createResult?.data;
+                    const newSessionID = newSessionData?.id;
+                    if (!newSessionID) {
+                        console.error("[opencode-immune] Multi-Cycle: Failed to create new session — no session ID returned.");
+                        return;
+                    }
+                    console.log(`[opencode-immune] Multi-Cycle: New session created: ${newSessionID}`);
+                    await addManagedUltraworkSession(state, newSessionID);
+                    // Send bootstrap prompt to the new session
+                    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 new session ${newSessionID}`);
+                }
+                catch (err) {
+                    console.error("[opencode-immune] Multi-Cycle: Failed to create new session or send prompt:", err);
+                }
+            }, 8_000); // 8s delay: let /commit finish first
+        }
+    };
+}
+// ═══════════════════════════════════════════════════════════════════════════════
+// PLUGIN MODULE EXPORT
+// ═══════════════════════════════════════════════════════════════════════════════
+async function server(input) {
+    const state = createState(input);
+    await loadManagedSessionsCache(state);
+    console.log(`[opencode-immune] Plugin initialized. Directory: ${input.directory}`);
+    // Compose tool.execute.after handlers:
+    // Todo Enforcer (counter) + Ralph Loop (edit error) + Comment Checker
+    const toolAfterHandlers = [
+        createTodoEnforcerToolAfter(state),
+        createRalphLoopToolAfter(state),
+        createCommentCheckerToolAfter(state),
+    ];
+    // Compose chat.message handlers:
+    // Todo Enforcer (check) + Keyword Detector + Context Monitor + Multi-Cycle
+    const chatMessageHandlers = [
+        createTodoEnforcerChatMessage(state),
+        createKeywordDetectorChatMessage(state),
+        createContextMonitorChatMessage(state),
+        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)),
+    };
+}
+exports.default = {
+    id: "opencode-immune",
+    server,
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "opencode-immune",
+  "version": "1.0.0",
+  "description": "OpenCode plugin: session recovery, auto-retry, multi-cycle automation, context monitoring",
+  "exports": {
+    "./server": "./dist/plugin.js"
+  },
+  "files": [
+    "dist/plugin.js"
+  ],
+  "scripts": {
+    "build": "node ./node_modules/typescript/bin/tsc --project tsconfig.json",
+    "dev": "node ./node_modules/typescript/bin/tsc --project tsconfig.json --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.4.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "typescript": "^5.7.0"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "ai",
+    "agent",
+    "recovery",
+    "retry"
+  ],
+  "license": "MIT"
+}