@appliqation/automation-sdk 2.1.11 → 2.3.0

package/src/reporters/playwright/AppliqationReporter.js

@@ -1,3 +1,4 @@
+const path = require('path');
 const AppliqationClient = require('../../AppliqationClient');
 const UuidExtractor = require('./helpers/UuidExtractor');
 const DeviceOsDetector = require('./helpers/DeviceOsDetector');
@@ -5,6 +6,51 @@ const PayloadBuilder = require('../../utils/PayloadBuilder');
 const logger = require('../../utils/logger');
 const { DEFAULT_APPLIQATION_BASE_URL } = require('../../constants');
 
+/**
+ * Check if Appliqation reporting should be enabled
+ * Checks both environment variable and CLI flag
+ * @returns {boolean} True if reporting should be enabled
+ */
+function isAppqEnabled() {
+  // Check environment variable first (easier to use)
+  const envEnabled = process.env.APPQ_ENABLE === '1' ||
+                     process.env.APPQ_ENABLE === 'true' ||
+                     process.env.APPLIQATION_ENABLE === '1' ||
+                     process.env.APPLIQATION_ENABLE === 'true';
+
+  if (envEnabled) {
+    return true;
+  }
+
+  // Check CLI flag (requires -- separator: npx playwright test -- --appq)
+  const argv = process.argv || [];
+  return argv.includes('--appq');
+}
+
+/**
+ * Extract run title from CLI arguments
+ * Supports: --appq_run_title="My Title" or --appq_run_title=MyTitle
+ * @returns {string|null} Run title from CLI args, or null if not found
+ */
+function getRunTitleFromCli() {
+  const argv = process.argv || [];
+
+  // Look for --appq_run_title=value or --appq_run_title="value"
+  for (const arg of argv) {
+    if (arg.startsWith('--appq_run_title=')) {
+      // Extract value after the = sign
+      let value = arg.substring('--appq_run_title='.length);
+
+      // Remove surrounding quotes if present
+      value = value.replace(/^["']|["']$/g, '');
+
+      return value || null;
+    }
+  }
+
+  return null;
+}
+
 /**
  * Appliqation Reporter for Playwright
  * Automatically reports test results to Appliqation platform
@@ -49,6 +95,8 @@ class AppliqationReporter {
       batchSubmit: true,
       batchSize: 50,
       logLevel: 'info',
+      deleteOrphanOnlyRuns: config.deleteOrphanOnlyRuns !== false,
+      failOnOrphanOnlyRuns: config.failOnOrphanOnlyRuns !== false,
       ...config
     };
 
@@ -66,15 +114,26 @@ class AppliqationReporter {
     // Note: No default fallback - validation will catch missing value
 
     // Apply title fallback if not provided
-    // Priority: 1) config.title, 2) process.env.APPLIQATION_RUN_TITLE, 3) timestamp-based default
+    // Priority: 1) config.title, 2) CLI --appq_run_title, 3) process.env.APPLIQATION_RUN_TITLE, 4) timestamp-based default
     if (!this.config.title) {
-      this.config.title = process.env.APPLIQATION_RUN_TITLE || `Automation Run - ${new Date().toISOString()}`;
+      const cliTitle = getRunTitleFromCli();
+      this.config.title = cliTitle || process.env.APPLIQATION_RUN_TITLE || `Automation Run - ${new Date().toISOString()}`;
     }
 
-    // Validate configuration
-    this.validateConfig();
+    // Check if --appq flag is present (opt-in approach)
+    this.appqEnabled = isAppqEnabled();
+
+    if (this.appqEnabled) {
+      // Validate configuration only if appq is enabled
+      this.validateConfig();
+      logger.info('Appliqation reporting ENABLED');
+      console.log('✅ Appliqation reporting enabled: Results will be sent to Appliqation portal');
+    } else {
+      logger.info('Appliqation reporting DISABLED');
+      console.log('ℹ️  Appliqation reporting disabled: Set APPQ_ENABLE=1 or add -- --appq flag to enable');
+    }
 
-    // Initialize SDK client
+    // Initialize SDK client (needed for UUID validation even if disabled)
     this.client = new AppliqationClient({
       baseUrl: this.config.baseUrl,
       apiKey: this.config.apiKey,
@@ -90,12 +149,27 @@ class AppliqationReporter {
     this.runsByProject = new Map(); // Map<projectKey, runInfo>
     this.resultsByRun = new Map(); // Map<runId, results[]>
     this.orphansByRun = new Map(); // Map<runId, orphans[]>
+    this.submittedUuidsByRun = new Map(); // Map<runId, Map<uuid, {file, title, browser}>>
+    this.submittedUuidsGlobal = new Map(); // Map<uuid, {file, title, browser, runId}>
     this.browserVersionDetected = new Map(); // Map<projectKey, boolean> - Track if version detected
     this.totalTests = 0;
     this.passedTests = 0;
     this.failedTests = 0;
     this.skippedTests = 0;
     this.orphanTests = 0;
+    this.validTests = 0; // Track tests with valid UUIDs
+    this.duplicateTests = 0; // Track duplicate UUID submissions
+    this.duplicateDetails = []; // Store details of each duplicate for summary
+    this.backendRejectedTests = 0; // Track tests rejected by backend validation (e.g., project mismatch)
+    this.rejectionsByRun = new Map(); // Track backend rejections per run: runId -> rejectedCount
+    this.deletedOrphanRuns = []; // Track deleted orphan-only runs
+    this.uniqueOrphans = new Map(); // Track unique orphan tests: "file:title" -> {file, title, browsers[]}
+    this.uniqueDuplicates = new Map(); // Track unique duplicate UUIDs: "uuid" -> {uuid, occurrences: [{file, title, browser}]}
+
+    // Execution tracking for summary file generation
+    this.executionStartTime = null;
+    this.executionEndTime = null;
+    this.playwrightOutputDir = null;
 
     // Show baseUrl only in DEBUG mode
     logger.info('Appliqation Playwright Reporter initialized', {
@@ -113,8 +187,23 @@ class AppliqationReporter {
    * @param {Object} suite - Root test suite
    */
   async onBegin(config, suite) {
+    // Capture execution start time for summary file
+    this.executionStartTime = new Date();
+
+    // Capture Playwright output directory
+    // Priority: 1) config._internal.outputDir (actual test-results path)
+    //           2) config.rootDir (project root)
+    //           3) process.cwd() (current working directory)
+    this.playwrightOutputDir = config._internal?.outputDir || config.rootDir || process.cwd();
+
     logger.info('Test run starting...');
 
+    // Skip run creation if --appq flag not present
+    if (!this.appqEnabled) {
+      logger.info('Appliqation reporting disabled. Skipping run matrix creation.');
+      return;
+    }
+
     if (!this.config.autoCreateRun) {
       logger.info('Auto-create run disabled. Skipping run matrix creation.');
       return;
@@ -309,7 +398,7 @@ class AppliqationReporter {
    * @param {Object} result - Test result
    */
   async onTestEnd(test, result) {
-    this.totalTests++;
+    // Note: Don't increment totalTests here - it's incremented later for non-duplicates/non-orphans only
 
     try {
       // Extract UUID from test - check result.annotations first since test.info().annotations.push() adds to result
@@ -345,7 +434,24 @@ class AppliqationReporter {
 
       if (!uuid) {
         // Orphan test - no UUID found
-        this.orphanTests++;
+        const orphanKey = `${test.location?.file || 'unknown'}:${test.title}`;
+
+        if (!this.uniqueOrphans.has(orphanKey)) {
+          // First occurrence of this unique orphan
+          this.orphanTests++;
+          this.uniqueOrphans.set(orphanKey, {
+            file: path.basename(test.location?.file || 'unknown'),
+            title: test.title,
+            browsers: [deviceInfo.browser]
+          });
+        } else {
+          // Same orphan on different browser - just add browser to list
+          const orphan = this.uniqueOrphans.get(orphanKey);
+          if (!orphan.browsers.includes(deviceInfo.browser)) {
+            orphan.browsers.push(deviceInfo.browser);
+          }
+        }
+
         this.trackOrphan(runInfo.runId, test, result, deviceInfo.browser);
 
         logger.warn('Test without UUID', {
@@ -357,6 +463,72 @@ class AppliqationReporter {
         return;
       }
 
+      // Duplicate detection (per-run AND per-browser - allows same UUID across different browsers/devices)
+      const trackingKey = `${runInfo.runId}:${deviceInfo.browser}`;
+      const submittedUuids = this.submittedUuidsByRun.get(trackingKey) || new Map();
+
+      // Check per-run+browser map (allows same UUID for different browsers in same run)
+      if (submittedUuids.has(uuid)) {
+        const firstOccurrence = submittedUuids.get(uuid);
+        const firstFile = path.basename(firstOccurrence.file);
+        const currentFile = path.basename(test.location?.file || 'unknown');
+
+        // Track unique duplicates
+        if (!this.uniqueDuplicates.has(uuid)) {
+          // First time seeing this duplicate UUID
+          this.duplicateTests++;
+          this.uniqueDuplicates.set(uuid, {
+            uuid,
+            occurrences: [
+              {
+                file: firstFile,
+                title: firstOccurrence.title,
+                browser: firstOccurrence.browser
+              },
+              {
+                file: currentFile,
+                title: test.title,
+                browser: deviceInfo.browser
+              }
+            ]
+          });
+        } else {
+          // Already tracking this duplicate - add this occurrence
+          const duplicate = this.uniqueDuplicates.get(uuid);
+          duplicate.occurrences.push({
+            file: currentFile,
+            title: test.title,
+            browser: deviceInfo.browser
+          });
+        }
+
+        // Keep old duplicateDetails for backward compatibility (if needed)
+        this.duplicateDetails.push({
+          uuid,
+          firstFile,
+          firstTitle: firstOccurrence.title,
+          duplicateFile: currentFile,
+          duplicateTitle: test.title
+        });
+
+        logger.warn(`Duplicate UUID detected: ${uuid}`);
+        logger.warn(`  First: ${firstFile} -> "${firstOccurrence.title}"`);
+        logger.warn(`  Dup:   ${currentFile} -> "${test.title}"`);
+        return; // Skip duplicate submission
+      }
+
+      // Store UUID occurrence (per-run only)
+      submittedUuids.set(uuid, {
+        file: test.location?.file || 'unknown',
+        title: test.title,
+        browser: deviceInfo.browser
+      });
+      this.submittedUuidsByRun.set(trackingKey, submittedUuids);
+
+      // Count only tests that will be submitted (non-duplicate, non-orphan)
+      this.totalTests++;
+      this.validTests++; // Track tests with valid UUIDs
+
       // Create result object
       const testResult = {
         runId: runInfo.runId, // Add runId for batch submission
@@ -394,23 +566,271 @@ class AppliqationReporter {
     }
   }
 
+  /**
+   * Handle runs that have only orphan tests (no valid UUIDs).
+   * Deletes empty runs and shows clear error messages.
+   *
+   * @private
+   * @returns {Promise<Array>} Array of deleted runs
+   */
+  async handleOrphanOnlyRuns() {
+    if (!this.config.deleteOrphanOnlyRuns) {
+      return []; // Feature disabled
+    }
+
+    const deletedRuns = [];
+
+    for (const [projectKey, runInfo] of this.runsByProject.entries()) {
+      const orphanCount = this.orphansByRun.get(runInfo.runId)?.length || 0;
+      const validCount = this.resultsByRun.get(runInfo.runId)?.length || 0;
+
+      // CRITICAL CHECK: Delete ONLY if all tests are orphans
+      if (orphanCount > 0 && validCount === 0) {
+        // Show clear error message FIRST (before attempting deletion)
+        // This ensures users always see the message, even if deletion fails
+        this.printOrphanOnlyError(orphanCount, projectKey);
+
+        try {
+          logger.warn('Deleting orphan-only run', {
+            runId: runInfo.runId,
+            orphanCount,
+            projectKey
+          });
+
+          await this.client.deleteRun(runInfo.runId, 'all_tests_orphaned');
+          deletedRuns.push({ runId: runInfo.runId, orphanCount, projectKey });
+        } catch (error) {
+          logger.error('Failed to delete orphan-only run (may already be deleted)', {
+            error: error.message,
+            runId: runInfo.runId
+          });
+          // Still track as deleted since user saw the error message
+          deletedRuns.push({ runId: runInfo.runId, orphanCount, projectKey });
+        }
+      }
+    }
+
+    // Store for summary
+    this.deletedOrphanRuns = deletedRuns;
+    return deletedRuns;
+  }
+
+  /**
+   * Print error message for orphan-only runs.
+   *
+   * @param {number} orphanCount - Number of orphan tests
+   * @param {string} projectKey - Project key
+   * @private
+   */
+  printOrphanOnlyError(orphanCount, projectKey) {
+    console.error('\n╔════════════════════════════════════════════════════════════════════╗');
+    console.error('║  ❌ RUN CREATION FAILED - ALL TESTS MISSING UUID ANNOTATIONS      ║');
+    console.error('╠════════════════════════════════════════════════════════════════════╣');
+    console.error(`║  Project: ${projectKey.padEnd(56)} ║`);
+    console.error(`║  Orphan Tests: ${orphanCount.toString().padEnd(51)} ║`);
+    console.error('║                                                                    ║');
+    console.error('║  ⚠️  NO RESULTS WERE SUBMITTED TO APPLIQATION                      ║');
+    console.error('║  The test run was automatically deleted to prevent analytics       ║');
+    console.error('║  corruption. All tests are missing UUID annotations.               ║');
+    console.error('╠════════════════════════════════════════════════════════════════════╣');
+    console.error('║  ✅ ACTION REQUIRED: Add UUID Annotations                          ║');
+    console.error('╠════════════════════════════════════════════════════════════════════╣');
+    console.error('║                                                                    ║');
+    console.error('║  Option 1: Using test tags (Recommended)                          ║');
+    console.error('║  ─────────────────────────────────────────────────────────────     ║');
+    console.error('║  test(\'My Test\', { tag: \'@uuid:123-xxx-xxx\' }, async ({ page }) => {║');
+    console.error('║    // your test code                                               ║');
+    console.error('║  });                                                               ║');
+    console.error('║                                                                    ║');
+    console.error('║  Option 2: Using test annotations                                 ║');
+    console.error('║  ─────────────────────────────────────────────────────────────     ║');
+    console.error('║  test(\'My Test\', async ({ page }, testInfo) => {                  ║');
+    console.error('║    testInfo.annotations.push({                                     ║');
+    console.error('║      type: \'uuid\',                                                 ║');
+    console.error('║      description: \'123-xxx-xxx\'                                    ║');
+    console.error('║    });                                                             ║');
+    console.error('║  });                                                               ║');
+    console.error('║                                                                    ║');
+    console.error('║  Option 3: Using mapAppqUuid helper                                ║');
+    console.error('║  ─────────────────────────────────────────────────────────────     ║');
+    console.error('║  const { mapAppqUuid } = require(\'@appliqation/automation-sdk/utils\');║');
+    console.error('║  test(\'My Test\', async ({ page }, testInfo) => {                  ║');
+    console.error('║    mapAppqUuid(testInfo, \'123-xxx-xxx\');                           ║');
+    console.error('║  });                                                               ║');
+    console.error('╠════════════════════════════════════════════════════════════════════╣');
+    console.error('║  📚 WHERE TO FIND UUIDs                                            ║');
+    console.error('╠════════════════════════════════════════════════════════════════════╣');
+    console.error('║                                                                    ║');
+    console.error('║  1. Open your test scenario in Appliqation UI                      ║');
+    console.error('║  2. Find the test case you want to automate                        ║');
+    console.error('║  3. Copy the UUID from the test case details                       ║');
+    console.error('║     Format: {scenario-id}-{uuid} (e.g., 1154-7a17b809-0ff9...)     ║');
+    console.error('║                                                                    ║');
+    console.error('║  💡 Tip: Export UUIDs in bulk from Appliqation for faster setup    ║');
+    console.error('╚════════════════════════════════════════════════════════════════════╝\n');
+  }
+
+  /**
+   * Handle runs where ALL tests were rejected by backend validation
+   * This happens when tests have UUIDs but they're invalid (wrong project, format, duplicates)
+   * Called AFTER submission when we know backend rejection counts
+   * @private
+   * @returns {Array} Array of deleted runs
+   */
+  async handleAllRejectedRuns() {
+    if (!this.config.deleteOrphanOnlyRuns) {
+      return []; // Feature disabled
+    }
+
+    const deletedRuns = [];
+
+    for (const [projectKey, runInfo] of this.runsByProject.entries()) {
+      const submittedCount = this.resultsByRun.get(runInfo.runId)?.length || 0;
+      const orphanCount = this.orphansByRun.get(runInfo.runId)?.length || 0;
+      const rejectedCount = this.rejectionsByRun.get(runInfo.runId) || 0;
+
+      // Calculate how many were actually accepted by backend
+      const acceptedCount = submittedCount - rejectedCount;
+
+      // CRITICAL CHECK: Delete ONLY if we submitted tests but ALL were rejected
+      // AND there are no orphans (orphans are handled separately)
+      if (submittedCount > 0 && acceptedCount === 0 && orphanCount === 0) {
+        // Show user-friendly error message FIRST (before deletion attempt)
+        this.printAllRejectedError(submittedCount, rejectedCount, projectKey);
+
+        try {
+          logger.warn('Deleting all-rejected run', {
+            runId: runInfo.runId,
+            submittedCount,
+            rejectedCount,
+            acceptedCount,
+            projectKey
+          });
+          await this.client.deleteRun(runInfo.runId, 'all_tests_rejected');
+          deletedRuns.push({
+            runId: runInfo.runId,
+            submittedCount,
+            rejectedCount,
+            projectKey
+          });
+        } catch (error) {
+          logger.error('Failed to delete all-rejected run (may already be deleted)', {
+            error: error.message,
+            runId: runInfo.runId
+          });
+          // Non-fatal: Continue even if deletion fails
+          // Still track as deleted since end result is the same
+          deletedRuns.push({
+            runId: runInfo.runId,
+            submittedCount,
+            rejectedCount,
+            projectKey
+          });
+        }
+      }
+    }
+
+    // Track deleted rejected runs
+    if (deletedRuns.length > 0) {
+      this.deletedOrphanRuns = [...(this.deletedOrphanRuns || []), ...deletedRuns];
+    }
+
+    return deletedRuns;
+  }
+
+  /**
+   * Print user-friendly error message for all-rejected runs
+   * @private
+   */
+  printAllRejectedError(submittedCount, rejectedCount, projectKey) {
+    console.error('\n╔════════════════════════════════════════════════════════════════════╗');
+    console.error('║  ❌ RUN CREATION FAILED - ALL TESTS REJECTED BY BACKEND           ║');
+    console.error('╠════════════════════════════════════════════════════════════════════╣');
+    console.error(`║  Project: ${projectKey.padEnd(56)} ║`);
+    console.error(`║  Tests Submitted: ${submittedCount.toString().padEnd(47)} ║`);
+    console.error(`║  Tests Rejected:  ${rejectedCount.toString().padEnd(47)} ║`);
+    console.error('║                                                                    ║');
+    console.error('║  ⚠️  NO RESULTS WERE ACCEPTED BY APPLIQATION                       ║');
+    console.error('║  The test run was automatically deleted to prevent analytics       ║');
+    console.error('║  corruption. All submitted tests were rejected by the backend.     ║');
+    console.error('╠════════════════════════════════════════════════════════════════════╣');
+    console.error('║  ✅ COMMON REJECTION REASONS                                       ║');
+    console.error('╠════════════════════════════════════════════════════════════════════╣');
+    console.error('║                                                                    ║');
+    console.error('║  1. INVALID UUID FORMAT                                            ║');
+    console.error('║  ─────────────────────────────────────────────────────────────     ║');
+    console.error('║  ❌ Wrong: \'1154-uuid-here-99\' (extra suffix)                      ║');
+    console.error('║  ✅ Right: \'1154-7f991165-9f59-47e1-8e90-d57d2e9cbf66\'             ║');
+    console.error('║                                                                    ║');
+    console.error('║  2. WRONG PROJECT                                                  ║');
+    console.error('║  ─────────────────────────────────────────────────────────────     ║');
+    console.error('║  Using UUID from project 1162 in project 1154 tests               ║');
+    console.error('║  ✅ Solution: Use UUIDs from the correct project                   ║');
+    console.error('║                                                                    ║');
+    console.error('║  3. DUPLICATE UUIDs                                                ║');
+    console.error('║  ─────────────────────────────────────────────────────────────     ║');
+    console.error('║  Multiple tests using the same UUID in one run                    ║');
+    console.error('║  ✅ Solution: Each test needs a unique UUID                        ║');
+    console.error('║                                                                    ║');
+    console.error('║  4. TEST CASE DOESN\'T EXIST                                        ║');
+    console.error('║  ─────────────────────────────────────────────────────────────     ║');
+    console.error('║  UUID doesn\'t match any test case in your project                 ║');
+    console.error('║  ✅ Solution: Verify UUID exists in Appliqation Test Cases         ║');
+    console.error('╠════════════════════════════════════════════════════════════════════╣');
+    console.error('║  📋 HOW TO FIX                                                     ║');
+    console.error('╠════════════════════════════════════════════════════════════════════╣');
+    console.error('║                                                                    ║');
+    console.error('║  1. Check test logs above for specific rejection reasons          ║');
+    console.error('║  2. Verify UUIDs in Appliqation portal → Test Cases                ║');
+    console.error('║  3. Ensure UUID format: {nid}-{uuid} (no extra suffixes)          ║');
+    console.error('║  4. Confirm UUIDs belong to the correct project                    ║');
+    console.error('║  5. Remove any duplicate UUID mappings                             ║');
+    console.error('║                                                                    ║');
+    console.error('╚════════════════════════════════════════════════════════════════════╝\n');
+  }
+
   /**
    * Called once after all tests complete
    */
   async onEnd(result) {
-    logger.info('Test run complete. Submitting results...');
+    logger.info('Test run complete.');
 
     try {
-      // Submit batched results
-      if (this.config.batchSubmit) {
-        await this.submitBatchedResults();
-      }
+      // Handle orphan-only runs BEFORE submitting results
+      const orphanDeletedRuns = await this.handleOrphanOnlyRuns();
+
+      // Skip submission if --appq flag not present
+      if (this.appqEnabled) {
+        logger.info('Submitting results to Appliqation...');
+
+        // Submit batched results
+        if (this.config.batchSubmit) {
+          await this.submitBatchedResults();
+        }
 
-      // Submit orphan tests
-      await this.submitOrphanTests();
+        // Submit orphan tests
+        await this.submitOrphanTests();
+
+        // Handle all-rejected runs AFTER submission (when we know backend rejection counts)
+        const rejectedDeletedRuns = await this.handleAllRejectedRuns();
+
+        // Combine all deleted runs
+        const allDeletedRuns = [...(orphanDeletedRuns || []), ...(rejectedDeletedRuns || [])];
+
+        // Exit with error code if any runs were deleted
+        if (allDeletedRuns.length > 0 && this.config.failOnOrphanOnlyRuns) {
+          logger.error('Exiting with error code due to deleted runs (orphan or rejected)');
+          process.exitCode = 1; // Set error exit code for CI/CD
+        }
+      } else {
+        logger.info('Appliqation reporting disabled. Skipping result submission.');
+      }
 
-      // Print summary
+      // Print summary (always show, even if not submitted)
       this.printSummary();
+
+      // Write summary to file (always write, even if not submitted)
+      await this.writeSummaryToFile();
     } catch (error) {
       logger.error('Error in onEnd', {
         error: error.message
@@ -453,6 +873,11 @@ class AppliqationReporter {
           }
         });
 
+        // Track backend validation rejections (global and per-run)
+        const rejectedCount = summary.failed || 0;
+        this.backendRejectedTests += rejectedCount;
+        this.rejectionsByRun.set(runId, rejectedCount);
+
         logger.info(`Results submitted for run ${runId}`, {
           success: summary.success,
           failed: summary.failed,
@@ -558,27 +983,310 @@ class AppliqationReporter {
    * @private
    */
   printSummary() {
+    const testsSubmitted = this.totalTests;
+    const testsAccepted = testsSubmitted - this.backendRejectedTests;
+
     console.log('\n╔═══════════════════════════════════════════════════════════╗');
     console.log('║         Appliqation Test Results Summary                 ║');
     console.log('╠═══════════════════════════════════════════════════════════╣');
-    console.log(`║  Total Tests:       ${this.totalTests.toString().padStart(5)}                               ║`);
-    console.log(`║  Passed:            ${this.passedTests.toString().padStart(5)}                               ║`);
-    console.log(`║  Failed:            ${this.failedTests.toString().padStart(5)}                               ║`);
-    console.log(`║  Skipped:           ${this.skippedTests.toString().padStart(5)}                               ║`);
-    console.log(`║  Orphan (No UUID):  ${this.orphanTests.toString().padStart(5)}                               ║`);
+
+    // Show reporting status
+    if (!this.appqEnabled) {
+      console.log('║  ⚠️  Appliqation Reporting: DISABLED                      ║');
+      console.log('║      (Set APPQ_ENABLE=1 or add -- --appq flag)            ║');
+      console.log('╠═══════════════════════════════════════════════════════════╣');
+    } else {
+      console.log('║  Submitted to Backend:                                    ║');
+      console.log(`║    Total Submitted: ${testsSubmitted.toString().padStart(5)}                               ║`);
+      console.log(`║    ✅ Accepted:     ${testsAccepted.toString().padStart(5)}                               ║`);
+      console.log(`║    ❌ Rejected:     ${this.backendRejectedTests.toString().padStart(5)}                               ║`);
+      console.log('║                                                           ║');
+    }
+    console.log('║                                                           ║');
+    console.log('║  Test Execution Results (Playwright):                    ║');
+    console.log(`║    Passed:          ${this.passedTests.toString().padStart(5)}                               ║`);
+    console.log(`║    Failed:          ${this.failedTests.toString().padStart(5)}                               ║`);
+    console.log(`║    Skipped:         ${this.skippedTests.toString().padStart(5)}                               ║`);
+    console.log('║                                                           ║');
+    console.log('║  Not Submitted:                                           ║');
+    console.log(`║    Orphan (No UUID):${this.orphanTests.toString().padStart(5)}                               ║`);
+    console.log(`║    Duplicates:      ${this.duplicateTests.toString().padStart(5)}                               ║`);
     console.log('╠═══════════════════════════════════════════════════════════╣');
-    console.log(`║  Run Matrices Created: ${this.runsByProject.size}                               ║`);
 
-    for (const [projectKey, runInfo] of this.runsByProject.entries()) {
-      console.log(`║    ${projectKey}: ${runInfo.runId}            ║`);
+    // Only show run matrices if reporting is enabled
+    if (this.appqEnabled && this.runsByProject.size > 0) {
+      console.log(`║  Run Matrices Created: ${this.runsByProject.size}                               ║`);
+
+      for (const [projectKey, runInfo] of this.runsByProject.entries()) {
+        console.log(`║    ${projectKey}: ${runInfo.runId}            ║`);
+      }
+
+      // Show deleted orphan-only runs
+      if (this.deletedOrphanRuns.length > 0) {
+        console.log(`║  Deleted (Orphan-only): ${this.deletedOrphanRuns.length}                             ║`);
+      }
     }
 
     console.log('╚═══════════════════════════════════════════════════════════╝\n');
 
+    if (this.duplicateTests > 0) {
+      console.log(`\n⚠️  Warning: ${this.duplicateTests} duplicate UUID(s) detected!\n`);
+
+      // Show details of each unique duplicate UUID
+      let index = 1;
+      for (const duplicate of this.uniqueDuplicates.values()) {
+        console.log(`${index}. UUID: ${duplicate.uuid}`);
+        console.log(`   Occurrences (${duplicate.occurrences.length}):`);
+        duplicate.occurrences.forEach((occ, i) => {
+          console.log(`   ${i + 1}) ${occ.file} - "${occ.title}" (${occ.browser})`);
+        });
+        console.log('');
+        index++;
+      }
+
+      console.log('Each test should have a unique UUID within a browser.\n');
+    }
+
+    if (this.orphanTests > 0) {
+      console.log(`\n⚠️  ${this.orphanTests} test(s) missing UUIDs - not submitted to Appliqation\n`);
+
+      // Show details of each unique orphan test
+      let index = 1;
+      for (const orphan of this.uniqueOrphans.values()) {
+        console.log(`${index}. File: ${orphan.file}`);
+        console.log(`   Test: "${orphan.title}"`);
+        console.log(`   Browsers: ${orphan.browsers.join(', ')}\n`);
+        index++;
+      }
+
+      console.log('Fix: Add UUID tag → test(\'name\', { tag: \'@uuid:1154-xxx...\' }, async () => {...});\n');
+    }
+  }
+
+  /**
+   * Write execution summary to file
+   * Creates timestamped txt file in AppQ_Execution_Summary folder
+   * @private
+   */
+  async writeSummaryToFile() {
+    const fs = require('fs').promises;
+    const path = require('path');
+
+    try {
+      this.executionEndTime = new Date();
+      const duration = this.executionEndTime - this.executionStartTime;
+
+      // Build output directory path
+      // If playwrightOutputDir already contains 'test-results' (from config._internal.outputDir),
+      // don't add it again. Otherwise, add 'test-results' to the path.
+      const baseDir = this.playwrightOutputDir;
+      const needsTestResults = !baseDir.includes('test-results');
+
+      const summaryDir = needsTestResults
+        ? path.join(baseDir, 'test-results', 'AppQ_Execution_Summary')
+        : path.join(baseDir, 'AppQ_Execution_Summary');
+
+      // Create directory if it doesn't exist
+      await fs.mkdir(summaryDir, { recursive: true });
+
+      // Build filename with run title and timestamp
+      const runTitle = this.config.title || 'execution_summary';
+      const timestamp = this.formatDateTimeForFilename(this.executionStartTime);
+      const filename = `${runTitle}_${timestamp}.txt`;
+      const filepath = path.join(summaryDir, filename);
+
+      // Build comprehensive summary content
+      const summaryContent = this.buildSummaryContent(duration);
+
+      // Write to file
+      await fs.writeFile(filepath, summaryContent, 'utf8');
+
+      logger.info(`Execution summary saved to: ${filepath}`);
+      console.log(`\n📄 Execution summary saved: ${filename}`);
+
+    } catch (error) {
+      logger.error('Failed to write summary file', { error: error.message });
+      // Don't throw - file writing failure should not break test run
+    }
+  }
+
+  /**
+   * Format date/time for filename: 2025-01-21_14-30-45
+   * @private
+   */
+  formatDateTimeForFilename(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    const seconds = String(date.getSeconds()).padStart(2, '0');
+
+    return `${year}-${month}-${day}_${hours}-${minutes}-${seconds}`;
+  }
+
+  /**
+   * Build comprehensive summary content for file
+   * @private
+   */
+  buildSummaryContent(duration) {
+    const lines = [];
+
+    // Header
+    lines.push('═══════════════════════════════════════════════════════════');
+    lines.push('          APPLIQATION TEST EXECUTION SUMMARY');
+    lines.push('═══════════════════════════════════════════════════════════');
+    lines.push('');
+
+    // Execution Metadata
+    lines.push('EXECUTION METADATA:');
+    lines.push('─────────────────────────────────────────────────────────');
+    lines.push(`Start Time:     ${this.executionStartTime.toISOString()}`);
+    lines.push(`End Time:       ${this.executionEndTime.toISOString()}`);
+    lines.push(`Duration:       ${this.formatDuration(duration)}`);
+    lines.push(`Run Title:      ${this.config.title || 'N/A'}`);
+    lines.push(`Appq Reporting: ${this.appqEnabled ? 'ENABLED' : 'DISABLED (Set APPQ_ENABLE=1 or add -- --appq flag)'}`);
+    lines.push('');
+
+    // Test Results Summary (ASCII Table from printSummary)
+    const testsSubmitted = this.totalTests;
+    const testsAccepted = testsSubmitted - this.backendRejectedTests;
+
+    lines.push('╔═══════════════════════════════════════════════════════════╗');
+    lines.push('║         Appliqation Test Results Summary                 ║');
+    lines.push('╠═══════════════════════════════════════════════════════════╣');
+
+    // Show submission status
+    if (!this.appqEnabled) {
+      lines.push('║  ⚠️  Appliqation Reporting: DISABLED                      ║');
+      lines.push('║      (Set APPQ_ENABLE=1 or add -- --appq flag)            ║');
+      lines.push('╠═══════════════════════════════════════════════════════════╣');
+    } else {
+      lines.push('║  Submitted to Backend:                                    ║');
+      lines.push(`║    Total Submitted: ${testsSubmitted.toString().padStart(5)}                               ║`);
+      lines.push(`║    ✅ Accepted:     ${testsAccepted.toString().padStart(5)}                               ║`);
+      lines.push(`║    ❌ Rejected:     ${this.backendRejectedTests.toString().padStart(5)}                               ║`);
+      lines.push('║                                                           ║');
+    }
+    lines.push('║  Test Execution Results (Playwright):                    ║');
+    lines.push(`║    Passed:          ${this.passedTests.toString().padStart(5)}                               ║`);
+    lines.push(`║    Failed:          ${this.failedTests.toString().padStart(5)}                               ║`);
+    lines.push(`║    Skipped:         ${this.skippedTests.toString().padStart(5)}                               ║`);
+    lines.push('║                                                           ║');
+    lines.push('║  Not Submitted:                                           ║');
+    lines.push(`║    Orphan (No UUID):${this.orphanTests.toString().padStart(5)}                               ║`);
+    lines.push(`║    Duplicates:      ${this.duplicateTests.toString().padStart(5)}                               ║`);
+    lines.push('╠═══════════════════════════════════════════════════════════╣');
+
+    // Run IDs (only show if reporting is enabled)
+    if (this.appqEnabled && this.runsByProject.size > 0) {
+      lines.push(`║  Run Matrices Created: ${this.runsByProject.size.toString().padStart(5)}                           ║`);
+      for (const [projectKey, runInfo] of this.runsByProject) {
+        const displayKey = projectKey.length > 30 ? projectKey.substring(0, 27) + '...' : projectKey;
+        const paddedKey = displayKey.padEnd(30);
+        lines.push(`║    ${paddedKey}: ${runInfo.runId.padEnd(20)} ║`);
+      }
+
+      // Show deleted orphan-only runs
+      if (this.deletedOrphanRuns.length > 0) {
+        lines.push(`║  Deleted (Orphan-only): ${this.deletedOrphanRuns.length.toString().padStart(5)}                        ║`);
+      }
+    }
+
+    lines.push('╚═══════════════════════════════════════════════════════════╝');
+    lines.push('');
+
+    // Detailed Errors Section
+    if (this.duplicateTests > 0 || this.orphanTests > 0 || this.backendRejectedTests > 0) {
+      lines.push('');
+      lines.push('DETAILED ERRORS & WARNINGS:');
+      lines.push('═══════════════════════════════════════════════════════════');
+      lines.push('');
+    }
+
+    // Duplicate UUIDs Details
+    if (this.duplicateTests > 0 && this.uniqueDuplicates.size > 0) {
+      lines.push('⚠️  DUPLICATE UUIDs DETECTED:');
+      lines.push('─────────────────────────────────────────────────────────');
+      lines.push(`Count: ${this.duplicateTests} unique UUID(s)`);
+      lines.push('');
+
+      // List each unique duplicate UUID with all occurrences
+      let index = 1;
+      for (const duplicate of this.uniqueDuplicates.values()) {
+        lines.push(`${index}. UUID: ${duplicate.uuid}`);
+        lines.push(`   Occurrences (${duplicate.occurrences.length}):`);
+        duplicate.occurrences.forEach((occ, i) => {
+          lines.push(`   ${i + 1}) File: ${occ.file}`);
+          lines.push(`      Test: "${occ.title}"`);
+          lines.push(`      Browser: ${occ.browser}`);
+        });
+        lines.push('');
+        index++;
+      }
+
+      lines.push('Action Required: Each test should have a unique UUID within a browser.');
+      lines.push('');
+    }
+
+    // Orphan Tests Warning
     if (this.orphanTests > 0) {
-      console.log('⚠️  Warning: Some tests are missing UUID annotations!');
-      console.log('   Add UUIDs to map tests to Appliqation test cases:');
-      console.log('   test(\'My Test\', { tag: \'@uuid:123-xxx-...\' }, async ({ page }) => { ... });\n');
+      lines.push('⚠️  TESTS MISSING UUIDs (Not Submitted):');
+      lines.push('─────────────────────────────────────────────────────────');
+      lines.push(`Count: ${this.orphanTests} unique test(s)`);
+      lines.push('');
+
+      // List each unique orphan test with details
+      let index = 1;
+      for (const orphan of this.uniqueOrphans.values()) {
+        lines.push(`${index}. File: ${orphan.file}`);
+        lines.push(`   Test: "${orphan.title}"`);
+        lines.push(`   Browsers: ${orphan.browsers.join(', ')}`);
+        lines.push('');
+        index++;
+      }
+
+      lines.push('Action Required: Add UUID tags to submit results');
+      lines.push('Example: test(\'name\', { tag: \'@uuid:1154-abc-...\' }, async () => {...});');
+      lines.push('');
+    }
+
+    // Backend Rejections
+    if (this.backendRejectedTests > 0) {
+      lines.push('BACKEND VALIDATION REJECTIONS:');
+      lines.push('─────────────────────────────────────────────────────────');
+      lines.push(`Total rejected: ${this.backendRejectedTests}`);
+      lines.push('');
+      lines.push('These test cases were rejected due to project ownership validation.');
+      lines.push('The test case UUID does not belong to the project associated with');
+      lines.push('your API key. Verify the correct project and test case mappings.');
+      lines.push('');
+    }
+
+    // Footer
+    lines.push('═══════════════════════════════════════════════════════════');
+    lines.push(`Generated by Appliqation SDK v${require('../../../package.json').version}`);
+    lines.push(`Timestamp: ${new Date().toISOString()}`);
+    lines.push('═══════════════════════════════════════════════════════════');
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Format duration in human-readable format
+   * @private
+   */
+  formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+
+    if (hours > 0) {
+      return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+    } else if (minutes > 0) {
+      return `${minutes}m ${seconds % 60}s`;
+    } else {
+      return `${seconds}s`;
     }
   }