@peakflo/agent-harness 0.0.0-stage → 0.2.1-rc.3

package/dist/adapters/claude-code-adapter.js

@@ -0,0 +1,1918 @@
+"use strict";
+/**
+ * Claude Code Adapter
+ *
+ * Implements CodingAgentAdapter for Claude Code using @anthropic-ai/claude-agent-sdk.
+ *
+ * Key differences from OpenCode:
+ * - Uses AsyncGenerator streaming API instead of HTTP client
+ * - File-based session persistence (~/.claude/sessions/)
+ * - Different message format (SDKMessage vs OpenCode messages)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeCodeAdapter = exports.ClaudeSystemSubtype = void 0;
+const coding_agent_adapter_1 = require("./coding-agent-adapter");
+const permission_mode_1 = require("../runtime/permission-mode");
+let ClaudeAgentSDK = null;
+/** Module-level cache for the resolved Claude executable path (persists across adapter instances) */
+let resolvedClaudeExecutablePath = null;
+/** Maximum number of messages to keep in the buffer per session */
+const MAX_MESSAGE_BUFFER_SIZE = 500;
+var ClaudeSystemSubtype;
+(function (ClaudeSystemSubtype) {
+    ClaudeSystemSubtype["INIT"] = "init";
+    ClaudeSystemSubtype["TASK_STARTED"] = "task_started";
+    ClaudeSystemSubtype["TASK_PROGRESS"] = "task_progress";
+    ClaudeSystemSubtype["TASK_NOTIFICATION"] = "task_notification";
+    ClaudeSystemSubtype["TASK_UPDATED"] = "task_updated";
+    /** Authoritative in-flight background-task list. Emitted by the CLI but NOT
+     *  surfaced by SDK >= 0.3.x (absent from the SDKMessage union) — older bundled
+     *  SDKs (e.g. 0.2.x) do pass it through, so it is handled defensively both as a
+     *  status source and as a transcript-suppression case. */
+    ClaudeSystemSubtype["BACKGROUND_TASKS_CHANGED"] = "background_tasks_changed";
+    ClaudeSystemSubtype["STATUS"] = "status";
+    ClaudeSystemSubtype["THINKING_TOKENS"] = "thinking_tokens";
+})(ClaudeSystemSubtype || (exports.ClaudeSystemSubtype = ClaudeSystemSubtype = {}));
+/**
+ * Terminal states for a Claude Code background task. Once a task reports one of
+ * these (via `task_updated.patch.status` or `task_notification.status`) it is no
+ * longer in flight and stops counting towards the session being BUSY.
+ */
+const TERMINAL_TASK_STATUSES = new Set(['completed', 'failed', 'killed', 'stopped']);
+/**
+ * Safety cap on how long a background task may be considered "in flight".
+ * Because in-flight background work suppresses IDLE *and* exempts the session
+ * from agent-manager's stuck-session watchdog, a task whose terminal
+ * notification is lost would otherwise pin the session BUSY forever. Generous
+ * enough that no legitimate subagent hits it.
+ */
+const MAX_BACKGROUND_TASK_AGE_MS = 60 * 60 * 1000; // 60 minutes
+class ClaudeCodeAdapter {
+    sessions = new Map();
+    sdkLoading = null;
+    claudeExecutablePath = null;
+    /**
+     * Callback set by agent-manager to trigger an immediate poll cycle
+     * when new stream data is buffered.  Eliminates the up-to-2-second
+     * latency of the fixed-interval polling heartbeat.
+     */
+    onDataAvailable;
+    constructor() {
+        this.sdkLoading = this.loadSDK();
+    }
+    /**
+     * Find the Claude CLI executable path
+     */
+    async findClaudeExecutable() {
+        if (this.claudeExecutablePath) {
+            return this.claudeExecutablePath;
+        }
+        // Check module-level cache (persists across adapter instances)
+        if (resolvedClaudeExecutablePath) {
+            this.claudeExecutablePath = resolvedClaudeExecutablePath;
+            return this.claudeExecutablePath;
+        }
+        const isWin = process.platform === 'win32';
+        try {
+            const { execFile } = await Promise.resolve().then(() => __importStar(require('child_process')));
+            const { promisify } = await Promise.resolve().then(() => __importStar(require('util')));
+            const execFileAsync = promisify(execFile);
+            // Try to find claude in PATH
+            const whichCmd = isWin ? 'where' : 'which';
+            const binaryName = 'claude';
+            const { stdout } = await execFileAsync(whichCmd, [binaryName]);
+            let found = stdout.trim().split(/\r?\n/)[0];
+            // On Windows, the SDK spawns the executable directly without shell,
+            // so .cmd files fail with EINVAL. Resolve .cmd → the underlying cli.js
+            // so the SDK uses `node cli.js` instead.
+            if (isWin) {
+                found = await this.resolveWindowsCmdToJs(found);
+            }
+            this.claudeExecutablePath = found;
+            resolvedClaudeExecutablePath = found;
+            console.log(`[ClaudeCodeAdapter] Found claude executable at: ${this.claudeExecutablePath}`);
+            return this.claudeExecutablePath;
+        }
+        catch {
+            // Common installation locations — must cover Homebrew, npm globals,
+            // pnpm globals, Volta, and NVM paths so the binary is found even when
+            // the shell PATH wasn't fully resolved (packaged macOS GUI app).
+            const home = process.env.HOME || process.env.USERPROFILE || '';
+            const commonPaths = isWin
+                ? [
+                    `${home}\\AppData\\Roaming\\npm\\node_modules\\@anthropic-ai\\claude-code\\cli.js`,
+                    `${home}\\AppData\\Roaming\\npm\\claude.cmd`,
+                    `${home}\\AppData\\Roaming\\npm\\claude.exe`,
+                    `${home}\\.local\\bin\\claude.cmd`,
+                    `${home}\\.local\\bin\\claude.exe`
+                ]
+                : [
+                    '/usr/local/bin/claude',
+                    '/opt/homebrew/bin/claude',
+                    `${home}/.local/bin/claude`,
+                    `${home}/.npm-global/bin/claude`,
+                    `${home}/Library/pnpm/claude`,
+                    `${home}/.volta/bin/claude`,
+                ];
+            // Dynamically detect NVM-managed npm global bin (avoids hardcoding a Node version)
+            if (!isWin && home) {
+                try {
+                    const { join } = await Promise.resolve().then(() => __importStar(require('path')));
+                    const { readdirSync } = await Promise.resolve().then(() => __importStar(require('fs')));
+                    const nvmDir = join(home, '.nvm', 'versions', 'node');
+                    const versions = readdirSync(nvmDir);
+                    versions.sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
+                    for (const v of versions) {
+                        commonPaths.push(join(nvmDir, v, 'bin', 'claude'));
+                    }
+                }
+                catch {
+                    // NVM not installed — skip
+                }
+            }
+            const { existsSync } = await Promise.resolve().then(() => __importStar(require('fs')));
+            for (const path of commonPaths) {
+                if (existsSync(path)) {
+                    let resolved = path;
+                    if (isWin && path.endsWith('.cmd')) {
+                        resolved = await this.resolveWindowsCmdToJs(path);
+                    }
+                    this.claudeExecutablePath = resolved;
+                    resolvedClaudeExecutablePath = resolved;
+                    console.log(`[ClaudeCodeAdapter] Found claude executable at: ${this.claudeExecutablePath}`);
+                    return this.claudeExecutablePath;
+                }
+            }
+            throw new Error('Claude CLI not found. Install it with: npm install -g @anthropic-ai/claude-code');
+        }
+    }
+    /**
+     * On Windows, .cmd wrapper files can't be spawned directly by the SDK
+     * (no shell: true). Resolve claude.cmd → the underlying cli.js path.
+     */
+    async resolveWindowsCmdToJs(cmdPath) {
+        try {
+            const { readFileSync, existsSync } = await Promise.resolve().then(() => __importStar(require('fs')));
+            const { join, dirname } = await Promise.resolve().then(() => __importStar(require('path')));
+            // Try the known npm global layout first: same dir as .cmd → node_modules/@anthropic-ai/claude-code/cli.js
+            const cmdDir = dirname(cmdPath);
+            const cliJs = join(cmdDir, 'node_modules', '@anthropic-ai', 'claude-code', 'cli.js');
+            if (existsSync(cliJs)) {
+                console.log(`[ClaudeCodeAdapter] Resolved .cmd → ${cliJs}`);
+                return cliJs;
+            }
+            // Parse the .cmd file to extract the JS path
+            const content = readFileSync(cmdPath, 'utf8');
+            const match = content.match(/"[^"]*node(?:\.exe)?"[^"]*"([^"]+\.js)"/)
+                || content.match(/node(?:\.exe)?\s+"([^"]+\.js)"/)
+                || content.match(/node(?:\.exe)?\s+([^\s]+\.js)/);
+            if (match?.[1]) {
+                const resolvedJs = match[1].includes('%dp0%')
+                    ? match[1].replace(/%dp0%/g, cmdDir + '\\')
+                    : match[1];
+                if (existsSync(resolvedJs)) {
+                    console.log(`[ClaudeCodeAdapter] Parsed .cmd → ${resolvedJs}`);
+                    return resolvedJs;
+                }
+            }
+        }
+        catch (err) {
+            console.warn(`[ClaudeCodeAdapter] Failed to resolve .cmd to .js:`, err);
+        }
+        // Fall back to original .cmd path
+        return cmdPath;
+    }
+    /**
+     * Build environment variables for Claude process
+     * Removes CLAUDECODE to prevent nested session errors.
+     * When secrets are configured, sets SHELL to the secret-shell.sh wrapper
+     * so every bash command fetches secrets from the broker transparently.
+     */
+    buildClaudeEnvironment() {
+        const env = { ...process.env };
+        // Remove CLAUDECODE to prevent nested session error
+        delete env.CLAUDECODE;
+        return env;
+    }
+    /**
+     * Build PreToolUse hooks for secret injection.
+     * Registers a hook that prepends `export KEY='value'` lines to each Bash command.
+     * The LLM never sees the modified command — only the original tool call and
+     * the output appear in conversation context.
+     */
+    buildSecretHooks(config) {
+        const secretEnvVars = config.secretEnvVars;
+        if (!secretEnvVars || Object.keys(secretEnvVars).length === 0) {
+            return undefined;
+        }
+        // Build shell export lines — single-quote values, escape embedded quotes
+        const exportLines = Object.entries(secretEnvVars)
+            .map(([k, v]) => `export ${k}='${v.replace(/'/g, "'\\''")}'`)
+            .join('\n');
+        console.log(`[ClaudeCodeAdapter] Registering PreToolUse hook for secrets: [${Object.keys(secretEnvVars).join(', ')}]`);
+        const hook = async (input) => {
+            const toolInput = ('tool_input' in input ? input.tool_input : undefined);
+            if (!toolInput?.command) {
+                return {};
+            }
+            // Prepend secret exports to the bash command
+            const originalCommand = toolInput.command;
+            const modifiedCommand = exportLines + '\n' + originalCommand;
+            return {
+                hookSpecificOutput: {
+                    hookEventName: 'PreToolUse',
+                    updatedInput: {
+                        ...toolInput,
+                        command: modifiedCommand
+                    }
+                }
+            };
+        };
+        return {
+            PreToolUse: [{
+                    matcher: 'Bash',
+                    hooks: [hook]
+                }]
+        };
+    }
+    async loadSDK() {
+        try {
+            ClaudeAgentSDK = await Promise.resolve().then(() => __importStar(require('@anthropic-ai/claude-agent-sdk')));
+            console.log('[ClaudeCodeAdapter] SDK loaded successfully');
+        }
+        catch (error) {
+            console.error('[ClaudeCodeAdapter] Failed to load SDK:', error);
+            ClaudeAgentSDK = null;
+        }
+        finally {
+            this.sdkLoading = null;
+        }
+    }
+    async ensureSDKLoaded() {
+        if (ClaudeAgentSDK)
+            return;
+        if (this.sdkLoading) {
+            await this.sdkLoading;
+        }
+        if (!ClaudeAgentSDK) {
+            throw new Error('Claude Agent SDK failed to load');
+        }
+    }
+    async initialize() {
+        await this.ensureSDKLoaded();
+    }
+    async createSession(config) {
+        await this.ensureSDKLoaded();
+        if (!ClaudeAgentSDK) {
+            throw new Error('Claude Agent SDK not loaded');
+        }
+        // Create session state (without starting a query yet)
+        // The first sendPrompt call will start the actual query
+        const session = {
+            sessionId: '', // Will be set from first message
+            queryIterator: null,
+            abortController: null,
+            status: 'idle',
+            messageBuffer: [],
+            messageCursor: 0,
+            streamTask: null,
+            lastError: null,
+            config, // Store config for use in sendPrompt
+            isResumed: false, // New session, not resumed
+            backgroundTasks: new Map(),
+            sawResult: false,
+            enqueuePrompt: null,
+            releasePrompt: null,
+        };
+        // Generate UUID-format session ID (required by Claude Code)
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const sessionId = randomUUID();
+        this.sessions.set(sessionId, session);
+        console.log(`[ClaudeCodeAdapter] Session created: ${sessionId}`);
+        return sessionId;
+    }
+    /**
+     * Check if a session ID is valid for Claude Code (UUID format)
+     */
+    isValidClaudeSessionId(sessionId) {
+        // Claude Code expects UUID format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+        const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+        return uuidRegex.test(sessionId);
+    }
+    /**
+     * Load conversation history from Claude session file
+     */
+    /**
+     * Cleans the session file by removing messages with empty text blocks
+     * This prevents API errors when resuming sessions
+     */
+    async cleanSessionFile(sessionId, workspaceDir) {
+        try {
+            const { readFileSync, writeFileSync, existsSync } = await Promise.resolve().then(() => __importStar(require('fs')));
+            const { join } = await Promise.resolve().then(() => __importStar(require('path')));
+            const { homedir } = await Promise.resolve().then(() => __importStar(require('os')));
+            const claudeDir = join(homedir(), '.claude', 'projects');
+            // Claude Code CLI encodes workspace paths by replacing all non-alphanumeric/non-hyphen chars with '-'
+            const encodedWorkspace = workspaceDir.replace(/[^a-zA-Z0-9-]/g, '-');
+            const sessionFile = join(claudeDir, encodedWorkspace, `${sessionId}.jsonl`);
+            console.log(`[ClaudeCodeAdapter] Cleaning session file: ${sessionFile}`);
+            // Check if session file exists
+            if (!existsSync(sessionFile)) {
+                console.log(`[ClaudeCodeAdapter] Session file not found, skipping clean: ${sessionFile}`);
+                return;
+            }
+            const content = readFileSync(sessionFile, 'utf-8');
+            const lines = content.trim().split('\n');
+            const cleanedLines = [];
+            for (const line of lines) {
+                const entry = JSON.parse(line);
+                // Keep non-message entries as-is
+                if (entry.type !== 'user' && entry.type !== 'assistant') {
+                    cleanedLines.push(line);
+                    continue;
+                }
+                // Check if message has content with empty text blocks
+                if (entry.message?.content) {
+                    let hasEmptyText = false;
+                    for (const contentPart of entry.message.content) {
+                        if (contentPart.type === 'text' && (!contentPart.text || contentPart.text.trim() === '')) {
+                            hasEmptyText = true;
+                            break;
+                        }
+                    }
+                    // Skip messages with empty text blocks
+                    if (hasEmptyText) {
+                        console.log(`[ClaudeCodeAdapter] Removing message with empty text block: ${entry.uuid}`);
+                        continue;
+                    }
+                }
+                cleanedLines.push(line);
+            }
+            // Write cleaned content back
+            writeFileSync(sessionFile, cleanedLines.join('\n') + '\n', 'utf-8');
+            console.log(`[ClaudeCodeAdapter] Session file cleaned: ${lines.length} -> ${cleanedLines.length} lines`);
+        }
+        catch (error) {
+            console.warn(`[ClaudeCodeAdapter] Failed to clean session file:`, error);
+            // Don't throw - let resume attempt proceed even if cleaning fails
+        }
+    }
+    /**
+     * Public, side-effect-free read of the persisted session history from the
+     * on-disk JSONL — no CLI/SDK spawn, no live session required. Used to backfill
+     * the durable transcript projection once. Returns [] if the file is missing.
+     */
+    async getPersistedMessages(sessionId, config) {
+        const workspaceDir = config.workspaceDir;
+        if (!workspaceDir)
+            return [];
+        try {
+            return await this.loadSessionHistory(sessionId, workspaceDir);
+        }
+        catch {
+            return [];
+        }
+    }
+    async loadSessionHistory(sessionId, workspaceDir) {
+        try {
+            const { readFileSync, existsSync } = await Promise.resolve().then(() => __importStar(require('fs')));
+            const { join } = await Promise.resolve().then(() => __importStar(require('path')));
+            const { homedir } = await Promise.resolve().then(() => __importStar(require('os')));
+            // Session files are stored in: ~/.claude/projects/[encoded-workspace]/[sessionId].jsonl
+            // Claude Code CLI encodes workspace paths by replacing all non-alphanumeric/non-hyphen chars with '-'
+            const claudeDir = join(homedir(), '.claude', 'projects');
+            const encodedWorkspace = workspaceDir.replace(/[^a-zA-Z0-9-]/g, '-');
+            const sessionFile = join(claudeDir, encodedWorkspace, `${sessionId}.jsonl`);
+            console.log(`[ClaudeCodeAdapter] Loading session history from: ${sessionFile}`);
+            // Check if session file exists
+            if (!existsSync(sessionFile)) {
+                console.warn(`[ClaudeCodeAdapter] Session file not found: ${sessionFile}`);
+                throw new Error('SESSION_FILE_NOT_FOUND: The Claude Code session file does not exist. This may happen if the session was deleted or never synced.');
+            }
+            const content = readFileSync(sessionFile, 'utf-8');
+            const lines = content.trim().split('\n');
+            const messages = [];
+            // Map tool_use_id → part reference so tool_result can merge into it
+            const toolUseParts = new Map();
+            for (const line of lines) {
+                const entry = JSON.parse(line);
+                // Skip non-message entries (queue-operation, etc.)
+                if (entry.type !== 'user' && entry.type !== 'assistant')
+                    continue;
+                const message = {
+                    id: entry.uuid,
+                    role: entry.type === 'user' ? coding_agent_adapter_1.MessageRole.USER : coding_agent_adapter_1.MessageRole.ASSISTANT,
+                    parts: []
+                };
+                // Parse message content
+                // Use the stable API message ID for part IDs — must match the pattern
+                // in convertSDKMessageToParts so that dedup state from loadSessionHistory
+                // correctly prevents re-emission of historical messages during streaming replay.
+                const stableId = entry.message?.id || entry.uuid || entry.type;
+                if (entry.message?.content) {
+                    for (let blockIdx = 0; blockIdx < entry.message.content.length; blockIdx++) {
+                        const contentPart = entry.message.content[blockIdx];
+                        if (contentPart.type === 'text') {
+                            // Skip empty text blocks (corrupt messages)
+                            if (!contentPart.text || contentPart.text.trim() === '')
+                                continue;
+                            message.parts.push({
+                                id: `${stableId}-text-${blockIdx}`,
+                                type: coding_agent_adapter_1.MessagePartType.TEXT,
+                                text: contentPart.text,
+                                content: contentPart.text
+                            });
+                        }
+                        else if (contentPart.type === 'thinking') {
+                            if (!contentPart.thinking || contentPart.thinking.trim() === '')
+                                continue;
+                            message.parts.push({
+                                id: `${stableId}-thinking-${blockIdx}`,
+                                type: coding_agent_adapter_1.MessagePartType.REASONING,
+                                text: contentPart.thinking,
+                                content: contentPart.thinking
+                            });
+                        }
+                        else if (contentPart.type === 'tool_use') {
+                            const rawInput = contentPart.input;
+                            const toolName = contentPart.name || 'unknown';
+                            const title = this.buildToolTitle(toolName, rawInput);
+                            const input = rawInput ? JSON.stringify(rawInput, null, 2) : undefined;
+                            const toolObj = {
+                                name: toolName,
+                                status: 'pending',
+                                title,
+                                input,
+                            };
+                            // Detect TodoWrite → set todowrite type and extract todos
+                            let partType = coding_agent_adapter_1.MessagePartType.TOOL;
+                            let todos = rawInput?.todos;
+                            if (typeof todos === 'string') {
+                                try {
+                                    todos = JSON.parse(todos);
+                                }
+                                catch { }
+                            }
+                            if (Array.isArray(todos) && todos.length > 0) {
+                                partType = 'todowrite';
+                                toolObj.todos = todos.map((t, i) => ({
+                                    id: t.id || `todo-${i}`,
+                                    content: t.content || '',
+                                    status: t.status || 'pending',
+                                    priority: t.priority,
+                                }));
+                            }
+                            // Detect AskUserQuestion → set question type and extract questions
+                            let questions = rawInput?.questions;
+                            if (typeof questions === 'string') {
+                                try {
+                                    questions = JSON.parse(questions);
+                                }
+                                catch { }
+                            }
+                            if (Array.isArray(questions) && questions.length > 0) {
+                                partType = 'question';
+                                toolObj.questions = questions;
+                            }
+                            // Detect EnterPlanMode / ExitPlanMode → set planreview type
+                            // For ExitPlanMode, the plan content is in input.plan (not in tool_result)
+                            if (toolName === 'EnterPlanMode' || toolName === 'ExitPlanMode') {
+                                partType = 'planreview';
+                                toolObj.title = toolName === 'EnterPlanMode' ? 'Enter plan mode' : 'Exit plan mode';
+                                if (toolName === 'ExitPlanMode' && rawInput?.plan) {
+                                    toolObj.output = String(rawInput.plan).slice(0, 50000);
+                                }
+                            }
+                            const toolPartId = contentPart.id ? `tool-${contentPart.id}` : `${stableId}-tool_use-${contentPart.id || blockIdx}`;
+                            message.parts.push({ id: toolPartId, type: partType, tool: toolObj });
+                            if (contentPart.id)
+                                toolUseParts.set(contentPart.id, toolObj);
+                        }
+                        else if (contentPart.type === 'tool_result' && contentPart.tool_use_id) {
+                            // Merge result into the matching tool_use part instead of creating separate entry
+                            const matchingTool = toolUseParts.get(contentPart.tool_use_id);
+                            if (matchingTool) {
+                                matchingTool.status = 'success';
+                                // Plan content should not be truncated (cap at 50K for safety)
+                                const isPlan = matchingTool.name === 'ExitPlanMode' || matchingTool.name === 'EnterPlanMode';
+                                const rawContent = contentPart.content ? String(contentPart.content) : undefined;
+                                // Filter out confirmation prompts like "Exit/Enter plan mode?"
+                                const sanitized = isPlan && rawContent && /^(exit|enter) plan mode\??$/i.test(rawContent.trim())
+                                    ? undefined : rawContent;
+                                matchingTool.output = sanitized
+                                    ? (isPlan ? sanitized.slice(0, 50000) : sanitized.slice(0, 2000))
+                                    : undefined;
+                            }
+                            // Don't push a separate part — result is merged into tool_use
+                        }
+                    }
+                }
+                if (message.parts.length > 0) {
+                    // Preserve the ORIGINAL event time from the session log so replay/
+                    // rehydration shows real timestamps (and the durable projection stores
+                    // them as created_at) instead of defaulting to "now" on every reload.
+                    const receivedAt = entry.timestamp ? Date.parse(entry.timestamp) : NaN;
+                    if (!Number.isNaN(receivedAt)) {
+                        for (const part of message.parts)
+                            part.receivedAt = receivedAt;
+                    }
+                    messages.push(message);
+                }
+            }
+            console.log(`[ClaudeCodeAdapter] Loaded ${messages.length} messages from session history`);
+            return messages;
+        }
+        catch (error) {
+            // Re-throw session file not found errors
+            const errMsg = error instanceof Error ? error.message : String(error);
+            if (errMsg.includes('SESSION_FILE_NOT_FOUND')) {
+                throw error;
+            }
+            // For other errors, warn and return empty array
+            console.warn(`[ClaudeCodeAdapter] Failed to load session history:`, errMsg);
+            return [];
+        }
+    }
+    async resumeSession(sessionId, config) {
+        await this.ensureSDKLoaded();
+        if (!ClaudeAgentSDK) {
+            throw new Error('Claude Agent SDK not loaded');
+        }
+        // Validate session ID format
+        if (!this.isValidClaudeSessionId(sessionId)) {
+            console.warn(`[ClaudeCodeAdapter] Invalid session ID format: ${sessionId}`);
+            throw new Error('INCOMPATIBLE_SESSION_ID: This session was created with a different coding agent and cannot be resumed with Claude Code.');
+        }
+        // Clean session file to remove empty text blocks before resuming
+        await this.cleanSessionFile(sessionId, config.workspaceDir);
+        // Create session state (idle until user sends a message)
+        const session = {
+            sessionId,
+            queryIterator: null, // Will be created when user sends first message
+            abortController: null,
+            status: 'idle',
+            messageBuffer: [],
+            messageCursor: 0,
+            streamTask: null,
+            lastError: null,
+            config, // Store config for later use
+            isResumed: true, // Resumed from persistence
+            backgroundTasks: new Map(),
+            sawResult: false,
+            enqueuePrompt: null,
+            releasePrompt: null,
+        };
+        this.sessions.set(sessionId, session);
+        // Don't start query yet - wait for user to send a message
+        // The query will be started in sendPrompt with resume option
+        console.log(`[ClaudeCodeAdapter] Session resumed: ${sessionId} (waiting for user prompt)`);
+        // Load conversation history from session file
+        const messages = await this.loadSessionHistory(sessionId, config.workspaceDir);
+        console.log(`[ClaudeCodeAdapter] Session loaded with ${messages.length} messages`);
+        return messages;
+    }
+    async sendPrompt(sessionId, parts, config) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        if (!ClaudeAgentSDK) {
+            throw new Error('Claude Agent SDK not loaded');
+        }
+        // Extract text from 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 prompt parts');
+        }
+        // Note: Don't add user message to buffer - agent-manager already shows it
+        // to avoid duplicate messages in UI
+        // Check if this is the first prompt (no query running yet)
+        const isFirstPrompt = !session.queryIterator;
+        // A live query owns a persistent prompt stream. Add the next turn to that
+        // stream instead of closing and recreating the harness process at every
+        // normal idle boundary.
+        if (!isFirstPrompt && session.enqueuePrompt) {
+            session.sawResult = false;
+            session.status = 'busy';
+            session.lastError = null;
+            session.enqueuePrompt(promptText);
+            return;
+        }
+        // Recovery path for an old or incomplete live-session state which has no
+        // prompt queue. Close that process before creating a correct persistent one.
+        if (!isFirstPrompt && session.queryIterator) {
+            session.releasePrompt?.();
+            session.releasePrompt = null;
+            session.enqueuePrompt = null;
+            session.abortController?.abort();
+            // Wait for stream cleanup to complete to avoid race conditions
+            if (session.streamTask) {
+                try {
+                    await session.streamTask;
+                }
+                catch {
+                    // Ignore errors during cleanup (abort errors are expected)
+                }
+            }
+        }
+        // Find Claude executable
+        const claudePath = await this.findClaudeExecutable();
+        // Create new abort controller
+        const abortController = new AbortController();
+        session.abortController = abortController;
+        // Build options
+        const secretHooks = this.buildSecretHooks(config);
+        const effort = config.reasoningEffort === 'minimal' ? undefined : config.reasoningEffort;
+        const claudePermissionMode = (0, permission_mode_1.claudeCodePermissionMode)(config);
+        const options = {
+            cwd: config.workspaceDir,
+            pathToClaudeCodeExecutable: claudePath,
+            env: this.buildClaudeEnvironment(),
+            mcpServers: config.mcpServers,
+            model: config.model,
+            effort,
+            systemPrompt: config.systemPrompt,
+            abortController,
+            /*
+             * DEFECT G1 WAS BORN ON THIS LINE.
+             *
+             * It used to read:
+             *     permissionMode: 'bypassPermissions', // Auto-approve all actions
+             *     allowDangerouslySkipPermissions: true,
+             *
+             * — a hardcode, with the per-agent `permission_mode` sitting unread in
+             * the config that was passed in. Every agent ran fully unrestricted no
+             * matter what the user chose, while the UI showed them their choice.
+             *
+             * The comment justified it with "the user has already chosen to run
+             * agent". That was true of 20x's ORIGINAL shape, where the agent ran on
+             * the user's own laptop with the user watching. It stopped being true the
+             * moment the same adapter ran unattended in a cloud sandbox with a real
+             * filesystem, which is the whole point of the sandbox.
+             *
+             * `claudeCodePermissionMode` reconstructs the user's original four-valued
+             * choice from the (permissionMode, sandboxMode) pair the runner mapped it
+             * onto — see runtime/permission-mode.ts for the table. Claude Code is the
+             * one backend that takes all four natively, so nothing is lost here.
+             *
+             * A config with NO permissionMode maps to 'default', NOT to
+             * 'bypassPermissions'. That is deliberate: the old behaviour must not be
+             * reachable by omission, or every caller that forgets the field silently
+             * restores the defect.
+             */
+            permissionMode: claudePermissionMode,
+            // ONLY for the mode that actually asks for it. The SDK requires this flag
+            // to honour 'bypassPermissions'; passing it unconditionally would make
+            // the mode above decorative in exactly the way G1 was.
+            ...(claudePermissionMode === 'bypassPermissions'
+                ? { allowDangerouslySkipPermissions: true }
+                : {}),
+            ...(secretHooks ? { hooks: secretHooks } : {}),
+        };
+        // Determine session continuation mode
+        if (isFirstPrompt && session.isResumed) {
+            // First prompt after resume: use resume to load persisted session
+            options.resume = sessionId;
+            // Don't use continue with resume - they're mutually exclusive
+        }
+        else if (isFirstPrompt && session.sessionId) {
+            // Process exited (error recovery or idle timeout) but session has a
+            // valid Claude Code UUID. Resume from persistence so the agent keeps
+            // its full conversation history instead of starting from scratch.
+            options.resume = session.sessionId;
+        }
+        else if (!isFirstPrompt) {
+            // Subsequent prompts: continue existing session in same process
+            options.continue = true;
+        }
+        // Otherwise: brand-new session, no continue/resume needed
+        console.log('[ClaudeCodeAdapter] Starting query with options:', {
+            cwd: options.cwd,
+            pathToClaudeCodeExecutable: options.pathToClaudeCodeExecutable,
+            model: options.model,
+            effort: options.effort,
+            permissionMode: options.permissionMode,
+            continue: options.continue,
+            resume: options.resume,
+            isFirstPrompt,
+            isResumed: session.isResumed,
+            promptLength: promptText.length,
+            promptPreview: promptText.substring(0, 100),
+            hasEnv: !!options.env,
+            hasMcpServers: !!options.mcpServers,
+            mcpServerNames: options.mcpServers ? Object.keys(options.mcpServers) : [],
+        });
+        // ── Streaming-input prompt ──
+        // Passing a plain string puts the Claude Code CLI in one-shot mode: it closes
+        // stdin, and as soon as the turn emits `result` the process tears down and
+        // KILLS any background task still in flight (observed as
+        // `task_updated {status:'killed'}` / `task_notification {status:'stopped'}`).
+        // Since Claude Code backgrounds Task-tool subagents by default, that silently
+        // killed subagents the moment the coordinator's turn went quiet.
+        //
+        // The queue stays open across normal idle boundaries. This matches the
+        // lifecycle used by the other push-based harness adapters: polling can stop,
+        // while the provider event stream remains subscribed and can wake it later.
+        const promptQueue = [promptText];
+        let wakePromptReader = null;
+        let promptStreamClosed = false;
+        session.enqueuePrompt = (nextPrompt) => {
+            if (promptStreamClosed)
+                return;
+            promptQueue.push(nextPrompt);
+            wakePromptReader?.();
+            wakePromptReader = null;
+        };
+        session.releasePrompt = () => {
+            if (promptStreamClosed)
+                return;
+            promptStreamClosed = true;
+            wakePromptReader?.();
+            wakePromptReader = null;
+        };
+        session.backgroundTasks.clear();
+        session.sawResult = false;
+        const promptStream = (async function* () {
+            while (!promptStreamClosed) {
+                if (promptQueue.length === 0) {
+                    await new Promise((resolve) => {
+                        wakePromptReader = resolve;
+                    });
+                    continue;
+                }
+                const nextPrompt = promptQueue.shift();
+                yield {
+                    type: 'user',
+                    message: { role: 'user', content: nextPrompt },
+                    parent_tool_use_id: null,
+                };
+            }
+        })();
+        // Start new query
+        const query = ClaudeAgentSDK.query({
+            prompt: promptStream,
+            options,
+        });
+        console.log('[ClaudeCodeAdapter] Query created, starting stream consumption');
+        session.queryIterator = query;
+        session.status = 'busy';
+        session.lastError = null; // Clear any previous error (e.g., rate limit) for recovery
+        if (!isFirstPrompt) {
+            session.messageBuffer = []; // Clear buffer for new messages (but keep history for first prompt)
+            session.messageCursor = 0;
+        }
+        // After first prompt in a resumed session, clear the flag so subsequent prompts use continue
+        if (isFirstPrompt && session.isResumed) {
+            session.isResumed = false;
+        }
+        // Start consuming stream
+        session.streamTask = this.consumeStream(sessionId, session);
+    }
+    async getStatus(sessionId, _config) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return { type: coding_agent_adapter_1.SessionStatusType.ERROR, message: 'Session not found' };
+        }
+        if (session.lastError) {
+            return { type: coding_agent_adapter_1.SessionStatusType.ERROR, message: session.lastError };
+        }
+        // getStatus is the 2s poll path, so it is also where a stalled background
+        // task gets aged out and a turn that finished between stream messages gets
+        // settled — otherwise a lost terminal notification would pin BUSY forever.
+        this.settleTurnIfComplete(sessionId, session);
+        // A turn that ended while subagents are still running in the background is
+        // paused, not finished. Reporting IDLE here makes agent-manager mark the task
+        // ready_for_review, unregister it from polling (so the subagents' output can
+        // never be delivered) and eventually reap the session — killing them.
+        if (session.backgroundTasks.size > 0) {
+            return { type: coding_agent_adapter_1.SessionStatusType.BUSY };
+        }
+        return {
+            type: session.status === 'busy' ? coding_agent_adapter_1.SessionStatusType.BUSY : coding_agent_adapter_1.SessionStatusType.IDLE,
+        };
+    }
+    /**
+     * Exposes in-flight background subagents as "running tools" so agent-manager's
+     * delegation-aware watchdogs (which look for tool names like `task`/`agent`)
+     * stand down instead of aborting a coordinator that is waiting on children.
+     */
+    async getRunningTools(sessionId, _config) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return [];
+        // Every entry is reported as `task` — a name in agent-manager's
+        // DELEGATION_TOOL_NAMES set. Backgrounded work (subagent *and* bash) is
+        // long-running by design, so it must be exempt from BOTH the 90s stuck-tool
+        // detector and the 5min stuck-session watchdog; naming a backgrounded bash
+        // 'bash' would instead get the session aborted after 90 seconds.
+        return [...session.backgroundTasks.values()].map((t) => ({
+            partId: `task-${t.taskId}`,
+            toolName: 'task',
+            startTime: t.startedAt,
+            input: { taskType: t.taskType ?? 'unknown', description: t.description ?? '' },
+        }));
+    }
+    async pollMessages(sessionId, _seenMessageIds, seenPartIds, partContentLengths, _config) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return [];
+        }
+        const newParts = [];
+        // Process only NEW buffered messages using cursor (avoids re-scanning entire buffer)
+        const bufferLen = session.messageBuffer.length;
+        for (let i = session.messageCursor; i < bufferLen; i++) {
+            const sdkMsg = session.messageBuffer[i];
+            const msgId = this.getMessageId(sdkMsg);
+            if (!msgId)
+                continue;
+            // Convert SDKMessage to MessagePart
+            const parts = this.convertSDKMessageToParts(sdkMsg, seenPartIds, partContentLengths);
+            newParts.push(...parts);
+        }
+        // Advance cursor past processed messages
+        session.messageCursor = bufferLen;
+        // If we have the real Claude session ID and it's different from the map key,
+        // include it in the first part so agent-manager can update the database
+        if (session.sessionId && session.sessionId !== sessionId && newParts.length > 0) {
+            newParts[0].realSessionId = session.sessionId;
+        }
+        return newParts;
+    }
+    async abortPrompt(sessionId, _config) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        console.log(`[ClaudeCodeAdapter] Aborting session ${sessionId}`);
+        // Close the streaming-input prompt first so the generator can't keep the
+        // process alive while we wait for the stream task to unwind.
+        session.releasePrompt?.();
+        session.releasePrompt = null;
+        session.enqueuePrompt = null;
+        session.backgroundTasks.clear();
+        session.abortController?.abort();
+        // Wait for stream to finish cleanup
+        if (session.streamTask) {
+            console.log(`[ClaudeCodeAdapter] Waiting for stream cleanup...`);
+            try {
+                await session.streamTask;
+            }
+            catch {
+                // Ignore abort errors
+            }
+            console.log(`[ClaudeCodeAdapter] Stream cleanup complete`);
+        }
+        session.status = 'idle';
+        console.log(`[ClaudeCodeAdapter] Session ${sessionId} aborted and set to idle`);
+    }
+    async destroySession(sessionId, _config) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        // Abort any ongoing query
+        session.releasePrompt?.();
+        session.releasePrompt = null;
+        session.enqueuePrompt = null;
+        session.backgroundTasks.clear();
+        session.abortController?.abort();
+        // Wait for stream task to complete
+        if (session.streamTask) {
+            try {
+                await session.streamTask;
+            }
+            catch {
+                // Ignore errors during cleanup
+            }
+        }
+        // Remove all references to this session (both temp ID and real ID)
+        // Since re-keying keeps both keys, we need to clean up both
+        const keysToDelete = [];
+        for (const [key, sess] of this.sessions.entries()) {
+            if (sess === session) {
+                keysToDelete.push(key);
+            }
+        }
+        for (const key of keysToDelete) {
+            this.sessions.delete(key);
+            console.log(`[ClaudeCodeAdapter] Removed session key: ${key}`);
+        }
+    }
+    async getAllMessages(sessionId, _config) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return [];
+        }
+        // Reuse the same convertSDKMessageToParts() that the live streaming path uses.
+        // This ensures replay produces the same message structure (IDs, content, tool
+        // fields) as the original live stream, which is critical for:
+        //   - Correct content extraction from nested message.content[] arrays
+        //   - Proper tool names (tool_name vs name), statuses, and titles
+        //   - Consistent part IDs so mobile dedup works on reconnect
+        const seenPartIds = new Set();
+        const partContentLengths = new Map();
+        const messages = [];
+        let currentMessage = null;
+        let messageIdCounter = 0;
+        for (const msg of session.messageBuffer) {
+            // Derive role from message type
+            const msgRecord = msg;
+            const roleStr = (msgRecord.role || (msg.type === 'user' ? 'user' : '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;
+            // Convert using the full SDK message parser
+            const parts = this.convertSDKMessageToParts(msg, seenPartIds, partContentLengths);
+            if (parts.length === 0)
+                continue;
+            // Start new message if role changed
+            if (!currentMessage || currentMessage.role !== role) {
+                if (currentMessage) {
+                    messages.push(currentMessage);
+                }
+                currentMessage = {
+                    id: `msg-${messageIdCounter++}`,
+                    role,
+                    parts: []
+                };
+            }
+            currentMessage.parts.push(...parts);
+        }
+        // Push last message
+        if (currentMessage) {
+            messages.push(currentMessage);
+        }
+        return messages;
+    }
+    async respondToQuestion(sessionId, answers, config) {
+        // Claude Code runs with bypassPermissions, so AskUserQuestion ends the
+        // session turn (it appears in permission_denials in the result message).
+        // Send the user's answer as a follow-up prompt to continue the conversation.
+        const answerText = Object.values(answers).filter(Boolean).join('\n');
+        if (!answerText) {
+            console.warn(`[ClaudeCodeAdapter] respondToQuestion called with empty answers for session ${sessionId}`);
+            return;
+        }
+        console.log(`[ClaudeCodeAdapter] Sending question answer as follow-up prompt for session ${sessionId}`);
+        await this.sendPrompt(sessionId, [{ type: coding_agent_adapter_1.MessagePartType.TEXT, text: answerText }], config);
+    }
+    async registerMcpServer(_serverName, _mcpConfig, _workspaceDir) {
+        // Claude Code handles MCP servers via the mcpServers option
+        // They're passed per-session in createSession/resumeSession/sendPrompt
+        // No global registration needed
+    }
+    async checkHealth() {
+        try {
+            await this.ensureSDKLoaded();
+            if (!ClaudeAgentSDK) {
+                return { available: false, reason: 'Claude Agent SDK not loaded' };
+            }
+            return { available: true };
+        }
+        catch (error) {
+            return { available: false, reason: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    // ========================================================================
+    // Private Helper Methods
+    // ========================================================================
+    /**
+     * Safely logs a message by truncating large base64 content
+     */
+    /**
+     * Lightweight message logger — only logs type/subtype to avoid blocking
+     * the event loop with expensive JSON serialization on every streaming chunk.
+     */
+    safeLogMessage(msg) {
+        if (!msg || typeof msg !== 'object')
+            return;
+        const m = msg;
+        console.log(`[ClaudeCodeAdapter] msg: type=${m.type} subtype=${m.subtype || '-'}`);
+    }
+    /**
+     * Consumes the query stream in the background and buffers messages
+     */
+    async consumeStream(sessionId, session) {
+        if (!session.queryIterator)
+            return;
+        console.log('[ClaudeCodeAdapter] Starting stream consumption');
+        try {
+            let messagesSinceYield = 0;
+            for await (const message of session.queryIterator) {
+                // Guard against undefined/null messages from the SDK (can happen during
+                // process crashes, lock acquisition failures, or SDK bugs)
+                if (!message || typeof message !== 'object') {
+                    console.warn('[ClaudeCodeAdapter] Received invalid message from SDK, skipping:', typeof message);
+                    continue;
+                }
+                const msg = message;
+                // ── Prevent microtask starvation ──
+                // When the subprocess sends a burst of messages, the async iterator
+                // resolves each next() as a microtask without ever yielding to the
+                // macrotask queue.  This starves IPC, timers, and rendering callbacks,
+                // making the UI completely unresponsive (loading cursor).
+                // Yield every 5 messages so the event loop can process I/O.
+                messagesSinceYield++;
+                if (messagesSinceYield >= 5) {
+                    messagesSinceYield = 0;
+                    await new Promise((r) => setImmediate(r));
+                }
+                // Log message with truncation for large content
+                this.safeLogMessage(message);
+                // Extract real Claude Code session ID from first message
+                if (!session.sessionId && 'session_id' in msg) {
+                    const realSessionId = msg.session_id;
+                    session.sessionId = realSessionId;
+                    console.log(`[ClaudeCodeAdapter] Claude Code session ID: ${realSessionId}`);
+                    // Add the session under the real ID (keep old ID too until agent-manager updates)
+                    // This allows pollMessages to work with both IDs during transition
+                    if (realSessionId !== sessionId) {
+                        console.log(`[ClaudeCodeAdapter] Adding session under real ID: ${realSessionId} (keeping temp ID ${sessionId} until agent-manager updates)`);
+                        this.sessions.set(realSessionId, session);
+                        // Don't delete the old sessionId yet - agent-manager needs to poll with it
+                        // to receive the realSessionId. The old key will be deleted by destroySession
+                        // or when agent-manager explicitly removes it.
+                    }
+                }
+                // Check for session not found error BEFORE buffering
+                if (msg.type === 'result' && msg.subtype === 'error_during_execution' && msg.is_error) {
+                    const errors = Array.isArray(msg.errors) ? msg.errors : [];
+                    const sessionNotFound = errors.some((err) => err.includes('No conversation found') || err.includes('session ID'));
+                    if (sessionNotFound) {
+                        console.warn('[ClaudeCodeAdapter] Session not found on Claude Code server:', errors);
+                        // Don't buffer this error message - throw immediately
+                        throw new Error('INCOMPATIBLE_SESSION_ID: This session does not exist on Claude Code servers. It may have been created with a different coding agent or has expired.');
+                    }
+                }
+                // Handle error result messages (e.g., rate limits) before treating as normal
+                if (msg.type === 'result' && msg.is_error) {
+                    const raw = msg;
+                    // Extract meaningful error text from all available fields:
+                    // - `result` may be a string or object
+                    // - `errors` may be an array of error strings
+                    // - `error` may be a string
+                    const resultField = raw.result;
+                    const errorsField = Array.isArray(raw.errors) ? raw.errors : [];
+                    const errorField = typeof raw.error === 'string' ? raw.error : '';
+                    const subtypeField = typeof raw.subtype === 'string' ? raw.subtype : '';
+                    let errorText;
+                    if (typeof resultField === 'string' && resultField.length > 0) {
+                        errorText = resultField;
+                    }
+                    else if (errorsField.length > 0) {
+                        errorText = errorsField.map(String).join('; ');
+                    }
+                    else if (errorField) {
+                        errorText = errorField;
+                    }
+                    else if (resultField && typeof resultField === 'object') {
+                        errorText = JSON.stringify(resultField);
+                    }
+                    else if (subtypeField) {
+                        errorText = `Error during ${subtypeField}`;
+                    }
+                    else {
+                        errorText = 'Unknown error (no details in result message)';
+                    }
+                    console.warn('[ClaudeCodeAdapter] Received error result:', errorText);
+                    console.warn('[ClaudeCodeAdapter] Full error result message:', JSON.stringify(raw, null, 2));
+                    session.status = 'error';
+                    session.lastError = errorText;
+                }
+                if (msg.type === 'assistant' && msg.isApiErrorMessage === true) {
+                    const raw = msg;
+                    const messageField = raw.message;
+                    const contentField = Array.isArray(messageField?.content)
+                        ? messageField.content
+                        : Array.isArray(raw.content) ? raw.content : [];
+                    const text = contentField
+                        .map((part) => {
+                        const partRecord = part;
+                        return partRecord.type === 'text' ? partRecord.text || '' : '';
+                    })
+                        .filter(Boolean)
+                        .join('\n');
+                    session.status = 'error';
+                    session.lastError = text || 'Claude Code API error';
+                }
+                // Buffer message (only if we didn't throw above)
+                session.messageBuffer.push(message);
+                // Cap buffer size to prevent unbounded memory growth.
+                // Drop already-processed messages from the front when limit is exceeded.
+                if (session.messageBuffer.length > MAX_MESSAGE_BUFFER_SIZE) {
+                    const drop = session.messageBuffer.length - MAX_MESSAGE_BUFFER_SIZE;
+                    session.messageBuffer.splice(0, drop);
+                    session.messageCursor = Math.max(0, session.messageCursor - drop);
+                }
+                // Notify the polling coordinator that new data is available so it can
+                // deliver this message to the UI immediately instead of waiting for
+                // the next 2-second heartbeat tick.
+                if (this.onDataAvailable) {
+                    this.onDataAvailable(sessionId);
+                }
+                // Track background subagent/bash tasks so we never report the session as
+                // finished while children are still running.
+                this.trackBackgroundTask(sessionId, session, message);
+                // Update status based on message type
+                if (msg.type === 'status') {
+                    console.log(`[ClaudeCodeAdapter] Status update: ${msg.subtype}`);
+                    if (msg.subtype === 'busy') {
+                        session.status = 'busy';
+                        session.sawResult = false;
+                    }
+                    else if (msg.subtype === 'idle') {
+                        session.status = 'idle';
+                    }
+                }
+                else if (msg.type === 'result' && !msg.is_error) {
+                    console.log('[ClaudeCodeAdapter] Received result message');
+                    session.sawResult = true;
+                }
+                else if (msg.type === 'assistant' || msg.type === 'user') {
+                    // A new turn started (e.g. a background task woke the session back up)
+                    session.sawResult = false;
+                }
+                // The turn is only really over when `result` arrived AND nothing is left
+                // running in the background.
+                this.settleTurnIfComplete(sessionId, session);
+                // Log stderr/stdout if present
+                if (msg.type === 'stream_event' && msg.stderr) {
+                    console.error('[ClaudeCodeAdapter] Claude stderr:', msg.stderr);
+                }
+                if (msg.type === 'stream_event' && msg.stdout) {
+                    console.log('[ClaudeCodeAdapter] Claude stdout:', msg.stdout);
+                }
+            }
+            console.log('[ClaudeCodeAdapter] Stream consumption completed normally');
+        }
+        catch (error) {
+            const errName = error instanceof Error ? error.name : '';
+            const errMsg = error instanceof Error ? error.message : String(error);
+            const errStack = error instanceof Error ? error.stack : undefined;
+            if (errName === 'AbortError' || errMsg.includes('aborted by user')) {
+                console.log('[ClaudeCodeAdapter] Stream aborted by user');
+                // Don't set error status - this is normal when sending a new message
+            }
+            else if (errMsg.includes('INCOMPATIBLE_SESSION_ID')) {
+                // Store temporarily so resumeSession can detect and re-throw it
+                console.warn('[ClaudeCodeAdapter] Incompatible session error detected');
+                session.status = 'error';
+                session.lastError = errMsg;
+            }
+            else if (errMsg.includes('exited with code 1')) {
+                // Claude Code process failed - could be rate limit, resume failure, or other error
+                console.error('[ClaudeCodeAdapter] Claude Code process failed:', errMsg);
+                // Only treat as incompatible session if this was a resumed session AND we
+                // don't already have a specific error from the result message (e.g., rate limits).
+                // Note: session.config is always set, so only check session.isResumed here.
+                if (!session.lastError && session.isResumed) {
+                    console.warn('[ClaudeCodeAdapter] Resume failed - session may not exist on Claude servers');
+                    session.status = 'error';
+                    session.lastError = 'INCOMPATIBLE_SESSION_ID: Failed to resume session. The session may have expired or does not exist on Claude Code servers.';
+                }
+                else if (!session.lastError) {
+                    session.status = 'error';
+                    session.lastError = errMsg;
+                }
+            }
+            else {
+                console.error('[ClaudeCodeAdapter] Stream error:', error);
+                console.error('[ClaudeCodeAdapter] Error stack:', errStack);
+                console.error('[ClaudeCodeAdapter] Error details:', JSON.stringify(error, error instanceof Error ? Object.getOwnPropertyNames(error) : undefined, 2));
+                session.status = 'error';
+                session.lastError = errMsg;
+            }
+        }
+        finally {
+            console.log('[ClaudeCodeAdapter] Stream consumption ended');
+            // Always reset queryIterator when the stream ends (process exited).
+            // Previously only error paths did this, leaving a truthy-but-exhausted
+            // iterator after normal completion.  That caused the next sendPrompt to
+            // use `--continue` (most-recent conversation in directory) instead of
+            // `--resume <sessionId>` (exact session).  If any other session
+            // (heartbeat, subtask) ran in the same directory during idle, --continue
+            // would pick up the wrong conversation — the intermittent context-loss bug.
+            session.queryIterator = null;
+            // The process is gone, so nothing can still be running in the background.
+            session.backgroundTasks.clear();
+            session.releasePrompt?.();
+            session.releasePrompt = null;
+            session.enqueuePrompt = null;
+            if (session.status === 'error') {
+                // Error path: queryIterator already null above; no extra work needed.
+            }
+            else {
+                session.status = 'idle';
+                // Mark as resumed so the next sendPrompt uses --resume with the exact
+                // session ID rather than --continue (which targets most-recent in dir).
+                session.isResumed = true;
+            }
+        }
+    }
+    /**
+     * Maintains `session.backgroundTasks` from the SDK's task lifecycle messages.
+     *
+     * Note: the raw CLI also emits `background_tasks_changed` (which carries the
+     * authoritative in-flight list), but the SDK filters it out — it is not part of
+     * the `SDKMessage` union — so the set has to be rebuilt from task_started plus
+     * task_updated / task_notification.
+     */
+    trackBackgroundTask(sessionId, session, message) {
+        const msg = message;
+        if (msg.type !== 'system')
+            return;
+        // `background_tasks_changed` carries the CLI's authoritative in-flight list.
+        // SDK >= 0.3.x filters it out (verified against 0.3.169 and 0.3.195), but the
+        // app has historically bundled older SDKs that do pass it through — prefer it
+        // when available, since it cannot drift the way reconstruction can.
+        if (msg.subtype === ClaudeSystemSubtype.BACKGROUND_TASKS_CHANGED && Array.isArray(msg.tasks)) {
+            const next = new Map();
+            for (const t of msg.tasks) {
+                if (!t?.task_id)
+                    continue;
+                const existing = session.backgroundTasks.get(t.task_id);
+                next.set(t.task_id, {
+                    taskId: t.task_id,
+                    taskType: t.task_type ?? existing?.taskType,
+                    description: t.description ?? existing?.description,
+                    // Preserve the original start time so the staleness cap stays meaningful.
+                    startedAt: existing?.startedAt ?? Date.now(),
+                });
+            }
+            session.backgroundTasks = next;
+            console.log(`[ClaudeCodeAdapter] Background task list for ${sessionId} refreshed from ` +
+                `background_tasks_changed — ${next.size} in flight`);
+            return;
+        }
+        if (!msg.task_id)
+            return;
+        if (msg.subtype === ClaudeSystemSubtype.TASK_STARTED) {
+            session.backgroundTasks.set(msg.task_id, {
+                taskId: msg.task_id,
+                taskType: msg.task_type || (msg.subagent_type ? 'local_agent' : undefined),
+                description: msg.description,
+                startedAt: Date.now(),
+            });
+            console.log(`[ClaudeCodeAdapter] Background task started for ${sessionId}: ${msg.task_id} ` +
+                `(${msg.task_type || 'unknown'}) — ${session.backgroundTasks.size} in flight`);
+            return;
+        }
+        const terminalStatus = msg.subtype === ClaudeSystemSubtype.TASK_NOTIFICATION ? msg.status :
+            msg.subtype === ClaudeSystemSubtype.TASK_UPDATED ? msg.patch?.status :
+                undefined;
+        if (terminalStatus && TERMINAL_TASK_STATUSES.has(terminalStatus)) {
+            if (session.backgroundTasks.delete(msg.task_id)) {
+                console.log(`[ClaudeCodeAdapter] Background task ${msg.task_id} ${terminalStatus} for ${sessionId} — ` +
+                    `${session.backgroundTasks.size} still in flight`);
+            }
+        }
+    }
+    /**
+     * Drops background tasks that have outlived MAX_BACKGROUND_TASK_AGE_MS so a
+     * lost terminal notification can't keep the session BUSY (and un-reapable)
+     * indefinitely.
+     */
+    pruneStaleBackgroundTasks(sessionId, session) {
+        if (session.backgroundTasks.size === 0)
+            return;
+        const now = Date.now();
+        for (const [taskId, task] of session.backgroundTasks) {
+            if (now - task.startedAt > MAX_BACKGROUND_TASK_AGE_MS) {
+                session.backgroundTasks.delete(taskId);
+                console.warn(`[ClaudeCodeAdapter] Background task ${taskId} for ${sessionId} exceeded ` +
+                    `${MAX_BACKGROUND_TASK_AGE_MS / 60000}min without a terminal notification — ` +
+                    `no longer counting it as in flight`);
+            }
+        }
+    }
+    /**
+     * Marks the current turn idle once it has produced a `result` AND no
+     * background task is still running. The streaming-input prompt remains open
+     * for the full session lifetime. Until background work is complete,
+     * the session stays BUSY so agent-manager keeps polling instead of calling
+     * transitionToIdle (which flips the task to ready_for_review and eventually
+     * lets the inactivity reaper destroy the session out from under the subagents).
+     */
+    settleTurnIfComplete(sessionId, session) {
+        if (session.status === 'error')
+            return;
+        this.pruneStaleBackgroundTasks(sessionId, session);
+        if (!session.sawResult)
+            return;
+        if (session.backgroundTasks.size > 0) {
+            // Paused waiting on background work — explicitly NOT idle.
+            session.status = 'busy';
+            return;
+        }
+        if (session.status !== 'idle') {
+            console.log(`[ClaudeCodeAdapter] Turn complete for ${sessionId}, no background tasks left → idle`);
+        }
+        session.status = 'idle';
+    }
+    /**
+     * Extracts a unique message ID from SDKMessage
+     */
+    getMessageId(msg) {
+        if ('uuid' in msg && msg.uuid) {
+            return msg.uuid;
+        }
+        if ('message_id' in msg && msg.message_id) {
+            return msg.message_id;
+        }
+        return null;
+    }
+    /**
+     * Converts SDKMessage to MessagePart[] format
+     */
+    convertSDKMessageToParts(msg, seenPartIds, partContentLengths) {
+        const parts = [];
+        const msgWithProps = msg;
+        // ── Skip messages from inside a subtask ──
+        // Messages originating from a subagent task have a non-null parent_tool_use_id.
+        // These would otherwise leak as top-level user messages / tool calls in the
+        // transcript.  The task_started / task_progress / task_notification events
+        // already provide the high-level summary, so we suppress the inner messages.
+        // Exception: system messages (task_started, task_progress, task_notification,
+        // status) do NOT carry parent_tool_use_id and must always be processed.
+        if (msgWithProps.parent_tool_use_id) {
+            return parts;
+        }
+        // Handle assistant_message type
+        if (msgWithProps.type === 'assistant' || msgWithProps.type === 'assistant_message') {
+            // Content is nested inside message.content for Claude Code SDK format
+            const content = msgWithProps.message?.content || (Array.isArray(msgWithProps.content) ? msgWithProps.content : []);
+            const partType = msgWithProps.isApiErrorMessage ? coding_agent_adapter_1.MessagePartType.ERROR : coding_agent_adapter_1.MessagePartType.TEXT;
+            // Use the stable API message ID (e.g. msg_01FG7...) for dedup, not the streaming UUID.
+            // Claude Code sends multiple streaming chunks with different UUIDs but the same API message ID
+            // and the same text block, which would otherwise create duplicate text bubbles in the UI.
+            const stableId = msgWithProps.message?.id || msgWithProps.uuid || msgWithProps.type;
+            for (let blockIdx = 0; blockIdx < content.length; blockIdx++) {
+                const block = content[blockIdx];
+                const blockWithProps = block;
+                // For text blocks (no id), use stable message ID + block index for consistent dedup.
+                // For tool_use blocks, blockWithProps.id is the tool_use_id which is already stable.
+                const partId = `${stableId}-${blockWithProps.type}-${blockWithProps.id || blockIdx}`;
+                if (blockWithProps.type === 'text') {
+                    const text = blockWithProps.text || '';
+                    if (seenPartIds.has(partId)) {
+                        // Check if text content has grown since last seen (streaming update).
+                        // Without this, the first chunk (possibly empty/partial) gets recorded
+                        // and all subsequent chunks with the actual text are silently dropped,
+                        // causing missing assistant responses in the UI.
+                        const previousLength = partContentLengths.get(partId);
+                        if (previousLength !== undefined && String(text.length) !== previousLength && text.length > 0) {
+                            partContentLengths.set(partId, String(text.length));
+                            parts.push({
+                                id: partId,
+                                type: partType,
+                                text,
+                                update: true,
+                            });
+                        }
+                        continue;
+                    }
+                    seenPartIds.add(partId);
+                    partContentLengths.set(partId, String(text.length));
+                    parts.push({
+                        id: partId,
+                        type: partType,
+                        text,
+                    });
+                }
+                else if (blockWithProps.type === 'thinking') {
+                    const thinking = blockWithProps.thinking || '';
+                    if (seenPartIds.has(partId)) {
+                        const previousLength = partContentLengths.get(partId);
+                        if (previousLength !== undefined && String(thinking.length) !== previousLength && thinking.length > 0) {
+                            partContentLengths.set(partId, String(thinking.length));
+                            parts.push({
+                                id: partId,
+                                type: coding_agent_adapter_1.MessagePartType.REASONING,
+                                text: thinking,
+                                role: 'assistant',
+                                update: true,
+                            });
+                        }
+                        continue;
+                    }
+                    seenPartIds.add(partId);
+                    partContentLengths.set(partId, String(thinking.length));
+                    parts.push({
+                        id: partId,
+                        type: coding_agent_adapter_1.MessagePartType.REASONING,
+                        text: thinking,
+                        role: 'assistant',
+                    });
+                }
+                else if (seenPartIds.has(partId)) {
+                    continue;
+                }
+                else if (blockWithProps.type === 'tool_use') {
+                    seenPartIds.add(partId);
+                    const toolName = blockWithProps.name || 'unknown';
+                    const rawInput = blockWithProps.input;
+                    const input = rawInput ? JSON.stringify(rawInput, null, 2) : undefined;
+                    const toolUseId = blockWithProps.id || '';
+                    // Use tool_use_id as partId so we can update it when result arrives
+                    const toolPartId = `tool-${toolUseId}`;
+                    if (seenPartIds.has(toolPartId))
+                        continue;
+                    seenPartIds.add(toolPartId);
+                    // Build a human-readable title from tool input (mirrors buildPartPayload for OpenCode)
+                    const title = this.buildToolTitle(toolName, rawInput);
+                    // Detect AskUserQuestion → render as interactive question
+                    let questions = rawInput?.questions;
+                    if (typeof questions === 'string') {
+                        try {
+                            questions = JSON.parse(questions);
+                        }
+                        catch { }
+                    }
+                    if (Array.isArray(questions) && questions.length > 0) {
+                        partContentLengths.set(toolPartId, `pending:${toolName}`);
+                        parts.push({
+                            id: toolPartId,
+                            type: 'question',
+                            content: title || 'Question',
+                            tool: { name: toolName, status: 'pending', title, input, questions },
+                        });
+                        continue;
+                    }
+                    // Detect TodoWrite → render as todo list
+                    let todos = rawInput?.todos;
+                    if (typeof todos === 'string') {
+                        try {
+                            todos = JSON.parse(todos);
+                        }
+                        catch { }
+                    }
+                    if (Array.isArray(todos) && todos.length > 0) {
+                        // Normalize: ensure each todo has an id (Claude Code SDK omits it)
+                        const normalizedTodos = todos.map((t, i) => ({
+                            id: t.id || `todo-${i}`,
+                            content: t.content || '',
+                            status: t.status || 'pending',
+                            priority: t.priority,
+                        }));
+                        partContentLengths.set(toolPartId, `pending:${toolName}`);
+                        parts.push({
+                            id: toolPartId,
+                            type: 'todowrite',
+                            content: title || 'Todo List',
+                            tool: { name: toolName, status: 'pending', title, input, todos: normalizedTodos },
+                        });
+                        continue;
+                    }
+                    // Detect EnterPlanMode / ExitPlanMode → render as plan mode indicator
+                    // For ExitPlanMode, the plan content is in input.plan (not in tool_result)
+                    if (toolName === 'EnterPlanMode' || toolName === 'ExitPlanMode') {
+                        const planTitle = toolName === 'EnterPlanMode' ? 'Enter plan mode' : 'Exit plan mode';
+                        const planContent = toolName === 'ExitPlanMode' && rawInput?.plan
+                            ? String(rawInput.plan).slice(0, 50000) : undefined;
+                        partContentLengths.set(toolPartId, `pending:${toolName}`);
+                        parts.push({
+                            id: toolPartId,
+                            type: 'planreview',
+                            content: planTitle,
+                            tool: { name: toolName, status: 'pending', title: planTitle, input, output: planContent },
+                        });
+                        continue;
+                    }
+                    // Regular tool call
+                    partContentLengths.set(toolPartId, `pending:${toolName}`);
+                    parts.push({
+                        id: toolPartId,
+                        type: coding_agent_adapter_1.MessagePartType.TOOL,
+                        content: title ? `${toolName} — ${title}` : toolName,
+                        tool: { name: toolName, status: 'pending', title, input },
+                    });
+                }
+            }
+        }
+        else if (msgWithProps.type === 'user' || msgWithProps.type === 'user_message') {
+            // User messages contain tool results or text
+            const content = msgWithProps.message?.content || (Array.isArray(msgWithProps.content) ? msgWithProps.content : []);
+            for (const block of content) {
+                const blockWithProps = block;
+                // Handle user text messages
+                if (blockWithProps.type === 'text' && blockWithProps.text) {
+                    const partId = `${msgWithProps.uuid || 'user'}-text`;
+                    if (!seenPartIds.has(partId)) {
+                        seenPartIds.add(partId);
+                        const text = blockWithProps.text;
+                        partContentLengths.set(partId, String(text.length));
+                        parts.push({
+                            id: partId,
+                            type: coding_agent_adapter_1.MessagePartType.TEXT,
+                            text,
+                            role: 'user', // User messages
+                        });
+                    }
+                }
+                else if (blockWithProps.type === 'tool_result' && blockWithProps.tool_use_id) {
+                    const toolPartId = `tool-${blockWithProps.tool_use_id}`;
+                    const resultContent = blockWithProps.content || '';
+                    // Check if we already sent the pending tool call
+                    const previousContent = partContentLengths.get(toolPartId);
+                    // Plan mode tools should not be truncated (cap at 50K for safety)
+                    const isPlanReview = previousContent?.endsWith(':ExitPlanMode') || previousContent?.endsWith(':EnterPlanMode');
+                    // Filter out confirmation prompts like "Exit plan mode?" / "Enter plan mode?" — not useful content
+                    const sanitizedResult = isPlanReview && /^(exit|enter) plan mode\??$/i.test(resultContent.trim())
+                        ? '' : resultContent;
+                    const outputContent = isPlanReview
+                        ? sanitizedResult.slice(0, 50000)
+                        : resultContent.slice(0, 2000);
+                    if (previousContent) {
+                        const toolName = previousContent.split(':')[1] || 'tool';
+                        // Update the existing tool part - mark as completed
+                        partContentLengths.set(toolPartId, `success:${resultContent.length}`);
+                        // For plan review: don't send empty output (would overwrite plan from input.plan)
+                        parts.push({
+                            id: toolPartId,
+                            type: isPlanReview ? 'planreview' : coding_agent_adapter_1.MessagePartType.TOOL,
+                            content: isPlanReview ? (toolName === 'EnterPlanMode' ? 'Enter plan mode' : 'Exit plan mode') : `Tool completed`,
+                            tool: {
+                                name: toolName,
+                                status: 'success',
+                                ...(outputContent ? { output: outputContent } : {}),
+                            },
+                            update: true, // Mark as update to existing message
+                        });
+                    }
+                    else {
+                        // Tool call wasn't seen yet, send result only
+                        if (!seenPartIds.has(toolPartId)) {
+                            seenPartIds.add(toolPartId);
+                            partContentLengths.set(toolPartId, `success:${resultContent.length}`);
+                            parts.push({
+                                id: toolPartId,
+                                type: isPlanReview ? 'planreview' : coding_agent_adapter_1.MessagePartType.TOOL,
+                                content: isPlanReview ? 'Plan mode' : `Tool result`,
+                                tool: {
+                                    name: isPlanReview ? 'ExitPlanMode' : 'tool',
+                                    status: 'success',
+                                    output: outputContent,
+                                },
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        else if (msgWithProps.type === 'tool_use_summary') {
+            const partId = `tool-${msgWithProps.tool_use_id || Date.now()}`;
+            const toolName = msgWithProps.tool_name || 'unknown';
+            const status = msgWithProps.status || 'unknown';
+            const isPlanReview = toolName === 'ExitPlanMode' || toolName === 'EnterPlanMode';
+            const rawOutput = msgWithProps.output ? String(msgWithProps.output) : undefined;
+            // Filter out confirmation prompts like "Exit/Enter plan mode?"
+            const sanitizedOutput = isPlanReview && rawOutput && /^(exit|enter) plan mode\??$/i.test(rawOutput.trim())
+                ? undefined : rawOutput;
+            const output = sanitizedOutput
+                ? (isPlanReview ? sanitizedOutput.slice(0, 50000) : sanitizedOutput.slice(0, 2000))
+                : undefined;
+            const partType = isPlanReview ? 'planreview' : coding_agent_adapter_1.MessagePartType.TOOL;
+            const planLabel = toolName === 'EnterPlanMode' ? 'Enter plan mode' : 'Exit plan mode';
+            if (seenPartIds.has(partId)) {
+                // Tool_use was already emitted — send an UPDATE to merge the result into it
+                partContentLengths.set(partId, `${status}:${output?.length || 0}`);
+                parts.push({
+                    id: partId,
+                    type: partType,
+                    content: isPlanReview ? planLabel : `${toolName} — ${status}`,
+                    tool: { name: toolName, status, output },
+                    update: true,
+                });
+            }
+            else {
+                // First time seeing this tool — add as new entry
+                seenPartIds.add(partId);
+                partContentLengths.set(partId, `${status}:${output?.length || 0}`);
+                parts.push({
+                    id: partId,
+                    type: partType,
+                    content: isPlanReview ? planLabel : `${toolName} — ${status}`,
+                    tool: { name: toolName, status, output },
+                });
+            }
+        }
+        else if (msgWithProps.type === 'tool_progress') {
+            // SDKToolProgressMessage — periodic progress updates for running tools.
+            // Update the existing tool part with elapsed time so the UI shows a timer.
+            const toolUseId = msgWithProps.tool_use_id;
+            if (toolUseId) {
+                const partId = `tool-${toolUseId}`;
+                const toolName = msgWithProps.tool_name || 'tool';
+                const elapsed = msgWithProps.elapsed_time_seconds ?? 0;
+                const elapsedLabel = elapsed >= 60
+                    ? `${Math.floor(elapsed / 60)}m ${Math.round(elapsed % 60)}s`
+                    : `${Math.round(elapsed)}s`;
+                if (seenPartIds.has(partId)) {
+                    // Tool was already emitted — send an update with elapsed time
+                    parts.push({
+                        id: partId,
+                        type: coding_agent_adapter_1.MessagePartType.TOOL,
+                        tool: {
+                            name: toolName,
+                            status: 'running',
+                            title: `Running… ${elapsedLabel}`,
+                        },
+                        update: true,
+                    });
+                }
+                // If tool hasn't been seen yet, skip — progress before tool_use is meaningless
+            }
+        }
+        else if (msgWithProps.type === 'result') {
+            // Surface error result messages (e.g., rate limit errors) to the UI
+            const resultMsg = msg;
+            if (resultMsg.is_error) {
+                // Extract error text from all available fields (result, errors, error)
+                const resultField = resultMsg.result;
+                const errorsField = Array.isArray(resultMsg.errors) ? resultMsg.errors : [];
+                const errorField = typeof resultMsg.error === 'string' ? resultMsg.error : '';
+                let errorText;
+                if (typeof resultField === 'string' && resultField.length > 0) {
+                    errorText = resultField;
+                }
+                else if (errorsField.length > 0) {
+                    errorText = errorsField.map(String).join('; ');
+                }
+                else if (errorField) {
+                    errorText = errorField;
+                }
+                else if (resultField && typeof resultField === 'object') {
+                    errorText = JSON.stringify(resultField);
+                }
+                else {
+                    errorText = 'An error occurred (no details available)';
+                }
+                const partId = `result-error-${msgWithProps.uuid || Date.now()}`;
+                if (!seenPartIds.has(partId)) {
+                    seenPartIds.add(partId);
+                    partContentLengths.set(partId, String(errorText.length));
+                    parts.push({
+                        id: partId,
+                        type: coding_agent_adapter_1.MessagePartType.ERROR,
+                        text: errorText,
+                        role: 'system',
+                    });
+                }
+            }
+            else {
+                // Non-error result: extract the final assistant text as a safety net.
+                // Normally the text was already sent in a preceding assistant message event,
+                // but if the first streaming chunk had empty text and no subsequent chunk
+                // updated it, the result message is the only source of the final response.
+                const resultText = typeof resultMsg.result === 'string' ? resultMsg.result : '';
+                if (resultText) {
+                    // Check if any assistant text part was already emitted with non-empty content.
+                    // If so, skip — the text is already shown.  If not, emit it now.
+                    let hasNonEmptyText = false;
+                    for (const [pid, len] of partContentLengths) {
+                        if (pid.includes('-text-') && parseInt(len, 10) > 0) {
+                            hasNonEmptyText = true;
+                            break;
+                        }
+                    }
+                    if (!hasNonEmptyText) {
+                        const partId = `result-text-${msgWithProps.uuid || Date.now()}`;
+                        if (!seenPartIds.has(partId)) {
+                            seenPartIds.add(partId);
+                            partContentLengths.set(partId, String(resultText.length));
+                            parts.push({
+                                id: partId,
+                                type: coding_agent_adapter_1.MessagePartType.TEXT,
+                                text: resultText,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        else if (msgWithProps.type === 'system') {
+            // Skip system init messages - they're internal session setup
+            if (msgWithProps.subtype === ClaudeSystemSubtype.INIT) {
+                return parts;
+            }
+            // SDKTaskStartedMessage — subagent task started
+            if (msgWithProps.subtype === ClaudeSystemSubtype.TASK_STARTED) {
+                const taskId = msgWithProps.task_id || msgWithProps.uuid || `task-${Date.now()}`;
+                const partId = `task-${taskId}`;
+                if (!seenPartIds.has(partId)) {
+                    seenPartIds.add(partId);
+                    partContentLengths.set(partId, `started:${taskId}`);
+                    parts.push({
+                        id: partId,
+                        type: coding_agent_adapter_1.MessagePartType.TASK_PROGRESS,
+                        content: msgWithProps.description || 'Subagent task started',
+                        taskProgress: {
+                            taskId,
+                            status: 'started',
+                            description: msgWithProps.description || '',
+                        }
+                    });
+                }
+                return parts;
+            }
+            // SDKTaskProgressMessage — periodic progress updates for running subagent tasks
+            if (msgWithProps.subtype === ClaudeSystemSubtype.TASK_PROGRESS) {
+                const taskId = msgWithProps.task_id || `task-${Date.now()}`;
+                const partId = `task-${taskId}`;
+                const usage = msgWithProps.usage;
+                const alreadySeen = seenPartIds.has(partId);
+                if (!alreadySeen) {
+                    // Missed task_started — create the entry
+                    seenPartIds.add(partId);
+                }
+                partContentLengths.set(partId, `running:${taskId}`);
+                parts.push({
+                    id: partId,
+                    type: coding_agent_adapter_1.MessagePartType.TASK_PROGRESS,
+                    content: msgWithProps.description || 'Subagent task in progress',
+                    taskProgress: {
+                        taskId,
+                        status: 'running',
+                        description: msgWithProps.description || '',
+                        lastToolName: msgWithProps.last_tool_name,
+                        summary: msgWithProps.summary,
+                        usage,
+                    },
+                    update: alreadySeen,
+                });
+                return parts;
+            }
+            // SDKTaskNotificationMessage — subtask completion notifications
+            if (msgWithProps.subtype === ClaudeSystemSubtype.TASK_NOTIFICATION) {
+                const taskId = msgWithProps.task_id || `task-${Date.now()}`;
+                const partId = `task-${taskId}`;
+                const taskStatus = (msgWithProps.status || 'completed');
+                const summary = msgWithProps.summary || `Task ${taskStatus}`;
+                const usage = msgWithProps.usage;
+                const alreadySeen = seenPartIds.has(partId);
+                if (!alreadySeen) {
+                    seenPartIds.add(partId);
+                }
+                partContentLengths.set(partId, `${taskStatus}:${taskId}`);
+                parts.push({
+                    id: partId,
+                    type: coding_agent_adapter_1.MessagePartType.TASK_PROGRESS,
+                    content: summary,
+                    taskProgress: {
+                        taskId,
+                        status: taskStatus,
+                        description: summary,
+                        summary,
+                        usage,
+                    },
+                    update: alreadySeen,
+                });
+                return parts;
+            }
+            // ── Internal background-task bookkeeping — never rendered ──
+            // `task_updated` carries wire-level status patches and `background_tasks_changed`
+            // carries the in-flight list. Both are consumed by trackBackgroundTask(); the
+            // user-visible progress is already covered by task_started / task_progress /
+            // task_notification. Without this they fall through to the generic system
+            // handler below, which pushes the raw subtype string as a text bubble —
+            // spamming the transcript with literal "task_updated" /
+            // "background_tasks_changed" messages between every subagent update.
+            if (msgWithProps.subtype === ClaudeSystemSubtype.TASK_UPDATED ||
+                msgWithProps.subtype === ClaudeSystemSubtype.BACKGROUND_TASKS_CHANGED) {
+                return parts;
+            }
+            // SDKStatusMessage — transient status indicators (e.g. 'compacting')
+            if (msgWithProps.subtype === ClaudeSystemSubtype.STATUS) {
+                // null status means "cleared" — skip
+                if (!msgWithProps.status)
+                    return parts;
+                const partId = `system-status-${msgWithProps.uuid || Date.now()}`;
+                if (!seenPartIds.has(partId)) {
+                    seenPartIds.add(partId);
+                    const statusLabel = msgWithProps.status === 'compacting'
+                        ? 'Compacting conversation history…'
+                        : String(msgWithProps.status);
+                    partContentLengths.set(partId, String(statusLabel.length));
+                    parts.push({
+                        id: partId,
+                        type: 'system-status',
+                        content: statusLabel,
+                        role: 'system',
+                    });
+                }
+                return parts;
+            }
+            // SDKThinkingTokensMessage — reasoning/thinking token updates from Claude Code
+            if (msgWithProps.subtype === ClaudeSystemSubtype.THINKING_TOKENS) {
+                const partId = `thinking-tokens-${msgWithProps.session_id || 'session'}`;
+                const alreadySeen = seenPartIds.has(partId);
+                const estimatedTokens = typeof msgWithProps.estimated_tokens === 'number'
+                    ? msgWithProps.estimated_tokens
+                    : undefined;
+                const content = estimatedTokens !== undefined
+                    ? `Estimated thinking tokens: ${estimatedTokens}`
+                    : 'Estimating thinking tokens...';
+                if (!alreadySeen) {
+                    seenPartIds.add(partId);
+                }
+                partContentLengths.set(partId, String(content.length));
+                parts.push({
+                    id: partId,
+                    type: coding_agent_adapter_1.MessagePartType.REASONING,
+                    text: content,
+                    role: 'assistant',
+                    update: alreadySeen,
+                });
+                return parts;
+            }
+            const partId = `system-${msgWithProps.uuid || Date.now()}`;
+            if (!seenPartIds.has(partId)) {
+                seenPartIds.add(partId);
+                const content = msgWithProps.subtype || 'System message';
+                partContentLengths.set(partId, String(content.length));
+                parts.push({
+                    id: partId,
+                    type: coding_agent_adapter_1.MessagePartType.TEXT,
+                    content,
+                });
+            }
+        }
+        return parts;
+    }
+    /**
+     * Builds a human-readable title for a tool call from its input.
+     * Mirrors the titles that OpenCode/buildPartPayload produces.
+     */
+    buildToolTitle(toolName, input) {
+        if (!input)
+            return '';
+        switch (toolName) {
+            case 'Bash':
+                return input.command ? String(input.command) : (input.description ? String(input.description) : '');
+            case 'Read':
+                return input.file_path ? String(input.file_path) : '';
+            case 'Edit':
+            case 'Write':
+                return input.file_path ? String(input.file_path) : '';
+            case 'Grep':
+                return input.pattern
+                    ? `${input.pattern}${input.path ? ` in ${input.path}` : ''}`
+                    : '';
+            case 'Glob':
+                return input.pattern ? String(input.pattern) : '';
+            case 'Task':
+                return input.description ? String(input.description) : '';
+            case 'WebFetch':
+                return input.url ? String(input.url) : '';
+            case 'WebSearch':
+                return input.query ? String(input.query) : '';
+            case 'TodoWrite':
+                return 'Todo List';
+            case 'AskUserQuestion':
+                return 'Question';
+            case 'EnterPlanMode':
+                return 'Enter plan mode';
+            case 'ExitPlanMode':
+                return 'Exit plan mode';
+            default:
+                return '';
+        }
+    }
+}
+exports.ClaudeCodeAdapter = ClaudeCodeAdapter;