vibeman 0.0.5 → 0.0.6

package/dist/runtime/api/workflows/vibing-orchestrator.js

@@ -1,2462 +0,0 @@
-import { EventEmitter } from 'events';
-import { TaskUpdater } from '../tasks/task-updater.js';
-import { QualityPipeline } from './quality-pipeline.js';
-import { DatabaseService } from '../persistence/database-service.js';
-import { log } from '../lib/logger.js';
-import { generateId } from '../lib/id-generator.js';
-import path from 'path';
-import { stripNextInjectedEnv } from '../utils/stripNextEnv.js';
-import { spawn } from 'child_process';
-import { getSettingsService } from '../settings-service.js';
-import { getVibeDir } from '../lib/server/project-root.js';
-import { EXTENDED_PHASE_FLOW, EXTENDED_PHASE_LABELS } from './workflow-schema.js';
-import { reduce, computeNextAction } from './workflow-reducer.js';
-import { executeEffects } from './workflow-effects.js';
-import { WorkflowReconciler, HeartbeatTracker, IdempotencyGuard, } from './workflow-reconciler.js';
-// Use unified phase definitions from workflow-schema
-const PHASE_FLOW = EXTENDED_PHASE_FLOW;
-// Extended labels with legacy mappings for timeline display
-const PHASE_LABELS = {
-    ...EXTENDED_PHASE_LABELS,
-    draft: 'Workflow started',
-    implementing: 'Implementation',
-    validating: 'Validation',
-    merging: 'Merge',
-    approved: 'Approved',
-};
-// Default config
-const getDefaultConfig = async () => {
-    try {
-        const settingsService = getSettingsService();
-        await settingsService.initialize();
-        const settings = settingsService.getSettings();
-        return {
-            autoQualityChecks: settings.defaultWorkflow.autoQualityChecks,
-            requireHumanApproval: settings.defaultWorkflow.requireHumanApproval,
-            aiCodeReview: settings.defaultWorkflow.aiCodeReview,
-            stepByStepMode: false,
-            retryPolicy: {
-                maxImplementationAttempts: settings.defaultWorkflow.maxImplementationAttempts,
-            },
-            autoCommit: settings.defaultWorkflow.autoCommit,
-        };
-    }
-    catch (error) {
-        log.warn('Failed to load settings, using fallback defaults', error, 'vibing-orchestrator');
-        return {
-            autoQualityChecks: true,
-            requireHumanApproval: true,
-            aiCodeReview: true,
-            stepByStepMode: false,
-            retryPolicy: { maxImplementationAttempts: 3 },
-            autoCommit: false,
-        };
-    }
-};
-export class VibingOrchestrator extends EventEmitter {
-    // Build a new, visible timeline array without mutating the input
-    // Correct order: remove placeholders -> add real phases -> fill missing placeholders
-    computeVisibleTimeline(wf) {
-        const base = Array.isArray(wf.timeline) ? [...wf.timeline] : [];
-        // Visible phases in timeline
-        const visible = new Set([
-            'draft',
-            'implementing',
-            'validating',
-            'ai-reviewing',
-            'awaiting-review',
-            'merging',
-            'cleaning',
-            'failed',
-            'paused',
-        ]);
-        // Ensure a start marker exists (non-placeholder)
-        let startItem = base.find((t) => t.phase === 'draft' && !t.placeholder);
-        if (!startItem && wf.startTime) {
-            startItem = {
-                id: `start:${wf.startTime}`,
-                label: 'Workflow started',
-                phase: 'draft',
-                startTime: wf.startTime,
-            };
-        }
-        // Remove all placeholders and keep only visible phases
-        const realItems = base.filter((t) => !t.placeholder && visible.has(t.phase));
-        // Group real items by phase (preserve per-phase chronological order)
-        // TODO: retry logic is different from grouping by phase
-        const realByPhase = new Map();
-        for (const item of realItems) {
-            const ph = item.phase;
-            if (!realByPhase.has(ph))
-                realByPhase.set(ph, []);
-            realByPhase.get(ph).push(item);
-        }
-        for (const [, items] of realByPhase) {
-            items.sort((a, b) => {
-                const ta = new Date(a.startTime || wf.startTime || 0).getTime();
-                const tb = new Date(b.startTime || wf.startTime || 0).getTime();
-                return ta - tb;
-            });
-        }
-        // Compose final ordered list: start -> each phase in PHASE_FLOW (real items if any, else placeholder)
-        const out = [];
-        if (startItem)
-            out.push(startItem);
-        const ts = wf.metrics?.lastPhaseStartedAt ||
-            wf.lastUpdatedAt ||
-            wf.startTime ||
-            new Date().toISOString();
-        for (const ph of PHASE_FLOW) {
-            const items = realByPhase.get(ph) || [];
-            if (items.length > 0) {
-                out.push(...items);
-            }
-            else {
-                out.push({
-                    id: `placeholder:${ph}`,
-                    label: PHASE_LABELS[ph],
-                    phase: ph,
-                    startTime: ts,
-                    placeholder: true,
-                });
-            }
-        }
-        // Append any other visible real items not in PHASE_FLOW (e.g., 'awaiting-review', 'failed', 'paused')
-        for (const [ph, items] of realByPhase) {
-            if (!PHASE_FLOW.includes(ph) && ph !== 'draft') {
-                out.push(...items);
-            }
-        }
-        return out;
-    }
-    // Build a new timeline by appending an optional item, then normalizing
-    buildTimeline(wf, newItem) {
-        const base = Array.isArray(wf.timeline) ? [...wf.timeline] : [];
-        if (newItem)
-            base.push(newItem);
-        const tmp = { ...wf, timeline: base };
-        return this.computeVisibleTimeline(tmp);
-    }
-    constructor(taskService, agentService, worktreeService, config, gitService, persistenceDataDir) {
-        super();
-        this.taskService = taskService;
-        this.agentService = agentService;
-        this.worktreeService = worktreeService;
-        this.config = config;
-        this.gitService = gitService;
-        this.workflows = new Map();
-        this.initialized = false;
-        this.activeImprovements = new Map();
-        this.taskImprovementExecutions = new Map();
-        this.qualityPipeline = new QualityPipeline();
-        this.taskUpdater = new TaskUpdater();
-        // Persist workflows in a JSON file using the generic database service
-        const filePath = persistenceDataDir
-            ? path.join(persistenceDataDir, 'workflows.json')
-            : path.join(getVibeDir(), '.local/workflows.json');
-        this.workflowDB = new DatabaseService(filePath);
-        // Initialize Phase 3: Reliability & Observability components
-        this.heartbeatTracker = new HeartbeatTracker(5 * 60 * 1000); // 5 min stale threshold
-        this.idempotencyGuard = new IdempotencyGuard(60 * 60 * 1000); // 1 hour TTL
-        this.reconciler = new WorkflowReconciler({
-            checkIntervalMs: 60 * 1000, // Check every minute
-            stuckThresholdMs: 30 * 60 * 1000, // 30 min stuck threshold
-            maxReconcileAttempts: 3,
-        }, () => this.getWorkflowSnapshots(), (workflowId, action) => this.handleStuckWorkflow(workflowId, action));
-        // Forward execution updates from AgentService so UIs can subscribe via orchestrator
-        this.agentService.on('executionUpdated', (update) => {
-            this.emit('executionUpdated', update);
-        });
-        // Listen for execution creation so we can associate executionId to workflows
-        this.agentService.on('executionCreated', async (data) => {
-            try {
-                const wfId = data.workflowId;
-                if (!wfId)
-                    return;
-                const wf = this.workflows.get(wfId);
-                if (!wf)
-                    return;
-                // Track execution IDs and attempts for implementing phase
-                const attempt = (wf.attempts?.implementing || 0) + 1;
-                const executionIds = (wf.executionIds ?? (wf.executionIds = {}));
-                const implList = (executionIds['implementing'] || []);
-                executionIds['implementing'] = [...implList, data.executionId];
-                wf.attempts = wf.attempts || {};
-                wf.attempts['implementing'] = attempt;
-                // Timeline: record implementation attempt start
-                wf.timeline = this.buildTimeline(wf, {
-                    id: data.executionId,
-                    label: attempt > 1 ? `Implementation – Retry #${attempt}` : 'Implementation',
-                    phase: 'implementing',
-                    attempt,
-                    executionId: data.executionId,
-                    startTime: new Date().toISOString(),
-                });
-                await this.saveWorkflow(wf);
-                // Notify listeners that an execution for this workflow has started
-                this.emit('workflowExecutionStarted', {
-                    workflowId: wfId,
-                    executionId: data.executionId,
-                    phase: 'implementing',
-                    workflow: wf,
-                });
-            }
-            catch (err) {
-                log.warn('Failed to handle executionCreated event', err, 'vibing-orchestrator');
-            }
-        });
-    }
-    /**
-     * Initialize workflow orchestrator by loading existing workflows
-     * Call this after construction to load persisted workflows
-     */
-    async initialize() {
-        try {
-            // Load existing workflows from database
-            const all = await this.workflowDB.getAll();
-            const map = new Map();
-            for (const [id, wf] of Object.entries(all)) {
-                map.set(id, this.normalizeWorkflow(wf));
-            }
-            this.workflows = map;
-            log.debug('Loaded existing workflows from disk', { count: this.workflows.size }, 'vibing-orchestrator');
-            log.debug('Vibing orchestrator initialized with persisted workflows', undefined, 'vibing-orchestrator');
-            // Start reliability components
-            this.reconciler.start();
-            this.idempotencyGuard.start();
-            log.info('Started workflow reconciler and idempotency guard', {}, 'vibing-orchestrator');
-        }
-        catch (error) {
-            log.warn('Failed to load workflows from disk', error, 'vibing-orchestrator');
-        }
-        this.initialized = true;
-    }
-    /**
-     * Shutdown the orchestrator and cleanup resources
-     */
-    async shutdown() {
-        this.reconciler.stop();
-        this.idempotencyGuard.stop();
-        this.heartbeatTracker.clear();
-        log.info('Vibing orchestrator shutdown complete', {}, 'vibing-orchestrator');
-    }
-    // ============================================================================
-    // PHASE 3: Reliability & Observability Helpers
-    // ============================================================================
-    /**
-     * Get workflow snapshots for reconciler
-     */
-    getWorkflowSnapshots() {
-        const snapshots = [];
-        for (const [id, wf] of this.workflows) {
-            snapshots.push({
-                id,
-                taskId: wf.taskId,
-                phase: wf.phase,
-                lastUpdatedAt: wf.lastUpdatedAt || wf.startTime,
-                terminalStatus: wf.phase === 'failed' ? 'failed' : wf.phase === 'paused' ? 'paused' : null,
-                lastHeartbeat: this.heartbeatTracker.getLastHeartbeat(id),
-                reconcileAttempts: wf.reconcileAttempts,
-            });
-        }
-        return snapshots;
-    }
-    /**
-     * Handle stuck workflow detected by reconciler
-     */
-    async handleStuckWorkflow(workflowId, action) {
-        const wf = this.workflows.get(workflowId);
-        if (!wf)
-            return;
-        log.warn('Handling stuck workflow', { workflowId, action: action.action, reason: action.reason }, 'vibing-orchestrator');
-        // Track reconcile attempts
-        wf.reconcileAttempts = (wf.reconcileAttempts || 0) + 1;
-        switch (action.action) {
-            case 'timeout':
-                // Emit timeout event for UI notification
-                this.emit('workflowTimeout', {
-                    workflowId,
-                    phase: wf.phase,
-                    reason: action.reason,
-                    timestamp: action.timestamp,
-                });
-                break;
-            case 'fail':
-                // Mark workflow as failed after max attempts
-                await this.dispatch(workflowId, { type: 'PAUSE' });
-                wf.error = action.reason;
-                await this.saveWorkflow(wf);
-                this.emit('workflowStuckFailed', {
-                    workflowId,
-                    reason: action.reason,
-                    timestamp: action.timestamp,
-                });
-                break;
-            case 'retry':
-                // Attempt to retry the current phase
-                await this.dispatch(workflowId, { type: 'RETRY' });
-                break;
-            default:
-                break;
-        }
-    }
-    /**
-     * Record heartbeat for active workflow execution
-     */
-    recordHeartbeat(workflowId) {
-        const wf = this.workflows.get(workflowId);
-        if (wf) {
-            this.heartbeatTracker.recordHeartbeat(workflowId, wf.phase);
-        }
-    }
-    /**
-     * Check if reconciler is running
-     */
-    isReconcilerRunning() {
-        return this.reconciler.isRunning();
-    }
-    /**
-     * Get reconcile history for debugging
-     */
-    getReconcileHistory() {
-        return this.reconciler.getReconcileHistory();
-    }
-    // Normalize workflow shape so timeline/status writes don't throw
-    normalizeWorkflow(wf) {
-        const out = { ...wf };
-        if (!Array.isArray(out.phaseHistory))
-            out.phaseHistory = [];
-        if (!Array.isArray(out.timeline))
-            out.timeline = [];
-        if (!out.executionIds || typeof out.executionIds !== 'object')
-            out.executionIds = {};
-        const execPhases = ['implementing', 'validating', 'ai-reviewing', 'merging'];
-        for (const ph of execPhases) {
-            const arr = out.executionIds[ph];
-            if (!Array.isArray(arr))
-                out.executionIds[ph] = [];
-        }
-        if (!out.attempts || typeof out.attempts !== 'object')
-            out.attempts = {};
-        const metrics = (out.metrics ?? (out.metrics = { durationsMs: {} }));
-        if (!metrics.durationsMs)
-            metrics.durationsMs = {};
-        if (!metrics.lastPhaseStartedAt)
-            metrics.lastPhaseStartedAt = out.startTime;
-        if (!out.lastUpdatedAt)
-            out.lastUpdatedAt = out.startTime;
-        if (!out.status && out.phase === 'draft')
-            out.status = 'draft';
-        return out;
-    }
-    // ============================================================================
-    // NEW STATE MACHINE: Dispatch & Effect Execution
-    // ============================================================================
-    /**
-     * Convert VibingExecution to WorkflowState for the reducer
-     */
-    toWorkflowState(wf) {
-        // Map legacy phases to new simplified phases
-        // Key insight: checkpoint statuses (implemented, validated, etc.) indicate
-        // the PREVIOUS phase completed, so they map to the NEXT phase
-        const phaseMap = {
-            draft: 'draft',
-            implementing: 'implementing',
-            implemented: 'validating', // implementation done -> ready for validation
-            validating: 'validating',
-            validated: 'approved', // validation done -> ready for approval/review
-            'ai-reviewing': 'approved',
-            'ai-reviewed': 'approved',
-            'awaiting-review': 'approved',
-            approved: 'merging', // approved -> ready for merge
-            merging: 'merging',
-            merged: 'done', // merged -> ready for cleanup/done
-            cleaning: 'done',
-            cleaned: 'done',
-            completed: 'done',
-        };
-        const terminalMap = {
-            failed: 'failed',
-            paused: 'paused',
-        };
-        return {
-            id: wf.id,
-            taskId: wf.taskId,
-            phase: phaseMap[wf.phase] || 'draft',
-            terminalStatus: terminalMap[wf.phase] || null,
-            startTime: wf.startTime,
-            endTime: wf.endTime,
-            lastUpdatedAt: wf.lastUpdatedAt || wf.startTime,
-            attempts: (wf.attempts || {}),
-            executionIds: (wf.executionIds || {}),
-            qualityResults: wf.qualityResults,
-            aiReviewResult: wf.aiReviewResult,
-            links: wf.links || {},
-            error: wf.error,
-            failureContext: wf.failureContext
-                ? {
-                    atPhase: phaseMap[wf.failureContext.atPhase] || 'implementing',
-                    error: wf.failureContext.error,
-                    timestamp: wf.failureContext.timestamp,
-                }
-                : undefined,
-            config: {
-                autoQualityChecks: wf.metadata.autoQualityChecks,
-                requireHumanApproval: wf.metadata.requireHumanApproval,
-                aiCodeReview: wf.metadata.aiCodeReview ?? true,
-                stepByStepMode: wf.metadata.stepByStepMode ?? false,
-                autoCommit: wf.metadata.autoCommit ?? false,
-                createPR: wf.metadata.createPR,
-                autoMerge: wf.metadata.autoMerge,
-                retryPolicy: wf.metadata.retryPolicy || { maxImplementationAttempts: 3 },
-            },
-            rerunContext: wf.rerunContextHistory?.[wf.rerunContextHistory.length - 1]
-                ? {
-                    reason: wf.rerunContextHistory[wf.rerunContextHistory.length - 1].reason,
-                    previousExecutionId: wf.rerunContextHistory[wf.rerunContextHistory.length - 1].previousExecutionId,
-                }
-                : undefined,
-        };
-    }
-    /**
-     * Apply WorkflowState changes back to VibingExecution (for backward compatibility)
-     */
-    applyStateToExecution(wf, state) {
-        const reversePhaseMap = {
-            draft: 'draft',
-            implementing: 'implementing',
-            validating: 'validating',
-            approved: 'awaiting-review',
-            merging: 'merging',
-            done: 'completed',
-        };
-        wf.lastUpdatedAt = state.lastUpdatedAt;
-        wf.error = state.error;
-        wf.endTime = state.endTime;
-        if (state.terminalStatus) {
-            wf.phase = state.terminalStatus;
-            wf.status = state.terminalStatus;
-        }
-        else {
-            wf.phase = reversePhaseMap[state.phase];
-            wf.status = reversePhaseMap[state.phase];
-        }
-        if (state.qualityResults) {
-            wf.qualityResults = state.qualityResults;
-        }
-        if (state.aiReviewResult) {
-            wf.aiReviewResult = state.aiReviewResult;
-        }
-        if (state.links) {
-            wf.links = { ...wf.links, ...state.links };
-        }
-        if (state.failureContext) {
-            wf.failureContext = {
-                atPhase: state.failureContext.atPhase,
-                error: state.failureContext.error,
-                timestamp: state.failureContext.timestamp,
-            };
-        }
-    }
-    /**
-     * Create an EffectContext that binds orchestrator methods
-     */
-    createEffectContext(workflowId, state) {
-        const wf = this.workflows.get(workflowId);
-        return {
-            workflowId,
-            taskId: state.taskId,
-            state,
-            executeImplementation: async (feedback) => {
-                await this.executeImplementation(workflowId, feedback);
-            },
-            executeValidation: async () => {
-                await this.executeValidation(workflowId);
-            },
-            executeAiReview: async () => {
-                await this.executeAiReviewPhase(workflowId);
-            },
-            executeMerge: async () => {
-                await this.executeMerge(workflowId);
-            },
-            executeCleanup: async () => {
-                await this.executeCleanup(workflowId);
-            },
-            stopExecution: async () => {
-                if (wf) {
-                    const executions = this.agentService.getTaskExecutions(wf.taskId) || [];
-                    const running = executions.find((e) => e.status === 'running');
-                    if (running?.id) {
-                        await this.agentService.stopExecution(running.id);
-                    }
-                }
-            },
-            saveWorkflow: async (updatedState) => {
-                if (wf) {
-                    this.applyStateToExecution(wf, updatedState);
-                    await this.saveWorkflow(wf);
-                }
-            },
-            updateTask: async () => {
-                if (wf) {
-                    await this.updateTaskForReviewReadiness(wf);
-                }
-            },
-            emit: (name, payload) => {
-                this.emit(name, { ...payload, workflow: wf });
-            },
-        };
-    }
-    /**
-     * Dispatch an event to the workflow state machine (NEW API)
-     * This is the new way to trigger state transitions.
-     * Uses idempotency guard to prevent duplicate event processing.
-     */
-    async dispatch(workflowId, event) {
-        const wf = this.workflows.get(workflowId);
-        if (!wf) {
-            throw new Error(`Workflow ${workflowId} not found`);
-        }
-        // Generate idempotency key for this event
-        const eventKey = this.idempotencyGuard.generateEventKey(workflowId, event.type, event);
-        // Check if this event was already processed
-        const { skipped } = await this.idempotencyGuard.withIdempotency(eventKey, async () => {
-            const beforePhase = wf.phase;
-            const beforeStatus = wf.status;
-            const timestamp = new Date().toISOString();
-            log.info('Dispatching workflow event', {
-                workflowId,
-                eventType: event.type,
-                currentPhase: beforePhase,
-                currentStatus: beforeStatus,
-            }, 'vibing-orchestrator');
-            const currentState = this.toWorkflowState(wf);
-            const { state: newState, effects } = reduce(currentState, event);
-            // Apply state changes
-            this.applyStateToExecution(wf, newState);
-            // Record event in phase history for audit trail
-            const phaseHistory = wf.phaseHistory || [];
-            phaseHistory.push({
-                from: beforePhase,
-                to: wf.phase,
-                at: timestamp,
-                reason: `Event: ${event.type}`,
-            });
-            wf.phaseHistory = phaseHistory;
-            // Record heartbeat on state change
-            this.heartbeatTracker.recordHeartbeat(workflowId, wf.phase);
-            // Execute effects
-            const context = this.createEffectContext(workflowId, newState);
-            await executeEffects(effects, context);
-            log.info('Workflow event dispatched', {
-                workflowId,
-                eventType: event.type,
-                beforePhase,
-                afterPhase: wf.phase,
-                effectCount: effects.length,
-                effects: effects.map((e) => e.type),
-            }, 'vibing-orchestrator');
-            // Emit a generic event for UI/external listeners
-            this.emit('workflowEventDispatched', {
-                workflowId,
-                event,
-                beforePhase,
-                afterPhase: wf.phase,
-                timestamp,
-                workflow: wf,
-            });
-        });
-        if (skipped) {
-            log.debug('Skipped duplicate workflow event', { workflowId, eventType: event.type }, 'vibing-orchestrator');
-        }
-    }
-    /**
-     * Get the next recommended action for a workflow (uses new state machine)
-     */
-    getNextAction(workflowId) {
-        const wf = this.workflows.get(workflowId);
-        if (!wf)
-            return null;
-        const state = this.toWorkflowState(wf);
-        return computeNextAction(state);
-    }
-    // ============================================================================
-    // END NEW STATE MACHINE
-    // ============================================================================
-    /**
-     * Execute a task once (no phase management). Optionally associates with a workflow.
-     */
-    async executeTask(taskId, workflowId) {
-        const t = this.taskService.getTask(taskId);
-        if (!t)
-            throw new Error(`Task ${taskId} not found`);
-        // Wait for the executionCreated event for this task/workflow
-        const createdPromise = this.waitForExecutionCreated(taskId, workflowId, 15000);
-        // Kick off the agent execution (do not rely on returned id)
-        // Attach a catch handler to avoid unhandled promise rejection crashing the process
-        void this.agentService
-            .executeTask(taskId, workflowId)
-            .catch((err) => log.error('Agent execution failed to start (executeTask)', err, 'vibing-orchestrator'));
-        const executionId = await createdPromise;
-        return { executionId };
-    }
-    async stopExecution(executionId) {
-        await this.agentService.stopExecution(executionId);
-    }
-    getExecutionStatus(executionId) {
-        return this.agentService.getExecutionStatus(executionId);
-    }
-    async getPersistedExecutionLogs(executionId) {
-        return await this.agentService.getPersistedExecutionLogs(executionId);
-    }
-    getExecutionLogs(executionId) {
-        return this.agentService.getExecutionLogs(executionId);
-    }
-    getTaskExecutions(taskId) {
-        return this.agentService.getTaskExecutions(taskId);
-    }
-    getExecutionStats() {
-        return this.agentService.getExecutionStats();
-    }
-    async listAllExecutions() {
-        return await this.agentService.listAllExecutions();
-    }
-    async startTaskImprovement(taskId, data, options) {
-        const task = this.taskService.getTask(taskId);
-        if (!task)
-            throw new Error(`Task ${taskId} not found`);
-        const existingExecutionForTask = this.taskImprovementExecutions.get(taskId);
-        if (existingExecutionForTask) {
-            return { executionId: existingExecutionForTask };
-        }
-        const requestedExecution = options?.executionId;
-        if (requestedExecution) {
-            const status = this.agentService.getExecutionStatus(requestedExecution);
-            if (status && ['pending', 'running'].includes(status.status)) {
-                this.taskImprovementExecutions.set(taskId, requestedExecution);
-                return { executionId: requestedExecution };
-            }
-        }
-        const executionId = requestedExecution || generateId('improve');
-        if (this.activeImprovements.has(executionId)) {
-            return { executionId };
-        }
-        this.taskImprovementExecutions.set(taskId, executionId);
-        const job = this.runTaskImprovementPipeline(task, data, executionId, taskId);
-        this.activeImprovements.set(executionId, job);
-        void job.finally(() => {
-            this.activeImprovements.delete(executionId);
-            const current = this.taskImprovementExecutions.get(taskId);
-            if (current === executionId) {
-                this.taskImprovementExecutions.delete(taskId);
-            }
-        });
-        return { executionId };
-    }
-    async improveTaskContent(taskId, data, options) {
-        const task = this.taskService.getTask(taskId);
-        if (!task)
-            throw new Error(`Task ${taskId} not found`);
-        const res = await this.agentService.improveTaskContent(task, data, options?.executionId);
-        if (options?.workflowId) {
-            const wf = this.workflows.get(options.workflowId);
-            if (wf) {
-                wf.metadata = {
-                    ...wf.metadata,
-                    lastTaskImprovement: { ...res, timestamp: new Date().toISOString() },
-                };
-                await this.saveWorkflow(wf);
-            }
-        }
-        return res;
-    }
-    async runTaskImprovementPipeline(task, data, executionId, taskId) {
-        const timestamp = () => new Date().toLocaleTimeString();
-        const withLog = (message) => {
-            const baseLogs = this.agentService.getExecutionLogs(executionId) || [];
-            return [...baseLogs, `[${timestamp()}] ${message}`];
-        };
-        const originalSnapshot = JSON.parse(JSON.stringify(task));
-        let updatedTask = null;
-        this.agentService.registerCompletionInterceptor(executionId, async () => true);
-        try {
-            const improvement = await this.agentService.improveTaskContent(task, data, executionId);
-            const updates = {
-                type: improvement.type,
-                priority: improvement.priority,
-                content: improvement.content,
-            };
-            if (improvement.title) {
-                updates.title = improvement.title;
-            }
-            updatedTask = await this.taskService.updateTask(task.id, updates);
-            if (!this.gitService) {
-                throw new Error('Git service unavailable; cannot commit improved task');
-            }
-            const taskFilePath = path.join(getVibeDir(), 'tasks', `${updatedTask.id}.md`);
-            const relativeTaskPath = path.relative(this.gitService.getProjectRoot(), taskFilePath);
-            const commitMessage = `chore(${updatedTask.id.toLowerCase()}): apply AI improvement`;
-            let commitSummary = 'Task improvement saved without committing (no changes detected)';
-            try {
-                const commitInfo = await this.gitService.commitChanges(updatedTask, commitMessage, [
-                    relativeTaskPath,
-                ]);
-                commitSummary = `Task improvement committed (${commitInfo.hash.slice(0, 7)})`;
-            }
-            catch (commitError) {
-                const message = commitError instanceof Error ? commitError.message : String(commitError);
-                if (/nothing to commit|no changes added to commit|working tree clean/i.test(message)) {
-                    commitSummary = 'No file changes detected; commit skipped';
-                }
-                else {
-                    throw new Error(`Failed to commit improved task: ${message}`);
-                }
-            }
-            const completionLogs = withLog('Task file updated with AI improvement').concat(`[${timestamp()}] ${commitSummary}`);
-            await this.agentService.finalizeExecution(executionId, 'completed', undefined, completionLogs);
-        }
-        catch (error) {
-            if (updatedTask) {
-                const revertPayload = { ...originalSnapshot };
-                delete revertPayload.id;
-                try {
-                    await this.taskService.updateTask(task.id, revertPayload);
-                }
-                catch (revertError) {
-                    log.error('Failed to revert task after improvement failure', { taskId, executionId, error: revertError }, 'vibing-orchestrator');
-                }
-            }
-            const message = error instanceof Error ? error.message : String(error);
-            this.agentService.clearCompletionInterceptor(executionId);
-            await this.agentService.finalizeExecution(executionId, 'failed', message, withLog(`Error applying task improvement: ${message}`));
-            log.error('Failed to complete task improvement', { taskId, executionId, error }, 'vibing-orchestrator');
-        }
-        finally {
-            this.agentService.clearCompletionInterceptor(executionId);
-        }
-    }
-    async aiReviewCode(taskId, reviewContext, options) {
-        const res = await this.agentService.aiReviewCode(taskId, reviewContext, {
-            overrides: options?.overrides,
-            workflowId: options?.workflowId,
-            executionId: options?.executionId,
-        });
-        const wfId = options?.workflowId;
-        if (wfId) {
-            const wf = this.workflows.get(wfId);
-            if (wf) {
-                const timestamp = new Date().toISOString();
-                wf.metadata = {
-                    ...wf.metadata,
-                    aiReviewResult: { ...res, timestamp },
-                };
-                wf.aiReviewResult = { ...res, timestamp };
-                // Record execution ID under ai-reviewing for UI/observability
-                if (res?.executionId) {
-                    wf.executionIds = wf.executionIds || {};
-                    const list = wf.executionIds['ai-reviewing'] || [];
-                    wf.executionIds['ai-reviewing'] = [...list, res.executionId];
-                }
-                await this.saveWorkflow(wf);
-            }
-        }
-        return res;
-    }
-    async aiMerge(taskId, options) {
-        const overrides = options?.provider || options?.model
-            ? { provider: options?.provider, model: options?.model }
-            : undefined;
-        return await this.agentService.aiMerge(taskId, {
-            baseBranch: options?.baseBranch,
-            workflowId: options?.workflowId,
-            executionId: options?.executionId,
-            overrides,
-        });
-    }
-    // Worktree façade
-    async listWorktrees() {
-        return await this.worktreeService.listWorktrees();
-    }
-    async syncWorktreeState() {
-        await this.worktreeService.syncWorktreeState();
-    }
-    getWorktreeInfo(taskId) {
-        const wt = this.worktreeService.getWorktree(taskId);
-        if (!wt)
-            return null;
-        // Remove non-serializable references before exposing to callers
-        const { git, ...rest } = wt;
-        return rest;
-    }
-    async createWorktree(taskId) {
-        const task = this.taskService.getTask(taskId);
-        if (!task)
-            throw new Error(`Task ${taskId} not found`);
-        if (task.deleted_at)
-            throw new Error(`Task ${taskId} is deleted`);
-        const wt = await this.worktreeService.createWorktree(task);
-        const { git, ...rest } = wt;
-        return rest;
-    }
-    async deleteWorktree(taskId, force) {
-        await this.worktreeService.deleteWorktree(taskId, !!force);
-    }
-    async cleanupWorktree(params) {
-        await this.worktreeService.cleanupWorktree(params);
-    }
-    async createPullRequest(taskId, baseBranch = 'main') {
-        return await this.worktreeService.createPullRequest(taskId, baseBranch);
-    }
-    // Open in configured code editor (from settings.development.editor.command)
-    async openInEditor(worktreePath) {
-        try {
-            const settingsService = getSettingsService();
-            await settingsService.initialize();
-            const editor = settingsService.getSetting([
-                'development',
-                'editor',
-            ]) || { command: 'code', args: [] };
-            const cmd = editor.command || 'code';
-            const baseArgs = Array.isArray(editor.args) ? editor.args : [];
-            spawn(cmd, [...baseArgs, worktreePath], {
-                stdio: 'ignore',
-                detached: true,
-                env: stripNextInjectedEnv(),
-            });
-            return { success: true };
-        }
-        catch {
-            // Fallback to cursor if settings service fails
-            spawn('cursor', [worktreePath], {
-                stdio: 'ignore',
-                detached: true,
-                env: stripNextInjectedEnv(),
-            });
-            return { success: true };
-        }
-    }
-    async openInTerminal(worktreePath) {
-        // TODO: add options to resume the session
-        try {
-            const settingsService = getSettingsService();
-            await settingsService.initialize();
-            const terminal = settingsService.getSetting([
-                'development',
-                'terminal',
-            ]) || {
-                command: '/System/Applications/Utilities/Terminal.app/Contents/MacOS/Terminal',
-                args: [],
-            };
-            const cmd = terminal.command || '/System/Applications/Utilities/Terminal.app/Contents/MacOS/Terminal';
-            const baseArgs = Array.isArray(terminal.args) ? terminal.args : [];
-            spawn(cmd, [...baseArgs, worktreePath], {
-                stdio: 'ignore',
-                detached: true,
-                env: stripNextInjectedEnv(),
-            });
-            return { success: true };
-        }
-        catch {
-            // Fallback to default terminal if settings service fails
-            spawn('/System/Applications/Utilities/Terminal.app/Contents/MacOS/Terminal', [worktreePath], {
-                stdio: 'ignore',
-                detached: true,
-                env: stripNextInjectedEnv(),
-            });
-            return { success: true };
-        }
-    }
-    // Worktree status helpers used by UI gating flows
-    async checkWorktreeStatus(workflowId) {
-        const workflow = this.workflows.get(workflowId);
-        if (!workflow)
-            throw new Error(`Workflow ${workflowId} not found`);
-        const worktree = this.getWorktreeInfo(workflow.taskId);
-        if (!worktree?.path)
-            throw new Error('No worktree found for this task');
-        const status = await this.worktreeService.getGitService().getGitStatus(worktree.path);
-        const files = [...status.modified, ...status.staged, ...status.not_added];
-        return { clean: files.length === 0, uncommittedFiles: files, worktreePath: worktree.path };
-    }
-    async approveAndContinueReview(workflowId) {
-        const status = await this.checkWorktreeStatus(workflowId);
-        if (!status.clean) {
-            throw new Error(`Uncommitted changes found. Please commit or stash the following files:\n${status.uncommittedFiles.join('\n')}`);
-        }
-        await this.approveWorkflow(workflowId);
-    }
-    /**
-     * Mark workflow as completed by human decision.
-     * Does not perform merge/cleanup; simply finalizes the workflow and emits completion.
-     */
-    async markWorkflowCompleted(workflowId) {
-        const workflow = this.workflows.get(workflowId);
-        if (!workflow)
-            throw new Error(`Workflow ${workflowId} not found`);
-        // Record that completion was decided by human
-        workflow.metadata = {
-            ...workflow.metadata,
-            humanCompleted: true,
-        };
-        // Use dispatch for manual completion
-        await this.dispatch(workflowId, { type: 'COMPLETE_MANUAL' });
-        log.info('Workflow marked completed by human', { taskId: workflow.taskId }, 'vibing-orchestrator');
-    }
-    async ensureInitialized() {
-        if (!this.initialized) {
-            await this.initialize();
-        }
-    }
-    /**
-     * Start AI-assisted workflow for a task
-     */
-    async startWorkflow(taskId, customConfig) {
-        const task = this.taskService.getTask(taskId);
-        if (!task) {
-            throw new Error(`Task ${taskId} not found`);
-        }
-        const workflowId = generateId('workflow');
-        const defaultConfig = await getDefaultConfig();
-        // Ensure settings-derived defaults take precedence over constructor fallbacks
-        const finalConfig = { ...this.config, ...defaultConfig, ...customConfig };
-        const workflow = this.createNewWorkflow(workflowId, taskId, finalConfig);
-        this.workflows.set(workflowId, workflow);
-        // Persist the new workflow
-        await this.saveWorkflow(workflow);
-        this.emit('workflowStarted', workflow);
-        log.info('Starting workflow for task', { taskId, workflowId }, 'vibing-orchestrator');
-        await this.executeImplementation(workflowId);
-        return workflowId;
-    }
-    /**
-     * Pause a workflow execution
-     */
-    async pauseWorkflow(workflowId) {
-        const workflow = this.workflows.get(workflowId);
-        if (!workflow) {
-            throw new Error(`Workflow ${workflowId} not found`);
-        }
-        // Stop current execution if running
-        // Try to stop the most recent running execution for this task
-        const executions = this.agentService.getTaskExecutions(workflow.taskId) || [];
-        const running = executions
-            .filter((e) => e.status === 'running')
-            .sort((a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime())[0];
-        const latest = running ||
-            executions.sort((a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime())[0];
-        if (latest?.id) {
-            try {
-                await this.agentService.stopExecution(latest.id);
-            }
-            catch (error) {
-                log.warn('Failed to stop execution', error, 'vibing-orchestrator');
-            }
-        }
-        // Use dispatch for state transition
-        await this.dispatch(workflowId, { type: 'PAUSE' });
-        log.info('Paused workflow', { workflowId }, 'vibing-orchestrator');
-    }
-    /**
-     * Reset a workflow by deleting its record and optionally its worktree.
-     */
-    async resetWorkflow(workflowId, options) {
-        const wf = this.workflows.get(workflowId);
-        if (!wf)
-            throw new Error(`Workflow ${workflowId} not found`);
-        const taskId = wf.taskId;
-        if (options?.deleteWorktree) {
-            try {
-                await this.deleteWorktree(wf.taskId, !!options.force);
-            }
-            catch (e) {
-                log.warn('Failed to delete worktree during reset', e, 'vibing-orchestrator');
-            }
-        }
-        // Remove from memory and persistence
-        this.workflows.delete(workflowId);
-        try {
-            await this.workflowDB.delete(workflowId);
-        }
-        catch (e) {
-            log.warn('Failed to delete workflow persistence', e, 'vibing-orchestrator');
-        }
-        if (taskId) {
-            try {
-                const removed = await this.removeWorkflowsByTask(taskId);
-                if (removed > 0) {
-                    log.info('Deleted additional workflows for task during reset', { taskId, removed }, 'vibing-orchestrator');
-                }
-            }
-            catch (e) {
-                log.warn('Failed to delete all workflows for task on reset', e, 'vibing-orchestrator');
-            }
-        }
-        this.emit('workflowDeleted', { workflowId, taskId: wf.taskId });
-    }
-    /**
-     * Approve workflow changes and proceed to merge
-     */
-    async approveWorkflow(workflowId) {
-        const workflow = this.requireWorkflow(workflowId);
-        this.assertPhase(workflow, 'awaiting-review', 'approve');
-        // Close the awaiting-review timeline item if present
-        this.closeTimelineItem(workflow, 'awaiting-review');
-        // Use dispatch for state transition - reducer handles status update and effects
-        await this.dispatch(workflowId, { type: 'APPROVE' });
-        log.info('Approved workflow', { workflowId }, 'vibing-orchestrator');
-    }
-    /**
-     * Reject workflow and request changes
-     */
-    async rejectWorkflow(workflowId, feedback) {
-        const workflow = this.requireWorkflow(workflowId);
-        this.assertPhase(workflow, 'awaiting-review', 'reject');
-        // Close the awaiting-review timeline item if present
-        this.closeTimelineItem(workflow, 'awaiting-review');
-        // Use dispatch for state transition - reducer handles re-implementation with feedback
-        await this.dispatch(workflowId, { type: 'REJECT', feedback });
-        log.info('Rejected workflow', { workflowId, feedback }, 'vibing-orchestrator');
-    }
-    /**
-     * Helper to close a timeline item by phase
-     */
-    closeTimelineItem(workflow, phase) {
-        try {
-            const tl = (workflow.timeline || []);
-            for (let i = tl.length - 1; i >= 0; i--) {
-                const t = tl[i];
-                if (t.phase === phase && !t.placeholder && !t.endTime) {
-                    t.endTime = new Date().toISOString();
-                    break;
-                }
-            }
-            workflow.timeline = this.computeVisibleTimeline(workflow);
-        }
-        catch (err) {
-            log.debug(`Failed to finalize ${phase} timeline item`, err, 'vibing-orchestrator');
-        }
-    }
-    /**
-     * Get workflow status
-     */
-    getWorkflow(workflowId) {
-        const wf = this.workflows.get(workflowId) || null;
-        if (wf) {
-            wf.timeline = this.computeVisibleTimeline(wf);
-        }
-        return wf;
-    }
-    /**
-     * Get all workflows for a task
-     */
-    getTaskWorkflows(taskId) {
-        return Array.from(this.workflows.values())
-            .filter((w) => w.taskId === taskId)
-            .map((wf) => {
-            wf.timeline = this.computeVisibleTimeline(wf);
-            return wf;
-        })
-            .sort((a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime());
-    }
-    /**
-     * Get latest workflow for a task, preferring most recently updated.
-     * Falls back to newest startTime when lastUpdatedAt is unavailable.
-     */
-    getLatestWorkflowByTask(taskId) {
-        const list = Array.from(this.workflows.values()).filter((w) => w.taskId === taskId);
-        if (list.length === 0)
-            return null;
-        const sorted = list.sort((a, b) => {
-            const aTs = new Date(a.lastUpdatedAt || a.startTime || 0).getTime();
-            const bTs = new Date(b.lastUpdatedAt || b.startTime || 0).getTime();
-            return bTs - aTs;
-        });
-        const latest = sorted[0];
-        latest.timeline = this.computeVisibleTimeline(latest);
-        return latest;
-    }
-    /**
-     * Update UI phase with proper tracking of lastPhase, phaseHistory, and metrics.
-     * This is for UI-only phases that don't correspond to FSM states.
-     */
-    updateUIPhase(workflow, newPhase) {
-        const oldPhase = workflow.phase;
-        if (oldPhase === newPhase)
-            return;
-        workflow.lastPhase = oldPhase;
-        workflow.phase = newPhase;
-        const now = new Date().toISOString();
-        const history = workflow.phaseHistory || [];
-        history.push({ from: oldPhase, to: newPhase, at: now });
-        workflow.phaseHistory = history;
-        // Metrics accumulation
-        const metrics = (workflow.metrics = workflow.metrics || { durationsMs: {} });
-        const startTs = metrics.lastPhaseStartedAt
-            ? new Date(metrics.lastPhaseStartedAt).getTime()
-            : new Date(workflow.startTime).getTime();
-        const nowTs = new Date(now).getTime();
-        const delta = Math.max(0, nowTs - startTs);
-        const prev = metrics.durationsMs?.[oldPhase] || 0;
-        metrics.durationsMs = { ...metrics.durationsMs, [oldPhase]: prev + delta };
-        metrics.lastPhaseStartedAt = now;
-        if (newPhase === 'completed') {
-            metrics.totalDurationMs = Object.values(metrics.durationsMs || {}).reduce((a, b) => a + (b || 0), 0);
-        }
-        workflow.lastUpdatedAt = now;
-        workflow.timeline = this.computeVisibleTimeline(workflow);
-        this.heartbeatTracker.recordHeartbeat(workflow.id, newPhase);
-        this.emit('workflowPhaseChanged', {
-            workflowId: workflow.id,
-            oldPhase,
-            newPhase,
-            workflow,
-        });
-    }
-    /**
-     * Update task file when workflow becomes ready for review
-     */
-    async updateTaskForReviewReadiness(workflow) {
-        try {
-            const context = this.extractTaskUpdateContext(workflow);
-            await this.taskUpdater.updateTaskForReviewReadiness(workflow.taskId, context);
-            log.info('Task updated for review readiness', { taskId: workflow.taskId, workflowId: workflow.id }, 'vibing-orchestrator');
-        }
-        catch (error) {
-            log.error('Failed to update task for review readiness', { taskId: workflow.taskId, workflowId: workflow.id, error }, 'vibing-orchestrator');
-            // Don't throw - task update failure shouldn't block workflow progression
-        }
-    }
-    /**
-     * Extract context information for task updates
-     */
-    extractTaskUpdateContext(workflow) {
-        const context = {
-            workflowId: workflow.id,
-            phase: workflow.phase,
-            filesModified: [],
-            keyChanges: [],
-            testsAdded: workflow.qualityResults?.details?.tests,
-            testsPassed: workflow.qualityResults?.details?.tests,
-            buildPassed: workflow.qualityResults?.details?.build,
-            qualityChecksPassed: workflow.qualityResults?.overall,
-        };
-        // Extract AI review score if available
-        if (workflow.metadata?.aiReviewResult) {
-            context.aiReviewScore = workflow.metadata.aiReviewResult.qualityScore;
-        }
-        // Extract key changes from implementation attempts
-        const implementingExecutions = workflow.executionIds?.implementing || [];
-        if (implementingExecutions.length > 0) {
-            context.keyChanges = [
-                `Implementation completed in ${implementingExecutions.length} attempt(s)`,
-                'Core task functionality implemented',
-            ];
-        }
-        // Extract file modification info from worktree if available
-        try {
-            const worktree = this.agentService.getWorktreeInfo(workflow.taskId);
-            if (worktree?.path) {
-                context.filesModified = [`Changes made in worktree: ${worktree.branchName}`];
-            }
-        }
-        catch (error) {
-            log.debug('Could not extract worktree info for task update', error, 'vibing-orchestrator');
-        }
-        // Add quality check failures to key changes if any
-        if (workflow.qualityResults?.details) {
-            const failedCategories = Object.entries(workflow.qualityResults.details)
-                .filter(([, passed]) => !passed)
-                .map(([name]) => name);
-            if (failedCategories.length > 0) {
-                context.keyChanges.push(`Quality issues in: ${failedCategories.join(', ')}`);
-            }
-        }
-        return context;
-    }
-    /**
-     * Save workflow to persistence layer
-     */
-    async saveWorkflow(workflow) {
-        try {
-            await this.workflowDB.set(workflow.id, serializeVibe(workflow));
-        }
-        catch (error) {
-            log.warn('Failed to persist workflow', error, 'vibing-orchestrator');
-        }
-    }
-    /**
-     * Execute implementation phase with AI coding
-     */
-    async executeImplementation(workflowId, feedback, providerOverride) {
-        const workflow = this.workflows.get(workflowId);
-        if (!workflow)
-            return;
-        // Note: FSM has already transitioned to 'implementing' via START/RETRY event
-        // We only need to update timeline/metrics here for UI observability
-        this.updateUIPhase(workflow, 'implementing');
-        try {
-            log.info('Implementing task', { taskId: workflow.taskId }, 'vibing-orchestrator');
-            // Start task execution with enhanced prompts and workflow context
-            // Prepare rerun context if any
-            const previousExecId = (workflow.executionIds?.['implementing'] || []).slice(-1)[0];
-            const attempt = (workflow.attempts?.implementing || 0) + 1;
-            // Build rerun context automatically when available (no need to plumb reason externally)
-            const autoReason = feedback ||
-                workflow.failureContext?.error ||
-                (workflow.failureContext?.atPhase
-                    ? `Retry after ${workflow.failureContext.atPhase} failure`
-                    : undefined);
-            const aiReviewSource = workflow.aiReviewResult || workflow.metadata?.aiReviewResult;
-            const aiReviewContext = aiReviewSource
-                ? {
-                    summary: aiReviewSource.reviewSummary,
-                    recommendations: aiReviewSource.recommendations,
-                    score: aiReviewSource.qualityScore,
-                }
-                : undefined;
-            // Prepare to capture executionId from event, then start execution
-            const createdPromise = this.waitForExecutionCreated(workflow.taskId, workflowId, 20000);
-            // Fire-and-forget; attach catch to prevent unhandled rejection from crashing process
-            void this.agentService
-                .executeTask(workflow.taskId, workflowId, {
-                rerunContext: autoReason
-                    ? {
-                        reason: autoReason,
-                        previousExecutionId: previousExecId,
-                        failurePhase: workflow.failureContext?.atPhase,
-                        qualityResults: workflow.qualityResults,
-                        aiReview: aiReviewContext,
-                        attempt,
-                    }
-                    : undefined,
-                providerOverride: providerOverride || workflow.metadata?.aiRoutingOverrides?.execute_task,
-                workflowConfig: workflow.metadata,
-            })
-                .catch((err) => log.error('Agent execution failed to start (implementation phase)', err, 'vibing-orchestrator'));
-            const executionId = await createdPromise;
-            // Maintain placeholders and wait for execution to complete
-            workflow.timeline = this.computeVisibleTimeline(workflow);
-            await this.saveWorkflow(workflow);
-            // Wait for execution to complete
-            await this.waitForExecution(executionId);
-            const execution = this.agentService.getExecutionStatus(executionId);
-            if (!execution || execution.status === 'failed') {
-                throw new Error(`Implementation failed: ${execution?.error || 'Unknown error'}`);
-            }
-            // Timeline: complete implementation attempt
-            const tImpl = workflow.timeline.find((t) => t.executionId === executionId);
-            if (tImpl) {
-                tImpl.endTime = execution.endTime || new Date().toISOString();
-                tImpl.usage = execution.usage;
-                workflow.timeline = this.computeVisibleTimeline(workflow);
-                await this.saveWorkflow(workflow);
-            }
-            log.info('Implementation completed', { taskId: workflow.taskId }, 'vibing-orchestrator');
-            // Dispatch FSM event - reducer handles transition to 'validating' and triggers EXECUTE_VALIDATION effect
-            // In stepByStepMode, the effect is not triggered by reducer, so validation waits for Continue
-            // IMPORTANT: Dispatch before updating UI phase, otherwise toWorkflowState maps 'implemented' -> 'validating'
-            // which causes IMPL_SUCCESS to be an invalid transition (expecting 'implementing' phase)
-            // Note: dispatch already updates the workflow status via applyStateToExecution, so no need to set it again
-            await this.dispatch(workflowId, { type: 'IMPL_SUCCESS', executionId });
-            if (workflow.metadata.stepByStepMode) {
-                log.info('Manual step mode – implemented; waiting for Continue to run validation', { workflowId }, 'vibing-orchestrator');
-            }
-            // Note: In non-stepByStepMode, executeValidation is triggered by reducer's EXECUTE_VALIDATION effect
-        }
-        catch (error) {
-            await this.handlePhaseFailure(workflowId, 'implementing', error);
-        }
-    }
-    /**
-     * Public: re-run implementation phase on demand
-     * Uses dispatch(RETRY) to transition FSM and trigger implementation via effect.
-     */
-    async rerunImplementation(workflowId, feedback, providerOverride) {
-        const workflow = this.workflows.get(workflowId);
-        if (!workflow)
-            throw new Error(`Workflow ${workflowId} not found`);
-        // Store provider override for the effect to pick up
-        if (providerOverride) {
-            workflow.metadata = workflow.metadata || {};
-            workflow.metadata.aiRoutingOverrides = {
-                ...(workflow.metadata.aiRoutingOverrides || {}),
-                execute_task: providerOverride,
-            };
-        }
-        // Store feedback in failureContext for the implementation to use
-        if (feedback) {
-            workflow.failureContext = {
-                atPhase: workflow.phase,
-                error: feedback,
-                timestamp: new Date().toISOString(),
-            };
-        }
-        // Dispatch RETRY event - reducer handles transition and triggers EXECUTE_IMPLEMENTATION effect
-        await this.dispatch(workflowId, { type: 'RETRY' });
-    }
-    /**
-     * Get previous phase, preferring the phase where failure occurred
-     */
-    getPreviousPhase(workflowId) {
-        const wf = this.workflows.get(workflowId);
-        if (!wf)
-            return null;
-        return wf.failureContext?.atPhase || wf.lastPhase || null;
-    }
-    /**
-     * Rerun the phase that led to failure (or lastPhase if available)
-     */
-    async rerunPreviousPhase(workflowId) {
-        const phase = this.getPreviousPhase(workflowId);
-        if (!phase)
-            throw new Error('No previous phase recorded.');
-        await this.rerunPhase(workflowId, phase);
-    }
-    /**
-     * Rerun a specific phase programmatically
-     */
-    async rerunPhase(workflowId, phase) {
-        // Before rerun, reset timeline and results from the selected phase onward
-        await this.resetFromPhase(workflowId, phase);
-        switch (phase) {
-            case 'implementing':
-                // Use dispatch(RETRY) to transition FSM and trigger implementation via effect
-                await this.dispatch(workflowId, { type: 'RETRY' });
-                return;
-            case 'validating':
-                await this.executeValidation(workflowId);
-                return;
-            case 'ai-reviewing':
-                await this.executeAiReviewPhase(workflowId);
-                return;
-            case 'awaiting-review':
-                await this.executeAwaitingReview(workflowId);
-                return;
-            case 'merging':
-                await this.executeMerge(workflowId);
-                return;
-            case 'approved':
-                // Failure after approval typically means merge failed; try merging again
-                await this.executeMerge(workflowId);
-                return;
-            case 'cleaning':
-                await this.executeCleanup(workflowId);
-                return;
-            default:
-                // For other phases, restart implementation as a safe default
-                await this.dispatch(workflowId, { type: 'RETRY' });
-                return;
-        }
-    }
-    /**
-     * Reset workflow state from a given phase onward (inclusive).
-     * Clears timeline entries, execution IDs, attempts, and phase results for later phases
-     * so that a rerun behaves like a fresh run from that step.
-     */
-    async resetFromPhase(workflowId, from) {
-        const workflow = this.workflows.get(workflowId);
-        if (!workflow)
-            return;
-        const ordered = [
-            'draft',
-            'implementing',
-            'validating',
-            'ai-reviewing',
-            'awaiting-review',
-            'approved',
-            'merging',
-            'merged',
-            'cleaning',
-            'completed',
-        ];
-        const idx = ordered.indexOf(from);
-        if (idx < 0)
-            return;
-        const toReset = ordered.slice(idx); // inclusive of `from`
-        // Clear execution IDs and attempts for affected phases
-        workflow.executionIds = workflow.executionIds || {};
-        workflow.attempts = workflow.attempts || {};
-        for (const ph of toReset) {
-            if (workflow.executionIds[ph])
-                workflow.executionIds[ph] = [];
-            if (workflow.attempts[ph] !== undefined)
-                delete workflow.attempts[ph];
-        }
-        // Trim timeline items from affected phases
-        if (Array.isArray(workflow.timeline)) {
-            workflow.timeline = workflow.timeline.filter((t) => ordered.indexOf(t.phase) < idx);
-        }
-        // Trim phase history entries from affected phases so UI does not reconstruct later steps
-        if (Array.isArray(workflow.phaseHistory)) {
-            workflow.phaseHistory = workflow.phaseHistory.filter((h) => ordered.indexOf(h.to) < idx);
-            // Update lastPhase to the last remaining history entry (or 'draft')
-            const last = workflow.phaseHistory[workflow.phaseHistory.length - 1];
-            workflow.lastPhase = (last ? last.to : 'draft');
-        }
-        // Clear phase-specific results when rerunning from or before them
-        if (idx <= ordered.indexOf('validating')) {
-            workflow.qualityResults = undefined;
-        }
-        if (idx <= ordered.indexOf('ai-reviewing')) {
-            if (workflow.metadata) {
-                const { aiReviewResult, ...rest } = workflow.metadata || {};
-                workflow.metadata = { ...rest };
-            }
-        }
-        // Clear any failure/error context
-        workflow.error = undefined;
-        workflow.failureContext = undefined;
-        // Persist reset before kicking off rerun
-        await this.saveWorkflow(workflow);
-        // Notify listeners that the workflow snapshot changed (phase change will follow)
-        this.emit('workflowUpdated', workflow);
-    }
-    /**
-     * Perform AI code review of implemented changes
-     */
-    async performAICodeReview(workflowId, providedExecutionId) {
-        const workflow = this.workflows.get(workflowId);
-        if (!workflow)
-            return { passed: false };
-        try {
-            log.info('Running AI code review', { taskId: workflow.taskId }, 'vibing-orchestrator');
-            // Get worktree info for the task
-            const worktree = this.agentService.getWorktreeInfo(workflow.taskId);
-            if (!worktree) {
-                log.warn('No worktree found for AI code review, skipping', undefined, 'vibing-orchestrator');
-                return { passed: true, executionId: providedExecutionId };
-            }
-            // Execute AI code review via agent service
-            const review = await this.agentService.aiReviewCode(workflow.taskId, 'Automated AI code review triggered by workflow orchestrator', {
-                overrides: workflow.metadata?.aiRoutingOverrides?.ai_codereview,
-                executionId: providedExecutionId,
-                workflowId,
-            });
-            // Persist review result into workflow metadata
-            const timestamp = new Date().toISOString();
-            workflow.metadata = {
-                ...workflow.metadata,
-                aiReviewResult: { ...review, timestamp },
-            };
-            workflow.aiReviewResult = { ...review, timestamp };
-            // Track execution ID under ai-reviewing for observability
-            const executionId = providedExecutionId ?? review?.executionId;
-            if (executionId) {
-                workflow.executionIds = workflow.executionIds || {};
-                const list = workflow.executionIds['ai-reviewing'] || [];
-                if (!list.includes(executionId)) {
-                    workflow.executionIds['ai-reviewing'] = [...list, executionId];
-                }
-            }
-            await this.saveWorkflow(workflow);
-            // Gate by minimum score from settings
-            const minScore = await this.getAIReviewThreshold();
-            if (review.qualityScore < minScore) {
-                const msg = `AI code review score too low (${review.qualityScore} < ${minScore})`;
-                log.warn('AI code review score too low', { score: review.qualityScore, minScore }, 'vibing-orchestrator');
-                workflow.error = msg;
-                return { passed: false, executionId };
-            }
-            log.info('AI code review passed', { score: review.qualityScore }, 'vibing-orchestrator');
-            workflow.error = undefined;
-            return { passed: true, executionId };
-        }
-        catch (error) {
-            log.warn('AI code review failed', error, 'vibing-orchestrator');
-            const msg = error instanceof Error ? error.message : String(error);
-            const workflowRef = this.workflows.get(workflowId);
-            if (workflowRef) {
-                workflowRef.error = `AI code review failed: ${msg}`;
-            }
-            return { passed: false, executionId: providedExecutionId };
-        }
-    }
-    /**
-     * Execute AI review as a dedicated phase
-     * Note: 'ai-reviewing' is a UI-only phase for timeline display, not an FSM phase.
-     * FSM remains in 'approved' during AI review.
-     */
-    async executeAiReviewPhase(workflowId) {
-        const workflow = this.workflows.get(workflowId);
-        if (!workflow)
-            return;
-        // Update UI phase for timeline display (FSM stays in 'approved')
-        this.updateUIPhase(workflow, 'ai-reviewing');
-        try {
-            const attemptList = workflow.executionIds?.['ai-reviewing'] || [];
-            const attempt = attemptList.length + 1;
-            const execId = generateId('review');
-            workflow.executionIds = workflow.executionIds || {};
-            const aiList = workflow.executionIds['ai-reviewing'] || [];
-            workflow.executionIds['ai-reviewing'] = [...aiList, execId];
-            workflow.timeline = this.buildTimeline(workflow, {
-                id: execId,
-                label: attempt > 1 ? `AI Review – Retry #${attempt}` : 'AI Review',
-                phase: 'ai-reviewing',
-                attempt,
-                executionId: execId,
-                startTime: new Date().toISOString(),
-            });
-            await this.saveWorkflow(workflow);
-            this.emit('workflowExecutionStarted', {
-                workflowId,
-                executionId: execId,
-                phase: 'ai-reviewing',
-                workflow,
-            });
-            const { passed } = await this.performAICodeReview(workflowId, execId);
-            const latest = this.workflows.get(workflowId);
-            if (latest) {
-                const timeline = (latest.timeline || []);
-                const item = timeline.find((t) => t.executionId === execId);
-                if (item) {
-                    item.endTime = new Date().toISOString();
-                    if (!passed) {
-                        item.reason = latest.error || 'AI review did not pass the quality threshold';
-                    }
-                    latest.timeline = this.computeVisibleTimeline(latest);
-                    await this.saveWorkflow(latest);
-                }
-            }
-            if (!passed) {
-                const reason = workflow.error || 'AI review did not pass the quality threshold';
-                const retried = await this.maybeRetryImplementation(workflowId, reason, 'ai-reviewing');
-                if (!retried) {
-                    await this.handlePhaseFailure(workflowId, 'ai-reviewing', workflow.error);
-                }
-                return;
-            }
-            // AI review passed → set checkpoint
-            workflow.status = 'ai-reviewed';
-            workflow.lastUpdatedAt = new Date().toISOString();
-            workflow.timeline = this.computeVisibleTimeline(workflow);
-            await this.saveWorkflow(workflow);
-            workflow.status = 'awaiting-review';
-            workflow.lastUpdatedAt = new Date().toISOString();
-            await this.saveWorkflow(workflow);
-            await this.executeAwaitingReview(workflowId);
-            const wf = this.workflows.get(workflowId);
-            if (wf?.metadata.stepByStepMode) {
-                log.info('Manual step mode – AI review passed; waiting for Continue', { workflowId }, 'vibing-orchestrator');
-            }
-        }
-        catch (error) {
-            await this.handlePhaseFailure(workflowId, 'ai-reviewing', error);
-        }
-    }
-    async executeAwaitingReview(workflowId) {
-        const workflow = this.workflows.get(workflowId);
-        if (!workflow)
-            return;
-        // Update UI phase for timeline display (FSM is in 'approved')
-        // 'awaiting-review' is the UI representation of FSM 'approved' phase
-        this.updateUIPhase(workflow, 'awaiting-review');
-        // Update task file for review readiness
-        await this.updateTaskForReviewReadiness(workflow);
-        const hasReal = Array.isArray(workflow.timeline)
-            ? workflow.timeline.some((t) => t.phase === 'awaiting-review' && !t.placeholder)
-            : false;
-        if (!hasReal) {
-            workflow.timeline = this.buildTimeline(workflow, {
-                id: `awaiting-review:${new Date().toISOString()}`,
-                label: PHASE_LABELS['awaiting-review'],
-                phase: 'awaiting-review',
-                startTime: new Date().toISOString(),
-            });
-        }
-        await this.saveWorkflow(workflow);
-    }
-    /**
-     * Execute validation phase with quality checks
-     * Note: FSM has already transitioned to 'validating' via IMPL_SUCCESS event
-     */
-    async executeValidation(workflowId) {
-        const workflow = this.workflows.get(workflowId);
-        if (!workflow)
-            return;
-        // Update UI phase for timeline display (FSM is already in 'validating')
-        this.updateUIPhase(workflow, 'validating');
-        try {
-            if (!workflow.metadata.autoQualityChecks) {
-                // TODO implement later
-                return;
-            }
-            log.info('Running quality checks', { taskId: workflow.taskId }, 'vibing-orchestrator');
-            // Get worktree path for quality checks
-            const worktree = this.agentService.getWorktreeInfo(workflow.taskId);
-            const workingDirectory = worktree?.path || process.cwd();
-            // Start a generic execution for validation to unify observability
-            const execId = await this.agentService.startGenericExecution(workflow.taskId, {
-                workflowId,
-                workingDirectory,
-            });
-            const qualityOverride = workflow.metadata?.aiRoutingOverrides?.quality_checks;
-            try {
-                const resolved = await this.agentService.previewProviderForOperation('quality_checks', qualityOverride);
-                const providerLabel = resolved.model
-                    ? `${resolved.provider} (model: ${resolved.model})`
-                    : resolved.provider;
-                await this.agentService.logGenericExecution(execId, `[validation] Using provider: ${providerLabel}`);
-            }
-            catch (err) {
-                log.warn('Failed to resolve quality-check provider', err, 'vibing-orchestrator');
-            }
-            workflow.executionIds = workflow.executionIds || {};
-            const valList = workflow.executionIds['validating'] || [];
-            workflow.executionIds['validating'] = [...valList, execId];
-            workflow.timeline = this.buildTimeline(workflow, {
-                id: `validation:${new Date().toISOString()}`,
-                label: 'Validation',
-                phase: 'validating',
-                startTime: new Date().toISOString(),
-                executionId: execId,
-            });
-            await this.saveWorkflow(workflow);
-            // Notify listeners that a validation execution has started
-            this.emit('workflowExecutionStarted', {
-                workflowId,
-                executionId: execId,
-                phase: 'validating',
-                workflow,
-            });
-            // Capture quality checks used for this workflow (from settings if not already set)
-            try {
-                if (!workflow.metadata.qualityChecks || workflow.metadata.qualityChecks.length === 0) {
-                    const { getSettingsService } = await import('../settings-service.js');
-                    const settingsService = getSettingsService();
-                    await settingsService.initialize();
-                    const settings = settingsService.getSettings();
-                    if (settings.quality?.checks?.length) {
-                        workflow.metadata.qualityChecks = settings.quality.checks;
-                        await this.saveWorkflow(workflow);
-                    }
-                }
-            }
-            catch (e) {
-                log.warn('Failed to get quality checks from settings', e, 'vibing-orchestrator');
-            }
-            // Run quality pipeline with streaming logs
-            const qualityResults = await this.qualityPipeline.runChecksStreaming(workingDirectory, async (line) => {
-                try {
-                    await this.agentService.logGenericExecution(execId, String(line));
-                }
-                catch (err) {
-                    log.debug('Failed to stream validation log line', err, 'vibing-orchestrator');
-                }
-            });
-            workflow.qualityResults = qualityResults;
-            // Timeline: end validation
-            const timeline = workflow.timeline;
-            for (let i = timeline.length - 1; i >= 0; i--) {
-                const t = timeline[i];
-                if (t.phase === 'validating' && !t.endTime) {
-                    t.endTime = new Date().toISOString();
-                    break;
-                }
-            }
-            // Mark execution complete (completed even if checks failed; workflow handles failure)
-            await this.agentService.completeGenericExecution(execId, 'completed');
-            workflow.timeline = this.computeVisibleTimeline(workflow);
-            await this.saveWorkflow(workflow);
-            if (!qualityResults.overall) {
-                log.info('Quality checks failed', { taskId: workflow.taskId }, 'vibing-orchestrator');
-                workflow.error = 'Quality checks failed';
-                const reason = 'Quality checks failed. Please address the reported issues.';
-                const retried = await this.maybeRetryImplementation(workflowId, reason, 'validating');
-                if (!retried) {
-                    await this.handlePhaseFailure(workflowId, 'validating', workflow.error);
-                }
-                return;
-            }
-            log.info('Quality checks passed', { taskId: workflow.taskId }, 'vibing-orchestrator');
-            // Dispatch FSM event - reducer handles transition to 'approved' and may trigger AI review
-            // IMPORTANT: Dispatch before updating UI phase, otherwise toWorkflowState maps 'validated' -> 'approved'
-            // which causes VALID_SUCCESS to be an invalid transition (expecting 'validating' phase)
-            // Note: dispatch already updates the workflow status via applyStateToExecution, so no need to set it again
-            await this.dispatch(workflowId, { type: 'VALID_SUCCESS', results: qualityResults });
-            if (workflow.metadata.stepByStepMode) {
-                log.info('Manual step mode – waiting for Continue to run AI review', { workflowId }, 'vibing-orchestrator');
-            }
-            // Note: In non-stepByStepMode with aiCodeReview, executeAiReviewPhase is triggered by reducer's EXECUTE_AI_REVIEW effect
-        }
-        catch (error) {
-            await this.handlePhaseFailure(workflowId, 'validating', error);
-        }
-    }
-    /**
-     * Public: run validation phase on demand
-     */
-    async runValidation(workflowId) {
-        const workflow = this.workflows.get(workflowId);
-        if (!workflow)
-            throw new Error(`Workflow ${workflowId} not found`);
-        await this.executeValidation(workflowId);
-    }
-    /**
-     * Execute merge phase
-     * Note: FSM has already transitioned to 'merging' via APPROVE event
-     */
-    async executeMerge(workflowId, providerOverride) {
-        const workflow = this.workflows.get(workflowId);
-        if (!workflow)
-            return;
-        // Update UI phase for timeline display (FSM is already in 'merging')
-        this.updateUIPhase(workflow, 'merging');
-        let executionId;
-        try {
-            log.info('AI merging changes', { taskId: workflow.taskId }, 'vibing-orchestrator');
-            const mergeList = workflow.executionIds?.['merging'] || [];
-            const attempt = mergeList.length + 1;
-            executionId = generateId('merge');
-            const startTime = new Date().toISOString();
-            workflow.executionIds = workflow.executionIds || {};
-            workflow.executionIds['merging'] = [...mergeList, executionId];
-            workflow.timeline = this.buildTimeline(workflow, {
-                id: executionId,
-                label: attempt > 1 ? `Merge – Retry #${attempt}` : 'Merge',
-                phase: 'merging',
-                attempt,
-                executionId,
-                startTime,
-            });
-            workflow.lastUpdatedAt = startTime;
-            await this.saveWorkflow(workflow);
-            this.emit('workflowUpdated', workflow);
-            this.emit('workflowExecutionStarted', {
-                workflowId,
-                executionId,
-                phase: 'merging',
-                workflow,
-            });
-            await this.agentService.aiMerge(workflow.taskId, {
-                baseBranch: 'main',
-                executionId,
-                workflowId,
-                overrides: providerOverride || workflow.metadata?.aiRoutingOverrides?.ai_merge,
-            });
-            const mergeExec = this.agentService.getExecutionStatus(executionId);
-            if (!mergeExec || mergeExec.status !== 'completed') {
-                throw new Error(`AI merge failed: ${mergeExec?.error || 'Unknown error'}`);
-            }
-            // Verify merge actually succeeded by checking git state
-            const mergeVerification = await this.verifyMergeSuccess(workflow.taskId, executionId);
-            if (!mergeVerification.success) {
-                throw new Error(`Merge verification failed: ${mergeVerification.error}`);
-            }
-            const latest = this.workflows.get(workflowId) || workflow;
-            const timeline = (latest.timeline || []);
-            const tMerge = timeline.find((t) => t.executionId === executionId);
-            if (tMerge) {
-                tMerge.endTime = mergeExec.endTime || new Date().toISOString();
-                tMerge.usage = mergeExec.usage;
-                if (mergeVerification.mergeCommit) {
-                    tMerge.mergeCommit = mergeVerification.mergeCommit;
-                }
-                latest.timeline = this.computeVisibleTimeline(latest);
-                latest.lastUpdatedAt = new Date().toISOString();
-                await this.saveWorkflow(latest);
-            }
-            // Store merge commit in workflow links
-            if (mergeVerification.mergeCommit) {
-                workflow.links = workflow.links || {};
-                workflow.links.mergeCommit = mergeVerification.mergeCommit;
-            }
-            await this.taskService.updateTask(workflow.taskId, { status: 'done' });
-            // Dispatch FSM event - reducer handles transition to 'done' and triggers cleanup effect
-            // IMPORTANT: Dispatch before updating UI phase, otherwise toWorkflowState maps 'merged' -> 'done'
-            // which causes MERGE_SUCCESS to be an invalid transition (expecting 'merging' phase)
-            // Note: dispatch already updates the workflow status via applyStateToExecution, so no need to set it again
-            await this.dispatch(workflowId, { type: 'MERGE_SUCCESS' });
-            if (workflow.metadata.stepByStepMode) {
-                log.info('Manual step mode – merge completed; waiting for Continue', { workflowId }, 'vibing-orchestrator');
-            }
-            // Note: In non-stepByStepMode, executeCleanup is triggered by reducer's EXECUTE_CLEANUP effect
-            log.info('Merge completed, ready for cleanup', { taskId: workflow.taskId }, 'vibing-orchestrator');
-        }
-        catch (error) {
-            const latest = this.workflows.get(workflowId) || workflow;
-            if (executionId && latest) {
-                const timeline = (latest.timeline || []);
-                const pending = timeline.find((t) => t.executionId === executionId);
-                if (pending && !pending.endTime) {
-                    pending.endTime = new Date().toISOString();
-                    if (!pending.reason) {
-                        pending.reason = error instanceof Error ? error.message : String(error);
-                    }
-                    latest.timeline = this.computeVisibleTimeline(latest);
-                    latest.lastUpdatedAt = new Date().toISOString();
-                    await this.saveWorkflow(latest);
-                }
-            }
-            await this.handlePhaseFailure(workflowId, 'merging', error);
-        }
-    }
-    /**
-     * Verify that a merge actually succeeded by checking git state
-     */
-    async verifyMergeSuccess(taskId, executionId) {
-        try {
-            const worktree = this.worktreeService.getWorktree(taskId);
-            if (!worktree) {
-                return { success: false, error: 'No worktree found for task' };
-            }
-            const gitService = this.worktreeService.getGitService();
-            const mainRepoPath = gitService.getProjectRoot();
-            // Check 1: Verify we're on the main branch and it's clean
-            const { spawn } = await import('child_process');
-            const execGit = (args, cwd) => {
-                return new Promise((resolve) => {
-                    const child = spawn('git', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
-                    let stdout = '';
-                    let stderr = '';
-                    child.stdout?.on('data', (d) => (stdout += d.toString()));
-                    child.stderr?.on('data', (d) => (stderr += d.toString()));
-                    child.on('close', (code) => resolve({ stdout: stdout.trim(), exitCode: code ?? 1 }));
-                    child.on('error', () => resolve({ stdout: '', exitCode: 1 }));
-                });
-            };
-            // Get current branch in main repo
-            const branchResult = await execGit(['branch', '--show-current'], mainRepoPath);
-            const currentBranch = branchResult.stdout;
-            // Get git status
-            const statusResult = await execGit(['status', '--porcelain'], mainRepoPath);
-            const hasUncommittedChanges = statusResult.stdout.length > 0;
-            // Check if the feature branch commits are in the current branch
-            const featureBranch = worktree.branchName;
-            const logResult = await execGit(['log', '--oneline', '-20', '--grep', featureBranch], mainRepoPath);
-            // Also check for recent merge commits
-            const mergeLogResult = await execGit(['log', '--oneline', '-5', '--merges'], mainRepoPath);
-            // Get the latest commit hash
-            const headResult = await execGit(['rev-parse', 'HEAD'], mainRepoPath);
-            const latestCommit = headResult.stdout;
-            // Parse execution logs to check for MERGE_STATUS
-            let aiReportedSuccess = false;
-            let aiReportedFailure = false;
-            try {
-                const execLogs = await this.agentService.getPersistedExecutionLogs(executionId);
-                const logText = execLogs.logs.map((l) => l.message || '').join('\n');
-                if (logText.includes('MERGE_STATUS: SUCCESS')) {
-                    aiReportedSuccess = true;
-                }
-                if (logText.includes('MERGE_STATUS: FAILED') || logText.includes('unable to proceed')) {
-                    aiReportedFailure = true;
-                }
-            }
-            catch {
-                // Ignore log parsing errors
-            }
-            // Determine success based on multiple signals
-            if (aiReportedFailure) {
-                return { success: false, error: 'AI reported merge failure' };
-            }
-            if (hasUncommittedChanges) {
-                return { success: false, error: 'Main repo has uncommitted changes after merge' };
-            }
-            // Check if we're on main/master and feature branch content was merged
-            const isOnMainBranch = ['main', 'master'].includes(currentBranch);
-            if (!isOnMainBranch && !aiReportedSuccess) {
-                return {
-                    success: false,
-                    error: `Not on main branch after merge (current: ${currentBranch})`,
-                };
-            }
-            // If AI reported success or we detect merge evidence, consider it successful
-            const hasMergeEvidence = mergeLogResult.stdout.includes(featureBranch) ||
-                logResult.stdout.length > 0 ||
-                aiReportedSuccess;
-            if (hasMergeEvidence || aiReportedSuccess) {
-                log.info('Merge verification passed', { taskId, currentBranch, latestCommit, aiReportedSuccess }, 'vibing-orchestrator');
-                return { success: true, mergeCommit: latestCommit };
-            }
-            // Fallback: if status is clean and we're on main, accept it
-            if (isOnMainBranch && !hasUncommittedChanges) {
-                log.info('Merge verification passed (clean state)', { taskId, currentBranch }, 'vibing-orchestrator');
-                return { success: true, mergeCommit: latestCommit };
-            }
-            return {
-                success: false,
-                error: 'Could not verify merge completion - no merge evidence found',
-            };
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            log.error('Merge verification error', { taskId, error: msg }, 'vibing-orchestrator');
-            return { success: false, error: `Verification error: ${msg}` };
-        }
-    }
-    /**
-     * Public: run merge phase on demand
-     * This will attempt merge regardless of current phase.
-     */
-    async runMerge(workflowId, options) {
-        const workflow = this.workflows.get(workflowId);
-        if (!workflow)
-            throw new Error(`Workflow ${workflowId} not found`);
-        await this.executeMerge(workflowId, { provider: options?.provider, model: options?.model });
-    }
-    /**
-     * Execute cleanup phase: remove worktree/branch and finalize workflow
-     * Note: FSM has already transitioned to 'done' via MERGE_SUCCESS event
-     */
-    async executeCleanup(workflowId) {
-        const workflow = this.workflows.get(workflowId);
-        if (!workflow)
-            return;
-        // Update UI phase for timeline display
-        workflow.status = 'cleaning';
-        this.updateUIPhase(workflow, 'cleaning');
-        try {
-            log.info('Cleaning up resources', { taskId: workflow.taskId }, 'vibing-orchestrator');
-            // Remove worktree and local branch if present
-            try {
-                await this.worktreeService.deleteWorktree(workflow.taskId, true);
-            }
-            catch (err) {
-                log.warn('Cleanup encountered an issue (continuing)', err, 'vibing-orchestrator');
-            }
-            // Finalize workflow - update UI phases
-            workflow.status = 'cleaned';
-            workflow.endTime = new Date().toISOString();
-            this.updateUIPhase(workflow, 'cleaned');
-            // Dispatch FSM event for cleanup completion
-            await this.dispatch(workflowId, { type: 'CLEAN_SUCCESS' });
-            workflow.status = 'completed';
-            this.updateUIPhase(workflow, 'completed');
-            await this.saveWorkflow(workflow);
-            this.emit('workflowCompleted', workflow);
-            log.info('Workflow completed', { taskId: workflow.taskId }, 'vibing-orchestrator');
-        }
-        catch (error) {
-            log.error('Cleanup failed', error, 'vibing-orchestrator');
-            workflow.error = error instanceof Error ? error.message : String(error);
-            workflow.failureContext = {
-                atPhase: 'cleaning',
-                error: workflow.error,
-                timestamp: new Date().toISOString(),
-            };
-            // Dispatch failure event
-            await this.dispatch(workflowId, {
-                type: 'CLEAN_FAIL',
-                error: workflow.error,
-            });
-            workflow.status = 'failed';
-            this.updateUIPhase(workflow, 'failed');
-            await this.saveWorkflow(workflow);
-            this.emit('workflowFailed', workflow);
-        }
-    }
-    /**
-     * Public: run cleanup phase on demand
-     */
-    async runCleanup(workflowId) {
-        const workflow = this.workflows.get(workflowId);
-        if (!workflow)
-            throw new Error(`Workflow ${workflowId} not found`);
-        await this.executeCleanup(workflowId);
-    }
-    /**
-     * Public: manually skip to next phase
-     */
-    async skipToNextPhase(workflowId) {
-        const workflow = this.workflows.get(workflowId);
-        if (!workflow)
-            throw new Error(`Workflow ${workflowId} not found`);
-        // If anything is currently running for this task, stop it to move on quickly
-        try {
-            const executions = this.agentService.getTaskExecutions(workflow.taskId) || [];
-            const running = executions
-                .filter((e) => e.status === 'running')
-                .sort((a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime())[0];
-            if (running?.id) {
-                await this.agentService.stopExecution(running.id);
-            }
-        }
-        catch (error) {
-            log.warn('Failed to stop execution before skipping phase', error, 'vibing-orchestrator');
-        }
-        // Determine the base phase to compute the "next" from.
-        // For paused/failed, use the last known operational phase.
-        const lastTransitionTo = workflow.phaseHistory?.[workflow.phaseHistory.length - 1]?.to;
-        const basePhase = workflow.phase === 'paused'
-            ? lastTransitionTo || workflow.lastPhase || 'draft'
-            : workflow.phase === 'failed'
-                ? (workflow.failureContext?.atPhase ||
-                    workflow.lastPhase ||
-                    lastTransitionTo ||
-                    'implementing')
-                : workflow.phase;
-        const ordered = [
-            'draft',
-            'implementing',
-            'validating',
-            'ai-reviewing',
-            'awaiting-review',
-            'approved',
-            'merging',
-            'merged',
-            'cleaning',
-            'completed',
-            // 'failed' and 'paused' are non-linear; excluded from the sequence
-        ];
-        const idx = ordered.indexOf(basePhase);
-        const nextPhase = idx >= 0 && idx < ordered.length - 1 ? ordered[idx + 1] : 'completed';
-        if (nextPhase && nextPhase !== workflow.phase) {
-            log.info('Manually skipping workflow phase', { workflowId, currentPhase: workflow.phase, basePhase, nextPhase }, 'vibing-orchestrator');
-            // Update UI phase directly for skipping (FSM dispatch may not support all UI phases)
-            this.updateUIPhase(workflow, nextPhase);
-            await this.saveWorkflow(workflow);
-            // Immediately kick off the next phase where applicable to make skipping faster
-            switch (nextPhase) {
-                case 'implementing':
-                    await this.dispatch(workflowId, { type: 'RETRY' });
-                    break;
-                case 'validating':
-                    await this.executeValidation(workflowId);
-                    break;
-                case 'ai-reviewing':
-                    await this.executeAiReviewPhase(workflowId);
-                    break;
-                case 'approved':
-                case 'merging':
-                    await this.executeMerge(workflowId);
-                    break;
-                case 'merged':
-                case 'cleaning':
-                    await this.executeCleanup(workflowId);
-                    break;
-                case 'awaiting-review':
-                case 'completed':
-                default:
-                    // No immediate action; awaiting-review waits for human approval; completed is terminal
-                    break;
-            }
-        }
-    }
-    /**
-     * Wait for an execution to complete
-     */
-    async waitForExecution(executionId, timeoutMs = 30 * 60 * 1000) {
-        const startTime = Date.now();
-        let missingStatusWarned = false;
-        while (Date.now() - startTime < timeoutMs) {
-            const execution = this.agentService.getExecutionStatus(executionId);
-            if (!execution) {
-                if (!missingStatusWarned) {
-                    log.debug('Execution status not yet available; waiting for agent to register', { executionId }, 'vibing-orchestrator');
-                    missingStatusWarned = true;
-                }
-                await new Promise((resolve) => setTimeout(resolve, 500));
-                continue;
-            }
-            missingStatusWarned = false;
-            if (['completed', 'failed', 'cancelled'].includes(execution.status)) {
-                return;
-            }
-            // Wait 5 seconds before checking again
-            await new Promise((resolve) => setTimeout(resolve, 5000));
-        }
-        throw new Error(`Execution ${executionId} timed out after ${timeoutMs}ms`);
-    }
-    /**
-     * Wait for the AgentService to emit an executionCreated event for the given task/workflow
-     */
-    waitForExecutionCreated(taskId, workflowId, timeoutMs = 15000) {
-        return new Promise((resolve, reject) => {
-            const onCreated = (data) => {
-                try {
-                    if (data.taskId !== taskId)
-                        return;
-                    if (workflowId && data.workflowId !== workflowId)
-                        return;
-                    cleanup();
-                    resolve(data.executionId);
-                }
-                catch (err) {
-                    cleanup();
-                    reject(err instanceof Error ? err : new Error(String(err)));
-                }
-            };
-            const cleanup = () => {
-                clearTimeout(timer);
-                this.agentService.off('executionCreated', onCreated);
-            };
-            const timer = setTimeout(() => {
-                cleanup();
-                reject(new Error('Timed out waiting for executionCreated event'));
-            }, timeoutMs);
-            this.agentService.on('executionCreated', onCreated);
-        });
-    }
-    /**
-     * Get workflow statistics
-     */
-    getWorkflowStats() {
-        const workflows = Array.from(this.workflows.values());
-        const stats = {
-            total: workflows.length,
-            byPhase: {},
-            active: 0,
-            completed: 0,
-            failed: 0,
-        };
-        // Initialize phase counts
-        const phases = [
-            'draft',
-            'implementing',
-            'validating',
-            'ai-reviewing',
-            'awaiting-review',
-            'paused',
-            'approved',
-            'merging',
-            'merged',
-            'cleaning',
-            'completed',
-            'failed',
-        ];
-        phases.forEach((phase) => {
-            stats.byPhase[phase] = 0;
-        });
-        // Count workflows by phase
-        workflows.forEach((workflow) => {
-            stats.byPhase[workflow.phase]++;
-            if ([
-                'implementing',
-                'validating',
-                'ai-reviewing',
-                'awaiting-review',
-                'approved',
-                'merging',
-                'cleaning',
-            ].includes(workflow.phase)) {
-                stats.active++;
-            }
-            else if (['completed', 'merged'].includes(workflow.phase)) {
-                stats.completed++;
-            }
-            else if (workflow.phase === 'failed') {
-                stats.failed++;
-            }
-        });
-        return stats;
-    }
-    /**
-     * Get workflow persistence information
-     */
-    getWorkflowPersistenceInfo() {
-        return {
-            filePath: this.workflowDB.getFilePath(),
-            workflowCount: this.workflows.size,
-        };
-    }
-    /**
-     * Force save all workflows to disk
-     */
-    async saveAllWorkflows() {
-        const obj = {};
-        for (const [id, wf] of this.workflows)
-            obj[id] = serializeVibe(wf);
-        await this.workflowDB.setAll(obj);
-    }
-    /**
-     * Reload workflows from disk
-     */
-    async reloadWorkflows() {
-        const all = await this.workflowDB.getAll();
-        const map = new Map();
-        for (const [id, wf] of Object.entries(all)) {
-            map.set(id, this.normalizeWorkflow(wf));
-        }
-        this.workflows = map;
-        log.info('Reloaded workflows from disk', { count: this.workflows.size }, 'vibing-orchestrator');
-    }
-    /**
-     * Remove workflows by task ID
-     */
-    async removeWorkflowsByTask(taskId) {
-        const all = await this.workflowDB.getAll();
-        let removedCount = 0;
-        for (const [id, workflow] of Object.entries(all)) {
-            if (workflow.taskId === taskId) {
-                delete all[id];
-                removedCount++;
-            }
-        }
-        if (removedCount > 0) {
-            await this.workflowDB.setAll(all);
-        }
-        // Also remove from memory
-        for (const [id, workflow] of this.workflows) {
-            if (workflow.taskId === taskId) {
-                this.workflows.delete(id);
-            }
-        }
-        return removedCount;
-    }
-    /**
-     * Get comprehensive workflow statistics
-     */
-    async getDetailedStats() {
-        return {
-            memoryStats: this.getWorkflowStats(),
-            persistenceStats: await getDbStats(this.workflowDB),
-            persistencePath: this.workflowDB.getFilePath(),
-        };
-    }
-    /**
-     * Update workflow options without changing phase
-     */
-    async updateWorkflowOptions(workflowId, config) {
-        const workflow = this.workflows.get(workflowId);
-        if (!workflow) {
-            throw new Error(`Workflow ${workflowId} not found`);
-        }
-        // Update metadata with new config
-        workflow.metadata = { ...workflow.metadata, ...config };
-        // Persist the updated workflow
-        await this.saveWorkflow(workflow);
-        log.info('Updated workflow options', { workflowId }, 'vibing-orchestrator');
-        this.emit('workflowOptionsUpdated', workflow);
-    }
-    /**
-     * Continue workflow execution from current state
-     * Uses the new state machine to determine the next action
-     */
-    async continueWorkflow(workflowId) {
-        const workflow = this.workflows.get(workflowId);
-        if (!workflow) {
-            throw new Error(`Workflow ${workflowId} not found`);
-        }
-        // Use new state machine to compute next action
-        const nextAction = this.getNextAction(workflowId);
-        log.info('Continuing workflow (state-machine-driven)', {
-            workflowId,
-            phase: workflow.phase,
-            status: workflow.status,
-            nextAction: nextAction?.action,
-        }, 'vibing-orchestrator');
-        if (!nextAction || nextAction.action === 'none') {
-            log.info('No actionable next step', {
-                workflowId,
-                phase: workflow.phase,
-                reason: nextAction?.action === 'none' ? nextAction.reason : 'null action',
-            }, 'vibing-orchestrator');
-            return;
-        }
-        switch (nextAction.action) {
-            case 'implementing':
-                await this.executeImplementation(workflowId, nextAction.feedback);
-                return;
-            case 'validating':
-                await this.executeValidation(workflowId);
-                return;
-            case 'ai-reviewing':
-                await this.executeAiReviewPhase(workflowId);
-                return;
-            case 'awaiting-approval':
-                await this.executeAwaitingReview(workflowId);
-                return;
-            case 'merging':
-                await this.executeMerge(workflowId);
-                return;
-            case 'cleanup':
-                await this.executeCleanup(workflowId);
-                return;
-            default:
-                log.warn('Unknown next action from state machine', { workflowId, action: nextAction.action }, 'vibing-orchestrator');
-        }
-    }
-    // ============ Small helpers to reduce duplication ============
-    requireWorkflow(workflowId) {
-        const wf = this.workflows.get(workflowId);
-        if (!wf)
-            throw new Error(`Workflow ${workflowId} not found`);
-        return wf;
-    }
-    async getAIReviewThreshold() {
-        try {
-            const settingsService = getSettingsService();
-            await settingsService.initialize();
-            const settings = settingsService.getSettings();
-            return settings.agents.judgeAgent.reviewThresholdScore;
-        }
-        catch (error) {
-            log.warn('Failed to load AI review threshold from settings, using default', error, 'vibing-orchestrator');
-            return 70; // fallback default
-        }
-    }
-    assertPhase(workflow, expected, action) {
-        if (workflow.phase !== expected) {
-            throw new Error(`Cannot ${action} workflow in phase ${workflow.phase}; expected ${expected}`);
-        }
-    }
-    createNewWorkflow(workflowId, taskId, config) {
-        const now = new Date().toISOString();
-        const wf = {
-            id: workflowId,
-            taskId,
-            phase: 'draft',
-            startTime: now,
-            endTime: undefined,
-            status: 'draft',
-            // Phase tracking
-            lastPhase: undefined,
-            phaseHistory: [],
-            failureContext: undefined,
-            // Execution tracking and attempts per phase
-            executionIds: {
-                implementing: [],
-                validating: [],
-                'ai-reviewing': [],
-                merging: [],
-            },
-            attempts: {},
-            // Rerun context audit trail
-            rerunContextHistory: [],
-            // Quality + links placeholders
-            qualityResults: undefined,
-            links: {},
-            // Error placeholder
-            error: undefined,
-            // Observability/metrics
-            metrics: { durationsMs: {}, lastPhaseStartedAt: now },
-            lastUpdatedAt: now,
-            // Persisted workflow configuration
-            metadata: config,
-            // Initial timeline marker
-            timeline: [
-                {
-                    id: 'start',
-                    label: 'Workflow started',
-                    phase: 'draft',
-                    startTime: now,
-                },
-            ],
-        };
-        // Seed placeholders for the rest of the flow
-        wf.timeline = this.computeVisibleTimeline(wf);
-        return wf;
-    }
-    async maybeRetryImplementation(workflowId, reason, _atPhase) {
-        const workflow = this.requireWorkflow(workflowId);
-        // In step-by-step mode, do not auto-retry; wait for explicit Continue
-        if (workflow.metadata.stepByStepMode) {
-            log.info('Step-by-step mode: skipping auto-retry of implementation', { workflowId, reason }, 'vibing-orchestrator');
-            return false;
-        }
-        const max = workflow.metadata.retryPolicy?.maxImplementationAttempts || 0;
-        const implementingCount = (workflow.phaseHistory || []).filter((h) => h.to === 'implementing').length;
-        if (max > 0 && implementingCount < max) {
-            // Store reason in failureContext for the implementation to use
-            workflow.failureContext = {
-                atPhase: workflow.phase,
-                error: reason,
-                timestamp: new Date().toISOString(),
-            };
-            // Dispatch RETRY event - reducer handles transition and triggers EXECUTE_IMPLEMENTATION effect
-            await this.dispatch(workflowId, { type: 'RETRY' });
-            return true;
-        }
-        return false;
-    }
-    async handlePhaseFailure(workflowId, atPhase, error) {
-        const workflow = this.requireWorkflow(workflowId);
-        const msg = error instanceof Error ? error.message : String(error);
-        log.error(`${atPhase} failed`, error, 'vibing-orchestrator');
-        workflow.error = msg;
-        workflow.failureContext = {
-            atPhase,
-            error: msg,
-            timestamp: new Date().toISOString(),
-        };
-        // Attach reason to last timeline item of this phase
-        const wf = this.workflows.get(workflowId);
-        if (wf && Array.isArray(wf.timeline)) {
-            for (let i = wf.timeline.length - 1; i >= 0; i--) {
-                const t = wf.timeline[i];
-                if (t.phase === atPhase) {
-                    t.reason = msg;
-                    break;
-                }
-            }
-            await this.saveWorkflow(wf);
-        }
-        // Dispatch appropriate failure event based on phase
-        const failEvent = this.getFailEventForPhase(atPhase, msg);
-        if (failEvent) {
-            await this.dispatch(workflowId, failEvent);
-        }
-        // Update UI phase
-        workflow.status = 'failed';
-        this.updateUIPhase(workflow, 'failed');
-        await this.saveWorkflow(workflow);
-        this.emit('workflowFailed', workflow);
-    }
-    getFailEventForPhase(phase, error) {
-        switch (phase) {
-            case 'implementing':
-                return { type: 'IMPL_FAIL', error, canRetry: false };
-            case 'validating':
-                return { type: 'VALID_FAIL', error };
-            case 'merging':
-                return { type: 'MERGE_FAIL', error };
-            case 'cleaning':
-                return { type: 'CLEAN_FAIL', error };
-            default:
-                return null;
-        }
-    }
-    /**
-     * Get the agent service instance
-     */
-    getAgentService() {
-        return this.agentService;
-    }
-}
-// Helpers local to this module
-function serializeVibe(workflow) {
-    return {
-        ...workflow,
-        startTime: new Date(workflow.startTime).toISOString(),
-        endTime: workflow.endTime ? new Date(workflow.endTime).toISOString() : undefined,
-        qualityResults: workflow.qualityResults
-            ? {
-                ...workflow.qualityResults,
-                timestamp: new Date(workflow.qualityResults.timestamp).toISOString(),
-            }
-            : undefined,
-        aiReviewResult: workflow.aiReviewResult
-            ? {
-                ...workflow.aiReviewResult,
-                timestamp: workflow.aiReviewResult.timestamp
-                    ? new Date(workflow.aiReviewResult.timestamp).toISOString()
-                    : undefined,
-            }
-            : undefined,
-    };
-}
-async function getDbStats(db) {
-    const all = await db.getAll();
-    const stats = {
-        total: 0,
-        byPhase: {},
-        oldestWorkflow: undefined,
-        newestWorkflow: undefined,
-    };
-    let oldest = null;
-    let newest = null;
-    for (const wf of Object.values(all)) {
-        stats.total += 1;
-        stats.byPhase[wf.phase] = (stats.byPhase[wf.phase] || 0) + 1;
-        const start = new Date(wf.startTime);
-        if (!oldest || start < oldest) {
-            oldest = start;
-            stats.oldestWorkflow = wf.id;
-        }
-        if (!newest || start > newest) {
-            newest = start;
-            stats.newestWorkflow = wf.id;
-        }
-    }
-    return stats;
-}