@peakflo/agent-harness 0.0.0-stage → 0.2.2-rc.1

package/dist/adapters/opencode-adapter.js

@@ -0,0 +1,2710 @@
+"use strict";
+/**
+ * Extracted verbatim from 20x `src/main/adapters/opencode-adapter.ts`.
+ * CHANGED (nothing else):
+ *  - imports: `../utils/opencode-config` -> `./opencode-config`
+ *  - `import type { DatabaseManager } from '../database'` -> the narrow
+ *    structural `SettingsReader` type below (`getSetting` is the only member
+ *    this file ever used; its real signature in 20x `src/main/database.ts` is
+ *    `getSetting(key: string): string | undefined`).
+ *  - the enterprise AI gateway is injected: `readEnterpriseAiGatewayConfig(this.db)`
+ *    is now `this.gateway?.readModelGatewayConfig() ?? null`, because 20x's
+ *    `enterprise-ai-gateway.ts` decrypts via Electron `safeStorage` and cannot
+ *    be extracted. The constructor gained an optional second `gateway` param.
+ * The `@opencode-ai/sdk` type queries and dynamic imports are UNCHANGED; the
+ * SDK is an optional dependency and is declared ambiently in
+ * `./optional-agent-sdks.d.ts` so `tsc` succeeds when it is not installed.
+ * Source formatting (no semicolons) preserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpencodeAdapter = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const opencode_server_policy_1 = require("./opencode-server-policy");
+const opencode_config_1 = require("./opencode-config");
+const model_gateway_1 = require("./model-gateway");
+const coding_agent_adapter_1 = require("./coding-agent-adapter");
+/**
+ * A REAL dynamic ESM import, which `await import(...)` is not in this package.
+ *
+ * This package compiles to CommonJS, and `tsc` downlevels every `await
+ * import(x)` into `require(x)`. `@opencode-ai/sdk` is `"type": "module"` and
+ * its exports map declares ONLY an `"import"` condition, so the `require`
+ * resolution finds no target and Node throws ERR_PACKAGE_PATH_NOT_EXPORTED.
+ * The effect is total: `initialize()` then throws "OpenCode SDK not loaded"
+ * and NO TURN CAN EVER RUN from a compiled build.
+ *
+ * Going through `new Function` hides the `import` from the compiler, so it
+ * survives into the emitted JavaScript as a genuine ESM import. This is the
+ * standard workaround for loading an ESM-only dependency from CommonJS and it
+ * is why the specifier must stay a plain runtime string.
+ */
+const esmImport = new Function('specifier', 'return import(specifier)');
+let OpenCodeSDK = null;
+let OpenCodeV2 = null;
+let OpenCodeV2Client = null;
+// THE ONE DELIBERATE CHANGE TO THIS FILE, and it is forced by the sandbox.
+//
+// 20x wrote `import { Agent as UndiciAgent } from 'undici'` and built both
+// dispatchers at module load. That makes `undici` a REQUIRED runtime dependency
+// — and the real-image e2e proved that is fatal: `pf-bootstrap` installs the
+// harness with `--ignore-scripts` from the PRIVATE registry, and the sandbox's
+// egress allowlist does not include registry.npmjs.org. npm therefore cannot
+// resolve `undici` at all, and the boot fails with ETARGET on the private
+// registry or ENOTCACHED on the warm-fallback path. The package must have ZERO
+// required runtime dependencies, which is the property Phase 0 shipped with.
+//
+// So undici is loaded LAZILY and OPTIONALLY. Where it is present (the 20x
+// desktop, any host that installed it) behaviour is byte-identical to 20x.
+// Where it is absent the dispatcher is simply omitted and the platform fetch is
+// used unchanged.
+//
+// THE DEGRADATION IS REAL AND WORTH NAMING: without the dispatcher, undici's
+// built-in 300s headers/body timeout applies to `session.prompt()`, which stays
+// open for the WHOLE agent loop. A turn whose model is silent for more than
+// five minutes — a long tool call, a slow provider — would be cut off. That is
+// why this is a fallback and not the default.
+let undiciAgentCtor;
+function undiciDispatcher(options) {
+    if (undiciAgentCtor === undefined) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            undiciAgentCtor = require('undici').Agent;
+        }
+        catch {
+            undiciAgentCtor = null;
+        }
+    }
+    return undiciAgentCtor ? new undiciAgentCtor(options) : undefined;
+}
+// Custom fetch with no timeout — used ONLY for session.prompt() which stays open
+// for the entire agent loop (including all tool calls). All other SDK calls use the
+// default fetch which has the SDK's built-in 60s timeout.
+let noTimeoutAgent;
+const noTimeoutFetch = (req) => {
+    if (noTimeoutAgent === undefined)
+        noTimeoutAgent = undiciDispatcher({ headersTimeout: 0, bodyTimeout: 0 });
+    return globalThis.fetch(req, noTimeoutAgent ? { dispatcher: noTimeoutAgent } : {});
+};
+// Fetch with reasonable timeout for quick operations (health checks, config queries, provider listing)
+const QUICK_OP_TIMEOUT_MS = 15_000;
+let quickTimeoutAgent;
+const quickTimeoutFetch = (req) => {
+    if (quickTimeoutAgent === undefined)
+        quickTimeoutAgent = undiciDispatcher({
+            headersTimeout: QUICK_OP_TIMEOUT_MS,
+            bodyTimeout: QUICK_OP_TIMEOUT_MS
+        });
+    return globalThis.fetch(req, quickTimeoutAgent ? { dispatcher: quickTimeoutAgent } : {});
+};
+const DEFAULT_SERVER_URL = 'http://localhost:4096';
+/**
+ * Adapter for OpenCode backend
+ */
+/**
+ * A directory this process can ACTUALLY use, for opencode's instance state.
+ *
+ * `homedir()` alone is not that. In the managed sandbox the harness runs as
+ * `pfharness` (uid 1500) while HOME is inherited from the root bootstrap, so
+ * `homedir()` answers `/root` — mode 0700 and owned by root. opencode was then
+ * told to bootstrap there and every request died:
+ *
+ *   message=fromDirectory directory=/root
+ *   ERROR PermissionDenied: FileSystem.access (/root/opencode.jsonc)
+ *          EACCES: permission denied
+ *
+ * The server started, listened, and answered 500 to its very first
+ * `config.get()`. From the outside that reads as "fetch failed" and a turn that
+ * completes with no output, which is how it stayed unexplained for so long.
+ *
+ * So the directory is CHOSEN BY TESTING IT, not assumed: the first candidate
+ * this process can read AND write wins. PF_WORKSPACE_ROOT comes first because
+ * the sandbox image creates it as pfharness:0700 for exactly this reason.
+ */
+/**
+ * Every todo gets a stable id. opencode's `todowrite` input does not carry one.
+ *
+ * The fallback uses the INDEX AND THE CONTENT, both of which survive the status
+ * change that is the only field normally moving — so a streaming update does not
+ * remount the list and lose focus and scroll. Matches `claude-code-adapter`'s
+ * `id: t.id || 'todo-<i>'`, with the content added because a bare index
+ * collides between two todo lists shown in the same transcript.
+ *
+ * NOTE FOR 20x: `src/main/adapters/opencode-adapter.ts` has the SAME raw
+ * pass-through and therefore the same defect on the desktop. This fix belongs
+ * there too; the two adapters are copies of each other.
+ */
+function normaliseTodoIds(todos) {
+    return todos.map((entry, index) => {
+        const todo = (entry ?? {});
+        const id = typeof todo.id === 'string' && todo.id.length > 0 ? todo.id : null;
+        const content = typeof todo.content === 'string' ? todo.content : '';
+        return {
+            ...todo,
+            id: id ?? `todo-${index}-${content}`,
+            content,
+            status: todo.status ?? 'pending'
+        };
+    });
+}
+function usableStateDirectory(preferred) {
+    const candidates = [
+        preferred,
+        process.env.PF_WORKSPACE_ROOT,
+        // The sandbox image spelled this PLURAL for a long time while the harness
+        // read the singular, so the value silently never arrived. Accepting both
+        // means a host that sets either one is understood.
+        process.env.PF_WORKSPACES_ROOT,
+        (0, os_1.homedir)(),
+        (0, os_1.tmpdir)()
+    ].filter((d) => Boolean(d));
+    for (const dir of candidates) {
+        try {
+            (0, fs_1.accessSync)(dir, fs_1.constants.R_OK | fs_1.constants.W_OK);
+            return dir;
+        }
+        catch {
+            continue;
+        }
+    }
+    // tmpdir() is the last candidate and is writable on any sane host; if even
+    // that failed, returning it produces the ordinary error rather than a
+    // confusing one from a directory nobody chose.
+    return (0, os_1.tmpdir)();
+}
+class OpencodeAdapter {
+    db;
+    gateway;
+    serverPolicy;
+    /** Callback set by agent-manager to trigger an immediate poll cycle */
+    onDataAvailable;
+    sdkLoading = null;
+    serverInstance = null;
+    serverUrl = null;
+    serverStarting = null;
+    /** The shared V2 SDK client created alongside the server via createOpencode */
+    sharedClient = null;
+    /** A separate V2 client with a reasonable timeout for quick operations (config, providers, health) */
+    quickClient = null;
+    clients = new Map(); // sessionId -> ocClient (default timeout, for polling/status/create)
+    /** Separate clients with no timeout, used ONLY for session.prompt() which runs indefinitely */
+    promptClients = new Map();
+    v2Client = null;
+    promptAborts = new Map();
+    /** Provider errors captured from prompt results (surfaced via getStatus) */
+    promptErrors = new Map();
+    /** Absolute paths to generated OpenCode plugin files registered for this session/workspace */
+    pluginFilePaths = [];
+    /** Absolute paths to generated support files used by runtime plugins */
+    runtimeSupportFilePaths = [];
+    /** Absolute path to the generated tillDone config support file */
+    tillDoneConfigPath = null;
+    /** Whether the merged config has been pushed at least once to the running server.
+     *  Config is pushed once on first server connection; subsequent pushes happen only
+     *  via explicit `notifyConfigChanged()` calls (e.g. after settings edit or key rotation).
+     *  This avoids PATCH /global/config storms that abort all running sessions. */
+    configPushed = false;
+    /** Maximum number of automatic retries for transient prompt errors (e.g. "Aborted") */
+    static PROMPT_MAX_RETRIES = 3;
+    /** Base delay (ms) for exponential backoff between prompt retries */
+    static PROMPT_RETRY_BASE_DELAY_MS = 2_000;
+    /** Pending permission requests per session (captured from SSE events).
+     *  Each session may have multiple pending permissions (parallel tool calls). */
+    pendingPermissions = new Map();
+    /** Abort controller for the SSE event subscription */
+    sseAbort = null;
+    /** Per-session permission mode ('ask' = surface in UI, 'allow' = auto-approve) */
+    sessionPermissionModes = new Map();
+    /** Per-session workspace directory — needed for permission replies and other
+     *  session-scoped V2 API calls initiated from global SSE events. */
+    sessionWorkspaceDirs = new Map();
+    /** Per-session MCP server configs — retained for re-registration on session resume
+     *  (e.g. after 20x restart when stdio MCP server processes are dead). */
+    sessionMcpConfigs = new Map();
+    /** Per-session names of MCP servers that could not be attached. Read by the
+     *  agent-manager so the session documentation does not advertise tools that
+     *  are not there. */
+    sessionMcpAttachFailures = new Map();
+    constructor(db, gateway, 
+    /**
+     * WHOSE OPENCODE SERVER THIS IS. Defaults to `shared`, which is 20x's
+     * behaviour and the reason the desktop is not regressed by this change:
+     * a host that passes nothing keeps exactly what it had. The HARNESS
+     * passes an owned policy (see `cli.ts`), and an owned policy never
+     * adopts, never binds a well-known port and never kills anything.
+     */
+    serverPolicy = {
+        kind: 'shared',
+        url: opencode_server_policy_1.SHARED_SERVER_URL
+    }) {
+        this.db = db;
+        this.gateway = gateway;
+        this.serverPolicy = serverPolicy;
+        this.sdkLoading = this.loadSDK();
+    }
+    /** The state directory an OWNED server keeps its sessions in, else null. */
+    ownedStateDir() {
+        return this.serverPolicy.kind === 'owned'
+            ? this.serverPolicy.stateDir
+            : null;
+    }
+    /**
+     * WHICH opencode can honour a `ses_...` handle this adapter minted.
+     *
+     * Not the process and not the port: two opencode servers sharing one state
+     * directory each read the other's sessions immediately, and a session
+     * outlives the server that created it. Measured against opencode 1.18.23.
+     * So the answer is an identity of the STATE DIRECTORY, and it is stable
+     * across both a server restart and a harness restart.
+     */
+    backendInstanceId() {
+        return (0, opencode_server_policy_1.backendInstanceId)(this.serverPolicy);
+    }
+    async loadSDK() {
+        try {
+            OpenCodeSDK = await esmImport('@opencode-ai/sdk');
+            OpenCodeV2 = await esmImport('@opencode-ai/sdk/v2');
+            OpenCodeV2Client = await esmImport('@opencode-ai/sdk/v2/client');
+            console.log('[OpencodeAdapter] SDK loaded successfully (v2 available)');
+        }
+        catch (error) {
+            console.error('[OpencodeAdapter] Failed to load SDK:', error);
+        }
+        finally {
+            this.sdkLoading = null;
+        }
+    }
+    async ensureSDKLoaded() {
+        if (OpenCodeSDK)
+            return;
+        if (this.sdkLoading) {
+            await this.sdkLoading;
+        }
+        if (!OpenCodeSDK) {
+            throw new Error('OpenCode SDK not loaded');
+        }
+    }
+    async initialize() {
+        await this.ensureSDKLoaded();
+    }
+    /**
+     * Wait for a group of MCP servers to reach a terminal state.
+     * Uses one status query per retry cycle (batched) instead of polling per server.
+     */
+    async waitForMcpServersReady(ocClient, serverNames, workspaceDir, maxAttempts = 5, delayMs = 300) {
+        const pending = new Set(serverNames);
+        const states = new Map();
+        for (let attempt = 0; attempt < maxAttempts && pending.size > 0; attempt++) {
+            try {
+                const statusMap = await this.getMcpStatusMap(ocClient, workspaceDir);
+                for (const name of [...pending]) {
+                    const serverStatus = statusMap?.[name];
+                    if (!serverStatus?.status)
+                        continue;
+                    if (serverStatus.status === 'connected') {
+                        states.set(name, 'connected');
+                        pending.delete(name);
+                        console.log(`[OpencodeAdapter] MCP server '${name}' status: connected (attempt ${attempt + 1})`);
+                    }
+                    else if (serverStatus.status === 'failed') {
+                        states.set(name, 'failed');
+                        pending.delete(name);
+                        console.error(`[OpencodeAdapter] MCP server '${name}' status: failed${serverStatus.error ? ` - ${serverStatus.error}` : ''}`);
+                    }
+                }
+            }
+            catch (statusErr) {
+                console.warn('[OpencodeAdapter] Failed to query MCP status:', statusErr);
+            }
+            if (pending.size > 0 && attempt < maxAttempts - 1 && delayMs > 0) {
+                await new Promise((resolve) => setTimeout(resolve, delayMs));
+            }
+        }
+        for (const name of pending) {
+            states.set(name, 'timeout');
+        }
+        return states;
+    }
+    /**
+     * Query MCP status via SDK.
+     * Prefer mcp.list() (same view as `opencode mcp list`), fall back to mcp.status().
+     */
+    async getMcpStatusMap(ocClient, workspaceDir) {
+        const query = workspaceDir ? { query: { directory: workspaceDir } } : {};
+        const mcpClient = ocClient.mcp;
+        if (typeof mcpClient.list === 'function') {
+            try {
+                const listResult = await mcpClient.list(query);
+                if (!listResult.error) {
+                    const parsed = this.parseMcpListData(listResult.data);
+                    if (parsed)
+                        return parsed;
+                }
+            }
+            catch (err) {
+                console.warn('[OpencodeAdapter] mcp.list failed, falling back to mcp.status:', err);
+            }
+        }
+        const statusResult = await mcpClient.status(query);
+        return statusResult.data;
+    }
+    parseMcpListData(data) {
+        if (!data)
+            return undefined;
+        if (Array.isArray(data)) {
+            const out = {};
+            for (const item of data) {
+                const rec = item;
+                const name = rec.name || rec.id;
+                if (!name)
+                    continue;
+                out[name] = {
+                    status: rec.status || rec.state || rec.auth?.status,
+                    error: rec.error || rec.auth?.error
+                };
+            }
+            return Object.keys(out).length > 0 ? out : undefined;
+        }
+        if (typeof data === 'object') {
+            const obj = data;
+            const out = {};
+            for (const [name, value] of Object.entries(obj)) {
+                out[name] = {
+                    status: value?.status || value?.state,
+                    error: value?.error
+                };
+            }
+            return Object.keys(out).length > 0 ? out : undefined;
+        }
+        return undefined;
+    }
+    /**
+     * Register MCP servers with the OpenCode backend (mcp.add + mcp.connect).
+     * Called from both createSession (initial setup) and resumeSession (after 20x
+     * restart when stdio MCP server processes are dead and need re-registration).
+     *
+     * Returns which servers are attached and which are not. The caller MUST act on
+     * the failures: OpenCode receives its MCP servers only through these runtime
+     * calls, so a swallowed failure produces a session that silently has no tools
+     * while AGENTS.md still advertises them.
+     */
+    async registerMcpServers(ocClient, mcpServers, workspaceDir) {
+        const connectCandidates = [];
+        const attached = [];
+        const failed = [];
+        for (const [name, mcpConfig] of Object.entries(mcpServers)) {
+            try {
+                const mcpAddConfig = mcpConfig.type === 'http'
+                    ? {
+                        type: 'remote',
+                        url: mcpConfig.url ?? '',
+                        headers: mcpConfig.headers
+                    }
+                    : {
+                        type: 'local',
+                        command: [mcpConfig.command ?? '', ...(mcpConfig.args ?? [])],
+                        environment: mcpConfig.env
+                    };
+                console.log(`[OpencodeAdapter] Registering MCP server: ${name}`, JSON.stringify(mcpAddConfig));
+                // Add MCP server
+                const addResult = await ocClient.mcp.add({
+                    body: { name, config: mcpAddConfig },
+                    ...(workspaceDir && { query: { directory: workspaceDir } })
+                });
+                if (addResult.error) {
+                    console.error(`[OpencodeAdapter] mcp.add error for ${name}:`, addResult.error);
+                    failed.push(name);
+                    continue;
+                }
+                // Check the add response for immediate server status
+                const addStatus = addResult.data?.[name];
+                if (addStatus) {
+                    console.log(`[OpencodeAdapter] mcp.add status for '${name}': ${addStatus.status}${addStatus.error ? ` - ${addStatus.error}` : ''}`);
+                    if (addStatus.status === 'failed') {
+                        console.error(`[OpencodeAdapter] MCP server '${name}' failed immediately after add: ${addStatus.error}`);
+                        failed.push(name);
+                        continue;
+                    }
+                    if (addStatus.status === 'connected') {
+                        console.log(`[OpencodeAdapter] Successfully registered MCP server: ${name} (connected via mcp.add)`);
+                        attached.push(name);
+                        continue;
+                    }
+                }
+                // Connect to MCP server
+                const connectResult = await ocClient.mcp.connect({
+                    path: { name },
+                    ...(workspaceDir && { query: { directory: workspaceDir } })
+                });
+                if (connectResult.error) {
+                    console.error(`[OpencodeAdapter] mcp.connect error for ${name}:`, connectResult.error);
+                    failed.push(name);
+                    continue;
+                }
+                // Check connect result (returns boolean)
+                if (connectResult.data === false) {
+                    console.error(`[OpencodeAdapter] mcp.connect returned false for ${name} — server failed to connect`);
+                    failed.push(name);
+                    continue;
+                }
+                connectCandidates.push(name);
+            }
+            catch (mcpError) {
+                console.error(`[OpencodeAdapter] Failed to register MCP server ${name}:`, mcpError);
+                failed.push(name);
+            }
+        }
+        if (connectCandidates.length > 0) {
+            const readiness = await this.waitForMcpServersReady(ocClient, connectCandidates, workspaceDir);
+            for (const name of connectCandidates) {
+                const state = readiness.get(name);
+                if (state === 'connected') {
+                    console.log(`[OpencodeAdapter] Successfully registered MCP server: ${name}`);
+                    attached.push(name);
+                }
+                else if (state === 'failed') {
+                    console.error(`[OpencodeAdapter] MCP server '${name}' failed to connect`);
+                    failed.push(name);
+                }
+                else {
+                    console.error(`[OpencodeAdapter] MCP server '${name}' did not reach connected status — tools may not work`);
+                    failed.push(name);
+                }
+            }
+        }
+        return { attached, failed };
+    }
+    /**
+     * Attach the MCP servers of a session and verify the result.
+     *
+     * OpenCode keeps MCP servers only in the memory of the `opencode serve`
+     * process, so an attach failure is invisible in the session itself: the agent
+     * simply has no task-management tools while AGENTS.md advertises them. This
+     * helper therefore retries the failures once, and reports what is still
+     * missing so the caller can escalate instead of continuing silently.
+     */
+    async attachAndVerifyMcpServers(ocClient, mcpServers, workspaceDir, context) {
+        const first = await this.registerMcpServers(ocClient, mcpServers, workspaceDir);
+        if (first.failed.length === 0)
+            return first;
+        console.warn(`[OpencodeAdapter] ${context}: MCP servers not attached on first try (${first.failed.join(', ')}) — retrying once`);
+        const retryTargets = {};
+        for (const name of first.failed) {
+            const cfg = mcpServers[name];
+            if (cfg)
+                retryTargets[name] = cfg;
+        }
+        const second = await this.registerMcpServers(ocClient, retryTargets, workspaceDir);
+        const result = {
+            attached: [...first.attached, ...second.attached],
+            failed: second.failed
+        };
+        if (result.failed.length > 0) {
+            // Loud, single-line marker: this is the failure mode where an agent runs
+            // with no task-management tools while its own AGENTS.md lists 35 of them.
+            console.error(`[OpencodeAdapter] MCP ATTACH FAILED — ${context}: ${result.failed.join(', ')} not attached. ` +
+                `Agent tools from these servers are NOT available in this session.`);
+        }
+        return result;
+    }
+    setMcpAttachFailures(sessionId, failed) {
+        if (failed.length > 0) {
+            this.sessionMcpAttachFailures.set(sessionId, [...failed]);
+        }
+        else {
+            this.sessionMcpAttachFailures.delete(sessionId);
+        }
+    }
+    /**
+     * Names of MCP servers that are configured for the session but are NOT
+     * attached to the OpenCode backend, so none of their tools can be called.
+     */
+    getMcpAttachFailures(sessionId) {
+        return this.sessionMcpAttachFailures.get(sessionId) ?? [];
+    }
+    /**
+     * Disconnect the MCP servers that were attached for a session.
+     *
+     * Each attached stdio server is a child process of the shared `opencode serve`
+     * process, and it lives as long as that server does — which is days, because
+     * the server is shared and often adopted rather than spawned. Without this the
+     * stdio children accumulate one per session (the task-management-mcp leak).
+     * Servers still needed by another live session are kept.
+     */
+    async disconnectSessionMcpServers(sessionId) {
+        const ownConfig = this.sessionMcpConfigs.get(sessionId);
+        if (!ownConfig)
+            return;
+        const stillNeeded = new Set();
+        for (const [otherSessionId, otherConfig] of this.sessionMcpConfigs.entries()) {
+            if (otherSessionId === sessionId)
+                continue;
+            for (const name of Object.keys(otherConfig))
+                stillNeeded.add(name);
+        }
+        const client = this.clients.get(sessionId);
+        if (!client)
+            return;
+        const workspaceDir = this.sessionWorkspaceDirs.get(sessionId);
+        const mcpClient = client.mcp;
+        if (typeof mcpClient.disconnect !== 'function')
+            return;
+        for (const name of Object.keys(ownConfig)) {
+            if (stillNeeded.has(name))
+                continue;
+            try {
+                const result = await mcpClient.disconnect({
+                    path: { name },
+                    ...(workspaceDir && { query: { directory: workspaceDir } })
+                });
+                if (result?.error) {
+                    console.warn(`[OpencodeAdapter] mcp.disconnect error for ${name}:`, result.error);
+                }
+                else {
+                    console.log(`[OpencodeAdapter] Disconnected MCP server '${name}' for session ${sessionId}`);
+                }
+            }
+            catch (err) {
+                console.warn(`[OpencodeAdapter] mcp.disconnect failed for ${name}:`, err instanceof Error ? err.message : err);
+            }
+        }
+    }
+    getScopedPartId(messageId, rawPartId, fallbackIndex) {
+        if (rawPartId)
+            return `${messageId}:${rawPartId}`;
+        if (fallbackIndex !== undefined)
+            return `${messageId}:part-${fallbackIndex}`;
+        return undefined;
+    }
+    /**
+     * Returns the shared SDK client, ensuring the server is running first.
+     * Pass `quick: true` to get a client with a bounded timeout (for config queries, health checks).
+     */
+    async getClient(serverUrl, opts) {
+        const baseUrl = serverUrl || this.serverUrl || DEFAULT_SERVER_URL;
+        await this.ensureServerRunning(baseUrl);
+        if (opts?.quick) {
+            if (!this.quickClient) {
+                throw new Error('OpenCode quick client not available after server startup');
+            }
+            return this.quickClient;
+        }
+        if (!this.sharedClient) {
+            throw new Error('OpenCode client not available after server startup');
+        }
+        return this.sharedClient;
+    }
+    /**
+     * Push the merged provider/auth config to the running OpenCode server.
+     *
+     * ⚠️  PATCH /global/config causes the server to call disposeAllInstancesAndEmitGlobalDisposed(),
+     * which aborts every running session processor AND disconnects all MCP servers.
+     *
+     * Strategy:
+     *   - When sessions are active: push via directory-scoped PATCH /config for each
+     *     active session directory. This updates the config without killing MCP connections.
+     *   - When no sessions are active: safe to use global endpoint.
+     */
+    async pushMergedConfigToClient(client) {
+        const hasActivePrompts = this.promptAborts.size > 0;
+        try {
+            const mergedConfig = (0, opencode_config_1.buildMergedOpencodeConfig)(undefined, this.gateway);
+            if (!mergedConfig.provider) {
+                console.log('[OpencodeAdapter] pushMergedConfigToClient: no providers in merged config, skipping');
+                return;
+            }
+            const providerIds = Object.keys(mergedConfig.provider);
+            console.log('[OpencodeAdapter] pushMergedConfigToClient: pushing providers:', providerIds.join(', '));
+            const castConfig = mergedConfig;
+            if (hasActivePrompts) {
+                // Sessions are running — use directory-scoped config updates to avoid
+                // disposeAllInstances which would kill MCP connections.
+                console.log(`[OpencodeAdapter] pushMergedConfigToClient: ${this.promptAborts.size} prompt(s) active — using directory-scoped config push`);
+                const directories = new Set(this.sessionWorkspaceDirs.values());
+                if (directories.size > 0) {
+                    for (const dir of directories) {
+                        try {
+                            await client.config.update({
+                                config: castConfig,
+                                directory: dir
+                            });
+                        }
+                        catch {
+                            // Individual directory push failed — non-fatal
+                        }
+                    }
+                }
+                else {
+                    // No directories known — fall back to global as last resort
+                    console.warn('[OpencodeAdapter] pushMergedConfigToClient: no known directories, using global endpoint (may disrupt active sessions)');
+                    await client.global.config.update({ config: castConfig });
+                }
+            }
+            else {
+                // No active sessions — safe to use global endpoint
+                try {
+                    const result = await client.global.config.update({
+                        config: castConfig
+                    });
+                    if (result.error) {
+                        console.warn('[OpencodeAdapter] global.config.update returned error:', JSON.stringify(result.error));
+                        throw new Error('global.config.update returned error');
+                    }
+                }
+                catch {
+                    const result = await client.config.update({ config: castConfig });
+                    if (result.error) {
+                        console.warn('[OpencodeAdapter] config.update returned error:', JSON.stringify(result.error));
+                    }
+                }
+            }
+            this.configPushed = true;
+        }
+        catch (err) {
+            console.warn('[OpencodeAdapter] pushMergedConfigToClient failed:', err instanceof Error ? err.message : err);
+        }
+    }
+    /**
+     * Notify the adapter that provider config has changed (e.g. user edited agent settings,
+     * AI gateway key was rotated).  Pushes the updated config to the running server.
+     *
+     * Call this from the agent-manager when settings change — do NOT call it on every
+     * createSession or getClient, since PATCH /global/config aborts all running sessions.
+     */
+    async notifyConfigChanged() {
+        if (!this.sharedClient) {
+            console.log('[OpencodeAdapter] notifyConfigChanged: no server connection yet, skipping');
+            return;
+        }
+        console.log('[OpencodeAdapter] notifyConfigChanged: pushing updated config to server');
+        await this.pushMergedConfigToClient(this.sharedClient);
+    }
+    async getProviders(serverUrl, directory) {
+        return this.getProvidersInner(serverUrl, directory, true);
+    }
+    async getProvidersInner(serverUrl, directory, allowRecovery = true) {
+        try {
+            const client = await this.getClient(serverUrl, { quick: true });
+            // Push the merged config if it hasn't been pushed yet. This handles the
+            // edge case where getProviders is called before any session has started
+            // (e.g. the user opens settings immediately after app launch). Once config
+            // has been pushed via ensureServerRunning, this is a no-op. Subsequent
+            // config changes go through notifyConfigChanged().
+            if (!this.configPushed) {
+                await this.pushMergedConfigToClient(client);
+            }
+            // Always pass a writable directory so the OpenCode server doesn't fall
+            // back to its CWD (which is read-only on macOS when launched from
+            // /Applications). Without this, fromDirectory() in the server tries to
+            // create an SQLite DB at the CWD and fails with "disk I/O error".
+            const safeDirectory = usableStateDirectory(directory);
+            const result = await client.config.providers({
+                directory: safeDirectory
+            });
+            if (result.error) {
+                const errorStr = JSON.stringify(result.error);
+                // Detect SQLite database errors from the server (corrupted DB, stale WAL
+                // files, migration failures from opencode version upgrades).
+                // Recovery: kill the stale server, clear its DB, reset state, retry once.
+                if (allowRecovery && errorStr.includes('SQLiteError')) {
+                    console.warn('[OpencodeAdapter] SQLite error from server, attempting recovery:', errorStr);
+                    await this.recoverFromBrokenServer();
+                    return this.getProvidersInner(serverUrl, directory, false);
+                }
+                console.log('[OpencodeAdapter] No providers configured on server:', errorStr);
+                return null;
+            }
+            const data = result.data;
+            // Filter stale models from the enterprise AI gateway provider.
+            // The OpenCode server uses PATCH (merge semantics) for config updates,
+            // so models removed from LiteLLM persist in the server's config.
+            // We apply a client-side filter using the fresh model list from SQLite
+            // (which was just refreshed from LiteLLM by the caller in agent-manager).
+            if (data?.providers && this.gateway) {
+                this.filterStaleProviderModels(data.providers);
+            }
+            return data
+                ? { providers: data.providers || [], default: data.default || {} }
+                : null;
+        }
+        catch (error) {
+            console.log('[OpencodeAdapter] Could not get providers:', error instanceof Error ? error.message : error);
+            return null;
+        }
+    }
+    /**
+     * Remove models from the enterprise AI gateway provider that are no longer
+     * present in the fresh config stored in SQLite. Mutates the providers array
+     * in place.
+     */
+    filterStaleProviderModels(providers) {
+        if (!this.gateway)
+            return;
+        const freshConfig = this.gateway?.readModelGatewayConfig() ?? null;
+        if (!freshConfig?.models)
+            return;
+        const freshModelIds = new Set(freshConfig.models.map((m) => m.id));
+        const provider = providers.find((p) => p.id === model_gateway_1.ENTERPRISE_AI_GATEWAY_PROVIDER_ID);
+        if (!provider?.models || typeof provider.models !== 'object')
+            return;
+        const serverModels = provider.models;
+        const filtered = {};
+        for (const [modelId, modelConfig] of Object.entries(serverModels)) {
+            if (freshModelIds.has(modelId)) {
+                filtered[modelId] = modelConfig;
+            }
+        }
+        const removed = Object.keys(serverModels).length - Object.keys(filtered).length;
+        if (removed > 0) {
+            provider.models = filtered;
+            console.log(`[OpencodeAdapter] Filtered out ${removed} stale model(s) from ${model_gateway_1.ENTERPRISE_AI_GATEWAY_PROVIDER_ID} provider`);
+        }
+    }
+    /**
+     * Recover from a broken opencode server by killing it, clearing its
+     * corrupted database, and resetting adapter state so the next call
+     * spawns a fresh server.
+     */
+    async recoverFromBrokenServer() {
+        console.log('[OpencodeAdapter] Starting recovery: stopping broken server and clearing database');
+        // 1. Stop the server if we spawned it
+        try {
+            await this.stopServer();
+        }
+        catch {
+            // Already logged in stopServer
+        }
+        /*
+         * 2. NOTHING IS KILLED BY PORT OR BY NAME.
+         *
+         * This used to run `lsof -ti :4096 | xargs kill -9`, and on a developer's
+         * machine that is a SIGKILL to the human's own opencode server — a process
+         * this program did not start, holding sessions it does not own. There is no
+         * version of "recovery" that justifies it: killing by port kills whoever
+         * holds the port, and killing by name kills whoever shares the name.
+         *
+         * With an OWNED policy there is nothing to kill anyway. `stopServer` above
+         * closes the server this instance spawned, by handle, and a handle cannot
+         * name someone else's process.
+         */
+        /*
+         * 3. Clear the database ONLY when this runner owns the state directory.
+         *
+         * A corrupted database is a real failure mode after a crash or an opencode
+         * upgrade, and deleting it is a reasonable repair — of OUR state. Applied
+         * to a SHARED server it is not a repair, it is destroying a human's entire
+         * opencode history to fix our own process, so the shared policy repairs
+         * nothing and says so.
+         */
+        const ownedStateDir = this.ownedStateDir();
+        if (!ownedStateDir) {
+            console.warn('[OpencodeAdapter] Shared opencode server: not clearing a database ' +
+                'this runner does not own. Recovery is limited to reconnecting.');
+        }
+        else {
+            const dbFiles = ['opencode.db', 'opencode.db-shm', 'opencode.db-wal'];
+            for (const file of dbFiles) {
+                const filePath = (0, path_1.join)(ownedStateDir, file);
+                try {
+                    if ((0, fs_1.existsSync)(filePath)) {
+                        (0, fs_1.unlinkSync)(filePath);
+                        console.log(`[OpencodeAdapter] Deleted corrupted DB file: ${filePath}`);
+                    }
+                }
+                catch (err) {
+                    console.warn(`[OpencodeAdapter] Could not delete ${filePath}:`, err);
+                }
+            }
+        }
+        // 4. Reset adapter state so the next getClient() call spawns a fresh server
+        this.serverUrl = null;
+        this.serverInstance = null;
+        this.sharedClient = null;
+        this.quickClient = null;
+        this.v2Client = null;
+        this.serverStarting = null;
+        this.configPushed = false;
+        // Brief pause to let the OS release the port
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        console.log('[OpencodeAdapter] Recovery complete, will spawn fresh server on next call');
+    }
+    async checkHealth() {
+        try {
+            const client = await this.getClient(undefined, { quick: true });
+            const result = await client.global.health();
+            if (result.error) {
+                return { available: false, reason: 'Server not responding' };
+            }
+            const health = result.data;
+            console.log('[OpencodeAdapter] Health check OK, version:', health.version);
+            return { available: true };
+        }
+        catch (error) {
+            return {
+                available: false,
+                reason: error instanceof Error ? error.message : 'Server not accessible'
+            };
+        }
+    }
+    async findAccessibleServer(url) {
+        const urls = [url];
+        if (url.includes('localhost')) {
+            urls.push(url.replace('localhost', '127.0.0.1'));
+        }
+        else if (url.includes('127.0.0.1')) {
+            urls.push(url.replace('127.0.0.1', 'localhost'));
+        }
+        for (const testUrl of urls) {
+            try {
+                const response = await fetch(`${testUrl}/global/health`, {
+                    signal: AbortSignal.timeout(2000)
+                });
+                if (response.ok) {
+                    return testUrl;
+                }
+            }
+            catch {
+                // Try next URL
+            }
+        }
+        return null;
+    }
+    /**
+     * Ensures common binary install paths (e.g. ~/.opencode/bin) are in PATH
+     * so the SDK's createOpencode can find the `opencode` binary.
+     */
+    ensureBinaryPaths() {
+        const currentPath = process.env.PATH || '';
+        // Include user-configured custom binary path (set via deps:setOpencodePath
+        // in onboarding). Without this the installer finds opencode but the adapter
+        // cannot, because the custom path is only added to PATH during deps:check.
+        const customPath = this.db?.getSetting('OPENCODE_BINARY_PATH') ?? null;
+        const extraPaths = [
+            ...(customPath ? [customPath] : []),
+            (0, path_1.join)((0, os_1.homedir)(), '.opencode', 'bin'),
+            ...(process.platform === 'win32'
+                ? [(0, path_1.join)((0, os_1.homedir)(), 'AppData', 'Roaming', 'npm')]
+                : ['/usr/local/bin']),
+            (0, path_1.join)((0, os_1.homedir)(), '.local', 'bin')
+        ].filter((p) => !currentPath.includes(p));
+        if (extraPaths.length > 0) {
+            process.env.PATH = [...extraPaths, currentPath].join(path_1.delimiter);
+            console.log('[OpencodeAdapter] Added binary paths to PATH:', extraPaths);
+        }
+    }
+    setBashTimeoutDefault() {
+        // Set bash tool timeout if not already configured.
+        // Without this, bash commands inside the agent run indefinitely — a single
+        // hung `npm install` or `git clone` will keep the session stuck forever.
+        // 10 minutes is generous enough for legitimate long-running commands while
+        // preventing truly stuck processes.
+        if (!process.env.OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS) {
+            process.env.OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS = '600000'; // 10 minutes
+            console.log('[OpencodeAdapter] Set OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS=600000 (10min)');
+        }
+    }
+    /**
+     * Spawn THIS runner's own opencode server.
+     *
+     * Three properties, each deliberate:
+     *  - a port the kernel chose, bound to LOOPBACK ONLY, so it collides with
+     *    nothing and is reachable from nowhere else;
+     *  - its own state directory, so its sessions are its own and are not
+     *    pruned, listed or shared by anybody else's use of opencode;
+     *  - spawned, so `stopServer` has a `serverInstance` to close and the
+     *    "adopted, not mine to close" branch is unreachable.
+     *
+     * The state directory is passed through `XDG_DATA_HOME`, which is how
+     * opencode locates `opencode.db` — verified against opencode 1.18.23 by
+     * pointing a server at a private directory and finding its database there.
+     */
+    async startOwnedServer(stateDir, environment = {}) {
+        try {
+            (0, fs_1.mkdirSync)(stateDir, { recursive: true, mode: 0o700 });
+            /*
+             * Set on the harness process because the SDK spawns `opencode serve` as
+             * a child and the child inherits this environment. Safe to leave set: an
+             * OWNED policy is the only policy that reaches here, and it wants every
+             * opencode this process ever starts to use exactly this directory.
+             */
+            process.env.XDG_DATA_HOME = stateDir;
+            const port = await (0, opencode_server_policy_1.ephemeralLoopbackPort)();
+            const extraConfig = {};
+            if (this.pluginFilePaths.length > 0) {
+                extraConfig.plugin = [...this.pluginFilePaths];
+            }
+            const mergedConfig = (0, opencode_config_1.buildMergedOpencodeConfig)(extraConfig, this.gateway);
+            console.log(`[OpencodeAdapter] Starting OWNED opencode server on 127.0.0.1:${port} ` +
+                `(state ${stateDir}); it will never adopt a server it did not spawn`);
+            // The SDK has no environment option. Its async create call spawns the
+            // child before its first await. Install this turn's values for that spawn
+            // only, then restore the harness environment while startup completes.
+            const previous = new Map();
+            for (const key of [
+                'HTTP_PROXY',
+                'http_proxy',
+                'https_proxy',
+                'ALL_PROXY',
+                'all_proxy',
+                'no_proxy'
+            ]) {
+                previous.set(key, process.env[key]);
+                delete process.env[key];
+            }
+            for (const [key, value] of Object.entries(environment)) {
+                if (!previous.has(key))
+                    previous.set(key, process.env[key]);
+                process.env[key] = value;
+            }
+            const sdk = OpenCodeV2;
+            let started;
+            try {
+                started = sdk.createOpencode({
+                    hostname: '127.0.0.1',
+                    port,
+                    timeout: 30000,
+                    config: mergedConfig
+                });
+            }
+            finally {
+                for (const [key, value] of previous) {
+                    if (value === undefined)
+                        delete process.env[key];
+                    else
+                        process.env[key] = value;
+                }
+            }
+            const { client, server } = await started;
+            this.serverInstance = server;
+            this.serverUrl = server.url;
+            this.sharedClient = client;
+            this.quickClient = OpenCodeV2Client.createOpencodeClient({
+                baseUrl: server.url,
+                fetch: quickTimeoutFetch
+            });
+            console.log(`[OpencodeAdapter] OWNED opencode server ready at ${server.url}`);
+        }
+        finally {
+            this.serverStarting = null;
+            this.startEventSubscription();
+        }
+    }
+    async ensureServerRunning(targetUrl = DEFAULT_SERVER_URL, environment = {}) {
+        /*
+         * AN OWNED SERVER IGNORES `targetUrl` ENTIRELY.
+         *
+         * `targetUrl` reaches here from `config.serverUrl || DEFAULT_SERVER_URL`,
+         * and DEFAULT_SERVER_URL is the well-known 4096 a human may already be
+         * using. When this runner owns its server there is nothing to look for and
+         * nothing to negotiate: it spawns its own on a loopback port the kernel
+         * chose, or it fails. It NEVER probes 4096 and so can never adopt.
+         */
+        if (this.serverPolicy.kind === 'owned') {
+            if (this.serverUrl && this.serverInstance)
+                return;
+            if (this.serverStarting)
+                return this.serverStarting;
+            await this.ensureSDKLoaded();
+            this.ensureBinaryPaths();
+            this.setBashTimeoutDefault();
+            this.serverStarting = this.startOwnedServer(this.serverPolicy.stateDir, environment);
+            return this.serverStarting;
+        }
+        if (this.serverUrl) {
+            if (this.serverUrl === targetUrl) {
+                return;
+            }
+        }
+        if (this.serverStarting) {
+            return this.serverStarting;
+        }
+        await this.ensureSDKLoaded();
+        // Ensure common binary install paths are in PATH so the SDK can find `opencode`
+        this.ensureBinaryPaths();
+        this.setBashTimeoutDefault();
+        const isDefaultUrl = targetUrl === DEFAULT_SERVER_URL || targetUrl === 'http://127.0.0.1:4096';
+        this.serverStarting = (async () => {
+            try {
+                const accessibleUrl = await this.findAccessibleServer(targetUrl);
+                if (accessibleUrl) {
+                    this.serverUrl = accessibleUrl;
+                    this.serverInstance = null;
+                    // Create a V2 client for the existing server (has global.health())
+                    this.sharedClient = OpenCodeV2Client.createOpencodeClient({
+                        baseUrl: accessibleUrl
+                    });
+                    // Create a separate client with bounded timeout for quick operations
+                    this.quickClient = OpenCodeV2Client.createOpencodeClient({
+                        baseUrl: accessibleUrl,
+                        fetch: quickTimeoutFetch
+                    });
+                    // Push merged config (with auth.json keys injected) once on first connection
+                    // so custom providers like routerAI are properly authenticated.
+                    // This is the ONLY automatic config push; subsequent pushes happen only via
+                    // explicit notifyConfigChanged() calls to avoid aborting running sessions.
+                    try {
+                        // Use quickClient to avoid hanging indefinitely when the existing server is slow.
+                        await this.pushMergedConfigToClient(this.quickClient);
+                    }
+                    catch {
+                        // pushMergedConfigToClient already logs details
+                    }
+                    // Start SSE subscription for permission events
+                    this.startEventSubscription();
+                    return;
+                }
+                if (!isDefaultUrl) {
+                    throw new Error(`OpenCode server not accessible at ${targetUrl}`);
+                }
+                // Use SDK's createOpencode (starts server + client together, per docs).
+                // The SDK picks up opencode.json automatically; we pass a merged config
+                // that injects auth.json API keys into custom provider options so
+                // providers like routerAI are properly authenticated.
+                const url = new URL(targetUrl);
+                const hostname = url.hostname;
+                const port = parseInt(url.port || '4096', 10);
+                const extraConfig = {};
+                if (this.pluginFilePaths.length > 0) {
+                    extraConfig.plugin = [...this.pluginFilePaths];
+                    console.log('[OpencodeAdapter] Passing plugins to server config:', this.pluginFilePaths);
+                }
+                const mergedConfig = (0, opencode_config_1.buildMergedOpencodeConfig)(extraConfig, this.gateway);
+                console.log(`[OpencodeAdapter] Creating opencode instance at ${hostname}:${port} via SDK v2 createOpencode`);
+                const { client, server } = await OpenCodeV2.createOpencode({
+                    hostname,
+                    port,
+                    timeout: 10000,
+                    config: mergedConfig
+                });
+                this.serverInstance = server;
+                this.serverUrl = server.url;
+                this.sharedClient = client;
+                // Create a separate client with bounded timeout for quick operations
+                this.quickClient = OpenCodeV2Client.createOpencodeClient({
+                    baseUrl: server.url,
+                    fetch: quickTimeoutFetch
+                });
+                console.log(`[OpencodeAdapter] OpenCode instance created at ${server.url}`);
+            }
+            finally {
+                this.serverStarting = null;
+                // Start SSE subscription for permission events once the server is up
+                this.startEventSubscription();
+            }
+        })();
+        return this.serverStarting;
+    }
+    async createSession(config) {
+        // Write runtime plugin files BEFORE server starts so they are discovered at startup.
+        // Plugins that depend on support files read them dynamically, so updates can take
+        // effect without restarting the server.
+        this.writeRuntimePluginFiles(config);
+        /*
+         * WIRE 5, AND IT MUST BE BEFORE `session.create`.
+         *
+         * Written after the session was created, this file has no effect: OpenCode
+         * resolves a project's config when the session is created, so a permission
+         * block that appears afterwards is simply never consulted. Verified the
+         * hard way — with the write one line later, three real turns ran `ls -a` to
+         * completion in `ask` mode and NOT ONE raised a prompt, while the file on
+         * disk said `"bash": "ask"` the whole time. Do not move this below.
+         */
+        this.writeSessionPermissionConfig(config.workspaceDir, config.permissionMode || 'ask');
+        await this.ensureServerRunning(config.serverUrl || DEFAULT_SERVER_URL, config.environment);
+        // Config is pushed once on first server connection (ensureServerRunning).
+        // Subsequent config changes (key rotation, settings edit) go through
+        // notifyConfigChanged() called by the agent-manager — NOT here.
+        // Pushing config on every createSession caused a storm of PATCH /global/config
+        // calls that aborted all running sessions when parallel tasks started.
+        const baseUrl = this.serverUrl || config.serverUrl || DEFAULT_SERVER_URL;
+        // Default client uses SDK's built-in timeout (60s) for session create, polling, MCP ops, etc.
+        const ocClient = OpenCodeSDK.createOpencodeClient({ baseUrl });
+        // Separate client with no timeout — used ONLY for session.prompt() which runs indefinitely
+        const promptClient = OpenCodeSDK.createOpencodeClient({
+            baseUrl,
+            fetch: noTimeoutFetch
+        });
+        // Register runtime plugins via directory-scoped config.update().
+        // Using the directory scope avoids side-effects on other sessions — unscoped
+        // config patches can trigger disposeAllInstances on the OpenCode server,
+        // which kills MCP connections for every running session.
+        if (this.pluginFilePaths.length > 0) {
+            try {
+                await ocClient.config.update({
+                    body: { plugin: [...this.pluginFilePaths] },
+                    ...(config.workspaceDir && {
+                        query: { directory: config.workspaceDir }
+                    })
+                });
+                console.log('[OpencodeAdapter] Registered runtime plugins via config.update:', this.pluginFilePaths);
+            }
+            catch (err) {
+                console.warn('[OpencodeAdapter] config.update for runtime plugins failed (will rely on startup loading):', err);
+            }
+        }
+        // Register MCP servers BEFORE creating session so the session picks them up
+        let attachResult = { attached: [], failed: [] };
+        if (config.mcpServers) {
+            attachResult = await this.attachAndVerifyMcpServers(ocClient, config.mcpServers, config.workspaceDir, `createSession task=${config.taskId}`);
+        }
+        // Create OpenCode session
+        const result = await ocClient.session.create({
+            body: { title: `Task ${config.taskId}` },
+            ...(config.workspaceDir && { query: { directory: config.workspaceDir } })
+        });
+        if (result.error) {
+            const errData = result.error;
+            throw new Error(errData.data?.message || errData.name || 'Failed to create session');
+        }
+        if (!result.data?.id) {
+            throw new Error('No session ID returned from OpenCode');
+        }
+        const ocSessionId = result.data.id;
+        this.writeTillDoneSessionConfig(ocSessionId, config.tillDone !== false);
+        this.clients.set(ocSessionId, ocClient);
+        this.promptClients.set(ocSessionId, promptClient);
+        this.sessionPermissionModes.set(ocSessionId, config.permissionMode || 'ask');
+        if (config.workspaceDir)
+            this.sessionWorkspaceDirs.set(ocSessionId, config.workspaceDir);
+        if (config.mcpServers)
+            this.sessionMcpConfigs.set(ocSessionId, config.mcpServers);
+        this.setMcpAttachFailures(ocSessionId, attachResult.failed);
+        return ocSessionId;
+    }
+    async resumeSession(sessionId, config) {
+        // Update runtime plugin files before resuming (plugins read support files dynamically)
+        this.writeRuntimePluginFiles(config);
+        await this.ensureServerRunning(config.serverUrl || DEFAULT_SERVER_URL, config.environment);
+        const baseUrl = this.serverUrl || config.serverUrl || DEFAULT_SERVER_URL;
+        // Default client uses SDK's built-in timeout for polling/status
+        const ocClient = OpenCodeSDK.createOpencodeClient({ baseUrl });
+        // Separate client with no timeout for session.prompt() only
+        const promptClient = OpenCodeSDK.createOpencodeClient({
+            baseUrl,
+            fetch: noTimeoutFetch
+        });
+        // Register runtime plugins via directory-scoped config.update() to avoid
+        // side-effects on other sessions (see createSession comment).
+        if (this.pluginFilePaths.length > 0) {
+            try {
+                await ocClient.config.update({
+                    body: { plugin: [...this.pluginFilePaths] },
+                    ...(config.workspaceDir && {
+                        query: { directory: config.workspaceDir }
+                    })
+                });
+                console.log('[OpencodeAdapter] Registered runtime plugins via config.update:', this.pluginFilePaths);
+            }
+            catch (err) {
+                console.warn('[OpencodeAdapter] config.update for runtime plugins failed:', err);
+            }
+        }
+        // Re-register MCP servers — after a 20x restart, stdio MCP server
+        // processes (task-management, GCP logs) are dead and need re-registration.
+        // Remote MCP servers may also have lost their SSE connections.
+        // OpenCode handles transient mid-session reconnections internally, so this
+        // is only needed on resume, not during normal operation.
+        if (config.mcpServers) {
+            const attachResult = await this.attachAndVerifyMcpServers(ocClient, config.mcpServers, config.workspaceDir, `resumeSession session=${sessionId}`);
+            this.setMcpAttachFailures(sessionId, attachResult.failed);
+        }
+        // Validate session exists
+        const getResult = await ocClient.session.get({
+            path: { id: sessionId },
+            ...(config.workspaceDir && { query: { directory: config.workspaceDir } })
+        });
+        if (getResult.error || !getResult.data) {
+            throw new Error('Session no longer exists on server');
+        }
+        // ── Clean up stale session state from previous app instance ──
+        // When the app restarts and resumes a session, tool calls from the
+        // previous instance may still be in "running" state.  The OpenCode
+        // server reports these as "busy" even though nothing is actually
+        // executing.  This blocks new prompts and aborts.
+        //
+        // Fix: abort any in-progress prompt, then delete zombie "running"
+        // tool parts via V2 part.delete.
+        try {
+            await ocClient.session.abort({
+                path: { id: sessionId },
+                ...(config.workspaceDir && {
+                    query: { directory: config.workspaceDir }
+                })
+            });
+            console.log(`[OpencodeAdapter] Aborted any in-progress prompt on resume for session ${sessionId}`);
+        }
+        catch {
+            // Non-fatal: session may already be idle
+        }
+        // Delete zombie "running" tool parts that survived the abort.
+        // When a prompt is aborted, individual tool parts remain in
+        // "running" state permanently.  The server counts them as active
+        // work, so the session stays "busy" forever — a catch-22 that
+        // prevents both new prompts and message deletion.
+        // Using v2.part.delete is the only way to clear them.
+        try {
+            if (OpenCodeV2Client) {
+                const v2 = this.v2Client ||
+                    OpenCodeV2Client.createOpencodeClient({
+                        baseUrl: this.serverUrl || DEFAULT_SERVER_URL
+                    });
+                if (!this.v2Client)
+                    this.v2Client = v2;
+                // Scan messages for zombie running tool parts
+                const msgsResult = await ocClient.session.messages({
+                    path: { id: sessionId },
+                    ...(config.workspaceDir && {
+                        query: { directory: config.workspaceDir }
+                    })
+                });
+                let zombieCount = 0;
+                if (msgsResult.data && Array.isArray(msgsResult.data)) {
+                    for (const msg of msgsResult.data) {
+                        const msgId = msg.info
+                            ? msg.info.id
+                            : undefined;
+                        if (!msgId)
+                            continue;
+                        for (const part of msg.parts || []) {
+                            if (part.type !== 'tool')
+                                continue;
+                            const state = part.state;
+                            if (state?.status !== 'running')
+                                continue;
+                            try {
+                                await v2.part.delete({
+                                    sessionID: sessionId,
+                                    messageID: msgId,
+                                    partID: part.id,
+                                    ...(config.workspaceDir && { directory: config.workspaceDir })
+                                });
+                                zombieCount++;
+                            }
+                            catch {
+                                // Part may already have been cleaned up
+                            }
+                        }
+                    }
+                }
+                if (zombieCount > 0) {
+                    console.log(`[OpencodeAdapter] Deleted ${zombieCount} zombie running tool part(s) on resume for session ${sessionId}`);
+                    // Abort again after cleanup to transition the server from busy → idle
+                    try {
+                        await ocClient.session.abort({
+                            path: { id: sessionId },
+                            ...(config.workspaceDir && {
+                                query: { directory: config.workspaceDir }
+                            })
+                        });
+                    }
+                    catch {
+                        // Non-fatal
+                    }
+                }
+                /*
+                 * CLEAR STALE PENDING PERMISSIONS — AND THE ANSWER DEPENDS ON THE MODE.
+                 *
+                 * THIS USED TO AUTO-APPROVE, UNCONDITIONALLY, WITH `reply: 'always'`.
+                 * It was harmless while nothing ever raised a permission: OpenCode was
+                 * never configured to ask (see `writeSessionPermissionConfig`), so this
+                 * loop had nothing to find. Making permissions real turned it into a
+                 * live bypass — a harness crash or restart while a genuine "allow this
+                 * shell command?" prompt was outstanding would silently grant it BEFORE
+                 * THE USER EVER SAW IT, and `'always'` would suppress every future
+                 * prompt for that pattern too.
+                 *
+                 * That is exactly the unattended-access defect G1 exists to close,
+                 * reappearing through the resume path, and it was reachable only
+                 * because of the fix. Found in review, not by a test — the resume path
+                 * has no coverage for it, which is recorded rather than hidden.
+                 *
+                 * REJECT, for an asking session. The permission belongs to a turn that
+                 * has already ended; neither answer resurrects it, so the choice is
+                 * purely which way to fail. A rejected tool call is recoverable — the
+                 * user asks again. An approved one is not.
+                 *
+                 * An `allow` session is the one case where approving is what the user
+                 * actually chose, and it matches what `handleServerEvent` does live.
+                 */
+                const resumeMode = config.permissionMode || 'ask';
+                const staleReply = resumeMode === 'allow' ? 'always' : 'reject';
+                const listResult = await v2.permission.list({});
+                if (listResult.data && Array.isArray(listResult.data)) {
+                    const allPending = listResult.data;
+                    const sessionPending = allPending.filter((p) => p.sessionID === sessionId);
+                    for (const perm of sessionPending) {
+                        try {
+                            await v2.permission.reply({
+                                requestID: perm.id,
+                                reply: staleReply
+                            });
+                            console.log(`[OpencodeAdapter] Cleared stale permission ${perm.id} on resume with "${staleReply}" (permissionMode=${resumeMode})`);
+                        }
+                        catch {
+                            // Permission may have already expired
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.warn(`[OpencodeAdapter] Failed to clean up stale session state on resume:`, err instanceof Error ? err.message : err);
+        }
+        this.clients.set(sessionId, ocClient);
+        this.promptClients.set(sessionId, promptClient);
+        this.sessionPermissionModes.set(sessionId, config.permissionMode || 'ask');
+        if (config.workspaceDir)
+            this.sessionWorkspaceDirs.set(sessionId, config.workspaceDir);
+        if (config.mcpServers)
+            this.sessionMcpConfigs.set(sessionId, config.mcpServers);
+        // WIRE 5, on the resume path too. A workspace is rebuilt per turn, so a
+        // resumed session that skipped this would silently run unrestricted — the
+        // defect returning on the SECOND message of every conversation.
+        this.writeSessionPermissionConfig(config.workspaceDir, config.permissionMode || 'ask');
+        this.writeTillDoneSessionConfig(sessionId, config.tillDone !== false);
+        // Fetch existing messages
+        const messagesResult = await ocClient.session.messages({
+            path: { id: sessionId },
+            ...(config.workspaceDir && { query: { directory: config.workspaceDir } })
+        });
+        const messages = [];
+        if (messagesResult.data && Array.isArray(messagesResult.data)) {
+            for (const msg of messagesResult.data) {
+                if (!msg.info)
+                    continue;
+                const rawParts = msg.parts || [];
+                const transformedParts = rawParts.map((part, partIndex) => {
+                    const scopedPartId = this.getScopedPartId(String(msg.info.id), part.id, partIndex);
+                    if (part.type === 'tool') {
+                        return {
+                            ...this.transformToolPart(part),
+                            id: scopedPartId
+                        };
+                    }
+                    return {
+                        id: scopedPartId,
+                        type: part.type,
+                        text: part.text,
+                        content: part.text
+                    };
+                });
+                // Surface provider errors stored in msg.info.error (e.g. "Payment
+                // Required", quota exceeded).  OpenCode records these on the message
+                // info but creates no parts for them, so without this they vanish on
+                // resume.
+                const msgError = msg.info.error;
+                if (msgError && transformedParts.length === 0) {
+                    const errorText = msgError.data?.message || msgError.name || 'Unknown provider error';
+                    transformedParts.push({
+                        id: `error-${msg.info.id}`,
+                        type: 'text',
+                        text: `⚠️ Provider error: ${errorText}`,
+                        content: `⚠️ Provider error: ${errorText}`
+                    });
+                }
+                messages.push({
+                    id: msg.info.id,
+                    role: (msg.info.role || 'assistant'),
+                    parts: transformedParts
+                });
+            }
+        }
+        return messages;
+    }
+    async sendPrompt(sessionId, parts, config) {
+        // Use the no-timeout prompt client for session.prompt() which runs indefinitely.
+        // Falls back to the default client if promptClients entry is missing (shouldn't happen).
+        const ocClient = this.promptClients.get(sessionId) || this.clients.get(sessionId);
+        if (!ocClient) {
+            throw new Error(`No client found for session ${sessionId}`);
+        }
+        // Parse model from config
+        let modelParam;
+        if (config.model) {
+            const slashIdx = config.model.indexOf('/');
+            if (slashIdx > 0) {
+                modelParam = {
+                    providerID: config.model.slice(0, slashIdx),
+                    modelID: config.model.slice(slashIdx + 1)
+                };
+            }
+        }
+        const promptAbort = new AbortController();
+        this.promptAborts.set(sessionId, promptAbort);
+        // Fire-and-forget prompt with retry — the HTTP call stays open until the full
+        // agent loop completes (including tool call execution).  getStatus() checks
+        // promptAborts to reliably report BUSY while this call is in flight.
+        // Retries handle transient "Aborted" errors caused by config pushes or
+        // provider concurrency limits.
+        console.log(`[OpencodeAdapter] Sending prompt for session ${sessionId} (model: ${config.model || 'default'})`);
+        this.executePromptWithRetry(ocClient, sessionId, parts, modelParam, config, promptAbort).finally(() => {
+            this.promptAborts.delete(sessionId);
+        });
+    }
+    /**
+     * Returns true if the error message indicates a transient condition that
+     * may succeed on retry (e.g. OpenCode server aborted the session processor
+     * due to a config push, or the provider returned a temporary overload).
+     */
+    isRetryablePromptError(msg) {
+        const lower = msg.toLowerCase();
+        return (lower === 'aborted' ||
+            lower.includes('aborted') ||
+            lower.includes('overloaded') ||
+            lower.includes('service unavailable'));
+    }
+    /**
+     * Executes a prompt with automatic retry for transient errors.
+     * Keeps the AbortController in promptAborts alive during retries so
+     * getStatus() continues to report BUSY.
+     */
+    async executePromptWithRetry(ocClient, sessionId, parts, modelParam, config, promptAbort) {
+        const maxRetries = OpencodeAdapter.PROMPT_MAX_RETRIES;
+        const baseDelay = OpencodeAdapter.PROMPT_RETRY_BASE_DELAY_MS;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            if (promptAbort.signal.aborted)
+                return;
+            const promptStartTime = Date.now();
+            if (attempt > 0) {
+                console.log(`[OpencodeAdapter] Retry attempt ${attempt}/${maxRetries} for session ${sessionId}`);
+            }
+            try {
+                const result = await ocClient.session.prompt({
+                    path: { id: sessionId },
+                    body: {
+                        parts: parts,
+                        ...(modelParam && { model: modelParam }),
+                        ...(config.tools && { tools: config.tools })
+                    },
+                    ...(config.workspaceDir && {
+                        query: { directory: config.workspaceDir }
+                    }),
+                    signal: promptAbort.signal
+                });
+                const elapsed = Date.now() - promptStartTime;
+                console.log(`[OpencodeAdapter] Prompt completed for session ${sessionId} after ${elapsed}ms`);
+                // Log tool call details from the response for debugging
+                const res = result;
+                if (res?.data?.parts) {
+                    const toolParts = res.data.parts.filter((p) => p.type === 'tool');
+                    if (toolParts.length > 0) {
+                        console.log(`[OpencodeAdapter] Response contains ${toolParts.length} tool part(s):`, toolParts.map((p) => ({
+                            tool: p.tool,
+                            status: p.state?.status
+                        })));
+                    }
+                }
+                // Check for provider errors in the prompt response (e.g. quota exceeded,
+                // payment required, rate limit).  OpenCode wraps these in result.data.info.error
+                // but does NOT create a message with the error text, so pollMessages never
+                // picks them up and the user sees "idle" with no response.
+                const r = result;
+                const promptError = r?.data?.info?.error;
+                if (promptError) {
+                    const errorMsg = promptError.data?.message ||
+                        promptError.name ||
+                        'Unknown provider error';
+                    // Retry transient errors (e.g. "Aborted" from config push tearing down the bus)
+                    if (this.isRetryablePromptError(errorMsg) && attempt < maxRetries) {
+                        const delay = baseDelay * Math.pow(2, attempt);
+                        console.warn(`[OpencodeAdapter] Retryable provider error "${errorMsg}" for ${sessionId}, retrying (${attempt + 1}/${maxRetries}) after ${delay}ms`);
+                        await new Promise((resolve) => setTimeout(resolve, delay));
+                        continue;
+                    }
+                    console.error(`[OpencodeAdapter] Provider error for ${sessionId}: ${errorMsg}`);
+                    this.promptErrors.set(sessionId, errorMsg);
+                    if (this.onDataAvailable) {
+                        this.onDataAvailable(sessionId);
+                    }
+                }
+                // Success or non-retryable error — stop retrying
+                return;
+            }
+            catch (err) {
+                // User-initiated abort — exit silently
+                if (err instanceof Error && err.name === 'AbortError')
+                    return;
+                const errorMsg = err instanceof Error ? err.message : String(err);
+                // Retry transient HTTP-level errors
+                if (this.isRetryablePromptError(errorMsg) && attempt < maxRetries) {
+                    const delay = baseDelay * Math.pow(2, attempt);
+                    console.warn(`[OpencodeAdapter] Retryable HTTP error "${errorMsg}" for ${sessionId}, retrying (${attempt + 1}/${maxRetries}) after ${delay}ms`);
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                    continue;
+                }
+                console.error('[OpencodeAdapter] prompt error:', err);
+                // Surface HTTP-level errors (network failures, 4xx/5xx, connection refused)
+                // via promptErrors so getStatus() returns ERROR instead of silent IDLE.
+                this.promptErrors.set(sessionId, errorMsg);
+                if (this.onDataAvailable) {
+                    this.onDataAvailable(sessionId);
+                }
+                return;
+            }
+        }
+    }
+    async getStatus(sessionId, config) {
+        const ocClient = this.clients.get(sessionId);
+        if (!ocClient) {
+            return { type: coding_agent_adapter_1.SessionStatusType.ERROR, message: 'Client not found' };
+        }
+        // Check for pending permissions BEFORE the promptAborts check.
+        // Permissions block tool execution while the prompt HTTP call is still
+        // in-flight.  If we don't surface them here, the session appears busy
+        // forever because the prompt never completes.
+        if (this.pendingPermissions.has(sessionId) &&
+            (this.pendingPermissions.get(sessionId)?.length ?? 0) > 0) {
+            return { type: coding_agent_adapter_1.SessionStatusType.WAITING_APPROVAL };
+        }
+        // If the session.prompt() HTTP call is still in-flight, the agent is
+        // definitely still working — regardless of what the status API reports.
+        // This prevents premature IDLE detection when the status API briefly
+        // returns idle between tool call rounds or when using models (like
+        // featherless kimi k2.5) whose tool call format may not be fully
+        // reflected in the status endpoint.
+        if (this.promptAborts.has(sessionId)) {
+            return { type: coding_agent_adapter_1.SessionStatusType.BUSY };
+        }
+        const statusResult = await ocClient.session.status({
+            ...(config.workspaceDir && { query: { directory: config.workspaceDir } })
+        });
+        if (!statusResult.data) {
+            return this.resolveIdleOrPromptError(sessionId);
+        }
+        const ocStatus = statusResult.data[sessionId];
+        if (!ocStatus) {
+            return this.resolveIdleOrPromptError(sessionId);
+        }
+        const sdkType = (ocStatus.type || 'idle');
+        if (sdkType === 'waiting_approval' ||
+            sdkType === 'waiting_input' ||
+            sdkType === 'waiting_user') {
+            return { type: coding_agent_adapter_1.SessionStatusType.WAITING_APPROVAL };
+        }
+        // Check for pending questions via V2 SDK
+        try {
+            const v2 = this.getV2Client(config);
+            const listResult = await v2.question.list({
+                ...(config.workspaceDir && { directory: config.workspaceDir })
+            });
+            if (!listResult.error && listResult.data) {
+                const questions = listResult.data;
+                const targetQuestion = questions.find((q) => q.sessionID === sessionId ||
+                    q.sessionId === sessionId);
+                if (targetQuestion?.id) {
+                    return { type: coding_agent_adapter_1.SessionStatusType.WAITING_APPROVAL };
+                }
+            }
+        }
+        catch {
+            // Ignore errors when checking for questions
+        }
+        // If the status API says idle, double-check the messages for tool parts
+        // that are still pending/running. Some models (like featherless kimi k2.5)
+        // may have tool calls in flight that the status API doesn't reflect.
+        if (sdkType === 'idle') {
+            try {
+                const messagesResult = await ocClient.session.messages({
+                    path: { id: sessionId },
+                    ...(config.workspaceDir && {
+                        query: { directory: config.workspaceDir }
+                    })
+                });
+                if (messagesResult.data && Array.isArray(messagesResult.data)) {
+                    // Check the last assistant message for pending tool parts
+                    for (let i = messagesResult.data.length - 1; i >= 0; i--) {
+                        const msg = messagesResult.data[i];
+                        if (!msg.info || msg.info.role === 'user')
+                            continue;
+                        const parts = msg.parts || [];
+                        for (const part of parts) {
+                            if (part.type === 'tool') {
+                                const state = part.state;
+                                const toolStatus = state?.status;
+                                if (toolStatus === 'pending' || toolStatus === 'running') {
+                                    console.log(`[OpencodeAdapter] Status API says idle but tool part ${part.id} is ${toolStatus} — reporting BUSY`);
+                                    return { type: coding_agent_adapter_1.SessionStatusType.BUSY };
+                                }
+                            }
+                        }
+                        // Only check the last assistant message
+                        break;
+                    }
+                }
+            }
+            catch (err) {
+                console.warn('[OpencodeAdapter] Failed to check messages for pending tools:', err);
+            }
+        }
+        const statusType = sdkType.toUpperCase();
+        const resolvedType = coding_agent_adapter_1.SessionStatusType[statusType] ?? coding_agent_adapter_1.SessionStatusType.IDLE;
+        if (resolvedType === coding_agent_adapter_1.SessionStatusType.IDLE) {
+            return this.resolveIdleOrPromptError(sessionId);
+        }
+        return {
+            type: resolvedType,
+            message: 'message' in ocStatus
+                ? ocStatus.message
+                : undefined
+        };
+    }
+    /**
+     * Returns ERROR with captured prompt error if one exists, otherwise IDLE.
+     * Called from getStatus when the backend reports no active work.
+     */
+    resolveIdleOrPromptError(sessionId) {
+        const promptError = this.promptErrors.get(sessionId);
+        if (promptError) {
+            this.promptErrors.delete(sessionId);
+            return { type: coding_agent_adapter_1.SessionStatusType.ERROR, message: promptError };
+        }
+        return { type: coding_agent_adapter_1.SessionStatusType.IDLE };
+    }
+    /**
+     * Transforms a raw OpenCode tool part into the structured format the renderer expects.
+     * OpenCode returns tool name as `part.tool` (string) and details in `part.state`.
+     */
+    transformToolPart(part) {
+        const state = (part.state || {});
+        const stateInput = (state.input && typeof state.input === 'object' ? state.input : {});
+        const toolName = part.tool || 'unknown';
+        const status = state.status || 'unknown';
+        const inputStr = stateInput && Object.keys(stateInput).length > 0
+            ? JSON.stringify(stateInput, null, 2)
+            : undefined;
+        const outputStr = state.output
+            ? String(state.output).slice(0, 2000)
+            : undefined;
+        const errorStr = status === 'error' && state.error ? String(state.error) : undefined;
+        // Detect interactive question tools
+        let questions = stateInput.questions;
+        if (typeof questions === 'string') {
+            try {
+                questions = JSON.parse(questions);
+            }
+            catch { }
+        }
+        // Detect TodoWrite tools
+        let todos = stateInput.todos;
+        if (typeof todos === 'string') {
+            try {
+                todos = JSON.parse(todos);
+            }
+            catch { }
+        }
+        let partType = 'tool';
+        if (Array.isArray(questions) && questions.length > 0)
+            partType = 'question';
+        else if (Array.isArray(todos) && todos.length > 0)
+            partType = 'todowrite';
+        return {
+            id: part.id,
+            type: partType,
+            text: part.text,
+            content: part.text,
+            tool: {
+                name: toolName,
+                status,
+                title: state.title || undefined,
+                input: inputStr,
+                output: outputStr,
+                error: errorStr,
+                ...(Array.isArray(questions) && questions.length > 0 && { questions }),
+                /*
+                 * NORMALISED HERE, as the Claude adapter already does.
+                 *
+                 * opencode's `todowrite` input carries no `id`, and this forwarded it
+                 * raw — so every todo reached a renderer with `id: undefined`. Both
+                 * renderers key the list on `todo.id` directly (20x's
+                 * `AgentTranscriptPanel` and the workflow-builder `TodoBlock`), so the
+                 * list was keyed entirely on `undefined`: React warns, and colliding
+                 * keys let it reuse the wrong DOM node, so ticking one item can repaint
+                 * a different row.
+                 *
+                 * THE ADAPTER IS THE RIGHT HOME and the renderer is not. A renderer
+                 * that repaired the data would be guessing at what the backend meant,
+                 * and there are two of them to keep in step; the adapter is the one
+                 * place that knows this backend's shape. `claude-code-adapter` already
+                 * normalises exactly here, so this closes a gap between the two rather
+                 * than inventing a rule.
+                 */
+                ...(Array.isArray(todos) &&
+                    todos.length > 0 && { todos: normaliseTodoIds(todos) })
+            },
+            state: part.state
+        };
+    }
+    async pollMessages(sessionId, seenMessageIds, seenPartIds, partContentLengths, config) {
+        const ocClient = this.clients.get(sessionId);
+        if (!ocClient) {
+            return [];
+        }
+        const messagesResult = await ocClient.session.messages({
+            path: { id: sessionId },
+            ...(config.workspaceDir && { query: { directory: config.workspaceDir } })
+        });
+        if (!messagesResult.data || !Array.isArray(messagesResult.data)) {
+            return [];
+        }
+        const newParts = [];
+        for (const msg of messagesResult.data) {
+            if (!msg.info)
+                continue;
+            const msgId = msg.info.id;
+            const msgRole = msg.info.role; // Get role from message
+            // Skip if already seen and no parts have changed
+            const isNewMessage = !seenMessageIds.has(msgId);
+            if (isNewMessage) {
+                seenMessageIds.add(msgId);
+            }
+            const parts = msg.parts && Array.isArray(msg.parts) ? msg.parts : [];
+            for (const [partIndex, part] of parts.entries()) {
+                const partId = this.getScopedPartId(String(msgId), part.id, partIndex);
+                if (!partId)
+                    continue;
+                // Cast part to a loose record for uniform property access across SDK Part union members
+                const p = part;
+                const isNewPart = !seenPartIds.has(partId);
+                const isUpdatable = part.type === 'text' ||
+                    part.type === 'reasoning' ||
+                    part.type === 'tool';
+                if (isUpdatable) {
+                    const fingerprint = part.type === 'tool'
+                        ? `${p.state?.status}:${part.type}:${p.text?.length ?? 0}:${p.state?.output?.length ?? 0}`
+                        : String(p.text?.length ?? 0);
+                    const oldFingerprint = partContentLengths.get(partId);
+                    const hasChanged = oldFingerprint !== fingerprint;
+                    if (isNewPart || hasChanged) {
+                        seenPartIds.add(partId);
+                        partContentLengths.set(partId, fingerprint);
+                        if (part.type === 'tool') {
+                            const transformed = this.transformToolPart(p);
+                            newParts.push({
+                                ...transformed,
+                                id: partId,
+                                role: msgRole,
+                                update: !isNewPart
+                            });
+                        }
+                        else {
+                            newParts.push({
+                                id: partId,
+                                type: part.type,
+                                text: p.text,
+                                content: p.text,
+                                role: msgRole,
+                                update: !isNewPart
+                            });
+                        }
+                    }
+                }
+                else if (isNewPart) {
+                    seenPartIds.add(partId);
+                    newParts.push({
+                        id: partId,
+                        type: part.type,
+                        text: p.text,
+                        content: p.text,
+                        role: msgRole // Include role from message
+                    });
+                }
+            }
+        }
+        return newParts;
+    }
+    async getRunningTools(sessionId, config) {
+        const ocClient = this.clients.get(sessionId);
+        if (!ocClient)
+            return [];
+        try {
+            const messagesResult = await ocClient.session.messages({
+                path: { id: sessionId },
+                ...(config.workspaceDir && {
+                    query: { directory: config.workspaceDir }
+                })
+            });
+            if (!messagesResult.data || !Array.isArray(messagesResult.data))
+                return [];
+            const running = [];
+            for (const msg of messagesResult.data) {
+                const parts = msg.parts;
+                if (!parts || !Array.isArray(parts))
+                    continue;
+                for (const part of parts) {
+                    if (part.type !== 'tool')
+                        continue;
+                    const state = part.state;
+                    if (!state || state.status !== 'running')
+                        continue;
+                    const timeObj = state.time;
+                    const input = state.input;
+                    running.push({
+                        partId: part.id,
+                        toolName: part.tool || 'unknown',
+                        startTime: timeObj?.start,
+                        input: input || undefined
+                    });
+                }
+            }
+            return running;
+        }
+        catch (err) {
+            console.warn(`[OpencodeAdapter] getRunningTools failed for ${sessionId}:`, err instanceof Error ? err.message : err);
+            return [];
+        }
+    }
+    async abortPrompt(sessionId, _config) {
+        const abort = this.promptAborts.get(sessionId);
+        if (abort) {
+            abort.abort();
+            this.promptAborts.delete(sessionId);
+        }
+        // Also abort the session on the server side to ensure the backend
+        // stops processing. Without this, the backend continues running the
+        // old prompt (model generating tokens, bash commands executing) and
+        // rejects or queues new prompts — so the user can't recover by
+        // sending a follow-up message.
+        const ocClient = this.clients.get(sessionId);
+        if (ocClient) {
+            try {
+                await ocClient.session.abort({
+                    path: { id: sessionId },
+                    ...(_config.workspaceDir && {
+                        query: { directory: _config.workspaceDir }
+                    })
+                });
+                console.log(`[OpencodeAdapter] Server-side abort sent for session ${sessionId}`);
+            }
+            catch (err) {
+                // Non-fatal: the local abort is sufficient for the HTTP request.
+                // Server-side abort can fail if session is already idle or not found.
+                console.warn(`[OpencodeAdapter] Server-side abort failed for ${sessionId}:`, err instanceof Error ? err.message : err);
+            }
+        }
+    }
+    async destroySession(sessionId, _config) {
+        await this.abortPrompt(sessionId, _config);
+        // Release the stdio MCP children of this session before dropping the client.
+        // They are children of the long-lived `opencode serve` process, so nothing
+        // else would ever stop them.
+        await this.disconnectSessionMcpServers(sessionId);
+        this.clients.delete(sessionId);
+        this.promptClients.delete(sessionId);
+        this.pendingPermissions.delete(sessionId);
+        this.sessionPermissionModes.delete(sessionId);
+        this.sessionWorkspaceDirs.delete(sessionId);
+        this.sessionMcpConfigs.delete(sessionId);
+        this.sessionMcpAttachFailures.delete(sessionId);
+        this.removeTillDoneSessionConfig(sessionId);
+        if (this.clients.size > 0) {
+            return;
+        }
+        // Clean up generated runtime plugins and any support files they use.
+        for (const filePath of [
+            ...this.pluginFilePaths,
+            ...this.runtimeSupportFilePaths
+        ]) {
+            if (filePath) {
+                try {
+                    if ((0, fs_1.existsSync)(filePath)) {
+                        (0, fs_1.rmSync)(filePath);
+                        console.log(`[OpencodeAdapter] Removed runtime plugin file: ${filePath}`);
+                    }
+                }
+                catch (err) {
+                    console.warn(`[OpencodeAdapter] Failed to remove runtime plugin file: ${err}`);
+                }
+            }
+        }
+        this.pluginFilePaths = [];
+        this.runtimeSupportFilePaths = [];
+        this.tillDoneConfigPath = null;
+    }
+    /**
+     * Writes all generated runtime plugin files needed for this session.
+     * MUST be called BEFORE ensureServerRunning() so plugins are discovered at startup.
+     */
+    writeRuntimePluginFiles(config) {
+        this.pluginFilePaths = [];
+        this.runtimeSupportFilePaths = [];
+        this.tillDoneConfigPath = null;
+        if (!config.workspaceDir) {
+            return;
+        }
+        const openCodeDir = (0, path_1.join)(config.workspaceDir, '.opencode');
+        const pluginsDir = (0, path_1.join)(openCodeDir, 'plugins');
+        (0, fs_1.mkdirSync)(pluginsDir, { recursive: true });
+        this.writeTillDonePlugin(openCodeDir, pluginsDir, config.tillDone !== false);
+        this.writeSecretPlugin(config, openCodeDir, pluginsDir);
+    }
+    writeSecretPlugin(config, openCodeDir, pluginsDir) {
+        const secretCount = config.secretEnvVars
+            ? Object.keys(config.secretEnvVars).length
+            : 0;
+        console.log(`[OpencodeAdapter] writeSecretFiles: workspaceDir=${config.workspaceDir}, secretCount=${secretCount}`);
+        if (!config.secretEnvVars || secretCount === 0) {
+            console.log(`[OpencodeAdapter] writeSecretFiles: skipping — no secrets or no workspaceDir`);
+            return;
+        }
+        // 1. Write pre-formatted export commands to a secrets file.
+        //    The plugin reads this file on every bash invocation so updates take effect immediately.
+        const exportLines = Object.entries(config.secretEnvVars)
+            .map(([k, v]) => 'export ' + k + "='" + v.replace(/'/g, "'\\''") + "'")
+            .join('\n');
+        const secretsPath = (0, path_1.join)(openCodeDir, '.20x-secrets');
+        (0, fs_1.writeFileSync)(secretsPath, exportLines, 'utf-8');
+        this.runtimeSupportFilePaths.push(secretsPath);
+        // 2. Write the plugin JS that reads the secrets file and prepends exports to bash commands.
+        //    Uses tool.execute.before hook (same pattern as Claude Code PreToolUse).
+        const pluginPath = (0, path_1.join)(pluginsDir, '20x-secret-injector.js');
+        const pluginCode = this.buildSecretInjectorPluginCode(secretsPath);
+        (0, fs_1.writeFileSync)(pluginPath, pluginCode, 'utf-8');
+        this.pluginFilePaths.push(pluginPath);
+        console.log(`[OpencodeAdapter] Wrote secret files: plugin=${pluginPath}, secrets=${secretsPath} (${Object.keys(config.secretEnvVars).length} secret(s))`);
+    }
+    writeTillDonePlugin(openCodeDir, pluginsDir, enabled) {
+        const statePath = (0, path_1.join)(openCodeDir, '.20x-tilldone-state.json');
+        if (!(0, fs_1.existsSync)(statePath)) {
+            (0, fs_1.writeFileSync)(statePath, '{}\n', 'utf-8');
+        }
+        this.runtimeSupportFilePaths.push(statePath);
+        const configPath = (0, path_1.join)(openCodeDir, '.20x-tilldone-config.json');
+        const existingConfig = this.readTillDoneConfigFile(configPath);
+        (0, fs_1.writeFileSync)(configPath, JSON.stringify({
+            defaultEnabled: enabled,
+            sessions: existingConfig.sessions
+        }), 'utf-8');
+        this.runtimeSupportFilePaths.push(configPath);
+        this.tillDoneConfigPath = configPath;
+        const pluginPath = (0, path_1.join)(pluginsDir, '20x-tilldone.js');
+        const pluginCode = this.buildTillDonePluginCode(statePath, configPath);
+        (0, fs_1.writeFileSync)(pluginPath, pluginCode, 'utf-8');
+        this.pluginFilePaths.push(pluginPath);
+        console.log(`[OpencodeAdapter] Wrote tilldone plugin: plugin=${pluginPath}, state=${statePath}, enabled=${enabled}`);
+    }
+    readTillDoneConfig() {
+        if (!this.tillDoneConfigPath) {
+            return { defaultEnabled: true, sessions: {} };
+        }
+        return this.readTillDoneConfigFile(this.tillDoneConfigPath);
+    }
+    readTillDoneConfigFile(configPath) {
+        if (!(0, fs_1.existsSync)(configPath)) {
+            return { defaultEnabled: true, sessions: {} };
+        }
+        try {
+            const parsed = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf-8') || '{}');
+            const sessions = parsed.sessions &&
+                typeof parsed.sessions === 'object' &&
+                !Array.isArray(parsed.sessions)
+                ? Object.fromEntries(Object.entries(parsed.sessions).filter(([, value]) => typeof value === 'boolean'))
+                : {};
+            return {
+                defaultEnabled: parsed.defaultEnabled !== undefined
+                    ? parsed.defaultEnabled !== false
+                    : parsed.enabled !== false,
+                sessions
+            };
+        }
+        catch {
+            return { defaultEnabled: true, sessions: {} };
+        }
+    }
+    writeTillDoneConfig(config) {
+        if (!this.tillDoneConfigPath)
+            return;
+        (0, fs_1.writeFileSync)(this.tillDoneConfigPath, JSON.stringify(config), 'utf-8');
+    }
+    /**
+     * TELL OPENCODE TO ASK — defect G1's fifth wire, and the one that decides
+     * whether the other four are observable at all on this backend.
+     *
+     * THE PROBLEM. This adapter REACTS to `permission.asked`: it queues the
+     * permission, reports WAITING_APPROVAL, and offers getPendingApproval /
+     * respondToApproval. Nothing ever asked OpenCode to EMIT one. Only
+     * `external_directory` defaults to "ask" — `bash`, `edit` and `webfetch`
+     * default to allow — so the entire approval path was unreachable for every
+     * action a user would actually want to approve.
+     *
+     * MEASURED against a real `opencode serve` 1.18.25, real model, real `ls -a`:
+     *   no `permission` in the effective config  ->  permission.asked x0
+     *   `permission: {bash|edit|webfetch:'ask'}` ->  permission.asked x1, shaped
+     *      { id, sessionID, permission:'bash', patterns:['ls -a'], ... },
+     *      exactly what `handleServerEvent` already parses.
+     *
+     * WHY A FILE IN THE SESSION'S WORKSPACE, AND NOT THE MERGED SERVER CONFIG.
+     *
+     * The obvious place is `buildMergedOpencodeConfig`, and it is WRONG in two
+     * ways that only showed up by running it:
+     *
+     *   1. IT IS SERVER-WIDE. One OpenCode server serves every session on the
+     *      host — including, on a desktop, sessions this harness did not create.
+     *      A verification run that set it there immediately began raising
+     *      permission prompts for unrelated agent sessions belonging to the
+     *      machine's owner.
+     *   2. IT PERSISTS. `client.global.config.update` WRITES THROUGH to
+     *      `~/.config/opencode/opencode.json`. Setting a permission policy there
+     *      permanently rewrites the user's own OpenCode configuration — a file
+     *      this product does not own.
+     *
+     * A per-directory `opencode.json` has neither problem, and OpenCode really
+     * does honour it per session: with one shared server, `GET /config` returned
+     * `null` for the server's own cwd and `{bash:'ask',...}` for a session
+     * workspace containing this file. Verified before relying on it.
+     *
+     * WHY IT IS DERIVED FROM THE SESSION'S OWN MODE. Because it can be, now that
+     * it is per-session. A `bypassPermissions` agent writes `allow` and never
+     * pays a round trip; an asking agent writes `ask` and its permissions reach a
+     * human. One agent's choice cannot affect another's.
+     *
+     * THE MERGE IS DELIBERATELY ONE-WAY. Any `opencode.json` already in the
+     * workspace keeps its other keys, but NOT its permission block: a file in the
+     * workspace is attacker-influenceable — the agent can write there — so
+     * letting it weaken this would be defect G10's shape, an access control
+     * bypassable by a file on disk.
+     */
+    writeSessionPermissionConfig(workspaceDir, permissionMode) {
+        if (!workspaceDir)
+            return;
+        const decision = permissionMode === 'allow' ? 'allow' : 'ask';
+        const configPath = (0, path_1.join)(workspaceDir, 'opencode.json');
+        let existing = {};
+        try {
+            if ((0, fs_1.existsSync)(configPath)) {
+                existing = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf-8'));
+            }
+        }
+        catch {
+            // A workspace config we cannot parse is replaced rather than merged.
+            // Failing open here would mean no permission block at all, which is the
+            // defect this method exists to close.
+            existing = {};
+        }
+        const merged = {
+            $schema: 'https://opencode.ai/config.json',
+            ...existing,
+            // LAST, so the spread above can never weaken it.
+            permission: {
+                ...(existing.permission ?? {}),
+                bash: decision,
+                edit: decision,
+                webfetch: decision
+            }
+        };
+        try {
+            (0, fs_1.mkdirSync)(workspaceDir, { recursive: true });
+            (0, fs_1.writeFileSync)(configPath, JSON.stringify(merged, null, 2), 'utf-8');
+            console.log(`[OpencodeAdapter] Wrote session permission config: ${configPath} (bash/edit/webfetch=${decision})`);
+        }
+        catch (err) {
+            // Loud, because a silent failure here is exactly defect G1 again: the
+            // agent would run unrestricted while the UI showed the user their mode.
+            console.error(`[OpencodeAdapter] FAILED to write session permission config at ${configPath}. ` +
+                `Permissions for this session will NOT be enforced:`, err);
+        }
+    }
+    writeTillDoneSessionConfig(sessionId, enabled) {
+        const config = this.readTillDoneConfig();
+        this.writeTillDoneConfig({
+            ...config,
+            sessions: {
+                ...config.sessions,
+                [sessionId]: enabled
+            }
+        });
+    }
+    removeTillDoneSessionConfig(sessionId) {
+        if (!this.tillDoneConfigPath || !(0, fs_1.existsSync)(this.tillDoneConfigPath))
+            return;
+        const config = this.readTillDoneConfig();
+        if (!(sessionId in config.sessions))
+            return;
+        const sessions = { ...config.sessions };
+        delete sessions[sessionId];
+        this.writeTillDoneConfig({ ...config, sessions });
+    }
+    buildSecretInjectorPluginCode(secretsPath) {
+        return [
+            '// Auto-generated by 20x — do not edit. Removed on session destroy.',
+            'import { readFileSync } from "fs";',
+            '',
+            'var SECRETS_PATH = ' + JSON.stringify(secretsPath) + ';',
+            '',
+            'export var SecretInjector = async function() {',
+            '  return {',
+            '    "tool.execute.before": async function(input, output) {',
+            '      if (input.tool === "bash") {',
+            '        try {',
+            '          var exports = readFileSync(SECRETS_PATH, "utf-8").trim();',
+            '          if (exports) output.args.command = exports + "\\n" + output.args.command;',
+            '        } catch(e) {}',
+            '      }',
+            '    }',
+            '  };',
+            '};',
+            ''
+        ].join('\n');
+    }
+    buildTillDonePluginCode(statePath, configPath) {
+        const initialTodoPrompt = 'TillDone: before using other tools, call the built-in todowrite tool to create a concise task list for this task. Keep the list current as you work.';
+        return [
+            '// Auto-generated by 20x — do not edit. Removed on session destroy.',
+            'import { readFileSync, writeFileSync } from "fs";',
+            '',
+            'var STATE_PATH = ' + JSON.stringify(statePath) + ';',
+            'var CONFIG_PATH = ' + JSON.stringify(configPath) + ';',
+            'var INITIAL_TODO_PROMPT = ' + JSON.stringify(initialTodoPrompt) + ';',
+            '',
+            'function isTillDoneEnabled(sessionId) {',
+            '  if (!sessionId) return false;',
+            '  try {',
+            '    var raw = readFileSync(CONFIG_PATH, "utf-8");',
+            '    var parsed = JSON.parse(raw || "{}");',
+            '    if (parsed?.sessions && typeof parsed.sessions === "object") {',
+            '      if (Object.prototype.hasOwnProperty.call(parsed.sessions, sessionId)) {',
+            '        return parsed.sessions[sessionId] !== false;',
+            '      }',
+            '      return false;',
+            '    }',
+            '    if (Object.prototype.hasOwnProperty.call(parsed || {}, "defaultEnabled")) {',
+            '      return parsed.defaultEnabled !== false;',
+            '    }',
+            '    return parsed?.enabled !== false;',
+            '  } catch (e) {',
+            '    return false;',
+            '  }',
+            '}',
+            '',
+            'function readState() {',
+            '  try {',
+            '    var raw = readFileSync(STATE_PATH, "utf-8");',
+            '    var parsed = JSON.parse(raw || "{}");',
+            '    return parsed && typeof parsed === "object" ? parsed : {};',
+            '  } catch (e) {',
+            '    return {};',
+            '  }',
+            '}',
+            '',
+            'function writeState(state) {',
+            '  try {',
+            '    writeFileSync(STATE_PATH, JSON.stringify(state), "utf-8");',
+            '  } catch (e) {}',
+            '  return state;',
+            '}',
+            '',
+            '// SDK types: tool.execute.before input has { tool, sessionID, callID }',
+            '// SDK types: event hook input has { event: { type, properties: { sessionID, ... } } }',
+            '',
+            'function normalizeTodos(rawTodos) {',
+            '  if (!Array.isArray(rawTodos)) return [];',
+            '  return rawTodos.filter(Boolean).map(function(todo, index) {',
+            '    return {',
+            '      id: todo.id || String(index),',
+            '      content: todo.content || todo.text || todo.title || "",',
+            '      status: todo.status || "pending"',
+            '    };',
+            '  });',
+            '}',
+            '',
+            'export var TillDone = async function({ client }) {',
+            '  return {',
+            '    "tool.execute.before": async function(input) {',
+            '      if (input.tool === "todowrite" || input.tool === "skill" || input.tool === "task") return;',
+            '      var sessionId = input.sessionID;',
+            '      if (!sessionId) return;',
+            '      if (!isTillDoneEnabled(sessionId)) return;',
+            '      var state = readState();',
+            '      var todos = normalizeTodos((state[sessionId] || {}).todos);',
+            '      if (todos.length === 0) {',
+            '        throw new Error(INITIAL_TODO_PROMPT);',
+            '      }',
+            '    },',
+            '    event: async function(input) {',
+            '      var ev = input.event;',
+            '      if (!ev) return;',
+            '      var sessionId = ev.properties?.sessionID;',
+            '      if (!sessionId) return;',
+            '      if (!isTillDoneEnabled(sessionId)) return;',
+            '      var state = readState();',
+            '      var sessionState = state[sessionId] || { todos: [] };',
+            '',
+            '      if (ev.type === "todo.updated") {',
+            '        sessionState.todos = normalizeTodos(ev.properties?.todos || []);',
+            '        state[sessionId] = sessionState;',
+            '        writeState(state);',
+            '        return;',
+            '      }',
+            '',
+            '      if (ev.type === "session.deleted") {',
+            '        delete state[sessionId];',
+            '        writeState(state);',
+            '        return;',
+            '      }',
+            '    }',
+            '  };',
+            '};',
+            ''
+        ].join('\n');
+    }
+    async getAllMessages(sessionId, config) {
+        const ocClient = this.clients.get(sessionId);
+        if (!ocClient) {
+            return [];
+        }
+        try {
+            // Fetch all messages from OpenCode API
+            const messagesResult = await ocClient.session.messages({
+                path: { id: sessionId },
+                ...(config.workspaceDir && {
+                    query: { directory: config.workspaceDir }
+                })
+            });
+            if (!messagesResult.data || !Array.isArray(messagesResult.data)) {
+                return [];
+            }
+            // Convert OpenCode messages to SessionMessage format
+            const messages = messagesResult.data.map((msg, idx) => {
+                const msgInfo = msg.info;
+                const role = msgInfo?.role || 'assistant';
+                const parts = (msg.parts || []);
+                return {
+                    id: msgInfo?.id || `msg-${idx}`,
+                    role: (role === 'user'
+                        ? coding_agent_adapter_1.MessageRole.USER
+                        : coding_agent_adapter_1.MessageRole.ASSISTANT),
+                    parts: parts.map((p, partIndex) => ({
+                        id: this.getScopedPartId(String(msgInfo?.id || `msg-${idx}`), p.id, partIndex),
+                        type: p.type,
+                        text: p.text,
+                        content: p.text
+                    }))
+                };
+            });
+            return messages;
+        }
+        catch (error) {
+            console.error('[OpencodeAdapter] Error fetching messages:', error);
+            return [];
+        }
+    }
+    async registerMcpServer(_serverName, _mcpConfig, _workspaceDir) {
+        // This needs to be called before session creation
+        // We need access to the ocClient, which we don't have yet
+        // For now, this will be handled in the AgentManager until we refactor further
+        throw new Error('registerMcpServer must be called via AgentManager for now');
+    }
+    getV2Client(config) {
+        if (this.v2Client)
+            return this.v2Client;
+        if (!OpenCodeV2Client)
+            throw new Error('OpenCode V2 SDK not loaded');
+        const baseUrl = this.serverUrl || config.serverUrl || DEFAULT_SERVER_URL;
+        this.v2Client = OpenCodeV2Client.createOpencodeClient({ baseUrl });
+        return this.v2Client;
+    }
+    async respondToQuestion(sessionId, answers, config) {
+        const v2 = this.getV2Client(config);
+        try {
+            // List pending questions via V2 SDK
+            const listResult = await v2.question.list({
+                ...(config.workspaceDir && { directory: config.workspaceDir })
+            });
+            if (listResult.error) {
+                throw new Error(`question.list failed: ${JSON.stringify(listResult.error)}`);
+            }
+            const questions = listResult.data ?? [];
+            console.log(`[OpencodeAdapter] Pending questions (${questions.length}):`, questions.map((q) => ({
+                id: q.id,
+                sessionID: q.sessionID,
+                sessionId: q.sessionId,
+                questionCount: q.questions?.length
+            })));
+            // Find the question for this session
+            const question = questions.find((q) => q.sessionID === sessionId ||
+                q.sessionId === sessionId);
+            if (!question?.id) {
+                throw new Error(`[OpencodeAdapter] No pending question found for session ${sessionId}`);
+            }
+            console.log(`[OpencodeAdapter] Matched question:`, JSON.stringify(question, null, 2).slice(0, 1000));
+            // Build answers aligned with the question's questions array order
+            const questionItems = question.questions ?? [];
+            const answerKeys = Object.keys(answers);
+            const formattedAnswers = [];
+            for (let i = 0; i < questionItems.length; i++) {
+                const qItem = questionItems[i];
+                const matchKey = answerKeys.find((k) => k === qItem.header || k === qItem.question);
+                const answerValue = matchKey
+                    ? answers[matchKey]
+                    : Object.values(answers)[i];
+                formattedAnswers.push(answerValue ? [answerValue] : []);
+            }
+            console.log(`[OpencodeAdapter] Replying to question ${question.id} (${questionItems.length} items) with:`, formattedAnswers);
+            // Reply via V2 SDK
+            const replyResult = await v2.question.reply({
+                requestID: question.id,
+                answers: formattedAnswers,
+                ...(config.workspaceDir && { directory: config.workspaceDir })
+            });
+            if (replyResult.error) {
+                throw new Error(`question.reply failed: ${JSON.stringify(replyResult.error)}`);
+            }
+            console.log(`[OpencodeAdapter] Question ${question.id} replied successfully`);
+        }
+        catch (err) {
+            console.error('[OpencodeAdapter] Question API failed:', err);
+            throw err;
+        }
+    }
+    // ========================================================================
+    // Permission handling — OpenCode file-permission prompts surfaced in 20x UI
+    // ========================================================================
+    /**
+     * Returns the first pending permission for a session, formatted as an
+     * approval request the agent-manager can render.  The agent-manager
+     * duck-types for this method on any adapter during polling.
+     */
+    getPendingApproval(sessionId) {
+        const queue = this.pendingPermissions.get(sessionId);
+        if (!queue || queue.length === 0)
+            return null;
+        const pending = queue[0];
+        const pathList = pending.patterns.length > 0
+            ? pending.patterns.join(', ')
+            : 'requested path';
+        return {
+            toolCallId: pending.permissionId,
+            question: `Allow ${pending.permission} access to: ${pathList}`,
+            options: [
+                { optionId: 'allow', name: 'Yes', kind: 'option' },
+                { optionId: 'allow-always', name: 'Always', kind: 'option' },
+                { optionId: 'deny', name: 'No', kind: 'option' }
+            ]
+        };
+    }
+    /**
+     * Responds to a pending permission via the OpenCode HTTP API.
+     * Called by agent-manager when the user approves/denies in the UI.
+     */
+    async respondToApproval(sessionId, approved, optionId) {
+        const queue = this.pendingPermissions.get(sessionId);
+        if (!queue || queue.length === 0) {
+            // Fallback: try the V2 API for pending permissions.
+            // This handles the case where pendingPermissions was lost (e.g., app restart
+            // or watchdog abort) but the permission is still pending in OpenCode.
+            console.warn(`[OpencodeAdapter] No pending permission in memory for session ${sessionId}, trying V2 API fallback`);
+            return await this.respondToPermissionViaV2(sessionId, approved, optionId);
+        }
+        const pending = queue.shift();
+        if (queue.length === 0) {
+            this.pendingPermissions.delete(sessionId);
+        }
+        // OpenCode expects: "once" (allow this time), "always" (remember), or "reject" (deny)
+        let response;
+        if (!approved) {
+            response = 'reject';
+        }
+        else if (optionId === 'allow-always' ||
+            optionId === 'approved-for-session') {
+            response = 'always';
+        }
+        else {
+            response = 'once';
+        }
+        console.log(`[OpencodeAdapter] Responding to permission ${pending.permissionId}: ${response}`);
+        try {
+            const baseUrl = this.serverUrl || DEFAULT_SERVER_URL;
+            const url = `${baseUrl}/session/${encodeURIComponent(sessionId)}/permissions/${encodeURIComponent(pending.permissionId)}`;
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ response })
+            });
+            if (!res.ok) {
+                /*
+                 * A NON-OK STATUS IS A FAILED DELIVERY, AND IT MUST BE REPORTED AS ONE.
+                 *
+                 * This used to warn and fall through to `return true`. The caller then
+                 * recorded the answer as delivered, closed the question card, and wrote
+                 * "Approved" into the transcript — while the backend had never heard
+                 * it and the turn went on waiting for ever.
+                 *
+                 * OpenCode is the only backend wired into the cloud runner, so that
+                 * made the "your answer could not be delivered, please answer again"
+                 * recovery path UNREACHABLE FOR ITS PRIMARY TARGET.
+                 */
+                console.error(`[OpencodeAdapter] Permission response HTTP ${res.status}: ${await res.text().catch(() => '')}`);
+                return false;
+            }
+        }
+        catch (err) {
+            console.error(`[OpencodeAdapter] Failed to respond to permission ${pending.permissionId}:`, err);
+            // Reported, not swallowed — see the comment above.
+            return false;
+        }
+        // Trigger immediate poll so agent-manager sees next pending permission (if any)
+        if (this.onDataAvailable) {
+            this.onDataAvailable(sessionId);
+        }
+        return true;
+    }
+    /**
+     * Fallback: respond to a pending permission via the OpenCode V2 API.
+     * Used when the in-memory pendingPermissions map is empty (e.g., after
+     * app restart or watchdog abort) but the permission is still pending
+     * in the OpenCode backend.
+     *
+     * Uses v2Client.permission.list() (top-level, lists all sessions) and
+     * v2Client.permission.reply() to find and respond to the permission.
+     */
+    async respondToPermissionViaV2(sessionId, approved, optionId) {
+        try {
+            if (!OpenCodeV2Client) {
+                console.warn(`[OpencodeAdapter] Cannot fetch permissions — V2 SDK not loaded`);
+                return false;
+            }
+            const v2 = this.v2Client ||
+                OpenCodeV2Client.createOpencodeClient({
+                    baseUrl: this.serverUrl || DEFAULT_SERVER_URL
+                });
+            if (!this.v2Client)
+                this.v2Client = v2;
+            // permission.list() returns ALL pending permissions across all sessions.
+            // Filter to the target session.
+            const listResult = await v2.permission.list({});
+            if (listResult.error || !listResult.data) {
+                console.warn(`[OpencodeAdapter] V2 permission.list() failed or returned no data for session ${sessionId}`);
+                return false;
+            }
+            const allPending = listResult.data;
+            const sessionPending = allPending.filter((p) => p.sessionID === sessionId);
+            if (sessionPending.length === 0) {
+                console.warn(`[OpencodeAdapter] No pending permissions found via V2 API for session ${sessionId}`);
+                return false;
+            }
+            const first = sessionPending[0];
+            let reply;
+            if (!approved) {
+                reply = 'reject';
+            }
+            else if (optionId === 'allow-always' ||
+                optionId === 'approved-for-session') {
+                reply = 'always';
+            }
+            else {
+                reply = 'once';
+            }
+            const directory = this.sessionWorkspaceDirs.get(sessionId);
+            console.log(`[OpencodeAdapter] Responding to permission ${first.id} via V2 API: ${reply} (permission=${first.permission}, patterns=${first.patterns.join(', ')})`);
+            await v2.permission.reply({
+                requestID: first.id,
+                reply,
+                ...(directory && { directory })
+            });
+            // Trigger immediate poll so agent-manager sees the unblocked session
+            if (this.onDataAvailable) {
+                this.onDataAvailable(sessionId);
+            }
+            return true;
+        }
+        catch (err) {
+            console.error(`[OpencodeAdapter] V2 permission fallback failed for session ${sessionId}:`, err);
+            return false;
+        }
+    }
+    /**
+     * Subscribes to the OpenCode server's SSE event stream to capture
+     * `permission.asked` events.  Must be called after the server is running.
+     * Runs in the background; reconnects automatically on disconnect.
+     */
+    startEventSubscription() {
+        if (this.sseAbort || !this.serverUrl)
+            return;
+        this.sseAbort = new AbortController();
+        // Fire-and-forget — reconnection loop runs in the background
+        this.processEventStream(this.sseAbort.signal).catch(() => { });
+    }
+    async processEventStream(signal) {
+        const baseUrl = this.serverUrl || DEFAULT_SERVER_URL;
+        const url = `${baseUrl}/global/event`;
+        while (!signal.aborted) {
+            try {
+                const response = await globalThis.fetch(url, {
+                    signal,
+                    headers: { Accept: 'text/event-stream' }
+                });
+                const reader = response.body?.getReader();
+                if (!reader)
+                    return;
+                const decoder = new TextDecoder();
+                let buffer = '';
+                while (!signal.aborted) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    // Parse newline-delimited SSE data lines
+                    let nlIdx;
+                    while ((nlIdx = buffer.indexOf('\n')) !== -1) {
+                        const line = buffer.slice(0, nlIdx).trim();
+                        buffer = buffer.slice(nlIdx + 1);
+                        if (line.startsWith('data: ') || line.startsWith('data:')) {
+                            const json = line.startsWith('data: ')
+                                ? line.slice(6)
+                                : line.slice(5);
+                            if (!json)
+                                continue;
+                            try {
+                                const event = JSON.parse(json);
+                                this.handleServerEvent(event);
+                            }
+                            catch {
+                                // Not valid JSON — skip
+                            }
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                if (signal.aborted)
+                    return;
+                if (err instanceof Error && err.name === 'AbortError')
+                    return;
+                console.warn('[OpencodeAdapter] SSE connection error, reconnecting in 3s:', err instanceof Error ? err.message : err);
+                await new Promise((resolve) => setTimeout(resolve, 3_000));
+            }
+        }
+    }
+    /**
+     * Handle a single SSE event from the OpenCode server.
+     * We only care about `permission.asked` events.
+     *
+     * The /global/event endpoint wraps events in a `payload` envelope:
+     *   { payload: { id, type, properties } }
+     * The /event endpoint returns events directly:
+     *   { id, type, properties }
+     * We handle both formats.
+     */
+    handleServerEvent(event) {
+        // Unwrap /global/event payload envelope if present
+        const inner = (event.payload || event);
+        const type = inner.type;
+        if (type !== 'permission.asked')
+            return;
+        const props = (inner.properties || inner);
+        const permissionId = (props.id || props.permissionID);
+        const sessionID = (props.sessionID || props.sessionId);
+        const permission = (props.permission || props.name || 'unknown');
+        const patterns = (props.patterns || []);
+        if (!permissionId || !sessionID) {
+            console.warn('[OpencodeAdapter] permission.asked event missing id or sessionID:', JSON.stringify(event).slice(0, 300));
+            return;
+        }
+        console.log(`[OpencodeAdapter] Permission requested: ${permission} for session ${sessionID} (${permissionId}) patterns=${patterns.join(', ')}`);
+        // Auto-approve if the agent's permission mode is 'allow'
+        const mode = this.sessionPermissionModes.get(sessionID) || 'ask';
+        if (mode === 'allow') {
+            console.log(`[OpencodeAdapter] Auto-approving permission ${permissionId} (permissionMode=allow)`);
+            this.autoApprovePermission(sessionID, permissionId).catch((err) => {
+                console.error(`[OpencodeAdapter] Auto-approve failed for ${permissionId}:`, err);
+            });
+            return;
+        }
+        // Append to the session's permission queue for UI handling
+        let queue = this.pendingPermissions.get(sessionID);
+        if (!queue) {
+            queue = [];
+            this.pendingPermissions.set(sessionID, queue);
+        }
+        // Deduplicate by permissionId
+        if (!queue.some((p) => p.permissionId === permissionId)) {
+            queue.push({ permissionId, permission, patterns });
+        }
+        // Trigger immediate poll so agent-manager renders the approval prompt
+        if (this.onDataAvailable) {
+            this.onDataAvailable(sessionID);
+        }
+    }
+    /**
+     * Silently approve a permission request (used when permissionMode is 'allow').
+     * Uses the V2 SDK permission.reply() which hits the correct endpoint
+     * (POST /permission/{requestID}/reply). The V1 endpoint
+     * (POST /session/{id}/permissions/{permissionID}) returns 404 for
+     * permissions created by the V2 system.
+     */
+    async autoApprovePermission(sessionId, permissionId) {
+        // Resolve the workspace directory for this session — the OpenCode server
+        // may need it to properly scope the permission reply.
+        const directory = this.sessionWorkspaceDirs.get(sessionId);
+        try {
+            // Try V2 SDK first — this is the correct endpoint for V2 permissions
+            if (OpenCodeV2Client) {
+                const v2 = this.v2Client ||
+                    OpenCodeV2Client.createOpencodeClient({
+                        baseUrl: this.serverUrl || DEFAULT_SERVER_URL
+                    });
+                if (!this.v2Client)
+                    this.v2Client = v2;
+                await v2.permission.reply({
+                    requestID: permissionId,
+                    reply: 'always',
+                    ...(directory && { directory })
+                });
+                console.log(`[OpencodeAdapter] Auto-approved permission ${permissionId} via V2 API${directory ? ` (dir=${directory})` : ''}`);
+                return;
+            }
+            // Fallback to raw fetch if V2 SDK is not available
+            const baseUrl = this.serverUrl || DEFAULT_SERVER_URL;
+            const dirQuery = directory
+                ? `?directory=${encodeURIComponent(directory)}`
+                : '';
+            const url = `${baseUrl}/permission/${encodeURIComponent(permissionId)}/reply${dirQuery}`;
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ reply: 'always' })
+            });
+            if (!res.ok) {
+                console.warn(`[OpencodeAdapter] Auto-approve HTTP ${res.status}: ${await res.text().catch(() => '')}`);
+            }
+        }
+        catch (err) {
+            console.error(`[OpencodeAdapter] Auto-approve failed for ${permissionId}:`, err);
+        }
+    }
+    stopEventSubscription() {
+        if (this.sseAbort) {
+            this.sseAbort.abort();
+            this.sseAbort = null;
+        }
+    }
+    async stopServer() {
+        this.stopEventSubscription();
+        this.pendingPermissions.clear();
+        if (this.serverInstance) {
+            try {
+                await this.serverInstance.close();
+            }
+            catch (error) {
+                console.error('[OpencodeAdapter] Error stopping server:', error);
+            }
+        }
+        else if (this.serverUrl) {
+            // The server was adopted, not spawned by this app instance (see
+            // findAccessibleServer), so it is not ours to close. Say so: an adopted
+            // server outlives the app and keeps every MCP stdio child it ever
+            // attached, which is how those children pile up over days.
+            console.log(`[OpencodeAdapter] Not closing adopted opencode server at ${this.serverUrl} (not spawned by this instance)`);
+        }
+        // Reset client state in both cases — the adopted-server branch used to skip
+        // this and leave stale clients pointing at a server the app no longer uses.
+        this.serverInstance = null;
+        this.serverUrl = null;
+        this.sharedClient = null;
+        this.quickClient = null;
+        this.v2Client = null;
+        this.serverStarting = null;
+        this.configPushed = false;
+    }
+}
+exports.OpencodeAdapter = OpencodeAdapter;