@appliqation/automation-sdk 2.2.0 → 2.3.1

package/src/reporters/playwright/AppliqationReporter.js

@@ -95,6 +95,8 @@ class AppliqationReporter {
       batchSubmit: true,
       batchSize: 50,
       logLevel: 'info',
+      deleteOrphanOnlyRuns: config.deleteOrphanOnlyRuns !== false,
+      failOnOrphanOnlyRuns: config.failOnOrphanOnlyRuns !== false,
       ...config
     };
 
@@ -155,9 +157,14 @@ class AppliqationReporter {
     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;
@@ -427,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', {
@@ -439,41 +463,46 @@ class AppliqationReporter {
         return;
       }
 
-      // Duplicate detection (global across all runs + per run)
-      const trackingKey = runInfo.runId;
+      // 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();
 
-      const existingGlobal = this.submittedUuidsGlobal.get(uuid);
-
-      // Check global map first to catch duplicates across files/runs/browsers
-      if (existingGlobal) {
-        const firstFile = path.basename(existingGlobal.file);
-        const currentFile = path.basename(test.location?.file || 'unknown');
-
-        this.duplicateTests++;
-        // Note: Don't increment skippedTests - duplicates have their own category
-        this.duplicateDetails.push({
-          uuid,
-          firstFile,
-          firstTitle: existingGlobal.title,
-          duplicateFile: currentFile,
-          duplicateTitle: test.title
-        });
-
-        logger.warn(`Duplicate UUID detected (global): ${uuid}`);
-        logger.warn(`  First: ${firstFile} -> "${existingGlobal.title}"`);
-        logger.warn(`  Dup:   ${currentFile} -> "${test.title}"`);
-        return; // Skip duplicate submission
-      }
-
-      // Check per-run map to allow future per-run reporting if needed
+      // 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');
 
-        this.duplicateTests++;
-        // Note: Don't increment skippedTests - duplicates have their own category
+        // 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,
@@ -488,23 +517,17 @@ class AppliqationReporter {
         return; // Skip duplicate submission
       }
 
-      // Store UUID occurrence
+      // 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);
-      // Also track globally to catch duplicates across files/runs/browsers
-      this.submittedUuidsGlobal.set(uuid, {
-        file: test.location?.file || 'unknown',
-        title: test.title,
-        browser: deviceInfo.browser,
-        runId: runInfo.runId
-      });
 
       // 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 = {
@@ -543,6 +566,229 @@ 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
    */
@@ -550,6 +796,9 @@ class AppliqationReporter {
     logger.info('Test run complete.');
 
     try {
+      // 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...');
@@ -561,6 +810,18 @@ class AppliqationReporter {
 
         // 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.');
       }
@@ -612,8 +873,10 @@ class AppliqationReporter {
           }
         });
 
-        // Track backend validation rejections
-        this.backendRejectedTests += summary.failed || 0;
+        // 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,
@@ -682,14 +945,14 @@ class AppliqationReporter {
    */
   mapStatus(status) {
     const statusMap = {
-      'passed': 'passed',
-      'failed': 'failed',
-      'timedOut': 'failed',
-      'skipped': 'skipped',
-      'interrupted': 'skipped'
+      'passed': 'Pass',      // Capital case to match backend expectations
+      'failed': 'Fail',      // Capital case to match backend expectations
+      'timedOut': 'Fail',
+      'skipped': 'Skipped',  // Capital case to match backend expectations
+      'interrupted': 'Skipped'
     };
 
-    return statusMap[status] || 'failed';
+    return statusMap[status] || 'Fail';
   }
 
   /**
@@ -757,27 +1020,46 @@ class AppliqationReporter {
       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('⚠️  Warning: Duplicate UUID(s) detected!');
-      console.log('');
-      this.duplicateDetails.forEach((dup, index) => {
-        console.log(`${index + 1}. UUID: ${dup.uuid}`);
-        console.log(`   First occurrence: ${dup.firstFile} - "${dup.firstTitle}"`);
-        console.log(`   Duplicate found:  ${dup.duplicateFile} - "${dup.duplicateTitle}"`);
+      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('');
-      });
-      console.log(`Total: ${this.duplicateTests} duplicate test(s) skipped.`);
+        index++;
+      }
+
       console.log('Each test should have a unique UUID within a browser.\n');
     }
 
     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');
+      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');
     }
   }
 
@@ -904,6 +1186,11 @@ class AppliqationReporter {
         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('╚═══════════════════════════════════════════════════════════╝');
@@ -918,30 +1205,49 @@ class AppliqationReporter {
     }
 
     // Duplicate UUIDs Details
-    if (this.duplicateTests > 0 && this.duplicateDetails.length > 0) {
-      lines.push('DUPLICATE UUIDs DETECTED:');
+    if (this.duplicateTests > 0 && this.uniqueDuplicates.size > 0) {
+      lines.push('⚠️  DUPLICATE UUIDs DETECTED:');
       lines.push('─────────────────────────────────────────────────────────');
-      this.duplicateDetails.forEach((dup, idx) => {
-        lines.push(`${idx + 1}. UUID: ${dup.uuid}`);
-        lines.push(`   First occurrence: ${dup.firstFile}`);
-        lines.push(`                     "${dup.firstTitle}"`);
-        lines.push(`   Duplicate found:  ${dup.duplicateFile}`);
-        lines.push(`                     "${dup.duplicateTitle}"`);
+      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) {
-      lines.push('ORPHAN TESTS (Missing UUID Annotations):');
+      lines.push('⚠️  TESTS MISSING UUIDs (Not Submitted):');
       lines.push('─────────────────────────────────────────────────────────');
-      lines.push(`Total orphan tests: ${this.orphanTests}`);
+      lines.push(`Count: ${this.orphanTests} unique test(s)`);
       lines.push('');
-      lines.push('These tests are missing UUID annotations. Add UUIDs to map tests');
-      lines.push('to Appliqation test cases:');
-      lines.push('  test(\'My Test\', { tag: \'@uuid:123-xxx-...\' }, async ({ page }) => {');
-      lines.push('    // test code');
-      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('');
     }
 

package/src/reporters/playwright/helpers/UuidExtractor.js

@@ -120,16 +120,21 @@ class UuidExtractor {
     for (const annotation of annotations) {
       if (!annotation || typeof annotation !== 'object') continue;
 
-      // Check annotation type
+      // Check annotation type - STRICT validation for explicit UUID annotations
       if (annotation.type === 'uuid' || annotation.type === 'appliqation' || annotation.type === 'appliqation-uuid') {
         const uuid = annotation.description || annotation.value;
         if (uuid && UuidValidator.validate(uuid)) {
           return uuid;
         }
+        // If UUID type annotation exists but invalid, do NOT try pattern extraction
+        // This ensures invalid UUIDs are treated as orphans, not auto-corrected
+        if (uuid) {
+          return null; // Invalid UUID explicitly provided -> treat as orphan
+        }
       }
 
-      // Check annotation description for UUID
-      if (annotation.description) {
+      // Check annotation description for UUID (only for non-UUID-type annotations)
+      if (annotation.description && annotation.type !== 'uuid' && annotation.type !== 'appliqation' && annotation.type !== 'appliqation-uuid') {
         const uuid = this.extractFromTitle(annotation.description);
         if (uuid) return uuid;
       }

package/src/services/ResultService.js

@@ -2,8 +2,9 @@ const logger = require('../utils/logger');
 const { normalizeBrowser } = require('../utils/RunDataNormalizer');
 
 class ResultService {
-  constructor(httpClient, config = { options: {} }) {
+  constructor(httpClient, taggingService = null, config = { options: {} }) {
     this.http = httpClient;
+    this.tagging = taggingService;
     this.config = config;
   }
 
@@ -51,6 +52,18 @@ class ResultService {
         throw new Error(response.error || 'Result submission failed');
       }
 
+      // Auto-tag accepted result (await to ensure completion)
+      if (this.tagging && this.tagging.isEnabled()) {
+        try {
+          await this.tagging.autoTagAcceptedResults([result.uuid]);
+        } catch (err) {
+          logger.debug('Background tagging failed', {
+            error: err.message,
+            uuid: result.uuid
+          });
+        }
+      }
+
       return response.data || response;
     } catch (error) {
       logger.error('Failed to submit result', {
@@ -242,6 +255,28 @@ class ResultService {
 
     logger.info('Batch submission completed', summary);
 
+    // Auto-tag accepted results (await to ensure completion before reporter exits)
+    if (this.tagging && this.tagging.isEnabled() && allResults.length > 0) {
+      const acceptedUuids = allResults.map(r => r.uuid).filter(Boolean);
+
+      try {
+        const tagResult = await this.tagging.autoTagAcceptedResults(acceptedUuids);
+        if (tagResult.tagged > 0) {
+          console.log(`✅ Auto-tagged ${tagResult.tagged} test case(s) with "${this.tagging.tagName}"`);
+          if (tagResult.skipped > 0) {
+            console.log(`ℹ️  Skipped ${tagResult.skipped} test case(s) - already tagged with "${this.tagging.tagName}"`);
+          }
+        } else if (tagResult.skipped > 0) {
+          console.log(`ℹ️  All ${tagResult.skipped} test case(s) already tagged with "${this.tagging.tagName}" - skipping`);
+        }
+      } catch (err) {
+        logger.warn('Auto-tagging failed (non-blocking)', {
+          error: err.message,
+          count: acceptedUuids.length
+        });
+      }
+    }
+
     return summary;
   }