create-backlist 10.0.6 → 10.0.8

package/bin/index.js

@@ -272,7 +272,7 @@ async function printAnimatedBanner() {
     '  ║ / /_/ / / ___ |/ /___/ /| |   / /____/ / ___/ /            ║',
     '  ║/_____/ /_/  |_|\\____/_/ |_|  /_____/___//____/             ║',
     '  ║                                                              ║',
-    '  ║      ⚡ v9.0-ULTRA — Animated Enterprise CLI ⚡              ║',
+    '  ║      ⚡ v10.0-ULTRA — BACKLIST NEXTOG ENTERPRICE CLI ⚡              ║',
     '  ║   Real Testing · AI Powered · Zero Fake Data · Playwright   ║',
     '  ╚══════════════════════════════════════════════════════════════╝',
   ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-backlist",
-  "version": "10.0.6",
+  "version": "10.0.8",
   "description": "An advanced, multi-language backend generator based on frontend analysis. Smart Freemium SaaS CLI with Live QA.",
   "type": "module",
   "bin": {

package/src/qa/browser/crawler.js

@@ -1,4 +1,5 @@
 // Smart crawler with HTTP fallback when browser unavailable
+import chalk                    from 'chalk';
 import { URL }                  from 'node:url';
 import { shortId }              from '../qa-engine.js';
 import { getBrowserLaunchOptions } from './installer.js';
@@ -19,9 +20,9 @@ export class HTTPCrawler {
     while (queue.length > 0 && routes.length < maxPages) {
       const { url, depth } = queue.shift();
       const norm = this.#norm(url);
-      if (!norm || this.#visited.has(norm)) continue;
-      if (!this.#sameOrigin(norm, baseUrl))  continue;
-      if (depth > 3) continue;
+      if (!norm || this.#visited.has(norm))      continue;
+      if (!this.#sameOrigin(norm, baseUrl))       continue;
+      if (depth > 3)                              continue;
 
       this.#visited.add(norm);
 
@@ -29,18 +30,15 @@ export class HTTPCrawler {
       routes.push(route);
       if (onRoute) onRoute(route);
 
-      // Extract links from HTML response
-      if (route.links) {
-        for (const link of route.links) {
-          const ln = this.#norm(link);
-          if (ln && !this.#visited.has(ln) && this.#sameOrigin(ln, baseUrl)) {
-            queue.push({ url: ln, depth: depth + 1 });
-          }
+      for (const link of (route.links || [])) {
+        const ln = this.#norm(link);
+        if (ln && !this.#visited.has(ln) && this.#sameOrigin(ln, baseUrl)) {
+          queue.push({ url: ln, depth: depth + 1 });
         }
       }
     }
 
-    // Also probe common API paths
+    // Probe common API paths
     const apiPaths = [
       '/api/health', '/api/status', '/api/v1/health',
       '/api/v1/users', '/api/v1/products', '/health',
@@ -48,15 +46,17 @@ export class HTTPCrawler {
     ];
 
     for (const p of apiPaths) {
-      const url  = new URL(p, baseUrl).toString();
-      const norm = this.#norm(url);
-      if (this.#visited.has(norm)) continue;
-      this.#visited.add(norm);
-      const route = await this.#probeURL(url, 0);
-      if (route.status > 0 && route.status < 500) {
-        routes.push(route);
-        if (onRoute) onRoute(route);
-      }
+      try {
+        const url  = new URL(p, baseUrl).toString();
+        const norm = this.#norm(url);
+        if (this.#visited.has(norm)) continue;
+        this.#visited.add(norm);
+        const route = await this.#probeURL(url, 0);
+        if (route.status > 0 && route.status < 500) {
+          routes.push(route);
+          if (onRoute) onRoute(route);
+        }
+      } catch {}
     }
 
     return routes;
@@ -75,7 +75,7 @@ export class HTTPCrawler {
       });
       clearTimeout(timer);
 
-      const ct      = res.headers.get('content-type') || '';
+      const ct       = res.headers.get('content-type') || '';
       const duration = Date.now() - t0;
       const headers  = {};
       res.headers.forEach((v, k) => { headers[k] = v; });
@@ -151,25 +151,24 @@ export class HTTPCrawler {
   }
 
   #detectType(url, ct, status) {
-    if (status >= 400) return 'error-page';
+    if (status >= 400)                                return 'error-page';
     if (ct.includes('json') || url.includes('/api/')) return 'api';
     if (url.endsWith('.xml') || url.endsWith('.txt')) return 'resource';
-    if (/\/(login|signin|auth)/i.test(url)) return 'auth';
-    if (/\/(admin)/i.test(url))             return 'admin';
-    if (/\/(dashboard)/i.test(url))         return 'dashboard';
+    if (/\/(login|signin|auth)/i.test(url))           return 'auth';
+    if (/\/(admin)/i.test(url))                       return 'admin';
+    if (/\/(dashboard)/i.test(url))                   return 'dashboard';
     return 'page';
   }
 }
 
 // ── Browser-powered crawler (Playwright) ──────────────────────────────────
 export class SmartCrawler {
-  #visited = new Set();
+  #visited    = new Set();
   #launchOpts = null;
 
-  constructor(_playwright) {}  // playwright passed but we resolve it ourselves
+  constructor(_playwright) {}
 
   async crawl(baseUrl, { maxPages = 60, maxDepth = 4, onRoute } = {}) {
-    // Resolve launch options including auto-install
     if (!this.#launchOpts) {
       this.#launchOpts = await getBrowserLaunchOptions();
     }
@@ -213,9 +212,9 @@ export class SmartCrawler {
       while (queue.length > 0 && routes.length < maxPages) {
         const { url, depth } = queue.shift();
         const norm = this.#norm(url);
-        if (!norm || this.#visited.has(norm))       continue;
-        if (!this.#sameOrigin(norm, baseUrl))        continue;
-        if (depth > maxDepth)                        continue;
+        if (!norm || this.#visited.has(norm))   continue;
+        if (!this.#sameOrigin(norm, baseUrl))    continue;
+        if (depth > maxDepth)                    continue;
         this.#visited.add(norm);
 
         const route = await this.#probePage(context, norm, depth, baseUrl);
@@ -240,9 +239,9 @@ export class SmartCrawler {
   }
 
   async #probePage(context, url, depth, baseUrl) {
-    const page             = await context.newPage();
-    const networkRequests  = [];
-    const links            = new Set();
+    const page            = await context.newPage();
+    const networkRequests = [];
+    const links           = new Set();
 
     page.on('request', req => {
       const u = req.url();
@@ -257,27 +256,44 @@ export class SmartCrawler {
       const ct       = response?.headers()['content-type'] || '';
 
       if (!ct.includes('text/html') && !ct.includes('application/xhtml')) {
-        return { id: shortId(), url, type: this.#detectType(url, ct, status), status, depth, links: [], forms: [] };
+        return {
+          id: shortId(), url,
+          type  : this.#detectType(url, ct, status),
+          status, depth, links: [], forms: [],
+        };
       }
 
-      const hrefs = await page.$$eval('a[href]', els => els.map(e => e.href).filter(Boolean)).catch(() => []);
+      const hrefs = await page.$$eval('a[href]', els => els.map(e => e.href).filter(Boolean))
+        .catch(() => []);
       hrefs.forEach(h => links.add(h));
 
       const forms = await page.$$eval('form', els => els.map(f => ({
-        action: f.action, method: f.method || 'GET',
+        action: f.action,
+        method: f.method || 'GET',
         fields: Array.from(f.elements).map(el => ({
-          name: el.name, type: el.type, required: el.required,
+          name   : el.name,
+          type   : el.type,
+          required: el.required,
         })).filter(f => f.name),
       }))).catch(() => []);
 
-      networkRequests.forEach(r => { if (this.#sameOrigin(r.url, baseUrl)) links.add(r.url); });
+      networkRequests.forEach(r => {
+        if (this.#sameOrigin(r.url, baseUrl)) links.add(r.url);
+      });
 
       return {
-        id: shortId(), url, type: this.#detectType(url, ct, status),
-        status, depth, links: [...links], forms, contentType: ct,
+        id: shortId(), url,
+        type       : this.#detectType(url, ct, status),
+        status, depth,
+        links      : [...links],
+        forms,
+        contentType: ct,
       };
     } catch (err) {
-      return { id: shortId(), url, type: 'error', status: 0, depth, links: [], forms: [], error: err.message };
+      return {
+        id: shortId(), url, type: 'error', status: 0,
+        depth, links: [], forms: [], error: err.message,
+      };
     } finally {
       await page.close().catch(() => {});
     }
@@ -294,12 +310,12 @@ export class SmartCrawler {
   }
 
   #detectType(url, ct, status) {
-    if (status >= 400) return 'error-page';
+    if (status >= 400)                                return 'error-page';
     if (ct.includes('json') || url.includes('/api/')) return 'api';
     if (url.endsWith('.xml') || url.endsWith('.txt')) return 'resource';
-    if (/\/(login|signin|auth)/i.test(url)) return 'auth';
-    if (/\/(admin)/i.test(url))             return 'admin';
-    if (/\/(dashboard)/i.test(url))         return 'dashboard';
+    if (/\/(login|signin|auth)/i.test(url))           return 'auth';
+    if (/\/(admin)/i.test(url))                       return 'admin';
+    if (/\/(dashboard)/i.test(url))                   return 'dashboard';
     return 'page';
   }
-}
+}

package/src/qa/browser/interactions.js

@@ -1,5 +1,6 @@
 // Real browser interactions with HTTP fallback
-import { shortId, sleep }       from '../qa-engine.js';
+import chalk                   from 'chalk';
+import { shortId, sleep }      from '../qa-engine.js';
 import { getBrowserLaunchOptions } from './installer.js';
 
 // ── HTTP-only page tester (fallback) ──────────────────────────────────────
@@ -27,30 +28,28 @@ export class HTTPPageTester {
         try { text = await res.text(); } catch {}
       }
 
-      const pass = status >= 200 && status < 400;
-
-      // Extract forms from HTML
+      const pass  = status >= 200 && status < 400;
       const forms = this.#extractForms(text);
 
       onNetworkEvent?.({ type: 'response', url, status, headers });
 
       return {
         pass,
-        failReason      : pass ? null : `HTTP ${status}`,
-        page            : null,   // no real browser page
-        loadTime        : duration,
-        consoleErrors   : [],     // HTTP mode — no JS execution
-        networkErrors   : [],
-        jsErrors        : [],
-        resourcesFailed : [],
+        failReason        : pass ? null : `HTTP ${status}`,
+        page              : null,
+        loadTime          : duration,
+        consoleErrors     : [],
+        networkErrors     : [],
+        jsErrors          : [],
+        resourcesFailed   : [],
         interactedElements: [],
-        renderTime      : null,
-        domContentLoaded: null,
+        renderTime        : null,
+        domContentLoaded  : null,
         forms,
         status,
         headers,
         message: pass ? `HTTP ${status} in ${duration}ms` : `HTTP ${status}`,
-        mode    : 'http-fallback',
+        mode   : 'http-fallback',
       };
     } catch (err) {
       return {
@@ -63,13 +62,22 @@ export class HTTPPageTester {
   }
 
   async testForm(page, form) {
-    return { pass: true, validationOk: true, submissionOk: true, errors: [], duration: 0, message: 'HTTP mode — form structure detected' };
+    return {
+      pass        : true,
+      validationOk: true,
+      submissionOk: true,
+      errors      : [],
+      duration    : 0,
+      message     : 'HTTP mode — form structure detected',
+    };
   }
 
   async testAuthFlow(page, url, opts) {
-    // HTTP-mode auth check: verify login page exists + returns 200
     try {
-      const res = await fetch(url, { redirect: 'follow', signal: AbortSignal.timeout(8000) });
+      const res = await fetch(url, {
+        redirect: 'follow',
+        signal  : AbortSignal.timeout(8000),
+      });
       return {
         pass   : res.status === 200,
         details: [{ url, status: res.status, note: 'Login page reachable (HTTP mode)' }],
@@ -93,7 +101,7 @@ export class HTTPPageTester {
       const method = (attrs.match(/method=["']([^"']+)["']/) || [])[1] || 'GET';
       const fields = [];
       const inpRe  = /<input([^>]*)>/gi;
-      let inp;
+      let   inp;
       while ((inp = inpRe.exec(body)) !== null) {
         const name     = (inp[1].match(/name=["']([^"']+)["']/)  || [])[1];
         const type     = (inp[1].match(/type=["']([^"']+)["']/)  || [])[1] || 'text';
@@ -110,9 +118,9 @@ export class HTTPPageTester {
 export class BrowserInteractor {
   #playwright;
   #session;
-  #browser    = null;
-  #context    = null;
-  #launchOpts = null;
+  #browser     = null;
+  #context     = null;
+  #launchOpts  = null;
   #httpFallback;
   #useFallback = false;
 
@@ -133,9 +141,20 @@ export class BrowserInteractor {
       return;
     }
 
+    // If playwright module wasn't loaded, fall back
+    if (!this.#playwright) {
+      this.#useFallback = true;
+      console.log(chalk.yellow('\n  ⚠  Playwright module not available — using HTTP-only mode\n'));
+      return;
+    }
+
     try {
       const { executablePath, headless, args } = this.#launchOpts;
-      this.#browser = await this.#playwright.chromium.launch({ executablePath, headless, args });
+      this.#browser  = await this.#playwright.chromium.launch({
+        executablePath,
+        headless,
+        args,
+      });
       this.#context = await this.#browser.newContext({
         viewport         : { width: 1280, height: 800 },
         ignoreHTTPSErrors: true,
@@ -160,11 +179,11 @@ export class BrowserInteractor {
       return this.#httpFallback.testPage(url, opts);
     }
 
-    const page             = await this.#context.newPage();
-    const consoleErrors    = [];
-    const networkErrors    = [];
-    const jsErrors         = [];
-    const resourcesFailed  = [];
+    const page              = await this.#context.newPage();
+    const consoleErrors     = [];
+    const networkErrors     = [];
+    const jsErrors          = [];
+    const resourcesFailed   = [];
     const interactedElements = [];
 
     page.on('console', msg => {
@@ -182,7 +201,12 @@ export class BrowserInteractor {
     });
 
     page.on('requestfailed', req => {
-      const entry = { url: req.url(), method: req.method(), failure: req.failure()?.errorText || 'unknown', timestamp: Date.now() };
+      const entry = {
+        url      : req.url(),
+        method   : req.method(),
+        failure  : req.failure()?.errorText || 'unknown',
+        timestamp: Date.now(),
+      };
       networkErrors.push(entry);
       resourcesFailed.push({ url: req.url(), type: req.resourceType(), failure: entry.failure });
       opts.onNetworkEvent?.({ type: 'failed', ...entry });
@@ -199,27 +223,33 @@ export class BrowserInteractor {
       const response = await page.goto(url, { waitUntil: 'networkidle', timeout: 20_000 });
       const status   = response?.status() || 0;
 
-      if (status >= 500) { pass = false; failReason = `Server error: HTTP ${status}`; }
+      if      (status >= 500) { pass = false; failReason = `Server error: HTTP ${status}`; }
       else if (status >= 400) { pass = false; failReason = `Client error: HTTP ${status}`; }
 
       const timing = await page.evaluate(() => {
         const t = window.performance?.timing;
         if (!t) return null;
-        return { renderTime: t.domComplete - t.navigationStart, domContentLoaded: t.domContentLoadedEventEnd - t.navigationStart };
+        return {
+          renderTime      : t.domComplete - t.navigationStart,
+          domContentLoaded: t.domContentLoadedEventEnd - t.navigationStart,
+        };
       }).catch(() => null);
 
       renderTime       = timing?.renderTime;
       domContentLoaded = timing?.domContentLoaded;
 
       const forms = await page.$$eval('form', els => els.map(f => ({
-        action: f.action, method: f.method || 'GET',
+        action: f.action,
+        method: f.method || 'GET',
         fields: Array.from(f.elements).map(el => ({
-          name: el.name, type: el.type, required: el.required,
+          name   : el.name,
+          type   : el.type,
+          required: el.required,
           tagName: el.tagName?.toLowerCase(),
         })).filter(f => f.name),
       }))).catch(() => []);
 
-      // Real interactions
+      // Real hover interactions on nav links
       const navLinks = await page.$$('nav a, header a').catch(() => []);
       for (const link of navLinks.slice(0, 5)) {
         try {
@@ -243,8 +273,10 @@ export class BrowserInteractor {
 
     } catch (err) {
       return {
-        pass: false, failReason: err.message, page,
-        loadTime: Date.now() - t0,
+        pass      : false,
+        failReason: err.message,
+        page,
+        loadTime  : Date.now() - t0,
         consoleErrors, networkErrors, jsErrors,
         resourcesFailed, interactedElements,
         forms: [], message: err.message, mode: 'browser',
@@ -270,10 +302,24 @@ export class BrowserInteractor {
         els => els.map(e => e.textContent?.trim()).filter(Boolean)
       ).catch(() => []);
 
-      return { pass: true, validationOk: msgs.length > 0, submissionOk: true, errors, duration: Date.now() - t0, message: 'Form tested' };
+      return {
+        pass        : true,
+        validationOk: msgs.length > 0,
+        submissionOk: true,
+        errors,
+        duration    : Date.now() - t0,
+        message     : 'Form tested',
+      };
     } catch (err) {
       errors.push(err.message);
-      return { pass: false, validationOk: false, submissionOk: false, errors, duration: Date.now() - t0, message: err.message };
+      return {
+        pass        : false,
+        validationOk: false,
+        submissionOk: false,
+        errors,
+        duration    : Date.now() - t0,
+        message     : err.message,
+      };
     }
   }
 
@@ -286,35 +332,51 @@ export class BrowserInteractor {
     for (const cred of (opts.testCredentials || [])) {
       try {
         await page.goto(url, { waitUntil: 'networkidle', timeout: 15_000 });
+
         const uf = await page.$('input[type="email"],input[name="email"],input[name="username"]');
         const pf = await page.$('input[type="password"]');
         if (!uf || !pf) { details.push({ note: 'Login fields not found' }); continue; }
+
         await uf.fill(cred.username);
         await pf.fill(cred.password);
+
         const btn = await page.$('[type="submit"]');
         if (btn) { await btn.click(); await page.waitForTimeout(2000); }
 
         const body    = await page.textContent('body').catch(() => '');
         const curUrl  = page.url();
-        const rejected = /invalid|incorrect|error|wrong|fail/i.test(body) || curUrl.includes('login');
+        const rejected = /invalid|incorrect|error|wrong|fail/i.test(body)
+                      || curUrl.includes('login');
+
+        details.push({
+          credentials: cred.username.slice(0, 8) + '...',
+          expectFail : cred.expectFail,
+          wasRejected: rejected,
+          currentUrl : curUrl,
+        });
 
-        details.push({ credentials: cred.username.slice(0, 8) + '...', expectFail: cred.expectFail, wasRejected: rejected, currentUrl: curUrl });
         if (cred.expectFail && !rejected) { pass = false; }
       } catch (err) {
         details.push({ error: err.message });
       }
     }
-    return { pass, details, duration: Date.now() - t0, message: pass ? 'Auth flow validated' : 'Auth issues detected' };
+
+    return {
+      pass,
+      details,
+      duration: Date.now() - t0,
+      message : pass ? 'Auth flow validated' : 'Auth issues detected',
+    };
   }
 
   #testValue(field) {
     const t = (field.type || 'text').toLowerCase();
     const n = (field.name || '').toLowerCase();
-    if (t === 'email'    || n.includes('email'))    return 'test@backlist-qa.dev';
-    if (t === 'password' || n.includes('pass'))     return 'TestPass123!';
-    if (t === 'tel'      || n.includes('phone'))    return '+1-555-000-0000';
-    if (t === 'number')                             return '42';
-    if (n.includes('name'))                         return 'QA Test User';
+    if (t === 'email'  || n.includes('email')) return 'test@backlist-qa.dev';
+    if (t === 'password' || n.includes('pass')) return 'TestPass123!';
+    if (t === 'tel'    || n.includes('phone')) return '+1-555-000-0000';
+    if (t === 'number')                        return '42';
+    if (n.includes('name'))                    return 'QA Test User';
     return 'backlist-qa-test';
   }
-}
+}

package/src/qa/qa-engine.js

@@ -13,6 +13,7 @@ import path             from 'node:path';
 import os               from 'node:os';
 import { performance }  from 'node:perf_hooks';
 import { EventEmitter } from 'node:events';
+import readline         from 'node:readline';
 
 import { SmartCrawler }        from './browser/crawler.js';
 import { BrowserInteractor }   from './browser/interactions.js';
@@ -28,43 +29,64 @@ import { JSONReporter }        from './reporters/json.js';
 import { AIClassifier }        from './utils/ai-classifier.js';
 
 // ── Constants ─────────────────────────────────────────────────────────────
-export const VERSION      = '12.0.0';
-export const QA_DIR       = path.join(process.cwd(), '.backlist', 'qa');
-export const REPORT_DIR   = path.join(QA_DIR, 'reports');
-export const HISTORY_FILE = path.join(QA_DIR, 'history.json');
+export const VERSION        = '12.0.0';
+export const QA_DIR         = path.join(process.cwd(), '.backlist', 'qa');
+export const REPORT_DIR     = path.join(QA_DIR, 'reports');
+export const HISTORY_FILE   = path.join(QA_DIR, 'history.json');
 export const SCREENSHOT_DIR = path.join(REPORT_DIR, 'screenshots');
 
 // ── Utilities ─────────────────────────────────────────────────────────────
-export function timestamp()     { return new Date().toISOString(); }
-export function shortId()       { return Math.random().toString(36).slice(2, 9); }
-export function sleep(ms)       { return new Promise(r => setTimeout(r, ms)); }
+export function timestamp()        { return new Date().toISOString(); }
+export function shortId()          { return Math.random().toString(36).slice(2, 9); }
+export function sleep(ms)          { return new Promise(r => setTimeout(r, ms)); }
 export function formatDuration(ms) {
   if (ms < 1000) return `${Math.round(ms)}ms`;
   return `${(ms / 1000).toFixed(2)}s`;
 }
 export function formatBytes(b) {
-  if (!b || b < 0) return '0B';
-  if (b < 1024)        return `${b}B`;
-  if (b < 1024 * 1024) return `${(b / 1024).toFixed(1)}KB`;
+  if (!b || b < 0)      return '0B';
+  if (b < 1024)          return `${b}B`;
+  if (b < 1024 * 1024)   return `${(b / 1024).toFixed(1)}KB`;
   return `${(b / 1024 / 1024).toFixed(1)}MB`;
 }
 
+// ── Ask yes/no in terminal without async-inside-Promise issue ─────────────
+function askQuestion(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input : process.stdin,
+      output: process.stdout,
+    });
+    // Auto-resolve after 10s if no input
+    const timer = setTimeout(() => {
+      rl.close();
+      resolve(false);
+    }, 10_000);
+
+    rl.question(question, (answer) => {
+      clearTimeout(timer);
+      rl.close();
+      resolve(answer.toLowerCase().trim() === 'y');
+    });
+  });
+}
+
 // ── QA Session ────────────────────────────────────────────────────────────
 export class QASession {
   id;
   startedAt;
-  urls = {};
-  results    = [];  // real test results only
-  bugs       = [];  // real detected bugs only
-  screenshots = []; // real screenshots
+  urls          = {};
+  results       = [];
+  bugs          = [];
+  screenshots   = [];
   consoleErrors = [];
-  networkLog  = [];
-  apiLog      = [];
-  routeMap    = [];
-  perfMetrics = {};
-  secFindings = [];
-  a11yResults = [];
-  seoResults  = [];
+  networkLog    = [];
+  apiLog        = [];
+  routeMap      = [];
+  perfMetrics   = {};
+  secFindings   = [];
+  a11yResults   = [];
+  seoResults    = [];
 
   constructor(urls) {
     this.id        = `QA-${shortId()}`;
@@ -72,9 +94,7 @@ export class QASession {
     this.urls      = urls;
   }
 
-  addResult(result) {
-    this.results.push(result);
-  }
+  addResult(result) { this.results.push(result); }
 
   addBug(bug) {
     this.bugs.push({ ...bug, id: `BUG-${shortId()}`, createdAt: timestamp() });
@@ -111,110 +131,91 @@ export class QAEngine extends EventEmitter {
 
   constructor(session, options = {}) {
     super();
-    this.#session      = session;
-    this.#terminal     = new TerminalDashboard(session);
+    this.#session       = session;
+    this.#terminal      = new TerminalDashboard(session);
     this.#screenshotter = new ScreenshotCapture(SCREENSHOT_DIR);
     this.#aiClassifier  = new AIClassifier();
   }
 
-  // Replace the init() method in QAEngine class
-
-async init() {
-  // Dynamic import Playwright — optional
-  let playwright = null;
-  try {
-    playwright = await import('playwright');
-  } catch {
-    // Will use HTTP fallback throughout
-  }
-
-  // Always import installer — handles all browser detection
-  const { getBrowserLaunchOptions, ensureBrowser } = await import('./browser/installer.js');
-
-  // Check browser availability once — share result
-  const launchOpts = await getBrowserLaunchOptions();
-
-  if (!launchOpts.available) {
-    console.log(chalk.yellow('\n  ⚠  Playwright browser not found.'));
-    console.log(chalk.gray('  The QA engine will run in HTTP-only mode.'));
-    console.log(chalk.gray('  Browser-based tests (JS errors, screenshots, a11y'));
-    console.log(chalk.gray('  via axe-core, real Web Vitals) will be skipped.\n'));
-    console.log(chalk.dim('  To enable full browser testing:'));
-    console.log(chalk.white('    npx playwright install chromium\n'));
-
-    // Offer to install now
-    const shouldInstall = await new Promise(resolve => {
-      const rl = (await import('node:readline')).createInterface({
-        input : process.stdin,
-        output: process.stdout,
-      });
-      rl.question(chalk.cyan('  Install Playwright browser now? (y/N): '), ans => {
-        rl.close();
-        resolve(ans.toLowerCase() === 'y');
-      });
-      // Auto-timeout after 10s
-      setTimeout(() => { rl.close(); resolve(false); }, 10_000);
-    });
+  // ── FIX: init() — no await inside non-async callbacks ─────────────────
+  async init() {
+    // Dynamic import Playwright — optional dependency
+    let playwright = null;
+    try {
+      playwright = await import('playwright');
+    } catch {
+      // Will use HTTP fallback throughout — playwright is optional
+    }
 
-    if (shouldInstall) {
-      const { installPlaywrightBrowsers } = await import('./browser/installer.js');
-      const result = await installPlaywrightBrowsers();
-      if (!result.success) {
-        console.log(chalk.yellow('  Auto-install failed. Continuing in HTTP-only mode.\n'));
+    // Resolve browser launch options (handles all detection logic)
+    const { getBrowserLaunchOptions, installPlaywrightBrowsers } = await import('./browser/installer.js');
+    const launchOpts = await getBrowserLaunchOptions();
+
+    if (!launchOpts.available) {
+      console.log(chalk.yellow('\n  ⚠  Playwright browser not found.'));
+      console.log(chalk.gray('  The QA engine will run in HTTP-only mode.'));
+      console.log(chalk.gray('  Browser-based tests (JS errors, screenshots, real Web Vitals)'));
+      console.log(chalk.gray('  will be skipped. All HTTP-based tests will still run.\n'));
+      console.log(chalk.dim('  To enable full browser testing:'));
+      console.log(chalk.white('    npx playwright install chromium\n'));
+
+      // ── FIX: use the extracted askQuestion() helper — no await in Promise ──
+      const shouldInstall = await askQuestion(
+        chalk.cyan('  Install Playwright browser now? (y/N): ')
+      );
+
+      if (shouldInstall) {
+        const result = await installPlaywrightBrowsers();
+        if (!result.success) {
+          console.log(chalk.yellow('  Auto-install failed. Continuing in HTTP-only mode.\n'));
+        }
       }
+    } else {
+      const exeName = launchOpts.executablePath?.split(/[/\\]/).pop() ?? 'chromium';
+      console.log(chalk.gray(`  ✓ Browser ready (${launchOpts.source}: ${exeName})`));
     }
-  } else {
-    console.log(chalk.gray(`  ✓ Browser ready (${launchOpts.source}: ${launchOpts.executablePath?.split(/[/\\]/).pop()})`));
-  }
 
-  this.#crawler      = new SmartCrawler(playwright);
-  this.#interactor   = new BrowserInteractor(playwright, this.#session);
-  this.#apiValidator = new RealAPIValidator(this.#session);
-  this.#security     = new SecurityScanner(this.#session);
-  this.#performance  = new PerformanceProfiler(this.#session);
-  this.#a11y         = new AccessibilityChecker(playwright, this.#session);
-  this.#seo          = new SEOScanner(this.#session);
-  this.#screenshotter = new ScreenshotCapture(SCREENSHOT_DIR);
-  this.#aiClassifier  = new AIClassifier();
-
-  await this.#interactor.launch();
-  await this.#screenshotter.init();
-}
+    // Initialise all subsystems
+    this.#crawler       = new SmartCrawler(playwright);
+    this.#interactor    = new BrowserInteractor(playwright, this.#session);
+    this.#apiValidator  = new RealAPIValidator(this.#session);
+    this.#security      = new SecurityScanner(this.#session);
+    this.#performance   = new PerformanceProfiler(this.#session);
+    this.#a11y          = new AccessibilityChecker(playwright, this.#session);
+    this.#seo           = new SEOScanner(this.#session);
+    this.#screenshotter = new ScreenshotCapture(SCREENSHOT_DIR);
+    this.#aiClassifier  = new AIClassifier();
+
+    await this.#interactor.launch();
+    await this.#screenshotter.init();
+  }
 
   async run() {
     this.#terminal.start();
     this.emit('session:start', this.#session);
 
     try {
-      // Phase 1 — Discovery
       this.#terminal.setPhase('🔍 Phase 1: Route Discovery & Crawling');
       await this.#phaseDiscovery();
 
-      // Phase 2 — API Validation
       this.#terminal.setPhase('📡 Phase 2: Real API Validation');
       await this.#phaseAPIValidation();
 
-      // Phase 3 — Browser Interactions
       this.#terminal.setPhase('🖱️  Phase 3: Browser Interaction Testing');
       await this.#phaseBrowserInteractions();
 
-      // Phase 4 — Security Scan
       this.#terminal.setPhase('🛡️  Phase 4: Security Deep Scan');
       await this.#phaseSecurityScan();
 
-      // Phase 5 — Performance
       this.#terminal.setPhase('⚡ Phase 5: Performance Profiling');
       await this.#phasePerformance();
 
-      // Phase 6 — Accessibility
       this.#terminal.setPhase('♿ Phase 6: Accessibility Testing');
       await this.#phaseAccessibility();
 
-      // Phase 7 — SEO
       this.#terminal.setPhase('🔎 Phase 7: SEO Validation');
       await this.#phaseSEO();
 
-      // Phase 8 — AI Bug Classification
       this.#terminal.setPhase('🤖 Phase 8: AI Bug Classification');
       await this.#phaseAIClassification();
 
@@ -229,6 +230,36 @@ async init() {
     return this.#session;
   }
 
+  // Run a single named phase (used by manual QA)
+  async runPhase(name) {
+    this.#terminal.start();
+    try {
+      switch (name) {
+        case 'full-url':
+          await this.#phaseDiscovery();
+          await this.#phaseAPIValidation();
+          await this.#phaseBrowserInteractions();
+          await this.#phaseSecurityScan();
+          await this.#phasePerformance();
+          await this.#phaseAccessibility();
+          await this.#phaseSEO();
+          await this.#phaseAIClassification();
+          break;
+        case 'security':    await this.#phaseSecurityScan();    break;
+        case 'perf':        await this.#phasePerformance();     break;
+        case 'a11y':        await this.#phaseAccessibility();   break;
+        case 'seo':         await this.#phaseSEO();             break;
+        case 'api':         await this.#phaseAPIValidation();   break;
+        default:
+          await this.run();
+      }
+    } finally {
+      this.#terminal.stop();
+      await this.#interactor.close().catch(() => {});
+    }
+    return this.#session;
+  }
+
   abort() {
     this.#aborted = true;
     this.#terminal.stop();
@@ -242,9 +273,9 @@ async init() {
       this.#terminal.log(`Crawling ${label}: ${url}`);
 
       const routes = await this.#crawler.crawl(url, {
-        maxPages   : 60,
-        maxDepth   : 4,
-        onRoute    : (route) => {
+        maxPages: 60,
+        maxDepth: 4,
+        onRoute : (route) => {
           this.#session.routeMap.push(route);
           this.#terminal.log(`  Found: ${route.url} (${route.type})`);
         },
@@ -258,17 +289,16 @@ async init() {
         message : routes.length > 0
           ? `Discovered ${routes.length} routes`
           : 'No routes discovered — site may be unreachable',
-        data    : { routeCount: routes.length, routes },
-        url,
-        label,
+        data    : { routeCount: routes.length },
+        url, label,
       });
     }
   }
 
-  // ── Phase 2: Real API Validation ───────────────────────────────────────
+  // ── Phase 2: API Validation ────────────────────────────────────────────
   async #phaseAPIValidation() {
     const apiRoutes = this.#session.routeMap.filter(r =>
-      r.type === 'api' || r.url.includes('/api/')
+      r.type === 'api' || r.url?.includes('/api/')
     );
 
     this.#terminal.log(`Validating ${apiRoutes.length} API endpoints...`);
@@ -287,11 +317,11 @@ async init() {
         status  : result.pass ? 'PASS' : 'FAIL',
         message : result.message,
         data    : {
-          statusCode : result.statusCode,
+          statusCode  : result.statusCode,
           responseTime: result.responseTime,
-          contentType: result.contentType,
-          body       : result.body?.slice(0, 500),
-          headers    : result.headers,
+          contentType : result.contentType,
+          body        : result.body?.slice(0, 500),
+          headers     : result.headers,
         },
         url     : route.url,
         duration: result.responseTime,
@@ -308,7 +338,6 @@ async init() {
       }
     }
 
-    // Detect APIs from network traffic
     const discoveredAPIs = await this.#apiValidator.discoverFromNetworkLog(
       this.#session.networkLog
     );
@@ -338,7 +367,6 @@ async init() {
         },
       });
 
-      // Real screenshot on failure
       if (!result.pass || result.consoleErrors.length > 0) {
         const screenshot = await this.#screenshotter.capture(
           result.page,
@@ -346,7 +374,11 @@ async init() {
         );
         if (screenshot) {
           result.screenshotPath = screenshot;
-          this.#session.screenshots.push({ url: route.url, path: screenshot, reason: result.failReason });
+          this.#session.screenshots.push({
+            url   : route.url,
+            path  : screenshot,
+            reason: result.failReason,
+          });
         }
       }
 
@@ -354,26 +386,27 @@ async init() {
         name    : `Page: ${route.url}`,
         type    : 'browser',
         category: 'interaction',
-        status  : result.pass ? (result.consoleErrors.length > 0 ? 'FLAKY' : 'PASS') : 'FAIL',
+        status  : result.pass
+          ? (result.consoleErrors.length > 0 ? 'FLAKY' : 'PASS')
+          : 'FAIL',
         message : result.message,
         data    : {
-          loadTime      : result.loadTime,
-          consoleErrors : result.consoleErrors,
-          networkErrors : result.networkErrors,
+          loadTime          : result.loadTime,
+          consoleErrors     : result.consoleErrors,
+          networkErrors     : result.networkErrors,
           interactedElements: result.interactedElements,
-          screenshotPath: result.screenshotPath,
-          jsErrors      : result.jsErrors,
-          resourcesFailed: result.resourcesFailed,
-          renderTime    : result.renderTime,
-          domContentLoaded: result.domContentLoaded,
+          screenshotPath    : result.screenshotPath,
+          jsErrors          : result.jsErrors,
+          resourcesFailed   : result.resourcesFailed,
+          renderTime        : result.renderTime,
+          domContentLoaded  : result.domContentLoaded,
         },
-        url     : route.url,
-        duration: result.loadTime,
+        url          : route.url,
+        duration     : result.loadTime,
         screenshotPath: result.screenshotPath,
       });
 
-      // Real console errors → bugs
-      for (const err of result.consoleErrors) {
+      for (const err of (result.consoleErrors || [])) {
         this.#session.addBug({
           title      : `JS Error: ${err.text?.slice(0, 80)}`,
           severity   : err.type === 'error' ? 'P1' : 'P2',
@@ -384,8 +417,7 @@ async init() {
         });
       }
 
-      // Real network failures → bugs
-      for (const nErr of result.networkErrors) {
+      for (const nErr of (result.networkErrors || [])) {
         this.#session.addBug({
           title      : `Network Failure: ${nErr.url}`,
           severity   : 'P2',
@@ -396,12 +428,10 @@ async init() {
         });
       }
 
-      // Test forms on the page
-      if (result.forms && result.forms.length > 0) {
+      if (result.forms?.length > 0) {
         await this.#testForms(route.url, result.forms, result.page);
       }
 
-      // Test auth flows
       if (this.#isAuthPage(route.url)) {
         await this.#testAuthFlow(route.url, result.page);
       }
@@ -424,19 +454,18 @@ async init() {
           status  : finding.pass ? 'PASS' : 'FAIL',
           message : finding.detail,
           data    : finding.evidence,
-          url,
-          label,
+          url, label,
           severity: finding.severity,
         });
 
         if (!finding.pass && (finding.severity === 'P0' || finding.severity === 'P1')) {
           this.#session.addBug({
-            title      : `Security: ${finding.check}`,
-            severity   : finding.severity,
-            type       : 'security',
-            description: finding.detail,
+            title         : `Security: ${finding.check}`,
+            severity      : finding.severity,
+            type          : 'security',
+            description   : finding.detail,
             url,
-            evidence   : finding.evidence,
+            evidence      : finding.evidence,
             recommendation: finding.recommendation,
           });
         }
@@ -452,20 +481,18 @@ async init() {
       const metrics = await this.#performance.profile(url);
       this.#session.perfMetrics[label] = metrics;
 
-      // Core Web Vitals as real test results
       const vitals = [
-        { name: 'LCP',  value: metrics.lcp,  threshold: 2500,  unit: 'ms' },
-        { name: 'FID',  value: metrics.fid,  threshold: 100,   unit: 'ms' },
-        { name: 'CLS',  value: metrics.cls,  threshold: 0.1,   unit: ''   },
-        { name: 'FCP',  value: metrics.fcp,  threshold: 1800,  unit: 'ms' },
-        { name: 'TTFB', value: metrics.ttfb, threshold: 800,   unit: 'ms' },
-        { name: 'TTI',  value: metrics.tti,  threshold: 3800,  unit: 'ms' },
-        { name: 'TBT',  value: metrics.tbt,  threshold: 200,   unit: 'ms' },
+        { name: 'LCP',  value: metrics.lcp,  threshold: 2500, unit: 'ms' },
+        { name: 'FID',  value: metrics.fid,  threshold: 100,  unit: 'ms' },
+        { name: 'CLS',  value: metrics.cls,  threshold: 0.1,  unit: ''   },
+        { name: 'FCP',  value: metrics.fcp,  threshold: 1800, unit: 'ms' },
+        { name: 'TTFB', value: metrics.ttfb, threshold: 800,  unit: 'ms' },
+        { name: 'TBT',  value: metrics.tbt,  threshold: 200,  unit: 'ms' },
       ];
 
       for (const vital of vitals) {
-        const pass = vital.value !== null && vital.value <= vital.threshold;
-        const na   = vital.value === null;
+        const na   = vital.value === null || vital.value === undefined;
+        const pass = !na && vital.value <= vital.threshold;
 
         this.#addResult({
           name    : `[${label}] ${vital.name} — Core Web Vital`,
@@ -473,38 +500,35 @@ async init() {
           category: 'web-vitals',
           status  : na ? 'SKIP' : (pass ? 'PASS' : 'FAIL'),
           message : na
-            ? `${vital.name} not measurable`
-            : `${vital.name}: ${vital.value}${vital.unit} (threshold: ${vital.threshold}${vital.unit})`,
-          data    : { value: vital.value, threshold: vital.threshold, unit: vital.unit },
-          url,
-          label,
+            ? `${vital.name} not measurable (HTTP-only mode)`
+            : `${vital.name}: ${vital.value}${vital.unit} (threshold: ≤${vital.threshold}${vital.unit})`,
+          data    : { value: vital.value, threshold: vital.threshold },
+          url, label,
           duration: vital.value,
         });
 
         if (!na && !pass) {
           this.#session.addBug({
-            title      : `Poor ${vital.name}: ${vital.value}${vital.unit} (>${vital.threshold}${vital.unit})`,
-            severity   : vital.name === 'LCP' || vital.name === 'CLS' ? 'P1' : 'P2',
-            type       : 'performance',
-            description: `${vital.name} exceeds threshold on ${label}`,
+            title         : `Poor ${vital.name}: ${vital.value}${vital.unit} (>${vital.threshold}${vital.unit})`,
+            severity      : (vital.name === 'LCP' || vital.name === 'CLS') ? 'P1' : 'P2',
+            type          : 'performance',
+            description   : `${vital.name} exceeds threshold on ${label}`,
             url,
-            evidence   : { value: vital.value, threshold: vital.threshold },
+            evidence      : { value: vital.value, threshold: vital.threshold },
             recommendation: `Optimize ${vital.name} — see https://web.dev/vitals`,
           });
         }
       }
 
-      // Real resource analysis
       for (const resource of (metrics.slowResources || [])) {
         this.#addResult({
-          name    : `[${label}] Slow resource: ${resource.url.split('/').pop()}`,
+          name    : `[${label}] Slow resource: ${resource.url?.split('/').pop()}`,
           type    : 'performance',
           category: 'resource',
           status  : 'FAIL',
           message : `${resource.url} took ${resource.duration}ms (${formatBytes(resource.size)})`,
           data    : resource,
-          url,
-          label,
+          url, label,
           duration: resource.duration,
         });
       }
@@ -524,7 +548,7 @@ async init() {
       const result = await this.#a11y.check(route.url);
       this.#session.a11yResults.push({ url: route.url, ...result });
 
-      for (const violation of result.violations) {
+      for (const violation of (result.violations || [])) {
         this.#addResult({
           name    : `A11y [${violation.impact}]: ${violation.description}`,
           type    : 'accessibility',
@@ -545,18 +569,17 @@ async init() {
 
         if (violation.impact === 'critical' || violation.impact === 'serious') {
           this.#session.addBug({
-            title      : `A11y: ${violation.description}`,
-            severity   : violation.impact === 'critical' ? 'P0' : 'P1',
-            type       : 'accessibility',
-            description: `${violation.nodes} element(s): ${violation.help}`,
-            url        : route.url,
-            evidence   : violation.affectedNodes,
+            title         : `A11y: ${violation.description}`,
+            severity      : violation.impact === 'critical' ? 'P0' : 'P1',
+            type          : 'accessibility',
+            description   : `${violation.nodes} element(s): ${violation.help}`,
+            url           : route.url,
+            evidence      : violation.affectedNodes,
             recommendation: violation.helpUrl,
           });
         }
       }
 
-      // Passes also recorded as real results
       for (const pass of (result.passes || []).slice(0, 5)) {
         this.#addResult({
           name    : `A11y Pass: ${pass.description}`,
@@ -584,7 +607,7 @@ async init() {
       const result = await this.#seo.scan(route.url);
       this.#session.seoResults.push({ url: route.url, ...result });
 
-      for (const check of result.checks) {
+      for (const check of (result.checks || [])) {
         this.#addResult({
           name    : `SEO: ${check.name} — ${new URL(route.url).pathname}`,
           type    : 'seo',
@@ -598,11 +621,11 @@ async init() {
 
         if (!check.pass && (check.severity === 'P0' || check.severity === 'P1')) {
           this.#session.addBug({
-            title      : `SEO: ${check.name}`,
-            severity   : check.severity,
-            type       : 'seo',
-            description: check.detail,
-            url        : route.url,
+            title         : `SEO: ${check.name}`,
+            severity      : check.severity,
+            type          : 'seo',
+            description   : check.detail,
+            url           : route.url,
             recommendation: check.recommendation,
           });
         }
@@ -616,16 +639,16 @@ async init() {
 
     for (const bug of this.#session.bugs) {
       const classification = await this.#aiClassifier.classify(bug, this.#session);
-      bug.aiSeverity     = classification.severity;
-      bug.aiCategory     = classification.category;
+      bug.aiSeverity       = classification.severity;
+      bug.aiCategory       = classification.category;
       bug.aiRecommendation = classification.recommendation;
-      bug.aiConfidence   = classification.confidence;
+      bug.aiConfidence     = classification.confidence;
     }
 
-    // Sort bugs by AI-determined severity
     this.#session.bugs.sort((a, b) => {
       const order = { P0: 0, P1: 1, P2: 2, P3: 3 };
-      return (order[a.aiSeverity || a.severity] || 3) - (order[b.aiSeverity || b.severity] || 3);
+      return (order[a.aiSeverity || a.severity] || 3)
+           - (order[b.aiSeverity || b.severity] || 3);
     });
   }
 
@@ -673,9 +696,9 @@ async init() {
 
     const result = await this.#interactor.testAuthFlow(page, url, {
       testCredentials: [
-        { username: 'test@example.com',  password: 'wrong-password-test', expectFail: true },
-        { username: 'invalid@test.com',  password: 'wrong123',            expectFail: true },
-        { username: '',                  password: '',                    expectFail: true },
+        { username: 'test@example.com', password: 'wrong-password-test', expectFail: true },
+        { username: 'invalid@test.com', password: 'wrong123',            expectFail: true },
+        { username: '',                 password: '',                    expectFail: true },
       ],
     });
 
@@ -706,7 +729,6 @@ async init() {
     return /\/(login|signin|auth|register|signup)/i.test(url);
   }
 
-  // ── Add real result ────────────────────────────────────────────────────
   #addResult(result) {
     const r = {
       id       : shortId(),
@@ -721,9 +743,9 @@ async init() {
   }
 }
 
-// ─────────────────────────────────────────────────────────────────────────
+// ═══════════════════════════════════════════════════════════════════════════
 //  Public API — exported functions
-// ─────────────────────────────────────────────────────────────────────────
+// ═══════════════════════════════════════════════════════════════════════════
 
 export async function initQASystem() {
   await fs.ensureDir(QA_DIR);
@@ -738,12 +760,12 @@ export async function saveSession(session) {
   const history = await loadHistory();
   const summary = session.getSummary();
   history.runs.unshift({
-    id       : session.id,
-    startedAt: session.startedAt,
-    urls     : session.urls,
+    id             : session.id,
+    startedAt      : session.startedAt,
+    urls           : session.urls,
     summary,
-    version  : VERSION,
-    bugCount : session.bugs.length,
+    version        : VERSION,
+    bugCount       : session.bugs.length,
     screenshotCount: session.screenshots.length,
   });
   if (history.runs.length > 100) history.runs = history.runs.slice(0, 100);
@@ -774,11 +796,8 @@ export async function runUrlQA({ localUrl, stagingUrl, prodUrl, options = {} } =
   await engine.run();
   await saveSession(session);
 
-  const htmlReporter = new HTMLReporter(session);
-  const jsonReporter = new JSONReporter(session);
-
-  const htmlPath = await htmlReporter.generate(REPORT_DIR);
-  const jsonPath = await jsonReporter.generate(REPORT_DIR);
+  const htmlPath = await new HTMLReporter(session).generate(REPORT_DIR);
+  const jsonPath = await new JSONReporter(session).generate(REPORT_DIR);
 
   return { session, htmlPath, jsonPath };
 }
@@ -832,12 +851,12 @@ export async function runManualQA() {
   const action = await p.select({
     message: 'Manual QA — what to run?',
     options: [
-      { value: 'full-url',  label: '🌐 Full URL-Based Real Scan', hint: 'Browser + API + Security + Perf + SEO + A11y' },
-      { value: 'security',  label: '🛡️  Security Only',           hint: 'Real HTTP security header + vuln scan'         },
-      { value: 'perf',      label: '⚡ Performance Only',          hint: 'Real Core Web Vitals measurement'             },
-      { value: 'a11y',      label: '♿ Accessibility Only',        hint: 'Real axe-core WCAG scan'                      },
-      { value: 'seo',       label: '🔎 SEO Only',                  hint: 'Real meta, og, robots, sitemap scan'          },
-      { value: 'api',       label: '📡 API Only',                  hint: 'Real endpoint probe + contract validation'    },
+      { value: 'full-url', label: '🌐 Full URL-Based Real Scan', hint: 'Browser + API + Security + Perf + SEO + A11y' },
+      { value: 'security', label: '🛡️  Security Only',           hint: 'Real HTTP security header + vuln scan'        },
+      { value: 'perf',     label: '⚡ Performance Only',          hint: 'Real Core Web Vitals measurement'            },
+      { value: 'a11y',     label: '♿ Accessibility Only',        hint: 'Real axe-core WCAG scan'                     },
+      { value: 'seo',      label: '🔎 SEO Only',                  hint: 'Real meta, og, robots, sitemap scan'         },
+      { value: 'api',      label: '📡 API Only',                  hint: 'Real endpoint probe + contract validation'   },
     ],
   });
   if (p.isCancel(action)) { p.cancel('Cancelled.'); return; }
@@ -861,8 +880,6 @@ export async function runManualQA() {
   const session = new QASession(urls);
   const engine  = new QAEngine(session);
   await engine.init();
-
-  // Only run selected phases
   await engine.runPhase(action);
 
   await saveSession(session);
@@ -881,8 +898,8 @@ export async function autoRunPostGeneration(options = {}) {
   console.log('');
 
   const url = await p.text({
-    message    : 'Server URL to validate:',
-    placeholder: 'http://localhost:3000',
+    message     : 'Server URL to validate:',
+    placeholder : 'http://localhost:3000',
     defaultValue: 'http://localhost:3000',
   });
   if (p.isCancel(url)) { p.cancel('Cancelled.'); return; }
@@ -907,7 +924,8 @@ export async function viewQAHistory() {
 
   for (const run of history.runs.slice(0, 15)) {
     const rate   = run.summary?.passRate ?? '–';
-    const color  = Number(rate) >= 90 ? chalk.green : Number(rate) >= 70 ? chalk.yellow : chalk.red;
+    const color  = Number(rate) >= 90 ? chalk.green
+                 : Number(rate) >= 70 ? chalk.yellow : chalk.red;
     const bugs   = run.bugCount ?? 0;
     const shots  = run.screenshotCount ?? 0;
     const urlStr = Object.values(run.urls || {}).filter(Boolean).join(', ');
@@ -939,7 +957,6 @@ export async function viewQAHistory() {
   const reportPath = path.join(REPORT_DIR, `${chosen.toLowerCase()}.html`);
   if (await fs.pathExists(reportPath)) {
     console.log(chalk.green(`  📄 Report: ${reportPath}`));
-    // Open in browser if possible
     try {
       const { exec } = await import('node:child_process');
       const cmd = process.platform === 'darwin' ? 'open'