vibeman 0.0.0 → 0.0.2

package/dist/runtime/api/agent/agent-service.js

@@ -0,0 +1,895 @@
+import { EventEmitter } from 'events';
+import { WorktreeService } from '../vcs/worktree-service.js';
+import { ExecutionLogPersistence } from '../persistence/execution-log-persistence.js';
+import { log } from '../lib/logger.js';
+import { generateId } from '../lib/id-generator.js';
+import { getProjectRoot } from '../lib/server/project-root.js';
+import { CoreAgentService } from './core-agent-service.js';
+import { ClaudeCodeAdapter, CodexCliProvider } from './ai-providers/index.js';
+import { PromptService } from './prompt-service.js';
+import { RoutingPolicyManager, } from './routing-policy.js';
+import { isTestEnv } from '../utils/env.js';
+import { parseImprovementResult, parseReviewResult } from './parsers.js';
+import { getSettingsService } from '../settings-service.js';
+const fullTools = [
+    'Bash',
+    'Edit',
+    'Glob',
+    'Grep',
+    'MultiEdit',
+    'NotebookEdit',
+    'NotebookRead',
+    'Read',
+    'Task',
+    'TodoWrite',
+    'WebSearch',
+    'WebFetch',
+    'Write',
+];
+export class AgentService extends EventEmitter {
+    constructor(taskService, projectRoot = getProjectRoot(), worktreeService) {
+        super();
+        this.taskService = taskService;
+        this.projectRoot = projectRoot;
+        // Keep only minimal execution context locally; defer status/messages to CoreAgentService
+        this.executionRegistry = new Map();
+        this.initialized = false;
+        // Track lightweight status for generic (non-core) executions
+        this.genericStates = new Map();
+        // Centralized default tool sets per operation
+        // TODO: need to be more granular, based on the task type and the toolset available for the AI provider
+        this.defaultTools = {
+            execute_task: fullTools,
+            improve_task: fullTools,
+            code_review: fullTools,
+            ai_merge: fullTools,
+        };
+        // Centralized system prompts for all AI operations
+        this.systemPrompts = {
+            execute_task: {
+                base: 'You are an expert software engineer. Follow best practices, write clean maintainable code, and ensure your implementation is robust and well-tested.',
+                rerun: 'You are continuing a rerun of this task. Use prior context and focus on fixes.',
+            },
+            improve_task: 'You are an expert at improving task specifications. Respond with ONLY a valid JSON object containing type, priority, and content fields. No additional text or formatting.',
+            ai_codereview: 'You are a senior developer performing thorough code review. Focus on quality, security, and best practices. Respond with ONLY a valid JSON object. Ultrathink.',
+            ai_merge: 'You are an expert at resolving merge conflicts and integrating code changes. Ensure clean merges that maintain code consistency and functionality.',
+        };
+        this.worktreeService = worktreeService || new WorktreeService(projectRoot);
+        this.logPersistence = new ExecutionLogPersistence();
+        this.initialize();
+        // Log streaming updates for verification in dev environments
+        if (!isTestEnv()) {
+            this.on('executionUpdated', (update) => {
+                const exec = this.getExecutionStatus(update.executionId);
+                const last = exec?.logs?.[exec.logs.length - 1];
+                if (last) {
+                    log.info('Execution update', { executionId: update.executionId, message: last }, 'agent-service');
+                }
+            });
+        }
+        // Initialize worktree manager
+        this.initializeWorktrees();
+    }
+    // ============ Generic (non-AI) execution helpers for local tasks (e.g., validation) ============
+    /**
+     * Start a generic execution that is not backed by an AI provider.
+     * This enables persistent logs and status queries via existing APIs.
+     */
+    async startGenericExecution(taskId, options) {
+        const executionId = generateId('exec');
+        const startTime = new Date().toISOString();
+        const workingDirectory = options?.workingDirectory || this.projectRoot;
+        // Register minimal context so status queries work
+        this.executionRegistry.set(executionId, { taskId, workingDirectory, startTime });
+        const initial = {
+            id: executionId,
+            taskId,
+            status: 'pending',
+            startTime,
+            logs: [],
+            workingDirectory,
+        };
+        await this.logPersistence.startExecution(initial, options?.workflowId);
+        this.genericStates.set(executionId, { status: 'running' });
+        // Emit an update to notify subscribers
+        this.emit('executionUpdated', { executionId, status: 'running', logs: [] });
+        return executionId;
+    }
+    /** Append a log line to a generic execution and notify listeners (best-effort). */
+    async logGenericExecution(executionId, message, level = 'info', data) {
+        await this.logPersistence.logMessage(executionId, message, level, data);
+        try {
+            const logs = (await this.logPersistence.readExecutionLogs(executionId)).logs.map((e) => e.message);
+            this.emit('executionUpdated', { executionId, status: 'running', logs });
+        }
+        catch {
+            // ignore
+        }
+    }
+    /** Mark a generic execution as completed/failed/cancelled and notify listeners. */
+    async completeGenericExecution(executionId, status, error) {
+        await this.logPersistence.completeExecution(executionId, status, error);
+        this.genericStates.set(executionId, { status, endTime: new Date().toISOString(), error });
+        try {
+            const logs = (await this.logPersistence.readExecutionLogs(executionId)).logs.map((e) => e.message);
+            this.emit('executionUpdated', { executionId, status, logs, error });
+        }
+        catch {
+            this.emit('executionUpdated', { executionId, status, logs: [], error });
+        }
+    }
+    getAgentConfig() {
+        try {
+            const settings = getSettingsService().getSettings();
+            return {
+                executionTimeout: 30 * 60 * 1000, // 30 minutes fixed
+                defaultProvider: settings.agents.defaultProvider || 'claude-code',
+            };
+        }
+        catch {
+            return { executionTimeout: 30 * 60 * 1000, defaultProvider: 'claude-code' };
+        }
+    }
+    initialize() {
+        if (this.initialized)
+            return;
+        // Initialize core agent service with settings
+        const agentConfig = this.getAgentConfig();
+        this.coreAgentService = new CoreAgentService({
+            defaultProvider: agentConfig.defaultProvider,
+            executionTimeout: agentConfig.executionTimeout,
+        });
+        // Register Claude Code adapter
+        const claudeAdapter = new ClaudeCodeAdapter({
+            defaultWorkingDirectory: this.projectRoot,
+            defaultModel: 'claude-sonnet-4-20250514',
+        });
+        this.coreAgentService.registerProvider('claude-code', claudeAdapter);
+        // Register Codex CLI provider (not default)
+        const codexProvider = new CodexCliProvider({
+            defaultWorkingDirectory: this.projectRoot,
+        });
+        this.coreAgentService.registerProvider('codex', codexProvider);
+        // Initialize prompt service
+        this.promptService = new PromptService(this.projectRoot, this.taskService);
+        // Initialize routing policy manager
+        this.routingPolicyManager = new RoutingPolicyManager();
+        // Create example policy file if needed (guarded for mocked environments)
+        try {
+            const maybePromise = this.routingPolicyManager.createExamplePolicy?.();
+            if (maybePromise && typeof maybePromise.catch === 'function') {
+                maybePromise.catch((err) => log.warn('Failed to create example policy', err, 'agent-service'));
+            }
+        }
+        catch (err) {
+            log.warn('Failed to trigger example policy creation', err, 'agent-service');
+        }
+        // Set up event forwarding
+        this.setupEventForwarding();
+        this.initialized = true;
+    }
+    setupEventForwarding() {
+        // Persist every message and enrich realtime UI for non-assistant types
+        this.coreAgentService.on('executionMessage', (data) => {
+            const state = this.coreAgentService.getExecutionStatus(data.executionId);
+            const status = state?.status || 'running';
+            const summary = this.summarizeMessage(data.message);
+            void this.logPersistence.logMessage(data.executionId, summary, data.message.type === 'error' ? 'error' : 'info', { raw: data.message });
+            const logs = this.coreAgentService
+                .getExecutionMessages(data.executionId)
+                .map((m) => this.summarizeMessage(m));
+            this.emit('executionUpdated', {
+                executionId: data.executionId,
+                status,
+                logs,
+            });
+        });
+        this.coreAgentService.on('executionCompleted', (data) => {
+            void this.logPersistence.completeExecution(data.executionId, 'completed');
+            const logs = this.coreAgentService
+                .getExecutionMessages(data.executionId)
+                .map((m) => this.summarizeMessage(m));
+            this.emit('executionUpdated', {
+                executionId: data.executionId,
+                status: 'completed',
+                logs,
+            });
+        });
+        this.coreAgentService.on('executionFailed', (data) => {
+            void this.logPersistence.completeExecution(data.executionId, 'failed', data.error);
+            const logs = this.coreAgentService
+                .getExecutionMessages(data.executionId)
+                .map((m) => this.summarizeMessage(m));
+            this.emit('executionUpdated', {
+                executionId: data.executionId,
+                status: 'failed',
+                logs,
+                error: data.error,
+            });
+        });
+        this.coreAgentService.on('executionCancelled', (data) => {
+            void this.logPersistence.completeExecution(data.executionId, 'cancelled');
+            const logs = this.coreAgentService
+                .getExecutionMessages(data.executionId)
+                .map((m) => this.summarizeMessage(m));
+            this.emit('executionUpdated', {
+                executionId: data.executionId,
+                status: 'cancelled',
+                logs,
+            });
+        });
+    }
+    /**
+     * Map core agent update to legacy format
+     * TODO: remove this later in a separate task, need to migrate the UI to handle raw message streaming
+     */
+    mapToLegacyUpdate(data) {
+        const messages = this.coreAgentService
+            .getExecutionMessages(data.executionId)
+            .map((m) => this.summarizeMessage(m));
+        return {
+            executionId: data.executionId,
+            status: data.status ||
+                this.coreAgentService.getExecutionStatus(data.executionId)?.status ||
+                'running',
+            logs: messages,
+            error: data.error,
+        };
+    }
+    /**
+     * Create a concise, human-readable line from a structured execution message
+     */
+    summarizeMessage(msg) {
+        const ts = new Date(msg.timestamp || Date.now()).toLocaleTimeString();
+        switch (msg.type) {
+            case 'init':
+                return `[${ts}] Init: session started`;
+            case 'assistant':
+                return typeof msg.content === 'string' ? msg.content : '[assistant message]';
+            case 'tool_use': {
+                const tool = msg.tool || 'tool';
+                const input = msg.input ? JSON.stringify(msg.input) : '';
+                return `[${ts}] TOOL ${tool} ${input}`;
+            }
+            case 'result': {
+                const success = msg.success;
+                return `[${ts}] Result: ${success ? 'success' : 'error'}`;
+            }
+            case 'system':
+                return `[${ts}] SYSTEM: ${typeof msg.content === 'string' ? msg.content : ''}`;
+            case 'error':
+                return `[${ts}] ERROR: ${String(msg.content || '')}`;
+            default:
+                // Ensure template-literal receives a string; avoid `never` type in lint
+                return `[${ts}] ${String(msg.type)}`;
+        }
+    }
+    /**
+     * Initialize worktree manager
+     */
+    async initializeWorktrees() {
+        try {
+            await this.worktreeService.initialize();
+        }
+        catch (error) {
+            log.warn('Failed to initialize WorktreeService', error, 'agent-service');
+        }
+    }
+    /**
+     * Execute a task using AI in an isolated worktree
+     */
+    async executeTask(taskId, workflowId, options) {
+        const task = this.taskService.getTask(taskId);
+        if (!task) {
+            throw new Error(`Task ${taskId} not found`);
+        }
+        const executionId = generateId('exec');
+        // Pre-register minimal context for this execution
+        const initialStart = new Date().toISOString();
+        this.executionRegistry.set(executionId, {
+            taskId,
+            workingDirectory: this.projectRoot,
+            startTime: initialStart,
+        });
+        // Start persistent logging with workflow context
+        const initialExecution = {
+            id: executionId,
+            taskId,
+            status: 'pending',
+            startTime: initialStart,
+            logs: [],
+            workingDirectory: this.projectRoot,
+        };
+        await this.logPersistence.startExecution(initialExecution, workflowId);
+        // Update task status to in-progress
+        await this.taskService.updateTask(taskId, { status: 'in-progress' });
+        // Fire-and-forget creation event if needed by listeners
+        // Include workflowId so orchestrators can associate execution to workflows
+        this.emit('executionCreated', { executionId, taskId, workflowId });
+        // Create worktree for isolated execution
+        let worktree;
+        let workingDirectory = this.projectRoot;
+        try {
+            worktree = await this.worktreeService.createWorktree(task);
+            if (worktree?.path) {
+                workingDirectory = worktree.path;
+                log.info('Task executing in worktree', { taskId, workingDirectory }, 'agent-service');
+                // Update registry with actual working directory
+                this.executionRegistry.set(executionId, {
+                    taskId,
+                    workingDirectory,
+                    startTime: initialStart,
+                });
+            }
+        }
+        catch (error) {
+            log.error('Failed to create worktree, using main directory', error, 'agent-service');
+        }
+        // Generate task prompt with workflow configuration for dynamic instructions
+        const prompt = await this.promptService.generateTaskPrompt(task, options?.workflowConfig);
+        // Build system prompt - use rerun context if available, otherwise base prompt
+        let appendSystemPrompt;
+        if (options?.rerunContext) {
+            appendSystemPrompt = await this.buildRerunSystemPrompt(task, options.rerunContext, workingDirectory);
+        }
+        else {
+            appendSystemPrompt = this.systemPrompts.execute_task.base;
+        }
+        // Persist prompt for auditing
+        void this.logPersistence.logMessage(executionId, 'Prompt prepared', 'info', {
+            prompt,
+            appendSystemPrompt, // include system/rerun append
+            options: { workingDirectory, tools: this.defaultTools.execute_task },
+            taskId: task.id,
+            workflowId,
+            rerunContext: options?.rerunContext,
+        });
+        await this.executeWithRouting('execute_task', prompt, {
+            workingDirectory,
+            tools: this.defaultTools.execute_task,
+            timeout: 30 * 60 * 1000,
+            appendSystemPrompt,
+            dangerouslyBypassApprovalsAndSandbox: true,
+            executionId,
+            metadata: {
+                operation: 'execute_task',
+                taskId,
+                workflowId,
+                worktree,
+                rerun: !!options?.rerunContext,
+                previousExecutionId: options?.rerunContext?.previousExecutionId,
+            },
+        }, options?.providerOverride);
+        return executionId;
+    }
+    /**
+     * Build an appended system prompt with rerun context (reason, logs, failed checks)
+     */
+    async buildRerunSystemPrompt(task, rerun, workingDirectory) {
+        const parts = [];
+        // Start with base system prompt, then add rerun context
+        parts.push(this.systemPrompts.execute_task.base);
+        parts.push('\n\n' + this.systemPrompts.execute_task.rerun);
+        parts.push(`Rerun reason: ${rerun.reason}`);
+        if (rerun.attempt)
+            parts.push(`Attempt: ${String(rerun.attempt)}`);
+        if (rerun.failurePhase)
+            parts.push(`Previous failure phase: ${rerun.failurePhase}`);
+        parts.push(`Working directory: ${workingDirectory}`);
+        // Try to get persisted logs tail if not provided and we have an execution id
+        let logs = rerun.lastLogs || [];
+        if ((!logs || logs.length === 0) && rerun.previousExecutionId) {
+            try {
+                const persisted = await this.getPersistedExecutionLogs(rerun.previousExecutionId);
+                const tail = persisted.logs.slice(-30).map((e) => e.message || JSON.stringify(e));
+                logs = tail;
+            }
+            catch {
+                const mem = this.getExecutionLogs(rerun.previousExecutionId);
+                logs = mem.slice(-30);
+            }
+        }
+        if (logs && logs.length) {
+            parts.push('Recent logs (tail):');
+            parts.push(logs.join('\n'));
+        }
+        const q = rerun.qualityResults;
+        if (q) {
+            const failed = Object.entries(q.details || {}).filter(([, ok]) => !ok);
+            if (failed.length) {
+                parts.push('Quality checks failed previously:');
+                for (const [name] of failed) {
+                    const output = q.outputs?.[name];
+                    parts.push(`- ${name}: ${output ? String(output).slice(0, 2000) : 'failed'}`);
+                }
+            }
+        }
+        parts.push('Instruction: Address the reasons above. Avoid repeating prior mistakes. Keep changes scoped and test thoroughly. ');
+        return parts.join('\n');
+    }
+    /**
+     * Stop a running execution and cleanup worktree
+     */
+    async stopExecution(executionId) {
+        const registry = this.executionRegistry.get(executionId);
+        if (!registry) {
+            throw new Error(`Execution ${executionId} not found`);
+        }
+        try {
+            await this.coreAgentService.stopExecution(executionId);
+        }
+        catch (error) {
+            log.warn('Failed to stop execution', error, 'agent-service');
+        }
+        const logs = this.coreAgentService
+            .getExecutionMessages(executionId)
+            .map((m) => this.summarizeMessage(m));
+        this.emit('executionUpdated', {
+            executionId,
+            status: 'cancelled',
+            logs,
+        });
+    }
+    /**
+     * Get execution status
+     */
+    getExecutionStatus(executionId) {
+        const registry = this.executionRegistry.get(executionId);
+        const state = this.coreAgentService.getExecutionStatus(executionId);
+        if (registry && state) {
+            const logs = this.coreAgentService
+                .getExecutionMessages(executionId)
+                .map((m) => this.summarizeMessage(m));
+            return {
+                id: executionId,
+                taskId: registry.taskId,
+                status: state.status,
+                startTime: registry.startTime || state.startTime,
+                endTime: state.endTime,
+                logs,
+                error: state.error,
+                provider: state.provider,
+                usage: state.usage,
+                workingDirectory: registry.workingDirectory,
+            };
+        }
+        // Fallback for generic/local executions (non-core) using in-memory state
+        if (registry && this.genericStates.has(executionId)) {
+            const gs = this.genericStates.get(executionId);
+            return {
+                id: executionId,
+                taskId: registry.taskId,
+                status: gs.status,
+                startTime: registry.startTime,
+                endTime: gs.endTime,
+                logs: [],
+                error: gs.error,
+                provider: 'local',
+                workingDirectory: registry.workingDirectory,
+            };
+        }
+        return null;
+    }
+    /**
+     * Get execution logs
+     */
+    getExecutionLogs(executionId) {
+        return this.coreAgentService
+            .getExecutionMessages(executionId)
+            .map((m) => this.summarizeMessage(m));
+    }
+    /**
+     * Get all executions for a task
+     */
+    getTaskExecutions(taskId) {
+        const results = [];
+        for (const [id, meta] of this.executionRegistry.entries()) {
+            if (meta.taskId !== taskId)
+                continue;
+            const state = this.coreAgentService.getExecutionStatus(id);
+            if (!state)
+                continue;
+            results.push({
+                id,
+                taskId: meta.taskId,
+                status: state.status,
+                startTime: meta.startTime || state.startTime,
+                endTime: state.endTime,
+                logs: [],
+                error: state.error,
+                workingDirectory: meta.workingDirectory,
+            });
+        }
+        return results.sort((a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime());
+    }
+    /**
+     * Improve task content using AI
+     */
+    async improveTaskContent(task, taskData, executionId) {
+        const finalExecutionId = executionId || generateId('improve');
+        try {
+            // Pre-register execution to enable streaming logs and persistence
+            if (!this.executionRegistry.has(finalExecutionId)) {
+                const startTime = new Date().toISOString();
+                this.executionRegistry.set(finalExecutionId, {
+                    taskId: task.id,
+                    workingDirectory: this.projectRoot,
+                    startTime,
+                });
+                const execRec = {
+                    id: finalExecutionId,
+                    taskId: task.id,
+                    status: 'pending',
+                    startTime,
+                    logs: [],
+                    workingDirectory: this.projectRoot,
+                };
+                await this.logPersistence.startExecution(execRec);
+            }
+            // Generate improvement prompt
+            const prompt = await this.promptService.generateImprovementPrompt(task, taskData);
+            void this.logPersistence.logMessage(finalExecutionId, 'Improvement prompt prepared', 'info', {
+                prompt,
+                options: { workingDirectory: this.projectRoot, tools: this.defaultTools.improve_task },
+                taskId: task.id,
+            });
+            // Execute improvement with AI
+            const result = await this.executeWithRouting('improve_task', prompt, {
+                workingDirectory: this.projectRoot,
+                appendSystemPrompt: this.systemPrompts.improve_task,
+                tools: this.defaultTools.improve_task,
+                timeout: 5 * 60 * 1000,
+                dangerouslyBypassApprovalsAndSandbox: false,
+                executionId: finalExecutionId,
+                metadata: {
+                    operation: 'improve_task',
+                    taskId: task.id,
+                },
+            });
+            // Parse the result
+            const improvement = this.parseImprovementResult(result, taskData);
+            const payload = { ...improvement, executionId: finalExecutionId };
+            // Ensure registry exists (already handled above) and mark completion in persistence
+            await this.logPersistence.completeExecution(finalExecutionId, 'completed');
+            return payload;
+        }
+        catch (error) {
+            await this.logPersistence.completeExecution(finalExecutionId, 'failed', error instanceof Error ? error.message : String(error));
+            throw new Error(`Failed to improve task content: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Perform AI code review of changes in a worktree
+     */
+    async aiReviewCode(taskId, reviewContext, options) {
+        const task = this.taskService.getTask(taskId);
+        if (!task) {
+            throw new Error(`Task ${taskId} not found`);
+        }
+        const worktree = this.worktreeService.getWorktree(taskId);
+        if (!worktree) {
+            throw new Error(`No worktree found for task ${taskId}`);
+        }
+        const executionId = options?.executionId ?? generateId('review');
+        try {
+            // Pre-register execution for streaming/persistence
+            if (!this.executionRegistry.has(executionId)) {
+                const startTime = new Date().toISOString();
+                this.executionRegistry.set(executionId, {
+                    taskId,
+                    workingDirectory: this.projectRoot,
+                    startTime,
+                });
+                const execRec = {
+                    id: executionId,
+                    taskId,
+                    status: 'pending',
+                    startTime,
+                    logs: [],
+                    workingDirectory: this.projectRoot,
+                };
+                await this.logPersistence.startExecution(execRec, options?.workflowId);
+            }
+            // Generate review prompt
+            const reviewPrompt = await this.promptService.generateReviewPrompt(task, worktree, reviewContext);
+            void this.logPersistence.logMessage(executionId, 'Review prompt prepared', 'info', {
+                prompt: reviewPrompt,
+                options: { workingDirectory: worktree.path, tools: this.defaultTools.code_review },
+                taskId,
+            });
+            // Execute review with AI
+            const result = await this.executeWithRouting('ai_codereview', reviewPrompt, {
+                workingDirectory: worktree.path,
+                appendSystemPrompt: this.systemPrompts.ai_codereview,
+                tools: this.defaultTools.code_review,
+                timeout: 10 * 60 * 1000,
+                executionId,
+                metadata: {
+                    operation: 'ai_codereview',
+                    taskId,
+                },
+            }, options?.overrides);
+            // Parse review result
+            const review = this.parseReviewResult(result);
+            const payload = { executionId, ...review };
+            // Ensure registry exists for lookups
+            if (!this.executionRegistry.has(executionId)) {
+                this.executionRegistry.set(executionId, {
+                    taskId,
+                    workingDirectory: this.projectRoot,
+                    startTime: new Date().toISOString(),
+                });
+            }
+            return payload;
+        }
+        catch (error) {
+            throw new Error(`Failed to review code: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Perform AI-assisted merge of a task's worktree into the base project
+     */
+    async aiMerge(taskId, options) {
+        const task = this.taskService.getTask(taskId);
+        if (!task) {
+            throw new Error(`Task ${taskId} not found`);
+        }
+        const worktree = this.worktreeService.getWorktree(taskId);
+        if (!worktree) {
+            throw new Error(`No worktree found for task ${taskId}`);
+        }
+        const executionId = options?.executionId ?? generateId('merge');
+        const workingDirectory = worktree.path || this.projectRoot;
+        try {
+            // Pre-register execution for streaming/persistence
+            if (!this.executionRegistry.has(executionId)) {
+                const startTime = new Date().toISOString();
+                this.executionRegistry.set(executionId, {
+                    taskId,
+                    workingDirectory,
+                    startTime,
+                });
+                const execRec = {
+                    id: executionId,
+                    taskId,
+                    status: 'pending',
+                    startTime,
+                    logs: [],
+                    workingDirectory,
+                };
+                await this.logPersistence.startExecution(execRec, options?.workflowId);
+            }
+            // Generate merge prompt
+            const mergePrompt = await this.promptService.generateAIMergePrompt(task, worktree, options?.baseBranch);
+            void this.logPersistence.logMessage(executionId, 'Merge prompt prepared', 'info', {
+                prompt: mergePrompt,
+                options: { workingDirectory, tools: this.defaultTools.ai_merge },
+                taskId,
+                baseBranch: options?.baseBranch,
+            });
+            // Execute merge with AI
+            await this.executeWithRouting('ai_merge', mergePrompt, {
+                workingDirectory,
+                appendSystemPrompt: this.systemPrompts.ai_merge,
+                tools: this.defaultTools.ai_merge,
+                timeout: 15 * 60 * 1000,
+                executionId,
+                metadata: {
+                    operation: 'ai_merge',
+                    taskId,
+                    baseBranch: options?.baseBranch,
+                },
+            }, options?.overrides);
+            return { executionId };
+        }
+        catch (error) {
+            throw new Error(`AI merge failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Get persistent execution logs
+     */
+    async getPersistedExecutionLogs(executionId) {
+        return await this.logPersistence.readExecutionLogs(executionId);
+    }
+    /**
+     * List all execution metadata from persistence
+     */
+    async listAllExecutions() {
+        return await this.logPersistence.listExecutions();
+    }
+    /**
+     * Clean up old execution logs
+     */
+    async cleanupOldExecutionLogs(maxAgeDays = 30) {
+        return await this.logPersistence.cleanupOldLogs(maxAgeDays);
+    }
+    /**
+     * Remove execution logs for a specific task
+     */
+    async removeExecutionLogsByTask(taskId) {
+        return await this.logPersistence.removeExecutionsByTask(taskId);
+    }
+    /**
+     * Get execution log statistics
+     */
+    async getExecutionLogStats() {
+        return await this.logPersistence.getStats();
+    }
+    /**
+     * Get statistics about executions
+     */
+    getExecutionStats() {
+        const states = this.coreAgentService.getAllExecutions();
+        const worktreeCounts = this.worktreeService.getWorktreeCounts();
+        return {
+            total: states.length,
+            pending: states.filter((e) => e.status === 'pending').length,
+            running: states.filter((e) => e.status === 'running').length,
+            completed: states.filter((e) => e.status === 'completed').length,
+            failed: states.filter((e) => e.status === 'failed').length,
+            cancelled: states.filter((e) => e.status === 'cancelled').length,
+            worktrees: {
+                active: worktreeCounts.active,
+                total: worktreeCounts.total,
+                enabled: true,
+            },
+        };
+    }
+    /**
+     * Get worktree service instance
+     */
+    getWorktreeService() {
+        return this.worktreeService;
+    }
+    /**
+     * Get worktree information for a task
+     */
+    getWorktreeInfo(taskId) {
+        const wt = this.worktreeService.getWorktree(taskId);
+        if (!wt)
+            return null;
+        const { git, ...rest } = wt;
+        return rest;
+    }
+    /**
+     * Get core agent service metrics
+     */
+    getCoreMetrics() {
+        const states = this.coreAgentService.getAllExecutions();
+        return {
+            totalExecutions: states.length,
+            activeExecutions: states.filter((e) => e.status === 'running').length,
+            completedExecutions: states.filter((e) => e.status === 'completed').length,
+            failedExecutions: states.filter((e) => e.status === 'failed').length,
+            cancelledExecutions: states.filter((e) => e.status === 'cancelled').length,
+        };
+    }
+    /**
+     * Get available AI providers
+     */
+    getAvailableProviders() {
+        return this.coreAgentService.getProviders();
+    }
+    /**
+     * Validate provider setup
+     */
+    async validateProviders() {
+        return await this.coreAgentService.validateProviders();
+    }
+    /**
+     * Get available models from all providers
+     */
+    async getAvailableModels() {
+        return await this.coreAgentService.getAvailableModels();
+    }
+    /**
+     * Parse improvement result from AI response
+     */
+    parseImprovementResult(result, originalData) {
+        return parseImprovementResult(result, originalData);
+    }
+    /**
+     * Parse review result from AI response
+     */
+    parseReviewResult(result) {
+        return parseReviewResult(result);
+    }
+    /**
+     * Resolve provider for specific operation with failover support
+     */
+    async resolveProviderForOperation(operation, overrides) {
+        return await this.routingPolicyManager.resolveProviderForOperation(operation, overrides);
+    }
+    /**
+     * Execute with provider resolution and failover
+     */
+    async executeWithRouting(operation, prompt, options = {}, overrides) {
+        const resolved = await this.resolveProviderForOperation(operation, overrides);
+        // Merge resolved options with base options
+        const executionOptions = {
+            ...options,
+            ...resolved.options,
+            model: resolved.model || options.model,
+            // Don't override workingDirectory or timeout from base options
+            workingDirectory: options.workingDirectory,
+            timeout: options.timeout,
+        };
+        // Default maxTokens from settings when not provided (unlimited if omitted)
+        try {
+            if (executionOptions.maxTokens === undefined) {
+                const s = getSettingsService().getSettings();
+                const def = operation === 'ai_codereview'
+                    ? s.agents?.judgeAgent?.maxTokens
+                    : s.agents?.codingAgent?.maxTokens;
+                if (typeof def === 'number') {
+                    executionOptions.maxTokens = def;
+                }
+            }
+        }
+        catch {
+            // best effort; ignore if settings unavailable
+        }
+        const providersToTry = [resolved.provider, ...(resolved.fallbacks || [])];
+        // Ensure Codex executes with write permissions when it is in the routing set.
+        // Some overrides may omit the flag, so default it on for task execution.
+        if (operation === 'execute_task' &&
+            providersToTry.includes('codex') &&
+            executionOptions.dangerouslyBypassApprovalsAndSandbox === undefined) {
+            executionOptions.dangerouslyBypassApprovalsAndSandbox = true;
+        }
+        let lastError = null;
+        for (let i = 0; i < providersToTry.length; i++) {
+            const provider = providersToTry[i];
+            const isLastProvider = i === providersToTry.length - 1;
+            try {
+                log.debug(`Attempting execution with provider: ${provider} (attempt ${i + 1}/${providersToTry.length})`, { operation, provider, isLastProvider }, 'agent-service');
+                const result = await this.coreAgentService.execute({
+                    prompt,
+                    provider,
+                    options: executionOptions,
+                    metadata: {
+                        ...options.metadata,
+                        operation,
+                        provider,
+                        model: resolved.model,
+                        providerAttempt: i + 1,
+                        totalProviderAttempts: providersToTry.length,
+                    },
+                    executionId: options.executionId,
+                });
+                // Success - log provider usage
+                log.info(`Successful execution with provider: ${provider}`, {
+                    operation,
+                    provider,
+                    model: resolved.model,
+                    attempt: i + 1,
+                    fallbackUsed: i > 0,
+                }, 'agent-service');
+                return result;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                log.warn(`Provider ${provider} failed for operation ${operation}`, {
+                    operation,
+                    provider,
+                    attempt: i + 1,
+                    error: lastError.message,
+                    willRetry: !isLastProvider,
+                }, 'agent-service');
+                // If this is not the last provider, continue to next
+                if (!isLastProvider) {
+                    continue;
+                }
+            }
+        }
+        // All providers failed
+        throw new Error(`All providers failed for operation ${operation}. Last error: ${lastError?.message}`);
+    }
+    /**
+     * Get routing policy manager (for tRPC router access)
+     */
+    getRoutingPolicyManager() {
+        return this.routingPolicyManager;
+    }
+}