sudocode 1.1.17 → 1.1.18-dev.0

package/node_modules/@sudocode-ai/local-server/dist/execution/executors/agent-executor-wrapper.js

@@ -0,0 +1,725 @@
+/**
+ * AgentExecutorWrapper - Generic wrapper for any agent adapter
+ *
+ * Provides a unified execution interface that works with any IAgentAdapter.
+ * Supports Claude Code, Codex, Cursor, Copilot, and any future agents.
+ *
+ * @module execution/executors/agent-executor-wrapper
+ */
+import { ClaudeCodeExecutor, CodexExecutor, CursorExecutor, CopilotExecutor, } from "agent-execution-engine/agents";
+import { NormalizedEntryToAgUiAdapter } from "../output/normalized-to-ag-ui-adapter.js";
+import { AgUiEventAdapter } from "../output/ag-ui-adapter.js";
+import { updateExecution, getExecution } from "../../services/executions.js";
+import { broadcastExecutionUpdate } from "../../services/websocket.js";
+import { execSync } from "child_process";
+import { ExecutionChangesService } from "../../services/execution-changes-service.js";
+import { notifyExecutionEvent } from "../../services/execution-event-callbacks.js";
+/**
+ * Merge agent config with overrides, filtering undefined values.
+ *
+ * Enables functional composition of configs where undefined values
+ * are treated as "not present" rather than explicit values.
+ *
+ * @param base - Base agent configuration
+ * @param overrides - Partial overrides to apply (undefined values ignored)
+ * @returns Merged configuration with undefined values filtered out
+ */
+function mergeAgentConfig(base, overrides) {
+    return {
+        ...base,
+        ...Object.fromEntries(Object.entries(overrides).filter(([_, v]) => v !== undefined)),
+    };
+}
+/**
+ * Generic wrapper for any agent adapter
+ *
+ * Provides basic execution lifecycle management for any agent that implements
+ * IAgentAdapter. This is a simplified version compared to ClaudeExecutorWrapper,
+ * which has specialized logic for Claude Code's protocol peer.
+ *
+ * @example
+ * ```typescript
+ * const wrapper = new AgentExecutorWrapper({
+ *   adapter: codexAdapter,
+ *   agentConfig: {
+ *     workDir: '/path/to/repo',
+ *     apiKey: 'sk-...',
+ *     model: 'code-davinci-002',
+ *   },
+ *   lifecycleService,
+ *   logsStore,
+ *   projectId: 'my-project',
+ *   db,
+ *   transportManager,
+ * });
+ *
+ * await wrapper.executeWithLifecycle(executionId, task, workDir);
+ * ```
+ */
+export class AgentExecutorWrapper {
+    adapter;
+    executor;
+    /** Agent type used for executor selection and logging */
+    agentType;
+    _agentConfig;
+    logsStore;
+    transportManager;
+    projectId;
+    db;
+    /** MOSTLY DEPRECATED. just used for the workdir today */
+    processConfig;
+    activeExecutions;
+    /** Track completion state for Claude Code executions (from protocol peer) */
+    completionState;
+    constructor(config) {
+        this.adapter = config.adapter;
+        this.agentType = config.agentType;
+        this._agentConfig = config.agentConfig;
+        this.logsStore = config.logsStore;
+        this.transportManager = config.transportManager;
+        this.projectId = config.projectId;
+        this.db = config.db;
+        this.activeExecutions = new Map();
+        this.completionState = new Map();
+        // Build process configuration from agent-specific config
+        this.processConfig = this.adapter.buildProcessConfig(this._agentConfig);
+        // Create executor instance based on agent type
+        this.executor = this.createExecutor(config.agentType, this._agentConfig);
+        console.log("[AgentExecutorWrapper] Initialized", {
+            agentType: this.agentType,
+            adapterName: this.adapter.metadata.name,
+            projectId: this.projectId,
+            workDir: this.processConfig.workDir,
+            hasTransport: !!this.transportManager,
+            hasLogsStore: !!this.logsStore,
+        });
+    }
+    /**
+     * Create the appropriate executor for the given agent type
+     *
+     * @param agentType - Type of agent
+     * @param agentConfig - Agent configuration
+     * @returns Executor instance
+     */
+    createExecutor(agentType, agentConfig) {
+        switch (agentType) {
+            case "claude-code":
+                return new ClaudeCodeExecutor({
+                    workDir: agentConfig.workDir,
+                    executablePath: agentConfig.claudePath,
+                    print: agentConfig.print ?? true,
+                    outputFormat: agentConfig.outputFormat ?? "stream-json",
+                    verbose: agentConfig.verbose ?? true,
+                    dangerouslySkipPermissions: agentConfig.dangerouslySkipPermissions ?? false,
+                    restrictToWorkDir: agentConfig.restrictToWorkDir ?? true,
+                    directoryGuardHookPath: agentConfig.directoryGuardHookPath,
+                    mcpServers: agentConfig.mcpServers,
+                    appendSystemPrompt: agentConfig.appendSystemPrompt,
+                    disallowedTools: agentConfig.disallowedTools,
+                });
+            case "codex":
+                return new CodexExecutor(agentConfig);
+            case "cursor":
+                return new CursorExecutor(agentConfig);
+            case "copilot":
+                return new CopilotExecutor(agentConfig);
+            default:
+                throw new Error(`Unknown agent type: ${agentType}`);
+        }
+    }
+    /**
+     * Execute a task with full lifecycle management
+     *
+     * @param executionId - Unique execution identifier
+     * @param task - Task to execute
+     * @param workDir - Working directory for execution
+     */
+    async executeWithLifecycle(executionId, task, workDir) {
+        console.log(`[AgentExecutorWrapper] Starting execution ${executionId}`, {
+            agentType: this.adapter.metadata.name,
+            taskId: task.id,
+            workDir,
+        });
+        // 1. Setup AG-UI system
+        const { agUiAdapter, normalizedAdapter } = this.setupAgUiSystem(executionId);
+        // 2. Connect to transport
+        if (this.transportManager) {
+            this.transportManager.connectAdapter(agUiAdapter, executionId);
+            console.log(`[AgentExecutorWrapper] Connected AG-UI adapter to transport for ${executionId}`);
+        }
+        try {
+            // 3. Emit run started event
+            agUiAdapter.emitRunStarted({
+                model: task.config?.model || this.adapter.metadata.name,
+                timestamp: new Date().toISOString(),
+            });
+            // 4. Update execution status to running
+            updateExecution(this.db, executionId, { status: "running" });
+            const execution = getExecution(this.db, executionId);
+            if (execution) {
+                broadcastExecutionUpdate(this.projectId, executionId, "status_changed", execution, execution.issue_id || undefined);
+            }
+            // 5. Execute task with agent executor
+            // Check if task has MCP servers or other runtime config that requires a fresh executor
+            let executor = this.executor;
+            const taskMcpServers = task.metadata?.mcpServers;
+            const taskAppendSystemPrompt = task.metadata?.appendSystemPrompt;
+            const taskDangerouslySkipPermissions = task.metadata
+                ?.dangerouslySkipPermissions;
+            const taskResume = task.metadata?.resume;
+            // Debug: Log what we received in task metadata
+            console.log(`[AgentExecutorWrapper] Task metadata for ${executionId}:`, {
+                agentType: this.agentType,
+                hasMcpServers: !!taskMcpServers,
+                mcpServerNames: taskMcpServers
+                    ? Object.keys(taskMcpServers)
+                    : "none",
+                hasAppendSystemPrompt: !!taskAppendSystemPrompt,
+                dangerouslySkipPermissions: taskDangerouslySkipPermissions,
+                resume: taskResume,
+            });
+            if (this.agentType === "claude-code" &&
+                (taskMcpServers ||
+                    taskAppendSystemPrompt ||
+                    taskDangerouslySkipPermissions !== undefined || // false is a valid override
+                    taskResume)) {
+                // Create a task-specific executor with merged config
+                console.log(`[AgentExecutorWrapper] Creating task-specific executor for ${executionId}`, {
+                    mcpServers: taskMcpServers ? Object.keys(taskMcpServers) : "none",
+                    dangerouslySkipPermissions: taskDangerouslySkipPermissions,
+                    resume: taskResume,
+                });
+                const taskSpecificConfig = mergeAgentConfig(this._agentConfig, {
+                    mcpServers: taskMcpServers,
+                    appendSystemPrompt: taskAppendSystemPrompt,
+                    dangerouslySkipPermissions: taskDangerouslySkipPermissions,
+                    resume: taskResume,
+                });
+                executor = this.createExecutor(this.agentType, taskSpecificConfig);
+            }
+            console.log(`[AgentExecutorWrapper] Spawning ${this.adapter.metadata.name} process for ${executionId}`, {
+                taskId: task.id,
+                workDir,
+                promptLength: task.prompt.length,
+            });
+            const spawned = await executor.executeTask(task);
+            console.log(`[AgentExecutorWrapper] ${this.adapter.metadata.name} process spawned for ${executionId}`, {
+                pid: spawned.process.process?.pid,
+                spawnfile: spawned.process.process?.spawnfile,
+            });
+            // 6. Store cancellation handle
+            this.activeExecutions.set(executionId, {
+                cancel: () => {
+                    if (spawned.process.process) {
+                        spawned.process.process.kill("SIGTERM");
+                    }
+                },
+            });
+            // 7. Initialize completion state for Claude Code
+            if (this.agentType === "claude-code") {
+                this.completionState.set(executionId, {
+                    completed: false,
+                    exitCode: 0,
+                });
+            }
+            // 8. Create output stream from process stdout/stderr
+            const outputStream = this.createOutputChunks(spawned.process, executionId);
+            const normalized = this.executor.normalizeOutput(outputStream, workDir);
+            // 9. Process normalized output (runs concurrently with process)
+            const processOutputPromise = this.processNormalizedOutput(executionId, normalized, normalizedAdapter);
+            // 10. Capture stderr for debugging
+            const childProcess = spawned.process.process;
+            if (childProcess && childProcess.stderr) {
+                let stderrOutput = "";
+                childProcess.stderr.on("data", (data) => {
+                    const chunk = data.toString();
+                    stderrOutput += chunk;
+                    console.error(`[AgentExecutorWrapper] ${this.adapter.metadata.name} stderr for ${executionId}:`, chunk);
+                });
+            }
+            // 11. Wait for output processing to complete
+            await processOutputPromise;
+            console.log(`[AgentExecutorWrapper] Output processing completed for ${executionId}`);
+            // 12. Close stdin to signal the process to exit (for Claude Code with peer)
+            if (this.agentType === "claude-code" &&
+                childProcess &&
+                childProcess.stdin) {
+                try {
+                    childProcess.stdin.end();
+                    console.log(`[AgentExecutorWrapper] Closed stdin for Claude Code process ${executionId}`);
+                }
+                catch (error) {
+                    console.error(`[AgentExecutorWrapper] Error closing stdin for ${executionId}:`, error);
+                }
+            }
+            // 13. Wait for process to exit (with timeout for Claude Code)
+            const exitCode = await Promise.race([
+                new Promise((resolve) => {
+                    if (!childProcess) {
+                        // Use completion state for Claude Code if available
+                        if (this.agentType === "claude-code") {
+                            const state = this.completionState.get(executionId);
+                            resolve(state?.exitCode ?? 0);
+                        }
+                        else {
+                            resolve(0);
+                        }
+                        return;
+                    }
+                    childProcess.on("exit", (code) => {
+                        console.log(`[AgentExecutorWrapper] Process exited with code ${code} for ${executionId}`);
+                        // For Claude Code, use completion state exit code if available (more reliable)
+                        if (this.agentType === "claude-code") {
+                            const state = this.completionState.get(executionId);
+                            if (state?.completed) {
+                                console.log(`[AgentExecutorWrapper] Using completion state exit code ${state.exitCode} for ${executionId}`);
+                                resolve(state.exitCode);
+                                return;
+                            }
+                        }
+                        resolve(code ?? 0);
+                    });
+                    childProcess.on("error", (error) => {
+                        console.error(`[AgentExecutorWrapper] Process error for ${executionId}:`, error);
+                        resolve(1);
+                    });
+                }),
+                // Timeout for Claude Code processes that may not exit cleanly
+                this.agentType === "claude-code"
+                    ? new Promise((resolve) => {
+                        setTimeout(() => {
+                            console.log(`[AgentExecutorWrapper] Process exit timeout for ${executionId}, using completion state`);
+                            if (childProcess && !childProcess.killed) {
+                                childProcess.kill("SIGTERM");
+                            }
+                            // Use completion state exit code
+                            const state = this.completionState.get(executionId);
+                            resolve(state?.exitCode ?? 0);
+                        }, 5000);
+                    })
+                    : new Promise(() => { }), // Never resolves for non-Claude agents
+            ]);
+            // 14. Handle completion
+            if (exitCode === 0) {
+                await this.handleSuccess(executionId);
+                agUiAdapter.emitRunFinished({ exitCode });
+            }
+            else {
+                throw new Error(`Process exited with code ${exitCode}`);
+            }
+        }
+        catch (error) {
+            console.error(`[AgentExecutorWrapper] Execution failed for ${executionId}:`, error);
+            await this.handleError(executionId, error);
+            agUiAdapter.emitRunError(error instanceof Error ? error.message : String(error));
+            throw error;
+        }
+        finally {
+            // Cleanup
+            this.activeExecutions.delete(executionId);
+            this.completionState.delete(executionId);
+            if (this.transportManager) {
+                this.transportManager.disconnectAdapter(agUiAdapter);
+                console.log(`[AgentExecutorWrapper] Disconnected AG-UI adapter for ${executionId}`);
+            }
+        }
+    }
+    /**
+     * Resume a task from a previous session
+     *
+     * @param executionId - Unique execution identifier
+     * @param sessionId - Session ID to resume from
+     * @param task - Task to resume
+     * @param workDir - Working directory for execution
+     */
+    async resumeWithLifecycle(executionId, sessionId, task, workDir) {
+        // Check if executor supports resume
+        const capabilities = this.executor.getCapabilities?.();
+        if (!capabilities?.supportsSessionResume || !this.executor.resumeTask) {
+            console.log(`[AgentExecutorWrapper] Resume not supported for agent '${this.adapter.metadata.name}'`);
+            throw new Error(`Resume functionality not supported for agent '${this.adapter.metadata.name}'`);
+        }
+        console.log(`[AgentExecutorWrapper] Resuming session ${sessionId} for ${executionId}`);
+        // Setup AG-UI system
+        const { agUiAdapter, normalizedAdapter } = this.setupAgUiSystem(executionId);
+        if (this.transportManager) {
+            this.transportManager.connectAdapter(agUiAdapter, executionId);
+        }
+        try {
+            agUiAdapter.emitRunStarted({
+                model: task.config?.model || this.adapter.metadata.name,
+                sessionId,
+                resumed: true,
+            });
+            // Update status and session_id (sessionId is the path used for resumption)
+            updateExecution(this.db, executionId, {
+                status: "running",
+                session_id: sessionId,
+            });
+            const execution = getExecution(this.db, executionId);
+            if (execution) {
+                broadcastExecutionUpdate(this.projectId, executionId, "status_changed", execution, execution.issue_id || undefined);
+            }
+            // Use resumeTask instead of executeTask
+            const spawned = await this.executor.resumeTask(task, sessionId);
+            this.activeExecutions.set(executionId, {
+                cancel: () => {
+                    if (spawned.process.process) {
+                        spawned.process.process.kill("SIGTERM");
+                    }
+                },
+            });
+            // Initialize completion state for Claude Code
+            if (this.agentType === "claude-code") {
+                this.completionState.set(executionId, {
+                    completed: false,
+                    exitCode: 0,
+                });
+            }
+            // Create output streams
+            const outputChunks = this.createOutputChunks(spawned.process, executionId);
+            const normalized = this.executor.normalizeOutput(outputChunks, workDir);
+            const processOutputPromise = this.processNormalizedOutput(executionId, normalized, normalizedAdapter);
+            await processOutputPromise;
+            // For Claude Code, use completion state; for others, wait for process exit
+            let exitCode = 0;
+            if (this.agentType === "claude-code") {
+                const state = this.completionState.get(executionId);
+                exitCode = state?.exitCode ?? 0;
+                console.log(`[AgentExecutorWrapper] Using completion state exit code ${exitCode} for resumed ${executionId}`);
+            }
+            else {
+                exitCode = await new Promise((resolve, reject) => {
+                    const childProcess = spawned.process.process;
+                    if (!childProcess) {
+                        reject(new Error("No child process available"));
+                        return;
+                    }
+                    childProcess.on("exit", (code) => resolve(code || 0));
+                    childProcess.on("error", (error) => reject(error));
+                });
+            }
+            if (exitCode === 0) {
+                await this.handleSuccess(executionId);
+                agUiAdapter.emitRunFinished({ exitCode });
+            }
+            else {
+                throw new Error(`Process exited with code ${exitCode}`);
+            }
+        }
+        catch (error) {
+            await this.handleError(executionId, error);
+            agUiAdapter.emitRunError(error instanceof Error ? error.message : String(error));
+            throw error;
+        }
+        finally {
+            this.activeExecutions.delete(executionId);
+            this.completionState.delete(executionId);
+            if (this.transportManager) {
+                this.transportManager.disconnectAdapter(agUiAdapter);
+            }
+        }
+    }
+    /**
+     * Cancel a running execution
+     *
+     * @param executionId - Execution ID to cancel
+     */
+    async cancel(executionId) {
+        console.log(`[AgentExecutorWrapper] Cancel execution ${executionId}`);
+        // Kill the process if active
+        const execution = this.activeExecutions.get(executionId);
+        if (execution) {
+            execution.cancel();
+            this.activeExecutions.delete(executionId);
+        }
+        else {
+            console.warn(`[AgentExecutorWrapper] No active execution found for ${executionId}`);
+        }
+        // Capture final commit before marking stopped
+        const dbExecution = getExecution(this.db, executionId);
+        const repoPath = dbExecution?.worktree_path || this.processConfig.workDir;
+        let afterCommit;
+        try {
+            afterCommit = execSync("git rev-parse HEAD", {
+                cwd: repoPath,
+                encoding: "utf-8",
+            }).trim();
+        }
+        catch (error) {
+            console.warn(`[AgentExecutorWrapper] Failed to capture after_commit for cancelled execution ${executionId}:`, error instanceof Error ? error.message : String(error));
+            // Continue - this is supplementary data
+        }
+        // Update database status
+        updateExecution(this.db, executionId, {
+            after_commit: afterCommit,
+            status: "stopped",
+            completed_at: new Date().toISOString(),
+        });
+        const updatedExecution = getExecution(this.db, executionId);
+        if (updatedExecution) {
+            broadcastExecutionUpdate(this.projectId, executionId, "status_changed", updatedExecution, updatedExecution.issue_id || undefined);
+        }
+    }
+    /**
+     * Setup AG-UI system for execution
+     *
+     * @private
+     */
+    setupAgUiSystem(executionId) {
+        const agUiAdapter = new AgUiEventAdapter(executionId);
+        const normalizedAdapter = new NormalizedEntryToAgUiAdapter(agUiAdapter);
+        console.log(`[AgentExecutorWrapper] Setup AG-UI system for ${executionId}`);
+        return { agUiAdapter, normalizedAdapter };
+    }
+    /**
+     * Process normalized output from agent
+     *
+     * For Claude Code: Also captures session ID from metadata for session resumption
+     *
+     * @private
+     */
+    async processNormalizedOutput(executionId, normalized, normalizedAdapter) {
+        console.log(`[AgentExecutorWrapper] Processing normalized output for ${executionId}`);
+        let entryCount = 0;
+        let sessionIdCaptured = false;
+        for await (const entry of normalized) {
+            entryCount++;
+            // Log first 10 entries and every 100th entry for debugging
+            if (entryCount <= 10 || entryCount % 100 === 0) {
+                console.log(`[AgentExecutorWrapper] Entry ${entryCount} for ${executionId}:`, {
+                    index: entry.index,
+                    kind: entry.type.kind,
+                    timestamp: entry.timestamp,
+                    hasMetadata: !!entry.metadata,
+                    sessionId: entry.metadata?.sessionId,
+                });
+            }
+            try {
+                // Capture session ID from metadata for Claude Code (populated by normalizer from SystemMessage)
+                if (this.agentType === "claude-code" &&
+                    !sessionIdCaptured &&
+                    entry.metadata?.sessionId) {
+                    const sessionId = entry.metadata.sessionId;
+                    updateExecution(this.db, executionId, { session_id: sessionId });
+                    console.log(`[AgentExecutorWrapper] Captured session ID from metadata: ${sessionId} for ${executionId}`);
+                    sessionIdCaptured = true;
+                }
+                // 1. Store normalized entry for historical replay
+                this.logsStore.appendNormalizedEntry(executionId, entry);
+                // 2. Convert to AG-UI and broadcast for real-time streaming
+                await normalizedAdapter.processEntry(entry);
+            }
+            catch (error) {
+                console.error(`[AgentExecutorWrapper] Error processing entry for ${executionId}:`, {
+                    entryIndex: entry.index,
+                    entryType: entry.type.kind,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                // Continue processing (don't fail entire execution for one entry)
+            }
+        }
+        console.log(`[AgentExecutorWrapper] Finished processing ${entryCount} entries for ${executionId}`);
+    }
+    /**
+     * Handle successful execution
+     *
+     * @private
+     */
+    async handleSuccess(executionId) {
+        console.log(`[AgentExecutorWrapper] Execution ${executionId} completed successfully`);
+        // Capture final commit before marking complete
+        const execution = getExecution(this.db, executionId);
+        const repoPath = execution?.worktree_path || this.processConfig.workDir;
+        let afterCommit;
+        try {
+            afterCommit = execSync("git rev-parse HEAD", {
+                cwd: repoPath,
+                encoding: "utf-8",
+            }).trim();
+        }
+        catch (error) {
+            console.warn(`[AgentExecutorWrapper] Failed to capture after_commit for execution ${executionId}:`, error instanceof Error ? error.message : String(error));
+            // Continue - this is supplementary data
+        }
+        // Calculate file changes using ExecutionChangesService
+        let filesChangedJson = null;
+        try {
+            // Import and instantiate ExecutionChangesService
+            const changesService = new ExecutionChangesService(this.db, this.processConfig.workDir);
+            // Get changes for this execution
+            const changesResult = await changesService.getChanges(executionId);
+            if (changesResult.available && changesResult.captured) {
+                // Extract just the file paths from the changes
+                const filePaths = changesResult.captured.files.map((f) => f.path);
+                filesChangedJson = JSON.stringify(filePaths);
+                console.log(`[AgentExecutorWrapper] Captured ${filePaths.length} file changes for execution ${executionId}`);
+            }
+            else {
+                console.log(`[AgentExecutorWrapper] No file changes detected for execution ${executionId}:`, changesResult.reason);
+            }
+        }
+        catch (error) {
+            console.warn(`[AgentExecutorWrapper] Failed to calculate files_changed for execution ${executionId}:`, error instanceof Error ? error.message : String(error));
+            // Continue - this is supplementary data
+        }
+        updateExecution(this.db, executionId, {
+            after_commit: afterCommit,
+            files_changed: filesChangedJson,
+            status: "completed",
+            completed_at: new Date().toISOString(),
+            exit_code: 0,
+        });
+        const updatedExecution = getExecution(this.db, executionId);
+        if (updatedExecution) {
+            broadcastExecutionUpdate(this.projectId, executionId, "status_changed", updatedExecution, updatedExecution.issue_id || undefined);
+            // Notify callbacks for workflow integration
+            await notifyExecutionEvent("completed", {
+                executionId,
+                workflowId: updatedExecution.workflow_execution_id ?? undefined,
+                issueId: updatedExecution.issue_id ?? undefined,
+            });
+        }
+    }
+    /**
+     * Handle execution error
+     *
+     * @private
+     */
+    async handleError(executionId, error) {
+        console.error(`[AgentExecutorWrapper] Execution ${executionId} failed:`, error);
+        // Calculate file changes even for failed executions
+        // (user may want to commit partial work)
+        let filesChangedJson = null;
+        try {
+            const changesService = new ExecutionChangesService(this.db, this.processConfig.workDir);
+            const changesResult = await changesService.getChanges(executionId);
+            if (changesResult.available && changesResult.captured) {
+                const filePaths = changesResult.captured.files.map((f) => f.path);
+                filesChangedJson = JSON.stringify(filePaths);
+                console.log(`[AgentExecutorWrapper] Captured ${filePaths.length} file changes for failed execution ${executionId}`);
+            }
+        }
+        catch (calcError) {
+            console.warn(`[AgentExecutorWrapper] Failed to calculate files_changed for failed execution ${executionId}:`, calcError instanceof Error ? calcError.message : String(calcError));
+        }
+        updateExecution(this.db, executionId, {
+            status: "failed",
+            completed_at: new Date().toISOString(),
+            error_message: error.message,
+            files_changed: filesChangedJson,
+        });
+        const execution = getExecution(this.db, executionId);
+        if (execution) {
+            broadcastExecutionUpdate(this.projectId, executionId, "status_changed", execution, execution.issue_id || undefined);
+            // Notify callbacks for workflow integration
+            await notifyExecutionEvent("failed", {
+                executionId,
+                workflowId: execution.workflow_execution_id ?? undefined,
+                issueId: execution.issue_id ?? undefined,
+                error: error.message,
+            });
+        }
+    }
+    /**
+     * Create output chunk stream from ManagedProcess
+     *
+     * For Claude Code: Uses protocol peer to receive messages
+     * For other agents: Reads directly from stdout/stderr streams
+     *
+     * @private
+     */
+    async *createOutputChunks(process, executionId) {
+        // Check if this is a Claude Code process with a protocol peer
+        const peer = process.peer;
+        if (this.agentType === "claude-code") {
+            // Claude Code REQUIRES a protocol peer
+            if (!peer) {
+                throw new Error("No peer attached to Claude Code process - cannot read output");
+            }
+            // Claude Code: Use protocol peer messages
+            console.log("[AgentExecutorWrapper] Using protocol peer for Claude Code output");
+            yield* this.peerMessagesToOutputChunks(peer, executionId);
+            return;
+        }
+        // Other agents: Use stdout/stderr streams
+        if (!process.streams) {
+            throw new Error("Process does not have streams available");
+        }
+        const { stdout, stderr } = process.streams;
+        // Merge stdout and stderr
+        const streams = [];
+        if (stdout) {
+            streams.push(this.streamToChunks(stdout, "stdout"));
+        }
+        if (stderr) {
+            streams.push(this.streamToChunks(stderr, "stderr"));
+        }
+        // Yield chunks from all streams
+        for (const stream of streams) {
+            for await (const chunk of stream) {
+                yield chunk;
+            }
+        }
+    }
+    /**
+     * Convert protocol peer messages to output chunks
+     *
+     * Used for Claude Code which uses a protocol peer that consumes stdout
+     * Updates completion state when result message is received
+     *
+     * @private
+     */
+    async *peerMessagesToOutputChunks(peer, executionId) {
+        const messageQueue = [];
+        let streamEnded = false;
+        let exitDetected = false;
+        // Register message handler
+        peer.onMessage((message) => {
+            messageQueue.push(message);
+            // Detect completion and update completion state
+            if (message.type === "result" &&
+                (message.subtype === "success" || message.subtype === "failure")) {
+                exitDetected = true;
+                const exitCode = message.subtype === "success" ? 0 : 1;
+                this.completionState.set(executionId, { completed: true, exitCode });
+                console.log(`[AgentExecutorWrapper] Detected completion from peer for ${executionId}:`, { subtype: message.subtype, exitCode });
+            }
+        });
+        // Process messages until completion
+        while (!streamEnded || messageQueue.length > 0) {
+            if (messageQueue.length === 0) {
+                if (exitDetected) {
+                    streamEnded = true;
+                    break;
+                }
+                // Wait for more messages
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                continue;
+            }
+            // Convert message to stream-json line format
+            const message = messageQueue.shift();
+            const line = JSON.stringify(message) + "\n";
+            yield {
+                type: "stdout",
+                data: Buffer.from(line, "utf-8"),
+                timestamp: new Date(),
+            };
+        }
+    }
+    /**
+     * Convert a readable stream to output chunks
+     *
+     * @private
+     */
+    async *streamToChunks(stream, type) {
+        for await (const chunk of stream) {
+            yield {
+                type,
+                data: Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk),
+                timestamp: new Date(),
+            };
+        }
+    }
+}
+//# sourceMappingURL=agent-executor-wrapper.js.map