vibeman 0.0.3 → 0.0.6

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

@@ -1,904 +0,0 @@
-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,
-            quality_checks: 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();
-        // 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,
-            });
-        });
-    }
-    /**
-     * 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'}`);
-                }
-            }
-        }
-        const review = rerun.aiReview;
-        if (review) {
-            parts.push('AI code review feedback from previous attempt:');
-            if (typeof review.score === 'number') {
-                parts.push(`- Quality score: ${review.score}`);
-            }
-            if (review.summary) {
-                parts.push(`- Summary: ${review.summary}`);
-            }
-            const recs = Array.isArray(review.recommendations)
-                ? review.recommendations.filter((r) => typeof r === 'string' && r.trim().length)
-                : [];
-            if (recs.length) {
-                parts.push('Recommendations:');
-                for (const item of recs.slice(0, 5)) {
-                    parts.push(`  * ${item}`);
-                }
-                if (recs.length > 5) {
-                    parts.push(`  * ...and ${recs.length - 5} more recommendations`);
-                }
-            }
-        }
-        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);
-    }
-    async previewProviderForOperation(operation, overrides) {
-        return await this.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,
-        };
-        // Persist a clear log line indicating chosen provider/model for this operation
-        try {
-            const execId = options?.executionId;
-            if (execId) {
-                await this.logPersistence.logMessage(execId, `Using provider: ${resolved.provider}${resolved.model ? ` (model: ${resolved.model})` : ''}`, 'info', { operation, resolved });
-            }
-        }
-        catch {
-            // best-effort logging; ignore
-        }
-        // 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;
-    }
-}