scripts-orchestrator 2.10.0 → 2.13.0

package/lib/orchestrator.js

@@ -1,29 +1,46 @@
+import fs from 'fs';
 import { processManager } from './process-manager.js';
 import { healthCheck } from './health-check.js';
 import { log } from './logger.js';
 import { GitCache } from './git-cache.js';
+import chalk from 'chalk';
 
 export class Orchestrator {
-  constructor(config, startPhase = null, logFolder = null, phases = null, sequential = false, force = false) {
+  constructor(
+    config,
+    startPhase = null,
+    logFolder = null,
+    phases = null,
+    sequential = false,
+    force = false,
+    metrics = [],
+    jsonResultsPath = null,
+    htmlResultsPath = null,
+  ) {
     this.config = config;
     this.startPhase = startPhase;
     this.logFolder = logFolder;
     this.phases = phases;
     this.sequential = sequential;
     this.force = force;
+    this.metrics = Array.isArray(metrics) ? metrics : [];
+    this.jsonResultsPath = jsonResultsPath ?? null;
+    this.htmlResultsPath = htmlResultsPath ?? null;
     this.processManager = processManager;
     this.healthCheck = healthCheck;
     this.logger = log;
     this.failedCommands = [];
     this.skippedCommands = [];
-    this.commandTimings = new Map();
+    this.skipReasons = new Map(); // Track why commands were skipped
+    this.commandTimings = new Map(); // command -> { durationMs, memoryKb? }
+    this.phaseResults = []; // { name, success, durationMs } per phase run
     this.gitCache = new GitCache(logFolder);
-    
+
     // Set the log folder in process manager
     if (logFolder) {
       this.processManager.setLogFolder(logFolder);
     }
-    
+
     // Flatten commands for easier tracking
     this.allCommands = this.flattenCommands(config);
   }
@@ -33,11 +50,11 @@ export class Orchestrator {
     if (Array.isArray(config)) {
       return config;
     }
-    
+
     if (config.phases) {
-      return config.phases.flatMap(phase => phase.parallel || []);
+      return config.phases.flatMap((phase) => phase.parallel || []);
     }
-    
+
     return [];
   }
 
@@ -71,13 +88,17 @@ export class Orchestrator {
 
     const startTime = Date.now();
 
+    const setTiming = (durationMs, memoryKb = null) => {
+      this.commandTimings.set(command, { durationMs, memoryKb });
+    };
+
     // Check for circular dependencies
     if (visited.has(command)) {
       this.logger.error(
         `Circular dependency detected: ${Array.from(visited).join(' -> ')} -> ${command}`,
       );
       this.failedCommands.push(command);
-      this.commandTimings.set(command, Date.now() - startTime);
+      setTiming(Date.now() - startTime);
       return false;
     }
     visited.add(command);
@@ -86,17 +107,31 @@ export class Orchestrator {
     if (status === 'disabled') {
       this.logger.warn(`Skipping: npm run ${command} (status: disabled)`);
       this.skippedCommands.push(command);
-      this.commandTimings.set(command, Date.now() - startTime);
+      this.skipReasons.set(command, 'disabled');
+      setTiming(Date.now() - startTime);
       visited.delete(command);
       return true;
     }
 
     const checkUrl = health_check?.url;
     if (checkUrl) {
-      this.logger.info(`Checking if ${checkUrl} is already available...`);
-      const urlAvailable = await this.healthCheck.waitForUrl({url: checkUrl, maxAttempts: 1, silent:true});
-      if (urlAvailable) {
-        this.logger.verbose(`${checkUrl} is already available. Skipping ${command} start.`);
+      this.logger.startEphemeral(
+        `check_${checkUrl}`,
+        chalk.blue(`[INFO] ⏳ Checking if ${checkUrl} is already available...`),
+      );
+      const urlAvailable = await this.healthCheck.waitForUrl({
+        url: checkUrl,
+        maxAttempts: 1,
+        silent: true,
+      });
+
+      if (!urlAvailable) {
+        this.logger.stopEphemeral(`check_${checkUrl}`);
+      } else {
+        this.logger.stopEphemeral(
+          `check_${checkUrl}`,
+          `✅ ${checkUrl} is already available. Skipping ${command} start.`,
+        );
         this.processManager.addBackgroundProcess({
           command,
           url: checkUrl,
@@ -104,7 +139,7 @@ export class Orchestrator {
           process_tracking,
           kill_command,
         });
-        this.commandTimings.set(command, Date.now() - startTime);
+        setTiming(Date.now() - startTime);
         visited.delete(command);
         return true;
       }
@@ -116,24 +151,22 @@ export class Orchestrator {
       if (!dependencySuccess) {
         this.logger.error(`Skipping ${command} due to failed dependency`);
         this.skippedCommands.push(command);
-        this.commandTimings.set(command, Date.now() - startTime);
+        this.skipReasons.set(command, 'failed_dependency');
+        setTiming(Date.now() - startTime);
         visited.delete(command);
         return false;
       }
 
       if (dependency.health_check?.url) {
-        this.logger.info(`Waiting for ${dependency.health_check.url} to be available...`);
         const urlAvailable = await this.healthCheck.waitForUrl({
           url: dependency.health_check.url,
           maxAttempts: dependency.health_check?.max_attempts || 20,
           interval: dependency.health_check?.interval || 2000,
         });
         if (!urlAvailable) {
-          this.logger.error(
-            `URL ${dependency.health_check.url} is not available after maximum attempts`,
-          );
           this.skippedCommands.push(command);
-          this.commandTimings.set(command, Date.now() - startTime);
+          this.skipReasons.set(command, 'failed_dependency');
+          setTiming(Date.now() - startTime);
           visited.delete(command);
           return false;
         }
@@ -141,7 +174,9 @@ export class Orchestrator {
           this.logger.verbose(`Waiting ${dependency.wait}ms`);
           await new Promise((resolve) => {
             setTimeout(() => {
-              this.logger.verbose(`Resolving after a wait of ${dependency.wait}ms`);
+              this.logger.verbose(
+                `Resolving after a wait of ${dependency.wait}ms`,
+              );
               resolve(true);
             }, dependency.wait);
           });
@@ -153,14 +188,17 @@ export class Orchestrator {
     let result = false;
     let commandOutput = '';
     let commandFailed = false;
-    
+    let lastRunResult = null;
+
     for (let attempt = 1; attempt <= attempts; attempt++) {
       if (attempt > 1) {
-        this.logger.warn(`Retrying ${command} (attempt ${attempt}/${attempts})`);
+        this.logger.warn(
+          `Retrying ${command} (attempt ${attempt}/${attempts})`,
+        );
         await new Promise((resolve) => setTimeout(resolve, 1000));
       }
 
-      const { success, output } = await this.processManager.runCommand({
+      const runResult = await this.processManager.runCommand({
         cmd: attempt === 1 ? command : retry_command || command,
         logFile: log || logFile, // Prefer 'log' key over 'logFile' for backwards compatibility
         background,
@@ -168,13 +206,19 @@ export class Orchestrator {
         kill_command,
         isRetry: attempt > 1,
         env,
+        reportTime: this.metrics.includes('time'),
+        reportMemory: this.metrics.includes('memory'),
       });
+      lastRunResult = runResult;
+      const { success, output } = runResult;
       commandOutput = output;
       result = success;
 
       if (result) {
         // Remove from failed commands if it was there
-        this.failedCommands = this.failedCommands.filter(cmd => cmd !== command);
+        this.failedCommands = this.failedCommands.filter(
+          (cmd) => cmd !== command,
+        );
         commandFailed = false;
         break;
       } else if (attempt < attempts) {
@@ -185,7 +229,9 @@ export class Orchestrator {
           commandFailed = true;
           break;
         }
-        this.logger.error(`Attempt ${attempt}/${attempts} failed for ${command}`);
+        this.logger.error(
+          `Attempt ${attempt}/${attempts} failed for ${command}`,
+        );
         commandFailed = true;
       } else {
         commandFailed = true;
@@ -194,52 +240,266 @@ export class Orchestrator {
 
     if (commandFailed) {
       this.failedCommands.push(command);
-      
+
       // Cleanup any background processes for this failed command
       if (background) {
-        this.logger.warn(`Command ${command} failed after all attempts. Cleaning up background processes.`);
+        this.logger.warn(
+          `Command ${command} failed after all attempts. Cleaning up background processes.`,
+        );
         try {
           await this.processManager.cleanupCommand(command);
         } catch (cleanupError) {
-          this.logger.error(`Failed to cleanup processes for ${command}: ${cleanupError.message}`);
+          this.logger.error(
+            `Failed to cleanup processes for ${command}: ${cleanupError.message}`,
+          );
         }
       }
     }
 
-    this.commandTimings.set(command, Date.now() - startTime);
+    const totalDurationMs = Date.now() - startTime;
+    setTiming(totalDurationMs, lastRunResult?.memoryKb ?? null);
     visited.delete(command);
     return result;
   }
 
   summarizeResults() {
-    this.logger.info('\nCommand Summary:');
     let hasFailures = false;
-    
+
+    // Check if any command failed or was skipped due to failure
     this.allCommands.forEach(({ command }) => {
-      const duration = this.commandTimings.get(command);
-      const durationStr = duration ? ` (${this.formatDuration(duration)})` : '';
-      
       if (this.failedCommands.includes(command)) {
         hasFailures = true;
-        // Get the actual log path from process manager
-        const logPath = this.processManager.getLogPath(command);
-        this.logger.error(`- ${command}: ❌${durationStr} (See ${logPath})`);
       } else if (this.skippedCommands.includes(command)) {
-        hasFailures = true;
-        this.logger.warn(`- ${command}: ⚠️${durationStr} (Skipped due to failed dependency)`);
-      } else {
-        this.logger.success(`- ${command}: ✅${durationStr}`);
+        const skipReason = this.skipReasons.get(command);
+        if (
+          skipReason === 'failed_dependency' ||
+          skipReason === 'after_phase_failure'
+        ) {
+          hasFailures = true;
+        }
       }
     });
 
     if (hasFailures) {
-      this.logger.error('\n❌ Some commands failed or were skipped. See details above.');
+      this.logger.error('\n❌ Some commands failed or were skipped.');
     } else {
       this.logger.success('\n🎉 All commands executed successfully!');
     }
   }
 
+  writeJsonResults(hasFailures) {
+    const overallDurationMs =
+      this.metrics.includes('time') && this.startTime
+        ? Date.now() - this.startTime
+        : undefined;
+
+    const commands = [];
+    if (Array.isArray(this.config)) {
+      this.config.forEach(({ command }) => {
+        const timing = this.commandTimings.get(command);
+        const skipReason = this.skippedCommands.includes(command)
+          ? this.skipReasons.get(command) ?? null
+          : null;
+        const success =
+          !this.failedCommands.includes(command) &&
+          (skipReason === null ||
+            skipReason === 'disabled' ||
+            skipReason === 'optional_phase_not_requested' ||
+            skipReason === 'before_start_phase');
+        const entry = {
+          command,
+          success,
+          ...(timing?.durationMs != null && this.metrics.includes('time')
+            ? { durationMs: timing.durationMs }
+            : {}),
+          ...(this.metrics.includes('memory')
+            ? { memoryKb: timing?.memoryKb ?? null }
+            : {}),
+          ...(skipReason ? { skipReason } : {}),
+        };
+        commands.push(entry);
+      });
+    } else if (this.config.phases) {
+      this.config.phases.forEach((phase) => {
+        (phase.parallel || []).forEach(({ command }) => {
+          const timing = this.commandTimings.get(command);
+          const skipReason = this.skippedCommands.includes(command)
+            ? this.skipReasons.get(command) ?? null
+            : null;
+          const success =
+            !this.failedCommands.includes(command) &&
+            (skipReason === null ||
+              skipReason === 'disabled' ||
+              skipReason === 'optional_phase_not_requested' ||
+              skipReason === 'before_start_phase');
+          const entry = {
+            command,
+            phase: phase.name,
+            success,
+            ...(timing?.durationMs != null && this.metrics.includes('time')
+              ? { durationMs: timing.durationMs }
+              : {}),
+            ...(this.metrics.includes('memory')
+              ? { memoryKb: timing?.memoryKb ?? null }
+              : {}),
+            ...(skipReason ? { skipReason } : {}),
+          };
+          commands.push(entry);
+        });
+      });
+    }
+
+    const payload = {
+      success: !hasFailures,
+      timestamp: new Date().toISOString(),
+      ...(overallDurationMs != null ? { overallDurationMs } : {}),
+      commands,
+      ...(this.config.phases && this.phaseResults.length > 0
+        ? { phases: this.phaseResults }
+        : {}),
+    };
+
+    const json = JSON.stringify(payload, null, 2);
+    if (this.jsonResultsPath === '-') {
+      console.log(json);
+    } else {
+      const outPath = this.jsonResultsPath || './scripts-orchestrator-results.json';
+      fs.writeFileSync(outPath, json, 'utf8');
+      this.logger.verbose(`Wrote results to ${outPath}`);
+    }
+
+    if (this.htmlResultsPath != null) {
+      this.writeHtmlResults(payload);
+    }
+  }
+
+  formatMs(ms) {
+    if (ms == null || ms === 0) return '—';
+    if (ms < 1000) return `${ms}ms`;
+    const s = (ms / 1000).toFixed(1);
+    return `${s}s`;
+  }
+
+  writeHtmlResults(payload) {
+    const escapeHtml = (s) => {
+      if (s == null) return '';
+      return String(s)
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+    };
+    const { success, timestamp, overallDurationMs, commands = [], phases = [] } = payload;
+    const maxDuration = Math.max(0, ...commands.map((c) => c.durationMs || 0), ...phases.map((p) => p.durationMs || 0));
+    const maxMemory = Math.max(0, ...commands.map((c) => c.memoryKb || 0));
+
+    const row = (c) => {
+      const durationPct = maxDuration > 0 && c.durationMs != null ? (c.durationMs / maxDuration) * 100 : 0;
+      const memoryPct = maxMemory > 0 && c.memoryKb != null ? (c.memoryKb / maxMemory) * 100 : 0;
+      const statusClass = c.success ? 'ok' : 'fail';
+      const statusLabel = c.success ? 'OK' : (c.skipReason || 'Failed');
+      return `
+        <tr class="${statusClass}">
+          <td><code>${escapeHtml(c.command)}</code></td>
+          <td>${c.phase != null ? escapeHtml(c.phase) : '—'}</td>
+          <td><span class="badge ${statusClass}">${escapeHtml(statusLabel)}</span></td>
+          <td>${this.formatMs(c.durationMs)}</td>
+          <td>${c.memoryKb != null ? `${(c.memoryKb / 1024).toFixed(1)} MB` : '—'}</td>
+          <td class="bar-cell"><div class="bar" style="width:${durationPct}%"></div></td>
+          <td class="bar-cell"><div class="bar mem" style="width:${memoryPct}%"></div></td>
+        </tr>`;
+    };
+
+    const phaseRow = (p) => {
+      const durationPct = maxDuration > 0 && p.durationMs != null ? (p.durationMs / maxDuration) * 100 : 0;
+      const statusClass = p.success ? 'ok' : 'fail';
+      return `
+        <tr class="${statusClass}">
+          <td>${escapeHtml(p.name)}</td>
+          <td><span class="badge ${statusClass}">${p.success ? 'OK' : 'Failed'}</span></td>
+          <td>${this.formatMs(p.durationMs)}</td>
+          <td class="bar-cell"><div class="bar" style="width:${durationPct}%"></div></td>
+        </tr>`;
+    };
+
+    const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>Scripts Orchestrator Report</title>
+  <style>
+    * { box-sizing: border-box; }
+    body { font-family: system-ui, sans-serif; margin: 1rem 2rem; background: #1a1a1a; color: #e0e0e0; }
+    h1 { font-size: 1.5rem; margin-bottom: 0.5rem; }
+    .summary { display: flex; gap: 1.5rem; flex-wrap: wrap; margin-bottom: 1.5rem; }
+    .summary .card { background: #2a2a2a; padding: 1rem 1.25rem; border-radius: 8px; min-width: 140px; }
+    .summary .card.success { border-left: 4px solid #22c55e; }
+    .summary .card.fail { border-left: 4px solid #ef4444; }
+    .summary .label { font-size: 0.75rem; text-transform: uppercase; color: #888; }
+    .summary .value { font-size: 1.25rem; font-weight: 600; }
+    section { margin-bottom: 1.5rem; }
+    section h2 { font-size: 1.1rem; color: #a0a0a0; margin-bottom: 0.5rem; }
+    table { width: 100%; border-collapse: collapse; background: #2a2a2a; border-radius: 8px; overflow: hidden; }
+    th, td { padding: 0.5rem 0.75rem; text-align: left; }
+    th { background: #333; color: #888; font-weight: 600; font-size: 0.8rem; }
+    tr.fail { background: rgba(239,68,68,0.08); }
+    .badge { padding: 0.2rem 0.5rem; border-radius: 4px; font-size: 0.8rem; }
+    .badge.ok { background: #22c55e; color: #0f0f0f; }
+    .badge.fail { background: #ef4444; color: #fff; }
+    .bar-cell { width: 120px; }
+    .bar { height: 8px; background: #3b82f6; border-radius: 4px; min-width: 2px; }
+    .bar.mem { background: #8b5cf6; }
+    code { font-size: 0.9em; background: #333; padding: 0.1rem 0.3rem; border-radius: 4px; }
+  </style>
+</head>
+<body>
+  <h1>Scripts Orchestrator Report</h1>
+  <div class="summary">
+    <div class="card ${success ? 'success' : 'fail'}">
+      <div class="label">Status</div>
+      <div class="value">${success ? 'Success' : 'Failed'}</div>
+    </div>
+    <div class="card">
+      <div class="label">Timestamp</div>
+      <div class="value" style="font-size:0.9rem">${escapeHtml(timestamp)}</div>
+    </div>
+    ${overallDurationMs != null ? `
+    <div class="card">
+      <div class="label">Total time</div>
+      <div class="value">${this.formatMs(overallDurationMs)}</div>
+    </div>` : ''}
+  </div>
+
+  ${phases.length > 0 ? `
+  <section>
+    <h2>Phases</h2>
+    <table>
+      <thead><tr><th>Phase</th><th>Status</th><th>Duration</th><th></th></tr></thead>
+      <tbody>${phases.map(phaseRow).join('')}</tbody>
+    </table>
+  </section>` : ''}
+
+  <section>
+    <h2>Commands</h2>
+    <table>
+      <thead><tr><th>Command</th><th>Phase</th><th>Status</th><th>Duration</th><th>Memory</th><th>Time</th><th>Memory</th></tr></thead>
+      <tbody>${commands.map(row).join('')}</tbody>
+    </table>
+  </section>
+</body>
+</html>`;
+
+    if (this.htmlResultsPath === '-') {
+      console.log(html);
+    } else {
+      const outPath = this.htmlResultsPath || './scripts-orchestrator-results.html';
+      fs.writeFileSync(outPath, html, 'utf8');
+      this.logger.verbose(`Wrote HTML report to ${outPath}`);
+    }
+  }
+
   async run() {
+    this.startTime = Date.now();
     try {
       // Check if we should skip execution based on git state (unless forced)
       if (!this.force) {
@@ -250,7 +510,9 @@ export class Orchestrator {
           process.exit(0);
         }
       } else {
-        this.logger.info('⚡ Force execution enabled, skipping git cache check');
+        this.logger.info(
+          '⚡ Force execution enabled, skipping git cache check',
+        );
       }
 
       let hasFailures = false;
@@ -276,14 +538,14 @@ export class Orchestrator {
             this.executeCommand(commandConfig),
           );
           const results = await Promise.all(tasks);
-          hasFailures = results.some(result => !result);
+          hasFailures = results.some((result) => !result);
         }
       } else if (this.config.phases) {
         // New: Run phases sequentially, commands within phases in parallel or sequential based on flag
         if (this.sequential) {
           this.logger.info('🔄 Running in sequential mode');
         }
-        
+
         for (const phase of this.config.phases) {
           // Check if we should start from this phase
           if (this.startPhase && !startPhaseFound) {
@@ -294,19 +556,27 @@ export class Orchestrator {
               // Mark all commands in previous phases as skipped
               phase.parallel.forEach(({ command }) => {
                 this.skippedCommands.push(command);
-                this.commandTimings.set(command, 0);
+                this.skipReasons.set(command, 'before_start_phase');
+                this.commandTimings.set(command, { durationMs: 0, memoryKb: null });
               });
               continue;
             }
           }
 
           // Check if this is an optional phase that should be skipped
-          if (phase.optional === true && this.phases && !this.phases.includes(phase.name)) {
-            this.logger.info(`\n⏭️  Skipping optional phase: ${phase.name} (not explicitly requested)`);
+          if (
+            phase.optional === true &&
+            this.phases &&
+            !this.phases.includes(phase.name)
+          ) {
+            this.logger.info(
+              `\n⏭️  Skipping optional phase: ${phase.name} (not explicitly requested)`,
+            );
             // Mark all commands in this phase as skipped
             phase.parallel.forEach(({ command }) => {
               this.skippedCommands.push(command);
-              this.commandTimings.set(command, 0);
+              this.skipReasons.set(command, 'optional_phase_not_requested');
+              this.commandTimings.set(command, { durationMs: 0, memoryKb: null });
             });
             continue;
           }
@@ -315,13 +585,14 @@ export class Orchestrator {
             // Mark all commands in remaining phases as skipped
             phase.parallel.forEach(({ command }) => {
               this.skippedCommands.push(command);
-              this.commandTimings.set(command, 0);
+              this.skipReasons.set(command, 'after_phase_failure');
+              this.commandTimings.set(command, { durationMs: 0, memoryKb: null });
             });
             continue;
           }
 
-          this.logger.info(`\n🔄 Starting phase: ${phase.name}`);
-          
+          const phaseStartTime = Date.now();
+
           let results;
           if (this.sequential) {
             // Run commands sequentially
@@ -341,58 +612,102 @@ export class Orchestrator {
             );
             results = await Promise.all(tasks);
           }
-          
-          const phaseHasFailures = results.some(result => !result);
-          
+
+          const phaseHasFailures = results.some((result) => !result);
+          const phaseDurationMs = Date.now() - phaseStartTime;
+          const phaseDurationStr = this.metrics.includes('time')
+            ? `(${this.formatDuration(phaseDurationMs)})`
+            : '';
+
+          this.phaseResults.push({
+            name: phase.name,
+            success: !phaseHasFailures,
+            durationMs: this.metrics.includes('time') ? phaseDurationMs : undefined,
+          });
+
           if (phaseHasFailures) {
             hasFailures = true;
             phaseFailed = true;
-            this.logger.error(`❌ Phase "${phase.name}" completed with failures`);
+            this.logger.stopPhase(phase.name, false, phaseDurationStr);
           } else {
-            this.logger.success(`✅ Phase "${phase.name}" completed successfully`);
+            this.logger.stopPhase(phase.name, true, phaseDurationStr);
           }
         }
       }
 
       // Validate start phase if specified
       if (this.startPhase && !startPhaseFound) {
-        const availablePhases = this.config.phases.map(p => p.name).join(', ');
-        this.logger.error(`❌ Start phase "${this.startPhase}" not found. Available phases: ${availablePhases}`);
+        const availablePhases = this.config.phases
+          .map((p) => p.name)
+          .join(', ');
+        this.logger.error(
+          `❌ Start phase "${this.startPhase}" not found. Available phases: ${availablePhases}`,
+        );
         process.exit(1);
       }
 
       // Validate phases if specified
       if (this.phases) {
-        const availablePhases = this.config.phases.map(p => p.name);
-        const invalidPhases = this.phases.filter(phase => !availablePhases.includes(phase));
+        const availablePhases = this.config.phases.map((p) => p.name);
+        const invalidPhases = this.phases.filter(
+          (phase) => !availablePhases.includes(phase),
+        );
         if (invalidPhases.length > 0) {
-          this.logger.error(`❌ Invalid phases specified: ${invalidPhases.join(', ')}. Available phases: ${availablePhases.join(', ')}`);
+          this.logger.error(
+            `❌ Invalid phases specified: ${invalidPhases.join(', ')}. Available phases: ${availablePhases.join(', ')}`,
+          );
           process.exit(1);
         }
       }
 
       // Check final status
-      hasFailures = hasFailures || 
-                   this.failedCommands.length > 0 || 
-                   this.skippedCommands.length > 0;
+      // Only count skipped commands as failures if they're due to dependency issues or phase failures
+      const failureSkippedCommands = Array.from(this.skipReasons.entries())
+        .filter(
+          ([, reason]) =>
+            reason === 'failed_dependency' || reason === 'after_phase_failure',
+        )
+        .map(([command]) => command);
+
+      hasFailures =
+        hasFailures ||
+        this.failedCommands.length > 0 ||
+        failureSkippedCommands.length > 0;
 
       // Add a small delay to ensure all processes have finished
       await new Promise((resolve) => setTimeout(resolve, 1000));
 
       this.summarizeResults();
-      
+
       // Cleanup before exit since finally blocks don't run after process.exit()
       try {
         await this.processManager.cleanup();
       } catch (error) {
         this.logger.error(`Cleanup failed: ${error.message}`);
       }
-      
+
+      // Log overall time after cleanup has finished (only when metrics include time)
+      if (this.startTime && this.metrics.includes('time')) {
+        const overallDuration = Date.now() - this.startTime;
+        this.logger.printMessage(() =>
+          console.log(
+            chalk.cyan(
+              `[INFO] ⏱️  Overall time taken: ${this.formatDuration(overallDuration)}`,
+            ),
+          ),
+        );
+      }
+
+      // Write JSON results if requested
+      if (this.jsonResultsPath != null) {
+        this.writeJsonResults(hasFailures);
+      }
+
       // Update git cache on successful execution
       if (!hasFailures) {
         await this.gitCache.updateCache();
       }
-      
+
       // Force exit with appropriate status
       if (hasFailures) {
         this.logger.info('Exiting with failure status...');
@@ -403,15 +718,15 @@ export class Orchestrator {
       }
     } catch (error) {
       this.logger.error(`Orchestrator failed: ${error.message}`);
-      
+
       // Cleanup on error
       try {
         await this.processManager.cleanup();
       } catch (cleanupError) {
         this.logger.error(`Cleanup failed: ${cleanupError.message}`);
       }
-      
+
       process.exit(1);
     }
   }
-} 
+}