codeceptjs 3.7.6-beta.1 → 3.7.6-beta.3

package/lib/codecept.js

@@ -122,6 +122,7 @@ class Codecept {
   /**
    * Executes bootstrap.
    *
+   * @returns {Promise<void>}
    */
   async bootstrap() {
     return runHook(this.config.bootstrap, 'bootstrap')
@@ -129,7 +130,8 @@ class Codecept {
 
   /**
    * Executes teardown.
-
+   *
+   * @returns {Promise<void>}
    */
   async teardown() {
     return runHook(this.config.teardown, 'teardown')
@@ -262,6 +264,11 @@ class Codecept {
     })
   }
 
+  /**
+   * Returns the version string of CodeceptJS.
+   *
+   * @returns {string} The version string.
+   */
   static version() {
     return JSON.parse(readFileSync(`${__dirname}/../package.json`, 'utf8')).version
   }

package/lib/command/workers/runTests.js

@@ -23,11 +23,49 @@ const Codecept = require(process.env.CODECEPT_CLASS_PATH || '../../codecept')
 const { options, tests, testRoot, workerIndex, poolMode } = workerData
 
 // hide worker output
-if (!options.debug && !options.verbose)
+// In pool mode, only suppress output if debug is NOT enabled
+// In regular mode, hide result output but allow step output in verbose/debug
+if (poolMode && !options.debug) {
+  // In pool mode without debug, suppress only result summaries and failures, but allow Scenario Steps
+  const originalWrite = process.stdout.write
+  process.stdout.write = string => {
+    // Always allow Scenario Steps output (including the circle symbol)
+    if (string.includes('Scenario Steps:') || string.includes('◯ Scenario Steps:')) {
+      return originalWrite.call(process.stdout, string)
+    }
+    if (string.includes('  FAIL  |') || string.includes('  OK  |') || string.includes('-- FAILURES:') || string.includes('AssertionError:') || string.includes('◯ File:')) {
+      return true
+    }
+    return originalWrite.call(process.stdout, string)
+  }
+} else if (!poolMode && !options.debug && !options.verbose) {
   process.stdout.write = string => {
     stdout += string
     return true
   }
+} else {
+  // In verbose/debug mode for test/suite modes, show step details
+  // but suppress individual worker result summaries to avoid duplicate output
+  const originalWrite = process.stdout.write
+  const originalConsoleLog = console.log
+
+  process.stdout.write = string => {
+    // Suppress individual worker result summaries and failure reports
+    if (string.includes('  FAIL  |') || string.includes('  OK  |') || string.includes('-- FAILURES:') || string.includes('AssertionError:') || string.includes('◯ File:') || string.includes('◯ Scenario Steps:')) {
+      return true
+    }
+    return originalWrite.call(process.stdout, string)
+  }
+
+  // Override console.log to catch result summaries
+  console.log = (...args) => {
+    const fullMessage = args.join(' ')
+    if (fullMessage.includes('  FAIL  |') || fullMessage.includes('  OK  |') || fullMessage.includes('-- FAILURES:')) {
+      return
+    }
+    return originalConsoleLog.apply(console, args)
+  }
+}
 
 const overrideConfigs = tryOrDefault(() => JSON.parse(options.override), {})
 

package/lib/event.js

@@ -2,13 +2,22 @@ const debug = require('debug')('codeceptjs:event')
 const events = require('events')
 const { error } = require('./output')
 
+const MAX_LISTENERS = 200
+
 const dispatcher = new events.EventEmitter()
 
-dispatcher.setMaxListeners(50)
+dispatcher.setMaxListeners(MAX_LISTENERS)
+
+// Increase process max listeners to prevent warnings for beforeExit and other events
+if (typeof process.setMaxListeners === 'function') {
+  process.setMaxListeners(MAX_LISTENERS)
+}
+
 /**
  * @namespace
  * @alias event
  */
+
 module.exports = {
   /**
    * @type {NodeJS.EventEmitter}

package/lib/helper/Appium.js

@@ -261,11 +261,13 @@ class Appium extends Webdriver {
 
     this.platform = null
     if (config.capabilities[`${vendorPrefix.appium}:platformName`]) {
-      this.platform = config.capabilities[`${vendorPrefix.appium}:platformName`].toLowerCase()
+      config.capabilities[`${vendorPrefix.appium}:platformName`] = config.capabilities[`${vendorPrefix.appium}:platformName`].toLowerCase()
+      this.platform = config.capabilities[`${vendorPrefix.appium}:platformName`]
     }
 
     if (config.capabilities.platformName) {
-      this.platform = config.capabilities.platformName.toLowerCase()
+      config.capabilities.platformName = config.capabilities.platformName.toLowerCase()
+      this.platform = config.capabilities.platformName
     }
 
     return config
@@ -389,6 +391,29 @@ class Appium extends Webdriver {
     return `${protocol}://${hostname}:${port}${normalizedPath}/session/${this.browser.sessionId}`
   }
 
+  /**
+   * Helper method to safely call isDisplayed() on mobile elements.
+   * Handles the case where webdriverio tries to use execute/sync which isn't supported in Appium.
+   * @private
+   */
+  async _isDisplayedSafe(element) {
+    if (this.isWeb) {
+      // For web contexts, use the normal isDisplayed
+      return element.isDisplayed()
+    }
+
+    try {
+      return await element.isDisplayed()
+    } catch (err) {
+      // If isDisplayed fails due to execute/sync not being supported in native mobile contexts,
+      // fall back to assuming the element is displayed (since we found it)
+      if (err.message && err.message.includes('Method is not implemented')) {
+        return true
+      }
+      throw err
+    }
+  }
+
   /**
    * Execute code only on iOS
    *
@@ -617,6 +642,7 @@ class Appium extends Webdriver {
    */
   async resetApp() {
     onlyForApps.call(this)
+    this.isWeb = false // Reset to native context after app reset
     return this.axios({
       method: 'post',
       url: `${this._buildAppiumEndpoint()}/appium/app/reset`,
@@ -1132,7 +1158,7 @@ class Appium extends Webdriver {
         ],
       },
     ])
-    await this.browser.pause(1000)
+    await this.browser.pause(2000)
   }
 
   /**
@@ -1294,28 +1320,26 @@ class Appium extends Webdriver {
     let currentSource
     return browser
       .waitUntil(
-        () => {
+        async () => {
           if (err) {
             return new Error(`Scroll to the end and element ${searchableLocator} was not found`)
           }
-          return browser
-            .$$(parseLocator.call(this, searchableLocator))
-            .then(els => els.length && els[0].isDisplayed())
-            .then(res => {
-              if (res) {
-                return true
-              }
-              return this[direction](scrollLocator, offset, speed)
-                .getSource()
-                .then(source => {
-                  if (source === currentSource) {
-                    err = true
-                  } else {
-                    currentSource = source
-                    return false
-                  }
-                })
-            })
+          const els = await browser.$$(parseLocator.call(this, searchableLocator))
+          if (els.length) {
+            const displayed = await this._isDisplayedSafe(els[0])
+            if (displayed) {
+              return true
+            }
+          }
+
+          await this[direction](scrollLocator, offset, speed)
+          const source = await this.browser.getPageSource()
+          if (source === currentSource) {
+            err = true
+          } else {
+            currentSource = source
+            return false
+          }
         },
         timeout * 1000,
         errorMsg,
@@ -1521,7 +1545,28 @@ class Appium extends Webdriver {
    */
   async dontSeeElement(locator) {
     if (this.isWeb) return super.dontSeeElement(locator)
-    return super.dontSeeElement(parseLocator.call(this, locator))
+
+    // For mobile native apps, use safe isDisplayed wrapper
+    const parsedLocator = parseLocator.call(this, locator)
+    const res = await this._locate(parsedLocator, false)
+    const { truth } = require('../assert/truth')
+    const Locator = require('../locator')
+
+    if (!res || res.length === 0) {
+      return truth(`elements of ${new Locator(parsedLocator)}`, 'to be seen').negate(false)
+    }
+
+    const selected = []
+    for (const el of res) {
+      const displayed = await this._isDisplayedSafe(el)
+      if (displayed) selected.push(true)
+    }
+
+    try {
+      return truth(`elements of ${new Locator(parsedLocator)}`, 'to be seen').negate(selected)
+    } catch (err) {
+      throw err
+    }
   }
 
   /**
@@ -1575,7 +1620,18 @@ class Appium extends Webdriver {
    */
   async grabNumberOfVisibleElements(locator) {
     if (this.isWeb) return super.grabNumberOfVisibleElements(locator)
-    return super.grabNumberOfVisibleElements(parseLocator.call(this, locator))
+
+    // For mobile native apps, use safe isDisplayed wrapper
+    const parsedLocator = parseLocator.call(this, locator)
+    const res = await this._locate(parsedLocator)
+
+    const selected = []
+    for (const el of res) {
+      const displayed = await this._isDisplayedSafe(el)
+      if (displayed) selected.push(true)
+    }
+
+    return selected.length
   }
 
   /**
@@ -1654,7 +1710,30 @@ class Appium extends Webdriver {
    */
   async seeElement(locator) {
     if (this.isWeb) return super.seeElement(locator)
-    return super.seeElement(parseLocator.call(this, locator))
+
+    // For mobile native apps, use safe isDisplayed wrapper
+    const parsedLocator = parseLocator.call(this, locator)
+    const res = await this._locate(parsedLocator, true)
+    const ElementNotFound = require('./errors/ElementNotFound')
+    const { truth } = require('../assert/truth')
+    const { dontSeeElementError } = require('./errors/ElementAssertion')
+    const Locator = require('../locator')
+
+    if (!res || res.length === 0) {
+      throw new ElementNotFound(parsedLocator)
+    }
+
+    const selected = []
+    for (const el of res) {
+      const displayed = await this._isDisplayedSafe(el)
+      if (displayed) selected.push(true)
+    }
+
+    try {
+      return truth(`elements of ${new Locator(parsedLocator)}`, 'to be seen').assert(selected)
+    } catch (e) {
+      dontSeeElementError(parsedLocator)
+    }
   }
 
   /**
@@ -1701,7 +1780,30 @@ class Appium extends Webdriver {
    */
   async waitForVisible(locator, sec = null) {
     if (this.isWeb) return super.waitForVisible(locator, sec)
-    return super.waitForVisible(parseLocator.call(this, locator), sec)
+
+    // For mobile native apps, use safe isDisplayed wrapper
+    const parsedLocator = parseLocator.call(this, locator)
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+    const Locator = require('../locator')
+
+    return this.browser.waitUntil(
+      async () => {
+        const res = await this._res(parsedLocator)
+        if (!res || res.length === 0) return false
+
+        const selected = []
+        for (const el of res) {
+          const displayed = await this._isDisplayedSafe(el)
+          if (displayed) selected.push(true)
+        }
+
+        return selected.length > 0
+      },
+      {
+        timeout: aSec * 1000,
+        timeoutMsg: `element (${new Locator(parsedLocator)}) still not visible after ${aSec} sec`,
+      },
+    )
   }
 
   /**
@@ -1710,7 +1812,27 @@ class Appium extends Webdriver {
    */
   async waitForInvisible(locator, sec = null) {
     if (this.isWeb) return super.waitForInvisible(locator, sec)
-    return super.waitForInvisible(parseLocator.call(this, locator), sec)
+
+    // For mobile native apps, use safe isDisplayed wrapper
+    const parsedLocator = parseLocator.call(this, locator)
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+    const Locator = require('../locator')
+
+    return this.browser.waitUntil(
+      async () => {
+        const res = await this._res(parsedLocator)
+        if (!res || res.length === 0) return true
+
+        const selected = []
+        for (const el of res) {
+          const displayed = await this._isDisplayedSafe(el)
+          if (displayed) selected.push(true)
+        }
+
+        return selected.length === 0
+      },
+      { timeout: aSec * 1000, timeoutMsg: `element (${new Locator(parsedLocator)}) still visible after ${aSec} sec` },
+    )
   }
 
   /**

package/lib/helper/Playwright.js

@@ -98,7 +98,13 @@ const pathSeparator = path.sep
  * @prop {boolean} [highlightElement] - highlight the interacting elements. Default: false. Note: only activate under verbose mode (--verbose).
  * @prop {object} [recordHar] - record HAR and will be saved to `output/har`. See more of [HAR options](https://playwright.dev/docs/api/class-browser#browser-new-context-option-record-har).
  * @prop {string} [testIdAttribute=data-testid] - locate elements based on the testIdAttribute. See more of [locate by test id](https://playwright.dev/docs/locators#locate-by-test-id).
- * @prop {object} [customLocatorStrategies] - custom locator strategies. An object with keys as strategy names and values as JavaScript functions. Example: `{ byRole: (selector, root) => { return root.querySelector(\`[role="\${selector}\"]\`) } }`
+ * @prop {object} [customLocatorStrategies] - custom locator strategies. An object with keys as strategy names and values as JavaScript functions. Example: `{ byRole: (selector, root) => { return root.querySelector(`[role="${selector}"]`) } }`
+ * @prop {string|object} [storageState] - Playwright storage state (path to JSON file or object)
+ *   passed directly to `browser.newContext`.
+ *   If a Scenario is declared with a `cookies` option (e.g. `Scenario('name', { cookies: [...] }, fn)`),
+ *   those cookies are used instead and the configured `storageState` is ignored (no merge).
+ *   May include session cookies, auth tokens, localStorage and (if captured with
+ *   `grabStorageState({ indexedDB: true })`) IndexedDB data; treat as sensitive and do not commit.
  */
 const config = {}
 
@@ -360,6 +366,10 @@ class Playwright extends Helper {
     // override defaults with config
     this._setConfig(config)
 
+    // pass storageState directly (string path or object) and let Playwright handle errors/missing file
+    if (typeof config.storageState !== 'undefined') {
+      this.storageState = config.storageState
+    }
   }
 
   _validateConfig(config) {
@@ -386,6 +396,7 @@ class Playwright extends Helper {
       use: { actionTimeout: 0 },
       ignoreHTTPSErrors: false, // Adding it here o that context can be set up to ignore the SSL errors,
       highlightElement: false,
+      storageState: undefined,
     }
 
     process.env.testIdAttribute = 'data-testid'
@@ -589,8 +600,7 @@ class Playwright extends Helper {
 
       // load pre-saved cookies
       if (test?.opts?.cookies) contextOptions.storageState = { cookies: test.opts.cookies }
-
-      if (this.storageState) contextOptions.storageState = this.storageState
+      else if (this.storageState) contextOptions.storageState = this.storageState
       if (this.options.userAgent) contextOptions.userAgent = this.options.userAgent
       if (this.options.locale) contextOptions.locale = this.options.locale
       if (this.options.colorScheme) contextOptions.colorScheme = this.options.colorScheme
@@ -1833,7 +1843,7 @@ class Playwright extends Helper {
 
   /**
    *
-   * _Note:_ Shortcuts like `'Meta'` + `'A'` do not work on macOS ([GoogleChrome/Puppeteer#1313](https://github.com/GoogleChrome/puppeteer/issues/1313)).
+   * _Note:_ Shortcuts like `'Meta'` + `'A'` do not work on macOS ([puppeteer/puppeteer#1313](https://github.com/puppeteer/puppeteer/issues/1313)).
    *
    * {{> pressKeyWithKeyNormalization }}
    */
@@ -2162,6 +2172,30 @@ class Playwright extends Helper {
     if (cookie[0]) return cookie[0]
   }
 
+  /**
+   * Grab the current storage state (cookies, localStorage, etc.) via Playwright's `browserContext.storageState()`.
+   * Returns the raw object that Playwright provides.
+   *
+   * Security: The returned object can contain authentication tokens, session cookies
+   * and (when `indexedDB: true` is used) data that may include user PII. Treat it as a secret.
+   * Avoid committing it to source control and prefer storing it in a protected secrets store / CI artifact vault.
+   *
+   * @param {object} [options]
+   * @param {boolean} [options.indexedDB] set to true to include IndexedDB in snapshot (Playwright >=1.51)
+   *
+   * ```js
+   * // basic usage
+   * const state = await I.grabStorageState();
+   * require('fs').writeFileSync('authState.json', JSON.stringify(state));
+   *
+   * // include IndexedDB when using Firebase Auth, etc.
+   * const stateWithIDB = await I.grabStorageState({ indexedDB: true });
+   * ```
+   */
+  async grabStorageState(options = {}) {
+    return this.browserContext.storageState(options)
+  }
+
   /**
    * {{> clearCookie }}
    */
@@ -3156,7 +3190,7 @@ class Playwright extends Helper {
   /**
    * Waits for navigation to finish. By default, it takes configured `waitForNavigation` option.
    *
-   * See [Playwright's reference](https://playwright.dev/docs/api/class-page?_highlight=waitfornavi#pagewaitfornavigationoptions)
+   * See [Playwright's reference](https://playwright.dev/docs/api/class-page#page-wait-for-navigation)
    *
    * @param {*} options
    */

package/lib/helper/Puppeteer.js

@@ -64,7 +64,7 @@ const consoleLogStore = new Console()
  * @prop {boolean} [keepBrowserState=false] - keep browser state between tests when `restart` is set to false.
  * @prop {boolean} [keepCookies=false] - keep cookies between tests when `restart` is set to false.
  * @prop {number} [waitForAction=100] - how long to wait after click, doubleClick or PressKey actions in ms. Default: 100.
- * @prop {string} [waitForNavigation=load] - when to consider navigation succeeded. Possible options: `load`, `domcontentloaded`, `networkidle0`, `networkidle2`. See [Puppeteer API](https://github.com/GoogleChrome/puppeteer/blob/master/docs/api.md#pagewaitfornavigationoptions). Array values are accepted as well.
+ * @prop {string|string[]} [waitForNavigation=load] - when to consider navigation succeeded. Possible options: `load`, `domcontentloaded`, `networkidle0`, `networkidle2`. See [Puppeteer API](https://github.com/puppeteer/puppeteer/blob/main/docs/api/puppeteer.waitforoptions.md). Array values are accepted as well.
  * @prop {number} [pressKeyDelay=10] - delay between key presses in ms. Used when calling Puppeteers page.type(...) in fillField/appendField
  * @prop {number} [getPageTimeout=30000] - config option to set maximum navigation time in milliseconds. If the timeout is set to 0, then timeout will be disabled.
  * @prop {number} [waitForTimeout=1000] - default wait* timeout in ms.
@@ -72,13 +72,13 @@ const consoleLogStore = new Console()
  * @prop {string} [userAgent] - user-agent string.
  * @prop {boolean} [manualStart=false] - do not start browser before a test, start it manually inside a helper with `this.helpers["Puppeteer"]._startBrowser()`.
  * @prop {string} [browser=chrome] - can be changed to `firefox` when using [puppeteer-firefox](https://codecept.io/helpers/Puppeteer-firefox).
- * @prop {object} [chrome] - pass additional [Puppeteer run options](https://github.com/GoogleChrome/puppeteer/blob/master/docs/api.md#puppeteerlaunchoptions).
+ * @prop {object} [chrome] - pass additional [Puppeteer run options](https://github.com/puppeteer/puppeteer/blob/main/docs/api/puppeteer.launchoptions.md).
  * @prop {boolean} [highlightElement] - highlight the interacting elements. Default: false. Note: only activate under verbose mode (--verbose).
  */
 const config = {}
 
 /**
- * Uses [Google Chrome's Puppeteer](https://github.com/GoogleChrome/puppeteer) library to run tests inside headless Chrome.
+ * Uses [Google Chrome's Puppeteer](https://github.com/puppeteer/puppeteer) library to run tests inside headless Chrome.
  * Browser control is executed via DevTools Protocol (instead of Selenium).
  * This helper works with a browser out of the box with no additional tools required to install.
  *
@@ -1349,7 +1349,7 @@ class Puppeteer extends Helper {
   }
 
   /**
-   * _Note:_ Shortcuts like `'Meta'` + `'A'` do not work on macOS ([GoogleChrome/puppeteer#1313](https://github.com/GoogleChrome/puppeteer/issues/1313)).
+   * _Note:_ Shortcuts like `'Meta'` + `'A'` do not work on macOS ([puppeteer/puppeteer#1313](https://github.com/puppeteer/puppeteer/issues/1313)).
    *
    * {{> pressKeyWithKeyNormalization }}
    */
@@ -2463,7 +2463,7 @@ class Puppeteer extends Helper {
   /**
    * Waits for navigation to finish. By default, takes configured `waitForNavigation` option.
    *
-   * See [Puppeteer's reference](https://github.com/GoogleChrome/puppeteer/blob/master/docs/api.md#pagewaitfornavigationoptions)
+   * See [Puppeteer's reference](https://github.com/puppeteer/puppeteer/blob/main/docs/api/puppeteer.page.waitfornavigation.md)
    *
    * @param {*} opts
    */
@@ -3093,7 +3093,7 @@ async function getClickablePoint(el) {
 }
 
 // List of key values to key definitions
-// https://github.com/GoogleChrome/puppeteer/blob/v1.20.0/lib/USKeyboardLayout.js
+// https://github.com/puppeteer/puppeteer/blob/v1.20.0/lib/USKeyboardLayout.js
 const keyDefinitionMap = {
   0: 'Digit0',
   1: 'Digit1',

package/lib/output.js

@@ -50,7 +50,40 @@ module.exports = {
    */
   process(process) {
     if (process === null) return (outputProcess = '')
-    if (process) outputProcess = String(process).length === 1 ? `[0${process}]` : `[${process}]`
+    if (process) {
+      // Handle objects by converting to empty string or extracting properties
+      let processValue = process
+      if (typeof process === 'object') {
+        // If it's an object, try to extract a numeric value or use empty string
+        processValue = process.id || process.index || process.worker || ''
+      }
+
+      // Check if this is a run-multiple process (contains : or .)
+      // Format: "1.runName:browserName" from run-multiple
+      if (String(processValue).includes(':') || (String(processValue).includes('.') && String(processValue).split('.').length > 1)) {
+        // Keep original format for run-multiple
+        outputProcess = colors.cyan.bold(`[${processValue}]`)
+      } else {
+        // Standard worker format for run-workers
+        const processNum = parseInt(processValue, 10)
+        const processStr = !isNaN(processNum) ? String(processNum).padStart(2, '0') : String(processValue).padStart(2, '0')
+
+        // Assign different colors to different workers for better identification
+        const workerColors = [
+          colors.cyan, // Worker 01 - Cyan
+          colors.magenta, // Worker 02 - Magenta
+          colors.green, // Worker 03 - Green
+          colors.yellow, // Worker 04 - Yellow
+          colors.blue, // Worker 05 - Blue
+          colors.red, // Worker 06 - Red
+          colors.white, // Worker 07 - White
+          colors.gray, // Worker 08 - Gray
+        ]
+        const workerIndex = !isNaN(processNum) ? processNum - 1 : -1
+        const colorFn = workerIndex >= 0 && workerColors[workerIndex % workerColors.length] ? workerColors[workerIndex % workerColors.length] : colors.cyan
+        outputProcess = colorFn.bold(`[Worker ${processStr}]`)
+      }
+    }
     return outputProcess
   },
 
@@ -149,25 +182,38 @@ module.exports = {
      * @param {Mocha.Test} test
      */
     started(test) {
-      print(`  ${colors.magenta.bold(test.title)}`)
+      // Only show feature name in workers mode (when outputProcess is set)
+      const featureName = outputProcess && test.parent?.title ? `${colors.cyan.bold(test.parent.title)} › ` : ''
+      print(`  ${featureName}${colors.magenta.bold(test.title)}`)
     },
     /**
      * @param {Mocha.Test} test
      */
     passed(test) {
-      print(`  ${colors.green.bold(figures.tick)} ${test.title} ${colors.grey(`in ${test.duration}ms`)}`)
+      // Only show feature name in workers mode (when outputProcess is set)
+      const featureName = outputProcess && test.parent?.title ? `${colors.cyan(test.parent.title)} › ` : ''
+      const scenarioName = colors.bold(test.title)
+      const executionTime = colors.cyan(`in ${test.duration}ms`)
+      print(`  ${colors.green.bold(figures.tick)} ${featureName}${scenarioName} ${executionTime}`)
     },
     /**
      * @param {Mocha.Test} test
      */
     failed(test) {
-      print(`  ${colors.red.bold(figures.cross)} ${test.title} ${colors.grey(`in ${test.duration}ms`)}`)
+      // Only show feature name in workers mode (when outputProcess is set)
+      const featureName = outputProcess && test.parent?.title ? `${colors.yellow(test.parent.title)} › ` : ''
+      const scenarioName = colors.bold(test.title)
+      const executionTime = colors.yellow(`in ${test.duration}ms`)
+      print(`  ${colors.red.bold(figures.cross)} ${featureName}${scenarioName} ${executionTime}`)
     },
     /**
      * @param {Mocha.Test} test
      */
     skipped(test) {
-      print(`  ${colors.yellow.bold('S')} ${test.title}`)
+      // Only show feature name in workers mode (when outputProcess is set)
+      const featureName = outputProcess && test.parent?.title ? `${colors.gray(test.parent.title)} › ` : ''
+      const scenarioName = colors.bold(test.title)
+      print(`  ${colors.yellow.bold('S')} ${featureName}${scenarioName}`)
     },
   },