vibeman 0.0.0 → 0.0.2

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

@@ -0,0 +1,1860 @@
+import { EventEmitter } from 'events';
+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';
+// Canonical phase flow and labels for server-driven timeline and placeholders
+// Action phases only; placeholders are created for these
+const PHASE_FLOW = [
+    'implementing',
+    'validating',
+    'ai-reviewing',
+    // Show awaiting-review explicitly in the main flow so the timeline
+    // reflects the human approval step in order
+    'awaiting-review',
+    'merging',
+    'cleaning',
+];
+const PHASE_LABELS = {
+    draft: 'Workflow started',
+    implementing: 'Implementation',
+    implemented: 'Implemented',
+    validating: 'Validation',
+    validated: 'Validated',
+    'ai-reviewing': 'AI Review',
+    'ai-reviewed': 'AI Reviewed',
+    'awaiting-review': 'Awaiting Review',
+    paused: 'Paused',
+    approved: 'Approved',
+    merging: 'Merge',
+    merged: 'Merged',
+    cleaning: 'Cleaning',
+    cleaned: 'Cleaned',
+    completed: 'Completed',
+    failed: 'Failed',
+};
+// 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.qualityPipeline = new QualityPipeline();
+        // Persist workflows in a JSON file using the generic database service
+        const filePath = persistenceDataDir
+            ? path.join(persistenceDataDir, 'workflows.json')
+            : path.join(getVibeDir(), 'workflows.json');
+        this.workflowDB = new DatabaseService(filePath);
+        // 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');
+        }
+        catch (error) {
+            log.warn('Failed to load workflows from disk', error, 'vibing-orchestrator');
+        }
+        this.initialized = true;
+    }
+    // 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;
+    }
+    /**
+     * 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 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 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) {
+                wf.metadata = {
+                    ...wf.metadata,
+                    aiReviewResult: { ...res, timestamp: new Date().toISOString() },
+                };
+                // 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,
+        };
+        workflow.endTime = new Date().toISOString();
+        await this.transitionToPhase(workflowId, 'completed');
+        this.emit('workflowCompleted', workflow);
+        log.info('Workflow marked completed by human', { taskId: workflow.taskId }, 'vibing-orchestrator');
+        await this.saveWorkflow(workflow);
+    }
+    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');
+            }
+        }
+        workflow.phase = 'paused';
+        workflow.error = 'Paused by user';
+        workflow.status = 'paused';
+        // Persist the workflow state
+        await this.saveWorkflow(workflow);
+        this.emit('workflowPaused', workflow);
+        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
+        try {
+            const tl = (workflow.timeline || []);
+            for (let i = tl.length - 1; i >= 0; i--) {
+                const t = tl[i];
+                if (t.phase === 'awaiting-review' && !t.placeholder && !t.endTime) {
+                    t.endTime = new Date().toISOString();
+                    break;
+                }
+            }
+            workflow.timeline = this.computeVisibleTimeline(workflow);
+            await this.saveWorkflow(workflow);
+        }
+        catch (err) {
+            log.debug('Failed to finalize awaiting-review timeline item', err, 'vibing-orchestrator');
+        }
+        workflow.status = 'approved';
+        workflow.lastUpdatedAt = new Date().toISOString();
+        await this.transitionToPhase(workflowId, 'approved');
+        await this.saveWorkflow(workflow);
+        if (workflow.metadata.stepByStepMode) {
+            log.info('Manual step mode – approved; waiting for Continue to run merge', { workflowId }, 'vibing-orchestrator');
+        }
+        else {
+            await this.executeMerge(workflowId);
+        }
+    }
+    /**
+     * 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
+        try {
+            const tl = (workflow.timeline || []);
+            for (let i = tl.length - 1; i >= 0; i--) {
+                const t = tl[i];
+                if (t.phase === 'awaiting-review' && !t.placeholder && !t.endTime) {
+                    t.endTime = new Date().toISOString();
+                    break;
+                }
+            }
+            workflow.timeline = this.computeVisibleTimeline(workflow);
+            await this.saveWorkflow(workflow);
+        }
+        catch (err) {
+            log.debug('Failed to finalize awaiting-review timeline item', err, 'vibing-orchestrator');
+        }
+        // Return to implementation phase with feedback
+        await this.transitionToPhase(workflowId, 'implementing');
+        await this.executeImplementation(workflowId, feedback);
+    }
+    /**
+     * 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;
+    }
+    /**
+     * Transition workflow to new phase
+     */
+    async transitionToPhase(workflowId, newPhase) {
+        const workflow = this.workflows.get(workflowId);
+        if (!workflow)
+            return;
+        const oldPhase = workflow.phase;
+        workflow.lastPhase = oldPhase;
+        workflow.phase = newPhase;
+        const history = workflow.phaseHistory || [];
+        const now = new Date().toISOString();
+        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);
+        log.info('Workflow phase transition', { workflowId, oldPhase, newPhase }, 'vibing-orchestrator');
+        await this.saveWorkflow(workflow);
+        this.emit('workflowPhaseChanged', { workflowId, oldPhase, newPhase, workflow });
+    }
+    /**
+     * 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;
+        await this.transitionToPhase(workflowId, '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);
+            // 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,
+                        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');
+            // Update checkpoint status
+            workflow.status = 'implemented';
+            workflow.lastUpdatedAt = new Date().toISOString();
+            await this.saveWorkflow(workflow);
+            await this.transitionToPhase(workflowId, 'implemented');
+            if (workflow.metadata.stepByStepMode) {
+                log.info('Manual step mode – implemented; waiting for Continue to run validation', { workflowId }, 'vibing-orchestrator');
+            }
+            else {
+                await this.executeValidation(workflowId);
+            }
+        }
+        catch (error) {
+            await this.handlePhaseFailure(workflowId, 'implementing', error);
+        }
+    }
+    /**
+     * Public: re-run implementation phase on demand
+     * Forces phase to 'implementing' and executes implementation again.
+     */
+    async rerunImplementation(workflowId, feedback, providerOverride) {
+        const workflow = this.workflows.get(workflowId);
+        if (!workflow)
+            throw new Error(`Workflow ${workflowId} not found`);
+        await this.transitionToPhase(workflowId, 'implementing');
+        await this.executeImplementation(workflowId, feedback, providerOverride);
+    }
+    /**
+     * 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':
+                await this.transitionToPhase(workflowId, 'implementing');
+                await this.executeImplementation(workflowId);
+                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.executeImplementation(workflowId);
+                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 },
+            };
+            // 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
+     */
+    async executeAiReviewPhase(workflowId) {
+        const workflow = this.workflows.get(workflowId);
+        if (!workflow)
+            return;
+        await this.transitionToPhase(workflowId, '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;
+        await this.transitionToPhase(workflowId, 'awaiting-review');
+        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(),
+            });
+        }
+        workflow.timeline = this.computeVisibleTimeline(workflow);
+        await this.saveWorkflow(workflow);
+    }
+    /**
+     * Execute validation phase with quality checks
+     */
+    async executeValidation(workflowId) {
+        const workflow = this.workflows.get(workflowId);
+        if (!workflow)
+            return;
+        await this.transitionToPhase(workflowId, '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,
+            });
+            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');
+            // Update checkpoint status
+            await this.transitionToPhase(workflowId, 'validated');
+            workflow.status = 'validated';
+            workflow.lastUpdatedAt = new Date().toISOString();
+            await this.saveWorkflow(workflow);
+            if (workflow.metadata.aiCodeReview) {
+                if (workflow.metadata.stepByStepMode) {
+                    log.info('Manual step mode – waiting for Continue to run AI review', { workflowId }, 'vibing-orchestrator');
+                }
+                else {
+                    await this.executeAiReviewPhase(workflowId);
+                }
+            }
+        }
+        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
+     */
+    async executeMerge(workflowId, providerOverride) {
+        const workflow = this.workflows.get(workflowId);
+        if (!workflow)
+            return;
+        await this.transitionToPhase(workflowId, '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'}`);
+            }
+            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;
+                latest.timeline = this.computeVisibleTimeline(latest);
+                latest.lastUpdatedAt = new Date().toISOString();
+                await this.saveWorkflow(latest);
+            }
+            await this.taskService.updateTask(workflow.taskId, { status: 'done' });
+            await this.transitionToPhase(workflowId, 'merged');
+            const mergedWorkflow = this.workflows.get(workflowId);
+            if (mergedWorkflow) {
+                mergedWorkflow.status = 'merged';
+                mergedWorkflow.lastUpdatedAt = new Date().toISOString();
+                await this.saveWorkflow(mergedWorkflow);
+            }
+            if (workflow.metadata.stepByStepMode) {
+                log.info('Manual step mode – merge completed; waiting for Continue', { workflowId }, 'vibing-orchestrator');
+            }
+            else {
+                await this.updateCleanupStatus(workflowId);
+            }
+            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);
+        }
+    }
+    async updateCleanupStatus(workflowId) {
+        const workflow = this.workflows.get(workflowId);
+        if (!workflow)
+            return;
+        await this.transitionToPhase(workflowId, 'cleaning');
+        workflow.status = 'cleaning';
+        workflow.lastUpdatedAt = new Date().toISOString();
+        workflow.timeline = this.buildTimeline(workflow, {
+            id: `cleaning:${new Date().toISOString()}`,
+            label: 'Cleaning',
+            phase: 'cleaning',
+            startTime: new Date().toISOString(),
+        });
+        await this.saveWorkflow(workflow);
+        this.emit('workflowUpdated', workflow);
+    }
+    /**
+     * 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
+     */
+    async executeCleanup(workflowId) {
+        const workflow = this.workflows.get(workflowId);
+        if (!workflow)
+            return;
+        await this.transitionToPhase(workflowId, '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
+            workflow.status = 'cleaned';
+            workflow.endTime = new Date().toISOString();
+            await this.transitionToPhase(workflowId, 'cleaned');
+            workflow.status = 'completed';
+            workflow.lastUpdatedAt = new Date().toISOString();
+            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(),
+            };
+            await this.transitionToPhase(workflowId, 'failed');
+            workflow.status = 'failed';
+            workflow.lastUpdatedAt = new Date().toISOString();
+            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');
+            await this.transitionToPhase(workflowId, nextPhase);
+            // Immediately kick off the next phase where applicable to make skipping faster
+            switch (nextPhase) {
+                case 'implementing':
+                    await this.executeImplementation(workflowId);
+                    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
+     */
+    async continueWorkflow(workflowId) {
+        const workflow = this.workflows.get(workflowId);
+        if (!workflow) {
+            throw new Error(`Workflow ${workflowId} not found`);
+        }
+        log.info('Continuing workflow (status-driven)', { workflowId, phase: workflow.phase, status: workflow.status }, 'vibing-orchestrator');
+        // If failed, prefer immediate retry of implementation
+        if (workflow.phase === 'failed' || workflow.status === 'failed') {
+            if (workflow.metadata.stepByStepMode) {
+                await this.rerunImplementation(workflowId);
+            }
+            else {
+                await this.executeImplementation(workflowId);
+            }
+            return;
+        }
+        // Compute next actionable phase from status/checkpoint
+        const next = this.computeNextActionPhase(workflow);
+        if (!next) {
+            log.info('No actionable next phase (waiting for human or already done)', { workflowId, phase: workflow.phase, status: workflow.status }, 'vibing-orchestrator');
+            return;
+        }
+        switch (next) {
+            case 'implementing':
+                await this.executeImplementation(workflowId);
+                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 'cleaning':
+                await this.executeCleanup(workflowId);
+                return;
+            default:
+                throw new Error(`Unsupported next phase computed: ${next}`);
+        }
+    }
+    // Decide next action from status/checkpoint and configuration
+    computeNextActionPhase(workflow) {
+        const status = workflow.status;
+        const cfg = workflow.metadata || {};
+        const requireHuman = !!cfg.requireHumanApproval;
+        const wantsAIReview = !!cfg.aiCodeReview;
+        // If paused, compute by last checkpoint
+        // If failed handling is done earlier
+        switch (status) {
+            case undefined:
+            case 'draft':
+                return 'implementing';
+            case 'implemented':
+                return 'validating';
+            case 'validated':
+                if (wantsAIReview)
+                    return 'ai-reviewing';
+                return requireHuman ? null : 'merging';
+            case 'ai-reviewed':
+                return requireHuman ? null : 'merging';
+            case 'awaiting-review':
+                return null; // wait for approveWorkflow
+            case 'approved':
+                return 'merging';
+            case 'merged':
+                return 'cleaning';
+            case 'cleaned':
+                return 'completed';
+            case 'completed':
+                return null;
+            case 'paused':
+                // Map paused to next by lastPhase or default to implementing
+                return workflow.lastPhase || 'implementing';
+            case 'failed':
+                return 'implementing';
+            default:
+                return null;
+        }
+    }
+    // ============ 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) {
+            await this.transitionToPhase(workflowId, 'implementing');
+            await this.executeImplementation(workflowId, reason);
+            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);
+        }
+        await this.transitionToPhase(workflowId, 'failed');
+        workflow.status = 'failed';
+        workflow.lastUpdatedAt = new Date().toISOString();
+        await this.saveWorkflow(workflow);
+        this.emit('workflowFailed', workflow);
+    }
+    /**
+     * 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,
+    };
+}
+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;
+}