vibeman 0.0.3 → 0.0.6

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

@@ -1,1891 +0,0 @@
-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) {
-                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,
-        };
-        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);
-            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');
-            // 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 },
-            };
-            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
-     */
-    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,
-            });
-            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');
-            // 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,
-        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;
-}