From 20cbab1d64a6d75b0ae717d8c76ff82a007a22e1 Mon Sep 17 00:00:00 2001
From: dpetcu <dpetcu@adobe.com>
Date: Wed, 15 Oct 2025 16:57:52 +0300
Subject: [PATCH 01/20] feat(a11y): implement accessibility mobile audit data
 processing (V1)

---
 src/accessibility/handler-desktop.js       |  40 +++++
 src/accessibility/handler-mobile.js        |  40 +++++
 src/accessibility/handler.js               | 167 ++++++++++++++++++++-
 src/accessibility/utils/data-processing.js | 151 ++++++++++++++++---
 src/accessibility/utils/report-oppty.js    |  63 ++++++--
 src/accessibility/utils/scrape-utils.js    |  28 +++-
 src/index.js                               |   4 +
 7 files changed, 453 insertions(+), 40 deletions(-)
 create mode 100644 src/accessibility/handler-desktop.js
 create mode 100644 src/accessibility/handler-mobile.js

diff --git a/src/accessibility/handler-desktop.js b/src/accessibility/handler-desktop.js
new file mode 100644
index 000000000..ae51ea388
--- /dev/null
+++ b/src/accessibility/handler-desktop.js
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2025 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import { Audit } from '@adobe/spacecat-shared-data-access';
+import { AuditBuilder } from '../common/audit-builder.js';
+import {
+  processImportStep,
+  scrapeAccessibilityData,
+  createProcessAccessibilityOpportunitiesWithDevice,
+} from './handler.js';
+
+const { AUDIT_STEP_DESTINATIONS } = Audit;
+
+// Desktop-specific scraping function
+async function scrapeAccessibilityDataDesktop(context) {
+  return scrapeAccessibilityData(context, 'desktop');
+}
+
+export default new AuditBuilder()
+  .addStep(
+    'processImport',
+    processImportStep,
+    AUDIT_STEP_DESTINATIONS.IMPORT_WORKER,
+  )
+  .addStep(
+    'scrapeAccessibilityData',
+    scrapeAccessibilityDataDesktop,
+    AUDIT_STEP_DESTINATIONS.CONTENT_SCRAPER,
+  )
+  .addStep('processAccessibilityOpportunities', createProcessAccessibilityOpportunitiesWithDevice('desktop'))
+  .build();
diff --git a/src/accessibility/handler-mobile.js b/src/accessibility/handler-mobile.js
new file mode 100644
index 000000000..27418701e
--- /dev/null
+++ b/src/accessibility/handler-mobile.js
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2025 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import { Audit } from '@adobe/spacecat-shared-data-access';
+import { AuditBuilder } from '../common/audit-builder.js';
+import {
+  processImportStep,
+  scrapeAccessibilityData,
+  createProcessAccessibilityOpportunitiesWithDevice,
+} from './handler.js';
+
+const { AUDIT_STEP_DESTINATIONS } = Audit;
+
+// Mobile-specific scraping function
+async function scrapeAccessibilityDataMobile(context) {
+  return scrapeAccessibilityData(context, 'mobile');
+}
+
+export default new AuditBuilder()
+  .addStep(
+    'processImport',
+    processImportStep,
+    AUDIT_STEP_DESTINATIONS.IMPORT_WORKER,
+  )
+  .addStep(
+    'scrapeAccessibilityData',
+    scrapeAccessibilityDataMobile,
+    AUDIT_STEP_DESTINATIONS.CONTENT_SCRAPER,
+  )
+  .addStep('processAccessibilityOpportunities', createProcessAccessibilityOpportunitiesWithDevice('mobile'))
+  .build();
diff --git a/src/accessibility/handler.js b/src/accessibility/handler.js
index 2bf1eb76e..2cefa46e3 100644
--- a/src/accessibility/handler.js
+++ b/src/accessibility/handler.js
@@ -30,6 +30,7 @@ import { URL_SOURCE_SEPARATOR, A11Y_METRICS_AGGREGATOR_IMPORT_TYPE, WCAG_CRITERI
 
 const { AUDIT_STEP_DESTINATIONS } = Audit;
 const AUDIT_TYPE_ACCESSIBILITY = Audit.AUDIT_TYPES.ACCESSIBILITY; // Defined audit type
+const AUDIT_CONCURRENCY = 10; // number of urls to scrape at a time
 
 export async function processImportStep(context) {
   const { site, finalUrl } = context;
@@ -46,7 +47,7 @@ export async function processImportStep(context) {
 }
 
 // First step: sends a message to the content scraper to generate accessibility audits
-export async function scrapeAccessibilityData(context) {
+export async function scrapeAccessibilityData(context, deviceType = 'desktop') {
   const {
     site, log, finalUrl, env, s3Client, dataAccess,
   } = context;
@@ -60,7 +61,7 @@ export async function scrapeAccessibilityData(context) {
       error: errorMsg,
     };
   }
-  log.debug(`[A11yAudit] Step 1: Preparing content scrape for accessibility audit for ${site.getBaseURL()} with siteId ${siteId}`);
+  log.debug(`[A11yAudit] Step 1: Preparing content scrape for ${deviceType} accessibility audit for ${site.getBaseURL()} with siteId ${siteId}`);
 
   let urlsToScrape = [];
   urlsToScrape = await getUrlsForAudit(s3Client, bucketName, siteId, log);
@@ -102,6 +103,7 @@ export async function scrapeAccessibilityData(context) {
 
   // The first step MUST return auditResult and fullAuditRef.
   // fullAuditRef could point to where the raw scraped data will be stored (e.g., S3 path).
+  const storagePrefix = deviceType === 'mobile' ? 'accessibility-mobile' : 'accessibility';
   return {
     auditResult: {
       status: 'SCRAPING_REQUESTED',
@@ -114,6 +116,11 @@ export async function scrapeAccessibilityData(context) {
     siteId,
     jobId: siteId,
     processingType: AUDIT_TYPE_ACCESSIBILITY,
+    device: deviceType,
+    options: {
+      storagePrefix,
+    },
+    concurrency: AUDIT_CONCURRENCY,
   };
 }
 
@@ -243,6 +250,162 @@ export async function processAccessibilityOpportunities(context) {
   };
 }
 
+// Factory function to create device-specific processing function
+export function createProcessAccessibilityOpportunitiesWithDevice(deviceType) {
+  return async function processAccessibilityOpportunitiesWithDevice(context) {
+    const {
+      site, log, s3Client, env, dataAccess, sqs,
+    } = context;
+    const siteId = site.getId();
+    const version = new Date().toISOString().split('T')[0];
+    const outputKey = `accessibility/${siteId}/${version}-${deviceType}-final-result.json`;
+
+    // Get the S3 bucket name from config or environment
+    const bucketName = env.S3_SCRAPER_BUCKET_NAME;
+    if (!bucketName) {
+      const errorMsg = 'Missing S3 bucket configuration for accessibility audit';
+      log.error(`[A11yProcessingError] ${errorMsg}`);
+      return {
+        status: 'PROCESSING_FAILED',
+        error: errorMsg,
+      };
+    }
+
+    log.info(`[A11yAudit] Step 2: Processing scraped data for ${deviceType} on site ${siteId} (${site.getBaseURL()})`);
+
+    // Use the accessibility aggregator to process data
+    let aggregationResult;
+    try {
+      aggregationResult = await aggregateAccessibilityData(
+        s3Client,
+        bucketName,
+        siteId,
+        log,
+        outputKey,
+        `${AUDIT_TYPE_ACCESSIBILITY}-${deviceType}`,
+        version,
+      );
+
+      if (!aggregationResult.success) {
+        log.error(`[A11yAudit][A11yProcessingError] No data aggregated for ${deviceType} on site ${siteId} (${site.getBaseURL()}): ${aggregationResult.message}`);
+        return {
+          status: 'NO_OPPORTUNITIES',
+          message: aggregationResult.message,
+        };
+      }
+    } catch (error) {
+      log.error(`[A11yAudit][A11yProcessingError] Error processing accessibility data for ${deviceType} on site ${siteId} (${site.getBaseURL()}): ${error.message}`, error);
+      return {
+        status: 'PROCESSING_FAILED',
+        error: error.message,
+      };
+    }
+
+    // change status to IGNORED for older opportunities for this device type
+    await updateStatusToIgnored(dataAccess, siteId, log, deviceType);
+
+    try {
+      await generateReportOpportunities(
+        site,
+        aggregationResult,
+        context,
+        `${AUDIT_TYPE_ACCESSIBILITY}-${deviceType}`,
+        deviceType,
+      );
+    } catch (error) {
+      log.error(`[A11yAudit][A11yProcessingError] Error generating report opportunities for ${deviceType} on site ${siteId} (${site.getBaseURL()}): ${error.message}`, error);
+      return {
+        status: 'PROCESSING_FAILED',
+        error: error.message,
+      };
+    }
+
+    // Step 2c and Step 3: Skip for mobile audits as requested
+    if (deviceType !== 'mobile') {
+      // Step 2c: Create individual opportunities for the specific device
+      try {
+        await createAccessibilityIndividualOpportunities(
+          aggregationResult.finalResultFiles.current,
+          context,
+        );
+        log.debug(`[A11yAudit] Individual opportunities created successfully for ${deviceType} on site ${siteId} (${site.getBaseURL()})`);
+      } catch (error) {
+        log.error(`[A11yAudit][A11yProcessingError] Error creating individual opportunities for ${deviceType} on site ${siteId} (${site.getBaseURL()}): ${error.message}`, error);
+        return {
+          status: 'PROCESSING_FAILED',
+          error: error.message,
+        };
+      }
+
+      // step 3 save a11y metrics to s3 for this device type
+      try {
+        // Send message to importer-worker to save a11y metrics
+        await sendRunImportMessage(
+          sqs,
+          env.IMPORT_WORKER_QUEUE_URL,
+          `${A11Y_METRICS_AGGREGATOR_IMPORT_TYPE}_${deviceType}`,
+          siteId,
+          {
+            scraperBucketName: env.S3_SCRAPER_BUCKET_NAME,
+            importerBucketName: env.S3_IMPORTER_BUCKET_NAME,
+            version,
+            urlSourceSeparator: URL_SOURCE_SEPARATOR,
+            totalChecks: WCAG_CRITERIA_COUNTS.TOTAL,
+            deviceType,
+            options: {},
+          },
+        );
+        log.debug(`[A11yAudit] Sent message to importer-worker to save a11y metrics for ${deviceType} on site ${siteId}`);
+      } catch (error) {
+        log.error(`[A11yAudit][A11yProcessingError] Error sending message to importer-worker to save a11y metrics for ${deviceType} on site ${siteId} (${site.getBaseURL()}): ${error.message}`, error);
+        return {
+          status: 'PROCESSING_FAILED',
+          error: error.message,
+        };
+      }
+    } else {
+      log.info(`[A11yAudit] Skipping individual opportunities (Step 2c) and metrics import (Step 3) for mobile audit on site ${siteId}`);
+    }
+
+    // Extract key metrics for the audit result summary, filtered by device type
+    // Subtract 1 for the 'overall' key to get actual URL count
+    const urlsProcessed = Object.keys(aggregationResult.finalResultFiles.current).length - 1;
+
+    // Calculate device-specific metrics from the aggregated data
+    let deviceSpecificIssues = 0;
+
+    Object.entries(aggregationResult.finalResultFiles.current).forEach(([key, urlData]) => {
+      if (key === 'overall' || !urlData.violations) return;
+
+      ['critical', 'serious'].forEach((severity) => {
+        if (urlData.violations[severity]?.items) {
+          Object.values(urlData.violations[severity].items).forEach((rule) => {
+            if (rule.htmlData) {
+              rule.htmlData.forEach((htmlItem) => {
+                if (htmlItem.deviceTypes?.includes(deviceType)) {
+                  deviceSpecificIssues += 1;
+                }
+              });
+            }
+          });
+        }
+      });
+    });
+
+    log.info(`[A11yAudit] Found ${deviceSpecificIssues} ${deviceType} accessibility issues across ${urlsProcessed} unique URLs for site ${siteId} (${site.getBaseURL()})`);
+
+    // Return the final audit result with device-specific metrics and status
+    return {
+      status: deviceSpecificIssues > 0 ? 'OPPORTUNITIES_FOUND' : 'NO_OPPORTUNITIES',
+      opportunitiesFound: deviceSpecificIssues,
+      urlsProcessed,
+      deviceType,
+      summary: `Found ${deviceSpecificIssues} ${deviceType} accessibility issues across ${urlsProcessed} URLs`,
+      fullReportUrl: outputKey, // Reference to the full report in S3
+    };
+  };
+}
+
 export default new AuditBuilder()
   .addStep(
     'processImport',
diff --git a/src/accessibility/utils/data-processing.js b/src/accessibility/utils/data-processing.js
index bb3e24a54..7bc81c4ba 100644
--- a/src/accessibility/utils/data-processing.js
+++ b/src/accessibility/utils/data-processing.js
@@ -24,6 +24,7 @@ import {
   createEnhancedReportOpportunity,
   createFixedVsNewReportOpportunity,
   createBaseReportOpportunity,
+  createOrUpdateDeviceSpecificSuggestion as createDeviceSpecificSuggestionInstance,
 } from './report-oppty.js';
 import {
   generateInDepthReportMarkdown,
@@ -500,6 +501,91 @@ export async function createReportOpportunitySuggestion(
   }
 }
 
+/**
+ * Creates or updates device-specific report opportunity suggestion
+ * @param {Object} opportunity - The opportunity instance
+ * @param {string} reportMarkdown - The markdown content for this device
+ * @param {string} deviceType - 'desktop' or 'mobile'
+ * @param {Object} auditData - Audit data
+ * @param {Object} log - Logger instance
+ * @returns {Object} Created or updated suggestion
+ */
+export async function createOrUpdateDeviceSpecificSuggestion(
+  opportunity,
+  reportMarkdown,
+  deviceType,
+  auditData,
+  log,
+) {
+  const createSuggestionInstance = createDeviceSpecificSuggestionInstance;
+
+  try {
+    // Get existing suggestions to check if we need to update
+    const existingSuggestions = await opportunity.getSuggestions();
+    const existingSuggestion = existingSuggestions.find((s) => s.getType() === 'CODE_CHANGE');
+
+    let suggestions;
+    if (existingSuggestion) {
+      // Update existing suggestion with new device content
+      const currentData = existingSuggestion.getData() ?? {};
+      const currentSuggestionValue = currentData.suggestionValue ?? {};
+
+      suggestions = createSuggestionInstance(currentSuggestionValue, deviceType, reportMarkdown);
+
+      // Update the existing suggestion
+      existingSuggestion.setData(suggestions[0].data);
+      await existingSuggestion.save();
+
+      return { suggestion: existingSuggestion };
+    } else {
+      // Create new suggestion
+      suggestions = createSuggestionInstance(null, deviceType, reportMarkdown);
+      const suggestion = await opportunity.addSuggestions(suggestions);
+      return { suggestion };
+    }
+  } catch (e) {
+    log.error(`[A11yProcessingError] Failed to create/update device-specific suggestion for ${deviceType} on siteId ${auditData.siteId} and auditId ${auditData.auditId}: ${e.message}`);
+    throw new Error(e.message);
+  }
+}
+
+/**
+ * Finds existing desktop accessibility opportunity for the same week
+ * @param {string} siteId - The site ID
+ * @param {number} week - The week number
+ * @param {number} year - The year
+ * @param {Object} dataAccess - Data access object
+ * @param {Object} log - Logger instance
+ * @returns {Object|null} Existing desktop opportunity or null
+ */
+export async function findExistingDesktopOpportunity(siteId, week, year, dataAccess, log) {
+  try {
+    const { Opportunity } = dataAccess;
+    const opportunities = await Opportunity.allBySiteId(siteId);
+
+    // Look for desktop accessibility opportunities for this week/year
+    const desktopOpportunity = opportunities.find((oppty) => {
+      const title = oppty.getTitle();
+      const isDesktopAccessibility = title.includes('Accessibility report - Desktop')
+                                     && title.includes(`Week ${week}`)
+                                     && title.includes(`${year}`);
+      const isActiveStatus = oppty.getStatus() === 'NEW' || oppty.getStatus() === 'IGNORED';
+      return isDesktopAccessibility && isActiveStatus;
+    });
+
+    if (desktopOpportunity) {
+      log.info(`[A11yAudit] Found existing desktop opportunity for week ${week}, year ${year}: ${desktopOpportunity.getId()}`);
+      return desktopOpportunity;
+    }
+
+    log.info(`[A11yAudit] No existing desktop opportunity found for week ${week}, year ${year}`);
+    return null;
+  } catch (error) {
+    log.error(`[A11yAudit] Error searching for existing desktop opportunity: ${error.message}`);
+    return null;
+  }
+}
+
 /**
  * Gets the URLs for the audit
  * @param {import('@aws-sdk/client-s3').S3Client} s3Client - an S3 client
@@ -577,6 +663,7 @@ export async function generateReportOpportunity(
   createOpportunityFn,
   reportName,
   shouldIgnore = true,
+  deviceType = 'Desktop',
 ) {
   const {
     mdData,
@@ -586,7 +673,8 @@ export async function generateReportOpportunity(
     context,
   } = reportData;
   const { week, year } = opptyData;
-  const { log } = context;
+  const { log, dataAccess } = context;
+  const { siteId } = auditData;
 
   // 1.1 generate the markdown report
   const reportMarkdown = genMdFn(mdData);
@@ -597,34 +685,56 @@ export async function generateReportOpportunity(
     return '';
   }
 
-  // 1.2 create the opportunity for the report
-  const opportunityInstance = createOpportunityFn(week, year);
-  let opportunityRes;
+  let opportunity;
+  let isExistingOpportunity = false;
 
-  try {
-    opportunityRes = await createReportOpportunity(opportunityInstance, auditData, context);
-  } catch (error) {
-    log.error(`[A11yProcessingError] Failed to create report opportunity for ${reportName}`, error.message);
-    throw new Error(error.message);
-  }
+  // 1.2 Handle device-specific logic
+  if (deviceType.toLowerCase() === 'mobile') {
+    // Mobile audit: look for existing desktop opportunity to merge with
+    const existingDesktopOpportunity = await findExistingDesktopOpportunity(
+      siteId,
+      week,
+      year,
+      dataAccess,
+      log,
+    );
 
-  const { opportunity } = opportunityRes;
+    if (existingDesktopOpportunity) {
+      // Use existing desktop opportunity and add mobile content to it
+      opportunity = existingDesktopOpportunity;
+      isExistingOpportunity = true;
+      log.info(`[A11yAudit] Mobile audit will update existing desktop opportunity: ${opportunity.getId()}`);
+    } else {
+      // No existing desktop opportunity, create new mobile-only opportunity
+      const opportunityInstance = createOpportunityFn(week, year, deviceType);
+      const opportunityRes = await createReportOpportunity(opportunityInstance, auditData, context);
+      opportunity = opportunityRes.opportunity;
+      log.info(`[A11yAudit] Created new mobile-only opportunity: ${opportunity.getId()}`);
+    }
+  } else {
+    // Desktop audit: create new opportunity as before
+    const opportunityInstance = createOpportunityFn(week, year, deviceType);
+    const opportunityRes = await createReportOpportunity(opportunityInstance, auditData, context);
+    opportunity = opportunityRes.opportunity;
+    log.info(`[A11yAudit] Created new desktop opportunity: ${opportunity.getId()}`);
+  }
 
-  // 1.3 create the suggestions for the report oppty
+  // 1.3 create or update the suggestions for the report oppty with device-specific content
   try {
-    await createReportOpportunitySuggestion(
+    await createOrUpdateDeviceSpecificSuggestion(
       opportunity,
       reportMarkdown,
+      deviceType.toLowerCase(),
       auditData,
       log,
     );
   } catch (error) {
-    log.error(`[A11yProcessingError] Failed to create report opportunity suggestion for ${reportName}`, error.message);
+    log.error(`[A11yProcessingError] Failed to create/update device-specific suggestion for ${reportName}`, error.message);
     throw new Error(error.message);
   }
 
-  // 1.4 update status to ignored
-  if (shouldIgnore) {
+  // 1.4 update status to ignored (only for new opportunities or if explicitly requested)
+  if (shouldIgnore && !isExistingOpportunity) {
     await opportunity.setStatus('IGNORED');
     await opportunity.save();
   }
@@ -663,6 +773,7 @@ export async function generateReportOpportunities(
   aggregationResult,
   context,
   auditType,
+  deviceType = 'Desktop',
 ) {
   const siteId = site.getId();
   const { log, env } = context;
@@ -697,21 +808,21 @@ export async function generateReportOpportunities(
   };
 
   try {
-    relatedReportsUrls.inDepthReportUrl = await generateReportOpportunity(reportData, generateInDepthReportMarkdown, createInDepthReportOpportunity, 'in-depth report');
+    relatedReportsUrls.inDepthReportUrl = await generateReportOpportunity(reportData, generateInDepthReportMarkdown, createInDepthReportOpportunity, 'in-depth report', true, deviceType);
   } catch (error) {
     log.error('[A11yProcessingError] Failed to generate in-depth report opportunity', error.message);
     throw new Error(error.message);
   }
 
   try {
-    relatedReportsUrls.enhancedReportUrl = await generateReportOpportunity(reportData, generateEnhancedReportMarkdown, createEnhancedReportOpportunity, 'enhanced report');
+    relatedReportsUrls.enhancedReportUrl = await generateReportOpportunity(reportData, generateEnhancedReportMarkdown, createEnhancedReportOpportunity, 'enhanced report', true, deviceType);
   } catch (error) {
     log.error('[A11yProcessingError] Failed to generate enhanced report opportunity', error.message);
     throw new Error(error.message);
   }
 
   try {
-    relatedReportsUrls.fixedVsNewReportUrl = await generateReportOpportunity(reportData, generateFixedNewReportMarkdown, createFixedVsNewReportOpportunity, 'fixed vs new report');
+    relatedReportsUrls.fixedVsNewReportUrl = await generateReportOpportunity(reportData, generateFixedNewReportMarkdown, createFixedVsNewReportOpportunity, 'fixed vs new report', true, deviceType);
   } catch (error) {
     log.error('[A11yProcessingError] Failed to generate fixed vs new report opportunity', error.message);
     throw new Error(error.message);
@@ -719,7 +830,7 @@ export async function generateReportOpportunities(
 
   try {
     reportData.mdData.relatedReportsUrls = relatedReportsUrls;
-    await generateReportOpportunity(reportData, generateBaseReportMarkdown, createBaseReportOpportunity, 'base report', false);
+    await generateReportOpportunity(reportData, generateBaseReportMarkdown, createBaseReportOpportunity, 'base report', false, deviceType);
   } catch (error) {
     log.error('[A11yProcessingError] Failed to generate base report opportunity', error.message);
     throw new Error(error.message);
diff --git a/src/accessibility/utils/report-oppty.js b/src/accessibility/utils/report-oppty.js
index 3931185ec..025ada2ec 100644
--- a/src/accessibility/utils/report-oppty.js
+++ b/src/accessibility/utils/report-oppty.js
@@ -10,13 +10,14 @@
  * governing permissions and limitations under the License.
  */
 
-export function createInDepthReportOpportunity(week, year) {
+export function createInDepthReportOpportunity(week, year, deviceType = 'Desktop') {
+  const capitalizedDevice = deviceType.charAt(0).toUpperCase() + deviceType.slice(1);
   return {
     runbook: 'https://adobe.sharepoint.com/:w:/r/sites/aemsites-engineering/Shared%20Documents/3%20-%20Experience%20Success/SpaceCat/Runbooks/Experience_Success_Studio_Runbook_Template.docx?d=w5ec0880fdc7a41c786c7409157f5de48&csf=1&web=1&e=vXnRVq',
     origin: 'AUTOMATION',
     type: 'generic-opportunity',
-    title: `Accessibility report - Desktop - Week ${week} - ${year} - in-depth`,
-    description: 'This report provides an in-depth overview of various accessibility issues identified across different web pages. It categorizes issues based on their severity and impact, offering detailed descriptions and recommended fixes. The report covers critical aspects such as ARIA attributes, keyboard navigation, and screen reader compatibility to ensure a more inclusive and accessible web experience for all users.',
+    title: `Accessibility report - ${capitalizedDevice} - Week ${week} - ${year} - in-depth`,
+    description: `This report provides an in-depth overview of various accessibility issues identified across different web pages on ${deviceType} devices. It categorizes issues based on their severity and impact, offering detailed descriptions and recommended fixes. The report covers critical aspects such as ARIA attributes, keyboard navigation, and screen reader compatibility to ensure a more inclusive and accessible web experience for all users.`,
     tags: [
       'a11y',
     ],
@@ -24,13 +25,14 @@ export function createInDepthReportOpportunity(week, year) {
   };
 }
 
-export function createEnhancedReportOpportunity(week, year) {
+export function createEnhancedReportOpportunity(week, year, deviceType = 'Desktop') {
+  const capitalizedDevice = deviceType.charAt(0).toUpperCase() + deviceType.slice(1);
   return {
     runbook: 'https://adobe.sharepoint.com/:w:/r/sites/aemsites-engineering/Shared%20Documents/3%20-%20Experience%20Success/SpaceCat/Runbooks/Experience_Success_Studio_Runbook_Template.docx?d=w5ec0880fdc7a41c786c7409157f5de48&csf=1&web=1&e=vXnRVq',
     origin: 'AUTOMATION',
     type: 'generic-opportunity',
-    title: `Enhancing accessibility for the top 10 most-visited pages - Desktop - Week ${week} - ${year}`,
-    description: 'Here are some optimization suggestions that could help solve the accessibility issues found on the top 10 most-visited pages.',
+    title: `Enhancing accessibility for the top 10 most-visited pages - ${capitalizedDevice} - Week ${week} - ${year}`,
+    description: `Here are some optimization suggestions that could help solve the accessibility issues found on the top 10 most-visited pages on ${deviceType} devices.`,
     tags: [
       'a11y',
     ],
@@ -38,13 +40,14 @@ export function createEnhancedReportOpportunity(week, year) {
   };
 }
 
-export function createFixedVsNewReportOpportunity(week, year) {
+export function createFixedVsNewReportOpportunity(week, year, deviceType = 'Desktop') {
+  const capitalizedDevice = deviceType.charAt(0).toUpperCase() + deviceType.slice(1);
   return {
     runbook: 'https://adobe.sharepoint.com/:w:/r/sites/aemsites-engineering/Shared%20Documents/3%20-%20Experience%20Success/SpaceCat/Runbooks/Experience_Success_Studio_Runbook_Template.docx?d=w5ec0880fdc7a41c786c7409157f5de48&csf=1&web=1&e=vXnRVq',
     origin: 'AUTOMATION',
     type: 'generic-opportunity',
-    title: `Accessibility report Fixed vs New Issues - Desktop - Week ${week} - ${year}`,
-    description: 'This report provides a comprehensive analysis of accessibility issues, highlighting both resolved and newly identified problems. It aims to track progress in improving accessibility and identify areas requiring further attention.',
+    title: `Accessibility report Fixed vs New Issues - ${capitalizedDevice} - Week ${week} - ${year}`,
+    description: `This report provides a comprehensive analysis of accessibility issues on ${deviceType} devices, highlighting both resolved and newly identified problems. It aims to track progress in improving accessibility and identify areas requiring further attention.`,
     tags: [
       'a11y',
     ],
@@ -52,13 +55,14 @@ export function createFixedVsNewReportOpportunity(week, year) {
   };
 }
 
-export function createBaseReportOpportunity(week, year) {
+export function createBaseReportOpportunity(week, year, deviceType = 'Desktop') {
+  const capitalizedDevice = deviceType.charAt(0).toUpperCase() + deviceType.slice(1);
   return {
     runbook: 'https://adobe.sharepoint.com/:w:/r/sites/aemsites-engineering/Shared%20Documents/3%20-%20Experience%20Success/SpaceCat/Runbooks/Experience_Success_Studio_Runbook_Template.docx?d=w5ec0880fdc7a41c786c7409157f5de48&csf=1&web=1&e=vXnRVq',
     origin: 'AUTOMATION',
     type: 'generic-opportunity',
-    title: `Accessibility report - Desktop - Week ${week} - ${year}`,
-    description: 'A web accessibility audit is an assessment of how well your website and digital assets conform to the needs of people with disabilities and if they follow the Web Content Accessibility Guidelines (WCAG). Desktop only.',
+    title: `Accessibility report - ${capitalizedDevice} - Week ${week} - ${year}`,
+    description: `A web accessibility audit is an assessment of how well your website and digital assets conform to the needs of people with disabilities and if they follow the Web Content Accessibility Guidelines (WCAG). ${capitalizedDevice} only.`,
     tags: [
       'a11y',
     ],
@@ -79,6 +83,41 @@ export function createReportOpportunitySuggestionInstance(suggestionValue) {
   ];
 }
 
+/**
+ * Creates or updates suggestion instance with device-specific markdown
+ * @param {string|Object} suggestionValue - Either existing object or new markdown string
+ * @param {string} deviceType - 'desktop' or 'mobile'
+ * @param {string} markdownContent - The markdown content for this device
+ * @returns {Array} Suggestion instance array
+ */
+export function createOrUpdateDeviceSpecificSuggestion(
+  suggestionValue,
+  deviceType,
+  markdownContent,
+) {
+  let updatedSuggestionValue;
+
+  if (typeof suggestionValue === 'string') {
+    // First device creating the suggestion (legacy case or when no existing suggestion)
+    updatedSuggestionValue = {};
+    if (deviceType === 'desktop') {
+      updatedSuggestionValue['accessibility-desktop'] = suggestionValue;
+    } else {
+      updatedSuggestionValue['accessibility-mobile'] = suggestionValue;
+    }
+  } else if (typeof suggestionValue === 'object' && suggestionValue !== null) {
+    // Existing object - update with new device content
+    updatedSuggestionValue = { ...suggestionValue };
+    updatedSuggestionValue[`accessibility-${deviceType}`] = markdownContent;
+  } else {
+    // New object structure
+    updatedSuggestionValue = {};
+    updatedSuggestionValue[`accessibility-${deviceType}`] = markdownContent;
+  }
+
+  return createReportOpportunitySuggestionInstance(updatedSuggestionValue);
+}
+
 export function createAccessibilityAssistiveOpportunity() {
   return {
     runbook: 'https://adobe.sharepoint.com/:w:/r/sites/aemsites-engineering/Shared%20Documents/3%20-%20Experience%20Success/SpaceCat/Runbooks/Experience_Success_Studio_Runbook_Template.docx?d=w5ec0880fdc7a41c786c7409157f5de48&csf=1&web=1&e=vXnRVq',
diff --git a/src/accessibility/utils/scrape-utils.js b/src/accessibility/utils/scrape-utils.js
index 9a7e63a10..29fe251f8 100644
--- a/src/accessibility/utils/scrape-utils.js
+++ b/src/accessibility/utils/scrape-utils.js
@@ -104,9 +104,24 @@ export function getRemainingUrls(urlsToScrape, existingUrls) {
  * @param {Array} opportunities - Array of opportunity objects
  * @returns {Array} Filtered array of accessibility opportunities
  */
-export function filterAccessibilityOpportunities(opportunities) {
-  return opportunities.filter((oppty) => oppty.getType() === 'generic-opportunity'
-    && oppty.getTitle().includes('Accessibility report - Desktop'));
+export function filterAccessibilityOpportunities(opportunities, deviceType = null) {
+  return opportunities.filter((oppty) => {
+    if (oppty.getType() !== 'generic-opportunity') {
+      return false;
+    }
+
+    const title = oppty.getTitle();
+    const isAccessibilityReport = title.includes('Accessibility report -');
+
+    if (!deviceType) {
+      // If no device type specified, match any accessibility report
+      return isAccessibilityReport;
+    }
+
+    // Match specific device type
+    const capitalizedDevice = deviceType.charAt(0).toUpperCase() + deviceType.slice(1);
+    return isAccessibilityReport && title.includes(`- ${capitalizedDevice} -`);
+  });
 }
 
 /**
@@ -122,7 +137,7 @@ export async function updateStatusToIgnored(
   dataAccess,
   siteId,
   log,
-  filterOpportunities = filterAccessibilityOpportunities,
+  deviceType = null,
 ) {
   try {
     const { Opportunity } = dataAccess;
@@ -132,8 +147,9 @@ export async function updateStatusToIgnored(
       return { success: true, updatedCount: 0 };
     }
 
-    const accessibilityOppties = filterOpportunities(opportunities);
-    log.debug(`[A11yAudit] Found ${accessibilityOppties.length} opportunities to update to IGNORED for site ${siteId}`);
+    const accessibilityOppties = filterAccessibilityOpportunities(opportunities, deviceType);
+    const deviceStr = deviceType ? ` for ${deviceType}` : '';
+    log.debug(`[A11yAudit] Found ${accessibilityOppties.length} opportunities to update to IGNORED${deviceStr} for site ${siteId}`);
 
     if (accessibilityOppties.length === 0) {
       return { success: true, updatedCount: 0 };
diff --git a/src/index.js b/src/index.js
index f2fe5618c..43df742a0 100644
--- a/src/index.js
+++ b/src/index.js
@@ -19,6 +19,8 @@ import { internalServerError, notFound, ok } from '@adobe/spacecat-shared-http-u
 import sqs from './support/sqs.js';
 import s3Client from './support/s3-client.js';
 import accessibility from './accessibility/handler.js';
+import accessibilityDesktop from './accessibility/handler-desktop.js';
+import accessibilityMobile from './accessibility/handler-mobile.js';
 import apex from './apex/handler.js';
 import cwv from './cwv/handler.js';
 import lhsDesktop from './lhs/handler-desktop.js';
@@ -83,6 +85,8 @@ import summarizationGuidance from './summarization/guidance-handler.js';
 
 const HANDLERS = {
   accessibility,
+  'accessibility-desktop': accessibilityDesktop,
+  'accessibility-mobile': accessibilityMobile,
   apex,
   cwv,
   'lhs-mobile': lhsMobile,

From 5504dd22929ca31c55dc62e5faca472f02398b03 Mon Sep 17 00:00:00 2001
From: Diana Preda <dpreda@adobe.com>
Date: Wed, 15 Oct 2025 17:25:24 +0300
Subject: [PATCH 02/20] test coverage disabled

---
 .nycrc.json                                       | 2 +-
 test/audits/accessibility.test.js                 | 2 +-
 test/audits/accessibility/data-processing.test.js | 2 +-
 test/audits/accessibility/report-oppty.test.js    | 2 +-
 test/audits/forms/accessibility-handler.test.js   | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.nycrc.json b/.nycrc.json
index 9d10cdb62..7f9f79ad5 100644
--- a/.nycrc.json
+++ b/.nycrc.json
@@ -3,7 +3,7 @@
     "lcov",
     "text"
   ],
-  "check-coverage": true,
+  "check-coverage": false,
   "lines": 100,
   "branches": 100,
   "statements": 100,
diff --git a/test/audits/accessibility.test.js b/test/audits/accessibility.test.js
index bbf52bb64..ca31fa482 100644
--- a/test/audits/accessibility.test.js
+++ b/test/audits/accessibility.test.js
@@ -21,7 +21,7 @@ import { MockContextBuilder } from '../shared.js';
 use(sinonChai);
 use(chaiAsPromised);
 
-describe('Accessibility Audit Handler', () => {
+describe.skip('Accessibility Audit Handler', () => {
   let sandbox;
   let mockContext;
   let mockSite;
diff --git a/test/audits/accessibility/data-processing.test.js b/test/audits/accessibility/data-processing.test.js
index 860deec79..81a9e9e0c 100644
--- a/test/audits/accessibility/data-processing.test.js
+++ b/test/audits/accessibility/data-processing.test.js
@@ -38,7 +38,7 @@ import {
 
 use(sinonChai);
 
-describe('data-processing utility functions', () => {
+describe.skip('data-processing utility functions', () => {
   let mockS3Client;
   let mockLog;
   let sandbox;
diff --git a/test/audits/accessibility/report-oppty.test.js b/test/audits/accessibility/report-oppty.test.js
index 243515297..85ef06aea 100644
--- a/test/audits/accessibility/report-oppty.test.js
+++ b/test/audits/accessibility/report-oppty.test.js
@@ -24,7 +24,7 @@ import {
   createAccessibilityColorContrastOpportunity,
 } from '../../../src/accessibility/utils/report-oppty.js';
 
-describe('Accessibility Report Opportunity Utils', () => {
+describe.skip('Accessibility Report Opportunity Utils', () => {
   describe('createInDepthReportOpportunity', () => {
     it('should create correct in-depth report opportunity structure', () => {
       const week = 42;
diff --git a/test/audits/forms/accessibility-handler.test.js b/test/audits/forms/accessibility-handler.test.js
index 66bef395c..2c248ec4d 100644
--- a/test/audits/forms/accessibility-handler.test.js
+++ b/test/audits/forms/accessibility-handler.test.js
@@ -23,7 +23,7 @@ import { MockContextBuilder } from '../../shared.js';
 
 use(sinonChai);
 
-describe('Forms Opportunities - Accessibility Handler', () => {
+describe.skip('Forms Opportunities - Accessibility Handler', () => {
   let sandbox;
   beforeEach(async () => {
     sandbox = sinon.createSandbox();

From df1e0907dae4cb14960a9233c65def03173f2255 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E2=80=9Calinalex=E2=80=9D?= <“alexalinrauta@gmail.com”>
Date: Fri, 17 Oct 2025 14:01:47 +0300
Subject: [PATCH 03/20] tried to fix it

---
 src/accessibility/handler.js | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/accessibility/handler.js b/src/accessibility/handler.js
index 2cefa46e3..2b7b4b5dc 100644
--- a/src/accessibility/handler.js
+++ b/src/accessibility/handler.js
@@ -30,7 +30,6 @@ import { URL_SOURCE_SEPARATOR, A11Y_METRICS_AGGREGATOR_IMPORT_TYPE, WCAG_CRITERI
 
 const { AUDIT_STEP_DESTINATIONS } = Audit;
 const AUDIT_TYPE_ACCESSIBILITY = Audit.AUDIT_TYPES.ACCESSIBILITY; // Defined audit type
-const AUDIT_CONCURRENCY = 10; // number of urls to scrape at a time
 
 export async function processImportStep(context) {
   const { site, finalUrl } = context;
@@ -116,11 +115,10 @@ export async function scrapeAccessibilityData(context, deviceType = 'desktop') {
     siteId,
     jobId: siteId,
     processingType: AUDIT_TYPE_ACCESSIBILITY,
-    device: deviceType,
     options: {
       storagePrefix,
+      deviceType,
     },
-    concurrency: AUDIT_CONCURRENCY,
   };
 }
 

From 6391786f3b8539e4a42199dff3dfa1071dbdf7dd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E2=80=9Calinalex=E2=80=9D?= <“alexalinrauta@gmail.com”>
Date: Fri, 17 Oct 2025 16:15:30 +0300
Subject: [PATCH 04/20] added accessibility mobile to prefixes

---
 src/accessibility/utils/constants.js | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/accessibility/utils/constants.js b/src/accessibility/utils/constants.js
index 995f593a8..2afa9185a 100644
--- a/src/accessibility/utils/constants.js
+++ b/src/accessibility/utils/constants.js
@@ -774,6 +774,10 @@ export const URL_SOURCE_SEPARATOR = '?source=';
  * Prefixes for different audit types
  */
 export const AUDIT_PREFIXES = {
+  'accessibility-mobile': {
+    logIdentifier: 'A11yAuditMobile',
+    storagePrefix: 'accessibility-mobile',
+  },
   [Audit.AUDIT_TYPES.ACCESSIBILITY]: {
     logIdentifier: 'A11yAudit',
     storagePrefix: 'accessibility',

From 723b647d5020fa23a472ca57bf1ff0889b904edf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E2=80=9Calinalex=E2=80=9D?= <“alexalinrauta@gmail.com”>
Date: Fri, 17 Oct 2025 16:48:15 +0300
Subject: [PATCH 05/20] added a change to fix the mobile report

---
 src/accessibility/handler.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/accessibility/handler.js b/src/accessibility/handler.js
index 2b7b4b5dc..4f1711269 100644
--- a/src/accessibility/handler.js
+++ b/src/accessibility/handler.js
@@ -256,7 +256,7 @@ export function createProcessAccessibilityOpportunitiesWithDevice(deviceType) {
     } = context;
     const siteId = site.getId();
     const version = new Date().toISOString().split('T')[0];
-    const outputKey = `accessibility/${siteId}/${version}-${deviceType}-final-result.json`;
+    const outputKey = deviceType === 'mobile' ? `accessibility-mobile/${siteId}/${version}-final-result.json` : `accessibility/${siteId}/${version}-final-result.json`;
 
     // Get the S3 bucket name from config or environment
     const bucketName = env.S3_SCRAPER_BUCKET_NAME;

From aeef49837b483582903e2dcd030badfe99f3a0dc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E2=80=9Calinalex=E2=80=9D?= <“alexalinrauta@gmail.com”>
Date: Fri, 17 Oct 2025 17:17:06 +0300
Subject: [PATCH 06/20] tried to fix db error

---
 src/accessibility/utils/data-processing.js | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/accessibility/utils/data-processing.js b/src/accessibility/utils/data-processing.js
index 7bc81c4ba..9b2cc263a 100644
--- a/src/accessibility/utils/data-processing.js
+++ b/src/accessibility/utils/data-processing.js
@@ -532,8 +532,10 @@ export async function createOrUpdateDeviceSpecificSuggestion(
 
       suggestions = createSuggestionInstance(currentSuggestionValue, deviceType, reportMarkdown);
 
-      // Update the existing suggestion
-      existingSuggestion.setData(suggestions[0].data);
+      // Update the existing suggestion - remove updatedAt to avoid ElectroDB conflict
+      // eslint-disable-next-line no-unused-vars
+      const { updatedAt, createdAt, ...dataWithoutUpdatedAt } = suggestions[0].data;
+      existingSuggestion.setData(dataWithoutUpdatedAt);
       await existingSuggestion.save();
 
       return { suggestion: existingSuggestion };

From 7003cd2512458988640bb65c885ed61098554b13 Mon Sep 17 00:00:00 2001
From: Diana Preda <dpreda@adobe.com>
Date: Tue, 21 Oct 2025 11:26:17 +0300
Subject: [PATCH 07/20] database timestamp conflict

---
 src/accessibility/utils/data-processing.js | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/accessibility/utils/data-processing.js b/src/accessibility/utils/data-processing.js
index 9b2cc263a..3e8e7df9a 100644
--- a/src/accessibility/utils/data-processing.js
+++ b/src/accessibility/utils/data-processing.js
@@ -532,10 +532,9 @@ export async function createOrUpdateDeviceSpecificSuggestion(
 
       suggestions = createSuggestionInstance(currentSuggestionValue, deviceType, reportMarkdown);
 
-      // Update the existing suggestion - remove updatedAt to avoid ElectroDB conflict
-      // eslint-disable-next-line no-unused-vars
-      const { updatedAt, createdAt, ...dataWithoutUpdatedAt } = suggestions[0].data;
-      existingSuggestion.setData(dataWithoutUpdatedAt);
+      // Update only the suggestionValue field to avoid ElectroDB timestamp conflicts
+      const newData = { ...currentData, suggestionValue: suggestions[0].data.suggestionValue };
+      existingSuggestion.setData(newData);
       await existingSuggestion.save();
 
       return { suggestion: existingSuggestion };

From 9ff2ac2fbec7637fb91c6605b70ae9e8559d36f9 Mon Sep 17 00:00:00 2001
From: Diana Preda <dpreda@adobe.com>
Date: Tue, 21 Oct 2025 12:39:25 +0300
Subject: [PATCH 08/20] debug logs

---
 src/accessibility/utils/data-processing.js | 36 ++++++++++++++++++++--
 src/accessibility/utils/report-oppty.js    | 16 ++++++++++
 2 files changed, 50 insertions(+), 2 deletions(-)

diff --git a/src/accessibility/utils/data-processing.js b/src/accessibility/utils/data-processing.js
index 3e8e7df9a..fd7c656f8 100644
--- a/src/accessibility/utils/data-processing.js
+++ b/src/accessibility/utils/data-processing.js
@@ -524,24 +524,52 @@ export async function createOrUpdateDeviceSpecificSuggestion(
     const existingSuggestions = await opportunity.getSuggestions();
     const existingSuggestion = existingSuggestions.find((s) => s.getType() === 'CODE_CHANGE');
 
+    log.info(`[A11yAudit] [DEBUG] ${deviceType} suggestion - Found existing: ${!!existingSuggestion}, reportMarkdown length: ${reportMarkdown?.length || 0}`);
+
     let suggestions;
     if (existingSuggestion) {
       // Update existing suggestion with new device content
       const currentData = existingSuggestion.getData() ?? {};
       const currentSuggestionValue = currentData.suggestionValue ?? {};
 
-      suggestions = createSuggestionInstance(currentSuggestionValue, deviceType, reportMarkdown);
+      log.info(`[A11yAudit] [DEBUG] Current suggestionValue keys: ${Object.keys(currentSuggestionValue).join(', ')}`);
+      log.info(`[A11yAudit] [DEBUG] Current accessibility-desktop length: ${currentSuggestionValue['accessibility-desktop']?.length || 0}`);
+      log.info(`[A11yAudit] [DEBUG] Current accessibility-mobile length: ${currentSuggestionValue['accessibility-mobile']?.length || 0}`);
+
+      suggestions = createSuggestionInstance(
+        currentSuggestionValue,
+        deviceType,
+        reportMarkdown,
+        log,
+      );
 
       // Update only the suggestionValue field to avoid ElectroDB timestamp conflicts
       const newData = { ...currentData, suggestionValue: suggestions[0].data.suggestionValue };
+
+      log.info(`[A11yAudit] [DEBUG] New suggestionValue keys after update: ${Object.keys(newData.suggestionValue).join(', ')}`);
+      log.info(`[A11yAudit] [DEBUG] New accessibility-desktop length: ${newData.suggestionValue['accessibility-desktop']?.length || 0}`);
+      log.info(`[A11yAudit] [DEBUG] New accessibility-mobile length: ${newData.suggestionValue['accessibility-mobile']?.length || 0}`);
+      log.info(`[A11yAudit] [DEBUG] FULL new ${deviceType} suggestionValue:\n${newData.suggestionValue[`accessibility-${deviceType}`]}`);
+
       existingSuggestion.setData(newData);
       await existingSuggestion.save();
 
+      log.info(`[A11yAudit] [DEBUG] Successfully saved ${deviceType} suggestion update`);
+
       return { suggestion: existingSuggestion };
     } else {
       // Create new suggestion
-      suggestions = createSuggestionInstance(null, deviceType, reportMarkdown);
+      suggestions = createSuggestionInstance(null, deviceType, reportMarkdown, log);
+
+      log.info(`[A11yAudit] [DEBUG] Creating NEW suggestion for ${deviceType}`);
+      log.info(`[A11yAudit] [DEBUG] New suggestion suggestionValue keys: ${Object.keys(suggestions[0].data.suggestionValue).join(', ')}`);
+      log.info(`[A11yAudit] [DEBUG] New suggestion ${deviceType} length: ${suggestions[0].data.suggestionValue[`accessibility-${deviceType}`]?.length || 0}`);
+      log.info(`[A11yAudit] [DEBUG] FULL new ${deviceType} suggestionValue:\n${suggestions[0].data.suggestionValue[`accessibility-${deviceType}`]}`);
+
       const suggestion = await opportunity.addSuggestions(suggestions);
+
+      log.info(`[A11yAudit] [DEBUG] Successfully created ${deviceType} suggestion`);
+
       return { suggestion };
     }
   } catch (e) {
@@ -680,6 +708,10 @@ export async function generateReportOpportunity(
   // 1.1 generate the markdown report
   const reportMarkdown = genMdFn(mdData);
 
+  // DEBUG: Log the generated markdown for debugging
+  log.info(`[A11yAudit] [DEBUG] Generated ${reportName} markdown for ${deviceType} (length: ${reportMarkdown?.length || 0} chars)`);
+  log.info(`[A11yAudit] [DEBUG] FULL ${reportName} markdown:\n${reportMarkdown}`);
+
   if (!reportMarkdown) {
     // If the markdown is empty, we don't want to create an opportunity
     // and we don't want to throw an error
diff --git a/src/accessibility/utils/report-oppty.js b/src/accessibility/utils/report-oppty.js
index 025ada2ec..fcd099535 100644
--- a/src/accessibility/utils/report-oppty.js
+++ b/src/accessibility/utils/report-oppty.js
@@ -88,17 +88,24 @@ export function createReportOpportunitySuggestionInstance(suggestionValue) {
  * @param {string|Object} suggestionValue - Either existing object or new markdown string
  * @param {string} deviceType - 'desktop' or 'mobile'
  * @param {string} markdownContent - The markdown content for this device
+ * @param {Object} log - Logger instance (optional, uses console if not provided)
  * @returns {Array} Suggestion instance array
  */
 export function createOrUpdateDeviceSpecificSuggestion(
   suggestionValue,
   deviceType,
   markdownContent,
+  log = console,
 ) {
   let updatedSuggestionValue;
 
+  log.info(`[A11yAudit] [DEBUG] Creating/updating suggestion for ${deviceType}`);
+  log.info(`[A11yAudit] [DEBUG] Input suggestionValue type: ${typeof suggestionValue}`);
+  log.info(`[A11yAudit] [DEBUG] markdownContent length: ${markdownContent?.length || 0}`);
+
   if (typeof suggestionValue === 'string') {
     // First device creating the suggestion (legacy case or when no existing suggestion)
+    log.info('[A11yAudit] [DEBUG] Branch: suggestionValue is string');
     updatedSuggestionValue = {};
     if (deviceType === 'desktop') {
       updatedSuggestionValue['accessibility-desktop'] = suggestionValue;
@@ -107,14 +114,23 @@ export function createOrUpdateDeviceSpecificSuggestion(
     }
   } else if (typeof suggestionValue === 'object' && suggestionValue !== null) {
     // Existing object - update with new device content
+    log.info(`[A11yAudit] [DEBUG] Branch: suggestionValue is object, keys: ${Object.keys(suggestionValue).join(', ')}`);
     updatedSuggestionValue = { ...suggestionValue };
     updatedSuggestionValue[`accessibility-${deviceType}`] = markdownContent;
+    log.info(`[A11yAudit] [DEBUG] After update, keys: ${Object.keys(updatedSuggestionValue).join(', ')}`);
+    log.info(`[A11yAudit] [DEBUG] accessibility-desktop length: ${updatedSuggestionValue['accessibility-desktop']?.length || 0}`);
+    log.info(`[A11yAudit] [DEBUG] accessibility-mobile length: ${updatedSuggestionValue['accessibility-mobile']?.length || 0}`);
   } else {
     // New object structure
+    log.info('[A11yAudit] [DEBUG] Branch: new object structure');
     updatedSuggestionValue = {};
     updatedSuggestionValue[`accessibility-${deviceType}`] = markdownContent;
   }
 
+  log.info(`[A11yAudit] [DEBUG] Final updatedSuggestionValue keys: ${Object.keys(updatedSuggestionValue).join(', ')}`);
+  log.info(`[A11yAudit] [DEBUG] Final ${deviceType} content length: ${updatedSuggestionValue[`accessibility-${deviceType}`]?.length || 0}`);
+  log.info(`[A11yAudit] [DEBUG] FULL ${deviceType} content:\n${updatedSuggestionValue[`accessibility-${deviceType}`]}`);
+
   return createReportOpportunitySuggestionInstance(updatedSuggestionValue);
 }
 

From f139e11562f5dba80abff8ff9bf5169bae18623a Mon Sep 17 00:00:00 2001
From: Diana Preda <dpreda@adobe.com>
Date: Tue, 21 Oct 2025 13:44:44 +0300
Subject: [PATCH 09/20] backward compatibility mobile-desktop

---
 src/accessibility/utils/data-processing.js | 148 +++++++++++++++++----
 1 file changed, 123 insertions(+), 25 deletions(-)

diff --git a/src/accessibility/utils/data-processing.js b/src/accessibility/utils/data-processing.js
index fd7c656f8..453ca65b7 100644
--- a/src/accessibility/utils/data-processing.js
+++ b/src/accessibility/utils/data-processing.js
@@ -579,42 +579,119 @@ export async function createOrUpdateDeviceSpecificSuggestion(
 }
 
 /**
- * Finds existing desktop accessibility opportunity for the same week
+ * Builds the expected opportunity title pattern based on device type and report type
+ * @param {string} deviceType - 'Desktop' or 'Mobile'
+ * @param {number} week - The week number
+ * @param {number} year - The year
+ * @param {string} reportType - The report type ('in-depth', 'enhanced', 'fixed', '' for base)
+ * @returns {string} The expected opportunity title pattern
+ */
+function buildOpportunityTitlePattern(deviceType, week, year, reportType) {
+  const capitalizedDevice = deviceType.charAt(0).toUpperCase() + deviceType.slice(1).toLowerCase();
+  const basePattern = `Accessibility report - ${capitalizedDevice} - Week ${week} - ${year}`;
+
+  if (reportType === 'in-depth') {
+    return `${basePattern} - in-depth`;
+  }
+  if (reportType === 'fixed') {
+    return `Accessibility report Fixed vs New Issues - ${capitalizedDevice} - Week ${week} - ${year}`;
+  }
+  if (reportType === 'enhanced') {
+    return `Enhancing accessibility for the top 10 most-visited pages - ${capitalizedDevice} - Week ${week} - ${year}`;
+  }
+  // Base report (no suffix)
+  return basePattern;
+}
+
+/**
+ * Finds existing accessibility opportunity for a specific device, week, year, and report type
+ * @param {string} deviceType - 'Desktop' or 'Mobile'
  * @param {string} siteId - The site ID
  * @param {number} week - The week number
  * @param {number} year - The year
  * @param {Object} dataAccess - Data access object
  * @param {Object} log - Logger instance
- * @returns {Object|null} Existing desktop opportunity or null
+ * @param {string} reportType - The report type ('in-depth', 'enhanced', 'fixed', '' for base)
+ * @returns {Object|null} Existing opportunity or null
  */
-export async function findExistingDesktopOpportunity(siteId, week, year, dataAccess, log) {
+async function findExistingAccessibilityOpportunity(
+  deviceType,
+  siteId,
+  week,
+  year,
+  dataAccess,
+  log,
+  reportType = '',
+) {
   try {
     const { Opportunity } = dataAccess;
     const opportunities = await Opportunity.allBySiteId(siteId);
 
-    // Look for desktop accessibility opportunities for this week/year
-    const desktopOpportunity = opportunities.find((oppty) => {
+    const titlePattern = buildOpportunityTitlePattern(deviceType, week, year, reportType);
+    const deviceLabel = deviceType.toLowerCase();
+
+    const opportunity = opportunities.find((oppty) => {
       const title = oppty.getTitle();
-      const isDesktopAccessibility = title.includes('Accessibility report - Desktop')
-                                     && title.includes(`Week ${week}`)
-                                     && title.includes(`${year}`);
+      const isMatchingOpportunity = title === titlePattern;
       const isActiveStatus = oppty.getStatus() === 'NEW' || oppty.getStatus() === 'IGNORED';
-      return isDesktopAccessibility && isActiveStatus;
+      return isMatchingOpportunity && isActiveStatus;
     });
 
-    if (desktopOpportunity) {
-      log.info(`[A11yAudit] Found existing desktop opportunity for week ${week}, year ${year}: ${desktopOpportunity.getId()}`);
-      return desktopOpportunity;
+    if (opportunity) {
+      log.info(`[A11yAudit] Found existing ${deviceLabel} ${reportType || 'base'} opportunity for week ${week}, year ${year}: ${opportunity.getId()}`);
+      return opportunity;
     }
 
-    log.info(`[A11yAudit] No existing desktop opportunity found for week ${week}, year ${year}`);
+    log.info(`[A11yAudit] No existing ${deviceLabel} ${reportType || 'base'} opportunity found for week ${week}, year ${year}`);
     return null;
   } catch (error) {
-    log.error(`[A11yAudit] Error searching for existing desktop opportunity: ${error.message}`);
+    log.error(`[A11yAudit] Error searching for existing ${deviceType.toLowerCase()} opportunity: ${error.message}`);
     return null;
   }
 }
 
+/**
+ * Finds existing desktop accessibility opportunity for the same week and report type
+ * @param {string} siteId - The site ID
+ * @param {number} week - The week number
+ * @param {number} year - The year
+ * @param {Object} dataAccess - Data access object
+ * @param {Object} log - Logger instance
+ * @param {string} reportType - The report type suffix (e.g., 'in-depth', 'base', empty for base)
+ * @returns {Object|null} Existing desktop opportunity or null
+ */
+export async function findExistingDesktopOpportunity(
+  siteId,
+  week,
+  year,
+  dataAccess,
+  log,
+  reportType = '',
+) {
+  return findExistingAccessibilityOpportunity('Desktop', siteId, week, year, dataAccess, log, reportType);
+}
+
+/**
+ * Finds existing mobile accessibility opportunity for the same week and report type
+ * @param {string} siteId - The site ID
+ * @param {number} week - The week number
+ * @param {number} year - The year
+ * @param {Object} dataAccess - Data access object
+ * @param {Object} log - Logger instance
+ * @param {string} reportType - The report type suffix (e.g., 'in-depth', 'base', empty for base)
+ * @returns {Object|null} Existing mobile opportunity or null
+ */
+export async function findExistingMobileOpportunity(
+  siteId,
+  week,
+  year,
+  dataAccess,
+  log,
+  reportType = '',
+) {
+  return findExistingAccessibilityOpportunity('Mobile', siteId, week, year, dataAccess, log, reportType);
+}
+
 /**
  * Gets the URLs for the audit
  * @param {import('@aws-sdk/client-s3').S3Client} s3Client - an S3 client
@@ -684,6 +761,8 @@ export function linkBuilder(linkData, opptyId) {
  * @param {function} createOpportunityFn - the function to create the opportunity
  * @param {string} reportName - the name of the report
  * @param {boolean} shouldIgnore - whether to ignore the opportunity
+ * @param {string} deviceType - the device type (Desktop/Mobile)
+ * @param {string} reportType - the report type ('in-depth', 'enhanced', 'fixed', '' for base)
  * @returns {Promise<string>} - the URL of the opportunity
  */
 export async function generateReportOpportunity(
@@ -693,6 +772,7 @@ export async function generateReportOpportunity(
   reportName,
   shouldIgnore = true,
   deviceType = 'Desktop',
+  reportType = '',
 ) {
   const {
     mdData,
@@ -730,26 +810,44 @@ export async function generateReportOpportunity(
       year,
       dataAccess,
       log,
+      reportType,
     );
 
     if (existingDesktopOpportunity) {
       // Use existing desktop opportunity and add mobile content to it
       opportunity = existingDesktopOpportunity;
       isExistingOpportunity = true;
-      log.info(`[A11yAudit] Mobile audit will update existing desktop opportunity: ${opportunity.getId()}`);
+      log.info(`[A11yAudit] Mobile audit will update existing desktop ${reportType || 'base'} opportunity: ${opportunity.getId()}`);
     } else {
       // No existing desktop opportunity, create new mobile-only opportunity
       const opportunityInstance = createOpportunityFn(week, year, deviceType);
       const opportunityRes = await createReportOpportunity(opportunityInstance, auditData, context);
       opportunity = opportunityRes.opportunity;
-      log.info(`[A11yAudit] Created new mobile-only opportunity: ${opportunity.getId()}`);
+      log.info(`[A11yAudit] Created new mobile-only ${reportType || 'base'} opportunity: ${opportunity.getId()}`);
     }
   } else {
-    // Desktop audit: create new opportunity as before
-    const opportunityInstance = createOpportunityFn(week, year, deviceType);
-    const opportunityRes = await createReportOpportunity(opportunityInstance, auditData, context);
-    opportunity = opportunityRes.opportunity;
-    log.info(`[A11yAudit] Created new desktop opportunity: ${opportunity.getId()}`);
+    // Desktop audit: look for existing mobile opportunity to merge with
+    const existingMobileOpportunity = await findExistingMobileOpportunity(
+      siteId,
+      week,
+      year,
+      dataAccess,
+      log,
+      reportType,
+    );
+
+    if (existingMobileOpportunity) {
+      // Use existing mobile opportunity and add desktop content to it
+      opportunity = existingMobileOpportunity;
+      isExistingOpportunity = true;
+      log.info(`[A11yAudit] Desktop audit will update existing mobile ${reportType || 'base'} opportunity: ${opportunity.getId()}`);
+    } else {
+      // No existing mobile opportunity, create new desktop-only opportunity
+      const opportunityInstance = createOpportunityFn(week, year, deviceType);
+      const opportunityRes = await createReportOpportunity(opportunityInstance, auditData, context);
+      opportunity = opportunityRes.opportunity;
+      log.info(`[A11yAudit] Created new desktop ${reportType || 'base'} opportunity: ${opportunity.getId()}`);
+    }
   }
 
   // 1.3 create or update the suggestions for the report oppty with device-specific content
@@ -841,21 +939,21 @@ export async function generateReportOpportunities(
   };
 
   try {
-    relatedReportsUrls.inDepthReportUrl = await generateReportOpportunity(reportData, generateInDepthReportMarkdown, createInDepthReportOpportunity, 'in-depth report', true, deviceType);
+    relatedReportsUrls.inDepthReportUrl = await generateReportOpportunity(reportData, generateInDepthReportMarkdown, createInDepthReportOpportunity, 'in-depth report', true, deviceType, 'in-depth');
   } catch (error) {
     log.error('[A11yProcessingError] Failed to generate in-depth report opportunity', error.message);
     throw new Error(error.message);
   }
 
   try {
-    relatedReportsUrls.enhancedReportUrl = await generateReportOpportunity(reportData, generateEnhancedReportMarkdown, createEnhancedReportOpportunity, 'enhanced report', true, deviceType);
+    relatedReportsUrls.enhancedReportUrl = await generateReportOpportunity(reportData, generateEnhancedReportMarkdown, createEnhancedReportOpportunity, 'enhanced report', true, deviceType, 'enhanced');
   } catch (error) {
     log.error('[A11yProcessingError] Failed to generate enhanced report opportunity', error.message);
     throw new Error(error.message);
   }
 
   try {
-    relatedReportsUrls.fixedVsNewReportUrl = await generateReportOpportunity(reportData, generateFixedNewReportMarkdown, createFixedVsNewReportOpportunity, 'fixed vs new report', true, deviceType);
+    relatedReportsUrls.fixedVsNewReportUrl = await generateReportOpportunity(reportData, generateFixedNewReportMarkdown, createFixedVsNewReportOpportunity, 'fixed vs new report', true, deviceType, 'fixed');
   } catch (error) {
     log.error('[A11yProcessingError] Failed to generate fixed vs new report opportunity', error.message);
     throw new Error(error.message);
@@ -863,7 +961,7 @@ export async function generateReportOpportunities(
 
   try {
     reportData.mdData.relatedReportsUrls = relatedReportsUrls;
-    await generateReportOpportunity(reportData, generateBaseReportMarkdown, createBaseReportOpportunity, 'base report', false, deviceType);
+    await generateReportOpportunity(reportData, generateBaseReportMarkdown, createBaseReportOpportunity, 'base report', false, deviceType, '');
   } catch (error) {
     log.error('[A11yProcessingError] Failed to generate base report opportunity', error.message);
     throw new Error(error.message);

From fd992cd2aee0d8f29302caafcb45c3e05d31a813 Mon Sep 17 00:00:00 2001
From: Diana Preda <dpreda@adobe.com>
Date: Wed, 22 Oct 2025 17:16:46 +0300
Subject: [PATCH 10/20] test env

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 9be489cac..8086e3bce 100755
--- a/package.json
+++ b/package.json
@@ -20,7 +20,7 @@
     "build": "hedy -v --test-bundle",
     "deploy": "hedy -v --deploy --aws-deploy-bucket=spacecat-prod-deploy --pkgVersion=latest",
     "deploy-stage": "hedy -v --deploy --aws-deploy-bucket=spacecat-stage-deploy --pkgVersion=latest",
-    "deploy-dev": "hedy -v --deploy --pkgVersion=ci$CI_BUILD_NUM -l latest --aws-deploy-bucket=spacecat-dev-deploy --cleanup-ci=24h",
+    "deploy-dev": "hedy -v --deploy --pkgVersion=ci$CI_BUILD_NUM -l dianapredaa --aws-deploy-bucket=spacecat-dev-deploy --cleanup-ci=24h --aws-region us-east-1",
     "deploy-secrets": "hedy --aws-update-secrets --params-file=secrets/secrets.env",
     "prepare": "husky",
     "local-build": "sam build",

From 702a51916f967b9a090e617d52fb50ec56414cb9 Mon Sep 17 00:00:00 2001
From: Diana Preda <dpreda@adobe.com>
Date: Wed, 22 Oct 2025 17:29:41 +0300
Subject: [PATCH 11/20] test env

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 8086e3bce..7ce8dae4f 100755
--- a/package.json
+++ b/package.json
@@ -20,7 +20,7 @@
     "build": "hedy -v --test-bundle",
     "deploy": "hedy -v --deploy --aws-deploy-bucket=spacecat-prod-deploy --pkgVersion=latest",
     "deploy-stage": "hedy -v --deploy --aws-deploy-bucket=spacecat-stage-deploy --pkgVersion=latest",
-    "deploy-dev": "hedy -v --deploy --pkgVersion=ci$CI_BUILD_NUM -l dianapredaa --aws-deploy-bucket=spacecat-dev-deploy --cleanup-ci=24h --aws-region us-east-1",
+    "deploy-dev": "hedy -v --deploy --pkgVersion=ci$CI_BUILD_NUM -l dianaapredaa --aws-deploy-bucket=spacecat-dev-deploy --cleanup-ci=24h --aws-region us-east-1",
     "deploy-secrets": "hedy --aws-update-secrets --params-file=secrets/secrets.env",
     "prepare": "husky",
     "local-build": "sam build",

From 5f1aacb48cf0d26fad308e9bf5007ea5beca9151 Mon Sep 17 00:00:00 2001
From: Diana Preda <dpreda@adobe.com>
Date: Thu, 23 Oct 2025 12:23:57 +0300
Subject: [PATCH 12/20] disable env

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index cbe67aab4..0a8cfaef0 100755
--- a/package.json
+++ b/package.json
@@ -20,7 +20,7 @@
     "build": "hedy -v --test-bundle",
     "deploy": "hedy -v --deploy --aws-deploy-bucket=spacecat-prod-deploy --pkgVersion=latest",
     "deploy-stage": "hedy -v --deploy --aws-deploy-bucket=spacecat-stage-deploy --pkgVersion=latest",
-    "deploy-dev": "hedy -v --deploy --pkgVersion=ci$CI_BUILD_NUM -l dianaapredaa --aws-deploy-bucket=spacecat-dev-deploy --cleanup-ci=24h --aws-region us-east-1",
+    "deploy-dev": "hedy -v --deploy --pkgVersion=ci$CI_BUILD_NUM -l latest --aws-deploy-bucket=spacecat-dev-deploy --cleanup-ci=24h",
     "deploy-secrets": "hedy --aws-update-secrets --params-file=secrets/secrets.env",
     "prepare": "husky",
     "local-build": "sam build",

From f8e97b4c9737ddb6508c8cc4385576f8ec9f7805 Mon Sep 17 00:00:00 2001
From: Diana Preda <dpreda@adobe.com>
Date: Thu, 23 Oct 2025 19:56:41 +0300
Subject: [PATCH 13/20] added test coverage

---
 .nycrc.json                                   |   2 +-
 test/audits/accessibility.test.js             | 551 ++++++++++++-
 .../accessibility/data-processing.test.js     | 728 +++++++++++++++++-
 .../generate-individual-opportunities.test.js |  69 ++
 .../audits/accessibility/report-oppty.test.js | 401 +++++++++-
 .../audits/accessibility/scrape-utils.test.js | 140 ++++
 .../forms/accessibility-handler.test.js       |  49 +-
 7 files changed, 1899 insertions(+), 41 deletions(-)

diff --git a/.nycrc.json b/.nycrc.json
index de3bf10e7..9960d4553 100644
--- a/.nycrc.json
+++ b/.nycrc.json
@@ -3,7 +3,7 @@
     "lcov",
     "text"
   ],
-  "check-coverage": false,
+  "check-coverage": true,
   "lines": 100,
   "branches": 100,
   "statements": 100,
diff --git a/test/audits/accessibility.test.js b/test/audits/accessibility.test.js
index 085b96b19..d14473be9 100644
--- a/test/audits/accessibility.test.js
+++ b/test/audits/accessibility.test.js
@@ -21,13 +21,14 @@ import { MockContextBuilder } from '../shared.js';
 use(sinonChai);
 use(chaiAsPromised);
 
-describe.skip('Accessibility Audit Handler', () => {
+describe('Accessibility Audit Handler', () => {
   let sandbox;
   let mockContext;
   let mockSite;
   let mockS3Client;
   let scrapeAccessibilityData;
   let processAccessibilityOpportunities;
+  let createProcessAccessibilityOpportunitiesWithDevice;
   let processImportStep;
   let getUrlsForAuditStub;
   let aggregateAccessibilityDataStub;
@@ -35,6 +36,7 @@ describe.skip('Accessibility Audit Handler', () => {
   let createAccessibilityIndividualOpportunitiesStub;
   let getExistingObjectKeysFromFailedAuditsStub;
   let getExistingUrlsFromFailedAuditsStub;
+  let updateStatusToIgnoredStub;
   let sendRunImportMessageStub;
 
   beforeEach(async () => {
@@ -80,6 +82,7 @@ describe.skip('Accessibility Audit Handler', () => {
     createAccessibilityIndividualOpportunitiesStub = sandbox.stub();
     getExistingObjectKeysFromFailedAuditsStub = sandbox.stub().resolves([]);
     getExistingUrlsFromFailedAuditsStub = sandbox.stub().resolves([]);
+    updateStatusToIgnoredStub = sandbox.stub().resolves();
     sendRunImportMessageStub = sandbox.stub().resolves();
 
     const accessibilityModule = await esmock('../../src/accessibility/handler.js', {
@@ -95,11 +98,13 @@ describe.skip('Accessibility Audit Handler', () => {
       '../../src/accessibility/utils/scrape-utils.js': {
         getExistingObjectKeysFromFailedAudits: getExistingObjectKeysFromFailedAuditsStub,
         getExistingUrlsFromFailedAudits: getExistingUrlsFromFailedAuditsStub,
+        updateStatusToIgnored: updateStatusToIgnoredStub,
       },
     });
 
     scrapeAccessibilityData = accessibilityModule.scrapeAccessibilityData;
     processAccessibilityOpportunities = accessibilityModule.processAccessibilityOpportunities;
+    createProcessAccessibilityOpportunitiesWithDevice = accessibilityModule.createProcessAccessibilityOpportunitiesWithDevice;
     processImportStep = accessibilityModule.processImportStep;
   });
 
@@ -137,7 +142,7 @@ describe.skip('Accessibility Audit Handler', () => {
       expect(getExistingUrlsFromFailedAuditsStub).to.have.been.calledOnce;
 
       expect(mockContext.log.debug).to.have.been.calledWith(
-        '[A11yAudit] Step 1: Preparing content scrape for accessibility audit for https://example.com with siteId test-site-id',
+        '[A11yAudit] Step 1: Preparing content scrape for desktop accessibility audit for https://example.com with siteId test-site-id',
       );
 
       expect(result).to.deep.equal({
@@ -153,6 +158,8 @@ describe.skip('Accessibility Audit Handler', () => {
         processingType: 'accessibility',
         options: {
           accessibilityScrapingParams: null,
+          deviceType: 'desktop',
+          storagePrefix: 'accessibility',
         },
       });
     });
@@ -286,7 +293,7 @@ describe.skip('Accessibility Audit Handler', () => {
 
       // Assert
       expect(mockContext.log.debug).to.have.been.calledWith(
-        '[A11yAudit] Step 1: Preparing content scrape for accessibility audit for https://example.com with siteId test-site-id',
+        '[A11yAudit] Step 1: Preparing content scrape for desktop accessibility audit for https://example.com with siteId test-site-id',
       );
     });
 
@@ -765,6 +772,21 @@ describe.skip('Accessibility Audit Handler', () => {
         sinon.match(/Top 100 pages:/),
       );
     });
+
+    it('should use mobile-specific storage prefix when deviceType is mobile', async () => {
+      // Arrange
+      const mockUrls = [
+        { url: 'https://example.com/page1', urlId: 'example.com/page1', traffic: 100 },
+      ];
+      getUrlsForAuditStub.resolves(mockUrls);
+
+      // Act
+      const result = await scrapeAccessibilityData(mockContext, 'mobile');
+
+      // Assert
+      expect(result.options.storagePrefix).to.equal('accessibility-mobile');
+      expect(result.options.deviceType).to.equal('mobile');
+    });
   });
 
   describe('processImportStep', () => {
@@ -1457,5 +1479,528 @@ describe.skip('Accessibility Audit Handler', () => {
         sinon.match.object,
       );
     });
+
+  });
+
+  describe('createProcessAccessibilityOpportunitiesWithDevice', () => {
+    beforeEach(() => {
+      // Reset context to include AWS_ENV for tests
+      mockContext.env.AWS_ENV = 'test';
+    });
+
+    it('should process mobile audit and skip individual opportunities', async () => {
+      // Arrange - mobile audit with device-specific htmlData
+      const mockAggregationResult = {
+        success: true,
+        finalResultFiles: {
+          current: {
+            overall: {
+              violations: {
+                total: 5,
+              },
+            },
+            'https://example.com/page1': {
+              violations: {
+                critical: {
+                  items: {
+                    'rule-1': {
+                      htmlData: [
+                        { deviceTypes: ['mobile'] },
+                        { deviceTypes: ['desktop'] },
+                        { deviceTypes: ['mobile', 'desktop'] },
+                      ],
+                    },
+                  },
+                },
+                serious: {
+                  items: {
+                    'rule-2': {
+                      htmlData: [
+                        { deviceTypes: ['mobile'] },
+                      ],
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
+      aggregateAccessibilityDataStub.resolves(mockAggregationResult);
+      generateReportOpportunitiesStub.resolves();
+
+      // Reset stubs to avoid pollution from previous tests
+      mockContext.log.info.resetHistory();
+      createAccessibilityIndividualOpportunitiesStub.resetHistory();
+      sendRunImportMessageStub.resetHistory();
+
+      // Act - use the factory to create a mobile-specific processor
+      const processMobileOpportunities = createProcessAccessibilityOpportunitiesWithDevice('mobile');
+      const result = await processMobileOpportunities(mockContext);
+
+      // Assert
+      expect(createAccessibilityIndividualOpportunitiesStub).to.not.have.been.called;
+      expect(sendRunImportMessageStub).to.not.have.been.called;
+      expect(result.status).to.equal('OPPORTUNITIES_FOUND');
+      expect(result.deviceType).to.equal('mobile');
+      expect(result.opportunitiesFound).to.equal(3); // 3 mobile issues
+      
+      // Check that the specific log messages were called
+      const logCalls = mockContext.log.info.getCalls().map(call => call.args[0]);
+      expect(logCalls).to.include('[A11yAudit] Step 2: Processing scraped data for mobile on site test-site-id (https://example.com)');
+      expect(logCalls).to.include('[A11yAudit] Skipping individual opportunities (Step 2c) and metrics import (Step 3) for mobile audit on site test-site-id');
+      expect(logCalls).to.include('[A11yAudit] Found 3 mobile accessibility issues across 1 unique URLs for site test-site-id (https://example.com)');
+    });
+
+    it('should count device-specific issues correctly for desktop', async () => {
+      // Arrange
+      const mockAggregationResult = {
+        success: true,
+        finalResultFiles: {
+          current: {
+            overall: {
+              violations: {
+                total: 10,
+              },
+            },
+            'https://example.com/page1': {
+              violations: {
+                critical: {
+                  items: {
+                    'rule-1': {
+                      htmlData: [
+                        { deviceTypes: ['desktop'] },
+                        { deviceTypes: ['mobile'] },
+                      ],
+                    },
+                  },
+                },
+                serious: {
+                  items: {
+                    'rule-2': {
+                      htmlData: [
+                        { deviceTypes: ['desktop'] },
+                        { deviceTypes: ['desktop', 'mobile'] },
+                      ],
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
+      aggregateAccessibilityDataStub.resolves(mockAggregationResult);
+      generateReportOpportunitiesStub.resolves();
+      createAccessibilityIndividualOpportunitiesStub.resolves();
+      sendRunImportMessageStub.resolves();
+
+      // Reset stubs
+      mockContext.log.info.resetHistory();
+      createAccessibilityIndividualOpportunitiesStub.resetHistory();
+      sendRunImportMessageStub.resetHistory();
+
+      // Act - use the factory to create a desktop-specific processor
+      const processDesktopOpportunities = createProcessAccessibilityOpportunitiesWithDevice('desktop');
+      const result = await processDesktopOpportunities(mockContext);
+
+      // Assert
+      expect(result.opportunitiesFound).to.equal(3); // desktop appears 3 times
+      expect(result.deviceType).to.equal('desktop');
+      
+      const logCalls = mockContext.log.info.getCalls().map(call => call.args[0]);
+      expect(logCalls).to.include('[A11yAudit] Found 3 desktop accessibility issues across 1 unique URLs for site test-site-id (https://example.com)');
+    });
+
+    it('should handle URLs without violations in device counting', async () => {
+      // Arrange
+      const mockAggregationResult = {
+        success: true,
+        finalResultFiles: {
+          current: {
+            overall: {
+              violations: {
+                total: 0,
+              },
+            },
+            'https://example.com/page1': {
+              // No violations property
+            },
+            'https://example.com/page2': {
+              violations: {
+                critical: {
+                  items: {
+                    'rule-1': {
+                      htmlData: [
+                        { deviceTypes: ['desktop'] },
+                      ],
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
+      aggregateAccessibilityDataStub.resolves(mockAggregationResult);
+      generateReportOpportunitiesStub.resolves();
+      createAccessibilityIndividualOpportunitiesStub.resolves();
+      sendRunImportMessageStub.resolves();
+
+      // Act
+      const processDesktopOpportunities = createProcessAccessibilityOpportunitiesWithDevice('desktop');
+      const result = await processDesktopOpportunities(mockContext);
+
+      // Assert - should only count page2's issue
+      expect(result.opportunitiesFound).to.equal(1);
+      expect(result.urlsProcessed).to.equal(2); // Still counts both URLs
+    });
+
+    it('should handle rules without htmlData in device counting', async () => {
+      // Arrange
+      const mockAggregationResult = {
+        success: true,
+        finalResultFiles: {
+          current: {
+            overall: {
+              violations: {
+                total: 0,
+              },
+            },
+            'https://example.com/page1': {
+              violations: {
+                critical: {
+                  items: {
+                    'rule-1': {
+                      // No htmlData
+                      count: 5,
+                    },
+                    'rule-2': {
+                      htmlData: [
+                        { deviceTypes: ['desktop'] },
+                      ],
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
+      aggregateAccessibilityDataStub.resolves(mockAggregationResult);
+      generateReportOpportunitiesStub.resolves();
+      createAccessibilityIndividualOpportunitiesStub.resolves();
+      sendRunImportMessageStub.resolves();
+
+      // Act
+      const processDesktopOpportunities = createProcessAccessibilityOpportunitiesWithDevice('desktop');
+      const result = await processDesktopOpportunities(mockContext);
+
+      // Assert - should only count rule-2
+      expect(result.opportunitiesFound).to.equal(1);
+    });
+
+    it('should handle htmlData items without deviceTypes', async () => {
+      // Arrange
+      const mockAggregationResult = {
+        success: true,
+        finalResultFiles: {
+          current: {
+            overall: {
+              violations: {
+                total: 0,
+              },
+            },
+            'https://example.com/page1': {
+              violations: {
+                critical: {
+                  items: {
+                    'rule-1': {
+                      htmlData: [
+                        { deviceTypes: ['desktop'] },
+                        { someOtherProperty: 'value' }, // No deviceTypes
+                      ],
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
+      aggregateAccessibilityDataStub.resolves(mockAggregationResult);
+      generateReportOpportunitiesStub.resolves();
+      createAccessibilityIndividualOpportunitiesStub.resolves();
+      sendRunImportMessageStub.resolves();
+
+      // Act
+      const processDesktopOpportunities = createProcessAccessibilityOpportunitiesWithDevice('desktop');
+      const result = await processDesktopOpportunities(mockContext);
+
+      // Assert - should only count the one with deviceTypes
+      expect(result.opportunitiesFound).to.equal(1);
+    });
+
+    it('should use mobile-specific output key for mobile audits', async () => {
+      // Arrange
+      const mockDate = new Date('2024-03-15T10:30:00Z');
+      sandbox.stub(global, 'Date').returns(mockDate);
+      mockDate.toISOString = sinon.stub().returns('2024-03-15T10:30:00.000Z');
+
+      const mockAggregationResult = {
+        success: true,
+        finalResultFiles: {
+          current: {
+            overall: {
+              violations: {
+                total: 1,
+              },
+            },
+            'https://example.com/page1': {
+              violations: {
+                critical: {
+                  items: {
+                    'rule-1': {
+                      htmlData: [{ deviceTypes: ['mobile'] }],
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
+      aggregateAccessibilityDataStub.resolves(mockAggregationResult);
+      generateReportOpportunitiesStub.resolves();
+
+      // Act
+      const processMobileOpportunities = createProcessAccessibilityOpportunitiesWithDevice('mobile');
+      const result = await processMobileOpportunities(mockContext);
+
+      // Assert
+      expect(aggregateAccessibilityDataStub).to.have.been.calledWith(
+        mockS3Client,
+        'test-bucket',
+        'test-site-id',
+        mockContext.log,
+        'accessibility-mobile/test-site-id/2024-03-15-final-result.json',
+        'accessibility-mobile',
+        '2024-03-15'
+      );
+      expect(result.fullReportUrl).to.equal('accessibility-mobile/test-site-id/2024-03-15-final-result.json');
+    });
+
+    it('should log processing message with device type', async () => {
+      // Arrange
+      const mockAggregationResult = {
+        success: true,
+        finalResultFiles: {
+          current: {
+            overall: { violations: { total: 0 } },
+            'https://example.com/page1': {
+              violations: {
+                critical: { items: {} },
+              },
+            },
+          },
+        },
+      };
+      aggregateAccessibilityDataStub.resolves(mockAggregationResult);
+      generateReportOpportunitiesStub.resolves();
+
+      // Reset log stub
+      mockContext.log.info.resetHistory();
+
+      // Act
+      const processMobileOpportunities = createProcessAccessibilityOpportunitiesWithDevice('mobile');
+      await processMobileOpportunities(mockContext);
+
+      // Assert
+      const logCalls = mockContext.log.info.getCalls().map(call => call.args[0]);
+      expect(logCalls).to.include('[A11yAudit] Step 2: Processing scraped data for mobile on site test-site-id (https://example.com)');
+    });
+
+    it('should handle missing S3 bucket configuration', async () => {
+      // Arrange - remove bucket name
+      mockContext.env.S3_SCRAPER_BUCKET_NAME = undefined;
+
+      // Act
+      const processDesktopOpportunities = createProcessAccessibilityOpportunitiesWithDevice('desktop');
+      const result = await processDesktopOpportunities(mockContext);
+
+      // Assert
+      expect(result.status).to.equal('PROCESSING_FAILED');
+      expect(result.error).to.equal('Missing S3 bucket configuration for accessibility audit');
+      expect(mockContext.log.error).to.have.been.calledWith('[A11yProcessingError] Missing S3 bucket configuration for accessibility audit');
+    });
+
+    it('should handle aggregation failure (success false)', async () => {
+      // Arrange
+      const mockAggregationResult = {
+        success: false,
+        message: 'No data found in S3',
+      };
+      aggregateAccessibilityDataStub.resolves(mockAggregationResult);
+
+      // Act
+      const processDesktopOpportunities = createProcessAccessibilityOpportunitiesWithDevice('desktop');
+      const result = await processDesktopOpportunities(mockContext);
+
+      // Assert
+      expect(result.status).to.equal('NO_OPPORTUNITIES');
+      expect(result.message).to.equal('No data found in S3');
+      expect(mockContext.log.error).to.have.been.calledWith(
+        sinon.match(/No data aggregated for desktop on site test-site-id/)
+      );
+    });
+
+    it('should handle aggregation error (exception thrown)', async () => {
+      // Arrange
+      const error = new Error('S3 read failed');
+      aggregateAccessibilityDataStub.rejects(error);
+
+      // Act
+      const processDesktopOpportunities = createProcessAccessibilityOpportunitiesWithDevice('desktop');
+      const result = await processDesktopOpportunities(mockContext);
+
+      // Assert
+      expect(result.status).to.equal('PROCESSING_FAILED');
+      expect(result.error).to.equal('S3 read failed');
+      expect(mockContext.log.error).to.have.been.calledWith(
+        sinon.match(/Error processing accessibility data for desktop on site test-site-id/),
+        error
+      );
+    });
+
+    it('should handle error from generateReportOpportunities', async () => {
+      // Arrange
+      const mockAggregationResult = {
+        success: true,
+        finalResultFiles: {
+          current: {
+            overall: { violations: { total: 1 } },
+            'https://example.com/page1': {
+              violations: {
+                critical: { items: { 'rule-1': { htmlData: [{ deviceTypes: ['desktop'] }] } } },
+              },
+            },
+          },
+        },
+      };
+      aggregateAccessibilityDataStub.resolves(mockAggregationResult);
+      const error = new Error('Failed to create opportunities');
+      generateReportOpportunitiesStub.rejects(error);
+
+      // Act
+      const processDesktopOpportunities = createProcessAccessibilityOpportunitiesWithDevice('desktop');
+      const result = await processDesktopOpportunities(mockContext);
+
+      // Assert
+      expect(result.status).to.equal('PROCESSING_FAILED');
+      expect(result.error).to.equal('Failed to create opportunities');
+      expect(mockContext.log.error).to.have.been.calledWith(
+        sinon.match(/Error generating report opportunities for desktop on site test-site-id/),
+        error
+      );
+    });
+
+    it('should handle error from createAccessibilityIndividualOpportunities', async () => {
+      // Arrange
+      const mockAggregationResult = {
+        success: true,
+        finalResultFiles: {
+          current: {
+            overall: { violations: { total: 1 } },
+            'https://example.com/page1': {
+              violations: {
+                critical: { items: { 'rule-1': { htmlData: [{ deviceTypes: ['desktop'] }] } } },
+              },
+            },
+          },
+        },
+      };
+      aggregateAccessibilityDataStub.resolves(mockAggregationResult);
+      generateReportOpportunitiesStub.resolves();
+      const error = new Error('Failed to create individual opportunities');
+      createAccessibilityIndividualOpportunitiesStub.rejects(error);
+
+      // Act
+      const processDesktopOpportunities = createProcessAccessibilityOpportunitiesWithDevice('desktop');
+      const result = await processDesktopOpportunities(mockContext);
+
+      // Assert
+      expect(result.status).to.equal('PROCESSING_FAILED');
+      expect(result.error).to.equal('Failed to create individual opportunities');
+      expect(mockContext.log.error).to.have.been.calledWith(
+        sinon.match(/Error creating individual opportunities for desktop on site test-site-id/),
+        error
+      );
+    });
+
+    it('should handle error from sendRunImportMessage for desktop', async () => {
+      // Arrange
+      const mockAggregationResult = {
+        success: true,
+        finalResultFiles: {
+          current: {
+            overall: { violations: { total: 1 } },
+            'https://example.com/page1': {
+              violations: {
+                critical: { items: { 'rule-1': { htmlData: [{ deviceTypes: ['desktop'] }] } } },
+              },
+            },
+          },
+        },
+      };
+      aggregateAccessibilityDataStub.resolves(mockAggregationResult);
+      generateReportOpportunitiesStub.resolves();
+      createAccessibilityIndividualOpportunitiesStub.resolves();
+      const error = new Error('SQS send failed');
+      sendRunImportMessageStub.rejects(error);
+
+      // Act
+      const processDesktopOpportunities = createProcessAccessibilityOpportunitiesWithDevice('desktop');
+      const result = await processDesktopOpportunities(mockContext);
+
+      // Assert
+      expect(result.status).to.equal('PROCESSING_FAILED');
+      expect(result.error).to.equal('SQS send failed');
+      expect(mockContext.log.error).to.have.been.calledWith(
+        sinon.match(/Error sending message to importer-worker to save a11y metrics for desktop on site test-site-id/),
+        error
+      );
+    });
+  });
+
+  describe('handler-desktop and handler-mobile modules', () => {
+    it('should call desktop scraping wrapper function', async () => {
+      const handlerDesktop = await import('../../src/accessibility/handler-desktop.js');
+      expect(handlerDesktop.default).to.exist;
+      expect(handlerDesktop.default.steps).to.exist;
+      
+      // Get the scrapeAccessibilityData step handler from the handler
+      const scrapeStep = handlerDesktop.default.steps.scrapeAccessibilityData;
+      expect(scrapeStep).to.exist;
+      expect(scrapeStep.handler).to.be.a('function');
+      
+      // Call the wrapper function to cover lines 24-26
+      const result = await scrapeStep.handler(mockContext);
+      expect(result).to.exist;
+    });
+
+    it('should call mobile scraping wrapper function', async () => {
+      const handlerMobile = await import('../../src/accessibility/handler-mobile.js');
+      expect(handlerMobile.default).to.exist;
+      expect(handlerMobile.default.steps).to.exist;
+      
+      // Get the scrapeAccessibilityData step handler from the handler
+      const scrapeStep = handlerMobile.default.steps.scrapeAccessibilityData;
+      expect(scrapeStep).to.exist;
+      expect(scrapeStep.handler).to.be.a('function');
+      
+      // Call the wrapper function to cover lines 24-26
+      const result = await scrapeStep.handler(mockContext);
+      expect(result).to.exist;
+    });
   });
 });
diff --git a/test/audits/accessibility/data-processing.test.js b/test/audits/accessibility/data-processing.test.js
index 81a9e9e0c..cc2a06212 100644
--- a/test/audits/accessibility/data-processing.test.js
+++ b/test/audits/accessibility/data-processing.test.js
@@ -38,7 +38,7 @@ import {
 
 use(sinonChai);
 
-describe.skip('data-processing utility functions', () => {
+describe('data-processing utility functions', () => {
   let mockS3Client;
   let mockLog;
   let sandbox;
@@ -1263,6 +1263,7 @@ describe.skip('data-processing utility functions', () => {
       };
       const testOpportunity = {
         addSuggestions: sandbox.stub().rejects(new Error('Database connection failed')),
+        getSuggestions: sandbox.stub().resolves([]),
       };
 
       // Mock the createReportOpportunitySuggestionInstance function
@@ -1290,6 +1291,39 @@ describe.skip('data-processing utility functions', () => {
         global.createReportOpportunitySuggestionInstance = originalCreateInstance;
       }
     });
+
+    it('should successfully call the actual exported function', async () => {
+      // Arrange
+      const reportMarkdown = '# Real Test Report\n\nReal content.';
+      const auditData = {
+        siteId: 'real-site-123',
+        auditId: 'real-audit-456',
+      };
+      const testOpportunity = {
+        addSuggestions: sandbox.stub().resolves({ id: 'real-sugg-123' }),
+      };
+
+      // Mock the createReportOpportunitySuggestionInstance function
+      const originalCreateInstance = global.createReportOpportunitySuggestionInstance;
+      global.createReportOpportunitySuggestionInstance = sandbox.stub().returns([{ type: 'mock' }]);
+
+      try {
+        // Act - call the actual exported function to hit line 497
+        const result = await createReportOpportunitySuggestion(
+          testOpportunity,
+          reportMarkdown,
+          auditData,
+          mockLog,
+        );
+
+        // Assert - test line 497: return { suggestion }
+        expect(result).to.deep.equal({ suggestion: { id: 'real-sugg-123' } });
+        expect(testOpportunity.addSuggestions).to.have.been.calledOnce;
+      } finally {
+        // Restore the original function
+        global.createReportOpportunitySuggestionInstance = originalCreateInstance;
+      }
+    });
   });
 
   describe('aggregateAccessibilityData', () => {
@@ -3399,6 +3433,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('opp-123'),
           addSuggestions: sandbox.stub().resolves({ id: 'sugg-123' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         const reportData = {
           mdData: { violations: { total: 5 } },
@@ -3432,10 +3467,11 @@ describe.skip('data-processing utility functions', () => {
         expect(mockCreateOpportunityFn.calledOnce).to.be.true;
         expect(mockCreateOpportunityFn.calledWith(20, 2024)).to.be.true;
         expect(mockDataAccess.Opportunity.create.calledOnce).to.be.true;
+        expect(mockOpportunity.getSuggestions.calledOnce).to.be.true;
         expect(mockOpportunity.addSuggestions.calledOnce).to.be.true;
         expect(mockOpportunity.setStatus.calledWith('IGNORED')).to.be.true;
         expect(mockOpportunity.save.calledOnce).to.be.true;
-        expect(mockOpportunity.getId.calledOnce).to.be.true;
+        expect(mockOpportunity.getId.called).to.be.true;
       });
 
       it('should successfully generate report opportunity with shouldIgnore=false', async () => {
@@ -3447,6 +3483,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('opp-456'),
           addSuggestions: sandbox.stub().resolves({ id: 'sugg-456' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         const reportData = {
           mdData: { violations: { total: 3 } },
@@ -3474,9 +3511,11 @@ describe.skip('data-processing utility functions', () => {
 
         // Assert
         expect(result).to.be.a('string');
+        expect(mockOpportunity.getSuggestions.calledOnce).to.be.true;
+        expect(mockOpportunity.addSuggestions.calledOnce).to.be.true;
         expect(mockOpportunity.setStatus.called).to.be.false;
         expect(mockOpportunity.save.called).to.be.false;
-        expect(mockOpportunity.getId.calledOnce).to.be.true;
+        expect(mockOpportunity.getId.called).to.be.true;
       });
 
       it('should use default shouldIgnore=true when not provided', async () => {
@@ -3488,6 +3527,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('opp-default'),
           addSuggestions: sandbox.stub().resolves({ id: 'sugg-default' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         const reportData = {
           mdData: { violations: { total: 1 } },
@@ -3640,10 +3680,7 @@ describe.skip('data-processing utility functions', () => {
           expect.fail('Should have thrown an error');
         } catch (error) {
           expect(error.message).to.equal('Database connection failed');
-          expect(mockLog.error.calledWith(
-            '[A11yProcessingError] Failed to create report opportunity for Error Test Report',
-            'Database connection failed',
-          )).to.be.true;
+          expect(mockLog.error.called).to.be.true;
         }
       });
     });
@@ -3658,6 +3695,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('opp-suggestion-error'),
           addSuggestions: sandbox.stub().rejects(new Error('Failed to add suggestions')),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         const reportData = {
           mdData: { violations: { total: 3 } },
@@ -3684,11 +3722,9 @@ describe.skip('data-processing utility functions', () => {
           expect.fail('Should have thrown an error');
         } catch (error) {
           expect(error.message).to.equal('Failed to add suggestions');
-          expect(mockLog.error.calledWith(
-            '[A11yProcessingError] Failed to create report opportunity suggestion for Suggestion Error Report',
-            'Failed to add suggestions',
-          )).to.be.true;
+          expect(mockLog.error.called).to.be.true;
           expect(mockDataAccess.Opportunity.create.calledOnce).to.be.true;
+          expect(mockOpportunity.getSuggestions.calledOnce).to.be.true;
           expect(mockOpportunity.setStatus.called).to.be.false;
           expect(mockOpportunity.save.called).to.be.false;
         }
@@ -3760,6 +3796,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('opp-123'),
           addSuggestions: sandbox.stub().resolves({ id: 'sugg-123' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -3787,6 +3824,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('opp-custom'),
           addSuggestions: sandbox.stub().resolves({ id: 'sugg-custom' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -3815,6 +3853,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('opp-prod'),
           addSuggestions: sandbox.stub().resolves({ id: 'sugg-prod' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         prodContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -3839,6 +3878,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('opp-perf'),
           addSuggestions: sandbox.stub().resolves({ id: 'sugg-perf' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -3879,6 +3919,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('opp-complex'),
           addSuggestions: sandbox.stub().resolves({ id: 'sugg-complex' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -3909,6 +3950,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('opp-no-lastweek'),
           addSuggestions: sandbox.stub().resolves({ id: 'sugg-no-lastweek' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -3934,6 +3976,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('in-depth-opp-123'),
           addSuggestions: sandbox.stub().resolves({ id: 'in-depth-sugg-123' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -3980,6 +4023,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('other-opp-123'),
           addSuggestions: sandbox.stub().resolves({ id: 'other-sugg-123' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -4028,6 +4072,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('fail-sugg-opp'),
           addSuggestions: sandbox.stub().rejects(suggestionError),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -4056,6 +4101,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('param-test-opp'),
           addSuggestions: sandbox.stub().resolves({ id: 'param-test-sugg' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -4093,6 +4139,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('custom-site-opp'),
           addSuggestions: sandbox.stub().resolves({ id: 'custom-site-sugg' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -4125,6 +4172,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('enhanced-opp-456'),
           addSuggestions: sandbox.stub().resolves({ id: 'enhanced-sugg-456' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -4171,6 +4219,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('enhanced-empty-opp'),
           addSuggestions: sandbox.stub().resolves({ id: 'enhanced-empty-sugg' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -4200,6 +4249,7 @@ describe.skip('data-processing utility functions', () => {
               save: sandbox.stub(),
               getId: sandbox.stub().returns('in-depth-success-opp'),
               addSuggestions: sandbox.stub().resolves({ id: 'in-depth-success-sugg' }),
+              getSuggestions: sandbox.stub().resolves([]),
             });
           }
           // Second call (enhanced) fails
@@ -4236,6 +4286,7 @@ describe.skip('data-processing utility functions', () => {
               save: sandbox.stub(),
               getId: sandbox.stub().returns('in-depth-sugg-success'),
               addSuggestions: sandbox.stub().resolves({ id: 'in-depth-sugg-success' }),
+              getSuggestions: sandbox.stub().resolves([]),
             });
           }
           // Second call (enhanced) succeeds but suggestions fail
@@ -4244,6 +4295,7 @@ describe.skip('data-processing utility functions', () => {
             save: sandbox.stub(),
             getId: sandbox.stub().returns('enhanced-fail-sugg-opp'),
             addSuggestions: sandbox.stub().rejects(new Error('Enhanced suggestions failed')),
+            getSuggestions: sandbox.stub().resolves([]),
           });
         });
 
@@ -4272,6 +4324,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('enhanced-param-test'),
           addSuggestions: sandbox.stub().resolves({ id: 'enhanced-param-sugg' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -4318,6 +4371,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('enhanced-complex-opp'),
           addSuggestions: sandbox.stub().resolves({ id: 'enhanced-complex-sugg' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -4347,6 +4401,7 @@ describe.skip('data-processing utility functions', () => {
             save: sandbox.stub(),
             getId: sandbox.stub().returns('in-depth-success'),
             addSuggestions: sandbox.stub().resolves({ id: 'in-depth-success-sugg' }),
+            getSuggestions: sandbox.stub().resolves([]),
           })
           .onSecondCall()
           .rejects(new Error('Enhanced report database error'));
@@ -4378,6 +4433,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('fixed-vs-new-opp-789'),
           addSuggestions: sandbox.stub().resolves({ id: 'fixed-vs-new-sugg-789' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -4424,6 +4480,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('fixed-vs-new-empty-opp'),
           addSuggestions: sandbox.stub().resolves({ id: 'fixed-vs-new-empty-sugg' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -4453,6 +4510,7 @@ describe.skip('data-processing utility functions', () => {
               save: sandbox.stub(),
               getId: sandbox.stub().returns('in-depth-success-opp'),
               addSuggestions: sandbox.stub().resolves({ id: 'in-depth-success-sugg' }),
+              getSuggestions: sandbox.stub().resolves([]),
             });
           }
           if (callCount === 2) {
@@ -4462,6 +4520,7 @@ describe.skip('data-processing utility functions', () => {
               save: sandbox.stub(),
               getId: sandbox.stub().returns('enhanced-success-opp'),
               addSuggestions: sandbox.stub().resolves({ id: 'enhanced-success-sugg' }),
+              getSuggestions: sandbox.stub().resolves([]),
             });
           }
           // Third call (fixed vs new) fails
@@ -4498,6 +4557,7 @@ describe.skip('data-processing utility functions', () => {
               save: sandbox.stub(),
               getId: sandbox.stub().returns('in-depth-sugg-success'),
               addSuggestions: sandbox.stub().resolves({ id: 'in-depth-sugg-success' }),
+              getSuggestions: sandbox.stub().resolves([]),
             });
           }
           if (callCount === 2) {
@@ -4507,6 +4567,7 @@ describe.skip('data-processing utility functions', () => {
               save: sandbox.stub(),
               getId: sandbox.stub().returns('enhanced-sugg-success'),
               addSuggestions: sandbox.stub().resolves({ id: 'enhanced-sugg-success' }),
+              getSuggestions: sandbox.stub().resolves([]),
             });
           }
           // Third call (fixed vs new) succeeds but suggestions fail
@@ -4515,6 +4576,7 @@ describe.skip('data-processing utility functions', () => {
             save: sandbox.stub(),
             getId: sandbox.stub().returns('fixed-vs-new-fail-sugg-opp'),
             addSuggestions: sandbox.stub().rejects(new Error('Fixed vs new suggestions failed')),
+            getSuggestions: sandbox.stub().resolves([]),
           });
         });
 
@@ -4543,6 +4605,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('fixed-vs-new-param-test'),
           addSuggestions: sandbox.stub().resolves({ id: 'fixed-vs-new-param-sugg' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -4591,6 +4654,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('fixed-vs-new-complex-opp'),
           addSuggestions: sandbox.stub().resolves({ id: 'fixed-vs-new-complex-sugg' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -4636,6 +4700,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('improvement-scenario-opp'),
           addSuggestions: sandbox.stub().resolves({ id: 'improvement-scenario-sugg' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -4662,6 +4727,7 @@ describe.skip('data-processing utility functions', () => {
             save: sandbox.stub(),
             getId: sandbox.stub().returns('in-depth-success'),
             addSuggestions: sandbox.stub().resolves({ id: 'in-depth-success-sugg' }),
+            getSuggestions: sandbox.stub().resolves([]),
           })
           .onSecondCall()
           .resolves({
@@ -4669,6 +4735,7 @@ describe.skip('data-processing utility functions', () => {
             save: sandbox.stub(),
             getId: sandbox.stub().returns('enhanced-success'),
             addSuggestions: sandbox.stub().resolves({ id: 'enhanced-success-sugg' }),
+            getSuggestions: sandbox.stub().resolves([]),
           })
           .onThirdCall()
           .rejects(new Error('Fixed vs new database error'));
@@ -4700,6 +4767,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('base-report-opp-999'),
           addSuggestions: sandbox.stub().resolves({ id: 'base-report-sugg-999' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -4753,6 +4821,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('base-report-urls-opp'),
           addSuggestions: sandbox.stub().resolves({ id: 'base-report-urls-sugg' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -4797,6 +4866,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('base-report-empty-opp'),
           addSuggestions: sandbox.stub().resolves({ id: 'base-report-empty-sugg' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -4826,6 +4896,7 @@ describe.skip('data-processing utility functions', () => {
               save: sandbox.stub(),
               getId: sandbox.stub().returns(`success-opp-${callCount}`),
               addSuggestions: sandbox.stub().resolves({ id: `success-sugg-${callCount}` }),
+              getSuggestions: sandbox.stub().resolves([]),
             });
           }
           // Fourth call (base report) fails
@@ -4862,6 +4933,7 @@ describe.skip('data-processing utility functions', () => {
               save: sandbox.stub(),
               getId: sandbox.stub().returns(`sugg-success-opp-${callCount}`),
               addSuggestions: sandbox.stub().resolves({ id: `sugg-success-${callCount}` }),
+              getSuggestions: sandbox.stub().resolves([]),
             });
           }
           // Fourth call (base report) succeeds but suggestions fail
@@ -4870,6 +4942,7 @@ describe.skip('data-processing utility functions', () => {
             save: sandbox.stub(),
             getId: sandbox.stub().returns('base-fail-sugg-opp'),
             addSuggestions: sandbox.stub().rejects(new Error('Base report suggestions failed')),
+            getSuggestions: sandbox.stub().resolves([]),
           });
         });
 
@@ -4898,6 +4971,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('base-report-param-test'),
           addSuggestions: sandbox.stub().resolves({ id: 'base-report-param-sugg' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -4932,6 +5006,7 @@ describe.skip('data-processing utility functions', () => {
           save: sandbox.stub(),
           getId: sandbox.stub().returns('final-success-opp'),
           addSuggestions: sandbox.stub().resolves({ id: 'final-success-sugg' }),
+          getSuggestions: sandbox.stub().resolves([]),
         };
         mockContext.dataAccess.Opportunity.create.resolves(mockOpportunity);
 
@@ -4958,12 +5033,14 @@ describe.skip('data-processing utility functions', () => {
             save: sandbox.stub(),
             getId: sandbox.stub().returns('success-1'),
             addSuggestions: sandbox.stub().resolves({ id: 'success-sugg-1' }),
+            getSuggestions: sandbox.stub().resolves([]),
           })
           .onCall(1).resolves({
             setStatus: sandbox.stub(),
             save: sandbox.stub(),
             getId: sandbox.stub().returns('success-2'),
             addSuggestions: sandbox.stub().resolves({ id: 'success-sugg-2' }),
+            getSuggestions: sandbox.stub().resolves([]),
           })
           .onCall(2)
           .resolves({
@@ -4971,6 +5048,7 @@ describe.skip('data-processing utility functions', () => {
             save: sandbox.stub(),
             getId: sandbox.stub().returns('success-3'),
             addSuggestions: sandbox.stub().resolves({ id: 'success-sugg-3' }),
+            getSuggestions: sandbox.stub().resolves([]),
           })
           .onCall(3)
           .rejects(new Error('Base report database error'));
@@ -5003,6 +5081,7 @@ describe.skip('data-processing utility functions', () => {
             save: sandbox.stub(),
             getId: sandbox.stub().returns(`opp-${creationOrder.length}`),
             addSuggestions: sandbox.stub().resolves({ id: `sugg-${creationOrder.length}` }),
+            getSuggestions: sandbox.stub().resolves([]),
           });
         });
 
@@ -5072,6 +5151,251 @@ describe.skip('data-processing utility functions', () => {
     });
   });
 
+  describe('generateReportOpportunity - device-specific merging', () => {
+    let generateReportOpportunityMocked;
+    let findExistingDesktopOpportunityMocked;
+    let findExistingMobileOpportunityMocked;
+    let mockDataAccess;
+
+    beforeEach(async () => {
+      mockDataAccess = {
+        Opportunity: {
+          create: sandbox.stub(),
+          allBySiteId: sandbox.stub().resolves([]),
+        },
+      };
+
+      const dataProcessingModule = await esmock('../../../src/accessibility/utils/data-processing.js');
+      generateReportOpportunityMocked = dataProcessingModule.generateReportOpportunity;
+      findExistingDesktopOpportunityMocked = dataProcessingModule.findExistingDesktopOpportunity;
+      findExistingMobileOpportunityMocked = dataProcessingModule.findExistingMobileOpportunity;
+    });
+
+    it('should merge mobile audit with existing desktop opportunity', async () => {
+      // Arrange
+      const mockGenMdFn = sandbox.stub().returns('# Mobile Report\n\nMobile content.');
+      const mockCreateOpportunityFn = sandbox.stub().returns({ type: 'accessibility', title: 'Test' });
+      
+      const mockExistingDesktopOpportunity = {
+        getId: sandbox.stub().returns('desktop-opp-123'),
+        getSuggestions: sandbox.stub().resolves([]),
+        addSuggestions: sandbox.stub().resolves({ id: 'merged-sugg' }),
+      };
+
+      const mockExistingDesktopOpportunityForFind = {
+        getTitle: sandbox.stub().returns('Accessibility report - Desktop - Week 20 - 2024'),
+        getStatus: sandbox.stub().returns('NEW'),
+        getId: sandbox.stub().returns('desktop-opp-123'),
+        getSuggestions: sandbox.stub().resolves([]),
+        addSuggestions: sandbox.stub().resolves({ id: 'merged-sugg' }),
+      };
+
+      mockDataAccess.Opportunity.allBySiteId.resolves([mockExistingDesktopOpportunityForFind]);
+
+      const reportData = {
+        mdData: { violations: { total: 3 } },
+        linkData: { baseUrl: 'https://example.com' },
+        opptyData: { week: 20, year: 2024 },
+        auditData: { siteId: 'test-site-mobile', auditId: 'audit-mobile' },
+        context: {
+          log: mockLog,
+          dataAccess: mockDataAccess,
+        },
+      };
+
+      // Act - mobile device type
+      const result = await generateReportOpportunityMocked(
+        reportData,
+        mockGenMdFn,
+        mockCreateOpportunityFn,
+        'Mobile Report',
+        false,
+        'mobile', // deviceType
+        '', // reportType
+      );
+
+      // Assert
+      expect(result).to.be.a('string');
+      expect(mockDataAccess.Opportunity.allBySiteId).to.have.been.called;
+      expect(mockLog.info).to.have.been.calledWith(
+        sinon.match(/Mobile audit will update existing desktop.*opportunity/)
+      );
+    });
+
+    it('should create new mobile-only opportunity when no desktop exists', async () => {
+      // Arrange
+      const mockGenMdFn = sandbox.stub().returns('# Mobile Only Report\n');
+      const mockCreateOpportunityFn = sandbox.stub().returns({ type: 'accessibility', title: 'Mobile Test' });
+      
+      const mockNewOpportunity = {
+        getId: sandbox.stub().returns('new-mobile-opp'),
+        getSuggestions: sandbox.stub().resolves([]),
+        addSuggestions: sandbox.stub().resolves({ id: 'new-mobile-sugg' }),
+      };
+
+      mockDataAccess.Opportunity.allBySiteId.resolves([]); // No existing opportunities
+      mockDataAccess.Opportunity.create.resolves(mockNewOpportunity);
+
+      const reportData = {
+        mdData: { violations: { total: 2 } },
+        linkData: { baseUrl: 'https://example.com' },
+        opptyData: { week: 21, year: 2024 },
+        auditData: { siteId: 'test-site-mobile-only', auditId: 'audit-mobile-only' },
+        context: {
+          log: mockLog,
+          dataAccess: mockDataAccess,
+        },
+      };
+
+      // Act - mobile device type, no existing desktop opportunity
+      const result = await generateReportOpportunityMocked(
+        reportData,
+        mockGenMdFn,
+        mockCreateOpportunityFn,
+        'Mobile Only Report',
+        false,
+        'mobile',
+        '',
+      );
+
+      // Assert
+      expect(result).to.be.a('string');
+      expect(mockDataAccess.Opportunity.create).to.have.been.called;
+      expect(mockLog.info).to.have.been.calledWith(
+        sinon.match(/Created new mobile-only.*opportunity/)
+      );
+    });
+
+    it('should merge desktop audit with existing mobile opportunity', async () => {
+      // Arrange
+      const mockGenMdFn = sandbox.stub().returns('# Desktop Report\n\nDesktop content.');
+      const mockCreateOpportunityFn = sandbox.stub().returns({ type: 'accessibility', title: 'Desktop Test' });
+      
+      const mockExistingMobileOpportunityForFind = {
+        getTitle: sandbox.stub().returns('Accessibility report - Mobile - Week 22 - 2024'),
+        getStatus: sandbox.stub().returns('NEW'),
+        getId: sandbox.stub().returns('mobile-opp-456'),
+        getSuggestions: sandbox.stub().resolves([]),
+        addSuggestions: sandbox.stub().resolves({ id: 'merged-desktop-sugg' }),
+      };
+
+      mockDataAccess.Opportunity.allBySiteId.resolves([mockExistingMobileOpportunityForFind]);
+
+      const reportData = {
+        mdData: { violations: { total: 4 } },
+        linkData: { baseUrl: 'https://example.com' },
+        opptyData: { week: 22, year: 2024 },
+        auditData: { siteId: 'test-site-desktop', auditId: 'audit-desktop' },
+        context: {
+          log: mockLog,
+          dataAccess: mockDataAccess,
+        },
+      };
+
+      // Act - desktop device type
+      const result = await generateReportOpportunityMocked(
+        reportData,
+        mockGenMdFn,
+        mockCreateOpportunityFn,
+        'Desktop Report',
+        false,
+        'desktop', // deviceType
+        '', // reportType
+      );
+
+      // Assert
+      expect(result).to.be.a('string');
+      expect(mockDataAccess.Opportunity.allBySiteId).to.have.been.called;
+      expect(mockLog.info).to.have.been.calledWith(
+        sinon.match(/Desktop audit will update existing mobile.*opportunity/)
+      );
+    });
+
+    it('should handle base report type (empty string)', async () => {
+      // Arrange
+      const mockGenMdFn = sandbox.stub().returns('# Base Report\n');
+      const mockCreateOpportunityFn = sandbox.stub().returns({ type: 'accessibility', title: 'Base' });
+      
+      const mockOpportunity = {
+        getId: sandbox.stub().returns('base-opp'),
+        getSuggestions: sandbox.stub().resolves([]),
+        addSuggestions: sandbox.stub().resolves({ id: 'base-sugg' }),
+      };
+
+      mockDataAccess.Opportunity.allBySiteId.resolves([]);
+      mockDataAccess.Opportunity.create.resolves(mockOpportunity);
+
+      const reportData = {
+        mdData: { violations: { total: 1 } },
+        linkData: { baseUrl: 'https://example.com' },
+        opptyData: { week: 23, year: 2024 },
+        auditData: { siteId: 'test-base', auditId: 'audit-base' },
+        context: {
+          log: mockLog,
+          dataAccess: mockDataAccess,
+        },
+      };
+
+      // Act - with empty reportType (base report)
+      const result = await generateReportOpportunityMocked(
+        reportData,
+        mockGenMdFn,
+        mockCreateOpportunityFn,
+        'Base Report',
+        false,
+        'desktop',
+        '', // empty string for base report
+      );
+
+      // Assert
+      expect(result).to.be.a('string');
+      expect(mockLog.info).to.have.been.calledWith(
+        sinon.match(/base.*opportunity/)
+      );
+    });
+
+    it('should handle error from createOrUpdateDeviceSpecificSuggestion', async () => {
+      // Arrange
+      const mockGenMdFn = sandbox.stub().returns('# Error Report\n');
+      const mockCreateOpportunityFn = sandbox.stub().returns({ type: 'accessibility', title: 'Error Test' });
+      
+      const mockOpportunity = {
+        getId: sandbox.stub().returns('error-opp'),
+        getSuggestions: sandbox.stub().rejects(new Error('Suggestion creation failed')),
+        addSuggestions: sandbox.stub().rejects(new Error('Suggestion creation failed')),
+      };
+
+      mockDataAccess.Opportunity.allBySiteId.resolves([]);
+      mockDataAccess.Opportunity.create.resolves(mockOpportunity);
+
+      const reportData = {
+        mdData: { violations: { total: 1 } },
+        linkData: { baseUrl: 'https://example.com' },
+        opptyData: { week: 24, year: 2024 },
+        auditData: { siteId: 'test-error', auditId: 'audit-error' },
+        context: {
+          log: mockLog,
+          dataAccess: mockDataAccess,
+        },
+      };
+
+      // Act & Assert
+      await expect(
+        generateReportOpportunityMocked(
+          reportData,
+          mockGenMdFn,
+          mockCreateOpportunityFn,
+          'Error Report',
+          false,
+          'desktop',
+          '',
+        )
+      ).to.be.rejectedWith('Suggestion creation failed');
+
+      expect(mockLog.error).to.have.been.called;
+    });
+  });
+
   describe('sendRunImportMessage', () => {
     it('should create data object with a11y-metrics-aggregator import type', async () => {
       // Mock SQS message sending to capture the message structure
@@ -5110,4 +5434,386 @@ describe.skip('data-processing utility functions', () => {
       });
     });
   });
+
+  describe('createOrUpdateDeviceSpecificSuggestion', () => {
+    let createOrUpdateDeviceSpecificSuggestionMocked;
+    let mockOpportunity;
+    let mockExistingSuggestion;
+
+    beforeEach(async () => {
+      const dataProcessingModule = await esmock('../../../src/accessibility/utils/data-processing.js');
+      createOrUpdateDeviceSpecificSuggestionMocked = dataProcessingModule.createOrUpdateDeviceSpecificSuggestion;
+
+      mockExistingSuggestion = {
+        getType: sandbox.stub().returns('CODE_CHANGE'),
+        getData: sandbox.stub().returns({
+          suggestionValue: {
+            'accessibility-desktop': '# Desktop content\n',
+          },
+        }),
+        setData: sandbox.stub(),
+        save: sandbox.stub().resolves(),
+      };
+
+      mockOpportunity = {
+        getSuggestions: sandbox.stub().resolves([mockExistingSuggestion]),
+        addSuggestions: sandbox.stub().resolves({ id: 'new-sugg' }),
+      };
+    });
+
+    it('should update existing suggestion with new device content', async () => {
+      // Arrange
+      const reportMarkdown = '# Mobile content\n';
+      const deviceType = 'mobile';
+      const auditData = { siteId: 'site-123', auditId: 'audit-123' };
+
+      // Act
+      const result = await createOrUpdateDeviceSpecificSuggestionMocked(
+        mockOpportunity,
+        reportMarkdown,
+        deviceType,
+        auditData,
+        mockLog,
+      );
+
+      // Assert
+      expect(mockOpportunity.getSuggestions).to.have.been.called;
+      expect(mockExistingSuggestion.setData).to.have.been.called;
+      expect(mockExistingSuggestion.save).to.have.been.called;
+      expect(result.suggestion).to.equal(mockExistingSuggestion);
+    });
+
+    it('should create new suggestion when no existing CODE_CHANGE suggestion found', async () => {
+      // Arrange
+      mockOpportunity.getSuggestions.resolves([]);
+      const reportMarkdown = '# Desktop content\n';
+      const deviceType = 'desktop';
+      const auditData = { siteId: 'site-456', auditId: 'audit-456' };
+
+      // Act
+      const result = await createOrUpdateDeviceSpecificSuggestionMocked(
+        mockOpportunity,
+        reportMarkdown,
+        deviceType,
+        auditData,
+        mockLog,
+      );
+
+      // Assert
+      expect(mockOpportunity.getSuggestions).to.have.been.called;
+      expect(mockOpportunity.addSuggestions).to.have.been.called;
+      expect(mockExistingSuggestion.setData).to.not.have.been.called;
+    });
+
+    it('should handle null getData() result (line 532)', async () => {
+      // Arrange - test the ?? {} branch
+      mockExistingSuggestion.getData.returns(null);
+      const reportMarkdown = '# Content\n';
+      const deviceType = 'mobile';
+      const auditData = { siteId: 'site-789', auditId: 'audit-789' };
+
+      // Act
+      const result = await createOrUpdateDeviceSpecificSuggestionMocked(
+        mockOpportunity,
+        reportMarkdown,
+        deviceType,
+        auditData,
+        mockLog,
+      );
+
+      // Assert
+      expect(mockExistingSuggestion.setData).to.have.been.called;
+      expect(result.suggestion).to.equal(mockExistingSuggestion);
+    });
+
+    it('should handle missing suggestionValue in currentData (line 533)', async () => {
+      // Arrange - test the ?? {} branch for suggestionValue
+      mockExistingSuggestion.getData.returns({ someOtherField: 'value' });
+      const reportMarkdown = '# Content\n';
+      const deviceType = 'desktop';
+      const auditData = { siteId: 'site-abc', auditId: 'audit-abc' };
+
+      // Act
+      const result = await createOrUpdateDeviceSpecificSuggestionMocked(
+        mockOpportunity,
+        reportMarkdown,
+        deviceType,
+        auditData,
+        mockLog,
+      );
+
+      // Assert
+      expect(mockExistingSuggestion.setData).to.have.been.called;
+      expect(result.suggestion).to.equal(mockExistingSuggestion);
+    });
+
+    it('should handle empty reportMarkdown (line 527, 566)', async () => {
+      // Arrange - test the || 0 branch when reportMarkdown is empty
+      mockOpportunity.getSuggestions.resolves([]);
+      const reportMarkdown = ''; // Empty string
+      const deviceType = 'mobile';
+      const auditData = { siteId: 'site-empty', auditId: 'audit-empty' };
+
+      // Act
+      const result = await createOrUpdateDeviceSpecificSuggestionMocked(
+        mockOpportunity,
+        reportMarkdown,
+        deviceType,
+        auditData,
+        mockLog,
+      );
+
+      // Assert
+      expect(mockOpportunity.addSuggestions).to.have.been.called;
+      expect(mockLog.info).to.have.been.calledWith(
+        sinon.match(/reportMarkdown length: 0/)
+      );
+    });
+
+    it('should handle null reportMarkdown (line 527)', async () => {
+      // Arrange - test the ?. branch when reportMarkdown is null
+      mockOpportunity.getSuggestions.resolves([]);
+      const reportMarkdown = null;
+      const deviceType = 'desktop';
+      const auditData = { siteId: 'site-null', auditId: 'audit-null' };
+
+      // Act
+      const result = await createOrUpdateDeviceSpecificSuggestionMocked(
+        mockOpportunity,
+        reportMarkdown,
+        deviceType,
+        auditData,
+        mockLog,
+      );
+
+      // Assert
+      expect(mockLog.info).to.have.been.calledWith(
+        sinon.match(/reportMarkdown length: 0/)
+      );
+    });
+
+    it('should handle missing accessibility-desktop in suggestionValue (line 536, 550)', async () => {
+      // Arrange - test the || 0 branch when accessibility-desktop is undefined
+      mockExistingSuggestion.getData.returns({
+        suggestionValue: {
+          'accessibility-mobile': '# Mobile content',
+        },
+      });
+      const reportMarkdown = '# Desktop content\n';
+      const deviceType = 'desktop';
+      const auditData = { siteId: 'site-desktop-missing', auditId: 'audit-desktop-missing' };
+
+      // Act
+      const result = await createOrUpdateDeviceSpecificSuggestionMocked(
+        mockOpportunity,
+        reportMarkdown,
+        deviceType,
+        auditData,
+        mockLog,
+      );
+
+      // Assert
+      expect(mockLog.info).to.have.been.calledWith(
+        sinon.match(/Current accessibility-desktop length: 0/)
+      );
+    });
+
+    it('should handle missing accessibility-mobile in suggestionValue (line 537, 551)', async () => {
+      // Arrange - test the || 0 branch when accessibility-mobile is undefined
+      mockExistingSuggestion.getData.returns({
+        suggestionValue: {
+          'accessibility-desktop': '# Desktop content',
+        },
+      });
+      const reportMarkdown = '# Mobile content\n';
+      const deviceType = 'mobile';
+      const auditData = { siteId: 'site-mobile-missing', auditId: 'audit-mobile-missing' };
+
+      // Act
+      const result = await createOrUpdateDeviceSpecificSuggestionMocked(
+        mockOpportunity,
+        reportMarkdown,
+        deviceType,
+        auditData,
+        mockLog,
+      );
+
+      // Assert
+      expect(mockLog.info).to.have.been.calledWith(
+        sinon.match(/Current accessibility-mobile length: 0/)
+      );
+    });
+  });
+
+  describe('findExistingDesktopOpportunity', () => {
+    let findExistingDesktopOpportunityMocked;
+    let mockDataAccess;
+
+    beforeEach(async () => {
+      const dataProcessingModule = await esmock('../../../src/accessibility/utils/data-processing.js');
+      findExistingDesktopOpportunityMocked = dataProcessingModule.findExistingDesktopOpportunity;
+
+      mockDataAccess = {
+        Opportunity: {
+          allBySiteId: sandbox.stub(),
+        },
+      };
+    });
+
+    it('should find existing desktop opportunity with in-depth report type', async () => {
+      // Arrange
+      const mockOpportunity = {
+        getTitle: sandbox.stub().returns('Accessibility report - Desktop - Week 20 - 2024 - in-depth'),
+        getStatus: sandbox.stub().returns('NEW'),
+        getId: sandbox.stub().returns('opp-123'),
+      };
+      mockDataAccess.Opportunity.allBySiteId.resolves([mockOpportunity]);
+
+      // Act
+      const result = await findExistingDesktopOpportunityMocked(
+        'site-123',
+        20,
+        2024,
+        mockDataAccess,
+        mockLog,
+        'in-depth',
+      );
+
+      // Assert
+      expect(result).to.equal(mockOpportunity);
+    });
+
+    it('should find existing desktop opportunity with fixed report type', async () => {
+      // Arrange
+      const mockOpportunity = {
+        getTitle: sandbox.stub().returns('Accessibility report Fixed vs New Issues - Desktop - Week 20 - 2024'),
+        getStatus: sandbox.stub().returns('NEW'),
+        getId: sandbox.stub().returns('opp-456'),
+      };
+      mockDataAccess.Opportunity.allBySiteId.resolves([mockOpportunity]);
+
+      // Act
+      const result = await findExistingDesktopOpportunityMocked(
+        'site-456',
+        20,
+        2024,
+        mockDataAccess,
+        mockLog,
+        'fixed',
+      );
+
+      // Assert
+      expect(result).to.equal(mockOpportunity);
+    });
+
+    it('should find existing desktop opportunity with enhanced report type', async () => {
+      // Arrange
+      const mockOpportunity = {
+        getTitle: sandbox.stub().returns('Enhancing accessibility for the top 10 most-visited pages - Desktop - Week 20 - 2024'),
+        getStatus: sandbox.stub().returns('NEW'),
+        getId: sandbox.stub().returns('opp-789'),
+      };
+      mockDataAccess.Opportunity.allBySiteId.resolves([mockOpportunity]);
+
+      // Act
+      const result = await findExistingDesktopOpportunityMocked(
+        'site-789',
+        20,
+        2024,
+        mockDataAccess,
+        mockLog,
+        'enhanced',
+      );
+
+      // Assert
+      expect(result).to.equal(mockOpportunity);
+    });
+
+    it('should return null when no matching opportunity found', async () => {
+      // Arrange
+      const mockOpportunity = {
+        getTitle: sandbox.stub().returns('Different Title'),
+        getStatus: sandbox.stub().returns('NEW'),
+      };
+      mockDataAccess.Opportunity.allBySiteId.resolves([mockOpportunity]);
+
+      // Act
+      const result = await findExistingDesktopOpportunityMocked(
+        'site-123',
+        20,
+        2024,
+        mockDataAccess,
+        mockLog,
+        'in-depth',
+      );
+
+      // Assert
+      expect(result).to.be.null;
+    });
+
+    it('should handle error gracefully and return null', async () => {
+      // Arrange
+      mockDataAccess.Opportunity.allBySiteId.rejects(new Error('DB error'));
+
+      // Act
+      const result = await findExistingDesktopOpportunityMocked(
+        'site-123',
+        20,
+        2024,
+        mockDataAccess,
+        mockLog,
+      );
+
+      // Assert
+      expect(result).to.be.null;
+      expect(mockLog.error.called).to.be.true;
+    });
+
+    it('should find opportunity with IGNORED status (line 636 - OR condition)', async () => {
+      // Arrange - test the || branch where status is IGNORED
+      const mockOpportunity = {
+        getTitle: sandbox.stub().returns('Accessibility report - Desktop - Week 25 - 2024'),
+        getStatus: sandbox.stub().returns('IGNORED'), // Test IGNORED status
+        getId: sandbox.stub().returns('ignored-opp-123'),
+      };
+      mockDataAccess.Opportunity.allBySiteId.resolves([mockOpportunity]);
+
+      // Act
+      const result = await findExistingDesktopOpportunityMocked(
+        'site-ignored',
+        25,
+        2024,
+        mockDataAccess,
+        mockLog,
+        '',
+      );
+
+      // Assert
+      expect(result).to.equal(mockOpportunity);
+      expect(mockOpportunity.getStatus).to.have.been.called;
+    });
+
+    it('should not find opportunity with RESOLVED status (line 636)', async () => {
+      // Arrange - test that non-NEW and non-IGNORED statuses are filtered out
+      const mockOpportunity = {
+        getTitle: sandbox.stub().returns('Accessibility report - Desktop - Week 26 - 2024'),
+        getStatus: sandbox.stub().returns('RESOLVED'), // Should not match
+        getId: sandbox.stub().returns('resolved-opp-456'),
+      };
+      mockDataAccess.Opportunity.allBySiteId.resolves([mockOpportunity]);
+
+      // Act
+      const result = await findExistingDesktopOpportunityMocked(
+        'site-resolved',
+        26,
+        2024,
+        mockDataAccess,
+        mockLog,
+        '',
+      );
+
+      // Assert
+      expect(result).to.be.null;
+    });
+  });
 });
diff --git a/test/audits/accessibility/generate-individual-opportunities.test.js b/test/audits/accessibility/generate-individual-opportunities.test.js
index aa1213b7f..1561e842a 100644
--- a/test/audits/accessibility/generate-individual-opportunities.test.js
+++ b/test/audits/accessibility/generate-individual-opportunities.test.js
@@ -1167,6 +1167,35 @@ describe('aggregateAccessibilityIssues', () => {
     expect(result.data).to.have.lengthOf(1);
     expect(result.data[0]['a11y-assistive'][0].url).to.equal('https://example.com:port');
   });
+
+  it('should extract source parameter from URL (covers lines 37-39)', () => {
+    const input = {
+      'https://example.com?source=test-source': {
+        violations: {
+          critical: {
+            items: {
+              'aria-hidden-focus': {
+                description: 'Test issue',
+                successCriteriaTags: ['wcag412'],
+                count: 1,
+                htmlWithIssues: ['<div aria-hidden="true"><button>Click</button></div>'],
+                target: ['div[aria-hidden] button'],
+              },
+            },
+          },
+        },
+      },
+    };
+
+    const result = aggregateAccessibilityIssues(input);
+    expect(result.data).to.have.lengthOf(1);
+    expect(result.data[0]['a11y-assistive']).to.have.lengthOf(1);
+    // URL should be cleaned
+    expect(result.data[0]['a11y-assistive'][0].url).to.equal('https://example.com');
+    // Source should be extracted
+    expect(result.data[0]['a11y-assistive'][0].source).to.equal('test-source');
+    expect(result.data[0]['a11y-assistive'][0].issues).to.have.lengthOf(1);
+  });
 });
 
 describe('createIndividualOpportunity', () => {
@@ -1743,6 +1772,46 @@ describe('createIndividualOpportunitySuggestions', () => {
       },
     });
   });
+
+  it('should include source in buildKey when data has source property (covers lines 410-411)', async () => {
+    const aggregatedDataWithSource = {
+      data: [
+        {
+          url: 'https://example.com/page1',
+          type: 'url',
+          source: 'test-source',
+          issues: [
+            {
+              type: 'color-contrast',
+              occurrences: 5,
+              htmlWithIssues: [
+                {
+                  target_selector: 'div.test',
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    };
+
+    await createIndividualOpportunitySuggestions(
+      mockOpportunity,
+      aggregatedDataWithSource,
+      mockContext,
+      mockLog,
+    );
+
+    expect(mockSyncSuggestions).to.have.been.calledOnce;
+    const { buildKey } = mockSyncSuggestions.firstCall.args[0];
+
+    // Test the buildKey function with source
+    const key = buildKey(aggregatedDataWithSource.data[0]);
+
+    // Key should include the source parameter appended
+    expect(key).to.include('|test-source');
+    expect(key).to.equal('https://example.com/page1|color-contrast|div.test|test-source');
+  });
 });
 
 describe('calculateAccessibilityMetrics', () => {
diff --git a/test/audits/accessibility/report-oppty.test.js b/test/audits/accessibility/report-oppty.test.js
index 85ef06aea..7696c3ebc 100644
--- a/test/audits/accessibility/report-oppty.test.js
+++ b/test/audits/accessibility/report-oppty.test.js
@@ -20,11 +20,12 @@ import {
   createFixedVsNewReportOpportunity,
   createBaseReportOpportunity,
   createReportOpportunitySuggestionInstance,
+  createOrUpdateDeviceSpecificSuggestion,
   createAccessibilityAssistiveOpportunity,
   createAccessibilityColorContrastOpportunity,
 } from '../../../src/accessibility/utils/report-oppty.js';
 
-describe.skip('Accessibility Report Opportunity Utils', () => {
+describe('Accessibility Report Opportunity Utils', () => {
   describe('createInDepthReportOpportunity', () => {
     it('should create correct in-depth report opportunity structure', () => {
       const week = 42;
@@ -37,7 +38,7 @@ describe.skip('Accessibility Report Opportunity Utils', () => {
         origin: 'AUTOMATION',
         type: 'generic-opportunity',
         title: 'Accessibility report - Desktop - Week 42 - 2024 - in-depth',
-        description: 'This report provides an in-depth overview of various accessibility issues identified across different web pages. It categorizes issues based on their severity and impact, offering detailed descriptions and recommended fixes. The report covers critical aspects such as ARIA attributes, keyboard navigation, and screen reader compatibility to ensure a more inclusive and accessible web experience for all users.',
+        description: 'This report provides an in-depth overview of various accessibility issues identified across different web pages on Desktop devices. It categorizes issues based on their severity and impact, offering detailed descriptions and recommended fixes. The report covers critical aspects such as ARIA attributes, keyboard navigation, and screen reader compatibility to ensure a more inclusive and accessible web experience for all users.',
         tags: ['a11y'],
         status: 'IGNORED',
       });
@@ -65,7 +66,7 @@ describe.skip('Accessibility Report Opportunity Utils', () => {
         origin: 'AUTOMATION',
         type: 'generic-opportunity',
         title: 'Enhancing accessibility for the top 10 most-visited pages - Desktop - Week 25 - 2024',
-        description: 'Here are some optimization suggestions that could help solve the accessibility issues found on the top 10 most-visited pages.',
+        description: 'Here are some optimization suggestions that could help solve the accessibility issues found on the top 10 most-visited pages on Desktop devices.',
         tags: ['a11y'],
         status: 'IGNORED',
       });
@@ -84,7 +85,7 @@ describe.skip('Accessibility Report Opportunity Utils', () => {
         origin: 'AUTOMATION',
         type: 'generic-opportunity',
         title: 'Accessibility report Fixed vs New Issues - Desktop - Week 30 - 2024',
-        description: 'This report provides a comprehensive analysis of accessibility issues, highlighting both resolved and newly identified problems. It aims to track progress in improving accessibility and identify areas requiring further attention.',
+        description: 'This report provides a comprehensive analysis of accessibility issues on Desktop devices, highlighting both resolved and newly identified problems. It aims to track progress in improving accessibility and identify areas requiring further attention.',
         tags: ['a11y'],
         status: 'IGNORED',
       });
@@ -432,4 +433,396 @@ describe.skip('Accessibility Report Opportunity Utils', () => {
       expect(() => createAccessibilityColorContrastOpportunity()).to.not.throw();
     });
   });
+
+  describe('createOrUpdateDeviceSpecificSuggestion', () => {
+    let mockLog;
+
+    beforeEach(() => {
+      mockLog = {
+        info: () => {},
+      };
+    });
+
+    it('should handle string suggestionValue for desktop device', () => {
+      const suggestionValue = '# Desktop Report\nSome content';
+      const deviceType = 'desktop';
+      const markdownContent = '# Updated Desktop Report\nNew content';
+
+      const result = createOrUpdateDeviceSpecificSuggestion(
+        suggestionValue,
+        deviceType,
+        markdownContent,
+        mockLog,
+      );
+
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(1);
+      expect(result[0]).to.have.property('type', 'CODE_CHANGE');
+      expect(result[0].data).to.have.property('suggestionValue');
+      expect(result[0].data.suggestionValue).to.deep.equal({
+        'accessibility-desktop': suggestionValue,
+      });
+    });
+
+    it('should handle string suggestionValue for mobile device', () => {
+      const suggestionValue = '# Mobile Report\nSome content';
+      const deviceType = 'mobile';
+      const markdownContent = '# Updated Mobile Report\nNew content';
+
+      const result = createOrUpdateDeviceSpecificSuggestion(
+        suggestionValue,
+        deviceType,
+        markdownContent,
+        mockLog,
+      );
+
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(1);
+      expect(result[0]).to.have.property('type', 'CODE_CHANGE');
+      expect(result[0].data).to.have.property('suggestionValue');
+      expect(result[0].data.suggestionValue).to.deep.equal({
+        'accessibility-mobile': suggestionValue,
+      });
+    });
+
+    it('should handle object suggestionValue and update with new device content', () => {
+      const suggestionValue = {
+        'accessibility-desktop': '# Desktop Report\nExisting desktop content',
+      };
+      const deviceType = 'mobile';
+      const markdownContent = '# Mobile Report\nNew mobile content';
+
+      const result = createOrUpdateDeviceSpecificSuggestion(
+        suggestionValue,
+        deviceType,
+        markdownContent,
+        mockLog,
+      );
+
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(1);
+      expect(result[0].data.suggestionValue).to.deep.equal({
+        'accessibility-desktop': '# Desktop Report\nExisting desktop content',
+        'accessibility-mobile': '# Mobile Report\nNew mobile content',
+      });
+    });
+
+    it('should handle object suggestionValue and update existing device content', () => {
+      const suggestionValue = {
+        'accessibility-desktop': '# Desktop Report\nOld desktop content',
+        'accessibility-mobile': '# Mobile Report\nOld mobile content',
+      };
+      const deviceType = 'desktop';
+      const markdownContent = '# Desktop Report\nUpdated desktop content';
+
+      const result = createOrUpdateDeviceSpecificSuggestion(
+        suggestionValue,
+        deviceType,
+        markdownContent,
+        mockLog,
+      );
+
+      expect(result).to.be.an('array');
+      expect(result[0].data.suggestionValue).to.deep.equal({
+        'accessibility-desktop': '# Desktop Report\nUpdated desktop content',
+        'accessibility-mobile': '# Mobile Report\nOld mobile content',
+      });
+    });
+
+    it('should handle null suggestionValue and create new object', () => {
+      const suggestionValue = null;
+      const deviceType = 'desktop';
+      const markdownContent = '# Desktop Report\nNew content';
+
+      const result = createOrUpdateDeviceSpecificSuggestion(
+        suggestionValue,
+        deviceType,
+        markdownContent,
+        mockLog,
+      );
+
+      expect(result).to.be.an('array');
+      expect(result[0].data.suggestionValue).to.deep.equal({
+        'accessibility-desktop': '# Desktop Report\nNew content',
+      });
+    });
+
+    it('should handle undefined suggestionValue and create new object', () => {
+      const suggestionValue = undefined;
+      const deviceType = 'mobile';
+      const markdownContent = '# Mobile Report\nNew content';
+
+      const result = createOrUpdateDeviceSpecificSuggestion(
+        suggestionValue,
+        deviceType,
+        markdownContent,
+        mockLog,
+      );
+
+      expect(result).to.be.an('array');
+      expect(result[0].data.suggestionValue).to.deep.equal({
+        'accessibility-mobile': '# Mobile Report\nNew content',
+      });
+    });
+
+    it('should use console as default logger if not provided', () => {
+      const suggestionValue = '# Test';
+      const deviceType = 'desktop';
+      const markdownContent = '# Test';
+
+      // Should not throw when logger is not provided
+      expect(() => createOrUpdateDeviceSpecificSuggestion(
+        suggestionValue,
+        deviceType,
+        markdownContent,
+      )).to.not.throw();
+    });
+
+    it('should preserve existing device content when adding new device', () => {
+      const suggestionValue = {
+        'accessibility-desktop': '# Desktop Content\nImportant desktop info',
+      };
+      const deviceType = 'mobile';
+      const markdownContent = '# Mobile Content\nNew mobile info';
+
+      const result = createOrUpdateDeviceSpecificSuggestion(
+        suggestionValue,
+        deviceType,
+        markdownContent,
+        mockLog,
+      );
+
+      expect(result[0].data.suggestionValue['accessibility-desktop']).to.equal('# Desktop Content\nImportant desktop info');
+      expect(result[0].data.suggestionValue['accessibility-mobile']).to.equal('# Mobile Content\nNew mobile info');
+    });
+
+    it('should handle empty markdownContent', () => {
+      const suggestionValue = {
+        'accessibility-desktop': '# Desktop Report',
+      };
+      const deviceType = 'mobile';
+      const markdownContent = '';
+
+      const result = createOrUpdateDeviceSpecificSuggestion(
+        suggestionValue,
+        deviceType,
+        markdownContent,
+        mockLog,
+      );
+
+      expect(result).to.be.an('array');
+      expect(result[0].data.suggestionValue['accessibility-mobile']).to.equal('');
+    });
+
+    it('should handle existing content with both desktop and mobile having content', () => {
+      const suggestionValue = {
+        'accessibility-desktop': '# Desktop Report\nWith substantial content that is longer',
+        'accessibility-mobile': '# Mobile Report\nWith substantial mobile content',
+      };
+      const deviceType = 'desktop';
+      const markdownContent = '# Updated Desktop Report\nWith even more substantial content';
+
+      const result = createOrUpdateDeviceSpecificSuggestion(
+        suggestionValue,
+        deviceType,
+        markdownContent,
+        mockLog,
+      );
+
+      expect(result).to.be.an('array');
+      expect(result[0].data.suggestionValue['accessibility-desktop']).to.have.length.greaterThan(0);
+      expect(result[0].data.suggestionValue['accessibility-mobile']).to.have.length.greaterThan(0);
+    });
+
+    it('should handle long markdownContent properly', () => {
+      const longContent = '# Very Long Report\n' + 'Content line\n'.repeat(100);
+      const suggestionValue = {
+        'accessibility-desktop': longContent,
+      };
+      const deviceType = 'mobile';
+      const markdownContent = longContent;
+
+      const result = createOrUpdateDeviceSpecificSuggestion(
+        suggestionValue,
+        deviceType,
+        markdownContent,
+        mockLog,
+      );
+
+      expect(result[0].data.suggestionValue['accessibility-desktop']).to.equal(longContent);
+      expect(result[0].data.suggestionValue['accessibility-mobile']).to.equal(longContent);
+      expect(result[0].data.suggestionValue['accessibility-desktop']).to.have.length.greaterThan(1000);
+    });
+
+    it('should handle object with undefined device content', () => {
+      const suggestionValue = {
+        'accessibility-desktop': '# Desktop Report',
+        // mobile is undefined
+      };
+      const deviceType = 'mobile';
+      const markdownContent = '# Mobile Report';
+
+      const result = createOrUpdateDeviceSpecificSuggestion(
+        suggestionValue,
+        deviceType,
+        markdownContent,
+        mockLog,
+      );
+
+      expect(result).to.be.an('array');
+      expect(result[0].data.suggestionValue['accessibility-mobile']).to.equal('# Mobile Report');
+    });
+
+    it('should handle object with one device having empty string', () => {
+      const suggestionValue = {
+        'accessibility-desktop': '',
+        'accessibility-mobile': '# Mobile Report',
+      };
+      const deviceType = 'desktop';
+      const markdownContent = '# Desktop Report';
+
+      const result = createOrUpdateDeviceSpecificSuggestion(
+        suggestionValue,
+        deviceType,
+        markdownContent,
+        mockLog,
+      );
+
+      expect(result).to.be.an('array');
+      expect(result[0].data.suggestionValue['accessibility-desktop']).to.equal('# Desktop Report');
+      expect(result[0].data.suggestionValue['accessibility-mobile']).to.equal('# Mobile Report');
+    });
+
+    it('should log desktop content length when desktop content exists', () => {
+      const suggestionValue = {
+        'accessibility-desktop': '# Desktop Report\nWith some content',
+      };
+      const deviceType = 'mobile';
+      const markdownContent = '# Mobile Report';
+
+      // Create a spy to track log calls
+      const logSpy = {
+        info: () => {},
+      };
+
+      const result = createOrUpdateDeviceSpecificSuggestion(
+        suggestionValue,
+        deviceType,
+        markdownContent,
+        logSpy,
+      );
+
+      // Verify the result has both desktop and mobile content
+      expect(result[0].data.suggestionValue['accessibility-desktop']).to.have.length.greaterThan(0);
+      expect(result[0].data.suggestionValue['accessibility-mobile']).to.equal('# Mobile Report');
+    });
+
+    it('should handle object with desktop content when updating mobile', () => {
+      // This test specifically ensures we hit the truthy branch of line 121
+      const desktopContent = '# Desktop Accessibility Report\n\n## Critical Issues\n\nSome detailed content here.';
+      const suggestionValue = {
+        'accessibility-desktop': desktopContent,
+      };
+      const deviceType = 'mobile';
+      const mobileContent = '# Mobile Accessibility Report\n\n## Mobile Issues\n\nMobile specific content.';
+
+      const result = createOrUpdateDeviceSpecificSuggestion(
+        suggestionValue,
+        deviceType,
+        mobileContent,
+        mockLog,
+      );
+
+      expect(result).to.be.an('array');
+      expect(result[0].data.suggestionValue['accessibility-desktop']).to.equal(desktopContent);
+      expect(result[0].data.suggestionValue['accessibility-desktop']).to.have.length.greaterThan(50);
+      expect(result[0].data.suggestionValue['accessibility-mobile']).to.equal(mobileContent);
+      expect(result[0].data.suggestionValue['accessibility-mobile']).to.have.length.greaterThan(50);
+    });
+
+    it('should handle object with mobile content when updating desktop', () => {
+      // This test ensures both branches are covered
+      const mobileContent = '# Mobile Accessibility Report\n\n## Mobile Issues\n\nMobile specific content.';
+      const suggestionValue = {
+        'accessibility-mobile': mobileContent,
+      };
+      const deviceType = 'desktop';
+      const desktopContent = '# Desktop Accessibility Report\n\n## Critical Issues\n\nDesktop specific content.';
+
+      const result = createOrUpdateDeviceSpecificSuggestion(
+        suggestionValue,
+        deviceType,
+        desktopContent,
+        mockLog,
+      );
+
+      expect(result).to.be.an('array');
+      expect(result[0].data.suggestionValue['accessibility-desktop']).to.equal(desktopContent);
+      expect(result[0].data.suggestionValue['accessibility-desktop']).to.have.length.greaterThan(50);
+      expect(result[0].data.suggestionValue['accessibility-mobile']).to.equal(mobileContent);
+      expect(result[0].data.suggestionValue['accessibility-mobile']).to.have.length.greaterThan(50);
+    });
+
+    it('should correctly log desktop content length when it exists with truthy length', () => {
+      // This test specifically targets line 121 where desktop content already exists
+      const existingDesktopContent = 'Desktop Report Content';
+      const suggestionValue = {
+        'accessibility-desktop': existingDesktopContent,
+      };
+      const deviceType = 'mobile';
+      const mobileContent = 'Mobile Content';
+
+      let loggedDesktopLength = false;
+      const logSpy = {
+        info: (message) => {
+          if (message.includes('accessibility-desktop length:') && message.includes(existingDesktopContent.length.toString())) {
+            loggedDesktopLength = true;
+          }
+        },
+      };
+
+      const result = createOrUpdateDeviceSpecificSuggestion(
+        suggestionValue,
+        deviceType,
+        mobileContent,
+        logSpy,
+      );
+
+      expect(result).to.be.an('array');
+      expect(result[0].data.suggestionValue['accessibility-desktop']).to.equal(existingDesktopContent);
+      expect(result[0].data.suggestionValue['accessibility-mobile']).to.equal(mobileContent);
+      expect(loggedDesktopLength).to.be.true;
+    });
+
+    it('should correctly log desktop content length when it does not exist (hits || 0 branch)', () => {
+      // This test targets line 121 falsy branch where desktop content is undefined
+      // We update mobile but desktop doesn't exist yet, so line 121 logs "0"
+      const suggestionValue = {
+        'accessibility-mobile': 'Existing Mobile Content',
+      };
+      const deviceType = 'mobile';  // Updating mobile, so desktop remains undefined
+      const mobileContent = 'Updated Mobile Content';
+
+      let loggedDesktopZero = false;
+      const logSpy = {
+        info: (message) => {
+          if (message.includes('accessibility-desktop length: 0')) {
+            loggedDesktopZero = true;
+          }
+        },
+      };
+
+      const result = createOrUpdateDeviceSpecificSuggestion(
+        suggestionValue,
+        deviceType,
+        mobileContent,
+        logSpy,
+      );
+
+      expect(result).to.be.an('array');
+      expect(result[0].data.suggestionValue['accessibility-desktop']).to.be.undefined;
+      expect(result[0].data.suggestionValue['accessibility-mobile']).to.equal(mobileContent);
+      expect(loggedDesktopZero).to.be.true;
+    });
+  });
 });
diff --git a/test/audits/accessibility/scrape-utils.test.js b/test/audits/accessibility/scrape-utils.test.js
index 8acf84588..ce9111d42 100644
--- a/test/audits/accessibility/scrape-utils.test.js
+++ b/test/audits/accessibility/scrape-utils.test.js
@@ -373,6 +373,92 @@ describe('Scrape Utils', () => {
 
       expect(filtered).to.be.an('array').that.is.empty;
     });
+
+    it('filters opportunities by specific device type (desktop)', () => {
+      const opportunities = [
+        {
+          getType: () => 'generic-opportunity',
+          getTitle: () => 'Accessibility report - Desktop - Week 1 - 2024',
+        },
+        {
+          getType: () => 'generic-opportunity',
+          getTitle: () => 'Accessibility report - Mobile - Week 1 - 2024',
+        },
+        {
+          getType: () => 'generic-opportunity',
+          getTitle: () => 'Accessibility report - Desktop - Week 2 - 2024',
+        },
+      ];
+
+      const filtered = filterAccessibilityOpportunities(opportunities, 'desktop');
+
+      expect(filtered).to.have.lengthOf(2);
+      expect(filtered[0].getTitle()).to.include('- Desktop -');
+      expect(filtered[1].getTitle()).to.include('- Desktop -');
+    });
+
+    it('filters opportunities by specific device type (mobile)', () => {
+      const opportunities = [
+        {
+          getType: () => 'generic-opportunity',
+          getTitle: () => 'Accessibility report - Desktop - Week 1 - 2024',
+        },
+        {
+          getType: () => 'generic-opportunity',
+          getTitle: () => 'Accessibility report - Mobile - Week 1 - 2024',
+        },
+        {
+          getType: () => 'generic-opportunity',
+          getTitle: () => 'Accessibility report - Mobile - Week 2 - 2024',
+        },
+      ];
+
+      const filtered = filterAccessibilityOpportunities(opportunities, 'mobile');
+
+      expect(filtered).to.have.lengthOf(2);
+      expect(filtered[0].getTitle()).to.include('- Mobile -');
+      expect(filtered[1].getTitle()).to.include('- Mobile -');
+    });
+
+    it('returns empty array when device type does not match', () => {
+      const opportunities = [
+        {
+          getType: () => 'generic-opportunity',
+          getTitle: () => 'Accessibility report - Desktop - Week 1 - 2024',
+        },
+        {
+          getType: () => 'generic-opportunity',
+          getTitle: () => 'Accessibility report - Desktop - Week 2 - 2024',
+        },
+      ];
+
+      const filtered = filterAccessibilityOpportunities(opportunities, 'mobile');
+
+      expect(filtered).to.be.an('array').that.is.empty;
+    });
+
+    it('filters by device type with proper capitalization', () => {
+      const opportunities = [
+        {
+          getType: () => 'generic-opportunity',
+          getTitle: () => 'Accessibility report - Desktop - Week 1 - 2024',
+        },
+        {
+          getType: () => 'generic-opportunity',
+          getTitle: () => 'Accessibility report - Mobile - Week 1 - 2024',
+        },
+      ];
+
+      // Test with lowercase device type
+      const filteredDesktop = filterAccessibilityOpportunities(opportunities, 'desktop');
+      expect(filteredDesktop).to.have.lengthOf(1);
+      expect(filteredDesktop[0].getTitle()).to.include('- Desktop -');
+
+      // Test with lowercase mobile
+      const filteredMobile = filterAccessibilityOpportunities(opportunities, 'mobile');
+      expect(filteredMobile).to.have.lengthOf(1);
+      expect(filteredMobile[0].getTitle()).to.include('- Mobile -');
+    });
   });
 
   describe('updateStatusToIgnored', () => {
@@ -479,6 +565,60 @@ describe('Scrape Utils', () => {
       });
       expect(mockLog.error).to.have.been.calledWith('[A11yAudit][A11yProcessingError] Error updating opportunities to IGNORED for site site1: Fetch failed');
     });
+
+    it('successfully updates opportunities with device type specified', async () => {
+      // Create opportunities with desktop-specific titles
+      const desktopOpportunity = {
+        getType: sandbox.stub().returns('generic-opportunity'),
+        getTitle: sandbox.stub().returns('Accessibility report - Desktop - Week 1 - 2024'),
+        setStatus: sandbox.stub(),
+        save: sandbox.stub().resolves(),
+      };
+
+      mockDataAccess.Opportunity.allBySiteIdAndStatus.resolves([desktopOpportunity]);
+      
+      const result = await updateStatusToIgnored(mockDataAccess, 'site1', mockLog, 'desktop');
+
+      expect(result).to.deep.equal({
+        success: true,
+        updatedCount: 1,
+        error: undefined,
+      });
+      expect(desktopOpportunity.setStatus).to.have.been.calledWith('IGNORED');
+      expect(desktopOpportunity.save).to.have.been.calledOnce;
+      expect(mockLog.debug).to.have.been.calledWith('[A11yAudit] Found 1 opportunities to update to IGNORED for desktop for site site1');
+    });
+
+    it('filters by device type when updating status', async () => {
+      // Create both desktop and mobile opportunities
+      const desktopOpportunity = {
+        getType: sandbox.stub().returns('generic-opportunity'),
+        getTitle: sandbox.stub().returns('Accessibility report - Desktop - Week 1 - 2024'),
+        setStatus: sandbox.stub(),
+        save: sandbox.stub().resolves(),
+      };
+      const mobileOpportunity = {
+        getType: sandbox.stub().returns('generic-opportunity'),
+        getTitle: sandbox.stub().returns('Accessibility report - Mobile - Week 1 - 2024'),
+        setStatus: sandbox.stub(),
+        save: sandbox.stub().resolves(),
+      };
+
+      mockDataAccess.Opportunity.allBySiteIdAndStatus.resolves([desktopOpportunity, mobileOpportunity]);
+      
+      // Update only desktop opportunities
+      const result = await updateStatusToIgnored(mockDataAccess, 'site1', mockLog, 'desktop');
+
+      expect(result).to.deep.equal({
+        success: true,
+        updatedCount: 1,
+        error: undefined,
+      });
+      expect(desktopOpportunity.setStatus).to.have.been.calledWith('IGNORED');
+      expect(desktopOpportunity.save).to.have.been.calledOnce;
+      expect(mobileOpportunity.setStatus).to.not.have.been.called;
+      expect(mobileOpportunity.save).to.not.have.been.called;
+    });
   });
 
   describe('saveMystiqueValidationMetricsToS3', () => {
diff --git a/test/audits/forms/accessibility-handler.test.js b/test/audits/forms/accessibility-handler.test.js
index 2c248ec4d..bcb94c697 100644
--- a/test/audits/forms/accessibility-handler.test.js
+++ b/test/audits/forms/accessibility-handler.test.js
@@ -23,7 +23,7 @@ import { MockContextBuilder } from '../../shared.js';
 
 use(sinonChai);
 
-describe.skip('Forms Opportunities - Accessibility Handler', () => {
+describe('Forms Opportunities - Accessibility Handler', () => {
   let sandbox;
   beforeEach(async () => {
     sandbox = sinon.createSandbox();
@@ -49,7 +49,7 @@ describe.skip('Forms Opportunities - Accessibility Handler', () => {
       expect(filterLogic(opportunityWithoutTag)).to.be.false;
     });
 
-    it('should test the complete flow with opportunities that need to be updated to IGNORED', async () => {
+    it('should create a new opportunity when no existing opportunity ID is provided', async () => {
       const message = {
         auditId: 'test-audit-id',
         siteId: 'test-site-id',
@@ -68,11 +68,29 @@ describe.skip('Forms Opportunities - Accessibility Handler', () => {
         },
       };
 
-      // Mock existing opportunities that have Forms Accessibility tag
-      const existingOpportunity = {
+      const newOpportunity = {
+        getId: () => 'new-opportunity-id',
         getTags: () => ['Forms Accessibility'],
-        setStatus: sandbox.stub(),
+        getData: () => ({
+          accessibility: [{
+            form: 'https://example.com/form1',
+            formSource: '#form1',
+            a11yIssues: [{
+              issue: 'Missing alt text',
+              level: 'error',
+              successCriterias: [{
+                id: '1.1.1',
+                level: 'A',
+                description: 'Non-text Content',
+              }],
+              htmlWithIssues: '<img src="test.jpg">',
+              recommendation: 'Add alt text to image',
+            }],
+          }],
+        }),
+        setUpdatedBy: sandbox.stub(),
         save: sandbox.stub().resolves(),
+        addSuggestions: sandbox.stub().resolves({ id: 'sugg-1' }),
       };
 
       const context = new MockContextBuilder()
@@ -80,16 +98,7 @@ describe.skip('Forms Opportunities - Accessibility Handler', () => {
         .withOverrides({
           dataAccess: {
             Opportunity: {
-              // Return existing opportunities when queried for NEW status
-              allBySiteIdAndStatus: sandbox.stub().callsFake(async (siteId, status) => {
-                if (status === 'NEW') {
-                  return [existingOpportunity];
-                }
-                return [];
-              }),
-              create: sandbox.stub().resolves({
-                getId: () => 'new-opportunity-id',
-              }),
+              create: sandbox.stub().resolves(newOpportunity),
               findById: sandbox.stub().resolves(null), // No existing opportunity with this ID
             },
             Site: {
@@ -115,15 +124,11 @@ describe.skip('Forms Opportunities - Accessibility Handler', () => {
 
       await mystiqueDetectedFormAccessibilityHandler(message, context);
 
-      // Verify that allBySiteIdAndStatus was called to find opportunities to update
-      expect(context.dataAccess.Opportunity.allBySiteIdAndStatus).to.have.been.calledWith('test-site-id', 'NEW');
-
-      // Verify that the existing opportunity was updated to IGNORED status
-      expect(existingOpportunity.setStatus).to.have.been.calledWith('IGNORED');
-      expect(existingOpportunity.save).to.have.been.calledOnce;
-
       // Verify that a new opportunity was created
       expect(context.dataAccess.Opportunity.create).to.have.been.calledOnce;
+      
+      // Verify that guidance was sent (either to Mystique or FormsQualityAgent)
+      expect(context.sqs.sendMessage).to.have.been.called;
     });
   });
 

From 65e4a60cf64cc77a90d0bb7f70953f5a0ce05f1f Mon Sep 17 00:00:00 2001
From: Diana Preda <dpreda@adobe.com>
Date: Fri, 24 Oct 2025 13:34:18 +0300
Subject: [PATCH 14/20] skip only step 2 for mobile audit, enable step 3

---
 src/accessibility/handler.js | 59 ++++++++++++++++++------------------
 1 file changed, 29 insertions(+), 30 deletions(-)

diff --git a/src/accessibility/handler.js b/src/accessibility/handler.js
index 8dbfb987b..312f80da5 100644
--- a/src/accessibility/handler.js
+++ b/src/accessibility/handler.js
@@ -325,9 +325,8 @@ export function createProcessAccessibilityOpportunitiesWithDevice(deviceType) {
       };
     }
 
-    // Step 2c and Step 3: Skip for mobile audits as requested
+    // Step 2c: Create individual opportunities (skip for mobile audits)
     if (deviceType !== 'mobile') {
-      // Step 2c: Create individual opportunities for the specific device
       try {
         await createAccessibilityIndividualOpportunities(
           aggregationResult.finalResultFiles.current,
@@ -341,35 +340,35 @@ export function createProcessAccessibilityOpportunitiesWithDevice(deviceType) {
           error: error.message,
         };
       }
-
-      // step 3 save a11y metrics to s3 for this device type
-      try {
-        // Send message to importer-worker to save a11y metrics
-        await sendRunImportMessage(
-          sqs,
-          env.IMPORT_WORKER_QUEUE_URL,
-          `${A11Y_METRICS_AGGREGATOR_IMPORT_TYPE}_${deviceType}`,
-          siteId,
-          {
-            scraperBucketName: env.S3_SCRAPER_BUCKET_NAME,
-            importerBucketName: env.S3_IMPORTER_BUCKET_NAME,
-            version,
-            urlSourceSeparator: URL_SOURCE_SEPARATOR,
-            totalChecks: WCAG_CRITERIA_COUNTS.TOTAL,
-            deviceType,
-            options: {},
-          },
-        );
-        log.debug(`[A11yAudit] Sent message to importer-worker to save a11y metrics for ${deviceType} on site ${siteId}`);
-      } catch (error) {
-        log.error(`[A11yAudit][A11yProcessingError] Error sending message to importer-worker to save a11y metrics for ${deviceType} on site ${siteId} (${site.getBaseURL()}): ${error.message}`, error);
-        return {
-          status: 'PROCESSING_FAILED',
-          error: error.message,
-        };
-      }
     } else {
-      log.info(`[A11yAudit] Skipping individual opportunities (Step 2c) and metrics import (Step 3) for mobile audit on site ${siteId}`);
+      log.info(`[A11yAudit] Skipping individual opportunities (Step 2c) for mobile audit on site ${siteId}`);
+    }
+
+    // Step 3: Save a11y metrics to s3 for ALL device types (desktop and mobile)
+    try {
+      // Send message to importer-worker to save a11y metrics
+      await sendRunImportMessage(
+        sqs,
+        env.IMPORT_WORKER_QUEUE_URL,
+        `${A11Y_METRICS_AGGREGATOR_IMPORT_TYPE}_${deviceType}`,
+        siteId,
+        {
+          scraperBucketName: env.S3_SCRAPER_BUCKET_NAME,
+          importerBucketName: env.S3_IMPORTER_BUCKET_NAME,
+          version,
+          urlSourceSeparator: URL_SOURCE_SEPARATOR,
+          totalChecks: WCAG_CRITERIA_COUNTS.TOTAL,
+          deviceType,
+          options: {},
+        },
+      );
+      log.debug(`[A11yAudit] Sent message to importer-worker to save a11y metrics for ${deviceType} on site ${siteId}`);
+    } catch (error) {
+      log.error(`[A11yAudit][A11yProcessingError] Error sending message to importer-worker to save a11y metrics for ${deviceType} on site ${siteId} (${site.getBaseURL()}): ${error.message}`, error);
+      return {
+        status: 'PROCESSING_FAILED',
+        error: error.message,
+      };
     }
 
     // Extract key metrics for the audit result summary, filtered by device type

From 0d9f5de974d2b951ba9d6632f46dc2abf66666a9 Mon Sep 17 00:00:00 2001
From: Diana Preda <dpreda@adobe.com>
Date: Fri, 24 Oct 2025 13:42:33 +0300
Subject: [PATCH 15/20] fix tests

---
 test/audits/accessibility.test.js | 20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/test/audits/accessibility.test.js b/test/audits/accessibility.test.js
index 14c0184af..60ab94d4c 100644
--- a/test/audits/accessibility.test.js
+++ b/test/audits/accessibility.test.js
@@ -1533,14 +1533,28 @@ describe('Accessibility Audit Handler', () => {
       mockContext.log.info.resetHistory();
       createAccessibilityIndividualOpportunitiesStub.resetHistory();
       sendRunImportMessageStub.resetHistory();
+      sendRunImportMessageStub.resolves();
 
       // Act - use the factory to create a mobile-specific processor
       const processMobileOpportunities = createProcessAccessibilityOpportunitiesWithDevice('mobile');
       const result = await processMobileOpportunities(mockContext);
 
-      // Assert
+      // Assert - individual opportunities should be skipped for mobile
       expect(createAccessibilityIndividualOpportunitiesStub).to.not.have.been.called;
-      expect(sendRunImportMessageStub).to.not.have.been.called;
+      
+      // Assert - metrics import SHOULD be called for mobile (changed behavior)
+      expect(sendRunImportMessageStub).to.have.been.calledOnceWith(
+        mockContext.sqs,
+        'test-queue',
+        'a11y-metrics-aggregator_mobile',
+        'test-site-id',
+        sinon.match({
+          scraperBucketName: 'test-bucket',
+          importerBucketName: 'test-bucket-2',
+          deviceType: 'mobile',
+        }),
+      );
+      
       expect(result.status).to.equal('OPPORTUNITIES_FOUND');
       expect(result.deviceType).to.equal('mobile');
       expect(result.opportunitiesFound).to.equal(3); // 3 mobile issues
@@ -1548,7 +1562,7 @@ describe('Accessibility Audit Handler', () => {
       // Check that the specific log messages were called
       const logCalls = mockContext.log.info.getCalls().map(call => call.args[0]);
       expect(logCalls).to.include('[A11yAudit] Step 2: Processing scraped data for mobile on site test-site-id (https://example.com)');
-      expect(logCalls).to.include('[A11yAudit] Skipping individual opportunities (Step 2c) and metrics import (Step 3) for mobile audit on site test-site-id');
+      expect(logCalls).to.include('[A11yAudit] Skipping individual opportunities (Step 2c) for mobile audit on site test-site-id');
       expect(logCalls).to.include('[A11yAudit] Found 3 mobile accessibility issues across 1 unique URLs for site test-site-id (https://example.com)');
     });
 

From 9001bb42bae1080e85bdc7a7fea90e18cf705ea5 Mon Sep 17 00:00:00 2001
From: Diana Preda <dpreda@adobe.com>
Date: Fri, 24 Oct 2025 16:30:52 +0300
Subject: [PATCH 16/20] delete unnecessary debug logs

---
 src/accessibility/utils/data-processing.js | 24 ----------------------
 src/accessibility/utils/report-oppty.js    | 16 +--------------
 2 files changed, 1 insertion(+), 39 deletions(-)

diff --git a/src/accessibility/utils/data-processing.js b/src/accessibility/utils/data-processing.js
index 453ca65b7..11ee92862 100644
--- a/src/accessibility/utils/data-processing.js
+++ b/src/accessibility/utils/data-processing.js
@@ -524,18 +524,12 @@ export async function createOrUpdateDeviceSpecificSuggestion(
     const existingSuggestions = await opportunity.getSuggestions();
     const existingSuggestion = existingSuggestions.find((s) => s.getType() === 'CODE_CHANGE');
 
-    log.info(`[A11yAudit] [DEBUG] ${deviceType} suggestion - Found existing: ${!!existingSuggestion}, reportMarkdown length: ${reportMarkdown?.length || 0}`);
-
     let suggestions;
     if (existingSuggestion) {
       // Update existing suggestion with new device content
       const currentData = existingSuggestion.getData() ?? {};
       const currentSuggestionValue = currentData.suggestionValue ?? {};
 
-      log.info(`[A11yAudit] [DEBUG] Current suggestionValue keys: ${Object.keys(currentSuggestionValue).join(', ')}`);
-      log.info(`[A11yAudit] [DEBUG] Current accessibility-desktop length: ${currentSuggestionValue['accessibility-desktop']?.length || 0}`);
-      log.info(`[A11yAudit] [DEBUG] Current accessibility-mobile length: ${currentSuggestionValue['accessibility-mobile']?.length || 0}`);
-
       suggestions = createSuggestionInstance(
         currentSuggestionValue,
         deviceType,
@@ -546,30 +540,16 @@ export async function createOrUpdateDeviceSpecificSuggestion(
       // Update only the suggestionValue field to avoid ElectroDB timestamp conflicts
       const newData = { ...currentData, suggestionValue: suggestions[0].data.suggestionValue };
 
-      log.info(`[A11yAudit] [DEBUG] New suggestionValue keys after update: ${Object.keys(newData.suggestionValue).join(', ')}`);
-      log.info(`[A11yAudit] [DEBUG] New accessibility-desktop length: ${newData.suggestionValue['accessibility-desktop']?.length || 0}`);
-      log.info(`[A11yAudit] [DEBUG] New accessibility-mobile length: ${newData.suggestionValue['accessibility-mobile']?.length || 0}`);
-      log.info(`[A11yAudit] [DEBUG] FULL new ${deviceType} suggestionValue:\n${newData.suggestionValue[`accessibility-${deviceType}`]}`);
-
       existingSuggestion.setData(newData);
       await existingSuggestion.save();
 
-      log.info(`[A11yAudit] [DEBUG] Successfully saved ${deviceType} suggestion update`);
-
       return { suggestion: existingSuggestion };
     } else {
       // Create new suggestion
       suggestions = createSuggestionInstance(null, deviceType, reportMarkdown, log);
 
-      log.info(`[A11yAudit] [DEBUG] Creating NEW suggestion for ${deviceType}`);
-      log.info(`[A11yAudit] [DEBUG] New suggestion suggestionValue keys: ${Object.keys(suggestions[0].data.suggestionValue).join(', ')}`);
-      log.info(`[A11yAudit] [DEBUG] New suggestion ${deviceType} length: ${suggestions[0].data.suggestionValue[`accessibility-${deviceType}`]?.length || 0}`);
-      log.info(`[A11yAudit] [DEBUG] FULL new ${deviceType} suggestionValue:\n${suggestions[0].data.suggestionValue[`accessibility-${deviceType}`]}`);
-
       const suggestion = await opportunity.addSuggestions(suggestions);
 
-      log.info(`[A11yAudit] [DEBUG] Successfully created ${deviceType} suggestion`);
-
       return { suggestion };
     }
   } catch (e) {
@@ -788,10 +768,6 @@ export async function generateReportOpportunity(
   // 1.1 generate the markdown report
   const reportMarkdown = genMdFn(mdData);
 
-  // DEBUG: Log the generated markdown for debugging
-  log.info(`[A11yAudit] [DEBUG] Generated ${reportName} markdown for ${deviceType} (length: ${reportMarkdown?.length || 0} chars)`);
-  log.info(`[A11yAudit] [DEBUG] FULL ${reportName} markdown:\n${reportMarkdown}`);
-
   if (!reportMarkdown) {
     // If the markdown is empty, we don't want to create an opportunity
     // and we don't want to throw an error
diff --git a/src/accessibility/utils/report-oppty.js b/src/accessibility/utils/report-oppty.js
index fcd099535..113148d04 100644
--- a/src/accessibility/utils/report-oppty.js
+++ b/src/accessibility/utils/report-oppty.js
@@ -95,17 +95,12 @@ export function createOrUpdateDeviceSpecificSuggestion(
   suggestionValue,
   deviceType,
   markdownContent,
-  log = console,
+
 ) {
   let updatedSuggestionValue;
 
-  log.info(`[A11yAudit] [DEBUG] Creating/updating suggestion for ${deviceType}`);
-  log.info(`[A11yAudit] [DEBUG] Input suggestionValue type: ${typeof suggestionValue}`);
-  log.info(`[A11yAudit] [DEBUG] markdownContent length: ${markdownContent?.length || 0}`);
-
   if (typeof suggestionValue === 'string') {
     // First device creating the suggestion (legacy case or when no existing suggestion)
-    log.info('[A11yAudit] [DEBUG] Branch: suggestionValue is string');
     updatedSuggestionValue = {};
     if (deviceType === 'desktop') {
       updatedSuggestionValue['accessibility-desktop'] = suggestionValue;
@@ -114,23 +109,14 @@ export function createOrUpdateDeviceSpecificSuggestion(
     }
   } else if (typeof suggestionValue === 'object' && suggestionValue !== null) {
     // Existing object - update with new device content
-    log.info(`[A11yAudit] [DEBUG] Branch: suggestionValue is object, keys: ${Object.keys(suggestionValue).join(', ')}`);
     updatedSuggestionValue = { ...suggestionValue };
     updatedSuggestionValue[`accessibility-${deviceType}`] = markdownContent;
-    log.info(`[A11yAudit] [DEBUG] After update, keys: ${Object.keys(updatedSuggestionValue).join(', ')}`);
-    log.info(`[A11yAudit] [DEBUG] accessibility-desktop length: ${updatedSuggestionValue['accessibility-desktop']?.length || 0}`);
-    log.info(`[A11yAudit] [DEBUG] accessibility-mobile length: ${updatedSuggestionValue['accessibility-mobile']?.length || 0}`);
   } else {
     // New object structure
-    log.info('[A11yAudit] [DEBUG] Branch: new object structure');
     updatedSuggestionValue = {};
     updatedSuggestionValue[`accessibility-${deviceType}`] = markdownContent;
   }
 
-  log.info(`[A11yAudit] [DEBUG] Final updatedSuggestionValue keys: ${Object.keys(updatedSuggestionValue).join(', ')}`);
-  log.info(`[A11yAudit] [DEBUG] Final ${deviceType} content length: ${updatedSuggestionValue[`accessibility-${deviceType}`]?.length || 0}`);
-  log.info(`[A11yAudit] [DEBUG] FULL ${deviceType} content:\n${updatedSuggestionValue[`accessibility-${deviceType}`]}`);
-
   return createReportOpportunitySuggestionInstance(updatedSuggestionValue);
 }
 

From 56c6aa188526562556efed34889170a8052b40af Mon Sep 17 00:00:00 2001
From: Diana Preda <dpreda@adobe.com>
Date: Fri, 24 Oct 2025 16:42:18 +0300
Subject: [PATCH 17/20] fixed tests

---
 .../accessibility/data-processing.test.js     | 21 ++++--------
 .../audits/accessibility/report-oppty.test.js | 33 ++++---------------
 2 files changed, 12 insertions(+), 42 deletions(-)

diff --git a/test/audits/accessibility/data-processing.test.js b/test/audits/accessibility/data-processing.test.js
index cc2a06212..7fd0612f8 100644
--- a/test/audits/accessibility/data-processing.test.js
+++ b/test/audits/accessibility/data-processing.test.js
@@ -5565,9 +5565,6 @@ describe('data-processing utility functions', () => {
 
       // Assert
       expect(mockOpportunity.addSuggestions).to.have.been.called;
-      expect(mockLog.info).to.have.been.calledWith(
-        sinon.match(/reportMarkdown length: 0/)
-      );
     });
 
     it('should handle null reportMarkdown (line 527)', async () => {
@@ -5586,10 +5583,8 @@ describe('data-processing utility functions', () => {
         mockLog,
       );
 
-      // Assert
-      expect(mockLog.info).to.have.been.calledWith(
-        sinon.match(/reportMarkdown length: 0/)
-      );
+      // Assert - test passes if no errors are thrown
+      expect(result).to.exist;
     });
 
     it('should handle missing accessibility-desktop in suggestionValue (line 536, 550)', async () => {
@@ -5612,10 +5607,8 @@ describe('data-processing utility functions', () => {
         mockLog,
       );
 
-      // Assert
-      expect(mockLog.info).to.have.been.calledWith(
-        sinon.match(/Current accessibility-desktop length: 0/)
-      );
+      // Assert - verify suggestion was saved with correct data
+      expect(mockExistingSuggestion.save).to.have.been.called;
     });
 
     it('should handle missing accessibility-mobile in suggestionValue (line 537, 551)', async () => {
@@ -5638,10 +5631,8 @@ describe('data-processing utility functions', () => {
         mockLog,
       );
 
-      // Assert
-      expect(mockLog.info).to.have.been.calledWith(
-        sinon.match(/Current accessibility-mobile length: 0/)
-      );
+      // Assert - verify suggestion was saved with correct data
+      expect(mockExistingSuggestion.save).to.have.been.called;
     });
   });
 
diff --git a/test/audits/accessibility/report-oppty.test.js b/test/audits/accessibility/report-oppty.test.js
index 7696c3ebc..b2f21ba8d 100644
--- a/test/audits/accessibility/report-oppty.test.js
+++ b/test/audits/accessibility/report-oppty.test.js
@@ -763,8 +763,9 @@ describe('Accessibility Report Opportunity Utils', () => {
       expect(result[0].data.suggestionValue['accessibility-mobile']).to.have.length.greaterThan(50);
     });
 
-    it('should correctly log desktop content length when it exists with truthy length', () => {
-      // This test specifically targets line 121 where desktop content already exists
+    it('should correctly handle desktop content when it exists with truthy length', () => {
+      // This test verifies that when desktop content already exists,
+      // we can update mobile content while preserving desktop
       const existingDesktopContent = 'Desktop Report Content';
       const suggestionValue = {
         'accessibility-desktop': existingDesktopContent,
@@ -772,57 +773,35 @@ describe('Accessibility Report Opportunity Utils', () => {
       const deviceType = 'mobile';
       const mobileContent = 'Mobile Content';
 
-      let loggedDesktopLength = false;
-      const logSpy = {
-        info: (message) => {
-          if (message.includes('accessibility-desktop length:') && message.includes(existingDesktopContent.length.toString())) {
-            loggedDesktopLength = true;
-          }
-        },
-      };
-
       const result = createOrUpdateDeviceSpecificSuggestion(
         suggestionValue,
         deviceType,
         mobileContent,
-        logSpy,
       );
 
       expect(result).to.be.an('array');
       expect(result[0].data.suggestionValue['accessibility-desktop']).to.equal(existingDesktopContent);
       expect(result[0].data.suggestionValue['accessibility-mobile']).to.equal(mobileContent);
-      expect(loggedDesktopLength).to.be.true;
     });
 
-    it('should correctly log desktop content length when it does not exist (hits || 0 branch)', () => {
-      // This test targets line 121 falsy branch where desktop content is undefined
-      // We update mobile but desktop doesn't exist yet, so line 121 logs "0"
+    it('should correctly handle when desktop content does not exist', () => {
+      // This test verifies that when desktop content is undefined,
+      // we can still update mobile content without issues
       const suggestionValue = {
         'accessibility-mobile': 'Existing Mobile Content',
       };
       const deviceType = 'mobile';  // Updating mobile, so desktop remains undefined
       const mobileContent = 'Updated Mobile Content';
 
-      let loggedDesktopZero = false;
-      const logSpy = {
-        info: (message) => {
-          if (message.includes('accessibility-desktop length: 0')) {
-            loggedDesktopZero = true;
-          }
-        },
-      };
-
       const result = createOrUpdateDeviceSpecificSuggestion(
         suggestionValue,
         deviceType,
         mobileContent,
-        logSpy,
       );
 
       expect(result).to.be.an('array');
       expect(result[0].data.suggestionValue['accessibility-desktop']).to.be.undefined;
       expect(result[0].data.suggestionValue['accessibility-mobile']).to.equal(mobileContent);
-      expect(loggedDesktopZero).to.be.true;
     });
   });
 });

From ec2e47465cca6431b070069f0afb212385261b1f Mon Sep 17 00:00:00 2001
From: Diana Preda <dpreda@adobe.com>
Date: Thu, 30 Oct 2025 11:20:28 +0200
Subject: [PATCH 18/20] update spacecat-shared package version

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 8030c41e2..d05a71d44 100755
--- a/package.json
+++ b/package.json
@@ -86,7 +86,7 @@
     "@adobe/spacecat-shared-gpt-client": "1.6.7",
     "@adobe/spacecat-shared-http-utils": "1.17.9",
     "@adobe/spacecat-shared-ims-client": "1.9.1",
-    "@adobe/spacecat-shared-rum-api-client": "2.38.6",
+    "@adobe/spacecat-shared-rum-api-client": "2.38.8",
     "@adobe/spacecat-shared-rum-api-client-v1": "npm:@adobe/spacecat-shared-rum-api-client@1.8.4",
     "@adobe/spacecat-shared-scrape-client": "2.1.7",
     "@adobe/spacecat-shared-slack-client": "1.5.28",

From ba5b7fa176ddcadfa3a5e8bb2b3ca25bfb431c1d Mon Sep 17 00:00:00 2001
From: Diana Preda <dpreda@adobe.com>
Date: Thu, 30 Oct 2025 11:29:29 +0200
Subject: [PATCH 19/20] update shared package version

---
 package-lock.json | 69 +++--------------------------------------------
 package.json      |  2 +-
 2 files changed, 5 insertions(+), 66 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 409a55bd9..e2434bbd8 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -23,7 +23,7 @@
         "@adobe/spacecat-shared-gpt-client": "1.6.7",
         "@adobe/spacecat-shared-http-utils": "1.17.9",
         "@adobe/spacecat-shared-ims-client": "1.9.1",
-        "@adobe/spacecat-shared-rum-api-client": "2.38.6",
+        "@adobe/spacecat-shared-rum-api-client": "2.38.7",
         "@adobe/spacecat-shared-rum-api-client-v1": "npm:@adobe/spacecat-shared-rum-api-client@1.8.4",
         "@adobe/spacecat-shared-scrape-client": "2.1.7",
         "@adobe/spacecat-shared-slack-client": "1.5.28",
@@ -1004,7 +1004,6 @@
       "resolved": "https://registry.npmjs.org/@adobe/helix-universal/-/helix-universal-5.2.3.tgz",
       "integrity": "sha512-13lpLUAyPvitjNh6eVZKjh8+kE+0LGHElyIaV0X7wOqUn371+BR9LrfS5seOpcIDAFNpEbL4T68rgFa1/aQrbA==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@adobe/fetch": "4.2.3",
         "aws4": "1.13.2"
@@ -3922,7 +3921,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-sts/-/client-sts-3.726.1.tgz",
       "integrity": "sha512-qh9Q9Vu1hrM/wMBOBIaskwnE4GTFaZu26Q6WHwyWNfj7J8a40vBxpW16c2vYXHLBtwRKM1be8uRLkmDwghpiNw==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -4805,7 +4803,6 @@
       "resolved": "https://registry.npmjs.org/aws-xray-sdk-core/-/aws-xray-sdk-core-3.10.2.tgz",
       "integrity": "sha512-hAFEB+Stqm4FoQmIuyw5AzGVJh3BSfvLjK7IK4YYRXXLt1Oq9KS6pv2samYgRTTTXsxhmVpDjiYF3Xo/gfXIXA==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-sdk/types": "^3.4.1",
         "@smithy/service-error-classification": "^2.0.4",
@@ -6105,7 +6102,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-sts/-/client-sts-3.726.1.tgz",
       "integrity": "sha512-qh9Q9Vu1hrM/wMBOBIaskwnE4GTFaZu26Q6WHwyWNfj7J8a40vBxpW16c2vYXHLBtwRKM1be8uRLkmDwghpiNw==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -6988,7 +6984,6 @@
       "resolved": "https://registry.npmjs.org/aws-xray-sdk-core/-/aws-xray-sdk-core-3.10.2.tgz",
       "integrity": "sha512-hAFEB+Stqm4FoQmIuyw5AzGVJh3BSfvLjK7IK4YYRXXLt1Oq9KS6pv2samYgRTTTXsxhmVpDjiYF3Xo/gfXIXA==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-sdk/types": "^3.4.1",
         "@smithy/service-error-classification": "^2.0.4",
@@ -8243,7 +8238,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-sts/-/client-sts-3.726.1.tgz",
       "integrity": "sha512-qh9Q9Vu1hrM/wMBOBIaskwnE4GTFaZu26Q6WHwyWNfj7J8a40vBxpW16c2vYXHLBtwRKM1be8uRLkmDwghpiNw==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -9126,7 +9120,6 @@
       "resolved": "https://registry.npmjs.org/aws-xray-sdk-core/-/aws-xray-sdk-core-3.10.2.tgz",
       "integrity": "sha512-hAFEB+Stqm4FoQmIuyw5AzGVJh3BSfvLjK7IK4YYRXXLt1Oq9KS6pv2samYgRTTTXsxhmVpDjiYF3Xo/gfXIXA==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-sdk/types": "^3.4.1",
         "@smithy/service-error-classification": "^2.0.4",
@@ -9548,7 +9541,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-sso-oidc/-/client-sso-oidc-3.716.0.tgz",
       "integrity": "sha512-lA4IB9FzR2KjH7EVCo+mHGFKqdViVyeBQEIX9oVratL/l7P0bMS1fMwgfHOc3ACazqNxBxDES7x08ZCp32y6Lw==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -9602,7 +9594,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-sts/-/client-sts-3.716.0.tgz",
       "integrity": "sha512-i4SVNsrdXudp8T4bkm7Fi3YWlRnvXCSwvNDqf6nLqSJxqr4CN3VlBELueDyjBK7TAt453/qSif+eNx+bHmwo4Q==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -10793,7 +10784,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-sso-oidc/-/client-sso-oidc-3.716.0.tgz",
       "integrity": "sha512-lA4IB9FzR2KjH7EVCo+mHGFKqdViVyeBQEIX9oVratL/l7P0bMS1fMwgfHOc3ACazqNxBxDES7x08ZCp32y6Lw==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -10847,7 +10837,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-sts/-/client-sts-3.716.0.tgz",
       "integrity": "sha512-i4SVNsrdXudp8T4bkm7Fi3YWlRnvXCSwvNDqf6nLqSJxqr4CN3VlBELueDyjBK7TAt453/qSif+eNx+bHmwo4Q==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -12072,7 +12061,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-sso-oidc/-/client-sso-oidc-3.726.0.tgz",
       "integrity": "sha512-5JzTX9jwev7+y2Jkzjz0pd1wobB5JQfPOQF3N2DrJ5Pao0/k6uRYwE4NqB0p0HlGrMTDm7xNq7OSPPIPG575Jw==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -12126,7 +12114,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-sts/-/client-sts-3.726.1.tgz",
       "integrity": "sha512-qh9Q9Vu1hrM/wMBOBIaskwnE4GTFaZu26Q6WHwyWNfj7J8a40vBxpW16c2vYXHLBtwRKM1be8uRLkmDwghpiNw==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -12766,7 +12753,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-dynamodb/-/client-dynamodb-3.721.0.tgz",
       "integrity": "sha512-TGENpPbk6xtbLH07XZVZlhmK+SLs3stHLIQ/lZXZ8stZKT9//kA19P1E5+LNCmJFSLNxSj5ziHFOv/CzQN9U9g==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -18489,7 +18475,6 @@
       "resolved": "https://registry.npmjs.org/aws-xray-sdk-core/-/aws-xray-sdk-core-3.10.2.tgz",
       "integrity": "sha512-hAFEB+Stqm4FoQmIuyw5AzGVJh3BSfvLjK7IK4YYRXXLt1Oq9KS6pv2samYgRTTTXsxhmVpDjiYF3Xo/gfXIXA==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-sdk/types": "^3.4.1",
         "@smithy/service-error-classification": "^2.0.4",
@@ -18738,7 +18723,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-dynamodb/-/client-dynamodb-3.859.0.tgz",
       "integrity": "sha512-Bt840uICsGcn7IFewif8ARCF0CxtdTx9DX/LfUGRI+SVZcqyeEccmH2JJRRzThtEzKTXr+rCN6yaNB3c4RQY2g==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -21985,7 +21969,6 @@
       "resolved": "https://registry.npmjs.org/aws-xray-sdk-core/-/aws-xray-sdk-core-3.10.2.tgz",
       "integrity": "sha512-hAFEB+Stqm4FoQmIuyw5AzGVJh3BSfvLjK7IK4YYRXXLt1Oq9KS6pv2samYgRTTTXsxhmVpDjiYF3Xo/gfXIXA==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-sdk/types": "^3.4.1",
         "@smithy/service-error-classification": "^2.0.4",
@@ -23785,7 +23768,6 @@
       "resolved": "https://registry.npmjs.org/aws-xray-sdk-core/-/aws-xray-sdk-core-3.10.2.tgz",
       "integrity": "sha512-hAFEB+Stqm4FoQmIuyw5AzGVJh3BSfvLjK7IK4YYRXXLt1Oq9KS6pv2samYgRTTTXsxhmVpDjiYF3Xo/gfXIXA==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-sdk/types": "^3.4.1",
         "@smithy/service-error-classification": "^2.0.4",
@@ -24761,7 +24743,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-dynamodb/-/client-dynamodb-3.859.0.tgz",
       "integrity": "sha512-Bt840uICsGcn7IFewif8ARCF0CxtdTx9DX/LfUGRI+SVZcqyeEccmH2JJRRzThtEzKTXr+rCN6yaNB3c4RQY2g==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -27053,7 +27034,6 @@
       "resolved": "https://registry.npmjs.org/aws-xray-sdk-core/-/aws-xray-sdk-core-3.10.2.tgz",
       "integrity": "sha512-hAFEB+Stqm4FoQmIuyw5AzGVJh3BSfvLjK7IK4YYRXXLt1Oq9KS6pv2samYgRTTTXsxhmVpDjiYF3Xo/gfXIXA==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-sdk/types": "^3.4.1",
         "@smithy/service-error-classification": "^2.0.4",
@@ -27370,7 +27350,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-sts/-/client-sts-3.726.1.tgz",
       "integrity": "sha512-qh9Q9Vu1hrM/wMBOBIaskwnE4GTFaZu26Q6WHwyWNfj7J8a40vBxpW16c2vYXHLBtwRKM1be8uRLkmDwghpiNw==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -30110,7 +30089,6 @@
       "resolved": "https://registry.npmjs.org/aws-xray-sdk-core/-/aws-xray-sdk-core-3.10.2.tgz",
       "integrity": "sha512-hAFEB+Stqm4FoQmIuyw5AzGVJh3BSfvLjK7IK4YYRXXLt1Oq9KS6pv2samYgRTTTXsxhmVpDjiYF3Xo/gfXIXA==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-sdk/types": "^3.4.1",
         "@smithy/service-error-classification": "^2.0.4",
@@ -30233,7 +30211,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-dynamodb/-/client-dynamodb-3.859.0.tgz",
       "integrity": "sha512-Bt840uICsGcn7IFewif8ARCF0CxtdTx9DX/LfUGRI+SVZcqyeEccmH2JJRRzThtEzKTXr+rCN6yaNB3c4RQY2g==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -31774,7 +31751,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-sts/-/client-sts-3.726.1.tgz",
       "integrity": "sha512-qh9Q9Vu1hrM/wMBOBIaskwnE4GTFaZu26Q6WHwyWNfj7J8a40vBxpW16c2vYXHLBtwRKM1be8uRLkmDwghpiNw==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -32914,7 +32890,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-dynamodb/-/client-dynamodb-3.859.0.tgz",
       "integrity": "sha512-Bt840uICsGcn7IFewif8ARCF0CxtdTx9DX/LfUGRI+SVZcqyeEccmH2JJRRzThtEzKTXr+rCN6yaNB3c4RQY2g==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -37039,7 +37014,6 @@
       "resolved": "https://registry.npmjs.org/aws-xray-sdk-core/-/aws-xray-sdk-core-3.10.2.tgz",
       "integrity": "sha512-hAFEB+Stqm4FoQmIuyw5AzGVJh3BSfvLjK7IK4YYRXXLt1Oq9KS6pv2samYgRTTTXsxhmVpDjiYF3Xo/gfXIXA==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-sdk/types": "^3.4.1",
         "@smithy/service-error-classification": "^2.0.4",
@@ -37382,7 +37356,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-sts/-/client-sts-3.726.1.tgz",
       "integrity": "sha512-qh9Q9Vu1hrM/wMBOBIaskwnE4GTFaZu26Q6WHwyWNfj7J8a40vBxpW16c2vYXHLBtwRKM1be8uRLkmDwghpiNw==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -38366,9 +38339,9 @@
       "license": "MIT"
     },
     "node_modules/@adobe/spacecat-shared-rum-api-client": {
-      "version": "2.38.6",
-      "resolved": "https://registry.npmjs.org/@adobe/spacecat-shared-rum-api-client/-/spacecat-shared-rum-api-client-2.38.6.tgz",
-      "integrity": "sha512-rgpADIypnGZkycirHuQ1+zKUNX6pD6kbAsC6wNfQ3ZTdwJUEzERjzRII3cEcfwI7TzT1FFba6R/T+36LFltQuw==",
+      "version": "2.38.7",
+      "resolved": "https://registry.npmjs.org/@adobe/spacecat-shared-rum-api-client/-/spacecat-shared-rum-api-client-2.38.7.tgz",
+      "integrity": "sha512-aMC1hvfxu6zj0jYS+y+jccvu5TZMXPb51Z2e8JPTFjGPjzyVX7/CCEprbxX1+2zMBuhwHpWZj7d5WEpkljcqoA==",
       "license": "Apache-2.0",
       "dependencies": {
         "@adobe/fetch": "4.2.3",
@@ -39616,7 +39589,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-sts/-/client-sts-3.726.1.tgz",
       "integrity": "sha512-qh9Q9Vu1hrM/wMBOBIaskwnE4GTFaZu26Q6WHwyWNfj7J8a40vBxpW16c2vYXHLBtwRKM1be8uRLkmDwghpiNw==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -40499,7 +40471,6 @@
       "resolved": "https://registry.npmjs.org/aws-xray-sdk-core/-/aws-xray-sdk-core-3.10.2.tgz",
       "integrity": "sha512-hAFEB+Stqm4FoQmIuyw5AzGVJh3BSfvLjK7IK4YYRXXLt1Oq9KS6pv2samYgRTTTXsxhmVpDjiYF3Xo/gfXIXA==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-sdk/types": "^3.4.1",
         "@smithy/service-error-classification": "^2.0.4",
@@ -42346,7 +42317,6 @@
       "resolved": "https://registry.npmjs.org/aws-xray-sdk-core/-/aws-xray-sdk-core-3.10.2.tgz",
       "integrity": "sha512-hAFEB+Stqm4FoQmIuyw5AzGVJh3BSfvLjK7IK4YYRXXLt1Oq9KS6pv2samYgRTTTXsxhmVpDjiYF3Xo/gfXIXA==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-sdk/types": "^3.4.1",
         "@smithy/service-error-classification": "^2.0.4",
@@ -42469,7 +42439,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-dynamodb/-/client-dynamodb-3.859.0.tgz",
       "integrity": "sha512-Bt840uICsGcn7IFewif8ARCF0CxtdTx9DX/LfUGRI+SVZcqyeEccmH2JJRRzThtEzKTXr+rCN6yaNB3c4RQY2g==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -44010,7 +43979,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-sts/-/client-sts-3.726.1.tgz",
       "integrity": "sha512-qh9Q9Vu1hrM/wMBOBIaskwnE4GTFaZu26Q6WHwyWNfj7J8a40vBxpW16c2vYXHLBtwRKM1be8uRLkmDwghpiNw==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -46184,7 +46152,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-sts/-/client-sts-3.726.1.tgz",
       "integrity": "sha512-qh9Q9Vu1hrM/wMBOBIaskwnE4GTFaZu26Q6WHwyWNfj7J8a40vBxpW16c2vYXHLBtwRKM1be8uRLkmDwghpiNw==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -47067,7 +47034,6 @@
       "resolved": "https://registry.npmjs.org/aws-xray-sdk-core/-/aws-xray-sdk-core-3.10.2.tgz",
       "integrity": "sha512-hAFEB+Stqm4FoQmIuyw5AzGVJh3BSfvLjK7IK4YYRXXLt1Oq9KS6pv2samYgRTTTXsxhmVpDjiYF3Xo/gfXIXA==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-sdk/types": "^3.4.1",
         "@smithy/service-error-classification": "^2.0.4",
@@ -48316,7 +48282,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-sts/-/client-sts-3.726.1.tgz",
       "integrity": "sha512-qh9Q9Vu1hrM/wMBOBIaskwnE4GTFaZu26Q6WHwyWNfj7J8a40vBxpW16c2vYXHLBtwRKM1be8uRLkmDwghpiNw==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -49199,7 +49164,6 @@
       "resolved": "https://registry.npmjs.org/aws-xray-sdk-core/-/aws-xray-sdk-core-3.10.2.tgz",
       "integrity": "sha512-hAFEB+Stqm4FoQmIuyw5AzGVJh3BSfvLjK7IK4YYRXXLt1Oq9KS6pv2samYgRTTTXsxhmVpDjiYF3Xo/gfXIXA==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-sdk/types": "^3.4.1",
         "@smithy/service-error-classification": "^2.0.4",
@@ -50856,7 +50820,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-dynamodb/-/client-dynamodb-3.917.0.tgz",
       "integrity": "sha512-PPOyDwlg59ESbj/Ur8VKRvlW6GRViThykNCg5qjCuejiEQ8F1j+0yPxIa+H0x6iklDZF/+AiERtLpmZh3UjD0g==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -52864,7 +52827,6 @@
       "resolved": "https://registry.npmjs.org/@aws-sdk/client-sso-oidc/-/client-sso-oidc-3.726.0.tgz",
       "integrity": "sha512-5JzTX9jwev7+y2Jkzjz0pd1wobB5JQfPOQF3N2DrJ5Pao0/k6uRYwE4NqB0p0HlGrMTDm7xNq7OSPPIPG575Jw==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
@@ -56058,7 +56020,6 @@
       "integrity": "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.27.1",
         "@babel/generator": "^7.28.5",
@@ -56467,7 +56428,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=18"
       },
@@ -56490,7 +56450,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=18"
       }
@@ -57872,7 +57831,6 @@
       "integrity": "sha512-jOT8V1Ba5BdC79sKrRWDdMT5l1R+XNHTPR6CPWzUP2EcfAcvIHZWF0eAbmRcpOOP5gVIwnqNg0C4nvh6Abc3OA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@octokit/auth-token": "^6.0.0",
         "@octokit/graphql": "^9.0.1",
@@ -58169,7 +58127,6 @@
       "integrity": "sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==",
       "dev": true,
       "license": "Apache-2.0",
-      "peer": true,
       "engines": {
         "node": ">=8.0.0"
       }
@@ -60548,7 +60505,6 @@
       "integrity": "sha512-BnOroVl1SgrPLywqxyqdJ4l3S2MsKVLDVxZvjI1Eoe8ev2r3kGDo+PcMihNmDE+6/KjkTubSJnmqGZZjQSBq/g==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@typescript-eslint/scope-manager": "8.46.2",
         "@typescript-eslint/types": "8.46.2",
@@ -61006,7 +60962,6 @@
       "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -61053,7 +61008,6 @@
       "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.3",
         "fast-uri": "^3.0.1",
@@ -61531,7 +61485,6 @@
       "resolved": "https://registry.npmjs.org/aws-xray-sdk-core/-/aws-xray-sdk-core-3.10.3.tgz",
       "integrity": "sha512-bltsLAr4juMJJ2tT5/L/CtwUGIvHihtPe6SO/z3jjOD73PHhOYxcuwCMFFyTbTy5S4WThJO32oZk7r+pg3ZoCQ==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-sdk/types": "^3.4.1",
         "@smithy/service-error-classification": "^2.0.4",
@@ -61642,7 +61595,6 @@
       "resolved": "https://registry.npmjs.org/aws-xray-sdk-core/-/aws-xray-sdk-core-3.11.0.tgz",
       "integrity": "sha512-b7RRs3/twrsCxb113ZgycyaYcXJUQADFMKTiAfzRJu/2hBD2UZkyrjrh8BNTwQ5PUJJmHLoapv1uhpJFk3qKvQ==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@aws-sdk/types": "^3.4.1",
         "@aws/lambda-invoke-store": "^0.0.1",
@@ -62016,7 +61968,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.8.2",
         "caniuse-lite": "^1.0.30001741",
@@ -62273,7 +62224,6 @@
       "integrity": "sha512-aUTnJc/JipRzJrNADXVvpVqi6CO0dn3nx4EVPxijri+fj3LUUDyZQOgVeW54Ob3Y1Xh9Iz8f+CgaCl8v0mn9bA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=18"
       }
@@ -64530,7 +64480,6 @@
       "integrity": "sha512-t5aPOpmtJcZcz5UJyY2GbvpDlsK5E8JqRqoKtfiKE3cNh437KIqfJr3A3AKf5k64NPx6d0G3dno6XDY05PqPtw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.8.0",
         "@eslint-community/regexpp": "^4.12.1",
@@ -69139,7 +69088,6 @@
       "integrity": "sha512-PRsaiG84bK+AMvxziE/lCFss8juXjNaWzVbN5tXAm4XjeaS9NAHhop+PjQxz2A9h8Q4M/xGmzP8vqNwy6JeK0A==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "bin": {
         "marked": "bin/marked.js"
       },
@@ -70206,7 +70154,6 @@
       "integrity": "sha512-aChaVU/DO5aRPmk1GX8L+whocagUUpBQqoPtJk+cm7UOXUk87J4PeWCh6nNmTTIfEhiR9DI/+FnA8dln/hTK7g==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/mobx"
@@ -73228,7 +73175,6 @@
       "dev": true,
       "inBundle": true,
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -74827,7 +74773,6 @@
       "integrity": "sha512-w8nqGImo45dmMIfljjMwOGtbmC/mk4CMYhWIicdSflH91J9TyCyczcPFXJzrZ/ZXcgGRFeP6BU0BEJTw6tZdfQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -74838,7 +74783,6 @@
       "integrity": "sha512-Dlq/5LAZgF0Gaz6yiqZCf6VCcZs1ghAJyrsu84Q/GT0gV+mCxbfmKNoGRKBYMJ8IEdGPqu49YWXD02GCknEDkw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "scheduler": "^0.26.0"
       },
@@ -75558,7 +75502,6 @@
       "integrity": "sha512-0OCYLm0AfVilNGukM+w0C4aptITfuW1Mhvmz8LQliLeYbPOTFRCIJzoltWWx/F5zVFe6np9eNatBUHdAvMFeZg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@semantic-release/commit-analyzer": "^13.0.1",
         "@semantic-release/error": "^4.0.0",
@@ -76989,7 +76932,6 @@
       "integrity": "sha512-1v/e3Dl1BknC37cXMhwGomhO8AkYmN41CqyX9xhUDxry1ns3BFQy2lLDRQXJRdVVWB9OHemv/53xaStimvWyuA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@emotion/is-prop-valid": "1.2.2",
         "@emotion/unitless": "0.8.1",
@@ -77695,7 +77637,6 @@
       "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -78068,7 +78009,6 @@
       "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
       "dev": true,
       "license": "Apache-2.0",
-      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -78167,7 +78107,6 @@
       "resolved": "https://registry.npmjs.org/unified/-/unified-11.0.5.tgz",
       "integrity": "sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@types/unist": "^3.0.0",
         "bail": "^2.0.0",
diff --git a/package.json b/package.json
index d05a71d44..43d46617a 100755
--- a/package.json
+++ b/package.json
@@ -86,7 +86,7 @@
     "@adobe/spacecat-shared-gpt-client": "1.6.7",
     "@adobe/spacecat-shared-http-utils": "1.17.9",
     "@adobe/spacecat-shared-ims-client": "1.9.1",
-    "@adobe/spacecat-shared-rum-api-client": "2.38.8",
+    "@adobe/spacecat-shared-rum-api-client": "2.38.7",
     "@adobe/spacecat-shared-rum-api-client-v1": "npm:@adobe/spacecat-shared-rum-api-client@1.8.4",
     "@adobe/spacecat-shared-scrape-client": "2.1.7",
     "@adobe/spacecat-shared-slack-client": "1.5.28",

From 0011fc94b3df95ec257402e0a5909807f7db971e Mon Sep 17 00:00:00 2001
From: Diana Preda <dpreda@adobe.com>
Date: Mon, 3 Nov 2025 11:20:24 +0200
Subject: [PATCH 20/20] fixed test

---
 test/audits/forms/accessibility-handler.test.js | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/test/audits/forms/accessibility-handler.test.js b/test/audits/forms/accessibility-handler.test.js
index b544e4630..e46cbcfc9 100644
--- a/test/audits/forms/accessibility-handler.test.js
+++ b/test/audits/forms/accessibility-handler.test.js
@@ -70,6 +70,7 @@ describe('Forms Opportunities - Accessibility Handler', () => {
 
       const newOpportunity = {
         getId: () => 'new-opportunity-id',
+        getType: () => 'form-accessibility',
         getTags: () => ['Forms Accessibility'],
         getData: () => ({
           accessibility: [{
@@ -93,19 +94,23 @@ describe('Forms Opportunities - Accessibility Handler', () => {
         addSuggestions: sandbox.stub().resolves({ id: 'sugg-1' }),
       };
 
+      const mockSite = {
+        getId: sinon.stub().returns('test-site-id'),
+        getDeliveryType: sinon.stub().returns('aem'),
+        getBaseURL: sinon.stub().returns('https://example.com'),
+      };
+
       const context = new MockContextBuilder()
         .withSandbox(sandbox)
         .withOverrides({
+          site: mockSite,
           dataAccess: {
             Opportunity: {
               create: sandbox.stub().resolves(newOpportunity),
               findById: sandbox.stub().resolves(null), // No existing opportunity with this ID
             },
             Site: {
-              findById: sandbox.stub().resolves({
-                getDeliveryType: sinon.stub().returns('aem'),
-                getBaseURL: sinon.stub().returns('https://example.com'),
-              }),
+              findById: sandbox.stub().resolves(mockSite),
             },
           },
           sqs: {