vibeman 0.0.5 → 0.0.6

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

@@ -1,963 +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, GeminiCliProvider, AmpCliProvider, } 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();
-        this.completionInterceptors = 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. Detect the language of the input task content and respond in that SAME language for all markdown sections. Keep enum fields (type, priority) in English. 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);
-        // Register Gemini CLI provider (not default)
-        const geminiProvider = new GeminiCliProvider({
-            defaultWorkingDirectory: this.projectRoot,
-        });
-        this.coreAgentService.registerProvider('gemini', geminiProvider);
-        // Register Amp CLI provider (not default)
-        const ampProvider = new AmpCliProvider({
-            defaultWorkingDirectory: this.projectRoot,
-        });
-        this.coreAgentService.registerProvider('amp', ampProvider);
-        // 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) => {
-            const interceptor = this.completionInterceptors.get(data.executionId);
-            if (interceptor) {
-                this.completionInterceptors.delete(data.executionId);
-                Promise.resolve(interceptor(data))
-                    .then((handled) => {
-                    if (handled)
-                        return;
-                    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,
-                    });
-                })
-                    .catch((error) => log.error('Completion interceptor failed', error, 'agent-service'));
-                return;
-            }
-            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) => {
-            this.completionInterceptors.delete(data.executionId);
-            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) => {
-            this.completionInterceptors.delete(data.executionId);
-            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,
-            });
-        });
-    }
-    registerCompletionInterceptor(executionId, handler) {
-        this.completionInterceptors.set(executionId, handler);
-    }
-    clearCompletionInterceptor(executionId) {
-        this.completionInterceptors.delete(executionId);
-    }
-    async finalizeExecution(executionId, status, error, logs) {
-        this.completionInterceptors.delete(executionId);
-        if (status === 'completed') {
-            await this.logPersistence.completeExecution(executionId, 'completed');
-        }
-        else {
-            await this.logPersistence.completeExecution(executionId, status, error);
-        }
-        const finalLogs = logs ?? this.getExecutionLogs(executionId);
-        this.emit('executionUpdated', {
-            executionId,
-            status,
-            logs: finalLogs,
-            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) {
-            const msg = `Failed to create worktree for task ${taskId}: ${error instanceof Error ? error.message : String(error)}`;
-            log.error(msg, error, 'agent-service');
-            await this.logPersistence.logMessage(executionId, msg, 'error', { taskId, workflowId });
-            await this.completeGenericExecution(executionId, 'failed', msg);
-            throw new Error(msg);
-        }
-        // 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;
-    }
-}