vibeman 0.0.1 → 0.0.3

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

@@ -313,19 +313,22 @@ export class VibingOrchestrator extends EventEmitter {
         }
         return res;
     }
-    async reviewCode(taskId, reviewContext, options) {
-        const res = await this.agentService.reviewCode(taskId, reviewContext, {
-            provider: options?.provider,
-            model: options?.model,
+    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: new Date().toISOString() },
+                    aiReviewResult: { ...res, timestamp },
                 };
+                wf.aiReviewResult = { ...res, timestamp };
                 // Record execution ID under ai-reviewing for UI/observability
                 if (res?.executionId) {
                     wf.executionIds = wf.executionIds || {};
@@ -338,17 +341,15 @@ export class VibingOrchestrator extends EventEmitter {
         return res;
     }
     async aiMerge(taskId, options) {
-        const res = await this.agentService.aiMerge(taskId, { baseBranch: options?.baseBranch }, { provider: options?.provider, model: options?.model });
-        if (options?.workflowId) {
-            const wf = this.workflows.get(options.workflowId);
-            if (wf) {
-                wf.executionIds = wf.executionIds || {};
-                const list = wf.executionIds['merging'] || [];
-                wf.executionIds['merging'] = [...list, res.executionId];
-                await this.saveWorkflow(wf);
-            }
-        }
-        return res;
+        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() {
@@ -702,27 +703,7 @@ export class VibingOrchestrator extends EventEmitter {
             metrics.totalDurationMs = Object.values(metrics.durationsMs || {}).reduce((a, b) => a + (b || 0), 0);
         }
         workflow.lastUpdatedAt = now;
-        // If entering awaiting-review, add a real timeline item so the UI
-        // can expose review controls (instead of a placeholder that hides actions)
-        if (newPhase === '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:${now}`,
-                    label: PHASE_LABELS['awaiting-review'],
-                    phase: 'awaiting-review',
-                    startTime: now,
-                });
-            }
-            else {
-                workflow.timeline = this.computeVisibleTimeline(workflow);
-            }
-        }
-        else {
-            workflow.timeline = this.computeVisibleTimeline(workflow);
-        }
+        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 });
@@ -758,6 +739,14 @@ export class VibingOrchestrator extends EventEmitter {
                 (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
@@ -769,10 +758,12 @@ export class VibingOrchestrator extends EventEmitter {
                         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;
@@ -851,29 +842,26 @@ export class VibingOrchestrator extends EventEmitter {
                 await this.executeImplementation(workflowId);
                 return;
             case 'validating':
-                await this.transitionToPhase(workflowId, 'validating');
                 await this.executeValidation(workflowId);
                 return;
             case 'ai-reviewing':
-                await this.transitionToPhase(workflowId, 'ai-reviewing');
                 await this.executeAiReviewPhase(workflowId);
                 return;
+            case 'awaiting-review':
+                await this.executeAwaitingReview(workflowId);
+                return;
             case 'merging':
-                await this.transitionToPhase(workflowId, 'merging');
                 await this.executeMerge(workflowId);
                 return;
             case 'approved':
                 // Failure after approval typically means merge failed; try merging again
-                await this.transitionToPhase(workflowId, 'approved');
                 await this.executeMerge(workflowId);
                 return;
             case 'cleaning':
-                await this.transitionToPhase(workflowId, 'cleaning');
                 await this.executeCleanup(workflowId);
                 return;
             default:
                 // For other phases, restart implementation as a safe default
-                await this.transitionToPhase(workflowId, 'implementing');
                 await this.executeImplementation(workflowId);
                 return;
         }
@@ -944,31 +932,39 @@ export class VibingOrchestrator extends EventEmitter {
     /**
      * Perform AI code review of implemented changes
      */
-    async performAICodeReview(workflowId) {
+    async performAICodeReview(workflowId, providedExecutionId) {
         const workflow = this.workflows.get(workflowId);
         if (!workflow)
-            return false;
+            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 true; // do not fail if worktree missing
+                return { passed: true, executionId: providedExecutionId };
             }
             // Execute AI code review via agent service
-            const review = await this.agentService.reviewCode(workflow.taskId, 'Automated AI code review triggered by workflow orchestrator', workflow.metadata?.aiRoutingOverrides?.ai_codereview);
+            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
-            if (review?.executionId) {
+            const executionId = providedExecutionId ?? review?.executionId;
+            if (executionId) {
                 workflow.executionIds = workflow.executionIds || {};
                 const list = workflow.executionIds['ai-reviewing'] || [];
-                workflow.executionIds['ai-reviewing'] = [...list, review.executionId];
+                if (!list.includes(executionId)) {
+                    workflow.executionIds['ai-reviewing'] = [...list, executionId];
+                }
             }
             await this.saveWorkflow(workflow);
             // Gate by minimum score from settings
@@ -977,10 +973,11 @@ export class VibingOrchestrator extends EventEmitter {
                 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 false;
+                return { passed: false, executionId };
             }
             log.info('AI code review passed', { score: review.qualityScore }, 'vibing-orchestrator');
-            return true;
+            workflow.error = undefined;
+            return { passed: true, executionId };
         }
         catch (error) {
             log.warn('AI code review failed', error, 'vibing-orchestrator');
@@ -989,7 +986,7 @@ export class VibingOrchestrator extends EventEmitter {
             if (workflowRef) {
                 workflowRef.error = `AI code review failed: ${msg}`;
             }
-            return false;
+            return { passed: false, executionId: providedExecutionId };
         }
     }
     /**
@@ -999,26 +996,42 @@ export class VibingOrchestrator extends EventEmitter {
         const workflow = this.workflows.get(workflowId);
         if (!workflow)
             return;
+        await this.transitionToPhase(workflowId, 'ai-reviewing');
         try {
-            const before = workflow.executionIds?.['ai-reviewing']?.length || 0;
-            const passed = await this.performAICodeReview(workflowId);
-            // If an executionId was recorded for ai-reviewing, add instantaneous timeline entry
-            const after = workflow.executionIds?.['ai-reviewing']?.length || 0;
-            if (after > before) {
-                const execId = (workflow.executionIds?.['ai-reviewing'] || [])[after - 1];
-                workflow.timeline = this.buildTimeline(workflow, {
-                    id: execId,
-                    label: after > 1 ? `AI Review – Retry #${after}` : 'AI Review',
-                    phase: 'ai-reviewing',
-                    attempt: after,
-                    executionId: execId,
-                    startTime: new Date().toISOString(),
-                    endTime: new Date().toISOString(),
-                    reason: !passed
-                        ? workflow.error || 'AI review did not pass the quality threshold'
-                        : undefined,
-                });
-                await this.saveWorkflow(workflow);
+            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';
@@ -1033,10 +1046,10 @@ export class VibingOrchestrator extends EventEmitter {
             workflow.lastUpdatedAt = new Date().toISOString();
             workflow.timeline = this.computeVisibleTimeline(workflow);
             await this.saveWorkflow(workflow);
-            await this.transitionToPhase(workflowId, 'awaiting-review');
             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');
@@ -1046,6 +1059,25 @@ export class VibingOrchestrator extends EventEmitter {
             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
      */
@@ -1056,51 +1088,10 @@ export class VibingOrchestrator extends EventEmitter {
         await this.transitionToPhase(workflowId, 'validating');
         try {
             if (!workflow.metadata.autoQualityChecks) {
-                log.info('Skipping quality checks (disabled)', { taskId: workflow.taskId }, 'vibing-orchestrator');
-                // Create a generic execution for consistency/observability
-                const worktree = this.agentService.getWorktreeInfo(workflow.taskId);
-                const workingDirectory = worktree?.path || process.cwd();
-                const execId = await this.agentService.startGenericExecution(workflow.taskId, {
-                    workflowId,
-                    workingDirectory,
-                });
-                // Track execution id for validating phase and timeline
-                workflow.executionIds = workflow.executionIds || {};
-                const list = workflow.executionIds['validating'] || [];
-                workflow.executionIds['validating'] = [...list, execId];
-                workflow.timeline = this.buildTimeline(workflow, {
-                    id: execId,
-                    label: list.length >= 1 ? `Validation – Retry #${list.length + 1}` : 'Validation',
-                    phase: 'validating',
-                    attempt: list.length + 1,
-                    executionId: execId,
-                    startTime: new Date().toISOString(),
-                    endTime: new Date().toISOString(),
-                    reason: 'Auto quality checks disabled; skipping validation',
-                });
-                await this.agentService.logGenericExecution(execId, '[validation] Auto quality checks disabled; skipping validation.');
-                await this.agentService.completeGenericExecution(execId, 'completed');
-                workflow.timeline = this.computeVisibleTimeline(workflow);
-                await this.saveWorkflow(workflow);
-                // Mark checkpoint as validated even when skipping checks
-                workflow.status = 'validated';
-                workflow.lastUpdatedAt = new Date().toISOString();
-                await this.saveWorkflow(workflow);
-                await this.transitionToPhase(workflowId, 'awaiting-review');
-                const wf = this.workflows.get(workflowId);
-                if (wf?.metadata.stepByStepMode) {
-                    log.info('Manual step mode – validation skipped; waiting for Continue (awaiting-review)', { workflowId }, 'vibing-orchestrator');
-                }
+                // TODO implement later
                 return;
             }
             log.info('Running quality checks', { taskId: workflow.taskId }, 'vibing-orchestrator');
-            // Timeline: start validation
-            workflow.timeline = this.buildTimeline(workflow, {
-                id: `validation:${new Date().toISOString()}`,
-                label: 'Validation',
-                phase: 'validating',
-                startTime: new Date().toISOString(),
-            });
             // Get worktree path for quality checks
             const worktree = this.agentService.getWorktreeInfo(workflow.taskId);
             const workingDirectory = worktree?.path || process.cwd();
@@ -1109,20 +1100,27 @@ export class VibingOrchestrator extends EventEmitter {
                 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];
-            // Tie timeline item to this execution id
-            {
-                const timeline = workflow.timeline;
-                const tIdx = timeline.length - 1;
-                if (tIdx >= 0) {
-                    const t = timeline[tIdx];
-                    if (t && t.phase === 'validating' && !t.executionId)
-                        t.executionId = execId;
-                }
-            }
-            workflow.timeline = this.computeVisibleTimeline(workflow);
+            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', {
@@ -1158,14 +1156,12 @@ export class VibingOrchestrator extends EventEmitter {
             });
             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;
-                    }
+            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)
@@ -1184,37 +1180,17 @@ export class VibingOrchestrator extends EventEmitter {
             }
             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);
-            // Move to AI review phase or directly to reviewing
             if (workflow.metadata.aiCodeReview) {
-                await this.transitionToPhase(workflowId, 'ai-reviewing');
                 if (workflow.metadata.stepByStepMode) {
                     log.info('Manual step mode – waiting for Continue to run AI review', { workflowId }, 'vibing-orchestrator');
                 }
                 else {
                     await this.executeAiReviewPhase(workflowId);
                 }
-                return;
-            }
-            await this.transitionToPhase(workflowId, 'validated');
-            // If manual step mode is off and human approval not required, auto-approve
-            if (!workflow.metadata.stepByStepMode && !workflow.metadata.requireHumanApproval) {
-                log.info('Auto-approving workflow (human approval disabled)', { workflowId }, 'vibing-orchestrator');
-                // Update checkpoint to approved
-                workflow.status = 'approved';
-                workflow.lastUpdatedAt = new Date().toISOString();
-                await this.saveWorkflow(workflow);
-                await this.approveWorkflow(workflowId);
-            }
-            else {
-                // Move into awaiting-review phase so UI shows review actions
-                await this.transitionToPhase(workflowId, 'awaiting-review');
-                workflow.status = 'awaiting-review';
-                workflow.lastUpdatedAt = new Date().toISOString();
-                await this.saveWorkflow(workflow);
-                this.emit('workflowReadyForReview', workflow);
             }
         }
         catch (error) {
@@ -1238,57 +1214,102 @@ export class VibingOrchestrator extends EventEmitter {
         if (!workflow)
             return;
         await this.transitionToPhase(workflowId, 'merging');
+        let executionId;
         try {
             log.info('AI merging changes', { taskId: workflow.taskId }, 'vibing-orchestrator');
-            // AI-assisted merge to avoid raw git conflicts
-            const { executionId } = await this.agentService.aiMerge(workflow.taskId, { baseBranch: 'main' }, providerOverride || workflow.metadata?.aiRoutingOverrides?.ai_merge);
+            const mergeList = workflow.executionIds?.['merging'] || [];
+            const attempt = mergeList.length + 1;
+            executionId = generateId('merge');
+            const startTime = new Date().toISOString();
             workflow.executionIds = workflow.executionIds || {};
-            const mergeList = workflow.executionIds['merging'] || [];
             workflow.executionIds['merging'] = [...mergeList, executionId];
-            // Timeline: record merge attempt start
             workflow.timeline = this.buildTimeline(workflow, {
                 id: executionId,
-                label: mergeList.length >= 1 ? `Merge – Retry #${mergeList.length + 1}` : 'Merge',
+                label: attempt > 1 ? `Merge – Retry #${attempt}` : 'Merge',
                 phase: 'merging',
-                attempt: mergeList.length + 1,
+                attempt,
                 executionId,
-                startTime: new Date().toISOString(),
+                startTime,
             });
+            workflow.lastUpdatedAt = startTime;
             await this.saveWorkflow(workflow);
-            // Notify listeners that a merge execution for this workflow has started
+            this.emit('workflowUpdated', workflow);
             this.emit('workflowExecutionStarted', {
                 workflowId,
                 executionId,
                 phase: 'merging',
                 workflow,
             });
-            // Wait for AI merge to complete
-            await this.waitForExecution(executionId, 15 * 60 * 1000);
+            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'}`);
             }
-            // Timeline: complete merge attempt
-            const tMerge = workflow.timeline.find((t) => t.executionId === executionId);
+            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;
-                workflow.timeline = this.computeVisibleTimeline(workflow);
-                await this.saveWorkflow(workflow);
+                latest.timeline = this.computeVisibleTimeline(latest);
+                latest.lastUpdatedAt = new Date().toISOString();
+                await this.saveWorkflow(latest);
             }
-            // Update task status to done (after merge)
             await this.taskService.updateTask(workflow.taskId, { status: 'done' });
-            // Move to cleanup phase; final completion is after cleanup
             await this.transitionToPhase(workflowId, 'merged');
-            workflow.status = 'merged';
-            workflow.lastUpdatedAt = new Date().toISOString();
-            await this.saveWorkflow(workflow);
+            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.
@@ -1297,10 +1318,7 @@ export class VibingOrchestrator extends EventEmitter {
         const workflow = this.workflows.get(workflowId);
         if (!workflow)
             throw new Error(`Workflow ${workflowId} not found`);
-        await this.transitionToPhase(workflowId, 'merging');
-        // If not already approved/reviewing, proceed anyway to merge attempt
-        await this.executeMerge(workflowId, options);
-        await this.transitionToPhase(workflowId, 'merged');
+        await this.executeMerge(workflowId, { provider: options?.provider, model: options?.model });
     }
     /**
      * Execute cleanup phase: remove worktree/branch and finalize workflow
@@ -1434,11 +1452,18 @@ export class VibingOrchestrator extends EventEmitter {
      */
     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) {
-                throw new Error(`Execution ${executionId} not found`);
+                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;
             }
@@ -1623,7 +1648,6 @@ export class VibingOrchestrator extends EventEmitter {
                 await this.rerunImplementation(workflowId);
             }
             else {
-                await this.transitionToPhase(workflowId, 'implementing');
                 await this.executeImplementation(workflowId);
             }
             return;
@@ -1636,23 +1660,21 @@ export class VibingOrchestrator extends EventEmitter {
         }
         switch (next) {
             case 'implementing':
-                await this.transitionToPhase(workflowId, 'implementing');
                 await this.executeImplementation(workflowId);
                 return;
             case 'validating':
-                await this.transitionToPhase(workflowId, 'validating');
                 await this.executeValidation(workflowId);
                 return;
             case 'ai-reviewing':
-                await this.transitionToPhase(workflowId, 'ai-reviewing');
                 await this.executeAiReviewPhase(workflowId);
                 return;
+            case 'awaiting-review':
+                await this.executeAwaitingReview(workflowId);
+                return;
             case 'merging':
-                await this.transitionToPhase(workflowId, 'merging');
                 await this.executeMerge(workflowId);
                 return;
             case 'cleaning':
-                await this.transitionToPhase(workflowId, 'cleaning');
                 await this.executeCleanup(workflowId);
                 return;
             default:
@@ -1832,6 +1854,14 @@ function serializeVibe(workflow) {
                 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) {