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

package/dist/adapters/acp-adapter.js

@@ -0,0 +1,1732 @@
+"use strict";
+/**
+ * Unified ACP (Agent Client Protocol) adapter for all ACP-compatible coding agents.
+ * Supports: codex-acp and other ACP-compliant agent processes.
+ *
+ * Protocol: JSON-RPC 2.0 over stdio (newline-delimited JSON)
+ * Spec: https://github.com/agentclientprotocol/typescript-sdk
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AcpAdapter = void 0;
+/**
+ * Extracted verbatim from 20x `src/main/adapters/acp-adapter.ts`.
+ * CHANGED: imports only — `../child-stream-guards` ->
+ * `../runtime/child-stream-guards`. The `app.asar` -> `app.asar.unpacked`
+ * path rewrite is a plain string replace with no Electron import and is left
+ * exactly as it was. Source formatting (no semicolons) preserved.
+ */
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
+const child_stream_guards_1 = require("../runtime/child-stream-guards");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const util_1 = require("util");
+const coding_agent_adapter_1 = require("./coding-agent-adapter");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+const CURSOR_ACP_MODEL_VALUES = {
+    'composer-2.5': 'composer-2.5[fast=true]',
+    'grok-4.5': 'grok-4.5[effort=high,fast=true]'
+};
+/**
+ * Unified ACP adapter for all ACP-compatible agents
+ */
+class AcpAdapter {
+    agentType;
+    agentConfig;
+    sessions = new Map();
+    debugRpcLogs;
+    /**
+     * Maximum number of raw JSON-RPC messages to keep in permanent history.
+     * This is used for replaying transcripts upon session resume.
+     * 1,000 events is enough for ~50-100 turns.  Lowered from 2,000 to reduce
+     * memory footprint — each event can be multi-KB (tool outputs).
+     */
+    static MAX_PERMANENT_MESSAGES = 1000;
+    /**
+     * Maximum number of entries in toolCallMetadata before pruning.
+     * This map caches tool_call metadata for in-progress tool calls and should
+     * be pruned if it grows beyond what's reasonable (e.g. due to un-cleaned
+     * entries from tool calls that never completed).
+     */
+    static MAX_TOOL_CALL_METADATA = 500;
+    /** Callback set by agent-manager to trigger an immediate poll cycle */
+    onDataAvailable;
+    constructor(agentType) {
+        this.agentType = agentType;
+        this.agentConfig = this.getAgentConfig(agentType);
+        this.debugRpcLogs = AcpAdapter.isDebugLogLevel(process.env.LOG_LEVEL);
+    }
+    static isDebugLogLevel(value) {
+        if (!value)
+            return false;
+        const normalized = value.trim().toLowerCase();
+        return normalized === 'debug' || normalized === 'trace';
+    }
+    /**
+     * Resolve the path to the codex-acp native binary for the current platform.
+     *
+     * codex-acp ships as a native binary per platform (e.g. codex-acp-darwin-arm64).
+     * The JS wrapper (codex-acp.js) uses import.meta.resolve() which returns an ASAR
+     * path — but the OS can't execute a native binary from inside an ASAR archive.
+     * We bypass the wrapper and resolve the native binary directly, replacing the
+     * ASAR path with the unpacked path (electron-builder auto-unpacks native binaries).
+     *
+     * pnpm note: the platform-specific package (e.g. codex-acp-darwin-arm64) is an
+     * optionalDependency of codex-acp, so under pnpm it is NOT hoisted to the root
+     * node_modules. We must resolve it from codex-acp's own directory using the
+     * `{ paths }` option of require.resolve. In a packaged app (ASAR), electron-builder
+     * flattens the structure so a plain require.resolve would also work.
+     */
+    resolveCodexBinary() {
+        const platformMap = {
+            darwin: { arm64: 'codex-acp-darwin-arm64', x64: 'codex-acp-darwin-x64' },
+            linux: { arm64: 'codex-acp-linux-arm64', x64: 'codex-acp-linux-x64' },
+            win32: { arm64: 'codex-acp-win32-arm64', x64: 'codex-acp-win32-x64' },
+        };
+        const packages = platformMap[process.platform];
+        if (!packages)
+            throw new Error(`Unsupported platform for codex-acp: ${process.platform}`);
+        const packageName = packages[process.arch];
+        if (!packageName)
+            throw new Error(`Unsupported arch for codex-acp: ${process.arch} on ${process.platform}`);
+        const binaryName = process.platform === 'win32' ? 'codex-acp.exe' : 'codex-acp';
+        // Resolve from codex-acp's own directory so pnpm's nested optional deps are found.
+        const codexAcpDir = (0, path_1.dirname)(require.resolve('@zed-industries/codex-acp/package.json'));
+        let binaryPath = require.resolve(`@zed-industries/${packageName}/bin/${binaryName}`, { paths: [codexAcpDir] });
+        // In a packaged Electron app, require.resolve returns an ASAR path like:
+        //   /Applications/20x.app/Contents/Resources/app.asar/node_modules/.../bin/codex-acp
+        // The native binary is auto-unpacked to app.asar.unpacked, so fix the path.
+        if (binaryPath.includes('app.asar')) {
+            binaryPath = binaryPath.replace('app.asar', 'app.asar.unpacked');
+        }
+        console.log(`[AcpAdapter/codex] Resolved native binary: ${binaryPath}`);
+        return binaryPath;
+    }
+    getAgentConfig(agentType) {
+        switch (agentType) {
+            case 'codex':
+                // Codex ships as a native binary — spawn it directly, bypassing the JS wrapper
+                // which fails inside ASAR (see resolveCodexBinary docs for details).
+                return {
+                    command: this.resolveCodexBinary(),
+                    args: [],
+                    // Auth env is decided per-session by configureCodexAuthEnv(), which
+                    // gives the user's Codex CLI login (ChatGPT subscription) priority over
+                    // any ambient OPENAI_API_KEY/CODEX_API_KEY. Do NOT inject ambient keys
+                    // here — that previously hijacked subscription users into API-key auth.
+                    env: {}
+                };
+            case 'cursor':
+                return {
+                    command: 'cursor-agent',
+                    args: ['acp'],
+                    env: {}
+                };
+            default:
+                throw new Error(`Unsupported ACP agent type: ${agentType}`);
+        }
+    }
+    /**
+     * Decide how Codex authenticates for this session and mutate `env` accordingly.
+     * Returns true when API-key auth is used, false when the ChatGPT subscription /
+     * Codex CLI login is used.
+     *
+     * The user's explicit choice in the agent configuration (config.authMethod) is
+     * the source of truth:
+     *   - 'subscription' -> use the Codex CLI login (~/.codex), exactly like running
+     *     `codex` in a terminal. Any ambient OPENAI_API_KEY/CODEX_API_KEY inherited
+     *     from the user's shell is STRIPPED so it cannot hijack auth into API-key
+     *     mode (which bills a separate, often-exhausted quota and made 20x show
+     *     "out of rate limits" even though the terminal subscription worked fine).
+     *   - 'api_key' -> use an API key (the per-agent config key if set, otherwise the
+     *     ambient one) in an isolated temp CODEX_HOME so keys can differ per session.
+     *
+     * When authMethod is unset (legacy agents), fall back to the historical rule but
+     * WITHOUT the ambient-key hijack: only an explicitly-configured per-agent API
+     * key implies API-key mode; otherwise default to the subscription/login path.
+     */
+    configureCodexAuthEnv(env, config) {
+        if (this.agentType !== 'codex')
+            return false;
+        const explicitApiKey = config.apiKeys?.openai;
+        const useApiKey = config.authMethod === 'api_key' ? true
+            : config.authMethod === 'subscription' ? false
+                : !!explicitApiKey; // legacy default: only an explicit key opts into API-key mode
+        if (useApiKey) {
+            const key = explicitApiKey || env.OPENAI_API_KEY || env.CODEX_API_KEY;
+            if (key) {
+                env.OPENAI_API_KEY = key;
+                env.CODEX_API_KEY = key;
+            }
+            env.NO_BROWSER = '1';
+            env.CODEX_HOME = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'codex-session-'));
+            console.log(`[AcpAdapter/codex] Auth: API key (authMethod=${config.authMethod ?? 'legacy'}, isolated CODEX_HOME)`);
+            return true;
+        }
+        // Subscription / Codex CLI login path. Strip ambient keys so they can't
+        // hijack auth away from the ChatGPT subscription in the default CODEX_HOME.
+        delete env.OPENAI_API_KEY;
+        delete env.CODEX_API_KEY;
+        // Pin CODEX_HOME to the same dir the `codex` CLI uses in a terminal, so
+        // codex-acp reads the exact subscription login the user already has. We only
+        // set it when not already provided (a user who runs `codex` with a custom
+        // CODEX_HOME will have it in their shell env, which we inherit and preserve).
+        if (!env.CODEX_HOME) {
+            env.CODEX_HOME = (0, path_1.join)((0, os_1.homedir)(), '.codex');
+        }
+        console.log(`[AcpAdapter/codex] Auth: ChatGPT subscription / Codex CLI login (authMethod=${config.authMethod ?? 'legacy'}, CODEX_HOME=${env.CODEX_HOME})`);
+        return false;
+    }
+    configureCursorAuthEnv(env, config) {
+        if (this.agentType !== 'cursor')
+            return;
+        const explicitApiKey = config.apiKeys?.cursor;
+        const useApiKey = config.authMethod === 'api_key'
+            || (config.authMethod !== 'subscription' && !!explicitApiKey);
+        if (useApiKey) {
+            const key = explicitApiKey || env.CURSOR_API_KEY;
+            if (!key) {
+                throw new Error('Cursor API-key authentication requires a configured key or CURSOR_API_KEY');
+            }
+            env.CURSOR_API_KEY = key;
+            delete env.CURSOR_AUTH_TOKEN;
+            console.log('[AcpAdapter/cursor] Auth: API key');
+            return;
+        }
+        // CLI login is authoritative in subscription mode; ambient keys must not
+        // silently switch billing/authentication away from the logged-in account.
+        delete env.CURSOR_API_KEY;
+        delete env.CURSOR_AUTH_TOKEN;
+        console.log('[AcpAdapter/cursor] Auth: Cursor CLI login');
+    }
+    async initialize() {
+        // Verify agent process is available
+        const health = await this.checkHealth();
+        if (!health.available) {
+            throw new Error(health.reason || 'ACP agent not available');
+        }
+        console.log(`[AcpAdapter/${this.agentType}] Initialized successfully`);
+    }
+    /**
+     * Authenticate the session if required
+     */
+    async authenticateSession(session, initResult) {
+        const initObj = initResult;
+        const authMethods = (Array.isArray(initObj?.authMethods) ? initObj.authMethods : []);
+        if (authMethods.length > 0) {
+            // Use the auth mode decided in configureCodexAuthEnv() rather than sniffing
+            // ambient env vars. An ambient OPENAI_API_KEY in the user's shell must not
+            // flip a subscription user into API-key auth (and filter out "chatgpt").
+            const hasOpenAiKey = session.codexUseApiKey;
+            // When using an API key, filter out "chatgpt" browser-based auth so
+            // codex-acp uses the key instead of opening an OAuth popup. On the
+            // subscription path, allow all methods including chatgpt (Codex CLI login).
+            const usableMethods = (this.agentType === 'codex' && hasOpenAiKey)
+                ? authMethods.filter((m) => m.id !== 'chatgpt')
+                : authMethods;
+            const apiKeyMethod = usableMethods.find((m) => m.id === 'openai-api-key' || m.id === 'codex-api-key');
+            // Select an API-key method when a key is available, otherwise fall back to
+            // any non-key auth method (e.g. existing Codex CLI login via chatgpt).
+            const authMethod = hasOpenAiKey
+                ? (apiKeyMethod || usableMethods[0])
+                : (usableMethods.find((m) => m.id !== 'openai-api-key' && m.id !== 'codex-api-key') || apiKeyMethod || null);
+            console.log(`[AcpAdapter/${this.agentType}] Available auth methods: [${authMethods.map((m) => m.id).join(', ')}]; codexUseApiKey=${session.codexUseApiKey}`);
+            if (!authMethod) {
+                console.log(`[AcpAdapter/${this.agentType}] No usable auth method found; skipping authenticate`);
+                return;
+            }
+            // Note: we do NOT call `logout` before authenticate. When an API key is
+            // provided, CODEX_HOME points to a per-session temp directory so there are
+            // no stale disk credentials. This allows different API keys per session.
+            console.log(`[AcpAdapter/${this.agentType}] Authenticating with method: ${authMethod.id}`);
+            session.codexAuthSummary = `${session.codexUseApiKey ? 'API key' : 'subscription'} via authenticate(${authMethod.id})`;
+            await this.sendRpcRequest(session, 'authenticate', {
+                methodId: authMethod.id
+            });
+        }
+        else {
+            console.log(`[AcpAdapter/${this.agentType}] No auth methods advertised by agent (already authenticated); codexUseApiKey=${session.codexUseApiKey}`);
+        }
+    }
+    async createSession(config) {
+        const sessionId = config.taskId;
+        console.log(`[AcpAdapter/${this.agentType}] Creating session ${sessionId}`);
+        // Prepare environment with API keys
+        const env = {
+            ...process.env,
+            ...this.agentConfig.env
+        };
+        if (config.apiKeys?.anthropic) {
+            env.ANTHROPIC_API_KEY = config.apiKeys.anthropic;
+        }
+        // Inject secret env vars directly into process environment
+        if (config.secretEnvVars && Object.keys(config.secretEnvVars).length > 0) {
+            for (const [key, value] of Object.entries(config.secretEnvVars)) {
+                env[key] = value;
+            }
+        }
+        // Decide Codex auth (subscription vs API key) LAST so it is authoritative.
+        // It must run after secret-env injection: a user secret named OPENAI_API_KEY /
+        // CODEX_API_KEY would otherwise be re-added to env after subscription mode
+        // stripped it, re-hijacking Codex into API-key auth (stale "out of rate
+        // limits" that survives restarts because the secret lives in the DB).
+        const codexUseApiKey = this.configureCodexAuthEnv(env, config);
+        this.configureCursorAuthEnv(env, config);
+        const codexAuthSummary = this.agentType === 'codex'
+            ? `${codexUseApiKey ? 'API key' : 'subscription'} (authMethod=${config.authMethod ?? 'legacy'}, CODEX_HOME=${env.CODEX_HOME ?? 'default'})`
+            : '';
+        // Spawn ACP agent process
+        // On Windows, .cmd/.bat wrappers need shell:true to resolve
+        const needsShell = process.platform === 'win32' && /\.(cmd|bat)$/i.test(this.agentConfig.command);
+        const acpProcess = (0, child_process_1.spawn)(this.agentConfig.command, this.agentConfig.args, {
+            cwd: config.workspaceDir,
+            env,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            ...(needsShell ? { shell: true } : {})
+        });
+        // Every pipe needs an error listener before the first write. The agent can
+        // exit at any moment, and an unhandled EPIPE on its stdin takes the whole
+        // main process down with a crash dialog.
+        (0, child_stream_guards_1.guardChildStreams)(acpProcess, `AcpAdapter/${this.agentType}`);
+        const session = {
+            sessionId,
+            acpSessionId: null,
+            process: acpProcess,
+            stdoutBuffer: '',
+            status: coding_agent_adapter_1.SessionStatusType.IDLE,
+            messageBuffer: [],
+            permanentMessages: [],
+            pendingRequests: new Map(),
+            nextRequestId: 1,
+            pendingApproval: null,
+            config,
+            promptRequestId: null,
+            responseCounter: 0,
+            currentUserTurnId: 0,
+            lastChunkTime: null,
+            currentTurnId: 0,
+            lastSessionUpdateType: null,
+            activeTurnId: null,
+            pendingAssistantTurnSplit: false,
+            toolCallMetadata: new Map(),
+            lastError: null,
+            codexUseApiKey,
+            codexAuthSummary
+        };
+        // Temporarily store with workspace ID, will re-key after getting ACP session ID
+        this.sessions.set(sessionId, session);
+        // Set up stdout parser
+        this.setupStdoutParser(acpProcess, session);
+        // Set up stderr logging
+        acpProcess.stderr?.on('data', (chunk) => {
+            console.log(`[AcpAdapter/${this.agentType}] stderr:`, chunk.toString());
+        });
+        // Handle process exit
+        acpProcess.on('exit', (code, signal) => {
+            console.log(`[AcpAdapter/${this.agentType}] Process exited: code=${code}, signal=${signal}`);
+            session.status = code === 0 ? coding_agent_adapter_1.SessionStatusType.IDLE : coding_agent_adapter_1.SessionStatusType.ERROR;
+        });
+        // Initialize ACP protocol
+        const initResult = await this.sendRpcRequest(session, 'initialize', {
+            protocolVersion: 1,
+            clientCapabilities: {
+                fs: { readTextFile: false, writeTextFile: false },
+                terminal: false
+            },
+            clientInfo: {
+                name: 'pf-desktop',
+                version: '0.0.1'
+            }
+        });
+        // Authenticate if required
+        await this.authenticateSession(session, initResult);
+        // Create ACP session (only accepts cwd and mcpServers per ACP spec)
+        const convertedMcpServers = this.convertMcpServers(config.mcpServers) || [];
+        console.log(`[AcpAdapter/${this.agentType}] session/new mcpServers:`, JSON.stringify(convertedMcpServers));
+        const result = await this.sendRpcRequest(session, 'session/new', {
+            cwd: config.workspaceDir,
+            mcpServers: convertedMcpServers
+        });
+        // Extract session ID from result
+        const acpSessionId = this.extractAcpSessionId(result);
+        if (acpSessionId) {
+            session.acpSessionId = acpSessionId;
+            // Re-key the session map with the ACP session ID
+            this.sessions.delete(sessionId);
+            this.sessions.set(acpSessionId, session);
+        }
+        // Set model if specified
+        if (config.model && acpSessionId) {
+            try {
+                const modelValue = this.agentType === 'cursor'
+                    ? CURSOR_ACP_MODEL_VALUES[config.model] ?? config.model
+                    : config.model;
+                await this.sendRpcRequest(session, 'session/set_config_option', {
+                    sessionId: acpSessionId,
+                    configId: 'model',
+                    value: modelValue
+                });
+                console.log(`[AcpAdapter/${this.agentType}] Model set to: ${config.model}`);
+            }
+            catch (error) {
+                const errMsg = error instanceof Error ? error.message : String(error);
+                console.warn(`[AcpAdapter/${this.agentType}] Failed to set model: ${errMsg}`);
+                // Continue even if model setting fails (agent will use default)
+            }
+        }
+        if (config.reasoningEffort && config.reasoningEffort !== 'max' && acpSessionId) {
+            try {
+                await this.sendRpcRequest(session, 'session/set_config_option', {
+                    sessionId: acpSessionId,
+                    configId: 'model_reasoning_effort',
+                    value: config.reasoningEffort
+                });
+                console.log(`[AcpAdapter/${this.agentType}] Reasoning effort set to: ${config.reasoningEffort}`);
+            }
+            catch (error) {
+                const errMsg = error instanceof Error ? error.message : String(error);
+                console.warn(`[AcpAdapter/${this.agentType}] Failed to set reasoning effort: ${errMsg}`);
+                // Continue even if reasoning effort setting fails (agent will use default)
+            }
+        }
+        console.log(`[AcpAdapter/${this.agentType}] Session created: ${sessionId} (ACP: ${acpSessionId})`);
+        // Return the ACP session ID so it can be persisted and used for resuming
+        return acpSessionId || sessionId;
+    }
+    async resumeSession(sessionId, config) {
+        console.log(`[AcpAdapter/${this.agentType}] Resuming session ${sessionId}`);
+        console.log(`[AcpAdapter/${this.agentType}] Config API keys:`, {
+            hasApiKeys: !!config.apiKeys,
+            hasOpenai: !!config.apiKeys?.openai,
+            hasAnthropic: !!config.apiKeys?.anthropic,
+            anthropicKeyLength: config.apiKeys?.anthropic?.length
+        });
+        // Prepare environment with API keys
+        const env = {
+            ...process.env,
+            ...this.agentConfig.env
+        };
+        if (config.apiKeys?.anthropic) {
+            env.ANTHROPIC_API_KEY = config.apiKeys.anthropic;
+        }
+        // Inject secret env vars directly into process environment
+        if (config.secretEnvVars && Object.keys(config.secretEnvVars).length > 0) {
+            for (const [key, value] of Object.entries(config.secretEnvVars)) {
+                env[key] = value;
+            }
+        }
+        // Decide Codex auth (subscription vs API key) LAST so it is authoritative —
+        // see createSession for why this must run after secret-env injection.
+        const codexUseApiKey = this.configureCodexAuthEnv(env, config);
+        this.configureCursorAuthEnv(env, config);
+        const codexAuthSummary = this.agentType === 'codex'
+            ? `${codexUseApiKey ? 'API key' : 'subscription'} (authMethod=${config.authMethod ?? 'legacy'}, CODEX_HOME=${env.CODEX_HOME ?? 'default'})`
+            : '';
+        console.log(`[AcpAdapter/${this.agentType}] Environment after config:`, {
+            hasAnthropicInEnv: !!env.ANTHROPIC_API_KEY,
+            anthropicKeyLength: env.ANTHROPIC_API_KEY?.length,
+            anthropicKeyPrefix: env.ANTHROPIC_API_KEY?.substring(0, 5)
+        });
+        // Spawn ACP agent process
+        // On Windows, .cmd/.bat wrappers need shell:true to resolve
+        const needsShell = process.platform === 'win32' && /\.(cmd|bat)$/i.test(this.agentConfig.command);
+        const acpProcess = (0, child_process_1.spawn)(this.agentConfig.command, this.agentConfig.args, {
+            cwd: config.workspaceDir,
+            env,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            ...(needsShell ? { shell: true } : {})
+        });
+        // Every pipe needs an error listener before the first write. The agent can
+        // exit at any moment, and an unhandled EPIPE on its stdin takes the whole
+        // main process down with a crash dialog.
+        (0, child_stream_guards_1.guardChildStreams)(acpProcess, `AcpAdapter/${this.agentType}`);
+        const session = {
+            sessionId,
+            acpSessionId: sessionId, // sessionId is now the Codex UUID from database
+            process: acpProcess,
+            stdoutBuffer: '',
+            status: coding_agent_adapter_1.SessionStatusType.IDLE,
+            messageBuffer: [],
+            permanentMessages: [],
+            pendingRequests: new Map(),
+            nextRequestId: 1,
+            pendingApproval: null,
+            config,
+            promptRequestId: null,
+            responseCounter: 0,
+            currentUserTurnId: 0,
+            lastChunkTime: null,
+            currentTurnId: 0,
+            lastSessionUpdateType: null,
+            activeTurnId: null,
+            pendingAssistantTurnSplit: false,
+            toolCallMetadata: new Map(),
+            lastError: null,
+            codexUseApiKey,
+            codexAuthSummary
+        };
+        // Store with the Codex UUID (same as sessionId since we now return UUID from createSession)
+        this.sessions.set(sessionId, session);
+        // Set up stdout parser
+        this.setupStdoutParser(acpProcess, session);
+        // Set up stderr logging
+        acpProcess.stderr?.on('data', (chunk) => {
+            console.log(`[AcpAdapter/${this.agentType}] stderr:`, chunk.toString());
+        });
+        // Handle process exit
+        acpProcess.on('exit', (code, signal) => {
+            console.log(`[AcpAdapter/${this.agentType}] Process exited: code=${code}, signal=${signal}`);
+            session.status = code === 0 ? coding_agent_adapter_1.SessionStatusType.IDLE : coding_agent_adapter_1.SessionStatusType.ERROR;
+        });
+        // Initialize ACP protocol
+        const initResult = await this.sendRpcRequest(session, 'initialize', {
+            protocolVersion: 1,
+            clientCapabilities: {
+                fs: { readTextFile: false, writeTextFile: false },
+                terminal: false
+            },
+            clientInfo: {
+                name: 'pf-desktop',
+                version: '0.0.1'
+            }
+        });
+        // Authenticate if required
+        await this.authenticateSession(session, initResult);
+        // Try to load existing session
+        try {
+            await this.sendRpcRequest(session, 'session/load', {
+                sessionId: sessionId,
+                cwd: config.workspaceDir,
+                mcpServers: this.convertMcpServers(config.mcpServers) || []
+            });
+            console.log(`[AcpAdapter/${this.agentType}] Session loaded successfully: ${sessionId}`);
+            // Convert replayed notifications (buffered during session/load) to SessionMessages.
+            // Without this, the renderer sees status:'idle' + messages:[] and hides the panel.
+            const messages = await this.getAllMessages(sessionId, config);
+            // Drain replayed notifications from the live poll buffer. Otherwise the
+            // first poll after resume/send will emit the whole old transcript again.
+            session.messageBuffer = [];
+            return messages;
+        }
+        catch (error) {
+            // Check if session not found
+            const errMsg = error instanceof Error ? error.message : String(error);
+            if (errMsg.includes('not found') || errMsg.includes('does not exist')) {
+                // Clean up process
+                acpProcess.kill('SIGTERM');
+                this.sessions.delete(sessionId);
+                throw new Error(`INCOMPATIBLE_SESSION_ID: This ${this.agentType} session does not exist or has expired. Please start a new session.`);
+            }
+            // Re-throw other errors
+            throw error;
+        }
+    }
+    async sendPrompt(sessionId, parts, _config) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        // Extract text from message parts
+        const promptText = parts
+            .filter(p => p.type === 'text' && p.text)
+            .map(p => p.text)
+            .join('\n');
+        if (!promptText) {
+            throw new Error('No text content in message parts');
+        }
+        console.log(`[AcpAdapter/${this.agentType}] Sending prompt to session ${sessionId}:`);
+        console.log(promptText.slice(0, 200) + (promptText.length > 200 ? '...' : ''));
+        // Clear stale buffered events from the previous turn. Between the last
+        // pollMessages() call (which empties the buffer) and the idle detection
+        // that stops polling, new ACP notifications can still arrive.  When the
+        // next prompt triggers a fresh PollingEntry (with empty seenPartIds),
+        // those stale events would be re-processed with a new turnId, creating
+        // duplicate messages in the transcript.
+        session.messageBuffer = [];
+        // Store a synthetic user_message event in permanentMessages so that the
+        // user's prompt survives session resume / replay.  During session/load,
+        // the ACP agent may not echo user_message_chunk events, which means
+        // getAllMessages() would return no user parts and the transcript would
+        // show only agent responses.
+        this.addToPermanentMessages(session, {
+            jsonrpc: '2.0',
+            method: 'session/update',
+            params: {
+                update: {
+                    sessionUpdate: 'user_message',
+                    content: { type: 'text', text: promptText },
+                    messageId: `user-prompt-${session.currentTurnId + 1}`
+                }
+            }
+        });
+        session.status = coding_agent_adapter_1.SessionStatusType.BUSY;
+        session.lastError = null; // Clear any previous error (e.g., quota limit) for recovery
+        session.currentTurnId++;
+        session.activeTurnId = session.currentTurnId;
+        session.lastChunkTime = null;
+        // Send prompt via ACP (prompt must be an array of ContentBlock objects)
+        // Note: session/prompt is a long-running operation that responds via session/update notifications
+        // We send the request but don't await the response to avoid timeout
+        this.sendRpcRequestNoWait(session, 'session/prompt', {
+            sessionId: session.acpSessionId,
+            prompt: [
+                {
+                    type: 'text',
+                    text: promptText
+                }
+            ]
+        });
+    }
+    async getStatus(sessionId, _config) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return { type: coding_agent_adapter_1.SessionStatusType.ERROR, message: 'Session not found' };
+        }
+        return {
+            type: session.status,
+            message: session.status === 'error' ? (session.lastError || 'Process error') : undefined
+        };
+    }
+    async pollMessages(sessionId, seenMessageIds, seenPartIds, partContentLengths, _config) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return [];
+        }
+        const newParts = [];
+        // Process buffered ACP events
+        for (const event of session.messageBuffer) {
+            const converted = this.convertAcpEventToMessageParts(event, seenMessageIds, seenPartIds, partContentLengths, session);
+            newParts.push(...converted);
+        }
+        // Clear processed events
+        session.messageBuffer = [];
+        return newParts;
+    }
+    async abortPrompt(sessionId, _config) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        console.log(`[AcpAdapter/${this.agentType}] Sending session/cancel for ${sessionId}`);
+        // Send session/cancel notification (not a request - no response expected)
+        this.sendRpcNotification(session, 'session/cancel', {
+            sessionId: session.acpSessionId
+        });
+        // The agent will respond to the original session/prompt with stopReason: cancelled
+        // Status will be updated when we receive that response
+    }
+    async destroySession(sessionId, _config) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        console.log(`[AcpAdapter/${this.agentType}] Destroying session ${sessionId}`);
+        // Kill process
+        session.process.kill('SIGTERM');
+        // Wait a bit, then force kill if needed
+        setTimeout(() => {
+            if (!session.process.killed) {
+                session.process.kill('SIGKILL');
+            }
+        }, 1000);
+        // Eagerly clear large data structures to free memory immediately
+        session.permanentMessages.length = 0;
+        session.messageBuffer.length = 0;
+        session.toolCallMetadata.clear();
+        session.pendingRequests.clear();
+        // Remove session
+        this.sessions.delete(sessionId);
+    }
+    async getAllMessages(sessionId, _config) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return [];
+        }
+        // Convert all permanent messages to SessionMessages
+        const seenMessageIds = new Set();
+        const seenPartIds = new Set();
+        const partContentLengths = new Map();
+        // Use a Map to keep only the latest version of each part (by ID)
+        const partsByIdAndRole = new Map();
+        // Snapshot turn-related session state before processing.
+        // convertAcpEventToMessageParts() mutates turn counters (currentTurnId,
+        // activeTurnId, pendingAssistantTurnSplit, etc.) as it processes events.
+        // When getAllMessages() is called from replayMissedTranscriptPartsBeforeIdle
+        // AFTER a follow-up response, the session state has already advanced.
+        // Re-processing all permanent messages from the beginning with that
+        // advanced state produces DIFFERENT turn-based IDs (e.g. agent-response-5
+        // instead of agent-response-1), which bypass the seenPartIds dedup and
+        // cause every historical message to appear again in the transcript.
+        // By resetting to zero and restoring afterward, we ensure getAllMessages()
+        // always generates deterministic, stable IDs from the permanent history.
+        const savedTurnState = {
+            currentTurnId: session.currentTurnId,
+            activeTurnId: session.activeTurnId,
+            currentUserTurnId: session.currentUserTurnId,
+            lastChunkTime: session.lastChunkTime,
+            lastSessionUpdateType: session.lastSessionUpdateType,
+            pendingAssistantTurnSplit: session.pendingAssistantTurnSplit,
+            toolCallMetadata: new Map(session.toolCallMetadata),
+        };
+        // Reset to initial state so turn IDs are computed deterministically
+        session.currentTurnId = 0;
+        session.activeTurnId = null;
+        session.currentUserTurnId = 0;
+        session.lastChunkTime = null;
+        session.lastSessionUpdateType = null;
+        session.pendingAssistantTurnSplit = false;
+        session.toolCallMetadata = new Map();
+        // Process all permanent messages
+        for (const event of session.permanentMessages) {
+            const parts = this.convertAcpEventToMessageParts(event, seenMessageIds, seenPartIds, partContentLengths, session);
+            // Propagate original arrival time from the permanent event to each part
+            const receivedAt = event?._receivedAt;
+            // Keep only latest version of each part
+            for (const part of parts) {
+                if (receivedAt)
+                    part.receivedAt = receivedAt;
+                const key = `${part.id}-${part.role || 'assistant'}`;
+                // Only keep if newer or doesn't exist
+                if (!partsByIdAndRole.has(key) || part.update) {
+                    partsByIdAndRole.set(key, part);
+                }
+            }
+        }
+        // Restore live session state so polling / follow-up prompts continue
+        // from where they left off. The turn IDs computed above are only used
+        // for the returned messages — they must not leak into the live session.
+        session.currentTurnId = savedTurnState.currentTurnId;
+        session.activeTurnId = savedTurnState.activeTurnId;
+        session.currentUserTurnId = savedTurnState.currentUserTurnId;
+        session.lastChunkTime = savedTurnState.lastChunkTime;
+        session.lastSessionUpdateType = savedTurnState.lastSessionUpdateType;
+        session.pendingAssistantTurnSplit = savedTurnState.pendingAssistantTurnSplit;
+        session.toolCallMetadata = savedTurnState.toolCallMetadata;
+        const allParts = Array.from(partsByIdAndRole.values());
+        // Convert MessageParts to SessionMessages
+        const messages = [];
+        // Start a new message whenever the role changes OR the part itself is a
+        // new top-level transcript item. This keeps assistant text that arrives
+        // after tool calls in a separate message instead of appending it to the
+        // earlier assistant text during resume reconstruction.
+        let currentMessage = null;
+        let previousPart = null;
+        let messageIdCounter = 0;
+        for (const part of allParts) {
+            const roleStr = part.role || 'assistant';
+            const role = roleStr === 'user' ? coding_agent_adapter_1.MessageRole.USER :
+                roleStr === 'system' ? coding_agent_adapter_1.MessageRole.SYSTEM :
+                    coding_agent_adapter_1.MessageRole.ASSISTANT;
+            const startsNewMessage = !currentMessage
+                || currentMessage.role !== role
+                || !previousPart
+                || part.id !== previousPart.id;
+            if (startsNewMessage) {
+                if (currentMessage) {
+                    messages.push(currentMessage);
+                }
+                currentMessage = {
+                    id: `msg-${messageIdCounter++}`,
+                    role,
+                    parts: []
+                };
+            }
+            currentMessage.parts.push(part);
+            previousPart = part;
+        }
+        if (currentMessage) {
+            messages.push(currentMessage);
+        }
+        return messages;
+    }
+    async registerMcpServer(_serverName, _mcpConfig, _workspaceDir) {
+        // MCP server registration is handled during session creation
+        console.log(`[AcpAdapter/${this.agentType}] MCP server registration deferred to session creation`);
+    }
+    async checkHealth() {
+        try {
+            if (this.agentType === 'cursor') {
+                await execFileAsync(this.agentConfig.command, ['--version'], {
+                    timeout: 10000,
+                    windowsHide: true,
+                    shell: process.platform === 'win32'
+                });
+                return { available: true };
+            }
+            // Verify the ACP agent package is installed
+            const packageName = '@zed-industries/codex-acp';
+            try {
+                // Different packages have different entry points
+                const entryPoint = `${packageName}/bin/codex-acp.js`;
+                require.resolve(entryPoint);
+            }
+            catch {
+                return {
+                    available: false,
+                    reason: `${packageName} not found. Install with: pnpm add ${packageName}`
+                };
+            }
+            // Note: We don't check API keys here because they can be provided
+            // via UI configuration (agent.config.api_keys) at session creation time
+            return { available: true };
+        }
+        catch (error) {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            return {
+                available: false,
+                reason: this.agentType === 'cursor'
+                    ? `Cursor Agent CLI is unavailable. Install it and run cursor-agent login. (${errMsg})`
+                    : errMsg
+            };
+        }
+    }
+    /**
+     * Get pending approval request for a session
+     */
+    getPendingApproval(sessionId) {
+        const session = this.sessions.get(sessionId);
+        return session?.pendingApproval || null;
+    }
+    /**
+     * Respond to a pending approval request
+     */
+    async respondToApproval(sessionId, approved, optionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session || !session.pendingApproval) {
+            console.warn(`[AcpAdapter/${this.agentType}] No pending approval for session ${sessionId}`);
+            return;
+        }
+        const approval = session.pendingApproval;
+        // Determine the outcome based on user choice
+        let selectedOptionId = approval.options.some((option) => option.optionId === optionId)
+            ? optionId
+            : undefined;
+        if (!selectedOptionId) {
+            selectedOptionId = approved
+                ? approval.options.find((option) => option.optionId === 'allow-once')?.optionId || 'approved'
+                : approval.options.find((option) => option.optionId === 'reject-once')?.optionId || 'abort';
+        }
+        console.log(`[AcpAdapter/${this.agentType}] Responding to approval with: ${selectedOptionId}`);
+        // Send response to agent with correct ACP format
+        // Based on TypeScript SDK: outcome has double nesting with outcome field
+        this.sendRpcResponse(session, approval.requestId, {
+            result: {
+                outcome: {
+                    outcome: 'selected',
+                    optionId: selectedOptionId
+                }
+            }
+        });
+        // Clear pending approval
+        session.pendingApproval = null;
+    }
+    // ========================================================================
+    // Private Helper Methods
+    // ========================================================================
+    setupStdoutParser(process, session) {
+        process.stdout?.on('data', (chunk) => {
+            session.stdoutBuffer += chunk.toString();
+            // Parse newline-delimited JSON messages
+            let newlineIndex;
+            while ((newlineIndex = session.stdoutBuffer.indexOf('\n')) !== -1) {
+                const line = session.stdoutBuffer.slice(0, newlineIndex).trim();
+                session.stdoutBuffer = session.stdoutBuffer.slice(newlineIndex + 1);
+                if (!line)
+                    continue;
+                try {
+                    const message = JSON.parse(line);
+                    this.handleRpcMessage(session, message);
+                }
+                catch (error) {
+                    console.error(`[AcpAdapter/${this.agentType}] Failed to parse JSON-RPC message:`, line, error);
+                }
+            }
+        });
+    }
+    handleRpcMessage(session, message) {
+        if (this.debugRpcLogs) {
+            console.log(`[AcpAdapter/${this.agentType}] Received RPC message:`, JSON.stringify(message));
+        }
+        // Handle responses to our requests
+        if ('id' in message && message.id !== undefined && !('method' in message)) {
+            const pending = session.pendingRequests.get(message.id);
+            if (pending) {
+                session.pendingRequests.delete(message.id);
+                const response = message;
+                if ('error' in response && response.error) {
+                    // Check for quota/usage limit errors from the provider
+                    const errorInfo = this.extractCodexErrorInfo(response.error);
+                    if (errorInfo) {
+                        this.handleQuotaError(session, errorInfo);
+                    }
+                    pending.reject(new Error(response.error.message));
+                }
+                else if ('result' in response) {
+                    pending.resolve(response.result);
+                }
+                return;
+            }
+            // No pending request - could be error for permission response or other async operation
+            const response = message;
+            if ('error' in response && response.error) {
+                // Check for quota/usage limit errors from the provider
+                const errorInfo = this.extractCodexErrorInfo(response.error);
+                if (errorInfo) {
+                    this.handleQuotaError(session, errorInfo);
+                    return;
+                }
+                console.error(`[AcpAdapter/${this.agentType}] Unexpected error response:`, response.error);
+                // Push error to message buffers
+                const errorEvent = {
+                    _isError: true,
+                    message: response.error.message,
+                    data: response.error.data
+                };
+                session.messageBuffer.push(errorEvent);
+                this.addToPermanentMessages(session, errorEvent);
+                this.onDataAvailable?.(session.sessionId);
+                return;
+            }
+            // Check if this is a response to session/prompt
+            if (session.promptRequestId === message.id && 'result' in response) {
+                const result = response.result;
+                if (result?.stopReason) {
+                    console.log(`[AcpAdapter/${this.agentType}] Prompt completed with stopReason: ${result.stopReason}`);
+                    session.status = coding_agent_adapter_1.SessionStatusType.IDLE;
+                    session.activeTurnId = null;
+                    // Don't clear promptRequestId - keep it for late-arriving events
+                    // It will be updated when the next prompt is sent
+                }
+                return;
+            }
+        }
+        // Handle requests from agent (e.g., session/request_permission)
+        if ('method' in message && 'id' in message && message.id !== undefined) {
+            const request = message;
+            if (this.debugRpcLogs) {
+                console.log(`[AcpAdapter/${this.agentType}] << Request: ${request.method}`);
+            }
+            if (request.method === 'session/request_permission') {
+                this.handlePermissionRequest(session, request);
+                return;
+            }
+            if (this.agentType === 'cursor' && request.method === 'cursor/ask_question') {
+                this.sendRpcResponse(session, request.id, {
+                    result: { outcome: { outcome: 'skipped', reason: 'Cursor questions are not supported by 20x yet' } }
+                });
+                return;
+            }
+            if (this.agentType === 'cursor' && request.method === 'cursor/create_plan') {
+                this.sendRpcResponse(session, request.id, {
+                    result: { outcome: { outcome: 'cancelled' } }
+                });
+                return;
+            }
+            // Unknown request - send error response
+            this.sendRpcResponse(session, request.id, {
+                error: { code: -32601, message: `Method not found: ${request.method}` }
+            });
+            return;
+        }
+        // Handle notifications from agent
+        if ('method' in message && !('id' in message)) {
+            const notification = message;
+            if (this.debugRpcLogs) {
+                console.log(`[AcpAdapter/${this.agentType}] << Notification: ${notification.method}`);
+                if (notification.method === 'session/update') {
+                    const params = notification.params;
+                    console.log(`[AcpAdapter/${this.agentType}]    sessionUpdate: ${params?.update?.sessionUpdate}`);
+                }
+            }
+            // Store notification directly (no wrapping needed)
+            // Turn detection happens automatically based on time gaps and tool calls
+            // Buffer notification for polling (gets cleared after each poll)
+            session.messageBuffer.push(notification);
+            // Also store permanently for getAllMessages (replayed on resume).
+            this.addToPermanentMessages(session, notification);
+            this.onDataAvailable?.(session.sessionId);
+            // Update session status based on notification
+            this.updateSessionStatus(session, notification);
+        }
+    }
+    /**
+     * Extract codex-specific error info from an RPC error response.
+     * Returns a user-friendly error message if this is a known codex error type,
+     * or null if it's a generic error that should be handled normally.
+     */
+    extractCodexErrorInfo(error) {
+        const data = error.data;
+        if (!data?.codex_error_info)
+            return null;
+        const errorType = String(data.codex_error_info);
+        const providerMessage = typeof data.message === 'string' ? data.message : error.message;
+        switch (errorType) {
+            case 'usage_limit_exceeded':
+                return {
+                    errorType,
+                    userMessage: `Quota exceeded: ${providerMessage}. Please check your Codex plan and billing details to continue.`
+                };
+            case 'rate_limit_exceeded':
+                return {
+                    errorType,
+                    userMessage: `Rate limit reached: ${providerMessage}. Please wait a moment before trying again.`
+                };
+            default:
+                return {
+                    errorType,
+                    userMessage: `Codex error (${errorType}): ${providerMessage}`
+                };
+        }
+    }
+    /**
+     * Handle a quota/usage limit error by setting session state and surfacing
+     * a clear, actionable error message to the user.
+     */
+    handleQuotaError(session, errorInfo) {
+        // Append the auth identity 20x used so the user (and we) can see whether the
+        // limit came from their subscription or an API key — the whole point of the
+        // "terminal works but 20x doesn't" investigation.
+        const authNote = session.codexAuthSummary ? ` [20x auth: ${session.codexAuthSummary}]` : '';
+        const userMessage = `${errorInfo.userMessage}${authNote}`;
+        console.warn(`[AcpAdapter/${this.agentType}] Provider error (${errorInfo.errorType}):`, userMessage);
+        session.status = coding_agent_adapter_1.SessionStatusType.ERROR;
+        session.lastError = userMessage;
+        session.activeTurnId = null;
+        // Push a user-friendly error event to the LIVE message buffer only.
+        //
+        // IMPORTANT: Quota/rate-limit errors are TRANSIENT conditions tied to a
+        // point in time. They must NOT be written to permanentMessages, because
+        // permanentMessages is replayed on every session resume (getAllMessages).
+        // If we persisted them, the "Quota exceeded / Rate limit reached" message
+        // would re-appear at the end of the transcript forever — even after the
+        // user upgrades their Codex plan, re-logs in, or simply waits for the
+        // window to reset. That stale message is exactly what makes 20x keep
+        // "showing limits" after the underlying limit is gone. session.lastError
+        // is already cleared on the next sendPrompt() for recovery, so keeping the
+        // event out of the permanent history fully clears the stale state on resume.
+        const errorEvent = {
+            _isError: true,
+            message: userMessage,
+            data: null // Don't expose raw error data for known error types
+        };
+        session.messageBuffer.push(errorEvent);
+        this.onDataAvailable?.(session.sessionId);
+    }
+    updateSessionStatus(session, notification) {
+        // Handle session/update notifications
+        if (notification.method === 'session/update') {
+            const params = notification.params;
+            const update = params?.update;
+            if (!update)
+                return;
+            // Update status based on update type.
+            // IMPORTANT: Do NOT modify turn-related state (activeTurnId, pendingAssistantTurnSplit)
+            // here — this runs in real-time when notifications arrive, but pollMessages processes
+            // events in buffer order. Modifying turn state here would "leak" future event state
+            // into earlier events during polling, causing incorrect turn splits and duplication.
+            // Turn state is managed exclusively in convertAcpEventToMessageParts().
+            if (update.sessionUpdate === 'tool_call' || update.sessionUpdate === 'tool_call_update') {
+                session.status = coding_agent_adapter_1.SessionStatusType.BUSY;
+            }
+            else if (update.sessionUpdate === 'error' || update.sessionUpdate === 'failed') {
+                session.status = coding_agent_adapter_1.SessionStatusType.ERROR;
+            }
+            else if (update.sessionUpdate === 'completed' || update.sessionUpdate === 'finished') {
+                session.status = coding_agent_adapter_1.SessionStatusType.IDLE;
+            }
+            // For 'available_commands_update' and other notifications, keep current status
+        }
+        // Legacy: Handle other notification types by method name
+        else if (notification.method.includes('completed') || notification.method.includes('finished')) {
+            session.status = coding_agent_adapter_1.SessionStatusType.IDLE;
+        }
+        else if (notification.method.includes('error') || notification.method.includes('failed')) {
+            session.status = coding_agent_adapter_1.SessionStatusType.ERROR;
+        }
+        else if (notification.method.includes('started') || notification.method.includes('working')) {
+            session.status = coding_agent_adapter_1.SessionStatusType.BUSY;
+        }
+    }
+    /**
+     * Adds a notification or event to the permanent message history, with
+     * consolidation and size-based pruning to prevent OOM.
+     *
+     * IMPORTANT: events are stored as deep clones. The incoming `event` object is
+     * the SAME object that handleRpcMessage() pushed into session.messageBuffer
+     * for live polling. This method mutates stored events in two ways:
+     *   1. chunk consolidation rewrites content.text on the last stored event
+     *   2. tool outputs are truncated to 100KB for history
+     * Without cloning, those mutations corrupted the un-polled live buffer:
+     * when several agent_message_chunk deltas arrived between polls (always the
+     * case at the START of a response — the first token burst lands before the
+     * first poll cycle), consolidation silently rewrote the FIRST buffered chunk
+     * into the full accumulated text while the later buffered chunks stayed raw
+     * deltas. pollMessages() then appended those deltas again after the already
+     * complete text, scrambling the beginning of the message
+     * ("Hello world, how are you? world, how are you?").
+     */
+    addToPermanentMessages(session, event) {
+        const notification = event;
+        const lastMsg = session.permanentMessages[session.permanentMessages.length - 1];
+        let consolidated = false;
+        if (lastMsg?.method === 'session/update' && notification.method === 'session/update') {
+            const lastParams = lastMsg.params;
+            const nextParams = notification.params;
+            const lastUpdate = lastParams?.update;
+            const nextUpdate = nextParams?.update;
+            if (lastUpdate && nextUpdate && lastUpdate.sessionUpdate === nextUpdate.sessionUpdate && this.isAssistantChunkUpdateType(nextUpdate.sessionUpdate)) {
+                // Merge consecutive assistant/thought chunks
+                const lastText = this.extractTextFromUpdateContent(lastUpdate.content);
+                const nextText = this.extractTextFromUpdateContent(nextUpdate.content);
+                if (typeof lastUpdate.content === 'object' && lastUpdate.content !== null) {
+                    lastUpdate.content.text = this.mergeStreamingText(lastText, nextText);
+                    consolidated = true;
+                }
+            }
+        }
+        if (!consolidated) {
+            // Deep-clone before storing so history-only mutations (chunk
+            // consolidation above on later events, output truncation below) never
+            // leak into the identical object still queued in session.messageBuffer.
+            const stored = structuredClone(notification);
+            // Capping tool output size in permanent messages (replayed on resume).
+            // The full output is still delivered to the UI during the live session,
+            // but truncated here to keep the history bounded.
+            if (stored.method === 'session/update') {
+                const update = stored.params?.update;
+                if (update?.rawOutput && typeof update.rawOutput === 'object') {
+                    const ro = update.rawOutput;
+                    const MAX_HISTORY_OUTPUT_CHARS = 100_000; // 100KB per tool output in history
+                    if (typeof ro.stdout === 'string' && ro.stdout.length > MAX_HISTORY_OUTPUT_CHARS) {
+                        ro.stdout = ro.stdout.slice(0, MAX_HISTORY_OUTPUT_CHARS) + '\n... (truncated in history)';
+                    }
+                    if (typeof ro.formatted_output === 'string' && ro.formatted_output.length > MAX_HISTORY_OUTPUT_CHARS) {
+                        ro.formatted_output = ro.formatted_output.slice(0, MAX_HISTORY_OUTPUT_CHARS) + '\n... (truncated in history)';
+                    }
+                }
+            }
+            // Stamp with arrival time so replays can preserve original timing
+            ;
+            stored._receivedAt = Date.now();
+            session.permanentMessages.push(stored);
+        }
+        // Enforce absolute limit on permanent history to prevent OOM.
+        // Discard oldest 25% to amortise pruning cost (was 10% which caused frequent re-pruning).
+        if (session.permanentMessages.length > AcpAdapter.MAX_PERMANENT_MESSAGES) {
+            session.permanentMessages.splice(0, Math.ceil(AcpAdapter.MAX_PERMANENT_MESSAGES * 0.25));
+        }
+    }
+    async sendRpcRequest(session, method, params) {
+        const id = session.nextRequestId++;
+        const request = {
+            jsonrpc: '2.0',
+            id,
+            method,
+            params
+        };
+        return new Promise((resolve, reject) => {
+            // Register pending request
+            session.pendingRequests.set(id, { resolve, reject });
+            // Send request
+            const jsonString = JSON.stringify(request) + '\n';
+            session.process.stdin?.write(jsonString, (error) => {
+                if (error) {
+                    session.pendingRequests.delete(id);
+                    reject(new Error(`Failed to send request: ${error.message}`));
+                }
+            });
+            // Timeout after 30 seconds
+            setTimeout(() => {
+                if (session.pendingRequests.has(id)) {
+                    session.pendingRequests.delete(id);
+                    reject(new Error(`Request timeout: ${method}`));
+                }
+            }, 30000);
+        });
+    }
+    sendRpcRequestNoWait(session, method, params) {
+        const id = session.nextRequestId++;
+        // Track session/prompt request ID so we can handle the response
+        if (method === 'session/prompt') {
+            session.promptRequestId = id;
+        }
+        const request = {
+            jsonrpc: '2.0',
+            id,
+            method,
+            params
+        };
+        // Send request without waiting for response
+        // The response will be handled in handleRpcMessage when it arrives
+        const jsonString = JSON.stringify(request) + '\n';
+        session.process.stdin?.write(jsonString, (error) => {
+            if (error) {
+                console.error(`[AcpAdapter/${this.agentType}] Error sending ${method}:`, error);
+            }
+        });
+    }
+    sendRpcResponse(session, id, response) {
+        const rpcResponse = {
+            jsonrpc: '2.0',
+            id,
+            ...(response.error ? { error: response.error } : { result: response.result })
+        };
+        const jsonString = JSON.stringify(rpcResponse) + '\n';
+        console.log(`[AcpAdapter/${this.agentType}] Sending RPC response:`, jsonString.trim());
+        session.process.stdin?.write(jsonString, (error) => {
+            if (error)
+                console.error(`[AcpAdapter/${this.agentType}] Error sending response:`, error);
+        });
+    }
+    sendRpcNotification(session, method, params) {
+        const notification = {
+            jsonrpc: '2.0',
+            method,
+            params
+        };
+        const jsonString = JSON.stringify(notification) + '\n';
+        session.process.stdin?.write(jsonString, (error) => {
+            if (error)
+                console.error(`[AcpAdapter/${this.agentType}] Error sending notification ${method}:`, error);
+        });
+    }
+    handlePermissionRequest(session, request) {
+        const params = request.params;
+        // Extract permission details
+        const toolCall = params?.toolCall;
+        const options = params?.options || [];
+        // Get the question/reason from the tool call
+        const question = toolCall?.rawInput?.reason ||
+            toolCall?.content?.[0]?.content?.text ||
+            `Execute: ${toolCall?.title || 'unknown command'}`;
+        console.log(`[AcpAdapter/${this.agentType}] Permission request:`);
+        console.log(`  Question: ${question}`);
+        console.log(`  Tool: ${toolCall?.kind} - ${toolCall?.toolCallId}`);
+        console.log(`  Options: ${options.map((o) => `${o.name} (${o.optionId})`).join(', ')}`);
+        const approvalOptions = options.map((o) => ({
+            optionId: o.optionId,
+            name: o.name,
+            kind: o.kind
+        }));
+        if (session.config.permissionMode === 'allow') {
+            const autoApprovedOptionId = approvalOptions.find((option) => option.optionId === 'approved-for-session')?.optionId
+                || approvalOptions.find((option) => option.optionId === 'allow-always')?.optionId
+                || approvalOptions.find((option) => option.optionId === 'approved')?.optionId
+                || approvalOptions.find((option) => option.optionId === 'allow-once')?.optionId
+                || (this.agentType === 'cursor' ? 'allow-once' : 'approved');
+            console.log(`[AcpAdapter/${this.agentType}] Auto-approving permission with: ${autoApprovedOptionId}`);
+            this.sendRpcResponse(session, request.id, {
+                result: {
+                    outcome: {
+                        outcome: 'selected',
+                        optionId: autoApprovedOptionId
+                    }
+                }
+            });
+            return;
+        }
+        // Store the permission request for UI to handle
+        session.pendingApproval = {
+            requestId: request.id,
+            toolCallId: toolCall?.toolCallId || '',
+            question,
+            options: approvalOptions
+        };
+        // Update session status to waiting for approval
+        session.status = coding_agent_adapter_1.SessionStatusType.WAITING_APPROVAL;
+        console.log(`[AcpAdapter/${this.agentType}] Awaiting user approval...`);
+    }
+    extractAcpSessionId(result) {
+        if (!result || typeof result !== 'object')
+            return null;
+        // Try common session ID field names
+        const obj = result;
+        return (obj.sessionId || obj.session_id || obj.id);
+    }
+    /**
+     * Convert internal McpServerConfig map to ACP-spec McpServer array.
+     * ACP spec: https://agentclientprotocol.com/protocol/schema
+     *
+     * - mcpServers is Vec<McpServer> (array, not map)
+     * - stdio variant: { name, command, args: string[], env: EnvVariable[] }
+     * - http variant:  { type: "http", name, url, headers: HttpHeader[] }
+     * - EnvVariable / HttpHeader = { name: string, value: string }
+     */
+    convertMcpServers(servers) {
+        if (!servers)
+            return [];
+        const result = [];
+        for (const [name, config] of Object.entries(servers)) {
+            if (config.type === 'stdio') {
+                // Convert env from Record<string,string> to ACP EnvVariable[]
+                const envArray = config.env
+                    ? Object.entries(config.env).map(([k, v]) => ({ name: k, value: v }))
+                    : [];
+                result.push({
+                    name,
+                    command: config.command,
+                    args: config.args || [],
+                    env: envArray
+                });
+            }
+            else {
+                // http or sse — ACP requires a "type" discriminator for non-stdio variants
+                // Convert headers from Record<string,string> to ACP HttpHeader[]
+                const headersArray = config.headers
+                    ? Object.entries(config.headers).map(([k, v]) => ({ name: k, value: v }))
+                    : [];
+                result.push({
+                    type: config.type,
+                    name,
+                    url: config.url,
+                    headers: headersArray
+                });
+            }
+        }
+        return result;
+    }
+    extractTextFromUpdateContent(content) {
+        if (!content)
+            return '';
+        if (typeof content === 'string') {
+            return content;
+        }
+        if (Array.isArray(content)) {
+            return content
+                .map((entry) => this.extractTextFromUpdateContent(entry))
+                .filter(Boolean)
+                .join('\n');
+        }
+        if (typeof content !== 'object') {
+            return '';
+        }
+        const value = content;
+        if (typeof value.text === 'string') {
+            return value.text;
+        }
+        if (typeof value.content === 'string') {
+            return value.content;
+        }
+        if (value.content) {
+            const nestedContent = this.extractTextFromUpdateContent(value.content);
+            if (nestedContent)
+                return nestedContent;
+        }
+        if (value.message) {
+            const nestedMessage = this.extractTextFromUpdateContent(value.message);
+            if (nestedMessage)
+                return nestedMessage;
+        }
+        return '';
+    }
+    mergeStreamingText(currentText, incomingChunk) {
+        if (!currentText)
+            return incomingChunk;
+        if (!incomingChunk)
+            return currentText;
+        if (incomingChunk.startsWith(currentText)) {
+            return incomingChunk;
+        }
+        if (currentText.endsWith(incomingChunk)) {
+            return currentText;
+        }
+        const MIN_OVERLAP_CHARS = 8;
+        const maxSkippedPrefix = Math.min(32, currentText.length - MIN_OVERLAP_CHARS);
+        for (let skipped = 1; skipped <= maxSkippedPrefix; skipped++) {
+            const replayedText = currentText.slice(skipped);
+            if (incomingChunk.startsWith(replayedText)) {
+                return currentText.slice(0, skipped) + incomingChunk;
+            }
+        }
+        const maxOverlap = Math.min(currentText.length, incomingChunk.length);
+        for (let length = maxOverlap; length > 0; length--) {
+            if (length >= MIN_OVERLAP_CHARS && currentText.endsWith(incomingChunk.slice(0, length))) {
+                return currentText + incomingChunk.slice(length);
+            }
+        }
+        return currentText + incomingChunk;
+    }
+    isUserUpdateType(sessionUpdate) {
+        return sessionUpdate === 'user_message_chunk'
+            || sessionUpdate === 'human_message_chunk'
+            || sessionUpdate === 'user_message'
+            || sessionUpdate === 'human_message';
+    }
+    isAssistantChunkUpdateType(sessionUpdate) {
+        return sessionUpdate === 'agent_message_chunk'
+            || sessionUpdate === 'assistant_message_chunk'
+            || sessionUpdate === 'agent_thought_chunk';
+    }
+    isToolingUpdateType(sessionUpdate) {
+        // Only actual tool calls should trigger turn splits.
+        // `plan` and `available_commands_update` do NOT produce visible message parts
+        // and must NOT cause turn splits — otherwise every such notification fragments
+        // the assistant response into a separate message bubble.
+        return sessionUpdate === 'tool_call'
+            || sessionUpdate === 'tool_call_update';
+    }
+    getAssistantTurnId(session) {
+        const now = Date.now();
+        const previousType = session.lastSessionUpdateType;
+        const mustSplitAfterTool = session.pendingAssistantTurnSplit;
+        if (session.activeTurnId &&
+            !mustSplitAfterTool &&
+            !this.isToolingUpdateType(previousType) &&
+            !this.isUserUpdateType(previousType)) {
+            session.lastChunkTime = now;
+            return session.activeTurnId;
+        }
+        const timeSinceLastChunk = session.lastChunkTime ? now - session.lastChunkTime : Infinity;
+        const TIME_GAP_THRESHOLD = 2000;
+        const shouldStartNewTurn = session.currentTurnId === 0
+            || mustSplitAfterTool
+            || this.isUserUpdateType(previousType)
+            || this.isToolingUpdateType(previousType)
+            || (this.isAssistantChunkUpdateType(previousType) && timeSinceLastChunk > TIME_GAP_THRESHOLD);
+        if (shouldStartNewTurn) {
+            session.currentTurnId += 1;
+            console.log(`[AcpAdapter] Detected NEW assistant turn #${session.currentTurnId} (prev=${previousType}, gap=${timeSinceLastChunk}ms, split=${mustSplitAfterTool})`);
+        }
+        session.pendingAssistantTurnSplit = false;
+        if (session.activeTurnId) {
+            session.activeTurnId = session.currentTurnId;
+        }
+        session.lastChunkTime = now;
+        return session.currentTurnId;
+    }
+    getUserTurnId(session) {
+        if (!this.isUserUpdateType(session.lastSessionUpdateType)) {
+            session.currentUserTurnId += 1;
+            console.log(`[AcpAdapter] Detected NEW user turn #${session.currentUserTurnId} (prev=${session.lastSessionUpdateType})`);
+        }
+        return session.currentUserTurnId;
+    }
+    normalizeToolName(rawToolName) {
+        switch (rawToolName) {
+            case 'exec_command':
+                return 'command';
+            case 'write_stdin':
+                return 'stdin';
+            case 'update_plan':
+                return 'plan';
+            default:
+                return rawToolName || 'tool';
+        }
+    }
+    buildToolTitle(rawToolName, rawInput, fallback) {
+        const trimmedFallback = fallback?.trim();
+        switch (rawToolName) {
+            case 'exec_command': {
+                const command = rawInput?.command;
+                if (Array.isArray(command))
+                    return command.join(' ') || trimmedFallback;
+                if (typeof command === 'string' && command.trim())
+                    return command.trim();
+                const cmd = typeof rawInput?.cmd === 'string' ? rawInput.cmd.trim() : '';
+                if (cmd)
+                    return cmd;
+                return trimmedFallback;
+            }
+            case 'write_stdin': {
+                const chars = typeof rawInput?.chars === 'string' ? rawInput.chars.trim() : '';
+                if (chars)
+                    return chars.replace(/\s+/g, ' ').slice(0, 80);
+                return 'poll';
+            }
+            case 'update_plan': {
+                const plan = Array.isArray(rawInput?.plan) ? rawInput.plan : [];
+                const firstStep = plan.find((item) => typeof item === 'object' && item !== null && typeof item.step === 'string');
+                if (firstStep)
+                    return `${plan.length} steps: ${firstStep.step}`;
+                const explanation = typeof rawInput?.explanation === 'string' ? rawInput.explanation.trim() : '';
+                if (explanation)
+                    return explanation.slice(0, 80);
+                return trimmedFallback;
+            }
+            default:
+                return trimmedFallback;
+        }
+    }
+    convertAcpEventToMessageParts(event, _seenMessageIds, seenPartIds, partContentLengths, session) {
+        const parts = [];
+        // Unwrap event (events may be wrapped with metadata)
+        const wrappedEvent = event;
+        const actualEvent = (wrappedEvent._notification || event);
+        // Handle error events from adapter
+        if (actualEvent._isError) {
+            const errorId = `error-${Date.now()}`;
+            if (!seenPartIds.has(errorId)) {
+                seenPartIds.add(errorId);
+                parts.push({
+                    id: errorId,
+                    type: coding_agent_adapter_1.MessagePartType.TEXT,
+                    text: `Error: ${actualEvent.message}${actualEvent.data ? ` - ${actualEvent.data}` : ''}`,
+                    role: 'assistant'
+                });
+            }
+            return parts;
+        }
+        const notification = actualEvent;
+        // Handle session/update notifications (primary ACP notification type)
+        if (notification.method === 'session/update') {
+            const params = notification.params;
+            const update = params?.update;
+            if (!update)
+                return [];
+            // Use toolCallId as unique identifier for tool calls
+            const partId = update.toolCallId || (0, crypto_1.randomUUID)();
+            // Handle different update types
+            if (update.sessionUpdate === 'tool_call' || update.sessionUpdate === 'tool_call_update') {
+                if (session) {
+                    session.pendingAssistantTurnSplit = true;
+                }
+                // Cache metadata from initial tool_call events (in_progress) so we can
+                // use it when the completed tool_call_update arrives (which may lack
+                // name/input fields).
+                const rawInput = update.rawInput;
+                if (update.status !== 'completed' && session && partId) {
+                    const commandFromInput = Array.isArray(rawInput?.command)
+                        ? rawInput.command.join(' ')
+                        : rawInput?.command;
+                    const commandFromCmd = rawInput?.cmd;
+                    const commandFromParsed = rawInput?.parsed_cmd?.map((c) => c.cmd).join('; ');
+                    const cachedInput = commandFromInput || commandFromCmd || commandFromParsed || update.title || '';
+                    // Derive tool name: kind > rawInput.tool (with server prefix) > title (strip "Tool: " prefix)
+                    const toolFromRawInput = rawInput?.tool
+                        ? (rawInput.server ? `${rawInput.server}/${rawInput.tool}` : rawInput.tool)
+                        : undefined;
+                    const toolFromTitle = update.title?.startsWith('Tool: ') ? update.title.slice(6) : undefined;
+                    const cachedName = update.kind || toolFromRawInput || toolFromTitle || '';
+                    const cachedTitle = this.buildToolTitle(cachedName || update.title, rawInput, cachedInput);
+                    if (cachedName || cachedInput || cachedTitle) {
+                        // Cap toolCallMetadata to prevent unbounded growth from orphaned entries
+                        if (session.toolCallMetadata.size >= AcpAdapter.MAX_TOOL_CALL_METADATA) {
+                            // Evict oldest half (Maps preserve insertion order)
+                            const toEvict = Math.ceil(AcpAdapter.MAX_TOOL_CALL_METADATA * 0.5);
+                            let evicted = 0;
+                            for (const key of session.toolCallMetadata.keys()) {
+                                if (evicted >= toEvict)
+                                    break;
+                                session.toolCallMetadata.delete(key);
+                                evicted++;
+                            }
+                        }
+                        session.toolCallMetadata.set(partId, { name: cachedName, input: cachedInput, title: cachedTitle });
+                    }
+                    // Emit an in-progress tool part so the user sees the tool call
+                    // immediately (with a spinner) instead of waiting for completion.
+                    if (!seenPartIds.has(partId)) {
+                        seenPartIds.add(partId);
+                        const inProgressToolName = this.normalizeToolName(cachedName || update.title || 'tool');
+                        parts.push({
+                            id: partId,
+                            type: coding_agent_adapter_1.MessagePartType.TOOL,
+                            tool: {
+                                name: inProgressToolName,
+                                title: cachedTitle,
+                                status: 'running',
+                                input: cachedInput || undefined
+                            }
+                        });
+                    }
+                }
+                // Create / update the tool part when completed (with output)
+                if (update.status === 'completed') {
+                    const alreadySeen = seenPartIds.has(partId);
+                    seenPartIds.add(partId);
+                    // Look up cached metadata from initial tool_call event
+                    const cachedMeta = session?.toolCallMetadata.get(partId);
+                    // Extract command and output from rawInput/rawOutput
+                    const rawOutput = update.rawOutput;
+                    // Try to get command from multiple sources (tool_call has rawInput, tool_call_update has it in rawOutput)
+                    const commandFromInput = Array.isArray(rawInput?.command)
+                        ? rawInput.command.join(' ')
+                        : rawInput?.command;
+                    const commandFromCmd = rawInput?.cmd;
+                    const commandFromOutput = Array.isArray(rawOutput?.command)
+                        ? rawOutput.command.join(' ')
+                        : rawOutput?.command;
+                    const commandFromParsed = rawInput?.parsed_cmd?.map((c) => c.cmd).join('; ');
+                    // Extract from content array: [{type:"content", content:{type:"text", text:"..."}}]
+                    const contentArray = update.content;
+                    const inputFromContent = Array.isArray(contentArray)
+                        ? contentArray.map((c) => c.content?.text || c.text || '').filter(Boolean).join('\n')
+                        : undefined;
+                    const command = commandFromInput || commandFromCmd || commandFromOutput || commandFromParsed || update.title || cachedMeta?.input || inputFromContent || 'Unknown';
+                    // Extract output - handle Codex format: {content: [{text: "...", type: "text"}], isError: false}
+                    const outputFromContent = Array.isArray(rawOutput?.content)
+                        ? rawOutput.content.map((c) => c.text || '').filter(Boolean).join('\n')
+                        : undefined;
+                    const output = rawOutput?.formatted_output || rawOutput?.stdout || rawOutput?.stderr || outputFromContent || '';
+                    // Clean up cached metadata
+                    if (session) {
+                        session.toolCallMetadata.delete(partId);
+                    }
+                    // Derive tool name from multiple sources
+                    const completedToolFromTitle = update.title?.startsWith('Tool: ') ? update.title.slice(6) : undefined;
+                    const rawToolName = update.kind || cachedMeta?.name || completedToolFromTitle || update.title || 'tool';
+                    const toolName = this.normalizeToolName(rawToolName);
+                    const toolTitle = this.buildToolTitle(rawToolName, rawInput, cachedMeta?.title || (command && command !== rawToolName ? command : undefined));
+                    parts.push({
+                        id: partId,
+                        type: coding_agent_adapter_1.MessagePartType.TOOL,
+                        tool: {
+                            name: toolName,
+                            title: toolTitle,
+                            status: update.status,
+                            input: command,
+                            output: output
+                        },
+                        // If we already emitted an in-progress part for this tool,
+                        // mark as update so the renderer replaces rather than adds.
+                        update: alreadySeen
+                    });
+                }
+            }
+            else if (update.sessionUpdate === 'agent_message_chunk' || update.sessionUpdate === 'assistant_message_chunk') {
+                // Handle streaming text response from agent
+                // Format: { content: { type: 'text', text: '...' } }
+                const turnId = session ? this.getAssistantTurnId(session) : 0;
+                const messageId = turnId > 0 ? `agent-response-${turnId}` : 'agent-response';
+                if (this.debugRpcLogs) {
+                    console.log(`[AcpAdapter] agent_message_chunk: turnId=${turnId}, messageId=${messageId}`);
+                }
+                const chunk = this.extractTextFromUpdateContent(update.content);
+                if (chunk) {
+                    // Accumulate text across multiple chunks
+                    const currentText = partContentLengths.get(messageId) || '';
+                    const newText = this.mergeStreamingText(currentText, chunk);
+                    partContentLengths.set(messageId, newText);
+                    // Return update part with accumulated text
+                    parts.push({
+                        id: messageId,
+                        type: coding_agent_adapter_1.MessagePartType.TEXT,
+                        text: newText,
+                        role: 'assistant',
+                        update: seenPartIds.has(messageId) // Mark as update if we've seen this ID before
+                    });
+                    seenPartIds.add(messageId);
+                }
+            }
+            else if (update.sessionUpdate === 'agent_thought_chunk') {
+                // Handle reasoning/thinking chunks
+                // Format: { content: { type: 'text', text: '...' } }
+                const turnId = session ? this.getAssistantTurnId(session) : 0;
+                const thinkingId = turnId > 0 ? `agent-thinking-${turnId}` : 'agent-thinking';
+                const chunk = this.extractTextFromUpdateContent(update.content);
+                if (chunk) {
+                    // Accumulate text across multiple chunks
+                    const currentText = partContentLengths.get(thinkingId) || '';
+                    const newText = this.mergeStreamingText(currentText, chunk);
+                    partContentLengths.set(thinkingId, newText);
+                    // Return update part with accumulated text
+                    parts.push({
+                        id: thinkingId,
+                        type: coding_agent_adapter_1.MessagePartType.REASONING,
+                        text: newText,
+                        role: 'assistant',
+                        update: seenPartIds.has(thinkingId)
+                    });
+                    seenPartIds.add(thinkingId);
+                }
+            }
+            else if (update.sessionUpdate === 'user_message_chunk' || update.sessionUpdate === 'human_message_chunk') {
+                // Handle streaming user message chunks (usually when user types)
+                const turnId = session ? this.getUserTurnId(session) : 0;
+                const userId = turnId > 0 ? `user-message-${turnId}` : 'user-message';
+                const chunk = this.extractTextFromUpdateContent(update.content);
+                if (chunk) {
+                    // Accumulate text across multiple chunks
+                    const currentText = partContentLengths.get(userId) || '';
+                    const newText = this.mergeStreamingText(currentText, chunk);
+                    partContentLengths.set(userId, newText);
+                    // Return update part with accumulated text
+                    parts.push({
+                        id: userId,
+                        type: coding_agent_adapter_1.MessagePartType.TEXT,
+                        text: newText,
+                        role: 'user',
+                        update: seenPartIds.has(userId)
+                    });
+                    seenPartIds.add(userId);
+                }
+            }
+            else if (update.sessionUpdate === 'agent_message' ||
+                update.sessionUpdate === 'assistant_message' ||
+                update.sessionUpdate === 'user_message' ||
+                update.sessionUpdate === 'human_message') {
+                const text = this.extractTextFromUpdateContent(update.content);
+                if (!text)
+                    return parts;
+                const role = update.sessionUpdate === 'user_message' || update.sessionUpdate === 'human_message'
+                    ? 'user'
+                    : 'assistant';
+                // For assistant messages without a stable messageId, derive a
+                // deterministic ID from the current turn so it matches the streaming
+                // chunk ID (`agent-response-{turnId}`).  This prevents duplicates
+                // where the same text shows up once from chunks and again from
+                // the final agent_message event with a random UUID.
+                let partId;
+                if (update.messageId) {
+                    partId = update.messageId;
+                }
+                else if (role === 'assistant' && session) {
+                    const turnId = this.getAssistantTurnId(session);
+                    partId = turnId > 0 ? `agent-response-${turnId}` : 'agent-response';
+                }
+                else {
+                    partId = `${update.sessionUpdate}-${(0, crypto_1.randomUUID)()}`;
+                }
+                const alreadySeen = seenPartIds.has(partId);
+                if (!alreadySeen) {
+                    seenPartIds.add(partId);
+                    partContentLengths.set(partId, text);
+                    parts.push({
+                        id: partId,
+                        type: coding_agent_adapter_1.MessagePartType.TEXT,
+                        text,
+                        role
+                    });
+                }
+                else if (role === 'assistant') {
+                    // Final agent_message may have more complete text than the
+                    // accumulated chunks — update the existing entry so the
+                    // renderer gets the definitive version.
+                    const existingText = partContentLengths.get(partId) || '';
+                    if (text.length > existingText.length) {
+                        partContentLengths.set(partId, text);
+                        parts.push({
+                            id: partId,
+                            type: coding_agent_adapter_1.MessagePartType.TEXT,
+                            text,
+                            role,
+                            update: true
+                        });
+                    }
+                }
+            }
+            else if (update.sessionUpdate === 'plan') {
+                // Handle agent plan - we can ignore this for now or display it later
+                // Format: { entries: [{ content: '...', priority: 'high', status: 'pending' }] }
+                console.log(`[AcpAdapter/${this.agentType}] Received plan with ${(update.entries || []).length} entries`);
+            }
+            // Only update lastSessionUpdateType for events that affect turn detection.
+            // Non-content events like `plan` and `available_commands_update` must NOT
+            // pollute turn state — otherwise they cause the next assistant chunk to
+            // start a spurious new turn, fragmenting the response into multiple bubbles.
+            if (session && update.sessionUpdate) {
+                const isTurnRelevant = this.isAssistantChunkUpdateType(update.sessionUpdate)
+                    || this.isToolingUpdateType(update.sessionUpdate)
+                    || this.isUserUpdateType(update.sessionUpdate)
+                    || update.sessionUpdate === 'agent_message'
+                    || update.sessionUpdate === 'assistant_message';
+                if (isTurnRelevant) {
+                    session.lastSessionUpdateType = update.sessionUpdate;
+                }
+            }
+        }
+        return parts;
+    }
+}
+exports.AcpAdapter = AcpAdapter;