diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml
index bb09719d..319290ea 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -45,7 +45,10 @@ body:
         - allure-jsonunit
         - allure-junit-platform
         - allure-junit4
+        - allure-jupiter
+        - allure-jupiter-assert
         - allure-junit5
+        - allure-junit5-assert
         - allure-karate
         - allure-okhttp
         - allure-okhttp3
diff --git a/.github/labeler.yml b/.github/labeler.yml
index a419c97f..367271a0 100644
--- a/.github/labeler.yml
+++ b/.github/labeler.yml
@@ -48,8 +48,8 @@
   - "allure-junit4-aspect/**"
 
 "theme:junit-platform":
-  - "allure-junit5/**"
-  - "allure-junit5-assert/**"
+  - "allure-jupiter/**"
+  - "allure-jupiter-assert/**"
   - "allure-junit-platform/**"
 
 "theme:karate":
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 8f537bc9..341788f5 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -13,22 +13,83 @@ on:
       - 'main'
       - 'hotfix-*'
 
+concurrency:
+  # On main, we don't want any jobs cancelled.
+  # On PR branches, we cancel the job if new commits are pushed.
+  group: ${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
 jobs:
   build:
     name: "Build"
     runs-on: ubuntu-latest
+    env:
+      ALLURE_MATRIX_ENV: ubuntu-jdk-21
+      ALLURE_TEST_DUMP_NAME: allure-results-test-jdk-21
     steps:
       - uses: actions/checkout@v6
 
+      - uses: actions/setup-node@v6
+        with:
+          node-version: '20.x'
+
       - name: "Set up JDK"
         uses: actions/setup-java@v5
         with:
           distribution: 'zulu'
           java-version: 21
 
+      - name: "Setup Gradle"
+        uses: gradle/actions/setup-gradle@v6
+        with:
+          gradle-version: 'wrapper'
+
       - name: "Build with Gradle"
         run: ./gradlew build -x test --scan
 
-      - name: "Run tests"
+      - name: "Run tests with Allure"
         if: always()
-        run: ./gradlew --no-build-cache cleanTest test
+        run: npx -y allure@3 run --config ./allurerc.mjs --rerun 2 --environment="${{ env.ALLURE_MATRIX_ENV }}" --dump="${{ env.ALLURE_TEST_DUMP_NAME }}" -- ./gradlew --no-build-cache cleanTest test
+
+      - name: "Upload Allure test dump"
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: ${{ env.ALLURE_TEST_DUMP_NAME }}
+          path: ./${{ env.ALLURE_TEST_DUMP_NAME }}.zip
+
+  report:
+    needs: [build]
+    name: "Build report"
+    runs-on: ubuntu-latest
+    if: always()
+    permissions:
+      contents: read
+      pull-requests: write
+      checks: write
+    env:
+      ALLURE_SERVICE_TOKEN: ${{ secrets.ALLURE_SERVICE_TOKEN }}
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: actions/setup-node@v6
+        with:
+          node-version: '20.x'
+
+      - name: "Download Allure dumps"
+        uses: actions/download-artifact@v8
+        continue-on-error: true
+        with:
+          pattern: allure-results-*
+          path: ./
+          merge-multiple: true
+
+      - name: "Generate Allure report"
+        run: npx -y allure@3 generate --config ./allurerc.mjs --dump="allure-results-*.zip" --output=./build/allure-report
+
+      - name: "Post Allure summary"
+        if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.fork == false
+        uses: allure-framework/allure-action@v0
+        with:
+          report-directory: ./build/allure-report
+          github-token: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
index aeaa9e45..95443a12 100644
--- a/.idea/vcs.xml
+++ b/.idea/vcs.xml
@@ -10,7 +10,4 @@
       </list>
     </option>
   </component>
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
-  </component>
-</project>
+</project>
\ No newline at end of file
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 00000000..8b7a6aa4
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,8 @@
+# Project Guide
+
+Use [Allure Agent Mode](docs/allure-agent-mode.md) for all test-related work in this repository.
+
+- Read `docs/allure-agent-mode.md` before designing, writing, reviewing, validating, debugging, or enriching tests.
+- Run test-executing commands through `allure run`, including smoke checks after small edits.
+- Use `./gradlew` for repo-local test commands and scope runs to the smallest relevant module or task.
+- If agent-mode output is missing or incomplete, debug that first rather than relying on console-only conclusions.
diff --git a/README.md b/README.md
index e452787b..2c6f44a1 100644
--- a/README.md
+++ b/README.md
@@ -37,11 +37,12 @@
 - 📚 Example project — https://github.com/allure-examples?q=topic%3Ajunit4
 - ✅ Generate a project in 10 seconds via Allure Start - https://allurereport.org/start/
 - 
-## JUnit 5
-
-- 🚀 Documentation — https://allurereport.org/docs/junit5/
-- 📚 Example project — https://github.com/allure-examples?q=topic%3Ajunit5
-- ✅ Generate a project in 10 seconds via Allure Start - https://allurereport.org/start/
+## JUnit Jupiter (JUnit 5 and 6)
+
+- 🚀 Documentation — https://allurereport.org/docs/junit5/
+- 📚 Example project — https://github.com/allure-examples?q=topic%3Ajunit5
+- ✅ Generate a project in 10 seconds via Allure Start - https://allurereport.org/start/
+- 🧩 Use `io.qameta.allure:allure-jupiter` for new setups. `allure-junit5` remains available as a deprecated relocation coordinate during migration.
 
 ## Cucumber JVM
 
@@ -76,10 +77,72 @@ SelenideLogger.addListener("AllureSelenide", new AllureSelenide().enableLogs(Log
 https://github.com/SeleniumHQ/selenium/wiki/Logging
 ```
 
-
-## Rest Assured
-
-Filter for rest-assured http client, that generates attachment for allure.
+## Playwright Java
+
+AspectJ-based integration for Playwright Java that reports browser actions as Allure steps and attaches
+Playwright screenshots automatically:
+
+```xml
+<dependency>
+   <groupId>io.qameta.allure</groupId>
+   <artifactId>allure-playwright</artifactId>
+   <version>$LATEST_VERSION</version>
+</dependency>
+```
+
+Enable the AspectJ weaver for automatic action steps:
+```
+-javaagent:/path/to/aspectjweaver.jar
+```
+
+Usage example with Playwright Java JUnit fixtures:
+```java
+@UsePlaywright
+class UiTest {
+
+    @Test
+    void shouldOpenPage(Page page) {
+        page.navigate("https://playwright.dev");
+        page.screenshot();
+    }
+}
+```
+
+The module registers an Allure test lifecycle listener automatically, so per-test cleanup, failure diagnostics,
+and final trace/log flush work with any test framework that reports through Allure. Playwright pages and
+contexts are tracked by the AspectJ integration when they are created or used. Use
+`AllurePlaywright.register(...)` only for pages or contexts the aspect cannot observe.
+
+Frameworks or custom runners that do not use the Allure lifecycle can call the reporting hooks directly:
+```java
+AllurePlaywright.beforeTest();
+try {
+    testBody();
+} catch (Throwable e) {
+    AllurePlaywright.afterTestFailure(e);
+    throw e;
+} finally {
+    AllurePlaywright.afterTest();
+}
+```
+
+The following defaults can be overridden in `allure.properties`:
+```
+allure.playwright.steps.enabled=true
+allure.playwright.steps.mode=actions
+allure.playwright.parameters=redacted
+allure.playwright.screenshots.attach=true
+allure.playwright.failure.screenshot=true
+allure.playwright.failure.page-source=true
+allure.playwright.close.trace=true
+allure.playwright.close.video=true
+allure.playwright.close.page-logs=true
+```
+
+
+## Rest Assured
+
+Filter for rest-assured http client, that generates attachment for allure.
 
 ```xml
 <dependency>
@@ -95,14 +158,50 @@ Usage example:
 ```
 You can specify custom templates, which should be placed in src/main/resources/tpl folder:
 ```
-.filter(new AllureRestAssured()
-        .withRequestTemplate("custom-http-request.ftl")
-        .withResponseTemplate("custom-http-response.ftl"))
-```
-
-## OkHttp
-
-Interceptor for OkHttp client, that generates attachment for allure.
+.filter(new AllureRestAssured()
+        .withRequestTemplate("custom-http-request.ftl")
+        .withResponseTemplate("custom-http-response.ftl"))
+```
+
+## Spring Web
+
+Interceptor for Spring synchronous HTTP clients, that generates attachments for allure.
+
+```xml
+<dependency>
+   <groupId>io.qameta.allure</groupId>
+   <artifactId>allure-spring-web</artifactId>
+   <version>$LATEST_VERSION</version>
+</dependency>
+```
+
+Usage example with `RestClient`:
+```
+RestClient restClient = RestClient.builder()
+        .requestFactory(new BufferingClientHttpRequestFactory(new SimpleClientHttpRequestFactory()))
+        .requestInterceptor(new AllureRestTemplate())
+        .build();
+```
+Use a buffering request factory when the client should still be able to read the response body after Allure captures it.
+
+`RestTemplate` remains supported:
+```
+RestTemplate restTemplate = new RestTemplate(
+        new BufferingClientHttpRequestFactory(new SimpleClientHttpRequestFactory())
+);
+restTemplate.setInterceptors(Collections.singletonList(new AllureRestTemplate()));
+```
+
+You can specify custom templates, which should be placed in src/main/resources/tpl folder:
+```
+new AllureRestTemplate()
+        .setRequestTemplate("custom-http-request.ftl")
+        .setResponseTemplate("custom-http-response.ftl")
+```
+
+## OkHttp
+
+Interceptor for OkHttp client, that generates attachment for allure.
 
 ```xml
 <dependency>
diff --git a/allure-assertj/src/main/java/io/qameta/allure/assertj/AllureAspectJ.java b/allure-assertj/src/main/java/io/qameta/allure/assertj/AllureAspectJ.java
index dbd92dc3..33e2a3de 100644
--- a/allure-assertj/src/main/java/io/qameta/allure/assertj/AllureAspectJ.java
+++ b/allure-assertj/src/main/java/io/qameta/allure/assertj/AllureAspectJ.java
@@ -17,37 +17,27 @@
 
 import io.qameta.allure.Allure;
 import io.qameta.allure.AllureLifecycle;
-import io.qameta.allure.model.Status;
-import io.qameta.allure.model.StepResult;
-import io.qameta.allure.util.ObjectUtils;
 import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.After;
 import org.aspectj.lang.annotation.AfterReturning;
-import org.aspectj.lang.annotation.AfterThrowing;
+import org.aspectj.lang.annotation.Around;
 import org.aspectj.lang.annotation.Aspect;
-import org.aspectj.lang.annotation.Before;
 import org.aspectj.lang.annotation.Pointcut;
 import org.aspectj.lang.reflect.MethodSignature;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import org.assertj.core.api.AbstractAssert;
 
-import java.util.UUID;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-import static io.qameta.allure.util.ResultsUtils.getStatus;
-import static io.qameta.allure.util.ResultsUtils.getStatusDetails;
+import java.util.function.Supplier;
 
 /**
- * @author charlie (Dmitry Baev).
- * @author sskorol (Sergey Korol).
+ * Captures user-side AssertJ factories and fluent calls, then delegates assertion-chain state
+ * to {@link AssertJRecorder}.
+ *
  */
 @SuppressWarnings("all")
 @Aspect
 public class AllureAspectJ {
 
-    private static final Logger LOGGER = LoggerFactory.getLogger(AllureAspectJ.class);
-
     private static InheritableThreadLocal<AllureLifecycle> lifecycle = new InheritableThreadLocal<AllureLifecycle>() {
         @Override
         protected AllureLifecycle initialValue() {
@@ -55,64 +45,117 @@ protected AllureLifecycle initialValue() {
         }
     };
 
-    @Pointcut("execution(!private org.assertj.core.api.AbstractAssert.new(..))")
-    public void anyAssertCreation() {
+    private static final ThreadLocal<AssertJRecorder> RECORDER = ThreadLocal.withInitial(AssertJRecorder::new);
+
+    private static final ThreadLocal<Boolean> RECORDING_MUTED = ThreadLocal.withInitial(() -> false);
+
+    @Pointcut(
+        "("
+                + "call(public static * org.assertj.core.api.Assertions*.assertThat*(..))"
+                + " || call(public static * org.assertj.core.api.BDDAssertions*.then*(..))"
+                + " || call(public * org.assertj.core.api.*SoftAssertionsProvider+.assertThat*(..))"
+                + " || call(public * org.assertj.core.api.*SoftAssertionsProvider+.then*(..))"
+                + ")"
+    )
+
+    /**
+     * Handles the assert factory call callback.
+     */
+    public void assertFactoryCall() {
         //pointcut body, should be empty
     }
 
-    @Pointcut("execution(* org.assertj.core.api.AssertJProxySetup.*(..))")
-    public void proxyMethod() {
+    @Pointcut(
+        "("
+                + "call(public * org.assertj.core.api.AbstractAssert+.*(..))"
+                + " || call(public * org.assertj.core.api.Assert+.*(..))"
+                + " || call(public * org.assertj.core.api.Descriptable+.*(..))"
+                + ")"
+                + " && target(assertion)"
+    )
+
+    /**
+     * Handles the assert operation call callback.
+     *
+     * @param assertion the assertion
+     */
+    public void assertOperationCall(final AbstractAssert<?, ?> assertion) {
         //pointcut body, should be empty
     }
 
-    @Pointcut("execution(public * org.assertj.core.api.AbstractAssert+.*(..)) && !proxyMethod()")
-    public void anyAssert() {
+    /**
+     * Handles the user code call callback.
+     */
+    @Pointcut("!within(org.assertj..*) && !within(io.qameta.allure.assertj.AllureAspectJ)")
+    public void userCodeCall() {
         //pointcut body, should be empty
     }
 
-    @After("anyAssertCreation()")
-    public void logAssertCreation(final JoinPoint joinPoint) {
-        final String actual = joinPoint.getArgs().length > 0
-                ? ObjectUtils.toString(joinPoint.getArgs()[0])
-                : "<?>";
-        final String uuid = UUID.randomUUID().toString();
-        final String name = String.format("assertThat \'%s\'", actual);
+    @AfterReturning(
+            pointcut = "assertFactoryCall() && userCodeCall()",
+            returning = "result"
+    )
 
-        final StepResult result = new StepResult()
-                .setName(name)
-                .setStatus(Status.PASSED);
+    /**
+     * Handles the log assert creation callback.
+     *
+     * @param joinPoint the join point
+     * @param result the model object or framework result to process
+     */
+    public void logAssertCreation(final JoinPoint joinPoint, final Object result) {
+        if (isRecordingMuted() || !(result instanceof AbstractAssert)) {
+            return;
+        }
 
-        getLifecycle().startStep(uuid, result);
-        getLifecycle().stopStep(uuid);
+        final AbstractAssert<?, ?> assertion = (AbstractAssert<?, ?>) result;
+        getRecorder().assertionCreated(getLifecycle(), assertion, firstArgumentOf(joinPoint));
     }
 
-    @Before("anyAssert()")
-    public void stepStart(final JoinPoint joinPoint) {
-        final MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
-
-        final String uuid = UUID.randomUUID().toString();
-        final String name = joinPoint.getArgs().length > 0
-                ? String.format("%s \'%s\'", methodSignature.getName(), arrayToString(joinPoint.getArgs()))
-                : methodSignature.getName();
-
-        final StepResult result = new StepResult()
-                .setName(name);
+    /**
+     * Returns the log assert operation.
+     *
+     * @param joinPoint the join point
+     * @param assertion the assertion
+     * @return the log assert operation
+     * @throws Throwable if the underlying framework operation fails
+     */
+    @Around("assertOperationCall(assertion) && userCodeCall()")
+    public Object logAssertOperation(final ProceedingJoinPoint joinPoint,
+                                     final AbstractAssert<?, ?> assertion)
+            throws Throwable {
+        final String methodName = getMethodName(joinPoint);
+        if (isRecordingMuted() || getRecorder().isIgnored(methodName)) {
+            return joinPoint.proceed();
+        }
 
-        getLifecycle().startStep(uuid, result);
+        final AssertJOperation operation = getRecorder().startOperation(
+                getLifecycle(),
+                assertion,
+                methodName,
+                joinPoint.getArgs()
+        );
+        try {
+            final Object result = joinPoint.proceed();
+            getRecorder().operationPassed(operation, result);
+            return result;
+        } catch (Throwable throwable) {
+            getRecorder().operationFailed(operation, throwable);
+            throw throwable;
+        }
     }
 
-    @AfterThrowing(pointcut = "anyAssert()", throwing = "e")
-    public void stepFailed(final Throwable e) {
-        getLifecycle().updateStep(s -> s
-                .setStatus(getStatus(e).orElse(Status.BROKEN))
-                .setStatusDetails(getStatusDetails(e).orElse(null)));
-        getLifecycle().stopStep();
-    }
+    @After(
+        "execution(public void org.assertj.core.api.DefaultAssertionErrorCollector.collectAssertionError("
+                + "java.lang.AssertionError)) && args(error)"
+    )
 
-    @AfterReturning(pointcut = "anyAssert()")
-    public void stepStop() {
-        getLifecycle().updateStep(s -> s.setStatus(Status.PASSED));
-        getLifecycle().stopStep();
+    /**
+     * Handles the soft assertion failed callback.
+     *
+     * @param error the error reported by the framework
+     */
+    public void softAssertionFailed(final AssertionError error) {
+        getRecorder().softAssertionFailed(error);
     }
 
     /**
@@ -122,15 +165,48 @@ public void stepStop() {
      */
     public static void setLifecycle(final AllureLifecycle allure) {
         lifecycle.set(allure);
+        clearContext();
     }
 
+    /**
+     * Returns the lifecycle.
+     *
+     * @return the Allure lifecycle used by this integration
+     */
     public static AllureLifecycle getLifecycle() {
         return lifecycle.get();
     }
 
-    private static String arrayToString(final Object... array) {
-        return Stream.of(array)
-                .map(ObjectUtils::toString)
-                .collect(Collectors.joining(" "));
+    /**
+     * Handles the clear context callback.
+     */
+    public static void clearContext() {
+        RECORDER.remove();
+    }
+
+    static <T> T withoutRecording(final Supplier<T> supplier) {
+        final boolean previous = RECORDING_MUTED.get();
+        RECORDING_MUTED.set(true);
+        try {
+            return supplier.get();
+        } finally {
+            RECORDING_MUTED.set(previous);
+        }
+    }
+
+    private static AssertJRecorder getRecorder() {
+        return RECORDER.get();
+    }
+
+    private static boolean isRecordingMuted() {
+        return RECORDING_MUTED.get();
+    }
+
+    private static Object firstArgumentOf(final JoinPoint joinPoint) {
+        return joinPoint.getArgs().length == 0 ? null : joinPoint.getArgs()[0];
+    }
+
+    private static String getMethodName(final ProceedingJoinPoint joinPoint) {
+        return ((MethodSignature) joinPoint.getSignature()).getMethod().getName();
     }
 }
diff --git a/allure-assertj/src/main/java/io/qameta/allure/assertj/AssertJChain.java b/allure-assertj/src/main/java/io/qameta/allure/assertj/AssertJChain.java
new file mode 100644
index 00000000..c4d30c75
--- /dev/null
+++ b/allure-assertj/src/main/java/io/qameta/allure/assertj/AssertJChain.java
@@ -0,0 +1,123 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.assertj;
+
+import io.qameta.allure.model.Stage;
+import io.qameta.allure.model.Status;
+import io.qameta.allure.model.StatusDetails;
+import io.qameta.allure.model.StepResult;
+import org.assertj.core.api.AbstractAssert;
+
+import java.util.Optional;
+import java.util.UUID;
+
+/**
+ * Parent Allure step for one AssertJ assertion chain.
+ *
+ * <p>A chain is the stable container for all meaningful fluent operations produced by one AssertJ assertion object.
+ * {@link AssertJRecorder} creates it when user code calls an AssertJ factory such as {@code assertThat(actual)},
+ * stores it by assertion object identity, and appends one {@link AssertJOperation} child for every reported fluent
+ * call. Methods such as {@code extracting}, {@code first}, or {@code asInstanceOf} can return another assertion
+ * object, but they should still read as the same assertion story, so the returned assertion is associated with this
+ * chain instead of creating an unrelated top-level step.</p>
+ *
+ * <p>For a scalar assertion:</p>
+ * <pre>{@code
+ * assertThat("Data").hasSize(4)
+ *
+ * assert "Data"
+ *   has size 4
+ * }</pre>
+ *
+ * <p>For an assertion with a description, the parent step is renamed while the operation history stays visible:</p>
+ * <pre>{@code
+ * assertThat(user).as("user profile").isNotNull()
+ *
+ * assert user profile
+ *   described as "user profile"
+ *   is not null
+ * }</pre>
+ *
+ * <p>For navigation or extraction, later checks remain under the same parent:</p>
+ * <pre>{@code
+ * assertThat(results).extracting(Result::getName).containsExactly("passed")
+ *
+ * assert 1 Result item
+ *   extracts Result::getName -> 1 string
+ *   contains exactly ["passed"]
+ * }</pre>
+ *
+ * <p>This class is intentionally only a small mutable model around the retained {@link StepResult}. It owns the
+ * parent step name, status, timing, and child operation list. It does not decide which AssertJ methods are meaningful
+ * or how subjects and arguments are rendered; those decisions belong to {@link AssertJRecorder},
+ * {@link AssertJMethodSupport}, and {@link AssertJValueRenderer}.</p>
+ */
+final class AssertJChain {
+
+    private static final String ASSERTJ_STEP_PREFIX = "assert ";
+
+    private final String uuid;
+
+    private final AbstractAssert<?, ?> assertion;
+
+    private final StepResult step;
+
+    AssertJChain(final AbstractAssert<?, ?> assertion, final String subject) {
+        this.uuid = UUID.randomUUID().toString();
+        this.assertion = assertion;
+        this.step = new StepResult()
+                .setName(chainName(subject))
+                .setStatus(Status.PASSED)
+                .setStage(Stage.FINISHED)
+                .setStart(System.currentTimeMillis())
+                .setStop(System.currentTimeMillis());
+    }
+
+    String getUuid() {
+        return uuid;
+    }
+
+    AbstractAssert<?, ?> getAssertion() {
+        return assertion;
+    }
+
+    StepResult getStep() {
+        return step;
+    }
+
+    void addOperation(final AssertJOperation operation) {
+        step.getSteps().add(operation.getStep());
+    }
+
+    void rename(final Optional<String> description) {
+        description.ifPresent(value -> step.setName(chainName(value)));
+    }
+
+    void updateStatus(final Status status, final StatusDetails details) {
+        step
+                .setStatus(status)
+                .setStatusDetails(details);
+        finish();
+    }
+
+    void finish() {
+        step.setStop(System.currentTimeMillis());
+    }
+
+    private String chainName(final String subject) {
+        return AssertJValueRenderer.truncateStepName(ASSERTJ_STEP_PREFIX + subject);
+    }
+}
diff --git a/allure-assertj/src/main/java/io/qameta/allure/assertj/AssertJLifecycleListener.java b/allure-assertj/src/main/java/io/qameta/allure/assertj/AssertJLifecycleListener.java
new file mode 100644
index 00000000..d85316e2
--- /dev/null
+++ b/allure-assertj/src/main/java/io/qameta/allure/assertj/AssertJLifecycleListener.java
@@ -0,0 +1,50 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.assertj;
+
+import io.qameta.allure.listener.FixtureLifecycleListener;
+import io.qameta.allure.listener.TestLifecycleListener;
+import io.qameta.allure.model.FixtureResult;
+import io.qameta.allure.model.TestResult;
+
+/**
+ * Clears per-thread AssertJ recorder state after Allure has finished owning the current result.
+ *
+ * <p>{@link AllureAspectJ} keeps an {@link AssertJRecorder} in a {@link ThreadLocal} so assertion objects can
+ * be matched by identity across later fluent calls. Test engines commonly reuse worker threads, so that
+ * thread-local map would otherwise keep old assertion objects, rendered steps, and operation stack state after
+ * the test or fixture result has already been written. The retained {@code StepResult}s are already attached to
+ * the Allure model by reference, so removing the recorder here does not remove any reported steps; it only
+ * releases per-thread bookkeeping before the next test or fixture starts on the same thread.</p>
+ */
+public class AssertJLifecycleListener implements TestLifecycleListener, FixtureLifecycleListener {
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void afterTestWrite(final TestResult result) {
+        AllureAspectJ.clearContext();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void afterFixtureStop(final FixtureResult result) {
+        AllureAspectJ.clearContext();
+    }
+}
diff --git a/allure-assertj/src/main/java/io/qameta/allure/assertj/AssertJMethodSupport.java b/allure-assertj/src/main/java/io/qameta/allure/assertj/AssertJMethodSupport.java
new file mode 100644
index 00000000..455b2803
--- /dev/null
+++ b/allure-assertj/src/main/java/io/qameta/allure/assertj/AssertJMethodSupport.java
@@ -0,0 +1,98 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.assertj;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Keeps method-name decisions out of the aspect and recorder flow.
+ */
+final class AssertJMethodSupport {
+
+    private static final String AS = "as";
+    private static final String DESCRIBED_AS = "describedAs";
+
+    private static final List<String> IGNORED_METHODS = Arrays.asList(
+            "actual",
+            "descriptionText",
+            "equals",
+            "getWritableAssertionInfo",
+            "hashCode",
+            "toString"
+    );
+
+    private static final Set<String> NAVIGATION_METHODS = new HashSet<>(
+            Arrays.asList(
+                    "asBase64Decoded",
+                    "asBoolean",
+                    "asByte",
+                    "asDouble",
+                    "asFloat",
+                    "asInstanceOf",
+                    "asInt",
+                    "asList",
+                    "asLong",
+                    "asShort",
+                    "asString",
+                    "bytes",
+                    "decodedAsBase64",
+                    "element",
+                    "elements",
+                    "extracting",
+                    "extractingResultOf",
+                    "first",
+                    "flatExtracting",
+                    "flatMap",
+                    "last",
+                    "map",
+                    "rootCause",
+                    "singleElement",
+                    "size",
+                    "usingRecursiveAssertion",
+                    "usingRecursiveComparison"
+            )
+    );
+
+    private AssertJMethodSupport() {
+        throw new IllegalStateException("do not instantiate");
+    }
+
+    static boolean isIgnored(final String methodName) {
+        return IGNORED_METHODS.contains(methodName);
+    }
+
+    static String normalize(final String methodName) {
+        final int accessorIndex = methodName.indexOf("$accessor$");
+        if (accessorIndex > 0) {
+            return methodName.substring(0, accessorIndex);
+        }
+        if (DESCRIBED_AS.equals(methodName)) {
+            return AS;
+        }
+        return methodName;
+    }
+
+    static boolean isDescription(final String methodName) {
+        return AS.equals(methodName) || DESCRIBED_AS.equals(methodName);
+    }
+
+    static boolean isNavigation(final String methodName) {
+        return NAVIGATION_METHODS.contains(methodName);
+    }
+}
diff --git a/allure-assertj/src/main/java/io/qameta/allure/assertj/AssertJOperation.java b/allure-assertj/src/main/java/io/qameta/allure/assertj/AssertJOperation.java
new file mode 100644
index 00000000..f06b8be4
--- /dev/null
+++ b/allure-assertj/src/main/java/io/qameta/allure/assertj/AssertJOperation.java
@@ -0,0 +1,160 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.assertj;
+
+import io.qameta.allure.model.Parameter;
+import io.qameta.allure.model.Stage;
+import io.qameta.allure.model.Status;
+import io.qameta.allure.model.StatusDetails;
+import io.qameta.allure.model.StepResult;
+
+import java.util.List;
+
+import static io.qameta.allure.util.ResultsUtils.getStatus;
+import static io.qameta.allure.util.ResultsUtils.getStatusDetails;
+
+/**
+ * Child Allure step for one meaningful AssertJ fluent operation.
+ *
+ * <p>An operation is the report entry for one fluent method call inside an {@link AssertJChain}. The recorder creates
+ * it before proceeding with the intercepted AssertJ call, marks it passed or failed after the call returns, and keeps
+ * it attached to the chain that owns the assertion object. Earlier operations remain passed when a later operation
+ * fails, so the report shows the exact point where the assertion chain stopped matching the expectation.</p>
+ *
+ * <p>For a simple assertion, each checked method becomes one operation:</p>
+ * <pre>{@code
+ * assertThat("Data").startsWith("Da").endsWith("ta")
+ *
+ * assert "Data"
+ *   starts with "Da"
+ *   ends with "ta"
+ * }</pre>
+ *
+ * <p>For navigation methods, the operation name is enriched with the returned subject. The returned AssertJ object
+ * still belongs to the same chain, so the report stays readable as one story:</p>
+ * <pre>{@code
+ * assertThat(users).first(InstanceOfAssertFactories.STRING).startsWith("alice")
+ *
+ * assert 1 string
+ *   first element as InstanceOfAssertFactory -> "alice@example.org"
+ *   starts with "alice"
+ * }</pre>
+ *
+ * <p>For failures, this operation receives the failure status and status details, and the parent chain receives the
+ * same status. This makes the failed operation visible without losing the successful context before it:</p>
+ * <pre>{@code
+ * assertThat("Data").startsWith("Da").hasSize(5)
+ *
+ * assert "Data"                 FAILED
+ *   starts with "Da"             PASSED
+ *   has size 5                   FAILED
+ * }</pre>
+ *
+ * <p>Some AssertJ methods call other assertion methods internally. Those calls should not become extra child steps
+ * because they would duplicate implementation details instead of user intent. The {@code nestedLevel} counter lets the
+ * recorder reuse the active operation while those internal calls run, then finish only the user-visible operation.</p>
+ */
+final class AssertJOperation {
+
+    private final AssertJChain chain;
+
+    private final String methodName;
+
+    private final StepResult step;
+
+    private final boolean navigation;
+
+    private String returnedSubject;
+
+    private int nestedLevel;
+
+    AssertJOperation(final AssertJChain chain,
+                     final String methodName,
+                     final String name,
+                     final List<Parameter> parameters,
+                     final boolean navigation) {
+        this.chain = chain;
+        this.methodName = methodName;
+        this.navigation = navigation;
+        this.step = new StepResult()
+                .setName(name)
+                .setParameters(parameters)
+                .setStage(Stage.RUNNING)
+                .setStart(System.currentTimeMillis());
+    }
+
+    AssertJChain getChain() {
+        return chain;
+    }
+
+    StepResult getStep() {
+        return step;
+    }
+
+    boolean isNavigation() {
+        return navigation;
+    }
+
+    boolean isDescription() {
+        return AssertJMethodSupport.isDescription(methodName);
+    }
+
+    boolean isNested() {
+        return nestedLevel > 0;
+    }
+
+    AssertJOperation nested() {
+        nestedLevel++;
+        return this;
+    }
+
+    void leaveNested() {
+        nestedLevel--;
+    }
+
+    void setReturnedSubject(final String subject) {
+        if (returnedSubject != null) {
+            return;
+        }
+
+        returnedSubject = subject;
+        step.setName(AssertJValueRenderer.truncateStepName(step.getName() + " -> " + subject));
+    }
+
+    void passed() {
+        if (step.getStatus() == null) {
+            step.setStatus(Status.PASSED);
+        }
+        finish();
+    }
+
+    void failed(final Throwable throwable) {
+        final Status status = getStatus(throwable).orElse(Status.BROKEN);
+        final StatusDetails details = getStatusDetails(throwable).orElse(null);
+        step
+                .setStatus(status)
+                .setStatusDetails(details);
+        chain.updateStatus(status, details);
+        finish();
+    }
+
+    private void finish() {
+        step
+                .setStage(Stage.FINISHED)
+                .setStop(System.currentTimeMillis());
+        chain.finish();
+    }
+}
diff --git a/allure-assertj/src/main/java/io/qameta/allure/assertj/AssertJRecorder.java b/allure-assertj/src/main/java/io/qameta/allure/assertj/AssertJRecorder.java
new file mode 100644
index 00000000..50bc7753
--- /dev/null
+++ b/allure-assertj/src/main/java/io/qameta/allure/assertj/AssertJRecorder.java
@@ -0,0 +1,259 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.assertj;
+
+import io.qameta.allure.AllureLifecycle;
+import org.assertj.core.api.AbstractAssert;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.IdentityHashMap;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * Records AssertJ objects by identity and builds one Allure step tree per assertion chain.
+ *
+ * <p>The recorder is the stateful part behind {@link AllureAspectJ}. The aspect only detects user-side AssertJ
+ * factory calls and fluent operation calls; this class decides which {@link AssertJChain} owns the assertion object,
+ * where a new {@link AssertJOperation} should be attached, and how pass/fail state should be reflected in the retained
+ * Allure {@code StepResult} tree.</p>
+ *
+ * <p>Each aspect thread gets its own recorder instance. Assertion objects are tracked in an {@link IdentityHashMap}
+ * because AssertJ assertion classes can override {@code equals} and {@code hashCode}; object identity is the only safe
+ * way to know that a later fluent call belongs to the same assertion object that was created earlier.</p>
+ *
+ * <p>The normal hard-assertion flow is:</p>
+ * <pre>{@code
+ * assertThat("Data").startsWith("Da").endsWith("ta")
+ *
+ * assertionCreated(assertThat result, "Data")
+ * startOperation(startsWith, ["Da"])
+ * operationPassed(startsWith)
+ * startOperation(endsWith, ["ta"])
+ * operationPassed(endsWith)
+ *
+ * assert "Data"
+ *   starts with "Da"
+ *   ends with "ta"
+ * }</pre>
+ *
+ * <p>Stored assertion instances keep separate chains because the map key is the assertion instance itself:</p>
+ * <pre>{@code
+ * final AbstractStringAssert<?> a = assertThat("alpha");
+ * final AbstractStringAssert<?> b = assertThat("bravo");
+ *
+ * a.isEqualTo("alpha");
+ * b.isEqualTo("bravo");
+ *
+ * assert "alpha"
+ *   is equal to "alpha"
+ * assert "bravo"
+ *   is equal to "bravo"
+ * }</pre>
+ *
+ * <p>Navigation operations such as {@code extracting}, {@code first}, and {@code asInstanceOf} may return new AssertJ
+ * assertion objects. Those returned objects are registered against the existing chain, so later checks stay under the
+ * same parent step:</p>
+ * <pre>{@code
+ * assertThat(results).extracting(Result::getName).containsExactly("passed")
+ *
+ * assert 1 Result item
+ *   extracts Result::getName -> 1 string
+ *   contains exactly ["passed"]
+ * }</pre>
+ *
+ * <p>The {@code operations} stack tracks the currently executing user-visible operation. It has two jobs: assertions
+ * created inside callbacks such as {@code satisfies} are attached beneath the active operation, and AssertJ internal
+ * calls on the same chain are counted as nested work instead of being reported as extra steps.</p>
+ *
+ * <pre>{@code
+ * assertThat("alpha").satisfies(value -> assertThat(value).startsWith("al"))
+ *
+ * assert "alpha"
+ *   satisfies <lambda>
+ *     assert "alpha"
+ *       starts with "al"
+ * }</pre>
+ *
+ * <p>Soft assertion failures are reported before {@code assertAll()} throws. The AssertJ error collector callback calls
+ * {@link #softAssertionFailed(AssertionError)}, which marks the active operation and its chain as failed while
+ * preserving the earlier passed operations.</p>
+ */
+final class AssertJRecorder {
+
+    private final Map<AbstractAssert<?, ?>, AssertJChain> chains = new IdentityHashMap<>();
+
+    private final Deque<AssertJOperation> operations = new ArrayDeque<>();
+
+    private final AssertJValueRenderer renderer = new AssertJValueRenderer();
+
+    void assertionCreated(final AllureLifecycle lifecycle,
+                          final AbstractAssert<?, ?> assertion,
+                          final Object actual) {
+        if (chains.containsKey(assertion)) {
+            return;
+        }
+
+        final AssertJOperation activeOperation = activeOperation();
+        if (isNavigationResult(activeOperation)) {
+            chains.put(assertion, activeOperation.getChain());
+            return;
+        }
+
+        final AssertJChain chain = new AssertJChain(assertion, renderer.renderSubject(actual));
+        chains.put(assertion, chain);
+        attachChain(lifecycle, chain, activeOperation);
+    }
+
+    AssertJOperation startOperation(final AllureLifecycle lifecycle,
+                                    final AbstractAssert<?, ?> assertion,
+                                    final String methodName,
+                                    final Object... args) {
+        final AssertJChain chain = chainFor(lifecycle, assertion);
+        final String normalizedName = AssertJMethodSupport.normalize(methodName);
+
+        final AssertJOperation activeOperation = activeOperation();
+        if (isInternalCallOnSameChain(activeOperation, chain)) {
+            return activeOperation.nested();
+        }
+
+        final AssertJOperation operation = new AssertJOperation(
+                chain,
+                normalizedName,
+                renderer.renderOperation(normalizedName, args),
+                renderer.renderParameters(normalizedName, args),
+                AssertJMethodSupport.isNavigation(normalizedName)
+        );
+        chain.addOperation(operation);
+        operations.push(operation);
+        return operation;
+    }
+
+    void operationPassed(final AssertJOperation operation, final Object result) {
+        if (operation.isNested()) {
+            pop(operation);
+            return;
+        }
+
+        registerReturnedAssertion(operation, result);
+        renameChainFromDescription(operation);
+        operation.passed();
+        pop(operation);
+    }
+
+    void operationFailed(final AssertJOperation operation, final Throwable throwable) {
+        operation.failed(throwable);
+        pop(operation);
+    }
+
+    void softAssertionFailed(final AssertionError error) {
+        final AssertJOperation current = activeOperation();
+        if (current != null) {
+            current.failed(error);
+        }
+    }
+
+    boolean isIgnored(final String methodName) {
+        return AssertJMethodSupport.isIgnored(methodName);
+    }
+
+    private AssertJChain chainFor(final AllureLifecycle lifecycle, final AbstractAssert<?, ?> assertion) {
+        final AssertJChain chain = chains.get(assertion);
+        if (chain != null) {
+            return chain;
+        }
+
+        final AssertJChain created = new AssertJChain(assertion, renderer.renderSubject(actualOf(assertion)));
+        chains.put(assertion, created);
+        attachChain(lifecycle, created, activeOperation());
+        return created;
+    }
+
+    private void attachChain(final AllureLifecycle lifecycle,
+                             final AssertJChain chain,
+                             final AssertJOperation parentOperation) {
+        if (parentOperation == null) {
+            lifecycle.startStep(chain.getUuid(), chain.getStep());
+            lifecycle.stopStep(chain.getUuid());
+            return;
+        }
+
+        parentOperation.getStep().getSteps().add(chain.getStep());
+    }
+
+    private void registerReturnedAssertion(final AssertJOperation operation, final Object result) {
+        if (!(result instanceof AbstractAssert)) {
+            return;
+        }
+
+        final AbstractAssert<?, ?> returned = (AbstractAssert<?, ?>) result;
+        chains.put(returned, operation.getChain());
+        if (operation.isNavigation()) {
+            operation.setReturnedSubject(renderer.renderSubject(actualOf(returned)));
+        }
+    }
+
+    private void renameChainFromDescription(final AssertJOperation operation) {
+        if (operation.isDescription()) {
+            operation.getChain().rename(descriptionOf(operation.getChain().getAssertion()));
+        }
+    }
+
+    private AssertJOperation activeOperation() {
+        return operations.peek();
+    }
+
+    private boolean isNavigationResult(final AssertJOperation activeOperation) {
+        return activeOperation != null && activeOperation.isNavigation();
+    }
+
+    private boolean isInternalCallOnSameChain(final AssertJOperation activeOperation, final AssertJChain chain) {
+        return activeOperation != null && activeOperation.getChain() == chain;
+    }
+
+    private void pop(final AssertJOperation operation) {
+        if (operation.isNested()) {
+            operation.leaveNested();
+            return;
+        }
+        if (!operations.isEmpty() && operations.peek() == operation) {
+            operations.pop();
+        }
+    }
+
+    private Object actualOf(final AbstractAssert<?, ?> assertion) {
+        return AllureAspectJ.withoutRecording(() -> {
+            try {
+                return assertion.actual();
+            } catch (RuntimeException e) {
+                return null;
+            }
+        });
+    }
+
+    private Optional<String> descriptionOf(final AbstractAssert<?, ?> assertion) {
+        return AllureAspectJ.withoutRecording(() -> {
+            try {
+                return Optional.ofNullable(assertion.descriptionText())
+                        .map(String::trim)
+                        .filter(value -> !value.isEmpty());
+            } catch (RuntimeException e) {
+                return Optional.empty();
+            }
+        });
+    }
+}
diff --git a/allure-assertj/src/main/java/io/qameta/allure/assertj/AssertJValueRenderer.java b/allure-assertj/src/main/java/io/qameta/allure/assertj/AssertJValueRenderer.java
new file mode 100644
index 00000000..49f9ba6a
--- /dev/null
+++ b/allure-assertj/src/main/java/io/qameta/allure/assertj/AssertJValueRenderer.java
@@ -0,0 +1,561 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.assertj;
+
+import io.qameta.allure.model.Parameter;
+import io.qameta.allure.util.ObjectUtils;
+import org.assertj.core.description.Description;
+import org.assertj.core.groups.Tuple;
+
+import java.lang.reflect.Array;
+import java.net.URI;
+import java.net.URL;
+import java.nio.file.Path;
+import java.time.temporal.TemporalAccessor;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+import static io.qameta.allure.util.ResultsUtils.getLambdaName;
+
+/**
+ * Renders AssertJ subjects and arguments into semantic step names.
+ */
+@SuppressWarnings("all")
+final class AssertJValueRenderer {
+
+    private static final int STEP_NAME_LIMIT = 1000;
+
+    private static final int INLINE_VALUE_LIMIT = 3;
+
+    private static final String LAMBDA = "<lambda>";
+
+    private static final String TRUNCATED = "...";
+
+    String renderSubject(final Object value) {
+        return truncateStepName(renderSubjectValue(value));
+    }
+
+    String renderOperation(final String methodName, final Object[] args) {
+        return truncateStepName(renderOperationName(methodName, args));
+    }
+
+    List<Parameter> renderParameters(final String methodName, final Object[] args) {
+        final Object[] values = parameterArguments(methodName, args);
+        if (values.length == 0) {
+            return Collections.emptyList();
+        }
+
+        final String renderedOperation = renderOperation(methodName, args);
+        final List<Parameter> parameters = new ArrayList<>();
+        for (int index = 0; index < values.length; index++) {
+            final String value = renderParameterValue(values[index]);
+            if (renderedOperation.contains(value)) {
+                continue;
+            }
+            parameters.add(
+                    new Parameter()
+                            .setName(parameterName(methodName, index))
+                            .setValue(value)
+                            .setMode(Parameter.Mode.DEFAULT)
+            );
+        }
+        return parameters;
+    }
+
+    static String truncateStepName(final String value) {
+        if (value == null || value.length() <= STEP_NAME_LIMIT) {
+            return value;
+        }
+        return value.substring(0, STEP_NAME_LIMIT - TRUNCATED.length()) + TRUNCATED;
+    }
+
+    private String renderSubjectValue(final Object value) {
+        if (value == null) {
+            return "null";
+        }
+        if (value instanceof CharSequence || isSimple(value)) {
+            return renderSimple(value);
+        }
+        if (value instanceof Collection) {
+            if (isInlineCollection((Collection<?>) value)) {
+                return renderCollectionValue((Collection<?>) value);
+            }
+            return renderCollectionSubject((Collection<?>) value);
+        }
+        if (value instanceof Map) {
+            return "map with " + renderEntryCount(((Map<?, ?>) value).size());
+        }
+        if (value.getClass().isArray()) {
+            return renderArraySubject(value);
+        }
+        if (value instanceof Iterable) {
+            return "iterable";
+        }
+        return simpleClassName(value);
+    }
+
+    private Object[] parameterArguments(final String methodName, final Object[] args) {
+        if (isDescriptionWithEmptyValues(args)) {
+            return new Object[]{args[0]};
+        }
+        if (isSingleVarargToUnwrap(methodName, args)) {
+            return new Object[]{Array.get(args[0], 0)};
+        }
+        return args;
+    }
+
+    private String parameterName(final String methodName, final int index) {
+        if ("hasFieldOrPropertyWithValue".equals(methodName)) {
+            return index == 0 ? "field or property" : "expected value";
+        }
+
+        if (index > 0) {
+            return "argument " + (index + 1);
+        }
+
+        switch (methodName) {
+            case "as":
+                return "description";
+            case "asInstanceOf":
+            case "first":
+            case "singleElement":
+                return "factory";
+            case "extracting":
+            case "flatExtracting":
+                return "extractor";
+            case "hasSize":
+                return "expected size";
+            case "satisfies":
+                return "condition";
+            case "contains":
+            case "containsExactly":
+            case "containsExactlyInAnyOrder":
+            case "endsWith":
+            case "isEqualTo":
+            case "startsWith":
+                return "expected";
+            default:
+                return "argument 1";
+        }
+    }
+
+    private String renderParameterValue(final Object value) {
+        return renderArgument(value);
+    }
+
+    private String renderOperationName(final String methodName, final Object[] args) {
+        if (args.length == 0) {
+            return readableMethodName(methodName);
+        }
+
+        final String arguments = renderArguments(methodName, args);
+        switch (methodName) {
+            case "as":
+                return "described as " + arguments;
+            case "asInstanceOf":
+                return "as instance of " + arguments;
+            case "contains":
+                return "contains " + arguments;
+            case "containsExactly":
+                return "contains exactly " + arguments;
+            case "containsExactlyInAnyOrder":
+                return "contains exactly in any order " + arguments;
+            case "endsWith":
+                return "ends with " + arguments;
+            case "extracting":
+                return "extracts " + arguments;
+            case "flatExtracting":
+                return "flat extracts " + arguments;
+            case "first":
+                return "first element as " + arguments;
+            case "hasFieldOrPropertyWithValue":
+                return renderHasFieldOrPropertyWithValue(args);
+            case "hasSize":
+                return "has size " + arguments;
+            case "isEqualTo":
+                return "is equal to " + arguments;
+            case "singleElement":
+                return "single element as " + arguments;
+            case "startsWith":
+                return "starts with " + arguments;
+            case "satisfies":
+                return "satisfies " + arguments;
+            default:
+                return readableMethodName(methodName) + " " + arguments;
+        }
+    }
+
+    private String renderHasFieldOrPropertyWithValue(final Object[] args) {
+        if (args.length != 2) {
+            return "has field or property with value " + renderEach(args);
+        }
+        return "has field or property " + renderArgument(args[0]) + " with value " + renderArgument(args[1]);
+    }
+
+    private String readableMethodName(final String methodName) {
+        if (methodName.startsWith("is") && methodName.length() > 2 && Character.isUpperCase(methodName.charAt(2))) {
+            return "is " + splitCamelCase(methodName.substring(2));
+        }
+        if (methodName.startsWith("has") && methodName.length() > 3 && Character.isUpperCase(methodName.charAt(3))) {
+            return "has " + splitCamelCase(methodName.substring(3));
+        }
+        return splitCamelCase(methodName);
+    }
+
+    private String splitCamelCase(final String value) {
+        return value
+                .replaceAll("([a-z0-9])([A-Z])", "$1 $2")
+                .toLowerCase();
+    }
+
+    private String renderArguments(final String methodName, final Object[] args) {
+        if (isDescriptionWithEmptyValues(args)) {
+            return renderArgument(args[0]);
+        }
+        if (isSingleVarargToUnwrap(methodName, args)) {
+            return renderArgument(Array.get(args[0], 0));
+        }
+        if (isSingleArrayArgument(args)) {
+            return renderArray(args[0]);
+        }
+        return renderEach(args);
+    }
+
+    private boolean isDescriptionWithEmptyValues(final Object[] args) {
+        return args.length == 2
+                && args[1] != null
+                && args[1].getClass().isArray()
+                && Array.getLength(args[1]) == 0;
+    }
+
+    private boolean isSingleVarargToUnwrap(final String methodName, final Object[] args) {
+        return args.length == 1
+                && args[0] != null
+                && args[0].getClass().isArray()
+                && Array.getLength(args[0]) == 1
+                && shouldUnwrapSingleVararg(methodName);
+    }
+
+    private boolean isSingleArrayArgument(final Object[] args) {
+        return args.length == 1
+                && args[0] != null
+                && args[0].getClass().isArray();
+    }
+
+    private boolean shouldUnwrapSingleVararg(final String methodName) {
+        return !methodName.contains("Any")
+                && !methodName.contains("Exactly")
+                && !methodName.contains("Only")
+                && !methodName.contains("Sequence")
+                && !methodName.contains("Subsequence")
+                && !methodName.endsWith("In");
+    }
+
+    private String renderEach(final Object[] args) {
+        final List<String> values = new ArrayList<>();
+        for (Object arg : args) {
+            values.add(renderArgument(arg));
+        }
+        return values.stream().collect(Collectors.joining(", "));
+    }
+
+    private String renderArgument(final Object value) {
+        if (value == null) {
+            return "null";
+        }
+        if (isLambda(value)) {
+            return renderLambda(value);
+        }
+        if (value instanceof Description) {
+            return renderSimple(value.toString());
+        }
+        if (value instanceof Tuple) {
+            return renderTuple((Tuple) value);
+        }
+        if (value instanceof CharSequence || isSimple(value)) {
+            return renderSimple(value);
+        }
+        if (value instanceof Collection) {
+            if (isInlineCollection((Collection<?>) value)) {
+                return renderCollectionValue((Collection<?>) value);
+            }
+            return renderCollectionSubject((Collection<?>) value);
+        }
+        if (value instanceof Map) {
+            return "map with " + renderEntryCount(((Map<?, ?>) value).size());
+        }
+        if (value.getClass().isArray()) {
+            return renderArray(value);
+        }
+        return simpleClassName(value);
+    }
+
+    private String renderArray(final Object array) {
+        if (array instanceof byte[]) {
+            return ObjectUtils.toString(array);
+        }
+
+        final int length = Array.getLength(array);
+        if (array.getClass().getComponentType().isPrimitive()) {
+            return ObjectUtils.toString(array);
+        }
+        if (allLambdas(array, length)) {
+            return length == 1 ? renderLambda(Array.get(array, 0)) : lambdaList(array, length);
+        }
+        if (allSimple(array, length) || !array.getClass().getComponentType().isPrimitive()) {
+            return renderObjectArray(array, length);
+        }
+        return array.getClass().getComponentType().getSimpleName() + "[](length=" + length + ")";
+    }
+
+    private String renderCollectionSubject(final Collection<?> value) {
+        final int size = value.size();
+        if (size == 0) {
+            return "empty collection";
+        }
+        return commonElementType(value)
+                .map(type -> renderElementCount(size, type))
+                .orElseGet(() -> renderItemCount(size));
+    }
+
+    private String renderArraySubject(final Object array) {
+        final int length = Array.getLength(array);
+        if (isInlineArray(array, length)) {
+            return renderArrayValue(array, length);
+        }
+        if (array instanceof byte[]) {
+            return "byte array with " + renderByteCount(length);
+        }
+        return renderElementCount(length, array.getClass().getComponentType());
+    }
+
+    private boolean isInlineCollection(final Collection<?> value) {
+        return value.size() <= INLINE_VALUE_LIMIT && allInlineValues(value);
+    }
+
+    private boolean allInlineValues(final Collection<?> value) {
+        for (Object item : value) {
+            if (!isInlineValue(item)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private boolean isInlineValue(final Object value) {
+        return value == null
+                || isLambda(value)
+                || value instanceof Description
+                || isInlineTuple(value)
+                || value instanceof CharSequence
+                || isSimple(value);
+    }
+
+    private boolean isInlineTuple(final Object value) {
+        if (!(value instanceof Tuple)) {
+            return false;
+        }
+        final Object[] values = ((Tuple) value).toArray();
+        return isInlineArray(values, values.length);
+    }
+
+    private String renderTuple(final Tuple tuple) {
+        final Object[] values = tuple.toArray();
+        return renderObjectArray(values, values.length)
+                .replaceFirst("^\\[", "(")
+                .replaceFirst("]$", ")");
+    }
+
+    private String renderCollectionValue(final Collection<?> value) {
+        final List<String> values = new ArrayList<>();
+        for (Object item : value) {
+            values.add(renderArgument(item));
+        }
+        return values.stream().collect(Collectors.joining(", ", "[", "]"));
+    }
+
+    private boolean isInlineArray(final Object array, final int length) {
+        if (length > INLINE_VALUE_LIMIT || array instanceof byte[]) {
+            return false;
+        }
+        if (array.getClass().getComponentType().isPrimitive()) {
+            return true;
+        }
+        for (int i = 0; i < length; i++) {
+            if (!isInlineValue(Array.get(array, i))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private String renderArrayValue(final Object array, final int length) {
+        if (array.getClass().getComponentType().isPrimitive()) {
+            return ObjectUtils.toString(array);
+        }
+        return renderObjectArray(array, length);
+    }
+
+    private Optional<Class<?>> commonElementType(final Collection<?> value) {
+        Class<?> result = null;
+        for (Object item : value) {
+            if (item == null) {
+                continue;
+            }
+            final Class<?> itemType = elementTypeOf(item);
+            if (result == null) {
+                result = itemType;
+            } else if (!result.equals(itemType)) {
+                return java.util.Optional.empty();
+            }
+        }
+        return java.util.Optional.ofNullable(result);
+    }
+
+    private Class<?> elementTypeOf(final Object item) {
+        if (item instanceof Collection) {
+            return Collection.class;
+        }
+        if (item instanceof Map) {
+            return Map.class;
+        }
+        return item.getClass();
+    }
+
+    private String renderElementCount(final int size, final Class<?> type) {
+        if (String.class.equals(type)) {
+            return size + " " + pluralize("string", size);
+        }
+        if (Boolean.class.equals(type) || Boolean.TYPE.equals(type)) {
+            return size + " " + pluralize("boolean", size);
+        }
+        if (Character.class.equals(type) || Character.TYPE.equals(type)) {
+            return size + " " + pluralize("character", size);
+        }
+        if (Number.class.isAssignableFrom(type) || type.isPrimitive() && !Boolean.TYPE.equals(type)
+                && !Character.TYPE.equals(type)) {
+            return size + " " + pluralize("number", size);
+        }
+        if (Collection.class.equals(type)) {
+            return size + " " + pluralize("collection", size);
+        }
+        if (Map.class.equals(type)) {
+            return size + " " + pluralize("map", size);
+        }
+        return size + " " + type.getSimpleName() + " " + pluralize("item", size);
+    }
+
+    private String renderItemCount(final int size) {
+        return size + " " + pluralize("item", size);
+    }
+
+    private String renderEntryCount(final int size) {
+        return size + " " + pluralize("entry", size);
+    }
+
+    private String renderByteCount(final int size) {
+        return size + " " + pluralize("byte", size);
+    }
+
+    private String pluralize(final String word, final int count) {
+        return count == 1 ? word : word + "s";
+    }
+
+    private String renderObjectArray(final Object array, final int length) {
+        final List<String> values = new ArrayList<>();
+        for (int i = 0; i < length; i++) {
+            values.add(renderArgument(Array.get(array, i)));
+        }
+        return values.stream().collect(Collectors.joining(", ", "[", "]"));
+    }
+
+    private boolean allLambdas(final Object array, final int length) {
+        if (length == 0) {
+            return false;
+        }
+        for (int i = 0; i < length; i++) {
+            if (!isLambda(Array.get(array, i))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private String lambdaList(final Object array, final int length) {
+        final List<String> values = new ArrayList<>();
+        for (int i = 0; i < length; i++) {
+            values.add(renderLambda(Array.get(array, i)));
+        }
+        return values.stream().collect(Collectors.joining(", ", "[", "]"));
+    }
+
+    private boolean allSimple(final Object array, final int length) {
+        for (int i = 0; i < length; i++) {
+            final Object item = Array.get(array, i);
+            if (item != null && !isSimple(item) && !(item instanceof CharSequence)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private boolean isSimple(final Object value) {
+        return value instanceof Number
+                || value instanceof Boolean
+                || value instanceof Character
+                || value instanceof Enum
+                || value instanceof Path
+                || value instanceof URI
+                || value instanceof URL
+                || value instanceof TemporalAccessor;
+    }
+
+    private boolean isLambda(final Object value) {
+        if (value == null) {
+            return false;
+        }
+        final Class<?> type = value.getClass();
+        return type.isSynthetic() || type.getName().contains("$$Lambda$");
+    }
+
+    private String renderLambda(final Object value) {
+        return getLambdaName(value)
+                .orElse(LAMBDA);
+    }
+
+    private String renderSimple(final Object value) {
+        if (value instanceof CharSequence || value instanceof Character) {
+            return "\"" + ObjectUtils.toString(value) + "\"";
+        }
+        if (value instanceof Enum) {
+            return ((Enum<?>) value).name();
+        }
+        return ObjectUtils.toString(value);
+    }
+
+    private String simpleClassName(final Object value) {
+        final Class<?> type = value.getClass();
+        if (type.isAnonymousClass()) {
+            return type.getSuperclass().getSimpleName();
+        }
+        return type.getSimpleName();
+    }
+}
diff --git a/allure-assertj/src/main/resources/META-INF/services/io.qameta.allure.listener.FixtureLifecycleListener b/allure-assertj/src/main/resources/META-INF/services/io.qameta.allure.listener.FixtureLifecycleListener
new file mode 100644
index 00000000..65aaf3ec
--- /dev/null
+++ b/allure-assertj/src/main/resources/META-INF/services/io.qameta.allure.listener.FixtureLifecycleListener
@@ -0,0 +1 @@
+io.qameta.allure.assertj.AssertJLifecycleListener
diff --git a/allure-assertj/src/main/resources/META-INF/services/io.qameta.allure.listener.TestLifecycleListener b/allure-assertj/src/main/resources/META-INF/services/io.qameta.allure.listener.TestLifecycleListener
new file mode 100644
index 00000000..65aaf3ec
--- /dev/null
+++ b/allure-assertj/src/main/resources/META-INF/services/io.qameta.allure.listener.TestLifecycleListener
@@ -0,0 +1 @@
+io.qameta.allure.assertj.AssertJLifecycleListener
diff --git a/allure-assertj/src/test/java/io/qameta/allure/assertj/AllureAspectJTest.java b/allure-assertj/src/test/java/io/qameta/allure/assertj/AllureAspectJTest.java
index 957657b1..377e7a6b 100644
--- a/allure-assertj/src/test/java/io/qameta/allure/assertj/AllureAspectJTest.java
+++ b/allure-assertj/src/test/java/io/qameta/allure/assertj/AllureAspectJTest.java
@@ -15,110 +15,536 @@
  */
 package io.qameta.allure.assertj;
 
+import io.qameta.allure.model.Parameter;
+import io.qameta.allure.model.Status;
+import io.qameta.allure.model.StatusDetails;
 import io.qameta.allure.model.StepResult;
 import io.qameta.allure.model.TestResult;
 import io.qameta.allure.test.AllureFeatures;
 import io.qameta.allure.test.AllureResults;
+import org.assertj.core.api.AbstractStringAssert;
+import org.assertj.core.api.InstanceOfAssertFactories;
 import org.assertj.core.api.SoftAssertions;
 import org.junit.jupiter.api.Test;
 
+import java.io.Serializable;
 import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
+import java.util.Collections;
+import java.util.function.Function;
 
 import static io.qameta.allure.test.RunUtils.runWithinTestContext;
 import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * @author charlie (Dmitry Baev).
- */
+import static org.assertj.core.api.Assertions.tuple;
 class AllureAspectJTest {
 
     @AllureFeatures.Steps
     @Test
-    void shouldCreateStepsForAsserts() {
+    void shouldCreateSemanticChainForScalarAssert() {
         final AllureResults results = runWithinTestContext(() -> {
             assertThat("Data")
                     .hasSize(4);
         }, AllureAspectJ::setLifecycle);
-        assertThat(results.getTestResults())
-                .flatExtracting(TestResult::getSteps)
+
+        final TestResult result = assertOnlyOneResult(results);
+        assertThat(result.getSteps())
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactly(tuple("assert \"Data\"", Status.PASSED));
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
                 .extracting(StepResult::getName)
-                .containsExactly(
-                        "assertThat 'Data'",
-                        "hasSize '4'"
-                );
+                .containsExactly("has size 4");
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .flatExtracting(StepResult::getParameters)
+                .isEmpty();
     }
 
     @AllureFeatures.Steps
     @Test
-    void shouldHandleNullableObject() {
+    void shouldUseAssertDescriptionAsChainName() {
         final AllureResults results = runWithinTestContext(() -> {
             assertThat((Object) null)
                     .as("Nullable object")
                     .isNull();
         }, AllureAspectJ::setLifecycle);
 
-        assertThat(results.getTestResults())
-                .flatExtracting(TestResult::getSteps)
+        final TestResult result = assertOnlyOneResult(results);
+        assertThat(result.getSteps())
                 .extracting(StepResult::getName)
-                .containsExactly(
-                        "assertThat 'null'",
-                        "as 'Nullable object []'",
-                        "isNull"
-                );
+                .containsExactly("assert Nullable object");
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly("described as \"Nullable object\"", "is null");
     }
 
     @AllureFeatures.Steps
     @Test
-    void shouldHandleByteArrayObject() {
-        final String s = "some string";
+    void shouldRenderByteArraysWithoutPayload() {
+        final String value = "some string";
         final AllureResults results = runWithinTestContext(() -> {
-            assertThat(s.getBytes(StandardCharsets.UTF_8))
+            assertThat(value.getBytes(StandardCharsets.UTF_8))
                     .as("Byte array object")
-                    .isEqualTo(s.getBytes(StandardCharsets.UTF_8));
+                    .isEqualTo(value.getBytes(StandardCharsets.UTF_8));
+        }, AllureAspectJ::setLifecycle);
+
+        final TestResult result = assertOnlyOneResult(results);
+        assertThat(result.getSteps())
+                .extracting(StepResult::getName)
+                .containsExactly("assert Byte array object");
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly("described as \"Byte array object\"", "is equal to <BINARY>");
+    }
+
+    @AllureFeatures.Steps
+    @Test
+    void shouldRenderCollectionsAsSubjectsAndExpectedValuesAsValues() {
+        final AllureResults results = runWithinTestContext(() -> {
+            assertThat(Arrays.asList("a", "b"))
+                    .containsExactly("a", "b");
+        }, AllureAspectJ::setLifecycle);
+
+        final TestResult result = assertOnlyOneResult(results);
+        assertThat(result.getSteps())
+                .extracting(StepResult::getName)
+                .containsExactly("assert [\"a\", \"b\"]");
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly("contains exactly [\"a\", \"b\"]");
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .flatExtracting(StepResult::getParameters)
+                .isEmpty();
+    }
+
+    @AllureFeatures.Steps
+    @Test
+    void shouldRenderSmallArraysAsValues() {
+        final AllureResults results = runWithinTestContext(() -> {
+            assertThat(new int[]{1, 2})
+                    .containsExactly(1, 2);
+
+            assertThat(new String[]{"alpha", "bravo"})
+                    .containsExactly("alpha", "bravo");
+        }, AllureAspectJ::setLifecycle);
+
+        final TestResult result = assertOnlyOneResult(results);
+        assertThat(result.getSteps())
+                .extracting(StepResult::getName)
+                .containsExactly("assert [1, 2]", "assert [\"alpha\", \"bravo\"]");
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly("contains exactly [1, 2]", "contains exactly [\"alpha\", \"bravo\"]");
+    }
+
+    @AllureFeatures.Steps
+    @Test
+    void shouldRenderTuplesAsValues() {
+        final AllureResults results = runWithinTestContext(() -> {
+            assertThat(
+                    Arrays.asList(
+                            tuple("first", Status.PASSED),
+                            tuple("second", Status.FAILED)
+                    )
+            )
+                    .containsExactly(
+                            tuple("first", Status.PASSED),
+                            tuple("second", Status.FAILED)
+                    );
+        }, AllureAspectJ::setLifecycle);
+
+        final TestResult result = assertOnlyOneResult(results);
+        assertThat(result.getSteps())
+                .extracting(StepResult::getName)
+                .containsExactly("assert [(\"first\", PASSED), (\"second\", FAILED)]");
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly("contains exactly [(\"first\", PASSED), (\"second\", FAILED)]");
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .flatExtracting(StepResult::getParameters)
+                .isEmpty();
+    }
+
+    @AllureFeatures.Steps
+    @Test
+    void shouldRenderNullValuesInContainsExactlyInAnyOrder() {
+        final AllureResults results = runWithinTestContext(() -> {
+            assertThat(Arrays.asList(null, "a", "b"))
+                    .containsExactlyInAnyOrder(null, "a", "b");
+        }, AllureAspectJ::setLifecycle);
+
+        final TestResult result = assertOnlyOneResult(results);
+        assertThat(result.getSteps())
+                .extracting(StepResult::getName)
+                .containsExactly("assert [null, \"a\", \"b\"]");
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly("contains exactly in any order [null, \"a\", \"b\"]");
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .flatExtracting(StepResult::getParameters)
+                .isEmpty();
+    }
+
+    @AllureFeatures.Steps
+    @Test
+    void shouldRenderNullValuesAfterExtractingAndKeepLambdaVarargs() {
+        final TestResult model = new TestResult();
+
+        final AllureResults results = runWithinTestContext(() -> {
+            assertThat(model)
+                    .extracting(TestResult::getDescription, TestResult::getDescriptionHtml)
+                    .containsExactly(null, null);
         }, AllureAspectJ::setLifecycle);
 
-        assertThat(results.getTestResults())
-                .flatExtracting(TestResult::getSteps)
+        final TestResult result = assertOnlyOneResult(results);
+        assertThat(result.getSteps())
+                .extracting(StepResult::getName)
+                .containsExactly("assert TestResult");
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
                 .extracting(StepResult::getName)
                 .containsExactly(
-                        "assertThat '<BINARY>'",
-                        "describedAs 'Byte array object'",
-                        "isEqualTo '<BINARY>'"
+                        "extracts [<lambda>, <lambda>] -> [null, null]",
+                        "contains exactly [null, null]"
                 );
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .flatExtracting(StepResult::getParameters)
+                .isEmpty();
+    }
+
+    @AllureFeatures.Steps
+    @Test
+    void shouldRenderFieldOrPropertyValueAssertions() {
+        final StatusDetails details = new StatusDetails()
+                .setMessage("Make the test failed");
+
+        final AllureResults results = runWithinTestContext(() -> {
+            assertThat(details)
+                    .hasFieldOrPropertyWithValue("message", "Make the test failed");
+        }, AllureAspectJ::setLifecycle);
+
+        final TestResult result = assertOnlyOneResult(results);
+        assertThat(result.getSteps())
+                .extracting(StepResult::getName)
+                .containsExactly("assert StatusDetails");
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly("has field or property \"message\" with value \"Make the test failed\"");
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .flatExtracting(StepResult::getParameters)
+                .isEmpty();
+    }
+
+    @AllureFeatures.Steps
+    @Test
+    void shouldTruncateLongStepNamesAndAddOnlyTruncatedValuesAsParameters() {
+        final String value = String.join("", Collections.nCopies(1200, "a"));
+
+        final AllureResults results = runWithinTestContext(() -> {
+            assertThat(value)
+                    .isEqualTo(value);
+        }, AllureAspectJ::setLifecycle);
+
+        final TestResult result = assertOnlyOneResult(results);
+        assertThat(result.getSteps())
+                .extracting(StepResult::getName)
+                .singleElement()
+                .asString()
+                .hasSize(1000)
+                .startsWith("assert \"")
+                .endsWith("...");
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .extracting(StepResult::getName)
+                .singleElement()
+                .asString()
+                .hasSize(1000)
+                .startsWith("is equal to \"")
+                .endsWith("...");
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .flatExtracting(StepResult::getParameters)
+                .extracting(Parameter::getName, Parameter::getValue)
+                .containsExactly(tuple("expected", "\"" + value + "\""));
     }
 
     @AllureFeatures.Steps
     @Test
-    void shouldHandleCollections() {
+    void shouldCreateSeparateChainsForMultipleAssertThatCalls() {
         final AllureResults results = runWithinTestContext(() -> {
+            assertThat("Data")
+                    .hasSize(4);
+
+            assertThat(42)
+                    .isPositive()
+                    .isEqualTo(42);
+
             assertThat(Arrays.asList("a", "b"))
-                .containsExactly("a", "b");
+                    .hasSize(2)
+                    .contains("a");
+        }, AllureAspectJ::setLifecycle);
+
+        final TestResult result = assertOnlyOneResult(results);
+        assertThat(result.getSteps())
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactly(
+                        tuple("assert \"Data\"", Status.PASSED),
+                        tuple("assert 42", Status.PASSED),
+                        tuple("assert [\"a\", \"b\"]", Status.PASSED)
+                );
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly(
+                        "has size 4",
+                        "is positive",
+                        "is equal to 42",
+                        "has size 2",
+                        "contains \"a\""
+                );
+    }
+
+    @AllureFeatures.Steps
+    @Test
+    void shouldAttachOperationsToStoredAssertionInstances() {
+        final String targetA = "alpha";
+        final String targetB = "bravo";
+
+        final AllureResults results = runWithinTestContext(() -> {
+            final AbstractStringAssert<?> a = assertThat(targetA);
+            final AbstractStringAssert<?> b = assertThat(targetB);
+
+            a.isEqualTo("alpha");
+            b.isEqualTo("bravo");
+        }, AllureAspectJ::setLifecycle);
+
+        final TestResult result = assertOnlyOneResult(results);
+        assertThat(result.getSteps())
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactly(
+                        tuple("assert \"alpha\"", Status.PASSED),
+                        tuple("assert \"bravo\"", Status.PASSED)
+                );
+        assertThat(result.getSteps())
+                .filteredOn("name", "assert \"alpha\"")
+                .flatExtracting(StepResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly("is equal to \"alpha\"");
+        assertThat(result.getSteps())
+                .filteredOn("name", "assert \"bravo\"")
+                .flatExtracting(StepResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly("is equal to \"bravo\"");
+    }
+
+    @AllureFeatures.Steps
+    @Test
+    void shouldAvoidVerboseModelToStringPayloads() {
+        final TestResult model = new TestResult()
+                .setUuid("uid")
+                .setName("testPassed")
+                .setFullName("other.PassingTest.testPassed");
+
+        final AllureResults results = runWithinTestContext(() -> {
+            assertThat(Collections.singletonList(model))
+                    .hasSize(1)
+                    .containsExactly(model);
         }, AllureAspectJ::setLifecycle);
 
-        assertThat(results.getTestResults())
-            .flatExtracting(TestResult::getSteps)
-            .extracting(StepResult::getName)
-            .containsExactly(
-                "assertThatList '[a, b]'",
-                "containsExactly '[a, b]'"
-            );
+        final TestResult result = assertOnlyOneResult(results);
+        assertThat(result.getSteps())
+                .extracting(StepResult::getName)
+                .containsExactly("assert 1 TestResult item");
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly("has size 1", "contains exactly [TestResult]");
+        assertThat(result.getSteps())
+                .extracting(StepResult::getName)
+                .noneMatch(name -> name.contains("fullName="))
+                .noneMatch(name -> name.contains("other.PassingTest.testPassed"));
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .extracting(StepResult::getName)
+                .noneMatch(name -> name.contains("fullName="))
+                .noneMatch(name -> name.contains("other.PassingTest.testPassed"));
     }
 
     @AllureFeatures.Steps
     @Test
-    void softAssertions() {
+    void shouldKeepNavigationInsideTheSameChain() {
+        final TestResult model = new TestResult()
+                .setFullName("my.company.Test.testOne");
+
+        final AllureResults results = runWithinTestContext(() -> {
+            assertThat(Collections.singletonList(model))
+                    .extracting(TestResult::getFullName)
+                    .containsExactly("my.company.Test.testOne");
+
+            assertThat(Collections.singletonList("alpha"))
+                    .first(InstanceOfAssertFactories.STRING)
+                    .startsWith("al");
+
+            assertThat(Collections.singletonList("bravo"))
+                    .singleElement(InstanceOfAssertFactories.STRING)
+                    .endsWith("vo");
+
+            assertThat((Object) "charlie")
+                    .asInstanceOf(InstanceOfAssertFactories.STRING)
+                    .contains("har");
+
+            assertThat(Collections.singletonList(Collections.singletonList("delta")))
+                    .flatExtracting(value -> value)
+                    .containsExactly("delta");
+        }, AllureAspectJ::setLifecycle);
+
+        final TestResult result = assertOnlyOneResult(results);
+        assertThat(result.getSteps())
+                .hasSize(5);
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly(
+                        "extracts <lambda> -> [\"my.company.Test.testOne\"]",
+                        "contains exactly [\"my.company.Test.testOne\"]",
+                        "first element as InstanceOfAssertFactory -> \"alpha\"",
+                        "starts with \"al\"",
+                        "single element as InstanceOfAssertFactory -> \"bravo\"",
+                        "ends with \"vo\"",
+                        "as instance of InstanceOfAssertFactory -> \"charlie\"",
+                        "contains \"har\"",
+                        "flat extracts <lambda> -> [\"delta\"]",
+                        "contains exactly [\"delta\"]"
+                );
+    }
+
+    @AllureFeatures.Steps
+    @Test
+    void shouldRenderSerializedLambdaMethodReferences() {
+        final TestResult model = new TestResult()
+                .setFullName("my.company.Test.testOne");
+
+        final AllureResults results = runWithinTestContext(() -> {
+            assertThat(Collections.singletonList(model))
+                    .extracting((Function<TestResult, String> & Serializable) TestResult::getFullName)
+                    .containsExactly("my.company.Test.testOne");
+        }, AllureAspectJ::setLifecycle);
+
+        final TestResult result = assertOnlyOneResult(results);
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly(
+                        "extracts TestResult::getFullName -> [\"my.company.Test.testOne\"]",
+                        "contains exactly [\"my.company.Test.testOne\"]"
+                );
+    }
+
+    @AllureFeatures.Steps
+    @Test
+    void shouldMarkTheFailedHardAssertionOperation() {
+        final AllureResults results = runWithinTestContext(() -> {
+            assertThat("Data")
+                    .hasSize(5);
+        }, AllureAspectJ::setLifecycle);
+
+        final TestResult result = assertOnlyOneResult(results);
+        assertThat(result.getSteps())
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactly(tuple("assert \"Data\"", Status.FAILED));
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactly(tuple("has size 5", Status.FAILED));
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .filteredOn("name", "has size 5")
+                .extracting(step -> step.getStatusDetails().getMessage())
+                .singleElement()
+                .asString()
+                .contains("size");
+    }
+
+    @AllureFeatures.Steps
+    @Test
+    void shouldMarkTheFailedSoftAssertionOperationBeforeAssertAll() {
         final AllureResults results = runWithinTestContext(() -> {
             final SoftAssertions soft = new SoftAssertions();
             soft.assertThat(25)
-                    .as("Test description")
+                    .as("Age")
                     .isEqualTo(26);
             soft.assertAll();
         }, AllureAspectJ::setLifecycle);
 
-        assertThat(results.getTestResults())
-                .flatExtracting(TestResult::getSteps)
+        final TestResult result = assertOnlyOneResult(results);
+        assertThat(result.getSteps())
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactly(tuple("assert Age", Status.FAILED));
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactly(
+                        tuple("described as \"Age\"", Status.PASSED),
+                        tuple("is equal to 26", Status.FAILED)
+                );
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .filteredOn("name", "is equal to 26")
+                .extracting(step -> step.getStatusDetails().getMessage())
+                .singleElement()
+                .asString()
+                .contains("expected: 26");
+    }
+
+    @AllureFeatures.Steps
+    @Test
+    void shouldAttachNestedAssertionsUnderCallbackOperations() {
+        final AllureResults results = runWithinTestContext(() -> {
+            assertThat("alpha")
+                    .satisfies(
+                            value -> assertThat(value)
+                                    .startsWith("al")
+                                    .endsWith("ha")
+                    );
+        }, AllureAspectJ::setLifecycle);
+
+        final TestResult result = assertOnlyOneResult(results);
+        assertThat(result.getSteps())
+                .extracting(StepResult::getName)
+                .containsExactly("assert \"alpha\"");
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
                 .extracting(StepResult::getName)
-                .contains("as 'Test description []'", "isEqualTo '26'");
+                .containsExactly("satisfies <lambda>");
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .filteredOn("name", "satisfies <lambda>")
+                .flatExtracting(StepResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly("assert \"alpha\"");
+        assertThat(result.getSteps())
+                .flatExtracting(StepResult::getSteps)
+                .filteredOn("name", "satisfies <lambda>")
+                .flatExtracting(StepResult::getSteps)
+                .flatExtracting(StepResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly("starts with \"al\"", "ends with \"ha\"");
+    }
+
+    private TestResult assertOnlyOneResult(final AllureResults results) {
+        assertThat(results.getTestResults()).hasSize(1);
+        return results.getTestResults().get(0);
     }
 }
diff --git a/allure-assertj/src/test/resources/allure.properties b/allure-assertj/src/test/resources/allure.properties
index 9c0b0a2d..c881472e 100644
--- a/allure-assertj/src/test/resources/allure.properties
+++ b/allure-assertj/src/test/resources/allure.properties
@@ -1,2 +1,3 @@
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-assertj
diff --git a/allure-attachments/src/main/java/io/qameta/allure/attachment/AttachmentContent.java b/allure-attachments/src/main/java/io/qameta/allure/attachment/AttachmentContent.java
index 070f2b5c..f3c57536 100644
--- a/allure-attachments/src/main/java/io/qameta/allure/attachment/AttachmentContent.java
+++ b/allure-attachments/src/main/java/io/qameta/allure/attachment/AttachmentContent.java
@@ -16,14 +16,31 @@
 package io.qameta.allure.attachment;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Defines the attachment content contract used by Allure attachment support.
+ *
+ * <p>Implement this interface when custom code needs to participate in the same integration flow as the built-in Allure adapter components.</p>
  */
 public interface AttachmentContent {
 
+    /**
+     * Returns the content.
+     *
+     * @return the content
+     */
     String getContent();
 
+    /**
+     * Returns the content type.
+     *
+     * @return the content type
+     */
     String getContentType();
 
+    /**
+     * Returns the file extension.
+     *
+     * @return the file extension
+     */
     String getFileExtension();
 
 }
diff --git a/allure-attachments/src/main/java/io/qameta/allure/attachment/AttachmentData.java b/allure-attachments/src/main/java/io/qameta/allure/attachment/AttachmentData.java
index f7f6af5f..77d8befe 100644
--- a/allure-attachments/src/main/java/io/qameta/allure/attachment/AttachmentData.java
+++ b/allure-attachments/src/main/java/io/qameta/allure/attachment/AttachmentData.java
@@ -18,11 +18,15 @@
 /**
  * Marker interface for complex Allure attachments.
  *
- * @author charlie (Dmitry Baev).
  */
 @FunctionalInterface
 public interface AttachmentData {
 
+    /**
+     * Returns the name.
+     *
+     * @return the attachment or display name
+     */
     String getName();
 
 }
diff --git a/allure-attachments/src/main/java/io/qameta/allure/attachment/AttachmentProcessor.java b/allure-attachments/src/main/java/io/qameta/allure/attachment/AttachmentProcessor.java
index 06ef35fc..2bfbb211 100644
--- a/allure-attachments/src/main/java/io/qameta/allure/attachment/AttachmentProcessor.java
+++ b/allure-attachments/src/main/java/io/qameta/allure/attachment/AttachmentProcessor.java
@@ -17,11 +17,16 @@
 
 /**
  * @param <T> the type of attachment data.
- * @author charlie (Dmitry Baev).
  */
 @FunctionalInterface
 public interface AttachmentProcessor<T extends AttachmentData> {
 
+    /**
+     * Adds the attachment.
+     *
+     * @param attachmentData the attachment data
+     * @param renderer the renderer used to turn attachment data into content
+     */
     void addAttachment(T attachmentData, AttachmentRenderer<T> renderer);
 
 }
diff --git a/allure-attachments/src/main/java/io/qameta/allure/attachment/AttachmentRenderException.java b/allure-attachments/src/main/java/io/qameta/allure/attachment/AttachmentRenderException.java
index 3a6303e7..b097a0e1 100644
--- a/allure-attachments/src/main/java/io/qameta/allure/attachment/AttachmentRenderException.java
+++ b/allure-attachments/src/main/java/io/qameta/allure/attachment/AttachmentRenderException.java
@@ -16,10 +16,18 @@
 package io.qameta.allure.attachment;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Supports Allure attachment integration with Allure reporting.
+ *
+ * <p>Use this type through the module that owns it when translating framework execution, result metadata, or attachments into Allure report data.</p>
  */
 public class AttachmentRenderException extends RuntimeException {
 
+    /**
+     * Creates an attachment render exception with the supplied values.
+     *
+     * @param message the message
+     * @param cause the failure cause reported by the framework
+     */
     public AttachmentRenderException(final String message, final Throwable cause) {
         super(message, cause);
     }
diff --git a/allure-attachments/src/main/java/io/qameta/allure/attachment/AttachmentRenderer.java b/allure-attachments/src/main/java/io/qameta/allure/attachment/AttachmentRenderer.java
index 15423fc8..ea2cee7d 100644
--- a/allure-attachments/src/main/java/io/qameta/allure/attachment/AttachmentRenderer.java
+++ b/allure-attachments/src/main/java/io/qameta/allure/attachment/AttachmentRenderer.java
@@ -17,9 +17,7 @@
 
 /**
  * @param <T> the type of attachment data
- * @author charlie (Dmitry Baev).
  */
-@SuppressWarnings("PMD.AvoidUncheckedExceptionsInSignatures")
 @FunctionalInterface
 public interface AttachmentRenderer<T extends AttachmentData> {
 
diff --git a/allure-attachments/src/main/java/io/qameta/allure/attachment/DefaultAttachmentContent.java b/allure-attachments/src/main/java/io/qameta/allure/attachment/DefaultAttachmentContent.java
index 2e3f200d..fb70c14f 100644
--- a/allure-attachments/src/main/java/io/qameta/allure/attachment/DefaultAttachmentContent.java
+++ b/allure-attachments/src/main/java/io/qameta/allure/attachment/DefaultAttachmentContent.java
@@ -16,7 +16,9 @@
 package io.qameta.allure.attachment;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Supports Allure attachment integration with Allure reporting.
+ *
+ * <p>Use this type through the module that owns it when translating framework execution, result metadata, or attachments into Allure report data.</p>
  */
 public class DefaultAttachmentContent implements AttachmentContent {
 
@@ -26,6 +28,13 @@ public class DefaultAttachmentContent implements AttachmentContent {
 
     private final String fileExtension;
 
+    /**
+     * Creates a default attachment content with the supplied values.
+     *
+     * @param content the attachment content
+     * @param contentType the attachment content type
+     * @param fileExtension the attachment file extension
+     */
     public DefaultAttachmentContent(final String content,
                                     final String contentType,
                                     final String fileExtension) {
@@ -34,16 +43,25 @@ public DefaultAttachmentContent(final String content,
         this.fileExtension = fileExtension;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public String getContent() {
         return content;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public String getContentType() {
         return contentType;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public String getFileExtension() {
         return fileExtension;
diff --git a/allure-attachments/src/main/java/io/qameta/allure/attachment/DefaultAttachmentProcessor.java b/allure-attachments/src/main/java/io/qameta/allure/attachment/DefaultAttachmentProcessor.java
index 017d1f61..3bfc71a4 100644
--- a/allure-attachments/src/main/java/io/qameta/allure/attachment/DefaultAttachmentProcessor.java
+++ b/allure-attachments/src/main/java/io/qameta/allure/attachment/DefaultAttachmentProcessor.java
@@ -21,20 +21,33 @@
 import java.nio.charset.StandardCharsets;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Supports Allure attachment integration with Allure reporting.
+ *
+ * <p>Use this type through the module that owns it when translating framework execution, result metadata, or attachments into Allure report data.</p>
  */
 public class DefaultAttachmentProcessor implements AttachmentProcessor<AttachmentData> {
 
     private final AllureLifecycle lifecycle;
 
+    /**
+     * Creates a default attachment processor with default configuration.
+     */
     public DefaultAttachmentProcessor() {
         this(Allure.getLifecycle());
     }
 
+    /**
+     * Creates a default attachment processor with the supplied values.
+     *
+     * @param lifecycle the Allure lifecycle to use
+     */
     public DefaultAttachmentProcessor(final AllureLifecycle lifecycle) {
         this.lifecycle = lifecycle;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void addAttachment(final AttachmentData attachmentData,
                               final AttachmentRenderer<AttachmentData> renderer) {
diff --git a/allure-attachments/src/main/java/io/qameta/allure/attachment/FreemarkerAttachmentRenderer.java b/allure-attachments/src/main/java/io/qameta/allure/attachment/FreemarkerAttachmentRenderer.java
index 354956d8..6442cb62 100644
--- a/allure-attachments/src/main/java/io/qameta/allure/attachment/FreemarkerAttachmentRenderer.java
+++ b/allure-attachments/src/main/java/io/qameta/allure/attachment/FreemarkerAttachmentRenderer.java
@@ -26,7 +26,9 @@
 import java.util.Collections;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Supports Allure attachment integration with Allure reporting.
+ *
+ * <p>Use this type through the module that owns it when translating framework execution, result metadata, or attachments into Allure report data.</p>
  */
 public class FreemarkerAttachmentRenderer implements AttachmentRenderer<AttachmentData> {
 
@@ -36,6 +38,11 @@ public class FreemarkerAttachmentRenderer implements AttachmentRenderer<Attachme
 
     private final String templateName;
 
+    /**
+     * Creates a freemarker attachment renderer with the supplied values.
+     *
+     * @param templateName the template name
+     */
     public FreemarkerAttachmentRenderer(final String templateName) {
         this.templateName = templateName;
         this.configuration = new Configuration(Configuration.VERSION_2_3_23);
@@ -45,6 +52,9 @@ public FreemarkerAttachmentRenderer(final String templateName) {
         this.configuration.setClassLoaderForTemplateLoading(getClass().getClassLoader(), "tpl");
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public DefaultAttachmentContent render(final AttachmentData data) {
         try (Writer writer = new StringWriter()) {
diff --git a/allure-attachments/src/main/java/io/qameta/allure/attachment/http/HttpRequestAttachment.java b/allure-attachments/src/main/java/io/qameta/allure/attachment/http/HttpRequestAttachment.java
index 8f35b75b..b58f9c18 100644
--- a/allure-attachments/src/main/java/io/qameta/allure/attachment/http/HttpRequestAttachment.java
+++ b/allure-attachments/src/main/java/io/qameta/allure/attachment/http/HttpRequestAttachment.java
@@ -24,7 +24,9 @@
 import java.util.Objects;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Describes an HTTP or RPC request attachment rendered in an Allure report.
+ *
+ * <p>Use this model to carry request metadata and body content from client interceptors to attachment renderers and processors.</p>
  */
 public class HttpRequestAttachment implements AttachmentData {
 
@@ -44,12 +46,35 @@ public class HttpRequestAttachment implements AttachmentData {
 
     private final Map<String, String> formParams;
 
+    /**
+     * Creates an HTTP request attachment with the supplied values.
+     *
+     * @param name the display name or logical name to use
+     * @param url the request URL or service method name
+     * @param method the framework or Java method to inspect
+     * @param body the attachment body
+     * @param curl the curl
+     * @param headers the headers
+     * @param cookies the cookies
+     */
     public HttpRequestAttachment(final String name, final String url, final String method,
                                  final String body, final String curl, final Map<String, String> headers,
                                  final Map<String, String> cookies) {
         this(name, url, method, body, curl, headers, cookies, Collections.emptyMap());
     }
 
+    /**
+     * Creates an HTTP request attachment with the supplied values.
+     *
+     * @param name the display name or logical name to use
+     * @param url the request URL or service method name
+     * @param method the framework or Java method to inspect
+     * @param body the attachment body
+     * @param curl the curl
+     * @param headers the headers
+     * @param cookies the cookies
+     * @param formParams the form params
+     */
     @SuppressWarnings("checkstyle:parameternumber")
     public HttpRequestAttachment(final String name, final String url, final String method,
                                  final String body, final String curl, final Map<String, String> headers,
@@ -64,39 +89,80 @@ public HttpRequestAttachment(final String name, final String url, final String m
         this.formParams = formParams;
     }
 
+    /**
+     * Returns the url.
+     *
+     * @return the url
+     */
     public String getUrl() {
         return url;
     }
 
+    /**
+     * Returns the method.
+     *
+     * @return the method
+     */
     public String getMethod() {
         return method;
     }
 
+    /**
+     * Returns the body.
+     *
+     * @return the body
+     */
     public String getBody() {
         return body;
     }
 
+    /**
+     * Returns the headers.
+     *
+     * @return the headers
+     */
     public Map<String, String> getHeaders() {
         return headers;
     }
 
+    /**
+     * Returns the cookies.
+     *
+     * @return the cookies
+     */
     public Map<String, String> getCookies() {
         return cookies;
     }
 
+    /**
+     * Returns the form params.
+     *
+     * @return the form params
+     */
     public Map<String, String> getFormParams() {
         return formParams;
     }
 
+    /**
+     * Returns the curl.
+     *
+     * @return the curl
+     */
     public String getCurl() {
         return curl;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public String getName() {
         return name;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public String toString() {
         return "HttpRequestAttachment("
@@ -135,16 +201,36 @@ private Builder(final String name, final String url) {
             this.url = url;
         }
 
+        /**
+         * Creates a builder for a builder.
+         *
+         * @param attachmentName the attachment display name
+         * @param url the request URL or service method name
+         * @return a new builder instance
+         */
         public static Builder create(final String attachmentName, final String url) {
             return new Builder(attachmentName, url);
         }
 
+        /**
+         * Sets the method.
+         *
+         * @param method the framework or Java method to inspect
+         * @return this instance for method chaining
+         */
         public Builder setMethod(final String method) {
             Objects.requireNonNull(method, "Method must not be null value");
             this.method = method;
             return this;
         }
 
+        /**
+         * Sets the header.
+         *
+         * @param name the display name or logical name to use
+         * @param value the value to set
+         * @return this instance for method chaining
+         */
         public Builder setHeader(final String name, final String value) {
             Objects.requireNonNull(name, "Header name must not be null value");
             Objects.requireNonNull(value, "Header value must not be null value");
@@ -152,12 +238,25 @@ public Builder setHeader(final String name, final String value) {
             return this;
         }
 
+        /**
+         * Sets the headers.
+         *
+         * @param headers the headers
+         * @return this instance for method chaining
+         */
         public Builder setHeaders(final Map<String, String> headers) {
             Objects.requireNonNull(headers, "Headers must not be null value");
             this.headers.putAll(headers);
             return this;
         }
 
+        /**
+         * Sets the cookie.
+         *
+         * @param name the display name or logical name to use
+         * @param value the value to set
+         * @return this instance for method chaining
+         */
         public Builder setCookie(final String name, final String value) {
             Objects.requireNonNull(name, "Cookie name must not be null value");
             Objects.requireNonNull(value, "Cookie value must not be null value");
@@ -165,18 +264,36 @@ public Builder setCookie(final String name, final String value) {
             return this;
         }
 
+        /**
+         * Sets the cookies.
+         *
+         * @param cookies the cookies
+         * @return this instance for method chaining
+         */
         public Builder setCookies(final Map<String, String> cookies) {
             Objects.requireNonNull(cookies, "Cookies must not be null value");
             this.cookies.putAll(cookies);
             return this;
         }
 
+        /**
+         * Sets the body.
+         *
+         * @param body the attachment body
+         * @return this instance for method chaining
+         */
         public Builder setBody(final String body) {
             Objects.requireNonNull(body, "Body should not be null value");
             this.body = body;
             return this;
         }
 
+        /**
+         * Sets the form params.
+         *
+         * @param formParams the form params
+         * @return this instance for method chaining
+         */
         public Builder setFormParams(final Map<String, String> formParams) {
             Objects.requireNonNull(formParams, "Form params must not be null value");
             this.formParams.putAll(formParams);
@@ -237,6 +354,11 @@ public Builder withBody(final String body) {
             return setBody(body);
         }
 
+        /**
+         * Builds a builder from the configured values.
+         *
+         * @return the built attachment model
+         */
         public HttpRequestAttachment build() {
             return new HttpRequestAttachment(name, url, method, body, getCurl(), headers, cookies, formParams);
         }
diff --git a/allure-attachments/src/main/java/io/qameta/allure/attachment/http/HttpResponseAttachment.java b/allure-attachments/src/main/java/io/qameta/allure/attachment/http/HttpResponseAttachment.java
index 20187c7c..4a956dba 100644
--- a/allure-attachments/src/main/java/io/qameta/allure/attachment/http/HttpResponseAttachment.java
+++ b/allure-attachments/src/main/java/io/qameta/allure/attachment/http/HttpResponseAttachment.java
@@ -23,7 +23,9 @@
 import java.util.Objects;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Describes an HTTP or RPC response attachment rendered in an Allure report.
+ *
+ * <p>Use this model to carry response metadata and body content from client interceptors to attachment renderers and processors.</p>
  */
 public class HttpResponseAttachment implements AttachmentData {
 
@@ -39,6 +41,16 @@ public class HttpResponseAttachment implements AttachmentData {
 
     private final Map<String, String> cookies;
 
+    /**
+     * Creates an HTTP response attachment with the supplied values.
+     *
+     * @param name the display name or logical name to use
+     * @param url the request URL or service method name
+     * @param body the attachment body
+     * @param responseCode the response code
+     * @param headers the headers
+     * @param cookies the cookies
+     */
     public HttpResponseAttachment(final String name, final String url,
                                   final String body, final int responseCode,
                                   final Map<String, String> headers, final Map<String, String> cookies) {
@@ -50,31 +62,62 @@ public HttpResponseAttachment(final String name, final String url,
         this.cookies = cookies;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public String getName() {
         return name;
     }
 
+    /**
+     * Returns the url.
+     *
+     * @return the url
+     */
     public String getUrl() {
         return url;
     }
 
+    /**
+     * Returns the body.
+     *
+     * @return the body
+     */
     public String getBody() {
         return body;
     }
 
+    /**
+     * Returns the response code.
+     *
+     * @return the response code
+     */
     public int getResponseCode() {
         return responseCode;
     }
 
+    /**
+     * Returns the headers.
+     *
+     * @return the headers
+     */
     public Map<String, String> getHeaders() {
         return headers;
     }
 
+    /**
+     * Returns the cookies.
+     *
+     * @return the cookies
+     */
     public Map<String, String> getCookies() {
         return cookies;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public String toString() {
         return "HttpResponseAttachment("
@@ -109,21 +152,46 @@ private Builder(final String name) {
             this.name = name;
         }
 
+        /**
+         * Creates a builder for a builder.
+         *
+         * @param attachmentName the attachment display name
+         * @return a new builder instance
+         */
         public static Builder create(final String attachmentName) {
             return new Builder(attachmentName);
         }
 
+        /**
+         * Sets the url.
+         *
+         * @param url the request URL or service method name
+         * @return this instance for method chaining
+         */
         public Builder setUrl(final String url) {
             Objects.requireNonNull(url, "Url must not be null value");
             this.url = url;
             return this;
         }
 
+        /**
+         * Sets the response code.
+         *
+         * @param responseCode the response code
+         * @return this instance for method chaining
+         */
         public Builder setResponseCode(final int responseCode) {
             this.responseCode = responseCode;
             return this;
         }
 
+        /**
+         * Sets the header.
+         *
+         * @param name the display name or logical name to use
+         * @param value the value to set
+         * @return this instance for method chaining
+         */
         public Builder setHeader(final String name, final String value) {
             Objects.requireNonNull(name, "Header name must not be null value");
             Objects.requireNonNull(value, "Header value must not be null value");
@@ -131,12 +199,25 @@ public Builder setHeader(final String name, final String value) {
             return this;
         }
 
+        /**
+         * Sets the headers.
+         *
+         * @param headers the headers
+         * @return this instance for method chaining
+         */
         public Builder setHeaders(final Map<String, String> headers) {
             Objects.requireNonNull(headers, "Headers must not be null value");
             this.headers.putAll(headers);
             return this;
         }
 
+        /**
+         * Sets the cookie.
+         *
+         * @param name the display name or logical name to use
+         * @param value the value to set
+         * @return this instance for method chaining
+         */
         public Builder setCookie(final String name, final String value) {
             Objects.requireNonNull(name, "Cookie name must not be null value");
             Objects.requireNonNull(value, "Cookie value must not be null value");
@@ -144,12 +225,24 @@ public Builder setCookie(final String name, final String value) {
             return this;
         }
 
+        /**
+         * Sets the cookies.
+         *
+         * @param cookies the cookies
+         * @return this instance for method chaining
+         */
         public Builder setCookies(final Map<String, String> cookies) {
             Objects.requireNonNull(cookies, "Cookies must not be null value");
             this.cookies.putAll(cookies);
             return this;
         }
 
+        /**
+         * Sets the body.
+         *
+         * @param body the attachment body
+         * @return this instance for method chaining
+         */
         public Builder setBody(final String body) {
             Objects.requireNonNull(body, "Body should not be null value");
             this.body = body;
@@ -226,6 +319,11 @@ public Builder withBody(final String body) {
             return setBody(body);
         }
 
+        /**
+         * Builds a builder from the configured values.
+         *
+         * @return the built attachment model
+         */
         public HttpResponseAttachment build() {
             return new HttpResponseAttachment(name, url, body, responseCode, headers, cookies);
         }
diff --git a/allure-attachments/src/test/java/io/qameta/allure/attachment/DefaultAttachmentProcessorTest.java b/allure-attachments/src/test/java/io/qameta/allure/attachment/DefaultAttachmentProcessorTest.java
index fe84d9cf..f1defa78 100644
--- a/allure-attachments/src/test/java/io/qameta/allure/attachment/DefaultAttachmentProcessorTest.java
+++ b/allure-attachments/src/test/java/io/qameta/allure/attachment/DefaultAttachmentProcessorTest.java
@@ -29,10 +29,6 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class DefaultAttachmentProcessorTest {
 
     @SuppressWarnings("unchecked")
diff --git a/allure-attachments/src/test/java/io/qameta/allure/attachment/FreemarkerAttachmentRendererTest.java b/allure-attachments/src/test/java/io/qameta/allure/attachment/FreemarkerAttachmentRendererTest.java
index 4f0c235e..956080c3 100644
--- a/allure-attachments/src/test/java/io/qameta/allure/attachment/FreemarkerAttachmentRendererTest.java
+++ b/allure-attachments/src/test/java/io/qameta/allure/attachment/FreemarkerAttachmentRendererTest.java
@@ -23,10 +23,6 @@
 import static io.qameta.allure.attachment.testdata.TestData.randomHttpRequestAttachment;
 import static io.qameta.allure.attachment.testdata.TestData.randomHttpResponseAttachment;
 import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class FreemarkerAttachmentRendererTest {
 
     private static final String CONTENT = "content";
@@ -35,7 +31,6 @@ class FreemarkerAttachmentRendererTest {
     private static final String FILE_EXTENSION = "fileExtension";
     private static final String HTML = ".html";
 
-
     @AllureFeatures.Attachments
     @Test
     void shouldRenderRequestAttachment() {
diff --git a/allure-attachments/src/test/java/io/qameta/allure/attachment/NegativeFreemarkerAttachmentRendererTest.java b/allure-attachments/src/test/java/io/qameta/allure/attachment/NegativeFreemarkerAttachmentRendererTest.java
index 444e5c61..5f5ba6d4 100644
--- a/allure-attachments/src/test/java/io/qameta/allure/attachment/NegativeFreemarkerAttachmentRendererTest.java
+++ b/allure-attachments/src/test/java/io/qameta/allure/attachment/NegativeFreemarkerAttachmentRendererTest.java
@@ -29,10 +29,6 @@
 import static io.qameta.allure.attachment.testdata.TestData.negativeHttpRequestAttachment;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertThrows;
-
-/**
- * @author a-simeshin (Simeshin Artem).
- */
 class NegativeFreemarkerAttachmentRendererTest {
 
     private static final String TEMPLATE_FOR_EXCEPTION = "body-npe-non-safe-attachment.ftl";
diff --git a/allure-attachments/src/test/java/io/qameta/allure/attachment/testdata/TestData.java b/allure-attachments/src/test/java/io/qameta/allure/attachment/testdata/TestData.java
index d30634da..3ef9c4c6 100644
--- a/allure-attachments/src/test/java/io/qameta/allure/attachment/testdata/TestData.java
+++ b/allure-attachments/src/test/java/io/qameta/allure/attachment/testdata/TestData.java
@@ -24,10 +24,6 @@
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.ThreadLocalRandom;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public final class TestData {
 
     private TestData() {
diff --git a/allure-attachments/src/test/resources/allure.properties b/allure-attachments/src/test/resources/allure.properties
index 9c0b0a2d..b47a01f6 100644
--- a/allure-attachments/src/test/resources/allure.properties
+++ b/allure-attachments/src/test/resources/allure.properties
@@ -1,2 +1,3 @@
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-attachments
diff --git a/allure-awaitility/src/main/java/io/qameta/allure/awaitility/AllureAwaitilityListener.java b/allure-awaitility/src/main/java/io/qameta/allure/awaitility/AllureAwaitilityListener.java
index 451e3fd9..5cd3b273 100644
--- a/allure-awaitility/src/main/java/io/qameta/allure/awaitility/AllureAwaitilityListener.java
+++ b/allure-awaitility/src/main/java/io/qameta/allure/awaitility/AllureAwaitilityListener.java
@@ -58,7 +58,6 @@
  * </pre>
  * </p>
  *
- * @author a-simeshin (Simeshin Artem)
  * @see org.awaitility.core.ConditionEvaluationListener
  * @see Awaitility#setDefaultConditionEvaluationListener(ConditionEvaluationListener)
  * @see ConditionFactory#conditionEvaluationListener(ConditionEvaluationListener)
@@ -77,14 +76,18 @@ public class AllureAwaitilityListener implements ConditionEvaluationListener<Obj
 
     private String currentConditionStepUUID;
 
-    private static final InheritableThreadLocal<AllureLifecycle> LIFECYCLE
-            = new InheritableThreadLocal<AllureLifecycle>() {
+    private static final InheritableThreadLocal<AllureLifecycle> LIFECYCLE = new InheritableThreadLocal<AllureLifecycle>() {
         @Override
         protected AllureLifecycle initialValue() {
             return Allure.getLifecycle();
         }
     };
 
+    /**
+     * Returns the lifecycle.
+     *
+     * @return the Allure lifecycle used by this integration
+     */
     public static AllureLifecycle getLifecycle() {
         return LIFECYCLE.get();
     }
@@ -225,7 +228,8 @@ public void exceptionIgnored(final IgnoredException ignoredException) {
             getLifecycle().updateStep(awaitilityCondition -> {
                 final String currentExceptionIgnoredStepUUID = UUID.randomUUID().toString();
                 final String message = String.format(
-                        onExceptionStepTextPattern, ignoredException.getThrowable().getMessage());
+                        onExceptionStepTextPattern, ignoredException.getThrowable().getMessage()
+                );
                 final StringWriter stringWriter = new StringWriter();
                 ignoredException.getThrowable().printStackTrace(new PrintWriter(stringWriter));
                 final String stackTrace = stringWriter.toString();
@@ -239,7 +243,8 @@ public void exceptionIgnored(final IgnoredException ignoredException) {
                 );
                 getLifecycle().addAttachment(
                         ignoredException.getThrowable().getMessage(), "text/plain", ".txt",
-                        stackTrace.getBytes(StandardCharsets.UTF_8));
+                        stackTrace.getBytes(StandardCharsets.UTF_8)
+                );
                 getLifecycle().stopStep(currentExceptionIgnoredStepUUID);
             });
         }
diff --git a/allure-awaitility/src/main/java/io/qameta/allure/awaitility/TemporalDuration.java b/allure-awaitility/src/main/java/io/qameta/allure/awaitility/TemporalDuration.java
index 5632b1be..d6243f7f 100644
--- a/allure-awaitility/src/main/java/io/qameta/allure/awaitility/TemporalDuration.java
+++ b/allure-awaitility/src/main/java/io/qameta/allure/awaitility/TemporalDuration.java
@@ -58,11 +58,17 @@ public class TemporalDuration implements TemporalAccessor {
         this.temporal = duration.addTo(BASE);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public boolean isSupported(final TemporalField field) {
         return temporal.isSupported(field) && temporal.getLong(field) - BASE.getLong(field) != 0L;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public long getLong(final TemporalField temporalField) {
         if (!isSupported(temporalField)) {
@@ -71,6 +77,9 @@ public long getLong(final TemporalField temporalField) {
         return temporal.getLong(temporalField) - BASE.getLong(temporalField);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public String toString() {
         if (duration.compareTo(Duration.ofMillis(1)) < 0) {
diff --git a/allure-awaitility/src/test/java/io/qameta/allure/awaitility/ConditionListenersPositiveTest.java b/allure-awaitility/src/test/java/io/qameta/allure/awaitility/ConditionListenersPositiveTest.java
index 59207847..9eb6d7d6 100644
--- a/allure-awaitility/src/test/java/io/qameta/allure/awaitility/ConditionListenersPositiveTest.java
+++ b/allure-awaitility/src/test/java/io/qameta/allure/awaitility/ConditionListenersPositiveTest.java
@@ -58,27 +58,27 @@ static void setup() {
     @TestFactory
     Stream<DynamicNode> globalSettingsAwaitWoAliasCheckTopLevelPassedStep() {
         final List<TestResult> testResult = runWithinTestContext(() -> {
-                    final AtomicInteger atomicInteger = new AtomicInteger(0);
-                    await().with()
-                            .conditionEvaluationListener(new AllureAwaitilityListener())
-                            .atMost(Duration.of(1000, ChronoUnit.MILLIS))
-                            .pollInterval(Duration.of(50, ChronoUnit.MILLIS))
-                            .until(atomicInteger::getAndIncrement, is(3));
-                },
+            final AtomicInteger atomicInteger = new AtomicInteger(0);
+            await().with()
+                    .conditionEvaluationListener(new AllureAwaitilityListener())
+                    .atMost(Duration.of(1000, ChronoUnit.MILLIS))
+                    .pollInterval(Duration.of(50, ChronoUnit.MILLIS))
+                    .until(atomicInteger::getAndIncrement, is(3));
+        },
                 AllureAwaitilityListener::setLifecycle
         ).getTestResults();
 
         return Stream.of(
-                DynamicTest.dynamicTest("Exactly 1 top level step for 1 awaitility condition", () ->
-                        assertThat(testResult.get(0).getSteps())
+                DynamicTest.dynamicTest(
+                        "Exactly 1 top level step for 1 awaitility condition", () -> assertThat(testResult.get(0).getSteps())
                                 .hasSize(1)
                 ),
-                DynamicTest.dynamicTest("Top level step has passed status", () ->
-                        assertThat(testResult.get(0).getSteps())
+                DynamicTest.dynamicTest(
+                        "Top level step has passed status", () -> assertThat(testResult.get(0).getSteps())
                                 .allMatch(step -> Status.PASSED.equals(step.getStatus()))
                 ),
-                DynamicTest.dynamicTest("Top level step has default name because await() wo alias", () ->
-                        assertThat(testResult.get(0).getSteps())
+                DynamicTest.dynamicTest(
+                        "Top level step has default name because await() wo alias", () -> assertThat(testResult.get(0).getSteps())
                                 .extracting(StepResult::getName)
                                 .containsExactly("Awaitility: Starting evaluation")
                 )
@@ -96,13 +96,13 @@ Stream<DynamicNode> globalSettingsAwaitWoAliasCheckTopLevelPassedStep() {
     @Test
     void globalSettingsAwaitWithAliasCheckTopLevelPassedStep() {
         final List<TestResult> testResult = runWithinTestContext(() -> {
-                    final AtomicInteger atomicInteger = new AtomicInteger(0);
-                    await("Counter should be at least 3").with()
-                            .conditionEvaluationListener(new AllureAwaitilityListener())
-                            .atMost(Duration.of(1000, ChronoUnit.MILLIS))
-                            .pollInterval(Duration.of(50, ChronoUnit.MILLIS))
-                            .until(atomicInteger::getAndIncrement, is(3));
-                },
+            final AtomicInteger atomicInteger = new AtomicInteger(0);
+            await("Counter should be at least 3").with()
+                    .conditionEvaluationListener(new AllureAwaitilityListener())
+                    .atMost(Duration.of(1000, ChronoUnit.MILLIS))
+                    .pollInterval(Duration.of(50, ChronoUnit.MILLIS))
+                    .until(atomicInteger::getAndIncrement, is(3));
+        },
                 AllureAwaitilityListener::setLifecycle
         ).getTestResults();
         assertEquals(
@@ -125,51 +125,51 @@ void globalSettingsAwaitWithAliasCheckTopLevelPassedStep() {
     @TestFactory
     Stream<DynamicNode> globalSettingsCheckAwaitWoAliasSecondLevelPassedSteps() {
         final List<TestResult> testResult = runWithinTestContext(() -> {
-                    final AtomicInteger atomicInteger = new AtomicInteger(0);
-                    await().with()
-                            .conditionEvaluationListener(new AllureAwaitilityListener())
-                            .atMost(Duration.of(1000, ChronoUnit.MILLIS))
-                            .pollInterval(Duration.of(50, ChronoUnit.MILLIS))
-                            .until(atomicInteger::getAndIncrement, is(3));
-                },
+            final AtomicInteger atomicInteger = new AtomicInteger(0);
+            await().with()
+                    .conditionEvaluationListener(new AllureAwaitilityListener())
+                    .atMost(Duration.of(1000, ChronoUnit.MILLIS))
+                    .pollInterval(Duration.of(50, ChronoUnit.MILLIS))
+                    .until(atomicInteger::getAndIncrement, is(3));
+        },
                 AllureAwaitilityListener::setLifecycle
         ).getTestResults();
 
         return Stream.of(
-                dynamicTest("Exactly 4 second level steps for 4 polling iterations", () ->
-                        assertThat(testResult.get(0).getSteps().get(0).getSteps())
+                dynamicTest(
+                        "Exactly 4 second level steps for 4 polling iterations", () -> assertThat(testResult.get(0).getSteps().get(0).getSteps())
                                 .hasSize(4)
                 ),
-                dynamicTest("All second level steps has passed statuses", () ->
-                        assertThat(testResult.get(0).getSteps().get(0).getSteps())
+                dynamicTest(
+                        "All second level steps has passed statuses", () -> assertThat(testResult.get(0).getSteps().get(0).getSteps())
                                 .allMatch(x -> x.getStatus().equals(Status.PASSED))
                 ),
-                dynamicTest("Second level step 1 name", () ->
-                        assertThat(testResult.get(0).getSteps().get(0).getSteps().get(0).getName())
+                dynamicTest(
+                        "Second level step 1 name", () -> assertThat(testResult.get(0).getSteps().get(0).getSteps().get(0).getName())
                                 .contains("io.qameta.allure.awaitility.ConditionListenersPositiveTest")
                                 .contains("expected <3> but was <0>")
                                 .contains("elapsed time")
                                 .contains("remaining time")
                                 .contains("last poll interval was")
                 ),
-                dynamicTest("Second level step 2 name", () ->
-                        assertThat(testResult.get(0).getSteps().get(0).getSteps().get(1).getName())
+                dynamicTest(
+                        "Second level step 2 name", () -> assertThat(testResult.get(0).getSteps().get(0).getSteps().get(1).getName())
                                 .contains("io.qameta.allure.awaitility.ConditionListenersPositiveTest")
                                 .contains("expected <3> but was <1>")
                                 .contains("elapsed time")
                                 .contains("remaining time")
                                 .contains("last poll interval was")
                 ),
-                dynamicTest("Second level step 3 name", () ->
-                        assertThat(testResult.get(0).getSteps().get(0).getSteps().get(2).getName())
+                dynamicTest(
+                        "Second level step 3 name", () -> assertThat(testResult.get(0).getSteps().get(0).getSteps().get(2).getName())
                                 .contains("io.qameta.allure.awaitility.ConditionListenersPositiveTest")
                                 .contains("expected <3> but was <2>")
                                 .contains("elapsed time")
                                 .contains("remaining time")
                                 .contains("last poll interval was")
                 ),
-                dynamicTest("Second level step 4 name", () ->
-                        assertThat(testResult.get(0).getSteps().get(0).getSteps().get(3).getName())
+                dynamicTest(
+                        "Second level step 4 name", () -> assertThat(testResult.get(0).getSteps().get(0).getSteps().get(3).getName())
                                 .contains("io.qameta.allure.awaitility.ConditionListenersPositiveTest")
                                 .contains("reached its end value of <3> after")
                                 .contains("remaining time")
diff --git a/allure-awaitility/src/test/java/io/qameta/allure/awaitility/GlobalSettingsNegativeTest.java b/allure-awaitility/src/test/java/io/qameta/allure/awaitility/GlobalSettingsNegativeTest.java
index b01c36cd..c00fcf77 100644
--- a/allure-awaitility/src/test/java/io/qameta/allure/awaitility/GlobalSettingsNegativeTest.java
+++ b/allure-awaitility/src/test/java/io/qameta/allure/awaitility/GlobalSettingsNegativeTest.java
@@ -63,12 +63,12 @@ void setup() {
     @Test
     void globalSettingsAwaitWoAliasCheckTopLevelBrokenStep() {
         final List<TestResult> testResult = runWithinTestContext(() -> {
-                    final AtomicInteger atomicInteger = new AtomicInteger(0);
-                    await().with()
-                            .atMost(Duration.of(1000, ChronoUnit.MILLIS))
-                            .pollInterval(Duration.of(500, ChronoUnit.MILLIS))
-                            .until(atomicInteger::getAndIncrement, is(3));
-                },
+            final AtomicInteger atomicInteger = new AtomicInteger(0);
+            await().with()
+                    .atMost(Duration.of(1000, ChronoUnit.MILLIS))
+                    .pollInterval(Duration.of(500, ChronoUnit.MILLIS))
+                    .until(atomicInteger::getAndIncrement, is(3));
+        },
                 AllureAwaitilityListener::setLifecycle
         ).getTestResults();
         assertEquals(
@@ -90,37 +90,42 @@ void globalSettingsAwaitWoAliasCheckTopLevelBrokenStep() {
     @TestFactory
     Stream<DynamicNode> globalSettingsCheckAwaitWoAliasSecondLevelTimeoutStep() {
         final List<TestResult> testResult = runWithinTestContext(() -> {
-                    final AtomicInteger atomicInteger = new AtomicInteger(0);
-                    await().with()
-                            .atMost(Duration.of(1000, ChronoUnit.MILLIS))
-                            .pollInterval(Duration.of(500, ChronoUnit.MILLIS))
-                            .until(atomicInteger::getAndIncrement, is(3));
-                },
+            final AtomicInteger atomicInteger = new AtomicInteger(0);
+            await().with()
+                    .atMost(Duration.of(1000, ChronoUnit.MILLIS))
+                    .pollInterval(Duration.of(500, ChronoUnit.MILLIS))
+                    .until(atomicInteger::getAndIncrement, is(3));
+        },
                 AllureAwaitilityListener::setLifecycle
         ).getTestResults();
 
         return Stream.of(
-                dynamicTest("Second level steps count", () ->
-                        assertThat(testResult.get(0).getSteps().get(0).getSteps())
+                dynamicTest(
+                        "Second level steps count", () -> assertThat(testResult.get(0).getSteps().get(0).getSteps())
                                 .as("Exactly 2 second level steps for 2 polling iterations")
-                                .hasSize(2)),
-                dynamicTest("Second level step 1 name", () ->
-                        assertThat(testResult.get(0).getSteps().get(0).getSteps().get(0).getName())
+                                .hasSize(2)
+                ),
+                dynamicTest(
+                        "Second level step 1 name", () -> assertThat(testResult.get(0).getSteps().get(0).getSteps().get(0).getName())
                                 .contains("io.qameta.allure.awaitility.GlobalSettingsNegativeTest")
                                 .contains("expected <3> but was <0>")
                                 .contains("elapsed time")
                                 .contains("remaining time")
-                                .contains("last poll interval was")),
-                dynamicTest("Second level step 1 status", () ->
-                        assertThat(testResult.get(0).getSteps().get(0).getSteps().get(0).getStatus())
-                                .isEqualTo(Status.PASSED)),
-                dynamicTest("Second level step 2 name", () ->
-                        assertThat(testResult.get(0).getSteps().get(0).getSteps().get(1).getName())
+                                .contains("last poll interval was")
+                ),
+                dynamicTest(
+                        "Second level step 1 status", () -> assertThat(testResult.get(0).getSteps().get(0).getSteps().get(0).getStatus())
+                                .isEqualTo(Status.PASSED)
+                ),
+                dynamicTest(
+                        "Second level step 2 name", () -> assertThat(testResult.get(0).getSteps().get(0).getSteps().get(1).getName())
                                 .contains("Condition timeout.")
-                                .contains("io.qameta.allure.awaitility.GlobalSettingsNegativeTest")),
-                dynamicTest("Second level step 2 status", () ->
-                        assertThat(testResult.get(0).getSteps().get(0).getSteps().get(1).getStatus())
-                                .isEqualTo(Status.BROKEN))
+                                .contains("io.qameta.allure.awaitility.GlobalSettingsNegativeTest")
+                ),
+                dynamicTest(
+                        "Second level step 2 status", () -> assertThat(testResult.get(0).getSteps().get(0).getSteps().get(1).getStatus())
+                                .isEqualTo(Status.BROKEN)
+                )
         );
     }
 
diff --git a/allure-awaitility/src/test/java/io/qameta/allure/awaitility/GlobalSettingsPositiveTest.java b/allure-awaitility/src/test/java/io/qameta/allure/awaitility/GlobalSettingsPositiveTest.java
index df782ada..dfb3ff3b 100644
--- a/allure-awaitility/src/test/java/io/qameta/allure/awaitility/GlobalSettingsPositiveTest.java
+++ b/allure-awaitility/src/test/java/io/qameta/allure/awaitility/GlobalSettingsPositiveTest.java
@@ -65,29 +65,29 @@ void setup() {
     @Test
     Stream<DynamicNode> globalSettingsAwaitWoAliasCheckTopLevelPassedStep() {
         final List<TestResult> testResult = runWithinTestContext(() -> {
-                    final AtomicInteger atomicInteger = new AtomicInteger(0);
-                    await().with()
-                            .atMost(Duration.of(1000, ChronoUnit.MILLIS))
-                            .pollInterval(Duration.of(50, ChronoUnit.MILLIS))
-                            .until(atomicInteger::getAndIncrement, is(3));
-                },
+            final AtomicInteger atomicInteger = new AtomicInteger(0);
+            await().with()
+                    .atMost(Duration.of(1000, ChronoUnit.MILLIS))
+                    .pollInterval(Duration.of(50, ChronoUnit.MILLIS))
+                    .until(atomicInteger::getAndIncrement, is(3));
+        },
                 AllureAwaitilityListener::setLifecycle
         ).getTestResults();
 
         return Stream.of(
-                dynamicTest("Steps count", () ->
-                        assertThat(testResult.get(0).getSteps())
+                dynamicTest(
+                        "Steps count", () -> assertThat(testResult.get(0).getSteps())
                                 .as("Exactly 1 top level step for 1 awaitility condition")
                                 .hasSize(1)
                 ),
-                dynamicTest("Top level step status", () ->
-                        assertEquals(
+                dynamicTest(
+                        "Top level step status", () -> assertEquals(
                                 Status.PASSED, testResult.get(0).getSteps().get(0).getStatus(),
                                 "Top level step has passed status"
                         )
                 ),
-                dynamicTest("Top level step name", () ->
-                        assertEquals(
+                dynamicTest(
+                        "Top level step name", () -> assertEquals(
                                 "Awaitility: Starting evaluation",
                                 testResult.get(0).getSteps().get(0).getName(),
                                 "Top level step has default name because await() wo alias"
@@ -107,12 +107,12 @@ Stream<DynamicNode> globalSettingsAwaitWoAliasCheckTopLevelPassedStep() {
     @Test
     void globalSettingsAwaitWithAliasCheckTopLevelPassedStep() {
         final List<TestResult> testResult = runWithinTestContext(() -> {
-                    final AtomicInteger atomicInteger = new AtomicInteger(0);
-                    await("Counter should be at least 3").with()
-                            .atMost(Duration.of(1000, ChronoUnit.MILLIS))
-                            .pollInterval(Duration.of(50, ChronoUnit.MILLIS))
-                            .until(atomicInteger::getAndIncrement, is(3));
-                },
+            final AtomicInteger atomicInteger = new AtomicInteger(0);
+            await("Counter should be at least 3").with()
+                    .atMost(Duration.of(1000, ChronoUnit.MILLIS))
+                    .pollInterval(Duration.of(50, ChronoUnit.MILLIS))
+                    .until(atomicInteger::getAndIncrement, is(3));
+        },
                 AllureAwaitilityListener::setLifecycle
         ).getTestResults();
         assertEquals(
@@ -135,24 +135,24 @@ void globalSettingsAwaitWithAliasCheckTopLevelPassedStep() {
     @Test
     Stream<DynamicNode> globalSettingsCheckAwaitWoAliasSecondLevelPassedSteps() {
         final List<TestResult> testResult = runWithinTestContext(() -> {
-                    final AtomicInteger atomicInteger = new AtomicInteger(0);
-                    await().with()
-                            .atMost(Duration.of(1000, ChronoUnit.MILLIS))
-                            .pollInterval(Duration.of(50, ChronoUnit.MILLIS))
-                            .until(atomicInteger::getAndIncrement, is(3));
-                },
+            final AtomicInteger atomicInteger = new AtomicInteger(0);
+            await().with()
+                    .atMost(Duration.of(1000, ChronoUnit.MILLIS))
+                    .pollInterval(Duration.of(50, ChronoUnit.MILLIS))
+                    .until(atomicInteger::getAndIncrement, is(3));
+        },
                 AllureAwaitilityListener::setLifecycle
         ).getTestResults();
 
         return Stream.of(
-                dynamicTest("Second level steps count", () ->
-                        assertEquals(
+                dynamicTest(
+                        "Second level steps count", () -> assertEquals(
                                 4, testResult.get(0).getSteps().get(0).getSteps().size(),
                                 "Exactly 4 second level steps for 4 polling iterations"
                         )
                 ),
-                dynamicTest("Second level steps all passed", () ->
-                        assertThat(testResult.get(0).getSteps().get(0).getSteps())
+                dynamicTest(
+                        "Second level steps all passed", () -> assertThat(testResult.get(0).getSteps().get(0).getSteps())
                                 .extracting(StepResult::getStatus)
                                 .containsExactlyInAnyOrder(
                                         Status.PASSED,
@@ -161,32 +161,32 @@ Stream<DynamicNode> globalSettingsCheckAwaitWoAliasSecondLevelPassedSteps() {
                                         Status.PASSED
                                 )
                 ),
-                dynamicTest("Second level step 1 name", () ->
-                        assertThat(testResult.get(0).getSteps().get(0).getSteps().get(0).getName())
+                dynamicTest(
+                        "Second level step 1 name", () -> assertThat(testResult.get(0).getSteps().get(0).getSteps().get(0).getName())
                                 .contains("io.qameta.allure.awaitility.GlobalSettingsPositiveTest")
                                 .contains("expected <3> but was <0>")
                                 .contains("elapsed time")
                                 .contains("remaining time")
                                 .contains("last poll interval was")
                 ),
-                dynamicTest("Second level step 2 name", () ->
-                        assertThat(testResult.get(0).getSteps().get(0).getSteps().get(1).getName())
+                dynamicTest(
+                        "Second level step 2 name", () -> assertThat(testResult.get(0).getSteps().get(0).getSteps().get(1).getName())
                                 .contains("io.qameta.allure.awaitility.GlobalSettingsPositiveTest")
                                 .contains("expected <3> but was <1>")
                                 .contains("elapsed time")
                                 .contains("remaining time")
                                 .contains("last poll interval was")
                 ),
-                dynamicTest("Second level step 3 name", () ->
-                        assertThat(testResult.get(0).getSteps().get(0).getSteps().get(2).getName())
+                dynamicTest(
+                        "Second level step 3 name", () -> assertThat(testResult.get(0).getSteps().get(0).getSteps().get(2).getName())
                                 .contains("io.qameta.allure.awaitility.GlobalSettingsPositiveTest")
                                 .contains("expected <3> but was <2>")
                                 .contains("elapsed time")
                                 .contains("remaining time")
                                 .contains("last poll interval was")
                 ),
-                dynamicTest("Second level step 4 name", () ->
-                        assertThat(testResult.get(0).getSteps().get(0).getSteps().get(3).getName())
+                dynamicTest(
+                        "Second level step 4 name", () -> assertThat(testResult.get(0).getSteps().get(0).getSteps().get(3).getName())
                                 .contains("io.qameta.allure.awaitility.GlobalSettingsPositiveTest")
                                 .contains("java.util.concurrent.atomic.AtomicInteger:")
                                 .contains("reached its end value of <3> after")
diff --git a/allure-awaitility/src/test/java/io/qameta/allure/awaitility/MultipleConditionsTest.java b/allure-awaitility/src/test/java/io/qameta/allure/awaitility/MultipleConditionsTest.java
index 8acb2782..6b2fff5f 100644
--- a/allure-awaitility/src/test/java/io/qameta/allure/awaitility/MultipleConditionsTest.java
+++ b/allure-awaitility/src/test/java/io/qameta/allure/awaitility/MultipleConditionsTest.java
@@ -43,24 +43,24 @@ void setup() {
     @TestFactory
     Stream<DynamicNode> bothAwaitilityStepsShouldAppearTest() {
         final List<TestResult> testResult = runWithinTestContext(() -> {
-                    await().with()
-                            .alias("First waiting")
-                            .until(() -> true);
-                    await().with()
-                            .alias("Second waiting")
-                            .until(() -> true);
-                },
+            await().with()
+                    .alias("First waiting")
+                    .until(() -> true);
+            await().with()
+                    .alias("Second waiting")
+                    .until(() -> true);
+        },
                 AllureAwaitilityListener::setLifecycle
         ).getTestResults();
 
         return Stream.of(
-                DynamicTest.dynamicTest("Exactly 2 top level step for 2 awaitility condition", () ->
-                        assertThat(testResult.get(0).getSteps())
+                DynamicTest.dynamicTest(
+                        "Exactly 2 top level step for 2 awaitility condition", () -> assertThat(testResult.get(0).getSteps())
                                 .describedAs("Allure TestResult contains exactly 2 top level step for 2 awaitility condition")
                                 .hasSize(2)
                 ),
-                DynamicTest.dynamicTest("All top level step for all awaitility condition has PASSED", () ->
-                        assertThat(testResult.get(0).getSteps())
+                DynamicTest.dynamicTest(
+                        "All top level step for all awaitility condition has PASSED", () -> assertThat(testResult.get(0).getSteps())
                                 .describedAs("Allure TestResult contains all top level step for all awaitility with PASSED condition")
                                 .allMatch(step -> Status.PASSED.equals(step.getStatus()))
                 )
diff --git a/allure-awaitility/src/test/resources/allure.properties b/allure-awaitility/src/test/resources/allure.properties
new file mode 100644
index 00000000..0486d8a7
--- /dev/null
+++ b/allure-awaitility/src/test/resources/allure.properties
@@ -0,0 +1,3 @@
+allure.results.directory=build/allure-results
+allure.label.epic=#project.description#
+allure.label.module=allure-awaitility
diff --git a/allure-bom/build.gradle.kts b/allure-bom/build.gradle.kts
index 9593300a..0d83d95e 100644
--- a/allure-bom/build.gradle.kts
+++ b/allure-bom/build.gradle.kts
@@ -8,6 +8,8 @@ dependencies {
     constraints {
         rootProject.subprojects.sorted()
                 .forEach { api("${it.group}:${it.name}:${it.version}") }
+        api("io.qameta.allure:allure-junit5:${project.version}")
+        api("io.qameta.allure:allure-junit5-assert:${project.version}")
     }
 }
 
diff --git a/allure-citrus/src/main/java/io/qameta/allure/citrus/AllureCitrus.java b/allure-citrus/src/main/java/io/qameta/allure/citrus/AllureCitrus.java
index d501b3a2..cc5e669d 100644
--- a/allure-citrus/src/main/java/io/qameta/allure/citrus/AllureCitrus.java
+++ b/allure-citrus/src/main/java/io/qameta/allure/citrus/AllureCitrus.java
@@ -59,10 +59,13 @@
 import static io.qameta.allure.util.ResultsUtils.createParameter;
 import static io.qameta.allure.util.ResultsUtils.createSuiteLabel;
 import static io.qameta.allure.util.ResultsUtils.createThreadLabel;
+import static io.qameta.allure.util.ResultsUtils.createTitlePath;
 import static io.qameta.allure.util.ResultsUtils.getProvidedLabels;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Reports Citrus test execution to Allure.
+ *
+ * <p>Register this listener with Citrus so suite, test case, and test action events are reflected as Allure containers, fixtures, tests, and steps. The listener can use the global lifecycle or an explicitly provided lifecycle.</p>
  */
 public class AllureCitrus implements TestListener, TestSuiteListener, TestActionListener {
 
@@ -72,64 +75,107 @@ public class AllureCitrus implements TestListener, TestSuiteListener, TestAction
 
     private final AllureLifecycle lifecycle;
 
+    /**
+     * Creates an Allure citrus with the supplied values.
+     *
+     * @param lifecycle the Allure lifecycle to use
+     */
     public AllureCitrus(final AllureLifecycle lifecycle) {
         this.lifecycle = lifecycle;
     }
 
+    /**
+     * Creates an Allure citrus with default configuration.
+     */
     @SuppressWarnings("unused")
     public AllureCitrus() {
         this.lifecycle = Allure.getLifecycle();
     }
 
+    /**
+     * Returns the lifecycle.
+     *
+     * @return the Allure lifecycle used by this integration
+     */
     public AllureLifecycle getLifecycle() {
         return lifecycle;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void onStart() {
         //do nothing
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void onStartSuccess() {
         //do nothing
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void onStartFailure(final Throwable cause) {
         //do nothing
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void onFinish() {
         //do nothing
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void onFinishSuccess() {
         //do nothing
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void onFinishFailure(final Throwable cause) {
         //do nothing
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void onTestStart(final TestCase test) {
         startTestCase(test);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void onTestFinish(final TestCase test) {
         //do nothing
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void onTestSuccess(final TestCase test) {
         stopTestCase(test, Status.PASSED, null);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void onTestFailure(final TestCase test, final Throwable cause) {
         final Status status = ResultsUtils.getStatus(cause).orElse(Status.BROKEN);
@@ -137,11 +183,17 @@ public void onTestFailure(final TestCase test, final Throwable cause) {
         stopTestCase(test, status, details);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void onTestSkipped(final TestCase test) {
         //do nothing
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void onTestActionStart(final TestCase testCase, final TestAction testAction) {
         final String parentUuid = getUuid(testCase);
@@ -149,11 +201,17 @@ public void onTestActionStart(final TestCase testCase, final TestAction testActi
         getLifecycle().startStep(parentUuid, uuid, new StepResult().setName(testAction.getName()));
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void onTestActionFinish(final TestCase testCase, final TestAction testAction) {
         getLifecycle().stopStep();
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void onTestActionSkipped(final TestCase testCase, final TestAction testAction) {
         //do nothing
@@ -161,25 +219,31 @@ public void onTestActionSkipped(final TestCase testCase, final TestAction testAc
 
     private void startTestCase(final TestCase testCase) {
         final String uuid = createUuid(testCase);
+        final Optional<? extends Class<?>> testClass = Optional.ofNullable(testCase.getTestClass());
 
         final TestResult result = new TestResult()
                 .setUuid(uuid)
                 .setName(testCase.getName())
+                .setTitlePath(
+                        testClass
+                                .map(ResultsUtils::createTitlePathFromJavaClass)
+                                .orElseGet(() -> createTitlePath(testCase.getName()))
+                )
                 .setStage(Stage.RUNNING);
 
         result.getLabels().addAll(getProvidedLabels());
 
-
-        final Optional<? extends Class<?>> testClass = Optional.ofNullable(testCase.getTestClass());
         testClass.map(this::getLabels).ifPresent(result.getLabels()::addAll);
         testClass.map(this::getLinks).ifPresent(result.getLinks()::addAll);
 
-        result.getLabels().addAll(Arrays.asList(
-                createHostLabel(),
-                createThreadLabel(),
-                createFrameworkLabel("citrus"),
-                createLanguageLabel("java")
-        ));
+        result.getLabels().addAll(
+                Arrays.asList(
+                        createHostLabel(),
+                        createThreadLabel(),
+                        createFrameworkLabel("citrus"),
+                        createLanguageLabel("java")
+                )
+        );
 
         testClass.ifPresent(aClass -> {
             final String suiteName = aClass.getCanonicalName();
@@ -217,7 +281,6 @@ private void stopTestCase(final TestCase testCase,
         getLifecycle().writeTestCase(uuid);
     }
 
-
     private String createUuid(final TestCase testCase) {
         final String uuid = UUID.randomUUID().toString();
         try {
@@ -265,7 +328,8 @@ private List<Link> getLinks(final AnnotatedElement annotatedElement) {
         return Stream.of(
                 getAnnotations(annotatedElement, io.qameta.allure.Link.class).map(ResultsUtils::createLink),
                 getAnnotations(annotatedElement, io.qameta.allure.Issue.class).map(ResultsUtils::createLink),
-                getAnnotations(annotatedElement, io.qameta.allure.TmsLink.class).map(ResultsUtils::createLink))
+                getAnnotations(annotatedElement, io.qameta.allure.TmsLink.class).map(ResultsUtils::createLink)
+        )
                 .reduce(Stream::concat).orElseGet(Stream::empty).collect(Collectors.toList());
     }
 
diff --git a/allure-citrus/src/test/java/io/qameta/allure/citrus/AllureCitrusTest.java b/allure-citrus/src/test/java/io/qameta/allure/citrus/AllureCitrusTest.java
index bf12e299..71202f2b 100644
--- a/allure-citrus/src/test/java/io/qameta/allure/citrus/AllureCitrusTest.java
+++ b/allure-citrus/src/test/java/io/qameta/allure/citrus/AllureCitrusTest.java
@@ -44,10 +44,6 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.tuple;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @SuppressWarnings("unchecked")
 class AllureCitrusTest {
 
@@ -61,6 +57,8 @@ void shouldSetName() {
         assertThat(results.getTestResults())
                 .extracting(TestResult::getName)
                 .containsExactly("Simple test");
+        assertThat(results.getTestResults().get(0).getTitlePath())
+                .containsExactly("com", "consol", "citrus", "dsl", "design", "DefaultTestDesigner");
     }
 
     @AllureFeatures.PassedTests
diff --git a/allure-citrus/src/test/resources/allure.properties b/allure-citrus/src/test/resources/allure.properties
index 9c0b0a2d..0833b8e0 100644
--- a/allure-citrus/src/test/resources/allure.properties
+++ b/allure-citrus/src/test/resources/allure.properties
@@ -1,2 +1,3 @@
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-citrus
diff --git a/allure-cucumber4-jvm/src/main/java/cucumber/runtime/formatter/TestSourcesModelProxy.java b/allure-cucumber4-jvm/src/main/java/cucumber/runtime/formatter/TestSourcesModelProxy.java
index f0209d58..1c19d47b 100644
--- a/allure-cucumber4-jvm/src/main/java/cucumber/runtime/formatter/TestSourcesModelProxy.java
+++ b/allure-cucumber4-jvm/src/main/java/cucumber/runtime/formatter/TestSourcesModelProxy.java
@@ -20,28 +20,59 @@
 import gherkin.ast.ScenarioDefinition;
 
 /**
- * Proxy class to internal Cucumber implementation of TestSourcesModel.
+ * Compatibility proxy around Cucumber feature source storage.
+ *
+ * <p>The proxy hides version-specific Cucumber source model APIs from the reporting plugin. Integrations use it to add source-read events and resolve feature, scenario, and step keyword metadata during execution.</p>
  */
 public class TestSourcesModelProxy {
 
     private final TestSourcesModel testSources;
 
+    /**
+     * Creates a test sources model proxy with default configuration.
+     */
     public TestSourcesModelProxy() {
         this.testSources = new TestSourcesModel();
     }
 
+    /**
+     * Adds the test source read event.
+     *
+     * @param path the path to read from or write to
+     * @param event the framework event to process
+     */
     public void addTestSourceReadEvent(final String path, final TestSourceRead event) {
         testSources.addTestSourceReadEvent(path, event);
     }
 
+    /**
+     * Returns the feature.
+     *
+     * @param path the path to read from or write to
+     * @return the feature
+     */
     public Feature getFeature(final String path) {
         return testSources.getFeature(path);
     }
 
+    /**
+     * Returns the scenario definition.
+     *
+     * @param path the path to read from or write to
+     * @param line the source line number to resolve
+     * @return the scenario definition
+     */
     public ScenarioDefinition getScenarioDefinition(final String path, final int line) {
         return testSources.getScenarioDefinition(path, line);
     }
 
+    /**
+     * Returns the keyword from source.
+     *
+     * @param uri the feature file URI
+     * @param stepLine the feature file line number of the step
+     * @return the keyword from source
+     */
     public String getKeywordFromSource(final String uri, final int stepLine) {
         return testSources.getKeywordFromSource(uri, stepLine);
     }
diff --git a/allure-cucumber4-jvm/src/main/java/io/qameta/allure/cucumber4jvm/AllureCucumber4Jvm.java b/allure-cucumber4-jvm/src/main/java/io/qameta/allure/cucumber4jvm/AllureCucumber4Jvm.java
index 967ee1a3..cc291892 100644
--- a/allure-cucumber4-jvm/src/main/java/io/qameta/allure/cucumber4jvm/AllureCucumber4Jvm.java
+++ b/allure-cucumber4-jvm/src/main/java/io/qameta/allure/cucumber4jvm/AllureCucumber4Jvm.java
@@ -71,18 +71,25 @@
 
 import static cucumber.api.HookType.Before;
 import static io.qameta.allure.util.ResultsUtils.createParameter;
+import static io.qameta.allure.util.ResultsUtils.createTitlePath;
+import static io.qameta.allure.util.ResultsUtils.createTitlePathFromSourcePath;
 import static io.qameta.allure.util.ResultsUtils.getStatus;
 import static io.qameta.allure.util.ResultsUtils.getStatusDetails;
 import static io.qameta.allure.util.ResultsUtils.md5;
 
 /**
- * Allure plugin for Cucumber JVM 4.0.
+ * Reports Cucumber JVM 4 execution to Allure.
+ *
+ * <p>Add this plugin to the Cucumber runtime so feature, scenario, step, hook, and attachment events are converted into Allure results. Use the default lifecycle for normal runs or pass one explicitly for embedded runners and tests.</p>
  */
-@SuppressWarnings({
-        "ClassDataAbstractionCoupling",
-        "ClassFanOutComplexity",
-        "MultipleStringLiterals",
-})
+@SuppressWarnings(
+    {
+            "ClassDataAbstractionCoupling",
+            "ClassFanOutComplexity",
+            "MultipleStringLiterals",
+            "PMD.GodClass",
+    }
+)
 public class AllureCucumber4Jvm implements ConcurrentEventListener {
 
     private static final String COLON = ":";
@@ -108,15 +115,26 @@ public class AllureCucumber4Jvm implements ConcurrentEventListener {
     private static final String TEXT_PLAIN = "text/plain";
     private static final String CUCUMBER_WORKING_DIR = Paths.get("").toUri().getSchemeSpecificPart();
 
+    /**
+     * Creates an Allure cucumber4 jvm with default configuration.
+     */
     @SuppressWarnings("unused")
     public AllureCucumber4Jvm() {
         this(Allure.getLifecycle());
     }
 
+    /**
+     * Creates an Allure cucumber4 jvm with the supplied values.
+     *
+     * @param lifecycle the Allure lifecycle to use
+     */
     public AllureCucumber4Jvm(final AllureLifecycle lifecycle) {
         this.lifecycle = lifecycle;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void setEventPublisher(final EventPublisher publisher) {
         publisher.registerHandlerFor(TestSourceRead.class, featureStartedHandler);
@@ -144,11 +162,11 @@ private void handleTestCaseStarted(final TestCaseStarted event) {
 
         final String name = testCase.getName();
 
-
         // the same way full name is generated for
         // org.junit.platform.engine.support.descriptor.ClasspathResourceSource
         // to support io.qameta.allure.junitplatform.AllurePostDiscoveryFilter
-        final String fullName = String.format("%s:%d",
+        final String fullName = String.format(
+                "%s:%d",
                 getTestCaseUri(testCase),
                 testCase.getLine()
         );
@@ -156,20 +174,23 @@ private void handleTestCaseStarted(final TestCaseStarted event) {
         final String testCaseUuid = testCaseUuids
                 .computeIfAbsent(testCase, tc -> UUID.randomUUID().toString());
 
+        final List<String> titlePath = createTitlePathFromSourcePath(getTestCaseUri(testCase));
+        titlePath.addAll(createTitlePath(feature.getName()));
+
         final TestResult result = new TestResult()
                 .setUuid(testCaseUuid)
                 .setTestCaseId(getTestCaseId(testCase))
                 .setHistoryId(getHistoryId(testCase))
                 .setFullName(fullName)
+                .setTitlePath(titlePath)
                 .setName(name)
                 .setLabels(labelBuilder.getScenarioLabels())
                 .setLinks(labelBuilder.getScenarioLinks());
 
-        final ScenarioDefinition scenarioDefinition =
-                testSources.getScenarioDefinition(
-                        testCase.getUri(),
-                        testCase.getLine()
-                );
+        final ScenarioDefinition scenarioDefinition = testSources.getScenarioDefinition(
+                testCase.getUri(),
+                testCase.getLine()
+        );
 
         if (scenarioDefinition instanceof ScenarioOutline) {
             result.setParameters(
@@ -209,9 +230,10 @@ private void handleTestCaseFinished(final TestCaseFinished event) {
                 .setMuted(tagParser.isMuted())
                 .setKnown(tagParser.isKnown());
 
-        lifecycle.updateTestCase(uuid, testResult -> testResult
-                .setStatus(status)
-                .setStatusDetails(statusDetails)
+        lifecycle.updateTestCase(
+                uuid, testResult -> testResult
+                        .setStatus(status)
+                        .setStatusDetails(statusDetails)
         );
 
         lifecycle.stopTestCase(uuid);
@@ -297,13 +319,13 @@ private void handleStartFixtureHook(final TestCase testCase,
             return;
         }
 
-
         final String containerUuid = hookStepContainerUuid
                 .computeIfAbsent(hook, unused -> UUID.randomUUID().toString());
 
-        lifecycle.startTestContainer(new TestResultContainer()
-                .setUuid(containerUuid)
-                .setChildren(Collections.singletonList(uuid))
+        lifecycle.startTestContainer(
+                new TestResultContainer()
+                        .setUuid(containerUuid)
+                        .setChildren(Collections.singletonList(uuid))
         );
 
         final FixtureResult hookResult = new FixtureResult()
@@ -402,15 +424,14 @@ private Status translateTestCaseStatus(final Result testCaseResult) {
     }
 
     private List<Parameter> getExamplesAsParameters(
-            final ScenarioOutline scenario,
-            final TestCase localCurrentTestCase) {
-        final Optional<Examples> maybeExample =
-                scenario.getExamples().stream()
-                        .filter(example -> example.getTableBody().stream()
-                                .anyMatch(row -> row.getLocation().getLine()
-                                                 == localCurrentTestCase.getLine())
-                        )
-                        .findFirst();
+                                                    final ScenarioOutline scenario,
+                                                    final TestCase localCurrentTestCase) {
+        final Optional<Examples> maybeExample = scenario.getExamples().stream()
+                .filter(
+                        example -> example.getTableBody().stream()
+                                .anyMatch(row -> row.getLocation().getLine() == localCurrentTestCase.getLine())
+                )
+                .findFirst();
 
         if (!maybeExample.isPresent()) {
             return Collections.emptyList();
@@ -449,8 +470,10 @@ private void createDataTableAttachment(final PickleTable pickleTable) {
         }
         final String attachmentSource = lifecycle
                 .prepareAttachment("Data table", "text/tab-separated-values", "csv");
-        lifecycle.writeAttachment(attachmentSource,
-                new ByteArrayInputStream(dataTableCsv.toString().getBytes(StandardCharsets.UTF_8)));
+        lifecycle.writeAttachment(
+                attachmentSource,
+                new ByteArrayInputStream(dataTableCsv.toString().getBytes(StandardCharsets.UTF_8))
+        );
     }
 
     private void handleStopHookStep(final Result eventResult,
@@ -471,9 +494,10 @@ private void handleStopHookStep(final Result eventResult,
         final StatusDetails statusDetails = getStatusDetails(eventResult.getError())
                 .orElseGet(StatusDetails::new);
 
-        lifecycle.updateFixture(uuid, result -> result
-                .setStatus(status)
-                .setStatusDetails(statusDetails)
+        lifecycle.updateFixture(
+                uuid, result -> result
+                        .setStatus(status)
+                        .setStatusDetails(statusDetails)
         );
         lifecycle.stopFixture(uuid);
 
@@ -494,8 +518,7 @@ private void handleStopStep(final TestCase testCase,
 
         final Status stepStatus = translateTestCaseStatus(eventResult);
 
-        final StatusDetails statusDetails
-                = eventResult.getStatus() == Result.Type.UNDEFINED
+        final StatusDetails statusDetails = eventResult.getStatus() == Result.Type.UNDEFINED
                 ? new StatusDetails().setMessage("Undefined Step. Please add step definition")
                 : getStatusDetails(eventResult.getError())
                         .orElse(new StatusDetails());
diff --git a/allure-cucumber4-jvm/src/main/java/io/qameta/allure/cucumber4jvm/LabelBuilder.java b/allure-cucumber4-jvm/src/main/java/io/qameta/allure/cucumber4jvm/LabelBuilder.java
index 0424e6e1..1f54ea8f 100644
--- a/allure-cucumber4-jvm/src/main/java/io/qameta/allure/cucumber4jvm/LabelBuilder.java
+++ b/allure-cucumber4-jvm/src/main/java/io/qameta/allure/cucumber4jvm/LabelBuilder.java
@@ -49,7 +49,7 @@
 /**
  * Scenario labels and links builder.
  */
-@SuppressWarnings({"CyclomaticComplexity", "MultipleStringLiterals"})
+@SuppressWarnings({"CyclomaticComplexity", "MultipleStringLiterals", "PMD.CognitiveComplexity"})
 final class LabelBuilder {
     private static final Logger LOGGER = LoggerFactory.getLogger(LabelBuilder.class);
     private static final String COMPOSITE_TAG_DELIMITER = "=";
@@ -116,17 +116,19 @@ final class LabelBuilder {
         final String uri = scenario.getUri();
 
         scenarioLabels.addAll(ResultsUtils.getProvidedLabels());
-        scenarioLabels.addAll(Arrays.asList(
-                createHostLabel(),
-                createThreadLabel(),
-                createFeatureLabel(featureName),
-                createStoryLabel(scenario.getName()),
-                createSuiteLabel(featureName),
-                createTestClassLabel(scenario.getName()),
-                createFrameworkLabel("cucumber4jvm"),
-                createLanguageLabel("java"),
-                createLabel("gherkin_uri", uri)
-        ));
+        scenarioLabels.addAll(
+                Arrays.asList(
+                        createHostLabel(),
+                        createThreadLabel(),
+                        createFeatureLabel(featureName),
+                        createStoryLabel(scenario.getName()),
+                        createSuiteLabel(featureName),
+                        createTestClassLabel(scenario.getName()),
+                        createFrameworkLabel("cucumber4jvm"),
+                        createLanguageLabel("java"),
+                        createLabel("gherkin_uri", uri)
+                )
+        );
 
         featurePackage(uri, featureName)
                 .map(ResultsUtils::createPackageLabel)
@@ -159,8 +161,10 @@ private void tryHandleNamedLink(final String tagString) {
             final String name = tagString.split(COMPOSITE_TAG_DELIMITER)[1];
             scenarioLinks.add(ResultsUtils.createLink(null, name, null, type));
         } else {
-            LOGGER.warn("Composite named tag {} does not match regex {}. Skipping", tagString,
-                    namedLinkPatternString);
+            LOGGER.warn(
+                    "Composite named tag {} does not match regex {}. Skipping", tagString,
+                    namedLinkPatternString
+            );
         }
     }
 
@@ -178,10 +182,12 @@ private Optional<String> featurePackage(final String uriString, final String fea
         final String schemeSpecificPart = uri.normalize().getSchemeSpecificPart();
         final Stream<String> folders = Stream.of(schemeSpecificPart.replaceAll("\\.", "_").split("/"));
         final Stream<String> name = Stream.of(featureName);
-        return Optional.of(Stream.concat(folders, name)
-                .filter(Objects::nonNull)
-                .filter(s -> !s.isEmpty())
-                .collect(Collectors.joining(".")));
+        return Optional.of(
+                Stream.concat(folders, name)
+                        .filter(Objects::nonNull)
+                        .filter(s -> !s.isEmpty())
+                        .collect(Collectors.joining("."))
+        );
     }
 
     private static Optional<URI> safeUri(final String uri) {
diff --git a/allure-cucumber4-jvm/src/main/java/io/qameta/allure/cucumber4jvm/TagParser.java b/allure-cucumber4-jvm/src/main/java/io/qameta/allure/cucumber4jvm/TagParser.java
index 4839d4ea..cc4b120d 100644
--- a/allure-cucumber4-jvm/src/main/java/io/qameta/allure/cucumber4jvm/TagParser.java
+++ b/allure-cucumber4-jvm/src/main/java/io/qameta/allure/cucumber4jvm/TagParser.java
@@ -52,9 +52,9 @@ public boolean isKnown() {
 
     private boolean getStatusDetailByTag(final String tagName) {
         return scenario.getTags().stream()
-                       .anyMatch(tag -> tag.getName().equalsIgnoreCase(tagName))
-               || feature.getTags().stream()
-                       .anyMatch(tag -> tag.getName().equalsIgnoreCase(tagName));
+                .anyMatch(tag -> tag.getName().equalsIgnoreCase(tagName))
+                || feature.getTags().stream()
+                        .anyMatch(tag -> tag.getName().equalsIgnoreCase(tagName));
     }
 
     public boolean isResultTag(final PickleTag tag) {
diff --git a/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/AllureCucumber4JvmTest.java b/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/AllureCucumber4JvmTest.java
index 85a1d093..dc6b6bb0 100644
--- a/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/AllureCucumber4JvmTest.java
+++ b/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/AllureCucumber4JvmTest.java
@@ -62,10 +62,6 @@
 import static org.assertj.core.api.Assertions.tuple;
 import static org.junit.jupiter.api.parallel.ResourceAccessMode.READ_WRITE;
 import static org.junit.jupiter.api.parallel.Resources.SYSTEM_PROPERTIES;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class AllureCucumber4JvmTest {
 
     @AllureFeatures.Base
@@ -77,6 +73,8 @@ void shouldSetName() {
         assertThat(testResults)
                 .extracting(TestResult::getName)
                 .containsExactlyInAnyOrder("Add a to b");
+        assertThat(testResults.get(0).getTitlePath())
+                .containsExactly("src", "test", "resources", "features", "simple.feature", "Simple feature");
     }
 
     @AllureFeatures.PassedTests
@@ -180,7 +178,7 @@ void shouldSetDescription() {
         final AllureResults results = runFeature("features/description.feature");
 
         final String expected = "This is description for current feature.\n"
-                                + "It should appear on each scenario in report";
+                + "It should appear on each scenario in report";
 
         final List<TestResult> testResults = results.getTestResults();
         assertThat(testResults)
@@ -197,7 +195,7 @@ void shouldSetScenarioDescription() {
         final AllureResults results = runFeature("features/scenario_description.feature");
 
         final String expected = "This is description for current feature.\n"
-                                + "It should appear on each scenario in report";
+                + "It should appear on each scenario in report";
 
         final List<TestResult> testResults = results.getTestResults();
         assertThat(testResults)
@@ -235,11 +233,12 @@ void shouldAddDataTableAttachment() {
         final String attachmentContent = new String(bytes, StandardCharsets.UTF_8);
 
         assertThat(attachmentContent)
-                .isEqualTo("""
-                        name\tlogin\temail
-                        Viktor\tclicman\tclicman@ya.ru
-                        Viktor2\tclicman2\tclicman2@ya.ru
+                .isEqualTo(
                         """
+                                name\tlogin\temail
+                                Viktor\tclicman\tclicman@ya.ru
+                                Viktor2\tclicman2\tclicman2@ya.ru
+                                """
                 );
 
     }
@@ -378,8 +377,14 @@ void shouldAddTags() {
 
     @AllureFeatures.Links
     @ExtendWith(SystemPropertyExtension.class)
-    @SystemProperty(name = "allure.link.issue.pattern", value = "https://example.org/issue/{}")
-    @SystemProperty(name = "allure.link.tms.pattern", value = "https://example.org/tms/{}")
+    @SystemProperty(
+            name = "allure.link.issue.pattern",
+            value = "https://example.org/issue/{}"
+    )
+    @SystemProperty(
+            name = "allure.link.tms.pattern",
+            value = "https://example.org/tms/{}"
+    )
     @Test
     void shouldAddLinks() {
         final AllureResults results = runFeature("features/tags.feature");
@@ -508,8 +513,10 @@ void shouldSupportDryRunForSimpleFeatures() {
     @AllureFeatures.Base
     @Test
     void shouldSupportDryRunForHooks() {
-        final AllureResults results = runFeature("features/hooks.feature", "--dry-run", "-t",
-                "@WithHooks or @BeforeHookWithException or @AfterHookWithException");
+        final AllureResults results = runFeature(
+                "features/hooks.feature", "--dry-run", "-t",
+                "@WithHooks or @BeforeHookWithException or @AfterHookWithException"
+        );
 
         final TestResult tr1 = results.getTestResultByName("Simple scenario with Before and After hooks");
 
@@ -649,8 +656,10 @@ void shouldProcessScenariosInParallelMode() {
     @AllureFeatures.Stages
     @Test
     void shouldDisplayHooksAsStages() {
-        final AllureResults results = runFeature("features/hooks.feature", "-t",
-                "@WithHooks or @BeforeHookWithException or @AfterHookWithException");
+        final AllureResults results = runFeature(
+                "features/hooks.feature", "-t",
+                "@WithHooks or @BeforeHookWithException or @AfterHookWithException"
+        );
 
         final TestResult tr1 = results.getTestResultByName("Simple scenario with Before and After hooks");
         final TestResult tr2 = results.getTestResultByName("Simple scenario with Before hook with Exception");
@@ -688,7 +697,6 @@ void shouldDisplayHooksAsStages() {
                         tuple("Then result is 15", Status.SKIPPED)
                 );
 
-
         assertThat(results.getTestResultContainersForTestResult(tr2))
                 .flatExtracting(TestResultContainer::getBefores)
                 .extracting(FixtureResult::getName, FixtureResult::getStatus)
@@ -734,8 +742,14 @@ void shouldHandleAmbigiousStepsExceptions() {
                 );
     }
 
-    @ResourceLock(value = SYSTEM_PROPERTIES, mode = READ_WRITE)
-    @SystemProperty(name = "allure.label.x-provided", value = "cucumberjvm5-test-provided")
+    @ResourceLock(
+            value = SYSTEM_PROPERTIES,
+            mode = READ_WRITE
+    )
+    @SystemProperty(
+            name = "allure.label.x-provided",
+            value = "cucumberjvm5-test-provided"
+    )
     @Test
     void shouldSupportProvidedLabels() {
         final AllureResults results = runFeature("features/simple.feature");
@@ -780,7 +794,10 @@ void shouldSupportRuntimeApiInStepsWhenHooksAreUsed() {
                 );
     }
 
-    @SystemProperty(name = "cucumber.junit-platform.naming-strategy", value = "long")
+    @SystemProperty(
+            name = "cucumber.junit-platform.naming-strategy",
+            value = "long"
+    )
     @Step
     private AllureResults runFeature(final String featureResource,
                                      final String... moreOptions) {
@@ -788,17 +805,18 @@ private AllureResults runFeature(final String featureResource,
             final AllureCucumber4Jvm cucumber4Jvm = new AllureCucumber4Jvm(lifecycle);
             final ClassLoader classLoader = currentThread().getContextClassLoader();
             final ResourceLoader resourceLoader = new MultiLoader(classLoader);
-            final List<String> opts = new ArrayList<>(Arrays.asList(
-                    "--glue", "io.qameta.allure.cucumber4jvm.samples",
-                    "--plugin", "null_summary"
-            ));
+            final List<String> opts = new ArrayList<>(
+                    Arrays.asList(
+                            "--glue", "io.qameta.allure.cucumber4jvm.samples",
+                            "--plugin", "null_summary"
+                    )
+            );
             opts.addAll(Arrays.asList(moreOptions));
             final FeatureWithLines featureWithLines = FeatureWithLines.parse("src/test/resources/" + featureResource);
             final RuntimeOptions options = new CommandlineOptionsParser()
                     .parse(opts.toArray(new String[]{})).addFeature(featureWithLines).build();
 
-            final FeaturePathFeatureSupplier supplier
-                    = new FeaturePathFeatureSupplier(new FeatureLoader(resourceLoader), options);
+            final FeaturePathFeatureSupplier supplier = new FeaturePathFeatureSupplier(new FeatureLoader(resourceLoader), options);
 
             final Runtime runtime = Runtime.builder()
                     .withClassLoader(classLoader)
@@ -811,5 +829,4 @@ private AllureResults runFeature(final String featureResource,
         });
     }
 
-
 }
diff --git a/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/AmbigiousSteps.java b/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/AmbigiousSteps.java
index 429e6290..06e9fbee 100644
--- a/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/AmbigiousSteps.java
+++ b/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/AmbigiousSteps.java
@@ -17,10 +17,6 @@
 
 import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class AmbigiousSteps {
 
     @When("^ambigious step (.+)$")
@@ -34,7 +30,7 @@ public void ambigious_2() {
     }
 
     @Then("^something bad should happen")
-    public void somethingBadStep(){
+    public void somethingBadStep() {
         //nothing here
     }
 }
diff --git a/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/AttachmentSteps.java b/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/AttachmentSteps.java
index d8307110..75b44942 100644
--- a/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/AttachmentSteps.java
+++ b/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/AttachmentSteps.java
@@ -19,25 +19,21 @@
 import io.cucumber.java.Before;
 import io.cucumber.java.en.Given;
 
-public class AttachmentSteps
-{
+public class AttachmentSteps {
     private Scenario scenario;
 
     @Before("@attachments")
-    public void setup(Scenario scenario)
-    {
+    public void setup(Scenario scenario) {
         this.scenario = scenario;
     }
 
     @Given("step with scenario write")
-    public void stepWithScenarioWrite()
-    {
+    public void stepWithScenarioWrite() {
         scenario.write("text attachment");
     }
 
     @Given("step with scenario embed")
-    public void stepWithScenarioEmbed()
-    {
+    public void stepWithScenarioEmbed() {
         scenario.embed("image attachment".getBytes(), "image/png");
     }
 }
diff --git a/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/BackgroundFeatureSteps.java b/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/BackgroundFeatureSteps.java
index 261680d8..9658b4f9 100644
--- a/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/BackgroundFeatureSteps.java
+++ b/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/BackgroundFeatureSteps.java
@@ -18,10 +18,6 @@
 import io.cucumber.java.en.Given;
 import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class BackgroundFeatureSteps {
 
     @Given("^cat is sad$")
diff --git a/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/BrokenFeatureSteps.java b/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/BrokenFeatureSteps.java
index 7521a2f4..e10e3cea 100644
--- a/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/BrokenFeatureSteps.java
+++ b/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/BrokenFeatureSteps.java
@@ -16,10 +16,6 @@
 package io.qameta.allure.cucumber4jvm.samples;
 
 import io.cucumber.java.en.Given;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class BrokenFeatureSteps {
 
     @Given("^everything is broken$")
diff --git a/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/DatatableFeatureSteps.java b/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/DatatableFeatureSteps.java
index 158b5ece..0861d463 100644
--- a/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/DatatableFeatureSteps.java
+++ b/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/DatatableFeatureSteps.java
@@ -15,12 +15,8 @@
  */
 package io.qameta.allure.cucumber4jvm.samples;
 
-import io.cucumber.java.en.Given;
 import io.cucumber.datatable.DataTable;
-
-/**
- * @author charlie (Dmitry Baev).
- */
+import io.cucumber.java.en.Given;
 @SuppressWarnings("unused")
 public class DatatableFeatureSteps {
 
diff --git a/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/HookSteps.java b/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/HookSteps.java
index 2aa7f01f..2a13ec8e 100644
--- a/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/HookSteps.java
+++ b/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/HookSteps.java
@@ -18,29 +18,25 @@
 import io.cucumber.java.After;
 import io.cucumber.java.Before;
 import org.assertj.core.api.Assertions;
-
-/**
- * @author letsrokk (Dmitry Mayer).
- */
 public class HookSteps {
 
     @Before("@WithHooks")
-    public void beforeHook(){
+    public void beforeHook() {
         // nothing
     }
 
     @After("@WithHooks")
-    public void afterHook(){
+    public void afterHook() {
         // nothing
     }
 
     @Before("@BeforeHookWithException")
-    public void beforeHookWithException(){
+    public void beforeHookWithException() {
         Assertions.fail("Exception in Hook step");
     }
 
     @After("@AfterHookWithException")
-    public void afterHookWithException(){
+    public void afterHookWithException() {
         Assertions.fail("Exception in Hook step");
     }
 
diff --git a/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/PendingSteps.java b/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/PendingSteps.java
index 1ab2b3f7..3fa6e3db 100644
--- a/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/PendingSteps.java
+++ b/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/PendingSteps.java
@@ -17,10 +17,6 @@
 
 import cucumber.api.PendingException;
 import io.cucumber.java.en.Given;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class PendingSteps {
 
     @Given("^step is yet to be implemented$")
diff --git a/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/RuntimeApiSteps.java b/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/RuntimeApiSteps.java
index 4c768742..7ce4af5c 100644
--- a/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/RuntimeApiSteps.java
+++ b/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/RuntimeApiSteps.java
@@ -20,19 +20,15 @@
 import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;
 import io.qameta.allure.Allure;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class RuntimeApiSteps {
 
     @Before("@beforeScenario")
-    public void beforeScenario(){
+    public void beforeScenario() {
         // nothing
     }
 
     @Before("@beforeFeature")
-    public void beforeFeature(){
+    public void beforeFeature() {
         // nothing
     }
 
diff --git a/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/SimpleFeatureSteps.java b/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/SimpleFeatureSteps.java
index 0d1f7723..e336b5e6 100644
--- a/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/SimpleFeatureSteps.java
+++ b/allure-cucumber4-jvm/src/test/java/io/qameta/allure/cucumber4jvm/samples/SimpleFeatureSteps.java
@@ -19,10 +19,6 @@
 import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;
 import org.assertj.core.api.Assertions;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class SimpleFeatureSteps {
 
     private int a;
diff --git a/allure-cucumber4-jvm/src/test/resources/allure.properties b/allure-cucumber4-jvm/src/test/resources/allure.properties
index dbfefee4..e026a61f 100644
--- a/allure-cucumber4-jvm/src/test/resources/allure.properties
+++ b/allure-cucumber4-jvm/src/test/resources/allure.properties
@@ -1,3 +1,4 @@
 allure.model.indentOutput=true
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-cucumber4-jvm
diff --git a/allure-cucumber5-jvm/src/main/java/io/qameta/allure/cucumber5jvm/AllureCucumber5Jvm.java b/allure-cucumber5-jvm/src/main/java/io/qameta/allure/cucumber5jvm/AllureCucumber5Jvm.java
index e1e9debb..cdcd95bd 100644
--- a/allure-cucumber5-jvm/src/main/java/io/qameta/allure/cucumber5jvm/AllureCucumber5Jvm.java
+++ b/allure-cucumber5-jvm/src/main/java/io/qameta/allure/cucumber5jvm/AllureCucumber5Jvm.java
@@ -67,18 +67,25 @@
 import java.util.stream.Stream;
 
 import static io.qameta.allure.util.ResultsUtils.createParameter;
+import static io.qameta.allure.util.ResultsUtils.createTitlePath;
+import static io.qameta.allure.util.ResultsUtils.createTitlePathFromSourcePath;
 import static io.qameta.allure.util.ResultsUtils.getStatus;
 import static io.qameta.allure.util.ResultsUtils.getStatusDetails;
 import static io.qameta.allure.util.ResultsUtils.md5;
 
 /**
- * Allure plugin for Cucumber JVM 5.0.
+ * Reports Cucumber JVM 5 execution to Allure.
+ *
+ * <p>Add this plugin to the Cucumber runtime so feature, scenario, step, hook, and attachment events are converted into Allure results. Use the default lifecycle for normal runs or pass one explicitly for embedded runners and tests.</p>
  */
-@SuppressWarnings({
-        "ClassDataAbstractionCoupling",
-        "ClassFanOutComplexity",
-        "MultipleStringLiterals",
-})
+@SuppressWarnings(
+    {
+            "ClassDataAbstractionCoupling",
+            "ClassFanOutComplexity",
+            "MultipleStringLiterals",
+            "PMD.GodClass",
+    }
+)
 public class AllureCucumber5Jvm implements ConcurrentEventListener {
 
     private static final String COLON = ":";
@@ -103,15 +110,26 @@ public class AllureCucumber5Jvm implements ConcurrentEventListener {
     private static final String TEXT_PLAIN = "text/plain";
     private static final String CUCUMBER_WORKING_DIR = Paths.get("").toUri().getSchemeSpecificPart();
 
+    /**
+     * Creates an Allure cucumber5 jvm with default configuration.
+     */
     @SuppressWarnings("unused")
     public AllureCucumber5Jvm() {
         this(Allure.getLifecycle());
     }
 
+    /**
+     * Creates an Allure cucumber5 jvm with the supplied values.
+     *
+     * @param lifecycle the Allure lifecycle to use
+     */
     public AllureCucumber5Jvm(final AllureLifecycle lifecycle) {
         this.lifecycle = lifecycle;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void setEventPublisher(final EventPublisher publisher) {
         publisher.registerHandlerFor(TestSourceRead.class, featureStartedHandler);
@@ -139,31 +157,34 @@ private void handleTestCaseStarted(final TestCaseStarted event) {
 
         final String name = testCase.getName();
 
-
         // the same way full name is generated for
         // org.junit.platform.engine.support.descriptor.ClasspathResourceSource
         // to support io.qameta.allure.junitplatform.AllurePostDiscoveryFilter
-        final String fullName = String.format("%s:%d",
+        final String fullName = String.format(
+                "%s:%d",
                 getTestCaseUri(testCase),
                 testCase.getLine()
         );
 
         final String testCaseUuid = testCase.getId().toString();
 
+        final List<String> titlePath = createTitlePathFromSourcePath(getTestCaseUri(testCase));
+        titlePath.addAll(createTitlePath(feature.getName()));
+
         final TestResult result = new TestResult()
                 .setUuid(testCaseUuid)
                 .setTestCaseId(getTestCaseId(testCase))
                 .setHistoryId(getHistoryId(testCase))
                 .setFullName(fullName)
+                .setTitlePath(titlePath)
                 .setName(name)
                 .setLabels(labelBuilder.getScenarioLabels())
                 .setLinks(labelBuilder.getScenarioLinks());
 
-        final ScenarioDefinition scenarioDefinition =
-                testSources.getScenarioDefinition(
-                        testCase.getUri(),
-                        testCase.getLine()
-                );
+        final ScenarioDefinition scenarioDefinition = testSources.getScenarioDefinition(
+                testCase.getUri(),
+                testCase.getLine()
+        );
 
         if (scenarioDefinition instanceof ScenarioOutline) {
             result.setParameters(
@@ -199,9 +220,10 @@ private void handleTestCaseFinished(final TestCaseFinished event) {
                 .setMuted(tagParser.isMuted())
                 .setKnown(tagParser.isKnown());
 
-        lifecycle.updateTestCase(uuid, testResult -> testResult
-                .setStatus(status)
-                .setStatusDetails(statusDetails)
+        lifecycle.updateTestCase(
+                uuid, testResult -> testResult
+                        .setStatus(status)
+                        .setStatusDetails(statusDetails)
         );
 
         lifecycle.stopTestCase(uuid);
@@ -269,9 +291,10 @@ private void handleStartFixtureHook(final TestCase testCase,
         final String containerUuid = hookStepContainerUuid
                 .computeIfAbsent(hook, unused -> UUID.randomUUID().toString());
 
-        lifecycle.startTestContainer(new TestResultContainer()
-                .setUuid(containerUuid)
-                .setChildren(Collections.singletonList(uuid))
+        lifecycle.startTestContainer(
+                new TestResultContainer()
+                        .setUuid(containerUuid)
+                        .setChildren(Collections.singletonList(uuid))
         );
 
         final FixtureResult hookResult = new FixtureResult()
@@ -354,15 +377,14 @@ private Status translateTestCaseStatus(final Result testCaseResult) {
     }
 
     private List<Parameter> getExamplesAsParameters(
-            final ScenarioOutline scenario,
-            final TestCase localCurrentTestCase) {
-        final Optional<Examples> maybeExample =
-                scenario.getExamples().stream()
-                        .filter(example -> example.getTableBody().stream()
-                                .anyMatch(row -> row.getLocation().getLine()
-                                                 == localCurrentTestCase.getLine())
-                        )
-                        .findFirst();
+                                                    final ScenarioOutline scenario,
+                                                    final TestCase localCurrentTestCase) {
+        final Optional<Examples> maybeExample = scenario.getExamples().stream()
+                .filter(
+                        example -> example.getTableBody().stream()
+                                .anyMatch(row -> row.getLocation().getLine() == localCurrentTestCase.getLine())
+                )
+                .findFirst();
 
         if (!maybeExample.isPresent()) {
             return Collections.emptyList();
@@ -400,8 +422,10 @@ private void createDataTableAttachment(final DataTableArgument dataTableArgument
         }
         final String attachmentSource = lifecycle
                 .prepareAttachment("Data table", "text/tab-separated-values", "csv");
-        lifecycle.writeAttachment(attachmentSource,
-                new ByteArrayInputStream(dataTableCsv.toString().getBytes(StandardCharsets.UTF_8)));
+        lifecycle.writeAttachment(
+                attachmentSource,
+                new ByteArrayInputStream(dataTableCsv.toString().getBytes(StandardCharsets.UTF_8))
+        );
     }
 
     private void handleStopHookStep(final Result eventResult,
@@ -422,9 +446,10 @@ private void handleStopHookStep(final Result eventResult,
         final StatusDetails statusDetails = getStatusDetails(eventResult.getError())
                 .orElseGet(StatusDetails::new);
 
-        lifecycle.updateFixture(uuid, result -> result
-                .setStatus(status)
-                .setStatusDetails(statusDetails)
+        lifecycle.updateFixture(
+                uuid, result -> result
+                        .setStatus(status)
+                        .setStatusDetails(statusDetails)
         );
         lifecycle.stopFixture(uuid);
 
@@ -445,8 +470,7 @@ private void handleStopStep(final TestCase testCase,
 
         final Status stepStatus = translateTestCaseStatus(eventResult);
 
-        final StatusDetails statusDetails
-                = eventResult.getStatus() == io.cucumber.plugin.event.Status.UNDEFINED
+        final StatusDetails statusDetails = eventResult.getStatus() == io.cucumber.plugin.event.Status.UNDEFINED
                 ? new StatusDetails().setMessage("Undefined Step. Please add step definition")
                 : getStatusDetails(eventResult.getError())
                         .orElse(new StatusDetails());
diff --git a/allure-cucumber5-jvm/src/main/java/io/qameta/allure/cucumber5jvm/LabelBuilder.java b/allure-cucumber5-jvm/src/main/java/io/qameta/allure/cucumber5jvm/LabelBuilder.java
index 73321148..31d7d53f 100644
--- a/allure-cucumber5-jvm/src/main/java/io/qameta/allure/cucumber5jvm/LabelBuilder.java
+++ b/allure-cucumber5-jvm/src/main/java/io/qameta/allure/cucumber5jvm/LabelBuilder.java
@@ -15,8 +15,8 @@
  */
 package io.qameta.allure.cucumber5jvm;
 
-import io.cucumber.plugin.event.TestCase;
 import gherkin.ast.Feature;
+import io.cucumber.plugin.event.TestCase;
 import io.qameta.allure.model.Label;
 import io.qameta.allure.model.Link;
 import io.qameta.allure.util.ResultsUtils;
@@ -48,7 +48,7 @@
 /**
  * Scenario labels and links builder.
  */
-@SuppressWarnings({"CyclomaticComplexity", "MultipleStringLiterals"})
+@SuppressWarnings({"CyclomaticComplexity", "MultipleStringLiterals", "PMD.CognitiveComplexity"})
 class LabelBuilder {
     private static final Logger LOGGER = LoggerFactory.getLogger(LabelBuilder.class);
     private static final String COMPOSITE_TAG_DELIMITER = "=";
@@ -113,17 +113,19 @@ class LabelBuilder {
         final URI uri = scenario.getUri();
 
         scenarioLabels.addAll(ResultsUtils.getProvidedLabels());
-        scenarioLabels.addAll(Arrays.asList(
-                createHostLabel(),
-                createThreadLabel(),
-                createFeatureLabel(featureName),
-                createStoryLabel(scenario.getName()),
-                createSuiteLabel(featureName),
-                createTestClassLabel(scenario.getName()),
-                createFrameworkLabel("cucumber5jvm"),
-                createLanguageLabel("java"),
-                createLabel("gherkin_uri", uri.toString())
-        ));
+        scenarioLabels.addAll(
+                Arrays.asList(
+                        createHostLabel(),
+                        createThreadLabel(),
+                        createFeatureLabel(featureName),
+                        createStoryLabel(scenario.getName()),
+                        createSuiteLabel(featureName),
+                        createTestClassLabel(scenario.getName()),
+                        createFrameworkLabel("cucumber5jvm"),
+                        createLanguageLabel("java"),
+                        createLabel("gherkin_uri", uri.toString())
+                )
+        );
 
         featurePackage(uri.toString(), featureName)
                 .map(ResultsUtils::createPackageLabel)
@@ -156,8 +158,10 @@ private void tryHandleNamedLink(final String tagString) {
             final String name = tagString.split(COMPOSITE_TAG_DELIMITER)[1];
             scenarioLinks.add(ResultsUtils.createLink(null, name, null, type));
         } else {
-            LOGGER.warn("Composite named tag {} does not match regex {}. Skipping", tagString,
-                    namedLinkPatternString);
+            LOGGER.warn(
+                    "Composite named tag {} does not match regex {}. Skipping", tagString,
+                    namedLinkPatternString
+            );
         }
     }
 
@@ -175,10 +179,12 @@ private Optional<String> featurePackage(final String uriString, final String fea
         final String schemeSpecificPart = uri.normalize().getSchemeSpecificPart();
         final Stream<String> folders = Stream.of(schemeSpecificPart.replaceAll("\\.", "_").split("/"));
         final Stream<String> name = Stream.of(featureName);
-        return Optional.of(Stream.concat(folders, name)
-                .filter(Objects::nonNull)
-                .filter(s -> !s.isEmpty())
-                .collect(Collectors.joining(".")));
+        return Optional.of(
+                Stream.concat(folders, name)
+                        .filter(Objects::nonNull)
+                        .filter(s -> !s.isEmpty())
+                        .collect(Collectors.joining("."))
+        );
     }
 
     private static Optional<URI> safeUri(final String uri) {
diff --git a/allure-cucumber5-jvm/src/main/java/io/qameta/allure/cucumber5jvm/TagParser.java b/allure-cucumber5-jvm/src/main/java/io/qameta/allure/cucumber5jvm/TagParser.java
index 5e980a98..e2e31d22 100644
--- a/allure-cucumber5-jvm/src/main/java/io/qameta/allure/cucumber5jvm/TagParser.java
+++ b/allure-cucumber5-jvm/src/main/java/io/qameta/allure/cucumber5jvm/TagParser.java
@@ -51,9 +51,9 @@ public boolean isKnown() {
 
     private boolean getStatusDetailByTag(final String tagName) {
         return scenario.getTags().stream()
-                       .anyMatch(tag -> tag.equalsIgnoreCase(tagName))
-               || feature.getTags().stream()
-                       .anyMatch(tag -> tag.getName().equalsIgnoreCase(tagName));
+                .anyMatch(tag -> tag.equalsIgnoreCase(tagName))
+                || feature.getTags().stream()
+                        .anyMatch(tag -> tag.getName().equalsIgnoreCase(tagName));
     }
 
     public boolean isResultTag(final String tag) {
diff --git a/allure-cucumber5-jvm/src/main/java/io/qameta/allure/cucumber5jvm/testsourcemodel/TestSourcesModel.java b/allure-cucumber5-jvm/src/main/java/io/qameta/allure/cucumber5jvm/testsourcemodel/TestSourcesModel.java
index 356783cb..4b390e11 100644
--- a/allure-cucumber5-jvm/src/main/java/io/qameta/allure/cucumber5jvm/testsourcemodel/TestSourcesModel.java
+++ b/allure-cucumber5-jvm/src/main/java/io/qameta/allure/cucumber5jvm/testsourcemodel/TestSourcesModel.java
@@ -28,24 +28,49 @@
 import gherkin.ast.Step;
 import gherkin.ast.TableRow;
 import io.cucumber.plugin.event.TestSourceRead;
+
 import java.net.URI;
 import java.util.HashMap;
 import java.util.Map;
 
+/**
+ * Stores parsed Cucumber feature source information.
+ *
+ * <p>Cucumber integrations use this model to map runtime events back to feature, scenario, and step definitions. It helps build accurate Allure names, labels, and step keywords from source files and line numbers.</p>
+ */
 public final class TestSourcesModel {
     private final Map<URI, TestSourceRead> pathToReadEventMap = new HashMap<>();
     private final Map<URI, GherkinDocument> pathToAstMap = new HashMap<>();
     private final Map<URI, Map<Integer, AstNode>> pathToNodeMap = new HashMap<>();
 
+    /**
+     * Returns the scenario definition.
+     *
+     * @param astNode the Cucumber AST node to inspect
+     * @return the scenario definition
+     */
     public static ScenarioDefinition getScenarioDefinition(final AstNode astNode) {
-        return astNode.node instanceof ScenarioDefinition ? (ScenarioDefinition) astNode.node
+        return astNode.node instanceof ScenarioDefinition
+                ? (ScenarioDefinition) astNode.node
                 : (ScenarioDefinition) astNode.parent.parent.node;
     }
 
+    /**
+     * Adds the test source read event.
+     *
+     * @param path the path to read from or write to
+     * @param event the framework event to process
+     */
     public void addTestSourceReadEvent(final URI path, final TestSourceRead event) {
         pathToReadEventMap.put(path, event);
     }
 
+    /**
+     * Returns the feature.
+     *
+     * @param path the path to read from or write to
+     * @return the feature
+     */
     public Feature getFeature(final URI path) {
         if (!pathToAstMap.containsKey(path)) {
             parseGherkinSource(path);
@@ -56,6 +81,13 @@ public Feature getFeature(final URI path) {
         return null;
     }
 
+    /**
+     * Returns the ast node.
+     *
+     * @param path the path to read from or write to
+     * @param line the source line number to resolve
+     * @return the ast node
+     */
     public AstNode getAstNode(final URI path, final int line) {
         if (!pathToNodeMap.containsKey(path)) {
             parseGherkinSource(path);
@@ -73,8 +105,10 @@ private void parseGherkinSource(final URI path) {
         final Parser<GherkinDocument> parser = new Parser<>(new AstBuilder());
         final TokenMatcher matcher = new TokenMatcher();
         try {
-            final GherkinDocument gherkinDocument = parser.parse(pathToReadEventMap.get(path).getSource(),
-                    matcher);
+            final GherkinDocument gherkinDocument = parser.parse(
+                    pathToReadEventMap.get(path).getSource(),
+                    matcher
+            );
             pathToAstMap.put(path, gherkinDocument);
             final Map<Integer, AstNode> nodeMap = new HashMap<>();
             final AstNode currentParent = new AstNode(gherkinDocument.getFeature(), null);
@@ -83,8 +117,10 @@ private void parseGherkinSource(final URI path) {
             }
             pathToNodeMap.put(path, nodeMap);
         } catch (ParserException e) {
-            throw new IllegalStateException("You are using a plugin that only supports till Gherkin 5.\n"
-                    + "Please check if the Gherkin provided follows the standard of Gherkin 5\n", e
+            throw new IllegalStateException(
+                    "You are using a plugin that only supports till Gherkin 5.\n"
+                            + "Please check if the Gherkin provided follows the standard of Gherkin 5\n",
+                    e
             );
         }
     }
diff --git a/allure-cucumber5-jvm/src/main/java/io/qameta/allure/cucumber5jvm/testsourcemodel/TestSourcesModelProxy.java b/allure-cucumber5-jvm/src/main/java/io/qameta/allure/cucumber5jvm/testsourcemodel/TestSourcesModelProxy.java
index 8a1bbe7c..ec7415ee 100644
--- a/allure-cucumber5-jvm/src/main/java/io/qameta/allure/cucumber5jvm/testsourcemodel/TestSourcesModelProxy.java
+++ b/allure-cucumber5-jvm/src/main/java/io/qameta/allure/cucumber5jvm/testsourcemodel/TestSourcesModelProxy.java
@@ -25,28 +25,62 @@
 import java.util.HashMap;
 import java.util.Map;
 
+/**
+ * Compatibility proxy around Cucumber feature source storage.
+ *
+ * <p>The proxy hides version-specific Cucumber source model APIs from the reporting plugin. Integrations use it to add source-read events and resolve feature, scenario, and step keyword metadata during execution.</p>
+ */
 public class TestSourcesModelProxy {
 
     private final Map<URI, TestSourceRead> pathToReadEventMap = new HashMap<>();
     private final TestSourcesModel testSources;
 
+    /**
+     * Creates a test sources model proxy with default configuration.
+     */
     public TestSourcesModelProxy() {
         this.testSources = new TestSourcesModel();
     }
 
+    /**
+     * Adds the test source read event.
+     *
+     * @param path the path to read from or write to
+     * @param event the framework event to process
+     */
     public void addTestSourceReadEvent(final URI path, final TestSourceRead event) {
         this.pathToReadEventMap.put(path, event);
         testSources.addTestSourceReadEvent(path, event);
     }
 
+    /**
+     * Returns the feature.
+     *
+     * @param path the path to read from or write to
+     * @return the feature
+     */
     public Feature getFeature(final URI path) {
         return testSources.getFeature(path);
     }
 
+    /**
+     * Returns the scenario definition.
+     *
+     * @param path the path to read from or write to
+     * @param line the source line number to resolve
+     * @return the scenario definition
+     */
     public ScenarioDefinition getScenarioDefinition(final URI path, final int line) {
         return testSources.getScenarioDefinition(testSources.getAstNode(path, line));
     }
 
+    /**
+     * Returns the keyword from source.
+     *
+     * @param uri the feature file URI
+     * @param stepLine the feature file line number of the step
+     * @return the keyword from source
+     */
     public String getKeywordFromSource(final URI uri, final int stepLine) {
         return this.getKeywordFromSourceInternal(uri, stepLine);
     }
diff --git a/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/AllureCucumber5JvmTest.java b/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/AllureCucumber5JvmTest.java
index 7456106a..d70b8741 100644
--- a/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/AllureCucumber5JvmTest.java
+++ b/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/AllureCucumber5JvmTest.java
@@ -65,10 +65,6 @@
 import static org.assertj.core.api.Assertions.tuple;
 import static org.junit.jupiter.api.parallel.ResourceAccessMode.READ_WRITE;
 import static org.junit.jupiter.api.parallel.Resources.SYSTEM_PROPERTIES;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class AllureCucumber5JvmTest {
 
     @AllureFeatures.Base
@@ -80,6 +76,8 @@ void shouldSetName() {
         assertThat(testResults)
                 .extracting(TestResult::getName)
                 .containsExactlyInAnyOrder("Add a to b");
+        assertThat(testResults.get(0).getTitlePath())
+                .containsExactly("src", "test", "resources", "features", "simple.feature", "Simple feature");
     }
 
     @AllureFeatures.PassedTests
@@ -183,7 +181,7 @@ void shouldSetDescription() {
         final AllureResults results = runFeature("features/description.feature");
 
         final String expected = "This is description for current feature.\n"
-                                + "It should appear on each scenario in report";
+                + "It should appear on each scenario in report";
 
         final List<TestResult> testResults = results.getTestResults();
         assertThat(testResults)
@@ -200,7 +198,7 @@ void shouldSetScenarioDescription() {
         final AllureResults results = runFeature("features/scenario_description.feature");
 
         final String expected = "This is description for current feature.\n"
-                                + "It should appear on each scenario in report";
+                + "It should appear on each scenario in report";
 
         final List<TestResult> testResults = results.getTestResults();
         assertThat(testResults)
@@ -238,11 +236,12 @@ void shouldAddDataTableAttachment() {
         final String attachmentContent = new String(bytes, StandardCharsets.UTF_8);
 
         assertThat(attachmentContent)
-                .isEqualTo("""
-                        name\tlogin\temail
-                        Viktor\tclicman\tclicman@ya.ru
-                        Viktor2\tclicman2\tclicman2@ya.ru
+                .isEqualTo(
                         """
+                                name\tlogin\temail
+                                Viktor\tclicman\tclicman@ya.ru
+                                Viktor2\tclicman2\tclicman2@ya.ru
+                                """
                 );
 
     }
@@ -381,8 +380,14 @@ void shouldAddTags() {
 
     @AllureFeatures.Links
     @ExtendWith(SystemPropertyExtension.class)
-    @SystemProperty(name = "allure.link.issue.pattern", value = "https://example.org/issue/{}")
-    @SystemProperty(name = "allure.link.tms.pattern", value = "https://example.org/tms/{}")
+    @SystemProperty(
+            name = "allure.link.issue.pattern",
+            value = "https://example.org/issue/{}"
+    )
+    @SystemProperty(
+            name = "allure.link.tms.pattern",
+            value = "https://example.org/tms/{}"
+    )
     @Test
     void shouldAddLinks() {
         final AllureResults results = runFeature("features/tags.feature");
@@ -511,8 +516,10 @@ void shouldSupportDryRunForSimpleFeatures() {
     @AllureFeatures.Base
     @Test
     void shouldSupportDryRunForHooks() {
-        final AllureResults results = runFeature("features/hooks.feature", "--dry-run", "-t",
-                "@WithHooks or @BeforeHookWithException or @AfterHookWithException");
+        final AllureResults results = runFeature(
+                "features/hooks.feature", "--dry-run", "-t",
+                "@WithHooks or @BeforeHookWithException or @AfterHookWithException"
+        );
 
         final TestResult tr1 = results.getTestResultByName("Simple scenario with Before and After hooks");
 
@@ -652,8 +659,10 @@ void shouldProcessScenariosInParallelMode() {
     @AllureFeatures.Stages
     @Test
     void shouldDisplayHooksAsStages() {
-        final AllureResults results = runFeature("features/hooks.feature", "-t",
-                "@WithHooks or @BeforeHookWithException or @AfterHookWithException");
+        final AllureResults results = runFeature(
+                "features/hooks.feature", "-t",
+                "@WithHooks or @BeforeHookWithException or @AfterHookWithException"
+        );
 
         final TestResult tr1 = results.getTestResultByName("Simple scenario with Before and After hooks");
         final TestResult tr2 = results.getTestResultByName("Simple scenario with Before hook with Exception");
@@ -691,7 +700,6 @@ void shouldDisplayHooksAsStages() {
                         tuple("Then result is 15", Status.SKIPPED)
                 );
 
-
         assertThat(results.getTestResultContainersForTestResult(tr2))
                 .flatExtracting(TestResultContainer::getBefores)
                 .extracting(FixtureResult::getName, FixtureResult::getStatus)
@@ -737,8 +745,14 @@ void shouldHandleAmbigiousStepsExceptions() {
                 );
     }
 
-    @ResourceLock(value = SYSTEM_PROPERTIES, mode = READ_WRITE)
-    @SystemProperty(name = "allure.label.x-provided", value = "cucumberjvm5-test-provided")
+    @ResourceLock(
+            value = SYSTEM_PROPERTIES,
+            mode = READ_WRITE
+    )
+    @SystemProperty(
+            name = "allure.label.x-provided",
+            value = "cucumberjvm5-test-provided"
+    )
     @Test
     void shouldSupportProvidedLabels() {
         final AllureResults results = runFeature("features/simple.feature");
@@ -783,17 +797,22 @@ void shouldSupportRuntimeApiInStepsWhenHooksAreUsed() {
                 );
     }
 
-    @SystemProperty(name = "cucumber.junit-platform.naming-strategy", value = "long")
+    @SystemProperty(
+            name = "cucumber.junit-platform.naming-strategy",
+            value = "long"
+    )
     @Step
     private AllureResults runFeature(final String featureResource,
                                      final String... moreOptions) {
         return RunUtils.runTests(lifecycle -> {
             final AllureCucumber5Jvm cucumber5jvm = new AllureCucumber5Jvm(lifecycle);
             final Supplier<ClassLoader> classLoader = ClassLoaders::getDefaultClassLoader;
-            final List<String> opts = new ArrayList<>(Arrays.asList(
-                    "--glue", "io.qameta.allure.cucumber5jvm.samples",
-                    "--plugin", "null_summary"
-            ));
+            final List<String> opts = new ArrayList<>(
+                    Arrays.asList(
+                            "--glue", "io.qameta.allure.cucumber5jvm.samples",
+                            "--plugin", "null_summary"
+                    )
+            );
             opts.addAll(Arrays.asList(moreOptions));
             final FeatureWithLines featureWithLines = FeatureWithLines.parse("src/test/resources/" + featureResource);
             final RuntimeOptions options = new CommandlineOptionsParser()
@@ -801,8 +820,7 @@ private AllureResults runFeature(final String featureResource,
 
             final EventBus bus = new TimeServiceEventBus(Clock.systemUTC(), UUID::randomUUID);
             final FeatureParser parser = new FeatureParser(bus::generateId);
-            final FeaturePathFeatureSupplier supplier
-                    = new FeaturePathFeatureSupplier(classLoader, options, parser);
+            final FeaturePathFeatureSupplier supplier = new FeaturePathFeatureSupplier(classLoader, options, parser);
 
             final Runtime runtime = Runtime.builder()
                     .withClassLoader(classLoader)
@@ -815,5 +833,4 @@ private AllureResults runFeature(final String featureResource,
         });
     }
 
-
 }
diff --git a/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/AmbigiousSteps.java b/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/AmbigiousSteps.java
index 3e605bb6..eca7e0f3 100644
--- a/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/AmbigiousSteps.java
+++ b/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/AmbigiousSteps.java
@@ -17,10 +17,6 @@
 
 import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class AmbigiousSteps {
 
     @When("^ambigious step (.+)$")
@@ -34,7 +30,7 @@ public void ambigious_2() {
     }
 
     @Then("^something bad should happen")
-    public void somethingBadStep(){
+    public void somethingBadStep() {
         //nothing here
     }
 }
diff --git a/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/AttachmentSteps.java b/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/AttachmentSteps.java
index a4489b08..1310cb9d 100644
--- a/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/AttachmentSteps.java
+++ b/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/AttachmentSteps.java
@@ -15,29 +15,25 @@
  */
 package io.qameta.allure.cucumber5jvm.samples;
 
-import io.cucumber.java.Scenario;
 import io.cucumber.java.Before;
+import io.cucumber.java.Scenario;
 import io.cucumber.java.en.Given;
 
-public class AttachmentSteps
-{
+public class AttachmentSteps {
     private Scenario scenario;
 
     @Before("@attachments")
-    public void setup(Scenario scenario)
-    {
+    public void setup(Scenario scenario) {
         this.scenario = scenario;
     }
 
     @Given("step with scenario write")
-    public void stepWithScenarioWrite()
-    {
+    public void stepWithScenarioWrite() {
         scenario.write("text attachment");
     }
 
     @Given("step with scenario embed")
-    public void stepWithScenarioEmbed()
-    {
-        scenario.embed("image attachment".getBytes(), "image/png","ImageAttachment");
+    public void stepWithScenarioEmbed() {
+        scenario.embed("image attachment".getBytes(), "image/png", "ImageAttachment");
     }
 }
diff --git a/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/BackgroundFeatureSteps.java b/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/BackgroundFeatureSteps.java
index 8a8a75e4..57cd03e2 100644
--- a/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/BackgroundFeatureSteps.java
+++ b/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/BackgroundFeatureSteps.java
@@ -18,10 +18,6 @@
 import io.cucumber.java.en.Given;
 import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class BackgroundFeatureSteps {
 
     @Given("^cat is sad$")
diff --git a/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/BrokenFeatureSteps.java b/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/BrokenFeatureSteps.java
index 900968ad..2fde1f09 100644
--- a/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/BrokenFeatureSteps.java
+++ b/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/BrokenFeatureSteps.java
@@ -16,10 +16,6 @@
 package io.qameta.allure.cucumber5jvm.samples;
 
 import io.cucumber.java.en.Given;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class BrokenFeatureSteps {
 
     @Given("^everything is broken$")
diff --git a/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/DatatableFeatureSteps.java b/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/DatatableFeatureSteps.java
index 98f22865..db70f804 100644
--- a/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/DatatableFeatureSteps.java
+++ b/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/DatatableFeatureSteps.java
@@ -17,10 +17,6 @@
 
 import io.cucumber.datatable.DataTable;
 import io.cucumber.java.en.Given;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @SuppressWarnings("unused")
 public class DatatableFeatureSteps {
 
diff --git a/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/HookSteps.java b/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/HookSteps.java
index 775d9086..786c53c2 100644
--- a/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/HookSteps.java
+++ b/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/HookSteps.java
@@ -18,29 +18,25 @@
 import io.cucumber.java.After;
 import io.cucumber.java.Before;
 import org.assertj.core.api.Assertions;
-
-/**
- * @author letsrokk (Dmitry Mayer).
- */
 public class HookSteps {
 
     @Before("@WithHooks")
-    public void beforeHook(){
+    public void beforeHook() {
         // nothing
     }
 
     @After("@WithHooks")
-    public void afterHook(){
+    public void afterHook() {
         // nothing
     }
 
     @Before("@BeforeHookWithException")
-    public void beforeHookWithException(){
+    public void beforeHookWithException() {
         Assertions.fail("Exception in Hook step");
     }
 
     @After("@AfterHookWithException")
-    public void afterHookWithException(){
+    public void afterHookWithException() {
         Assertions.fail("Exception in Hook step");
     }
 
diff --git a/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/PendingSteps.java b/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/PendingSteps.java
index 2b09a1f5..65a521e4 100644
--- a/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/PendingSteps.java
+++ b/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/PendingSteps.java
@@ -17,10 +17,6 @@
 
 import io.cucumber.java.PendingException;
 import io.cucumber.java.en.Given;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class PendingSteps {
 
     @Given("^step is yet to be implemented$")
diff --git a/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/RuntimeApiSteps.java b/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/RuntimeApiSteps.java
index 581b2afe..adc9e2fa 100644
--- a/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/RuntimeApiSteps.java
+++ b/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/RuntimeApiSteps.java
@@ -20,19 +20,15 @@
 import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;
 import io.qameta.allure.Allure;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class RuntimeApiSteps {
 
     @Before("@beforeScenario")
-    public void beforeScenario(){
+    public void beforeScenario() {
         // nothing
     }
 
     @Before("@beforeFeature")
-    public void beforeFeature(){
+    public void beforeFeature() {
         // nothing
     }
 
diff --git a/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/SimpleFeatureSteps.java b/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/SimpleFeatureSteps.java
index 46b0e946..4f489a54 100644
--- a/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/SimpleFeatureSteps.java
+++ b/allure-cucumber5-jvm/src/test/java/io/qameta/allure/cucumber5jvm/samples/SimpleFeatureSteps.java
@@ -19,10 +19,6 @@
 import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;
 import org.assertj.core.api.Assertions;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class SimpleFeatureSteps {
 
     private int a;
diff --git a/allure-cucumber5-jvm/src/test/resources/allure.properties b/allure-cucumber5-jvm/src/test/resources/allure.properties
index dbfefee4..8e296072 100644
--- a/allure-cucumber5-jvm/src/test/resources/allure.properties
+++ b/allure-cucumber5-jvm/src/test/resources/allure.properties
@@ -1,3 +1,4 @@
 allure.model.indentOutput=true
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-cucumber5-jvm
diff --git a/allure-cucumber6-jvm/src/main/java/io/qameta/allure/cucumber6jvm/AllureCucumber6Jvm.java b/allure-cucumber6-jvm/src/main/java/io/qameta/allure/cucumber6jvm/AllureCucumber6Jvm.java
index e8c71e51..148dfe4c 100644
--- a/allure-cucumber6-jvm/src/main/java/io/qameta/allure/cucumber6jvm/AllureCucumber6Jvm.java
+++ b/allure-cucumber6-jvm/src/main/java/io/qameta/allure/cucumber6jvm/AllureCucumber6Jvm.java
@@ -65,20 +65,27 @@
 import java.util.stream.Stream;
 
 import static io.qameta.allure.util.ResultsUtils.createParameter;
+import static io.qameta.allure.util.ResultsUtils.createTitlePath;
+import static io.qameta.allure.util.ResultsUtils.createTitlePathFromSourcePath;
 import static io.qameta.allure.util.ResultsUtils.getStatus;
 import static io.qameta.allure.util.ResultsUtils.getStatusDetails;
 import static io.qameta.allure.util.ResultsUtils.md5;
 
 /**
- * Allure plugin for Cucumber JVM 6.0.
+ * Reports Cucumber JVM 6 execution to Allure.
+ *
+ * <p>Add this plugin to the Cucumber runtime so feature, scenario, step, hook, and attachment events are converted into Allure results. Use the default lifecycle for normal runs or pass one explicitly for embedded runners and tests.</p>
  */
-@SuppressWarnings({
-        "ClassDataAbstractionCoupling",
-        "ClassFanOutComplexity",
-})
+@SuppressWarnings(
+    {
+            "ClassDataAbstractionCoupling",
+            "ClassFanOutComplexity",
+    }
+)
 public class AllureCucumber6Jvm implements ConcurrentEventListener {
 
     private static final String COLON = ":";
+    private static final String NEW_LINE = "\n";
 
     private final AllureLifecycle lifecycle;
 
@@ -98,15 +105,26 @@ public class AllureCucumber6Jvm implements ConcurrentEventListener {
     private static final String TEXT_PLAIN = "text/plain";
     private static final String CUCUMBER_WORKING_DIR = Paths.get("").toUri().getSchemeSpecificPart();
 
+    /**
+     * Creates an Allure cucumber6 jvm with default configuration.
+     */
     @SuppressWarnings("unused")
     public AllureCucumber6Jvm() {
         this(Allure.getLifecycle());
     }
 
+    /**
+     * Creates an Allure cucumber6 jvm with the supplied values.
+     *
+     * @param lifecycle the Allure lifecycle to use
+     */
     public AllureCucumber6Jvm(final AllureLifecycle lifecycle) {
         this.lifecycle = lifecycle;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void setEventPublisher(final EventPublisher publisher) {
         publisher.registerHandlerFor(TestSourceRead.class, featureStartedHandler);
@@ -134,31 +152,34 @@ private void handleTestCaseStarted(final TestCaseStarted event) {
 
         final String name = testCase.getName();
 
-
         // the same way full name is generated for
         // org.junit.platform.engine.support.descriptor.ClasspathResourceSource
         // to support io.qameta.allure.junitplatform.AllurePostDiscoveryFilter
-        final String fullName = String.format("%s:%d",
+        final String fullName = String.format(
+                "%s:%d",
                 getTestCaseUri(testCase),
                 testCase.getLocation().getLine()
         );
 
         final String testCaseUuid = testCase.getId().toString();
 
+        final List<String> titlePath = createTitlePathFromSourcePath(getTestCaseUri(testCase));
+        titlePath.addAll(createTitlePath(feature.getName()));
+
         final TestResult result = new TestResult()
                 .setUuid(testCaseUuid)
                 .setTestCaseId(getTestCaseId(testCase))
                 .setHistoryId(getHistoryId(testCase))
                 .setFullName(fullName)
+                .setTitlePath(titlePath)
                 .setName(name)
                 .setLabels(labelBuilder.getScenarioLabels())
                 .setLinks(labelBuilder.getScenarioLinks());
 
-        final Scenario scenarioDefinition =
-                testSources.getScenarioDefinition(
-                        testCase.getUri(),
-                        testCase.getLocation().getLine()
-                );
+        final Scenario scenarioDefinition = testSources.getScenarioDefinition(
+                testCase.getUri(),
+                testCase.getLocation().getLine()
+        );
 
         if (scenarioDefinition.getExamplesList() != null) {
             result.setParameters(
@@ -169,7 +190,7 @@ private void handleTestCaseStarted(final TestCaseStarted event) {
         final String description = Stream.of(feature.getDescription(), scenarioDefinition.getDescription())
                 .filter(Objects::nonNull)
                 .filter(s -> !s.isEmpty())
-                .collect(Collectors.joining("\n"));
+                .collect(Collectors.joining(NEW_LINE));
 
         if (!description.isEmpty()) {
             result.setDescription(description);
@@ -194,9 +215,10 @@ private void handleTestCaseFinished(final TestCaseFinished event) {
                 .setMuted(tagParser.isMuted())
                 .setKnown(tagParser.isKnown());
 
-        lifecycle.updateTestCase(uuid, testResult -> testResult
-                .setStatus(status)
-                .setStatusDetails(statusDetails)
+        lifecycle.updateTestCase(
+                uuid, testResult -> testResult
+                        .setStatus(status)
+                        .setStatusDetails(statusDetails)
         );
 
         lifecycle.stopTestCase(uuid);
@@ -256,9 +278,10 @@ private void handleStartFixtureHook(final TestCase testCase,
         final String containerUuid = hookStepContainerUuid
                 .computeIfAbsent(hookId, unused -> UUID.randomUUID().toString());
 
-        lifecycle.startTestContainer(new TestResultContainer()
-                .setUuid(containerUuid)
-                .setChildren(Collections.singletonList(uuid))
+        lifecycle.startTestContainer(
+                new TestResultContainer()
+                        .setUuid(containerUuid)
+                        .setChildren(Collections.singletonList(uuid))
         );
 
         final FixtureResult hookResult = new FixtureResult()
@@ -339,15 +362,14 @@ private Status translateTestCaseStatus(final Result testCaseResult) {
     }
 
     private List<Parameter> getExamplesAsParameters(
-            final Scenario scenario,
-            final TestCase localCurrentTestCase) {
-        final Optional<Examples> maybeExample =
-                scenario.getExamplesList().stream()
-                        .filter(example -> example.getTableBodyList().stream()
-                                .anyMatch(row -> row.getLocation().getLine()
-                                                 == localCurrentTestCase.getLocation().getLine())
-                        )
-                        .findFirst();
+                                                    final Scenario scenario,
+                                                    final TestCase localCurrentTestCase) {
+        final Optional<Examples> maybeExample = scenario.getExamplesList().stream()
+                .filter(
+                        example -> example.getTableBodyList().stream()
+                                .anyMatch(row -> row.getLocation().getLine() == localCurrentTestCase.getLocation().getLine())
+                )
+                .findFirst();
 
         if (!maybeExample.isPresent()) {
             return Collections.emptyList();
@@ -379,14 +401,16 @@ private void createDataTableAttachment(final DataTableArgument dataTableArgument
         final StringBuilder dataTableCsv = new StringBuilder();
         for (List<String> columns : rowsInTable) {
             if (!columns.isEmpty()) {
-                final String rowValue = columns.stream().collect(Collectors.joining("\t", "", "\n"));
+                final String rowValue = columns.stream().collect(Collectors.joining("\t", "", NEW_LINE));
                 dataTableCsv.append(rowValue);
             }
         }
         final String attachmentSource = lifecycle
                 .prepareAttachment("Data table", "text/tab-separated-values", "csv");
-        lifecycle.writeAttachment(attachmentSource,
-                new ByteArrayInputStream(dataTableCsv.toString().getBytes(StandardCharsets.UTF_8)));
+        lifecycle.writeAttachment(
+                attachmentSource,
+                new ByteArrayInputStream(dataTableCsv.toString().getBytes(StandardCharsets.UTF_8))
+        );
     }
 
     private void handleStopHookStep(final Result eventResult,
@@ -403,9 +427,10 @@ private void handleStopHookStep(final Result eventResult,
         final StatusDetails statusDetails = getStatusDetails(eventResult.getError())
                 .orElseGet(StatusDetails::new);
 
-        lifecycle.updateFixture(uuid, result -> result
-                .setStatus(status)
-                .setStatusDetails(statusDetails)
+        lifecycle.updateFixture(
+                uuid, result -> result
+                        .setStatus(status)
+                        .setStatusDetails(statusDetails)
         );
         lifecycle.stopFixture(uuid);
 
@@ -420,8 +445,7 @@ private void handleStopStep(final TestCase testCase,
 
         final Status stepStatus = translateTestCaseStatus(eventResult);
 
-        final StatusDetails statusDetails
-                = eventResult.getStatus() == io.cucumber.plugin.event.Status.UNDEFINED
+        final StatusDetails statusDetails = eventResult.getStatus() == io.cucumber.plugin.event.Status.UNDEFINED
                 ? new StatusDetails().setMessage("Undefined Step. Please add step definition")
                 : getStatusDetails(eventResult.getError())
                         .orElse(new StatusDetails());
diff --git a/allure-cucumber6-jvm/src/main/java/io/qameta/allure/cucumber6jvm/LabelBuilder.java b/allure-cucumber6-jvm/src/main/java/io/qameta/allure/cucumber6jvm/LabelBuilder.java
index 9684b9d5..794b78af 100644
--- a/allure-cucumber6-jvm/src/main/java/io/qameta/allure/cucumber6jvm/LabelBuilder.java
+++ b/allure-cucumber6-jvm/src/main/java/io/qameta/allure/cucumber6jvm/LabelBuilder.java
@@ -48,7 +48,7 @@
 /**
  * Scenario labels and links builder.
  */
-@SuppressWarnings({"CyclomaticComplexity", "MultipleStringLiterals"})
+@SuppressWarnings({"CyclomaticComplexity", "MultipleStringLiterals", "PMD.CognitiveComplexity"})
 class LabelBuilder {
     private static final Logger LOGGER = LoggerFactory.getLogger(LabelBuilder.class);
     private static final String COMPOSITE_TAG_DELIMITER = "=";
@@ -113,17 +113,19 @@ class LabelBuilder {
         final URI uri = scenario.getUri();
 
         scenarioLabels.addAll(ResultsUtils.getProvidedLabels());
-        scenarioLabels.addAll(Arrays.asList(
-                createHostLabel(),
-                createThreadLabel(),
-                createFeatureLabel(featureName),
-                createStoryLabel(scenario.getName()),
-                createSuiteLabel(featureName),
-                createTestClassLabel(scenario.getName()),
-                createFrameworkLabel("cucumber6jvm"),
-                createLanguageLabel("java"),
-                createLabel("gherkin_uri", uri.toString())
-        ));
+        scenarioLabels.addAll(
+                Arrays.asList(
+                        createHostLabel(),
+                        createThreadLabel(),
+                        createFeatureLabel(featureName),
+                        createStoryLabel(scenario.getName()),
+                        createSuiteLabel(featureName),
+                        createTestClassLabel(scenario.getName()),
+                        createFrameworkLabel("cucumber6jvm"),
+                        createLanguageLabel("java"),
+                        createLabel("gherkin_uri", uri.toString())
+                )
+        );
 
         featurePackage(uri.toString(), featureName)
                 .map(ResultsUtils::createPackageLabel)
@@ -156,8 +158,10 @@ private void tryHandleNamedLink(final String tagString) {
             final String name = tagString.split(COMPOSITE_TAG_DELIMITER)[1];
             scenarioLinks.add(ResultsUtils.createLink(null, name, null, type));
         } else {
-            LOGGER.warn("Composite named tag {} does not match regex {}. Skipping", tagString,
-                    namedLinkPatternString);
+            LOGGER.warn(
+                    "Composite named tag {} does not match regex {}. Skipping", tagString,
+                    namedLinkPatternString
+            );
         }
     }
 
@@ -175,10 +179,12 @@ private Optional<String> featurePackage(final String uriString, final String fea
         final String schemeSpecificPart = uri.normalize().getSchemeSpecificPart();
         final Stream<String> folders = Stream.of(schemeSpecificPart.replaceAll("\\.", "_").split("/"));
         final Stream<String> name = Stream.of(featureName);
-        return Optional.of(Stream.concat(folders, name)
-                .filter(Objects::nonNull)
-                .filter(s -> !s.isEmpty())
-                .collect(Collectors.joining(".")));
+        return Optional.of(
+                Stream.concat(folders, name)
+                        .filter(Objects::nonNull)
+                        .filter(s -> !s.isEmpty())
+                        .collect(Collectors.joining("."))
+        );
     }
 
     private static Optional<URI> safeUri(final String uri) {
diff --git a/allure-cucumber6-jvm/src/main/java/io/qameta/allure/cucumber6jvm/TagParser.java b/allure-cucumber6-jvm/src/main/java/io/qameta/allure/cucumber6jvm/TagParser.java
index 3d31fdef..66644299 100644
--- a/allure-cucumber6-jvm/src/main/java/io/qameta/allure/cucumber6jvm/TagParser.java
+++ b/allure-cucumber6-jvm/src/main/java/io/qameta/allure/cucumber6jvm/TagParser.java
@@ -51,9 +51,9 @@ public boolean isKnown() {
 
     private boolean getStatusDetailByTag(final String tagName) {
         return scenario.getTags().stream()
-                       .anyMatch(tag -> tag.equalsIgnoreCase(tagName))
-               || feature.getTagsList().stream()
-                       .anyMatch(tag -> tag.getName().equalsIgnoreCase(tagName));
+                .anyMatch(tag -> tag.equalsIgnoreCase(tagName))
+                || feature.getTagsList().stream()
+                        .anyMatch(tag -> tag.getName().equalsIgnoreCase(tagName));
     }
 
     public boolean isResultTag(final String tag) {
diff --git a/allure-cucumber6-jvm/src/main/java/io/qameta/allure/cucumber6jvm/testsourcemodel/TestSourcesModel.java b/allure-cucumber6-jvm/src/main/java/io/qameta/allure/cucumber6jvm/testsourcemodel/TestSourcesModel.java
index 2a338e95..2fa406ea 100644
--- a/allure-cucumber6-jvm/src/main/java/io/qameta/allure/cucumber6jvm/testsourcemodel/TestSourcesModel.java
+++ b/allure-cucumber6-jvm/src/main/java/io/qameta/allure/cucumber6jvm/testsourcemodel/TestSourcesModel.java
@@ -73,14 +73,16 @@ private void parseGherkinSource(final URI path) {
         final String source = pathToReadEventMap.get(path).getSource();
 
         final List<Messages.Envelope> sources = singletonList(
-                makeSourceEnvelope(source, path.toString()));
+                makeSourceEnvelope(source, path.toString())
+        );
 
         final List<Messages.Envelope> envelopes = Gherkin.fromSources(
                 sources,
                 true,
                 true,
                 true,
-                () -> String.valueOf(UUID.randomUUID())).collect(toList());
+                () -> String.valueOf(UUID.randomUUID())
+        ).collect(toList());
 
         final GherkinDocument gherkinDocument = envelopes.stream()
                 .filter(Messages.Envelope::hasGherkinDocument)
@@ -99,7 +101,7 @@ private void parseGherkinSource(final URI path) {
     }
 
     private void processFeatureDefinition(
-            final Map<Integer, AstNode> nodeMap, final FeatureChild child, final AstNode currentParent) {
+                                          final Map<Integer, AstNode> nodeMap, final FeatureChild child, final AstNode currentParent) {
         if (child.hasBackground()) {
             processBackgroundDefinition(nodeMap, child.getBackground(), currentParent);
         } else if (child.hasScenario()) {
@@ -114,8 +116,7 @@ private void processFeatureDefinition(
     }
 
     private void processBackgroundDefinition(
-            final Map<Integer, AstNode> nodeMap, final Background background, final AstNode currentParent
-    ) {
+                                             final Map<Integer, AstNode> nodeMap, final Background background, final AstNode currentParent) {
         final AstNode childNode = createAstNode(background, currentParent);
         nodeMap.put(background.getLocation().getLine(), childNode);
         for (Step step : background.getStepsList()) {
@@ -124,7 +125,7 @@ private void processBackgroundDefinition(
     }
 
     private void processScenarioDefinition(
-            final Map<Integer, AstNode> nodeMap, final Scenario child, final AstNode currentParent) {
+                                           final Map<Integer, AstNode> nodeMap, final Scenario child, final AstNode currentParent) {
         final AstNode childNode = createAstNode(child, currentParent);
         nodeMap.put(child.getLocation().getLine(), childNode);
         for (Step step : child.getStepsList()) {
@@ -136,7 +137,7 @@ private void processScenarioDefinition(
     }
 
     private void processRuleDefinition(
-            final Map<Integer, AstNode> nodeMap, final RuleChild child, final AstNode currentParent) {
+                                       final Map<Integer, AstNode> nodeMap, final RuleChild child, final AstNode currentParent) {
         if (child.hasBackground()) {
             processBackgroundDefinition(nodeMap, child.getBackground(), currentParent);
         } else if (child.hasScenario()) {
@@ -145,8 +146,7 @@ private void processRuleDefinition(
     }
 
     private void processScenarioOutlineExamples(
-            final Map<Integer, AstNode> nodeMap, final Scenario scenarioOutline, final AstNode parent
-    ) {
+                                                final Map<Integer, AstNode> nodeMap, final Scenario scenarioOutline, final AstNode parent) {
         for (Examples examples : scenarioOutline.getExamplesList()) {
             final AstNode examplesNode = createAstNode(examples, parent);
             final TableRow headerRow = examples.getTableHeader();
diff --git a/allure-cucumber6-jvm/src/main/java/io/qameta/allure/cucumber6jvm/testsourcemodel/TestSourcesModelProxy.java b/allure-cucumber6-jvm/src/main/java/io/qameta/allure/cucumber6jvm/testsourcemodel/TestSourcesModelProxy.java
index 36096f18..2e88546c 100644
--- a/allure-cucumber6-jvm/src/main/java/io/qameta/allure/cucumber6jvm/testsourcemodel/TestSourcesModelProxy.java
+++ b/allure-cucumber6-jvm/src/main/java/io/qameta/allure/cucumber6jvm/testsourcemodel/TestSourcesModelProxy.java
@@ -25,28 +25,62 @@
 import java.util.HashMap;
 import java.util.Map;
 
+/**
+ * Compatibility proxy around Cucumber feature source storage.
+ *
+ * <p>The proxy hides version-specific Cucumber source model APIs from the reporting plugin. Integrations use it to add source-read events and resolve feature, scenario, and step keyword metadata during execution.</p>
+ */
 public class TestSourcesModelProxy {
 
     private final Map<URI, TestSourceRead> pathToReadEventMap = new HashMap<>();
     private final TestSourcesModel testSources;
 
+    /**
+     * Creates a test sources model proxy with default configuration.
+     */
     public TestSourcesModelProxy() {
         this.testSources = new TestSourcesModel();
     }
 
+    /**
+     * Adds the test source read event.
+     *
+     * @param path the path to read from or write to
+     * @param event the framework event to process
+     */
     public void addTestSourceReadEvent(final URI path, final TestSourceRead event) {
         this.pathToReadEventMap.put(path, event);
         testSources.addTestSourceReadEvent(path, event);
     }
 
+    /**
+     * Returns the feature.
+     *
+     * @param path the path to read from or write to
+     * @return the feature
+     */
     public Feature getFeature(final URI path) {
         return testSources.getFeature(path);
     }
 
+    /**
+     * Returns the scenario definition.
+     *
+     * @param path the path to read from or write to
+     * @param line the source line number to resolve
+     * @return the scenario definition
+     */
     public Scenario getScenarioDefinition(final URI path, final int line) {
         return TestSourcesModel.getScenarioDefinition(testSources.getAstNode(path, line));
     }
 
+    /**
+     * Returns the keyword from source.
+     *
+     * @param uri the feature file URI
+     * @param stepLine the feature file line number of the step
+     * @return the keyword from source
+     */
     public String getKeywordFromSource(final URI uri, final int stepLine) {
         return this.getKeywordFromSourceInternal(uri, stepLine);
     }
diff --git a/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/AllureCucumber6JvmTest.java b/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/AllureCucumber6JvmTest.java
index 75cc8495..3cb35169 100644
--- a/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/AllureCucumber6JvmTest.java
+++ b/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/AllureCucumber6JvmTest.java
@@ -65,10 +65,6 @@
 import static org.assertj.core.api.Assertions.tuple;
 import static org.junit.jupiter.api.parallel.ResourceAccessMode.READ_WRITE;
 import static org.junit.jupiter.api.parallel.Resources.SYSTEM_PROPERTIES;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class AllureCucumber6JvmTest {
 
     @AllureFeatures.Base
@@ -80,6 +76,8 @@ void shouldSetName() {
         assertThat(testResults)
                 .extracting(TestResult::getName)
                 .containsExactlyInAnyOrder("Add a to b");
+        assertThat(testResults.get(0).getTitlePath())
+                .containsExactly("src", "test", "resources", "features", "simple.feature", "Simple feature");
     }
 
     @AllureFeatures.PassedTests
@@ -183,7 +181,7 @@ void shouldSetDescription() {
         final AllureResults results = runFeature("features/description.feature");
 
         final String expected = "This is description for current feature.\n"
-                                + "It should appear on each scenario in report";
+                + "It should appear on each scenario in report";
 
         final List<TestResult> testResults = results.getTestResults();
         assertThat(testResults)
@@ -200,7 +198,7 @@ void shouldSetScenarioDescription() {
         final AllureResults results = runFeature("features/scenario_description.feature");
 
         final String expected = "This is description for current feature.\n"
-                                + "It should appear on each scenario in report";
+                + "It should appear on each scenario in report";
 
         final List<TestResult> testResults = results.getTestResults();
         assertThat(testResults)
@@ -238,11 +236,12 @@ void shouldAddDataTableAttachment() {
         final String attachmentContent = new String(bytes, StandardCharsets.UTF_8);
 
         assertThat(attachmentContent)
-                .isEqualTo("""
-                        name\tlogin\temail
-                        Viktor\tclicman\tclicman@ya.ru
-                        Viktor2\tclicman2\tclicman2@ya.ru
+                .isEqualTo(
                         """
+                                name\tlogin\temail
+                                Viktor\tclicman\tclicman@ya.ru
+                                Viktor2\tclicman2\tclicman2@ya.ru
+                                """
                 );
 
     }
@@ -381,8 +380,14 @@ void shouldAddTags() {
 
     @AllureFeatures.Links
     @ExtendWith(SystemPropertyExtension.class)
-    @SystemProperty(name = "allure.link.issue.pattern", value = "https://example.org/issue/{}")
-    @SystemProperty(name = "allure.link.tms.pattern", value = "https://example.org/tms/{}")
+    @SystemProperty(
+            name = "allure.link.issue.pattern",
+            value = "https://example.org/issue/{}"
+    )
+    @SystemProperty(
+            name = "allure.link.tms.pattern",
+            value = "https://example.org/tms/{}"
+    )
     @Test
     void shouldAddLinks() {
         final AllureResults results = runFeature("features/tags.feature");
@@ -511,8 +516,10 @@ void shouldSupportDryRunForSimpleFeatures() {
     @AllureFeatures.Base
     @Test
     void shouldSupportDryRunForHooks() {
-        final AllureResults results = runFeature("features/hooks.feature", "--dry-run", "-t",
-                "@WithHooks or @BeforeHookWithException or @AfterHookWithException");
+        final AllureResults results = runFeature(
+                "features/hooks.feature", "--dry-run", "-t",
+                "@WithHooks or @BeforeHookWithException or @AfterHookWithException"
+        );
 
         final TestResult tr1 = results.getTestResultByName("Simple scenario with Before and After hooks");
 
@@ -652,8 +659,10 @@ void shouldProcessScenariosInParallelMode() {
     @AllureFeatures.Stages
     @Test
     void shouldDisplayHooksAsStages() {
-        final AllureResults results = runFeature("features/hooks.feature", "-t",
-                "@WithHooks or @BeforeHookWithException or @AfterHookWithException");
+        final AllureResults results = runFeature(
+                "features/hooks.feature", "-t",
+                "@WithHooks or @BeforeHookWithException or @AfterHookWithException"
+        );
 
         final TestResult tr1 = results.getTestResultByName("Simple scenario with Before and After hooks");
         final TestResult tr2 = results.getTestResultByName("Simple scenario with Before hook with Exception");
@@ -691,7 +700,6 @@ void shouldDisplayHooksAsStages() {
                         tuple("Then result is 15", Status.SKIPPED)
                 );
 
-
         assertThat(results.getTestResultContainersForTestResult(tr2))
                 .flatExtracting(TestResultContainer::getBefores)
                 .extracting(FixtureResult::getName, FixtureResult::getStatus)
@@ -737,8 +745,14 @@ void shouldHandleAmbigiousStepsExceptions() {
                 );
     }
 
-    @ResourceLock(value = SYSTEM_PROPERTIES, mode = READ_WRITE)
-    @SystemProperty(name = "allure.label.x-provided", value = "cucumberjvm6-test-provided")
+    @ResourceLock(
+            value = SYSTEM_PROPERTIES,
+            mode = READ_WRITE
+    )
+    @SystemProperty(
+            name = "allure.label.x-provided",
+            value = "cucumberjvm6-test-provided"
+    )
     @Test
     void shouldSupportProvidedLabels() {
         final AllureResults results = runFeature("features/simple.feature");
@@ -783,17 +797,22 @@ void shouldSupportRuntimeApiInStepsWhenHooksAreUsed() {
                 );
     }
 
-    @SystemProperty(name = "cucumber.junit-platform.naming-strategy", value = "long")
+    @SystemProperty(
+            name = "cucumber.junit-platform.naming-strategy",
+            value = "long"
+    )
     @Step
     private AllureResults runFeature(final String featureResource,
                                      final String... moreOptions) {
         return RunUtils.runTests(lifecycle -> {
             final AllureCucumber6Jvm cucumber6jvm = new AllureCucumber6Jvm(lifecycle);
             final Supplier<ClassLoader> classLoader = ClassLoaders::getDefaultClassLoader;
-            final List<String> opts = new ArrayList<>(Arrays.asList(
-                    "--glue", "io.qameta.allure.cucumber6jvm.samples",
-                    "--plugin", "null_summary"
-            ));
+            final List<String> opts = new ArrayList<>(
+                    Arrays.asList(
+                            "--glue", "io.qameta.allure.cucumber6jvm.samples",
+                            "--plugin", "null_summary"
+                    )
+            );
             opts.addAll(Arrays.asList(moreOptions));
             final FeatureWithLines featureWithLines = FeatureWithLines.parse("src/test/resources/" + featureResource);
             final RuntimeOptions options = new CommandlineOptionsParser(System.out)
@@ -801,8 +820,7 @@ private AllureResults runFeature(final String featureResource,
 
             final EventBus bus = new TimeServiceEventBus(Clock.systemUTC(), UUID::randomUUID);
             final FeatureParser parser = new FeatureParser(bus::generateId);
-            final FeaturePathFeatureSupplier supplier
-                    = new FeaturePathFeatureSupplier(classLoader, options, parser);
+            final FeaturePathFeatureSupplier supplier = new FeaturePathFeatureSupplier(classLoader, options, parser);
 
             final Runtime runtime = Runtime.builder()
                     .withClassLoader(classLoader)
diff --git a/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/AmbigiousSteps.java b/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/AmbigiousSteps.java
index 5a2e5a12..3ea3058c 100644
--- a/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/AmbigiousSteps.java
+++ b/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/AmbigiousSteps.java
@@ -17,10 +17,6 @@
 
 import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class AmbigiousSteps {
 
     @When("^ambigious step (.+)$")
@@ -34,7 +30,7 @@ public void ambigious_2() {
     }
 
     @Then("^something bad should happen")
-    public void somethingBadStep(){
+    public void somethingBadStep() {
         //nothing here
     }
 }
diff --git a/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/AttachmentSteps.java b/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/AttachmentSteps.java
index 6a9393a8..2b72de70 100644
--- a/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/AttachmentSteps.java
+++ b/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/AttachmentSteps.java
@@ -15,8 +15,8 @@
  */
 package io.qameta.allure.cucumber6jvm.samples;
 
-import io.cucumber.java.Scenario;
 import io.cucumber.java.Before;
+import io.cucumber.java.Scenario;
 import io.cucumber.java.en.Given;
 
 public class AttachmentSteps {
diff --git a/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/BackgroundFeatureSteps.java b/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/BackgroundFeatureSteps.java
index 578abfdf..5d909884 100644
--- a/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/BackgroundFeatureSteps.java
+++ b/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/BackgroundFeatureSteps.java
@@ -18,10 +18,6 @@
 import io.cucumber.java.en.Given;
 import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class BackgroundFeatureSteps {
 
     @Given("^cat is sad$")
diff --git a/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/BrokenFeatureSteps.java b/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/BrokenFeatureSteps.java
index 1222c28f..b1922783 100644
--- a/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/BrokenFeatureSteps.java
+++ b/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/BrokenFeatureSteps.java
@@ -16,10 +16,6 @@
 package io.qameta.allure.cucumber6jvm.samples;
 
 import io.cucumber.java.en.Given;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class BrokenFeatureSteps {
 
     @Given("^everything is broken$")
diff --git a/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/DatatableFeatureSteps.java b/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/DatatableFeatureSteps.java
index b8a69f6b..d278ec28 100644
--- a/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/DatatableFeatureSteps.java
+++ b/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/DatatableFeatureSteps.java
@@ -17,10 +17,6 @@
 
 import io.cucumber.datatable.DataTable;
 import io.cucumber.java.en.Given;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @SuppressWarnings("unused")
 public class DatatableFeatureSteps {
 
diff --git a/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/HookSteps.java b/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/HookSteps.java
index d7fe2a8e..94ceb8d7 100644
--- a/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/HookSteps.java
+++ b/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/HookSteps.java
@@ -18,29 +18,25 @@
 import io.cucumber.java.After;
 import io.cucumber.java.Before;
 import org.assertj.core.api.Assertions;
-
-/**
- * @author letsrokk (Dmitry Mayer).
- */
 public class HookSteps {
 
     @Before("@WithHooks")
-    public void beforeHook(){
+    public void beforeHook() {
         // nothing
     }
 
     @After("@WithHooks")
-    public void afterHook(){
+    public void afterHook() {
         // nothing
     }
 
     @Before("@BeforeHookWithException")
-    public void beforeHookWithException(){
+    public void beforeHookWithException() {
         Assertions.fail("Exception in Hook step");
     }
 
     @After("@AfterHookWithException")
-    public void afterHookWithException(){
+    public void afterHookWithException() {
         Assertions.fail("Exception in Hook step");
     }
 
diff --git a/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/PendingSteps.java b/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/PendingSteps.java
index f0a8fb7a..d4d1498c 100644
--- a/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/PendingSteps.java
+++ b/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/PendingSteps.java
@@ -17,10 +17,6 @@
 
 import io.cucumber.java.PendingException;
 import io.cucumber.java.en.Given;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class PendingSteps {
 
     @Given("^step is yet to be implemented$")
diff --git a/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/RuntimeApiSteps.java b/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/RuntimeApiSteps.java
index 7438ea19..61010571 100644
--- a/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/RuntimeApiSteps.java
+++ b/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/RuntimeApiSteps.java
@@ -20,19 +20,15 @@
 import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;
 import io.qameta.allure.Allure;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class RuntimeApiSteps {
 
     @Before("@beforeScenario")
-    public void beforeScenario(){
+    public void beforeScenario() {
         // nothing
     }
 
     @Before("@beforeFeature")
-    public void beforeFeature(){
+    public void beforeFeature() {
         // nothing
     }
 
diff --git a/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/SimpleFeatureSteps.java b/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/SimpleFeatureSteps.java
index 8d1c005a..e7618526 100644
--- a/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/SimpleFeatureSteps.java
+++ b/allure-cucumber6-jvm/src/test/java/io/qameta/allure/cucumber6jvm/samples/SimpleFeatureSteps.java
@@ -19,10 +19,6 @@
 import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;
 import org.assertj.core.api.Assertions;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class SimpleFeatureSteps {
 
     private int a;
diff --git a/allure-cucumber6-jvm/src/test/resources/allure.properties b/allure-cucumber6-jvm/src/test/resources/allure.properties
index dbfefee4..6b16969f 100644
--- a/allure-cucumber6-jvm/src/test/resources/allure.properties
+++ b/allure-cucumber6-jvm/src/test/resources/allure.properties
@@ -1,3 +1,4 @@
 allure.model.indentOutput=true
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-cucumber6-jvm
diff --git a/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/AllureCucumber7Jvm.java b/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/AllureCucumber7Jvm.java
index 60883143..032335b8 100644
--- a/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/AllureCucumber7Jvm.java
+++ b/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/AllureCucumber7Jvm.java
@@ -66,20 +66,27 @@
 import java.util.stream.Stream;
 
 import static io.qameta.allure.util.ResultsUtils.createParameter;
+import static io.qameta.allure.util.ResultsUtils.createTitlePath;
+import static io.qameta.allure.util.ResultsUtils.createTitlePathFromSourcePath;
 import static io.qameta.allure.util.ResultsUtils.getStatus;
 import static io.qameta.allure.util.ResultsUtils.getStatusDetails;
 import static io.qameta.allure.util.ResultsUtils.md5;
 
 /**
- * Allure plugin for Cucumber JVM 7.0.
+ * Reports Cucumber JVM 7 execution to Allure.
+ *
+ * <p>Add this plugin to the Cucumber runtime so feature, scenario, step, hook, and attachment events are converted into Allure results. Use the default lifecycle for normal runs or pass one explicitly for embedded runners and tests.</p>
  */
-@SuppressWarnings({
-        "ClassDataAbstractionCoupling",
-        "ClassFanOutComplexity",
-})
+@SuppressWarnings(
+    {
+            "ClassDataAbstractionCoupling",
+            "ClassFanOutComplexity",
+    }
+)
 public class AllureCucumber7Jvm implements ConcurrentEventListener {
 
     private static final String COLON = ":";
+    private static final String NEW_LINE = "\n";
 
     private final AllureLifecycle lifecycle;
 
@@ -99,15 +106,26 @@ public class AllureCucumber7Jvm implements ConcurrentEventListener {
     private static final String TEXT_PLAIN = "text/plain";
     private static final String CUCUMBER_WORKING_DIR = Paths.get("").toUri().getSchemeSpecificPart();
 
+    /**
+     * Creates an Allure cucumber7 jvm with default configuration.
+     */
     @SuppressWarnings("unused")
     public AllureCucumber7Jvm() {
         this(Allure.getLifecycle());
     }
 
+    /**
+     * Creates an Allure cucumber7 jvm with the supplied values.
+     *
+     * @param lifecycle the Allure lifecycle to use
+     */
     public AllureCucumber7Jvm(final AllureLifecycle lifecycle) {
         this.lifecycle = lifecycle;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void setEventPublisher(final EventPublisher publisher) {
         publisher.registerHandlerFor(TestSourceRead.class, featureStartedHandler);
@@ -135,31 +153,34 @@ private void handleTestCaseStarted(final TestCaseStarted event) {
 
         final String name = testCase.getName();
 
-
         // the same way full name is generated for
         // org.junit.platform.engine.support.descriptor.ClasspathResourceSource
         // to support io.qameta.allure.junitplatform.AllurePostDiscoveryFilter
-        final String fullName = String.format("%s:%d",
+        final String fullName = String.format(
+                "%s:%d",
                 getTestCaseUri(testCase),
                 testCase.getLocation().getLine()
         );
 
         final String testCaseUuid = testCase.getId().toString();
 
+        final List<String> titlePath = createTitlePathFromSourcePath(getTestCaseUri(testCase));
+        titlePath.addAll(createTitlePath(feature.getName()));
+
         final TestResult result = new TestResult()
                 .setUuid(testCaseUuid)
                 .setTestCaseId(getTestCaseId(testCase))
                 .setHistoryId(getHistoryId(testCase))
                 .setFullName(fullName)
+                .setTitlePath(titlePath)
                 .setName(name)
                 .setLabels(labelBuilder.getScenarioLabels())
                 .setLinks(labelBuilder.getScenarioLinks());
 
-        final Scenario scenarioDefinition =
-                testSources.getScenarioDefinition(
-                        testCase.getUri(),
-                        testCase.getLocation().getLine()
-                );
+        final Scenario scenarioDefinition = testSources.getScenarioDefinition(
+                testCase.getUri(),
+                testCase.getLocation().getLine()
+        );
 
         if (scenarioDefinition.getExamples() != null) {
             result.setParameters(
@@ -170,7 +191,7 @@ private void handleTestCaseStarted(final TestCaseStarted event) {
         final String description = Stream.of(feature.getDescription(), scenarioDefinition.getDescription())
                 .filter(Objects::nonNull)
                 .filter(s -> !s.isEmpty())
-                .collect(Collectors.joining("\n"));
+                .collect(Collectors.joining(NEW_LINE));
 
         if (!description.isEmpty()) {
             result.setDescription(description);
@@ -195,9 +216,10 @@ private void handleTestCaseFinished(final TestCaseFinished event) {
                 .setMuted(tagParser.isMuted())
                 .setKnown(tagParser.isKnown());
 
-        lifecycle.updateTestCase(uuid, testResult -> testResult
-                .setStatus(status)
-                .setStatusDetails(statusDetails)
+        lifecycle.updateTestCase(
+                uuid, testResult -> testResult
+                        .setStatus(status)
+                        .setStatusDetails(statusDetails)
         );
 
         lifecycle.stopTestCase(uuid);
@@ -257,9 +279,10 @@ private void handleStartFixtureHook(final TestCase testCase,
         final String containerUuid = hookStepContainerUuid
                 .computeIfAbsent(hookId, unused -> UUID.randomUUID().toString());
 
-        lifecycle.startTestContainer(new TestResultContainer()
-                .setUuid(containerUuid)
-                .setChildren(Collections.singletonList(uuid))
+        lifecycle.startTestContainer(
+                new TestResultContainer()
+                        .setUuid(containerUuid)
+                        .setChildren(Collections.singletonList(uuid))
         );
 
         final FixtureResult hookResult = new FixtureResult()
@@ -340,16 +363,15 @@ private Status translateTestCaseStatus(final Result testCaseResult) {
     }
 
     private List<Parameter> getExamplesAsParameters(
-            final Scenario scenario,
-            final TestCase localCurrentTestCase) {
+                                                    final Scenario scenario,
+                                                    final TestCase localCurrentTestCase) {
 
-        final Optional<Examples> maybeExample =
-                scenario.getExamples().stream()
-                        .filter(example -> example.getTableBody().stream()
-                                .anyMatch(row -> row.getLocation().getLine()
-                                                 == localCurrentTestCase.getLocation().getLine())
-                        )
-                        .findFirst();
+        final Optional<Examples> maybeExample = scenario.getExamples().stream()
+                .filter(
+                        example -> example.getTableBody().stream()
+                                .anyMatch(row -> row.getLocation().getLine() == localCurrentTestCase.getLocation().getLine())
+                )
+                .findFirst();
 
         if (!maybeExample.isPresent()) {
             return Collections.emptyList();
@@ -370,9 +392,10 @@ private List<Parameter> getExamplesAsParameters(
 
         final List<String> headerNames = examples.getTableHeader()
                 .map(TableRow::getCells)
-                .map(rows -> rows.stream()
-                        .map(TableCell::getValue)
-                        .collect(Collectors.toList())
+                .map(
+                        rows -> rows.stream()
+                                .map(TableCell::getValue)
+                                .collect(Collectors.toList())
                 )
                 .orElse(null);
 
@@ -392,14 +415,16 @@ private void createDataTableAttachment(final DataTableArgument dataTableArgument
         final StringBuilder dataTableCsv = new StringBuilder();
         for (List<String> columns : rowsInTable) {
             if (!columns.isEmpty()) {
-                final String rowValue = columns.stream().collect(Collectors.joining("\t", "", "\n"));
+                final String rowValue = columns.stream().collect(Collectors.joining("\t", "", NEW_LINE));
                 dataTableCsv.append(rowValue);
             }
         }
         final String attachmentSource = lifecycle
                 .prepareAttachment("Data table", "text/tab-separated-values", "csv");
-        lifecycle.writeAttachment(attachmentSource,
-                new ByteArrayInputStream(dataTableCsv.toString().getBytes(StandardCharsets.UTF_8)));
+        lifecycle.writeAttachment(
+                attachmentSource,
+                new ByteArrayInputStream(dataTableCsv.toString().getBytes(StandardCharsets.UTF_8))
+        );
     }
 
     private void handleStopHookStep(final Result eventResult,
@@ -416,9 +441,10 @@ private void handleStopHookStep(final Result eventResult,
         final StatusDetails statusDetails = getStatusDetails(eventResult.getError())
                 .orElseGet(StatusDetails::new);
 
-        lifecycle.updateFixture(uuid, result -> result
-                .setStatus(status)
-                .setStatusDetails(statusDetails)
+        lifecycle.updateFixture(
+                uuid, result -> result
+                        .setStatus(status)
+                        .setStatusDetails(statusDetails)
         );
         lifecycle.stopFixture(uuid);
 
@@ -433,8 +459,7 @@ private void handleStopStep(final TestCase testCase,
 
         final Status stepStatus = translateTestCaseStatus(eventResult);
 
-        final StatusDetails statusDetails
-                = eventResult.getStatus() == io.cucumber.plugin.event.Status.UNDEFINED
+        final StatusDetails statusDetails = eventResult.getStatus() == io.cucumber.plugin.event.Status.UNDEFINED
                 ? new StatusDetails().setMessage("Undefined Step. Please add step definition")
                 : getStatusDetails(eventResult.getError())
                         .orElse(new StatusDetails());
diff --git a/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/LabelBuilder.java b/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/LabelBuilder.java
index e4d96d5f..62123bdf 100644
--- a/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/LabelBuilder.java
+++ b/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/LabelBuilder.java
@@ -48,7 +48,7 @@
 /**
  * Scenario labels and links builder.
  */
-@SuppressWarnings({"CyclomaticComplexity", "MultipleStringLiterals"})
+@SuppressWarnings({"CyclomaticComplexity", "MultipleStringLiterals", "PMD.CognitiveComplexity"})
 class LabelBuilder {
     private static final Logger LOGGER = LoggerFactory.getLogger(LabelBuilder.class);
     private static final String COMPOSITE_TAG_DELIMITER = "=";
@@ -117,17 +117,19 @@ class LabelBuilder {
         final URI uri = scenario.getUri();
 
         scenarioLabels.addAll(ResultsUtils.getProvidedLabels());
-        scenarioLabels.addAll(Arrays.asList(
-                createHostLabel(),
-                createThreadLabel(),
-                createFeatureLabel(featureName),
-                createStoryLabel(scenario.getName()),
-                createSuiteLabel(featureName),
-                createTestClassLabel(scenario.getName()),
-                createFrameworkLabel("cucumber4jvm"),
-                createLanguageLabel("java"),
-                createLabel("gherkin_uri", uri.toString())
-        ));
+        scenarioLabels.addAll(
+                Arrays.asList(
+                        createHostLabel(),
+                        createThreadLabel(),
+                        createFeatureLabel(featureName),
+                        createStoryLabel(scenario.getName()),
+                        createSuiteLabel(featureName),
+                        createTestClassLabel(scenario.getName()),
+                        createFrameworkLabel("cucumber4jvm"),
+                        createLanguageLabel("java"),
+                        createLabel("gherkin_uri", uri.toString())
+                )
+        );
 
         featurePackage(uri.toString(), featureName)
                 .map(ResultsUtils::createPackageLabel)
@@ -160,8 +162,10 @@ private void tryHandleNamedLink(final String tagString) {
             final String name = tagString.split(COMPOSITE_TAG_DELIMITER)[1];
             scenarioLinks.add(ResultsUtils.createLink(null, name, null, type));
         } else {
-            LOGGER.warn("Composite named tag {} does not match regex {}. Skipping", tagString,
-                    namedLinkPatternString);
+            LOGGER.warn(
+                    "Composite named tag {} does not match regex {}. Skipping", tagString,
+                    namedLinkPatternString
+            );
         }
     }
 
@@ -179,10 +183,12 @@ private Optional<String> featurePackage(final String uriString, final String fea
         final String schemeSpecificPart = uri.normalize().getSchemeSpecificPart();
         final Stream<String> folders = Stream.of(schemeSpecificPart.replaceAll("\\.", "_").split("/"));
         final Stream<String> name = Stream.of(featureName);
-        return Optional.of(Stream.concat(folders, name)
-                .filter(Objects::nonNull)
-                .filter(s -> !s.isEmpty())
-                .collect(Collectors.joining(".")));
+        return Optional.of(
+                Stream.concat(folders, name)
+                        .filter(Objects::nonNull)
+                        .filter(s -> !s.isEmpty())
+                        .collect(Collectors.joining("."))
+        );
     }
 
     private static Optional<URI> safeUri(final String uri) {
diff --git a/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/TagParser.java b/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/TagParser.java
index ea7e10ef..faca7e91 100644
--- a/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/TagParser.java
+++ b/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/TagParser.java
@@ -51,9 +51,9 @@ public boolean isKnown() {
 
     private boolean getStatusDetailByTag(final String tagName) {
         return scenario.getTags().stream()
-                       .anyMatch(tag -> tag.equalsIgnoreCase(tagName))
-               || feature.getTags().stream()
-                       .anyMatch(tag -> tag.getName().equalsIgnoreCase(tagName));
+                .anyMatch(tag -> tag.equalsIgnoreCase(tagName))
+                || feature.getTags().stream()
+                        .anyMatch(tag -> tag.getName().equalsIgnoreCase(tagName));
     }
 
     public boolean isResultTag(final String tag) {
diff --git a/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/testsourcemodel/TestSourcesModel.java b/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/testsourcemodel/TestSourcesModel.java
index 479ada73..91e4e185 100644
--- a/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/testsourcemodel/TestSourcesModel.java
+++ b/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/testsourcemodel/TestSourcesModel.java
@@ -73,7 +73,8 @@ private void parseGherkinSource(final URI path) {
                 .build();
 
         final Stream<Envelope> envelopes = parser.parse(
-                Envelope.of(new Source(path.toString(), source, SourceMediaType.TEXT_X_CUCUMBER_GHERKIN_PLAIN)));
+                Envelope.of(new Source(path.toString(), source, SourceMediaType.TEXT_X_CUCUMBER_GHERKIN_PLAIN))
+        );
 
         // TODO: What about empty gherkin docs?
         final GherkinDocument gherkinDocument = envelopes
@@ -97,7 +98,7 @@ private void parseGherkinSource(final URI path) {
     }
 
     private void processFeatureDefinition(
-            final Map<Long, AstNode> nodeMap, final FeatureChild child, final AstNode currentParent) {
+                                          final Map<Long, AstNode> nodeMap, final FeatureChild child, final AstNode currentParent) {
         child.getBackground().ifPresent(background -> processBackgroundDefinition(nodeMap, background, currentParent));
         child.getScenario().ifPresent(scenario -> processScenarioDefinition(nodeMap, scenario, currentParent));
         child.getRule().ifPresent(rule -> {
@@ -108,8 +109,7 @@ private void processFeatureDefinition(
     }
 
     private void processBackgroundDefinition(
-            final Map<Long, AstNode> nodeMap, final Background background, final AstNode currentParent
-    ) {
+                                             final Map<Long, AstNode> nodeMap, final Background background, final AstNode currentParent) {
         final AstNode childNode = createAstNode(background, currentParent);
         nodeMap.put(background.getLocation().getLine(), childNode);
         for (Step step : background.getSteps()) {
@@ -118,7 +118,7 @@ private void processBackgroundDefinition(
     }
 
     private void processScenarioDefinition(
-            final Map<Long, AstNode> nodeMap, final Scenario child, final AstNode currentParent) {
+                                           final Map<Long, AstNode> nodeMap, final Scenario child, final AstNode currentParent) {
         final AstNode childNode = createAstNode(child, currentParent);
         nodeMap.put(child.getLocation().getLine(), childNode);
         for (Step step : child.getSteps()) {
@@ -130,14 +130,13 @@ private void processScenarioDefinition(
     }
 
     private void processRuleDefinition(
-            final Map<Long, AstNode> nodeMap, final RuleChild child, final AstNode currentParent) {
+                                       final Map<Long, AstNode> nodeMap, final RuleChild child, final AstNode currentParent) {
         child.getBackground().ifPresent(background -> processBackgroundDefinition(nodeMap, background, currentParent));
         child.getScenario().ifPresent(scenario -> processScenarioDefinition(nodeMap, scenario, currentParent));
     }
 
     private void processScenarioOutlineExamples(
-            final Map<Long, AstNode> nodeMap, final Scenario scenarioOutline, final AstNode parent
-    ) {
+                                                final Map<Long, AstNode> nodeMap, final Scenario scenarioOutline, final AstNode parent) {
         for (Examples examples : scenarioOutline.getExamples()) {
             final AstNode examplesNode = createAstNode(examples, parent);
             // TODO: Can tables without headers even exist?
diff --git a/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/testsourcemodel/TestSourcesModelProxy.java b/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/testsourcemodel/TestSourcesModelProxy.java
index 9a922620..155257b6 100644
--- a/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/testsourcemodel/TestSourcesModelProxy.java
+++ b/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/testsourcemodel/TestSourcesModelProxy.java
@@ -26,28 +26,62 @@
 import java.util.Map;
 import java.util.Objects;
 
+/**
+ * Compatibility proxy around Cucumber feature source storage.
+ *
+ * <p>The proxy hides version-specific Cucumber source model APIs from the reporting plugin. Integrations use it to add source-read events and resolve feature, scenario, and step keyword metadata during execution.</p>
+ */
 public class TestSourcesModelProxy {
 
     private final Map<URI, TestSourceRead> pathToReadEventMap = new HashMap<>();
     private final TestSourcesModel testSources;
 
+    /**
+     * Creates a test sources model proxy with default configuration.
+     */
     public TestSourcesModelProxy() {
         this.testSources = new TestSourcesModel();
     }
 
+    /**
+     * Adds the test source read event.
+     *
+     * @param path the path to read from or write to
+     * @param event the framework event to process
+     */
     public void addTestSourceReadEvent(final URI path, final TestSourceRead event) {
         this.pathToReadEventMap.put(path, event);
         testSources.addTestSourceReadEvent(path, event);
     }
 
+    /**
+     * Returns the feature.
+     *
+     * @param path the path to read from or write to
+     * @return the feature
+     */
     public Feature getFeature(final URI path) {
         return testSources.getFeature(path);
     }
 
+    /**
+     * Returns the scenario definition.
+     *
+     * @param path the path to read from or write to
+     * @param line the source line number to resolve
+     * @return the scenario definition
+     */
     public Scenario getScenarioDefinition(final URI path, final int line) {
         return TestSourcesModel.getScenarioDefinition(testSources.getAstNode(path, line));
     }
 
+    /**
+     * Returns the keyword from source.
+     *
+     * @param uri the feature file URI
+     * @param stepLine the feature file line number of the step
+     * @return the keyword from source
+     */
     public String getKeywordFromSource(final URI uri, final int stepLine) {
         return this.getKeywordFromSourceInternal(uri, stepLine);
     }
diff --git a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/AllureCucumber7JvmTest.java b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/AllureCucumber7JvmTest.java
index 0d8a20a7..109de2c4 100644
--- a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/AllureCucumber7JvmTest.java
+++ b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/AllureCucumber7JvmTest.java
@@ -65,10 +65,6 @@
 import static org.assertj.core.api.Assertions.tuple;
 import static org.junit.jupiter.api.parallel.ResourceAccessMode.READ_WRITE;
 import static org.junit.jupiter.api.parallel.Resources.SYSTEM_PROPERTIES;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class AllureCucumber7JvmTest {
 
     @AllureFeatures.Base
@@ -80,6 +76,8 @@ void shouldSetName() {
         assertThat(testResults)
                 .extracting(TestResult::getName)
                 .containsExactlyInAnyOrder("Add a to b");
+        assertThat(testResults.get(0).getTitlePath())
+                .containsExactly("src", "test", "resources", "features", "simple.feature", "Simple feature");
     }
 
     @AllureFeatures.PassedTests
@@ -183,7 +181,7 @@ void shouldSetDescription() {
         final AllureResults results = runFeature("features/description.feature");
 
         final String expected = "This is description for current feature.\n"
-                                + "It should appear on each scenario in report";
+                + "It should appear on each scenario in report";
 
         final List<TestResult> testResults = results.getTestResults();
         assertThat(testResults)
@@ -200,7 +198,7 @@ void shouldSetScenarioDescription() {
         final AllureResults results = runFeature("features/scenario_description.feature");
 
         final String expected = "This is description for current feature.\n"
-                                + "It should appear on each scenario in report";
+                + "It should appear on each scenario in report";
 
         final List<TestResult> testResults = results.getTestResults();
         assertThat(testResults)
@@ -238,11 +236,12 @@ void shouldAddDataTableAttachment() {
         final String attachmentContent = new String(bytes, StandardCharsets.UTF_8);
 
         assertThat(attachmentContent)
-                .isEqualTo("""
-                        name\tlogin\temail
-                        Viktor\tclicman\tclicman@ya.ru
-                        Viktor2\tclicman2\tclicman2@ya.ru
+                .isEqualTo(
                         """
+                                name\tlogin\temail
+                                Viktor\tclicman\tclicman@ya.ru
+                                Viktor2\tclicman2\tclicman2@ya.ru
+                                """
                 );
 
     }
@@ -381,8 +380,14 @@ void shouldAddTags() {
 
     @AllureFeatures.Links
     @ExtendWith(SystemPropertyExtension.class)
-    @SystemProperty(name = "allure.link.issue.pattern", value = "https://example.org/issue/{}")
-    @SystemProperty(name = "allure.link.tms.pattern", value = "https://example.org/tms/{}")
+    @SystemProperty(
+            name = "allure.link.issue.pattern",
+            value = "https://example.org/issue/{}"
+    )
+    @SystemProperty(
+            name = "allure.link.tms.pattern",
+            value = "https://example.org/tms/{}"
+    )
     @Test
     void shouldAddLinks() {
         final AllureResults results = runFeature("features/tags.feature");
@@ -511,8 +516,10 @@ void shouldSupportDryRunForSimpleFeatures() {
     @AllureFeatures.Base
     @Test
     void shouldSupportDryRunForHooks() {
-        final AllureResults results = runFeature("features/hooks.feature", "--dry-run", "-t",
-                "@WithHooks or @BeforeHookWithException or @AfterHookWithException");
+        final AllureResults results = runFeature(
+                "features/hooks.feature", "--dry-run", "-t",
+                "@WithHooks or @BeforeHookWithException or @AfterHookWithException"
+        );
 
         final TestResult tr1 = results.getTestResultByName("Simple scenario with Before and After hooks");
 
@@ -652,8 +659,10 @@ void shouldProcessScenariosInParallelMode() {
     @AllureFeatures.Stages
     @Test
     void shouldDisplayHooksAsStages() {
-        final AllureResults results = runFeature("features/hooks.feature", "-t",
-                "@WithHooks or @BeforeHookWithException or @AfterHookWithException");
+        final AllureResults results = runFeature(
+                "features/hooks.feature", "-t",
+                "@WithHooks or @BeforeHookWithException or @AfterHookWithException"
+        );
 
         final TestResult tr1 = results.getTestResultByName("Simple scenario with Before and After hooks");
         final TestResult tr2 = results.getTestResultByName("Simple scenario with Before hook with Exception");
@@ -691,7 +700,6 @@ void shouldDisplayHooksAsStages() {
                         tuple("Then result is 15", Status.SKIPPED)
                 );
 
-
         assertThat(results.getTestResultContainersForTestResult(tr2))
                 .flatExtracting(TestResultContainer::getBefores)
                 .extracting(FixtureResult::getName, FixtureResult::getStatus)
@@ -737,8 +745,14 @@ void shouldHandleAmbigiousStepsExceptions() {
                 );
     }
 
-    @ResourceLock(value = SYSTEM_PROPERTIES, mode = READ_WRITE)
-    @SystemProperty(name = "allure.label.x-provided", value = "cucumberjvm7-test-provided")
+    @ResourceLock(
+            value = SYSTEM_PROPERTIES,
+            mode = READ_WRITE
+    )
+    @SystemProperty(
+            name = "allure.label.x-provided",
+            value = "cucumberjvm7-test-provided"
+    )
     @Test
     void shouldSupportProvidedLabels() {
         final AllureResults results = runFeature("features/simple.feature");
@@ -783,7 +797,10 @@ void shouldSupportRuntimeApiInStepsWhenHooksAreUsed() {
                 );
     }
 
-    @SystemProperty(name = "cucumber.junit-platform.naming-strategy", value = "long")
+    @SystemProperty(
+            name = "cucumber.junit-platform.naming-strategy",
+            value = "long"
+    )
     @Step
     private AllureResults runFeature(final String featureResource,
                                      final String... moreOptions) {
@@ -791,10 +808,12 @@ private AllureResults runFeature(final String featureResource,
         return RunUtils.runTests(lifecycle -> {
             final AllureCucumber7Jvm cucumber7jvm = new AllureCucumber7Jvm(lifecycle);
             final Supplier<ClassLoader> classLoader = ClassLoaders::getDefaultClassLoader;
-            final List<String> opts = new ArrayList<>(Arrays.asList(
-                    "--glue", "io.qameta.allure.cucumber7jvm.samples",
-                    "--no-summary"
-            ));
+            final List<String> opts = new ArrayList<>(
+                    Arrays.asList(
+                            "--glue", "io.qameta.allure.cucumber7jvm.samples",
+                            "--no-summary"
+                    )
+            );
             opts.addAll(Arrays.asList(moreOptions));
             final FeatureWithLines featureWithLines = FeatureWithLines.parse("src/test/resources/" + featureResource);
             final RuntimeOptions options = new CommandlineOptionsParser(System.out)
@@ -802,8 +821,7 @@ private AllureResults runFeature(final String featureResource,
 
             final EventBus bus = new TimeServiceEventBus(Clock.systemUTC(), UUID::randomUUID);
             final FeatureParser parser = new FeatureParser(bus::generateId);
-            final FeaturePathFeatureSupplier supplier
-                    = new FeaturePathFeatureSupplier(classLoader, options, parser);
+            final FeaturePathFeatureSupplier supplier = new FeaturePathFeatureSupplier(classLoader, options, parser);
 
             final Runtime runtime = Runtime.builder()
                     .withClassLoader(classLoader)
diff --git a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/AmbigiousSteps.java b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/AmbigiousSteps.java
index 0406db2f..baaeee7a 100644
--- a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/AmbigiousSteps.java
+++ b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/AmbigiousSteps.java
@@ -17,10 +17,6 @@
 
 import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class AmbigiousSteps {
 
     @When("^ambigious step (.+)$")
@@ -34,7 +30,7 @@ public void ambigious_2() {
     }
 
     @Then("^something bad should happen")
-    public void somethingBadStep(){
+    public void somethingBadStep() {
         //nothing here
     }
 }
diff --git a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/AttachmentSteps.java b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/AttachmentSteps.java
index 455aaffe..bd1fb2a4 100644
--- a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/AttachmentSteps.java
+++ b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/AttachmentSteps.java
@@ -15,8 +15,8 @@
  */
 package io.qameta.allure.cucumber7jvm.samples;
 
-import io.cucumber.java.Scenario;
 import io.cucumber.java.Before;
+import io.cucumber.java.Scenario;
 import io.cucumber.java.en.Given;
 
 public class AttachmentSteps {
diff --git a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/BackgroundFeatureSteps.java b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/BackgroundFeatureSteps.java
index 1cb2041c..93f55c03 100644
--- a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/BackgroundFeatureSteps.java
+++ b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/BackgroundFeatureSteps.java
@@ -18,10 +18,6 @@
 import io.cucumber.java.en.Given;
 import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class BackgroundFeatureSteps {
 
     @Given("^cat is sad$")
diff --git a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/BrokenFeatureSteps.java b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/BrokenFeatureSteps.java
index e2b7676b..3dbcfa76 100644
--- a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/BrokenFeatureSteps.java
+++ b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/BrokenFeatureSteps.java
@@ -16,10 +16,6 @@
 package io.qameta.allure.cucumber7jvm.samples;
 
 import io.cucumber.java.en.Given;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class BrokenFeatureSteps {
 
     @Given("^everything is broken$")
diff --git a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/DatatableFeatureSteps.java b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/DatatableFeatureSteps.java
index d43bacfc..d01b6ce7 100644
--- a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/DatatableFeatureSteps.java
+++ b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/DatatableFeatureSteps.java
@@ -17,10 +17,6 @@
 
 import io.cucumber.datatable.DataTable;
 import io.cucumber.java.en.Given;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @SuppressWarnings("unused")
 public class DatatableFeatureSteps {
 
diff --git a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/HookSteps.java b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/HookSteps.java
index b85751af..c20d9dbe 100644
--- a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/HookSteps.java
+++ b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/HookSteps.java
@@ -18,29 +18,25 @@
 import io.cucumber.java.After;
 import io.cucumber.java.Before;
 import org.assertj.core.api.Assertions;
-
-/**
- * @author letsrokk (Dmitry Mayer).
- */
 public class HookSteps {
 
     @Before("@WithHooks")
-    public void beforeHook(){
+    public void beforeHook() {
         // nothing
     }
 
     @After("@WithHooks")
-    public void afterHook(){
+    public void afterHook() {
         // nothing
     }
 
     @Before("@BeforeHookWithException")
-    public void beforeHookWithException(){
+    public void beforeHookWithException() {
         Assertions.fail("Exception in Hook step");
     }
 
     @After("@AfterHookWithException")
-    public void afterHookWithException(){
+    public void afterHookWithException() {
         Assertions.fail("Exception in Hook step");
     }
 
diff --git a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/PendingSteps.java b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/PendingSteps.java
index b3c74e1b..bbdc1fce 100644
--- a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/PendingSteps.java
+++ b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/PendingSteps.java
@@ -17,10 +17,6 @@
 
 import io.cucumber.java.PendingException;
 import io.cucumber.java.en.Given;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class PendingSteps {
 
     @Given("^step is yet to be implemented$")
diff --git a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/RuntimeApiSteps.java b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/RuntimeApiSteps.java
index e76d71ac..393f880f 100644
--- a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/RuntimeApiSteps.java
+++ b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/RuntimeApiSteps.java
@@ -16,23 +16,19 @@
 package io.qameta.allure.cucumber7jvm.samples;
 
 import io.cucumber.java.Before;
+import io.cucumber.java.en.And;
 import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;
-import io.cucumber.java.en.And;
 import io.qameta.allure.Allure;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class RuntimeApiSteps {
 
     @Before("@beforeScenario")
-    public void beforeScenario(){
+    public void beforeScenario() {
         // nothing
     }
 
     @Before("@beforeFeature")
-    public void beforeFeature(){
+    public void beforeFeature() {
         // nothing
     }
 
diff --git a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/SimpleFeatureSteps.java b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/SimpleFeatureSteps.java
index 1280d9a5..b82ddb3d 100644
--- a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/SimpleFeatureSteps.java
+++ b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/SimpleFeatureSteps.java
@@ -19,10 +19,6 @@
 import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;
 import org.assertj.core.api.Assertions;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class SimpleFeatureSteps {
 
     private int a;
diff --git a/allure-cucumber7-jvm/src/test/resources/allure.properties b/allure-cucumber7-jvm/src/test/resources/allure.properties
index dbfefee4..20fde5c1 100644
--- a/allure-cucumber7-jvm/src/test/resources/allure.properties
+++ b/allure-cucumber7-jvm/src/test/resources/allure.properties
@@ -1,3 +1,4 @@
 allure.model.indentOutput=true
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-cucumber7-jvm
diff --git a/allure-descriptions-javadoc/src/main/java/io/qameta/allure/description/ClassNames.java b/allure-descriptions-javadoc/src/main/java/io/qameta/allure/description/ClassNames.java
index 09def58c..b3338a2f 100644
--- a/allure-descriptions-javadoc/src/main/java/io/qameta/allure/description/ClassNames.java
+++ b/allure-descriptions-javadoc/src/main/java/io/qameta/allure/description/ClassNames.java
@@ -14,10 +14,6 @@
  *  limitations under the License.
  */
 package io.qameta.allure.description;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 final class ClassNames {
 
     static final String DESCRIPTION_ANNOTATION = "io.qameta.allure.Description";
diff --git a/allure-descriptions-javadoc/src/main/java/io/qameta/allure/description/JavaDocDescriptionRenderer.java b/allure-descriptions-javadoc/src/main/java/io/qameta/allure/description/JavaDocDescriptionRenderer.java
index 6546dbb4..1985af5f 100644
--- a/allure-descriptions-javadoc/src/main/java/io/qameta/allure/description/JavaDocDescriptionRenderer.java
+++ b/allure-descriptions-javadoc/src/main/java/io/qameta/allure/description/JavaDocDescriptionRenderer.java
@@ -47,6 +47,7 @@
  * description path suitable for open source projects where comments may evolve over time and where
  * security is more important than pixel-perfect parity with the standard doclet.</p>
  */
+@SuppressWarnings({"PMD.GodClass", "PMD.TooManyMethods"})
 final class JavaDocDescriptionRenderer {
 
     private static final String PARAGRAPH_BREAK = "\n\n";
@@ -58,6 +59,7 @@ final class JavaDocDescriptionRenderer {
     private static final String CODE_TAG = "code";
     private static final String HTML_TAG_END = ">";
     private static final String CLOSING_TAG_PREFIX = "</";
+    private static final String NEW_LINE = "\n";
 
     /**
      * Converts raw JavaDoc comment text into the description format stored by the annotation
@@ -84,7 +86,7 @@ String render(final String rawDocComment) {
     }
 
     private String extractDescriptionBody(final String rawDocComment) {
-        final String[] lines = normalize(rawDocComment).split("\n", -1);
+        final String[] lines = normalize(rawDocComment).split(NEW_LINE, -1);
         final StringBuilder body = new StringBuilder();
         int inlineTagDepth = 0;
 
@@ -107,7 +109,7 @@ private boolean startsBlockTag(final String line) {
         return trimmed.length() > 1 && trimmed.charAt(0) == '@' && Character.isJavaIdentifierStart(trimmed.charAt(1));
     }
 
-    @SuppressWarnings("checkstyle:CyclomaticComplexity")
+    @SuppressWarnings({"checkstyle:CyclomaticComplexity", "PMD.CognitiveComplexity"})
     private void renderFragment(final String fragment, final StringBuilder rendered) {
         int index = 0;
         while (index < fragment.length()) {
@@ -182,10 +184,13 @@ private int renderInlineTag(final String fragment, final int start, final String
         return end + 1;
     }
 
-    @SuppressWarnings({
-            "checkstyle:CyclomaticComplexity",
-            "checkstyle:NPathComplexity",
-            "checkstyle:ReturnCount"})
+    @SuppressWarnings(
+        {
+                "checkstyle:CyclomaticComplexity",
+                "checkstyle:NPathComplexity",
+                "PMD.CognitiveComplexity",
+                "checkstyle:ReturnCount"}
+    )
     private int renderHtmlTag(final String fragment, final int start, final StringBuilder rendered) {
         if (start + 1 >= fragment.length() || Character.isWhitespace(fragment.charAt(start + 1))) {
             return start;
@@ -317,7 +322,7 @@ private void appendLineBreak(final StringBuilder rendered) {
     }
 
     private String cleanup(final String rendered) {
-        final String[] lines = normalize(rendered).split("\n", -1);
+        final String[] lines = normalize(rendered).split(NEW_LINE, -1);
         final StringBuilder cleaned = new StringBuilder();
         boolean blankLinePending = false;
 
@@ -331,7 +336,7 @@ private String cleanup(final String rendered) {
             }
 
             if (cleaned.length() > 0) {
-                cleaned.append(blankLinePending ? PARAGRAPH_BREAK : "\n");
+                cleaned.append(blankLinePending ? PARAGRAPH_BREAK : NEW_LINE);
             }
             cleaned.append(trimmed);
             blankLinePending = false;
@@ -341,7 +346,7 @@ private String cleanup(final String rendered) {
     }
 
     private String trimBlankLines(final String value) {
-        final String[] lines = normalize(value).split("\n", -1);
+        final String[] lines = normalize(value).split(NEW_LINE, -1);
         int start = 0;
         int end = lines.length;
 
@@ -452,7 +457,7 @@ private String trimTrailingWhitespace(final String line) {
     }
 
     private String normalize(final String value) {
-        return value.replace("\r\n", "\n").replace('\r', '\n');
+        return value.replace("\r\n", NEW_LINE).replace('\r', '\n');
     }
 
     private boolean isBlank(final String value) {
@@ -479,10 +484,12 @@ private int renderEntityReference(final String fragment, final int start, final
         return end + 1;
     }
 
-    @SuppressWarnings({
-            "checkstyle:CyclomaticComplexity",
-            "checkstyle:NPathComplexity",
-            "checkstyle:ReturnCount"})
+    @SuppressWarnings(
+        {
+                "checkstyle:CyclomaticComplexity",
+                "checkstyle:NPathComplexity",
+                "checkstyle:ReturnCount"}
+    )
     private String decodeEntity(final String entity) {
         if (entity.isEmpty()) {
             return null;
diff --git a/allure-descriptions-javadoc/src/main/java/io/qameta/allure/description/JavaDocDescriptionsProcessor.java b/allure-descriptions-javadoc/src/main/java/io/qameta/allure/description/JavaDocDescriptionsProcessor.java
index acc1d555..bd77d395 100644
--- a/allure-descriptions-javadoc/src/main/java/io/qameta/allure/description/JavaDocDescriptionsProcessor.java
+++ b/allure-descriptions-javadoc/src/main/java/io/qameta/allure/description/JavaDocDescriptionsProcessor.java
@@ -31,6 +31,7 @@
 import javax.tools.Diagnostic;
 import javax.tools.FileObject;
 import javax.tools.StandardLocation;
+
 import java.io.IOException;
 import java.io.Writer;
 import java.math.BigInteger;
@@ -44,7 +45,9 @@
 import static io.qameta.allure.description.ClassNames.DESCRIPTION_ANNOTATION;
 
 /**
- * @author Egor Borisov ehborisov@gmail.com
+ * Supports allure-descriptions-javadoc integration with Allure reporting.
+ *
+ * <p>Use this type through the module that owns it when translating framework execution, result metadata, or attachments into Allure report data.</p>
  */
 @SupportedAnnotationTypes(DESCRIPTION_ANNOTATION)
 public class JavaDocDescriptionsProcessor extends AbstractProcessor {
@@ -56,6 +59,9 @@ public class JavaDocDescriptionsProcessor extends AbstractProcessor {
     private Messager messager;
     private JavaDocDescriptionRenderer renderer;
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     @SuppressWarnings("PMD.AvoidSynchronizedAtMethodLevel")
     public synchronized void init(final ProcessingEnvironment env) {
@@ -66,11 +72,17 @@ public synchronized void init(final ProcessingEnvironment env) {
         renderer = new JavaDocDescriptionRenderer();
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public SourceVersion getSupportedSourceVersion() {
         return SourceVersion.latest();
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public boolean process(final Set<? extends TypeElement> annotations, final RoundEnvironment env) {
         final TypeElement typeElement = elementUtils.getTypeElement(DESCRIPTION_ANNOTATION);
@@ -96,14 +108,18 @@ public boolean process(final Set<? extends TypeElement> annotations, final Round
                     method.getEnclosingElement().toString(), name, typeParams
             );
             try {
-                final FileObject file = filer.createResource(StandardLocation.CLASS_OUTPUT, "",
-                        ALLURE_DESCRIPTIONS_FOLDER + hash);
+                final FileObject file = filer.createResource(
+                        StandardLocation.CLASS_OUTPUT, "",
+                        ALLURE_DESCRIPTIONS_FOLDER + hash
+                );
                 try (Writer writer = file.openWriter()) {
                     writer.write(docs);
                 }
             } catch (IOException e) {
-                messager.printMessage(Diagnostic.Kind.WARNING,
-                        "Unable to create resource from docs comment of method " + name + typeParams);
+                messager.printMessage(
+                        Diagnostic.Kind.WARNING,
+                        "Unable to create resource from docs comment of method " + name + typeParams
+                );
             }
         });
 
diff --git a/allure-descriptions-javadoc/src/test/java/io/qameta/allure/description/JavaDocDescriptionRendererTest.java b/allure-descriptions-javadoc/src/test/java/io/qameta/allure/description/JavaDocDescriptionRendererTest.java
index 180d2b03..7c85dfc5 100644
--- a/allure-descriptions-javadoc/src/test/java/io/qameta/allure/description/JavaDocDescriptionRendererTest.java
+++ b/allure-descriptions-javadoc/src/test/java/io/qameta/allure/description/JavaDocDescriptionRendererTest.java
@@ -29,10 +29,10 @@ class JavaDocDescriptionRendererTest {
     void shouldRenderPlainTextAndTrimBlankLines() {
         final String rendered = renderer.render(
                 "\r\n"
-                + "  First line   \r\n"
-                + "\r\n"
-                + "  Second line\t\r\n"
-                + "\r\n"
+                        + "  First line   \r\n"
+                        + "\r\n"
+                        + "  Second line\t\r\n"
+                        + "\r\n"
         );
 
         assertThat(rendered)
@@ -43,7 +43,7 @@ void shouldRenderPlainTextAndTrimBlankLines() {
     void shouldReturnEmptyStringWhenBodyContainsOnlyBlockTags() {
         final String rendered = renderer.render(
                 "@param value description\n"
-                + "@throws Exception description"
+                        + "@throws Exception description"
         );
 
         assertThat(rendered)
@@ -54,9 +54,9 @@ void shouldReturnEmptyStringWhenBodyContainsOnlyBlockTags() {
     void shouldIgnoreBlockTagsAndEverythingAfterThem() {
         final String rendered = renderer.render(
                 "Summary paragraph.\n"
-                + "\n"
-                + "@param value Description of the value.\n"
-                + "Continuation that should also be ignored."
+                        + "\n"
+                        + "@param value Description of the value.\n"
+                        + "Continuation that should also be ignored."
         );
 
         assertThat(rendered)
@@ -95,7 +95,7 @@ void shouldIgnoreStandardBlockTagsAfterMainDescription() {
     void shouldNotTreatAtSignsInsideTextAsBlockTags() {
         final String rendered = renderer.render(
                 "Email support@example.com\n"
-                + "Use @smoke in prose."
+                        + "Use @smoke in prose."
         );
 
         assertThat(rendered)
@@ -106,7 +106,7 @@ void shouldNotTreatAtSignsInsideTextAsBlockTags() {
     void shouldDecodeEscapedAtEntityBeforeBlockTags() {
         final String rendered = renderer.render(
                 "&#064;version stays in prose.\n"
-                + "@version 2.4.0"
+                        + "@version 2.4.0"
         );
 
         assertThat(rendered)
@@ -135,9 +135,9 @@ void shouldDecodeSupportedNamedAndNumericEntities() {
     void shouldRenderSupportedInlineTags() {
         final String rendered = renderer.render(
                 "Use {@code a < b}, {@literal <safe>}, "
-                + "{@link java.lang.String}, "
-                + "{@linkplain java.lang.String#valueOf(Object)}, "
-                + "{@link java.util.List list docs}."
+                        + "{@link java.lang.String}, "
+                        + "{@linkplain java.lang.String#valueOf(Object)}, "
+                        + "{@link java.util.List list docs}."
         );
 
         assertThat(rendered)
@@ -158,9 +158,9 @@ void shouldSupportBalancedBracesInsideInlineTags() {
     void shouldNotTreatAtLinesInsideBalancedInlineTagsAsBlockTags() {
         final String rendered = renderer.render(
                 "Summary {@literal first line\n"
-                + "@notATag\n"
-                + "last line}\n"
-                + "@param ignored"
+                        + "@notATag\n"
+                        + "last line}\n"
+                        + "@param ignored"
         );
 
         assertThat(rendered)
@@ -181,14 +181,14 @@ void shouldRenderNestedInlineTagsInsideLinkLabels() {
     void shouldSafelyDegradeUnsupportedStandardInlineTags() {
         final String rendered = renderer.render(
                 "Fallbacks: {@docRoot}, {@inheritDoc}, {@index release}, "
-                + "{@summary quick summary}, {@systemProperty user.home}, "
-                + "{@value java.lang.Integer#MAX_VALUE}."
+                        + "{@summary quick summary}, {@systemProperty user.home}, "
+                        + "{@value java.lang.Integer#MAX_VALUE}."
         );
 
         assertThat(rendered)
                 .isEqualTo(
                         "Fallbacks: docRoot, inheritDoc, index release, summary quick summary, "
-                        + "systemProperty user.home, value java.lang.Integer#MAX_VALUE."
+                                + "systemProperty user.home, value java.lang.Integer#MAX_VALUE."
                 );
     }
 
@@ -196,9 +196,9 @@ void shouldSafelyDegradeUnsupportedStandardInlineTags() {
     void shouldSafelyDegradeSnippetTags() {
         final String rendered = renderer.render(
                 "Snippet {@snippet :\n"
-                + "int answer = 42;\n"
-                + "@highlight substring=\"answer\"\n"
-                + "}."
+                        + "int answer = 42;\n"
+                        + "@highlight substring=\"answer\"\n"
+                        + "}."
         );
 
         assertThat(rendered)
@@ -301,28 +301,27 @@ void shouldDropUnknownHtmlTagsButKeepTheirTextContentEscaped() {
     void shouldRenderComplexModernJavadocExampleSafely() {
         final String rendered = renderer.render(
                 "Fetches release metadata for the current build.\n"
-                + "\n"
-                + "<p>Use {@link java.net.URI URIs} for endpoint configuration.</p>\n"
-                + "<ul>\n"
-                + "<li>Supports café, Привет, 東京, and λ.</li>\n"
-                + "<li>See the <a href=\"https://docs.oracle.com/\">Javadoc specification</a> "
-                + "and {@linkplain java.lang.String#formatted(Object...) formatted examples}.</li>\n"
-                + "</ul>\n"
-                + "Example: <code>client.fetch(\"v2\")</code>\n"
-                + "&#064;beta remains prose.\n"
-                + "@author Jane Doe\n"
-                + "@version 2.3.0\n"
-                + "@since 2.0"
+                        + "\n"
+                        + "<p>Use {@link java.net.URI URIs} for endpoint configuration.</p>\n"
+                        + "<ul>\n"
+                        + "<li>Supports café, Привет, 東京, and λ.</li>\n"
+                        + "<li>See the <a href=\"https://docs.oracle.com/\">Javadoc specification</a> "
+                        + "and {@linkplain java.lang.String#formatted(Object...) formatted examples}.</li>\n"
+                        + "</ul>\n"
+                        + "Example: <code>client.fetch(\"v2\")</code>\n"
+                        + "&#064;beta remains prose.\n"
+                        + "@version 2.3.0\n"
+                        + "@since 2.0"
         );
 
         assertThat(rendered)
                 .isEqualTo(
                         "Fetches release metadata for the current build.\n\n"
-                        + "Use URIs for endpoint configuration.\n\n"
-                        + "- Supports café, Привет, 東京, and λ.\n"
-                        + "- See the Javadoc specification and formatted examples.\n\n"
-                        + "Example: `client.fetch(\"v2\")`\n"
-                        + "@beta remains prose."
+                                + "Use URIs for endpoint configuration.\n\n"
+                                + "- Supports café, Привет, 東京, and λ.\n"
+                                + "- See the Javadoc specification and formatted examples.\n\n"
+                                + "Example: `client.fetch(\"v2\")`\n"
+                                + "@beta remains prose."
                 );
     }
 }
diff --git a/allure-descriptions-javadoc/src/test/java/io/qameta/allure/description/ProcessDescriptionsTest.java b/allure-descriptions-javadoc/src/test/java/io/qameta/allure/description/ProcessDescriptionsTest.java
index 29f80277..f3af3750 100644
--- a/allure-descriptions-javadoc/src/test/java/io/qameta/allure/description/ProcessDescriptionsTest.java
+++ b/allure-descriptions-javadoc/src/test/java/io/qameta/allure/description/ProcessDescriptionsTest.java
@@ -25,10 +25,6 @@
 
 import static com.google.testing.compile.CompilationSubject.assertThat;
 import static com.google.testing.compile.Compiler.javac;
-
-/**
- * @author Egor Borisov ehborisov@gmail.com
- */
 class ProcessDescriptionsTest {
 
     private static final String ALLURE_DESCRIPTIONS_FOLDER = "META-INF/allureDescriptions/";
@@ -237,10 +233,10 @@ void shouldIgnoreBlockTagsAndRenderSafeMarkdown() {
                 .contentsAsUtf8String()
                 .isEqualTo(
                         "This is my test description with `sample` and &lt;safe&gt;.\n\n"
-                        + "Use String for values.\n\n"
-                        + "- first item\n"
-                        + "- second item\n\n"
-                        + "alert(\"xss\")"
+                                + "Use String for values.\n\n"
+                                + "- first item\n"
+                                + "- second item\n\n"
+                                + "alert(\"xss\")"
                 );
     }
 
@@ -267,7 +263,6 @@ void shouldCaptureComplexModernJavadocDescriptionSafely() {
                 "* Example: <code>client.fetch(\"v2\")</code>",
                 "* &#064;beta remains prose.",
                 "*",
-                "* @author Jane Doe",
                 "* @version 2.3.0",
                 "* @since 2.0",
                 "* @see <a href=\"https://download.java.net/java/early_access/jdk27/docs/specs/javadoc/doc-comment-spec.html\">Javadoc spec</a>",
@@ -290,12 +285,12 @@ void shouldCaptureComplexModernJavadocDescriptionSafely() {
                 .contentsAsUtf8String()
                 .isEqualTo(
                         "Fetches release metadata for the current build.\n\n"
-                        + "Use URIs for endpoint configuration.\n\n"
-                        + "- Supports café, Привет, 東京, and λ.\n"
-                        + "- See the Javadoc specification\n"
-                        + "and formatted examples.\n\n"
-                        + "Example: `client.fetch(\"v2\")`\n"
-                        + "@beta remains prose."
+                                + "Use URIs for endpoint configuration.\n\n"
+                                + "- Supports café, Привет, 東京, and λ.\n"
+                                + "- See the Javadoc specification\n"
+                                + "and formatted examples.\n\n"
+                                + "Example: `client.fetch(\"v2\")`\n"
+                                + "@beta remains prose."
                 );
     }
 }
diff --git a/allure-descriptions-javadoc/src/test/resources/allure.properties b/allure-descriptions-javadoc/src/test/resources/allure.properties
index 9c0b0a2d..384d9cd5 100644
--- a/allure-descriptions-javadoc/src/test/resources/allure.properties
+++ b/allure-descriptions-javadoc/src/test/resources/allure.properties
@@ -1,2 +1,3 @@
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-descriptions-javadoc
diff --git a/allure-grpc/src/main/java/io/qameta/allure/grpc/AllureGrpc.java b/allure-grpc/src/main/java/io/qameta/allure/grpc/AllureGrpc.java
index ce71871a..e98953fc 100644
--- a/allure-grpc/src/main/java/io/qameta/allure/grpc/AllureGrpc.java
+++ b/allure-grpc/src/main/java/io/qameta/allure/grpc/AllureGrpc.java
@@ -34,6 +34,9 @@
 import io.qameta.allure.model.Attachment;
 import io.qameta.allure.model.Status;
 import io.qameta.allure.model.StepResult;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import java.io.ByteArrayInputStream;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
@@ -42,19 +45,20 @@
 import java.util.Locale;
 import java.util.Map;
 import java.util.UUID;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 /**
- * Allure interceptor logger for gRPC.
+ * Captures gRPC client calls as Allure attachments.
  *
- * @author dtuchs (Dmitry Tuchs).
+ * <p>Attach this interceptor to a gRPC channel or stub to record request messages, response messages, metadata, and call status. The default constructor uses built-in templates; the explicit constructor accepts custom renderers and processors.</p>
  */
-@SuppressWarnings({
-    "checkstyle:ClassFanOutComplexity",
-    "checkstyle:AnonInnerLength",
-    "checkstyle:JavaNCSS"
-})
+@SuppressWarnings(
+    {
+            "checkstyle:ClassFanOutComplexity",
+            "checkstyle:AnonInnerLength",
+            "checkstyle:JavaNCSS",
+            "PMD.GodClass"
+    }
+)
 public class AllureGrpc implements ClientInterceptor {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(AllureGrpc.class);
@@ -68,18 +72,31 @@ public class AllureGrpc implements ClientInterceptor {
     private final String requestTemplatePath;
     private final String responseTemplatePath;
 
+    /**
+     * Creates an Allure grpc with default configuration.
+     */
     public AllureGrpc() {
-        this(Allure.getLifecycle(), true, false,
-            "grpc-request.ftl", "grpc-response.ftl");
+        this(
+                Allure.getLifecycle(), true, false,
+                "grpc-request.ftl", "grpc-response.ftl"
+        );
     }
 
+    /**
+     * Creates an Allure grpc with the supplied values.
+     *
+     * @param lifecycle the Allure lifecycle to use
+     * @param markStepFailedOnNonZeroCode the mark step failed on non zero code
+     * @param interceptResponseMetadata the intercept response metadata
+     * @param requestTemplatePath the request template path
+     * @param responseTemplatePath the response template path
+     */
     public AllureGrpc(
-        final AllureLifecycle lifecycle,
-        final boolean markStepFailedOnNonZeroCode,
-        final boolean interceptResponseMetadata,
-        final String requestTemplatePath,
-        final String responseTemplatePath
-    ) {
+                      final AllureLifecycle lifecycle,
+                      final boolean markStepFailedOnNonZeroCode,
+                      final boolean interceptResponseMetadata,
+                      final String requestTemplatePath,
+                      final String responseTemplatePath) {
         this.lifecycle = lifecycle;
         this.markStepFailedOnNonZeroCode = markStepFailedOnNonZeroCode;
         this.interceptResponseMetadata = interceptResponseMetadata;
@@ -87,12 +104,14 @@ public AllureGrpc(
         this.responseTemplatePath = responseTemplatePath;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public <T, R> ClientCall<T, R> interceptCall(
-        final MethodDescriptor<T, R> methodDescriptor,
-        final CallOptions callOptions,
-        final Channel nextChannel
-    ) {
+                                                 final MethodDescriptor<T, R> methodDescriptor,
+                                                 final CallOptions callOptions,
+                                                 final Channel nextChannel) {
         final AllureLifecycle current = lifecycle;
         final String parent = current.getCurrentTestCaseOrStep().orElse(null);
         final String stepUuid = UUID.randomUUID().toString();
@@ -109,12 +128,12 @@ public <T, R> ClientCall<T, R> interceptCall(
         }
 
         final StepContext<T, R> stepContext = new StepContext<>(
-            stepUuid, methodDescriptor, current, clientMessages,
-            serverMessages, initialHeaders, trailers
+                stepUuid, methodDescriptor, current, clientMessages,
+                serverMessages, initialHeaders, trailers
         );
 
         return new ForwardingClientCall.SimpleForwardingClientCall<T, R>(
-            nextChannel.newCall(methodDescriptor, callOptions)
+                nextChannel.newCall(methodDescriptor, callOptions)
         ) {
             @Override
             public void start(final Listener<R> responseListener, final Metadata requestHeaders) {
@@ -154,59 +173,59 @@ public void sendMessage(final T message) {
     }
 
     private void addRawJsonAttachment(
-        final String stepUuid,
-        final String attachmentName,
-        final String jsonBody,
-        final AllureLifecycle lifecycle
-    ) {
+                                      final String stepUuid,
+                                      final String attachmentName,
+                                      final String jsonBody,
+                                      final AllureLifecycle lifecycle) {
         if (jsonBody == null || jsonBody.isEmpty()) {
             return;
         }
         final String source = UUID.randomUUID() + ".json";
-        lifecycle.updateStep(stepUuid, step -> step.getAttachments().add(
-            new Attachment()
-                .setName(attachmentName)
-                .setSource(source)
-                .setType("application/json")
-        ));
+        lifecycle.updateStep(
+                stepUuid, step -> step.getAttachments().add(
+                        new Attachment()
+                                .setName(attachmentName)
+                                .setSource(source)
+                                .setType("application/json")
+                )
+        );
         lifecycle.writeAttachment(
-            source,
-            new ByteArrayInputStream(jsonBody.getBytes(StandardCharsets.UTF_8))
+                source,
+                new ByteArrayInputStream(jsonBody.getBytes(StandardCharsets.UTF_8))
         );
     }
 
     private void handleClose(
-        final io.grpc.Status status,
-        final Metadata responseTrailers,
-        final StepContext<?, ?> stepContext
-    ) {
+                             final io.grpc.Status status,
+                             final Metadata responseTrailers,
+                             final StepContext<?, ?> stepContext) {
         try {
             if (interceptResponseMetadata && responseTrailers != null) {
                 copyAsciiResponseMetadata(responseTrailers, stepContext.getTrailers());
             }
             attachRequestIfPresent(
-                stepContext.getStepUuid(),
-                stepContext.getMethodDescriptor(),
-                stepContext.getClientMessages(),
-                stepContext.getLifecycle()
+                    stepContext.getStepUuid(),
+                    stepContext.getMethodDescriptor(),
+                    stepContext.getClientMessages(),
+                    stepContext.getLifecycle()
             );
             attachResponse(
-                stepContext.getStepUuid(),
-                stepContext.getServerMessages(),
-                status,
-                stepContext.getInitialHeaders(),
-                stepContext.getTrailers(),
-                stepContext.getLifecycle()
+                    stepContext.getStepUuid(),
+                    stepContext.getServerMessages(),
+                    status,
+                    stepContext.getInitialHeaders(),
+                    stepContext.getTrailers(),
+                    stepContext.getLifecycle()
             );
             stepContext.getLifecycle().updateStep(
-                stepContext.getStepUuid(),
-                step -> step.setStatus(convertStatus(status))
+                    stepContext.getStepUuid(),
+                    step -> step.setStatus(convertStatus(status))
             );
         } catch (Throwable throwable) {
             LOGGER.error("Failed to finalize Allure step for gRPC call", throwable);
             stepContext.getLifecycle().updateStep(
-                stepContext.getStepUuid(),
-                step -> step.setStatus(Status.BROKEN)
+                    stepContext.getStepUuid(),
+                    step -> step.setStatus(Status.BROKEN)
             );
         } finally {
             stopStepSafely(stepContext.getLifecycle(), stepContext.getStepUuid());
@@ -244,45 +263,43 @@ private <R> void handleServerMessage(final R message, final List<String> destina
     }
 
     private <T, R> void attachRequestIfPresent(
-        final String stepUuid,
-        final MethodDescriptor<T, R> methodDescriptor,
-        final List<String> clientMessages,
-        final AllureLifecycle lifecycle
-    ) {
+                                               final String stepUuid,
+                                               final MethodDescriptor<T, R> methodDescriptor,
+                                               final List<String> clientMessages,
+                                               final AllureLifecycle lifecycle) {
         final String body = toJsonBody(clientMessages);
         if (body == null) {
             return;
         }
         final String name = clientMessages.size() > 1
-            ? "gRPC request (collection of elements from Client stream)"
-            : "gRPC request";
+                ? "gRPC request (collection of elements from Client stream)"
+                : "gRPC request";
         final GrpcRequestAttachment requestAttachment = GrpcRequestAttachment.Builder
-            .create(name, methodDescriptor.getFullMethodName())
-            .setBody(body)
-            .build();
+                .create(name, methodDescriptor.getFullMethodName())
+                .setBody(body)
+                .build();
 
         addRenderedAttachmentToStep(
-            stepUuid,
-            requestAttachment.getName(),
-            requestAttachment,
-            requestTemplatePath,
-            lifecycle
+                stepUuid,
+                requestAttachment.getName(),
+                requestAttachment,
+                requestTemplatePath,
+                lifecycle
         );
         addRawJsonAttachment(stepUuid, name + JSON_SUFFIX, body, lifecycle);
     }
 
     private void attachResponse(
-        final String stepUuid,
-        final List<String> serverMessages,
-        final io.grpc.Status status,
-        final Map<String, String> initialHeaders,
-        final Map<String, String> trailers,
-        final AllureLifecycle lifecycle
-    ) {
+                                final String stepUuid,
+                                final List<String> serverMessages,
+                                final io.grpc.Status status,
+                                final Map<String, String> initialHeaders,
+                                final Map<String, String> trailers,
+                                final AllureLifecycle lifecycle) {
         final String body = toJsonBody(serverMessages);
         final String name = serverMessages.size() > 1
-            ? "gRPC response (collection of elements from Server stream)"
-            : "gRPC response";
+                ? "gRPC response (collection of elements from Server stream)"
+                : "gRPC response";
 
         final Map<String, String> metadata = new LinkedHashMap<>();
         if (interceptResponseMetadata) {
@@ -291,8 +308,8 @@ private void attachResponse(
         }
 
         final GrpcResponseAttachment.Builder builder = GrpcResponseAttachment.Builder
-            .create(name)
-            .setStatus(status.toString());
+                .create(name)
+                .setStatus(status.toString());
 
         if (body != null) {
             builder.setBody(body);
@@ -303,11 +320,11 @@ private void attachResponse(
 
         final GrpcResponseAttachment responseAttachment = builder.build();
         addRenderedAttachmentToStep(
-            stepUuid,
-            responseAttachment.getName(),
-            responseAttachment,
-            responseTemplatePath,
-            lifecycle
+                stepUuid,
+                responseAttachment.getName(),
+                responseAttachment,
+                responseTemplatePath,
+                lifecycle
         );
         if (body != null) {
             addRawJsonAttachment(stepUuid, name + JSON_SUFFIX, body, lifecycle);
@@ -330,14 +347,13 @@ private Status convertStatus(final io.grpc.Status grpcStatus) {
     }
 
     private static String buildStepName(
-        final Channel channel,
-        final MethodDescriptor<?, ?> methodDescriptor
-    ) {
+                                        final Channel channel,
+                                        final MethodDescriptor<?, ?> methodDescriptor) {
         final String authority = channel != null ? channel.authority() : null;
         final String safeAuthority = authority != null ? authority : UNKNOWN;
         final String type = toSnakeCase(methodDescriptor.getType());
         return "Send " + type + " gRPC request to "
-            + safeAuthority + "/" + methodDescriptor.getFullMethodName();
+                + safeAuthority + "/" + methodDescriptor.getFullMethodName();
     }
 
     private static String toSnakeCase(final MethodDescriptor.MethodType methodType) {
@@ -348,21 +364,19 @@ private static String toSnakeCase(final MethodDescriptor.MethodType methodType)
     }
 
     private void addRenderedAttachmentToStep(
-        final String stepUuid,
-        final String attachmentName,
-        final AttachmentData data,
-        final String templatePath,
-        final AllureLifecycle lifecycle
-    ) {
-        final AttachmentRenderer<AttachmentData> renderer =
-            new FreemarkerAttachmentRenderer(templatePath);
+                                             final String stepUuid,
+                                             final String attachmentName,
+                                             final AttachmentData data,
+                                             final String templatePath,
+                                             final AllureLifecycle lifecycle) {
+        final AttachmentRenderer<AttachmentData> renderer = new FreemarkerAttachmentRenderer(templatePath);
         final io.qameta.allure.attachment.AttachmentContent content;
         try {
             content = renderer.render(data);
         } catch (Throwable throwable) {
             LOGGER.warn(
-                "Could not render attachment '{}' using template '{}'",
-                attachmentName, templatePath, throwable
+                    "Could not render attachment '{}' using template '{}'",
+                    attachmentName, templatePath, throwable
             );
             return;
         }
@@ -376,21 +390,21 @@ private void addRenderedAttachmentToStep(
         }
         final String source = UUID.randomUUID() + fileExtension;
         lifecycle.updateStep(
-            stepUuid,
-            step -> step.getAttachments().add(
-                new Attachment()
-                    .setName(attachmentName)
-                    .setSource(source)
-                    .setType(
-                        content.getContentType() != null
-                            ? content.getContentType()
-                            : "text/html"
-                    )
-            )
+                stepUuid,
+                step -> step.getAttachments().add(
+                        new Attachment()
+                                .setName(attachmentName)
+                                .setSource(source)
+                                .setType(
+                                        content.getContentType() != null
+                                                ? content.getContentType()
+                                                : "text/html"
+                                )
+                )
         );
         lifecycle.writeAttachment(
-            source,
-            new ByteArrayInputStream(content.getContent().getBytes(StandardCharsets.UTF_8))
+                source,
+                new ByteArrayInputStream(content.getContent().getBytes(StandardCharsets.UTF_8))
         );
     }
 
@@ -406,9 +420,8 @@ private static String toJsonBody(final List<String> items) {
     }
 
     private static void copyAsciiResponseMetadata(
-        final Metadata source,
-        final Map<String, String> target
-    ) {
+                                                  final Metadata source,
+                                                  final Map<String, String> target) {
         for (String key : source.keys()) {
             if (key == null) {
                 continue;
@@ -416,8 +429,7 @@ private static void copyAsciiResponseMetadata(
             if (key.endsWith(Metadata.BINARY_HEADER_SUFFIX)) {
                 continue;
             }
-            final Metadata.Key<String> keyAscii =
-                Metadata.Key.of(key, Metadata.ASCII_STRING_MARSHALLER);
+            final Metadata.Key<String> keyAscii = Metadata.Key.of(key, Metadata.ASCII_STRING_MARSHALLER);
             final String value = source.get(keyAscii);
             if (value != null) {
                 target.put(key, value);
@@ -435,14 +447,13 @@ private static final class StepContext<T, R> {
         private final Map<String, String> trailers;
 
         StepContext(
-            final String stepUuid,
-            final MethodDescriptor<T, R> methodDescriptor,
-            final AllureLifecycle lifecycle,
-            final List<String> clientMessages,
-            final List<String> serverMessages,
-            final Map<String, String> initialHeaders,
-            final Map<String, String> trailers
-        ) {
+                    final String stepUuid,
+                    final MethodDescriptor<T, R> methodDescriptor,
+                    final AllureLifecycle lifecycle,
+                    final List<String> clientMessages,
+                    final List<String> serverMessages,
+                    final Map<String, String> initialHeaders,
+                    final Map<String, String> trailers) {
             this.stepUuid = stepUuid;
             this.methodDescriptor = methodDescriptor;
             this.lifecycle = lifecycle;
diff --git a/allure-grpc/src/main/java/io/qameta/allure/grpc/GrpcRequestAttachment.java b/allure-grpc/src/main/java/io/qameta/allure/grpc/GrpcRequestAttachment.java
index 1f227672..37966d02 100644
--- a/allure-grpc/src/main/java/io/qameta/allure/grpc/GrpcRequestAttachment.java
+++ b/allure-grpc/src/main/java/io/qameta/allure/grpc/GrpcRequestAttachment.java
@@ -19,26 +19,51 @@
 
 import java.util.Objects;
 
+/**
+ * Describes an HTTP or RPC request attachment rendered in an Allure report.
+ *
+ * <p>Use this model to carry request metadata and body content from client interceptors to attachment renderers and processors.</p>
+ */
 public class GrpcRequestAttachment implements AttachmentData {
 
     private final String name;
     private final String url;
     private final String body;
 
+    /**
+     * Creates a gRPC request attachment with the supplied values.
+     *
+     * @param name the display name or logical name to use
+     * @param url the request URL or service method name
+     * @param body the attachment body
+     */
     public GrpcRequestAttachment(final String name, final String url, final String body) {
         this.name = name;
         this.url = url;
         this.body = body;
     }
 
+    /**
+     * Returns the url.
+     *
+     * @return the url
+     */
     public String getUrl() {
         return url;
     }
 
+    /**
+     * Returns the body.
+     *
+     * @return the body
+     */
     public String getBody() {
         return body;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public String getName() {
         return name;
diff --git a/allure-grpc/src/main/java/io/qameta/allure/grpc/GrpcResponseAttachment.java b/allure-grpc/src/main/java/io/qameta/allure/grpc/GrpcResponseAttachment.java
index 414aa725..04f12518 100644
--- a/allure-grpc/src/main/java/io/qameta/allure/grpc/GrpcResponseAttachment.java
+++ b/allure-grpc/src/main/java/io/qameta/allure/grpc/GrpcResponseAttachment.java
@@ -21,6 +21,11 @@
 import java.util.Map;
 import java.util.Objects;
 
+/**
+ * Describes an HTTP or RPC response attachment rendered in an Allure report.
+ *
+ * <p>Use this model to carry response metadata and body content from client interceptors to attachment renderers and processors.</p>
+ */
 public class GrpcResponseAttachment implements AttachmentData {
 
     private final String name;
@@ -28,6 +33,14 @@ public class GrpcResponseAttachment implements AttachmentData {
     private final String status;
     private final Map<String, String> metadata;
 
+    /**
+     * Creates a gRPC response attachment with the supplied values.
+     *
+     * @param name the display name or logical name to use
+     * @param body the attachment body
+     * @param status the response status
+     * @param metadata the metadata values to include
+     */
     public GrpcResponseAttachment(final String name,
                                   final String body,
                                   final String status,
@@ -38,18 +51,36 @@ public GrpcResponseAttachment(final String name,
         this.metadata = metadata;
     }
 
+    /**
+     * Returns the body.
+     *
+     * @return the body
+     */
     public String getBody() {
         return body;
     }
 
+    /**
+     * Returns the metadata.
+     *
+     * @return the metadata
+     */
     public Map<String, String> getMetadata() {
         return metadata;
     }
 
+    /**
+     * Returns the status.
+     *
+     * @return the status
+     */
     public String getStatus() {
         return status;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public String getName() {
         return name;
diff --git a/allure-grpc/src/test/java/io/qameta/allure/grpc/AllureGrpcTest.java b/allure-grpc/src/test/java/io/qameta/allure/grpc/AllureGrpcTest.java
index a98e09e7..ec5d55ca 100644
--- a/allure-grpc/src/test/java/io/qameta/allure/grpc/AllureGrpcTest.java
+++ b/allure-grpc/src/test/java/io/qameta/allure/grpc/AllureGrpcTest.java
@@ -61,37 +61,47 @@ class AllureGrpcTest {
     @BeforeEach
     void configureMockServer() {
         managedChannel = ManagedChannelBuilder
-            .forAddress("localhost", GrpcMock.getGlobalPort())
-            .usePlaintext()
-            .directExecutor()
-            .build();
-
-        GrpcMock.stubFor(unaryMethod(TestServiceGrpc.getCalculateMethod())
-            .willReturn(Response.newBuilder().setMessage(RESPONSE_MESSAGE).build()));
-
-        GrpcMock.stubFor(serverStreamingMethod(TestServiceGrpc.getCalculateServerStreamMethod())
-            .willReturn(asList(
-                Response.newBuilder().setMessage(RESPONSE_MESSAGE).build(),
-                Response.newBuilder().setMessage(RESPONSE_MESSAGE).build()
-            )));
-
-        GrpcMock.stubFor(clientStreamingMethod(TestServiceGrpc.getCalculateClientStreamMethod())
-            .willReturn(Response.newBuilder().setMessage(RESPONSE_MESSAGE).build()));
-
-        GrpcMock.stubFor(bidiStreamingMethod(TestServiceGrpc.getCalculateBidiStreamMethod())
-            .willProxyTo(responseObserver -> new StreamObserver<Request>() {
-                @Override
-                public void onNext(Request request) {
-                    responseObserver.onNext(Response.newBuilder().setMessage(RESPONSE_MESSAGE).build());
-                }
-                @Override
-                public void onError(Throwable throwable) {
-                }
-                @Override
-                public void onCompleted() {
-                    responseObserver.onCompleted();
-                }
-            }));
+                .forAddress("localhost", GrpcMock.getGlobalPort())
+                .usePlaintext()
+                .directExecutor()
+                .build();
+
+        GrpcMock.stubFor(
+                unaryMethod(TestServiceGrpc.getCalculateMethod())
+                        .willReturn(Response.newBuilder().setMessage(RESPONSE_MESSAGE).build())
+        );
+
+        GrpcMock.stubFor(
+                serverStreamingMethod(TestServiceGrpc.getCalculateServerStreamMethod())
+                        .willReturn(
+                                asList(
+                                        Response.newBuilder().setMessage(RESPONSE_MESSAGE).build(),
+                                        Response.newBuilder().setMessage(RESPONSE_MESSAGE).build()
+                                )
+                        )
+        );
+
+        GrpcMock.stubFor(
+                clientStreamingMethod(TestServiceGrpc.getCalculateClientStreamMethod())
+                        .willReturn(Response.newBuilder().setMessage(RESPONSE_MESSAGE).build())
+        );
+
+        GrpcMock.stubFor(
+                bidiStreamingMethod(TestServiceGrpc.getCalculateBidiStreamMethod())
+                        .willProxyTo(responseObserver -> new StreamObserver<Request>() {
+                            @Override
+                            public void onNext(Request request) {
+                                responseObserver.onNext(Response.newBuilder().setMessage(RESPONSE_MESSAGE).build());
+                            }
+                            @Override
+                            public void onError(Throwable throwable) {
+                            }
+                            @Override
+                            public void onCompleted() {
+                                responseObserver.onCompleted();
+                            }
+                        })
+        );
     }
 
     @AfterEach
@@ -102,8 +112,8 @@ void shutdownChannel() {
     @Test
     void shouldCreateRequestAttachment() {
         Request request = Request.newBuilder()
-            .setTopic("1")
-            .build();
+                .setTopic("1")
+                .build();
 
         Status errorStatus = Status.NOT_FOUND;
         GrpcMock.stubFor(unaryMethod(TestServiceGrpc.getCalculateMethod()).willReturn(errorStatus));
@@ -111,40 +121,40 @@ void shouldCreateRequestAttachment() {
         AllureResults allureResults = executeUnaryExpectingException(request);
 
         assertThat(allureResults.getTestResults().get(0).getSteps().get(0).getStatus())
-            .isEqualTo(io.qameta.allure.model.Status.FAILED);
+                .isEqualTo(io.qameta.allure.model.Status.FAILED);
 
         assertThat(allureResults.getTestResults().get(0).getSteps())
-            .flatExtracting(StepResult::getAttachments)
-            .extracting(Attachment::getName)
-            .contains("gRPC request", "gRPC response");
+                .flatExtracting(StepResult::getAttachments)
+                .extracting(Attachment::getName)
+                .contains("gRPC request", "gRPC response");
     }
 
     @Test
     void shouldCreateResponseAttachment() {
         Request request = Request.newBuilder()
-            .setTopic("1")
-            .build();
+                .setTopic("1")
+                .build();
 
         AllureResults allureResults = executeUnary(request);
 
         assertThat(allureResults.getTestResults().get(0).getSteps())
-            .flatExtracting(StepResult::getAttachments)
-            .extracting(Attachment::getName)
-            .contains("gRPC response");
+                .flatExtracting(StepResult::getAttachments)
+                .extracting(Attachment::getName)
+                .contains("gRPC response");
     }
 
     @Test
     void shouldCreateResponseAttachmentForServerStreamingResponse() {
         Request request = Request.newBuilder()
-            .setTopic("1")
-            .build();
+                .setTopic("1")
+                .build();
 
         AllureResults allureResults = executeServerStreaming(request);
 
         assertThat(allureResults.getTestResults().get(0).getSteps())
-            .flatExtracting(StepResult::getAttachments)
-            .extracting(Attachment::getName)
-            .contains("gRPC response (collection of elements from Server stream)");
+                .flatExtracting(StepResult::getAttachments)
+                .extracting(Attachment::getName)
+                .contains("gRPC response (collection of elements from Server stream)");
     }
 
     @Test
@@ -153,18 +163,18 @@ void shouldCreateResponseAttachmentOnStatusException() {
         GrpcMock.stubFor(unaryMethod(TestServiceGrpc.getCalculateMethod()).willReturn(notFoundStatus));
 
         Request request = Request.newBuilder()
-            .setTopic("2")
-            .build();
+                .setTopic("2")
+                .build();
 
         AllureResults allureResults = executeUnaryExpectingException(request);
 
         assertThat(allureResults.getTestResults().get(0).getSteps().get(0).getStatus())
-            .isEqualTo(io.qameta.allure.model.Status.FAILED);
+                .isEqualTo(io.qameta.allure.model.Status.FAILED);
 
         assertThat(allureResults.getTestResults().get(0).getSteps())
-            .flatExtracting(StepResult::getAttachments)
-            .extracting(Attachment::getName)
-            .contains("gRPC response");
+                .flatExtracting(StepResult::getAttachments)
+                .extracting(Attachment::getName)
+                .contains("gRPC response");
     }
 
     @Test
@@ -173,8 +183,7 @@ void shouldCreateAttachmentsForClientStreamingWithAsynchronousStub() {
         Request secondClientRequest = Request.newBuilder().setTopic("B").build();
 
         runWithinTestContext(() -> {
-            TestServiceGrpc.TestServiceStub asynchronousStub =
-                TestServiceGrpc.newStub(managedChannel).withInterceptors(new AllureGrpc());
+            TestServiceGrpc.TestServiceStub asynchronousStub = TestServiceGrpc.newStub(managedChannel).withInterceptors(new AllureGrpc());
 
             final List<Response> receivedResponses = new ArrayList<Response>();
 
@@ -209,16 +218,22 @@ void shouldCreateAttachmentsForBidirectionalStreamingWithAsynchronousStub() {
         Request secondBidirectionalRequest = Request.newBuilder().setTopic("D").build();
 
         runWithinTestContext(() -> {
-            TestServiceGrpc.TestServiceStub asynchronousStub =
-                TestServiceGrpc.newStub(managedChannel).withInterceptors(new AllureGrpc());
+            TestServiceGrpc.TestServiceStub asynchronousStub = TestServiceGrpc.newStub(managedChannel).withInterceptors(new AllureGrpc());
 
             List<Response> receivedResponses = new ArrayList<>();
 
             Allure.step("async-root-bidi-stream", () -> {
                 StreamObserver<Response> responseObserver = new StreamObserver<Response>() {
-                    @Override public void onNext(Response value) { receivedResponses.add(value); }
-                    @Override public void onError(Throwable throwable) { }
-                    @Override public void onCompleted() { }
+                    @Override
+                    public void onNext(Response value) {
+                        receivedResponses.add(value);
+                    }
+                    @Override
+                    public void onError(Throwable throwable) {
+                    }
+                    @Override
+                    public void onCompleted() {
+                    }
                 };
 
                 StreamObserver<Request> requestObserver = asynchronousStub.calculateBidiStream(responseObserver);
@@ -235,14 +250,15 @@ void shouldCreateAttachmentsForBidirectionalStreamingWithAsynchronousStub() {
 
     @Test
     void unaryRequestBodyIsCapturedAsJsonObject() throws Exception {
-        GrpcMock.stubFor(unaryMethod(TestServiceGrpc.getCalculateMethod())
-            .willReturn(Response.newBuilder().setMessage("ok").build()));
+        GrpcMock.stubFor(
+                unaryMethod(TestServiceGrpc.getCalculateMethod())
+                        .willReturn(Response.newBuilder().setMessage("ok").build())
+        );
 
         Request request = Request.newBuilder().setTopic("topic-1").build();
 
         AllureResults allureResults = runWithinTestContext(() -> {
-            TestServiceGrpc.TestServiceBlockingStub stub =
-                TestServiceGrpc.newBlockingStub(managedChannel).withInterceptors(new AllureGrpc());
+            TestServiceGrpc.TestServiceBlockingStub stub = TestServiceGrpc.newBlockingStub(managedChannel).withInterceptors(new AllureGrpc());
             Response response = stub.calculate(request);
             assertThat(response.getMessage()).isEqualTo("ok");
         });
@@ -256,14 +272,15 @@ void unaryRequestBodyIsCapturedAsJsonObject() throws Exception {
 
     @Test
     void unaryResponseBodyIsCapturedAsJsonObject() throws Exception {
-        GrpcMock.stubFor(unaryMethod(TestServiceGrpc.getCalculateMethod())
-            .willReturn(Response.newBuilder().setMessage("hello-world").build()));
+        GrpcMock.stubFor(
+                unaryMethod(TestServiceGrpc.getCalculateMethod())
+                        .willReturn(Response.newBuilder().setMessage("hello-world").build())
+        );
 
         Request request = Request.newBuilder().setTopic("x").build();
 
         AllureResults allureResults = runWithinTestContext(() -> {
-            TestServiceGrpc.TestServiceBlockingStub stub =
-                TestServiceGrpc.newBlockingStub(managedChannel).withInterceptors(new AllureGrpc());
+            TestServiceGrpc.TestServiceBlockingStub stub = TestServiceGrpc.newBlockingStub(managedChannel).withInterceptors(new AllureGrpc());
             Response response = stub.calculate(request);
             assertThat(response.getMessage()).isEqualTo("hello-world");
         });
@@ -277,17 +294,20 @@ void unaryResponseBodyIsCapturedAsJsonObject() throws Exception {
 
     @Test
     void serverStreamingResponseBodyIsJsonArrayInOrder() throws Exception {
-        GrpcMock.stubFor(serverStreamingMethod(TestServiceGrpc.getCalculateServerStreamMethod())
-            .willReturn(asList(
-                Response.newBuilder().setMessage("first").build(),
-                Response.newBuilder().setMessage("second").build()
-            )));
+        GrpcMock.stubFor(
+                serverStreamingMethod(TestServiceGrpc.getCalculateServerStreamMethod())
+                        .willReturn(
+                                asList(
+                                        Response.newBuilder().setMessage("first").build(),
+                                        Response.newBuilder().setMessage("second").build()
+                                )
+                        )
+        );
 
         Request request = Request.newBuilder().setTopic("stream-topic").build();
 
         AllureResults allureResults = runWithinTestContext(() -> {
-            TestServiceGrpc.TestServiceBlockingStub stub =
-                TestServiceGrpc.newBlockingStub(managedChannel).withInterceptors(new AllureGrpc());
+            TestServiceGrpc.TestServiceBlockingStub stub = TestServiceGrpc.newBlockingStub(managedChannel).withInterceptors(new AllureGrpc());
             Iterator<Response> responseIterator = stub.calculateServerStream(request);
             assertThat(responseIterator.hasNext()).isTrue();
             assertThat(responseIterator.next().getMessage()).isEqualTo("first");
@@ -297,7 +317,7 @@ void serverStreamingResponseBodyIsJsonArrayInOrder() throws Exception {
         });
 
         String jsonPayload = readJsonAttachmentByName(
-            allureResults, "gRPC response (collection of elements from Server stream) (json)"
+                allureResults, "gRPC response (collection of elements from Server stream) (json)"
         );
         JsonNode actualJsonArray = JSON.readTree(jsonPayload);
 
@@ -310,10 +330,10 @@ private static String readJsonAttachmentByName(AllureResults allureResults, Stri
         TestResult test = allureResults.getTestResults().get(0);
 
         Attachment matchedAttachment = flattenSteps(test.getSteps()).stream()
-            .flatMap(step -> step.getAttachments().stream())
-            .filter(attachment -> jsonAttachmentName.equals(attachment.getName()))
-            .findFirst()
-            .orElseThrow(() -> new IllegalStateException("Attachment not found: " + jsonAttachmentName));
+                .flatMap(step -> step.getAttachments().stream())
+                .filter(attachment -> jsonAttachmentName.equals(attachment.getName()))
+                .findFirst()
+                .orElseThrow(() -> new IllegalStateException("Attachment not found: " + jsonAttachmentName));
 
         String attachmentSourceKey = matchedAttachment.getSource();
         Map<String, byte[]> attachmentsContent = allureResults.getAttachments();
@@ -327,8 +347,7 @@ private static String readJsonAttachmentByName(AllureResults allureResults, Stri
     protected final AllureResults executeUnary(Request request) {
         return runWithinTestContext(() -> {
             try {
-                TestServiceGrpc.TestServiceBlockingStub stub =
-                    TestServiceGrpc.newBlockingStub(managedChannel).withInterceptors(new AllureGrpc());
+                TestServiceGrpc.TestServiceBlockingStub stub = TestServiceGrpc.newBlockingStub(managedChannel).withInterceptors(new AllureGrpc());
                 Response response = stub.calculate(request);
                 assertThat(response.getMessage()).isEqualTo(RESPONSE_MESSAGE);
             } catch (Exception exception) {
@@ -340,8 +359,7 @@ protected final AllureResults executeUnary(Request request) {
     protected final AllureResults executeServerStreaming(Request request) {
         return runWithinTestContext(() -> {
             try {
-                TestServiceGrpc.TestServiceBlockingStub stub =
-                    TestServiceGrpc.newBlockingStub(managedChannel).withInterceptors(new AllureGrpc());
+                TestServiceGrpc.TestServiceBlockingStub stub = TestServiceGrpc.newBlockingStub(managedChannel).withInterceptors(new AllureGrpc());
                 Iterator<Response> responseIterator = stub.calculateServerStream(request);
                 int responseCount = 0;
                 while (responseIterator.hasNext()) {
@@ -356,14 +374,13 @@ protected final AllureResults executeServerStreaming(Request request) {
     }
 
     protected final AllureResults executeUnaryExpectingException(Request request) {
-        return runWithinTestContext(() ->
-            assertThatExceptionOfType(StatusRuntimeException.class)
-                .isThrownBy(() -> {
-                    TestServiceGrpc.TestServiceBlockingStub stub =
-                        TestServiceGrpc.newBlockingStub(managedChannel).withInterceptors(new AllureGrpc());
-                    Response response = stub.calculate(request);
-                    assertThat(response.getMessage()).isEqualTo("ok");
-                })
+        return runWithinTestContext(
+                () -> assertThatExceptionOfType(StatusRuntimeException.class)
+                        .isThrownBy(() -> {
+                            TestServiceGrpc.TestServiceBlockingStub stub = TestServiceGrpc.newBlockingStub(managedChannel).withInterceptors(new AllureGrpc());
+                            Response response = stub.calculate(request);
+                            assertThat(response.getMessage()).isEqualTo("ok");
+                        })
         );
     }
 
diff --git a/allure-grpc/src/test/resources/allure.properties b/allure-grpc/src/test/resources/allure.properties
index 9c0b0a2d..55602943 100644
--- a/allure-grpc/src/test/resources/allure.properties
+++ b/allure-grpc/src/test/resources/allure.properties
@@ -1,2 +1,3 @@
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-grpc
diff --git a/allure-hamcrest/build.gradle.kts b/allure-hamcrest/build.gradle.kts
index 6b0e5dd3..3817ab48 100644
--- a/allure-hamcrest/build.gradle.kts
+++ b/allure-hamcrest/build.gradle.kts
@@ -12,6 +12,7 @@ dependencies {
     testImplementation("org.slf4j:slf4j-simple")
     testImplementation(project(":allure-java-commons-test"))
     testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
+    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 }
 
 tasks.jar {
diff --git a/allure-hamcrest/src/main/java/io/qameta/allure/hamcrest/AllureHamcrestAssert.java b/allure-hamcrest/src/main/java/io/qameta/allure/hamcrest/AllureHamcrestAssert.java
index 60153b14..99d60fd9 100644
--- a/allure-hamcrest/src/main/java/io/qameta/allure/hamcrest/AllureHamcrestAssert.java
+++ b/allure-hamcrest/src/main/java/io/qameta/allure/hamcrest/AllureHamcrestAssert.java
@@ -15,17 +15,17 @@
  */
 package io.qameta.allure.hamcrest;
 
-import org.aspectj.lang.JoinPoint;
-import org.aspectj.lang.annotation.Aspect;
-import org.aspectj.lang.annotation.Pointcut;
-import org.aspectj.lang.annotation.Before;
-import org.aspectj.lang.annotation.AfterThrowing;
-import org.aspectj.lang.annotation.AfterReturning;
 import io.qameta.allure.Allure;
 import io.qameta.allure.AllureLifecycle;
 import io.qameta.allure.model.Status;
 import io.qameta.allure.model.StepResult;
 import io.qameta.allure.util.ObjectUtils;
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.annotation.AfterReturning;
+import org.aspectj.lang.annotation.AfterThrowing;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Before;
+import org.aspectj.lang.annotation.Pointcut;
 import org.hamcrest.Matcher;
 import org.hamcrest.StringDescription;
 
@@ -47,7 +47,6 @@
  * methods in the TypeSafeMatcher class.
  * </p>
  *
- * @author a-simeshin (Simeshin Artem)
  * @see org.hamcrest.TypeSafeMatcher
  */
 @Aspect
@@ -61,10 +60,18 @@ protected AllureLifecycle initialValue() {
         }
     };
 
+    /**
+     * Returns the lifecycle.
+     *
+     * @return the Allure lifecycle used by this integration
+     */
     public static AllureLifecycle getLifecycle() {
         return lifecycle.get();
     }
 
+    /**
+     * Handles the init assert that callback.
+     */
     @Pointcut("execution(void org.hamcrest.MatcherAssert.**(..))")
     public void initAssertThat() {
     }
@@ -106,12 +113,24 @@ public void catchAndStartStep(final JoinPoint joinPoint) {
         }
     }
 
-    @AfterThrowing(pointcut = "initAssertThat()", throwing = "e")
+    @AfterThrowing(
+            pointcut = "initAssertThat()",
+            throwing = "e"
+    )
+
+    /**
+     * Handles the step failed callback.
+     *
+     * @param e the e
+     */
     public void stepFailed(final Throwable e) {
         getLifecycle().updateStep(s -> s.setStatus(getStatus(e).orElse(Status.BROKEN)));
         getLifecycle().stopStep();
     }
 
+    /**
+     * Handles the step stop callback.
+     */
     @AfterReturning(pointcut = "initAssertThat()")
     public void stepStop() {
         getLifecycle().updateStep(s -> s.setStatus(Status.PASSED));
diff --git a/allure-hamcrest/src/test/java/io/qameta/allure/hamcrest/AllureHamcrestCollectionsMatchersTest.java b/allure-hamcrest/src/test/java/io/qameta/allure/hamcrest/AllureHamcrestCollectionsMatchersTest.java
index 21f2e5ee..acdd8900 100644
--- a/allure-hamcrest/src/test/java/io/qameta/allure/hamcrest/AllureHamcrestCollectionsMatchersTest.java
+++ b/allure-hamcrest/src/test/java/io/qameta/allure/hamcrest/AllureHamcrestCollectionsMatchersTest.java
@@ -54,7 +54,7 @@ public class AllureHamcrestCollectionsMatchersTest {
     @Test
     void hamcrestAssertNameForArrayMatchers() {
         final TestResult testResult = runWithinTestContext(
-                () -> assertThat(new Integer[]{1,2,3}, is(array(equalTo(1), equalTo(2), equalTo(3)))),
+                () -> assertThat(new Integer[]{1, 2, 3}, is(array(equalTo(1), equalTo(2), equalTo(3)))),
                 AllureHamcrestAssert::setLifecycle
         ).getTestResults().get(0);
 
diff --git a/allure-hamcrest/src/test/java/io/qameta/allure/hamcrest/AllureHamcrestTextMatchersTest.java b/allure-hamcrest/src/test/java/io/qameta/allure/hamcrest/AllureHamcrestTextMatchersTest.java
index 6c3932a0..515f6ecb 100644
--- a/allure-hamcrest/src/test/java/io/qameta/allure/hamcrest/AllureHamcrestTextMatchersTest.java
+++ b/allure-hamcrest/src/test/java/io/qameta/allure/hamcrest/AllureHamcrestTextMatchersTest.java
@@ -20,7 +20,6 @@
 import org.assertj.core.api.Assertions;
 import org.hamcrest.Matcher;
 import org.junit.jupiter.api.TestInstance;
-
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
diff --git a/allure-hamcrest/src/test/resources/allure.properties b/allure-hamcrest/src/test/resources/allure.properties
new file mode 100644
index 00000000..ee8c853e
--- /dev/null
+++ b/allure-hamcrest/src/test/resources/allure.properties
@@ -0,0 +1,3 @@
+allure.results.directory=build/allure-results
+allure.label.epic=#project.description#
+allure.label.module=allure-hamcrest
diff --git a/allure-httpclient/src/main/java/io/qameta/allure/httpclient/AllureHttpClientRequest.java b/allure-httpclient/src/main/java/io/qameta/allure/httpclient/AllureHttpClientRequest.java
index e988f922..1530c63a 100644
--- a/allure-httpclient/src/main/java/io/qameta/allure/httpclient/AllureHttpClientRequest.java
+++ b/allure-httpclient/src/main/java/io/qameta/allure/httpclient/AllureHttpClientRequest.java
@@ -35,19 +35,31 @@
 import static io.qameta.allure.attachment.http.HttpRequestAttachment.Builder.create;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Captures Apache HttpClient 4 requests as Allure attachments.
+ *
+ * <p>Register an instance as an {@link org.apache.http.HttpRequestInterceptor} on the client. The default constructor uses the standard request template and writer; the explicit constructor accepts custom rendering and processing components.</p>
  */
 public class AllureHttpClientRequest implements HttpRequestInterceptor {
 
     private final AttachmentRenderer<AttachmentData> renderer;
     private final AttachmentProcessor<AttachmentData> processor;
 
+    /**
+     * Creates an Allure http client request with default configuration.
+     */
     public AllureHttpClientRequest() {
-        this(new FreemarkerAttachmentRenderer("http-request.ftl"),
-             new DefaultAttachmentProcessor()
+        this(
+                new FreemarkerAttachmentRenderer("http-request.ftl"),
+                new DefaultAttachmentProcessor()
         );
     }
 
+    /**
+     * Creates an Allure http client request with the supplied values.
+     *
+     * @param renderer the renderer used to turn attachment data into content
+     * @param processor the processor used to write rendered attachments
+     */
     public AllureHttpClientRequest(final AttachmentRenderer<AttachmentData> renderer,
                                    final AttachmentProcessor<AttachmentData> processor) {
         this.renderer = renderer;
@@ -55,20 +67,28 @@ public AllureHttpClientRequest(final AttachmentRenderer<AttachmentData> renderer
     }
 
     private static String getAttachmentName(final HttpRequest request) {
-        return String.format("Request_%s_%s", request.getRequestLine().getMethod(),
-                             request.getRequestLine().getUri());
+        return String.format(
+                "Request_%s_%s", request.getRequestLine().getMethod(),
+                request.getRequestLine().getUri()
+        );
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void process(final HttpRequest request,
-                        final HttpContext context) throws IOException {
+                        final HttpContext context)
+            throws IOException {
 
-        final HttpRequestAttachment.Builder builder = create(getAttachmentName(request),
-                                                             request.getRequestLine().getUri())
+        final HttpRequestAttachment.Builder builder = create(
+                getAttachmentName(request),
+                request.getRequestLine().getUri()
+        )
                 .setMethod(request.getRequestLine().getMethod());
 
         Stream.of(request.getAllHeaders())
-              .forEach(header -> builder.setHeader(header.getName(), header.getValue()));
+                .forEach(header -> builder.setHeader(header.getName(), header.getValue()));
 
         if (request instanceof HttpEntityEnclosingRequest) {
             final HttpEntity entity = ((HttpEntityEnclosingRequest) request).getEntity();
diff --git a/allure-httpclient/src/main/java/io/qameta/allure/httpclient/AllureHttpClientResponse.java b/allure-httpclient/src/main/java/io/qameta/allure/httpclient/AllureHttpClientResponse.java
index d34476b6..a1ae607a 100644
--- a/allure-httpclient/src/main/java/io/qameta/allure/httpclient/AllureHttpClientResponse.java
+++ b/allure-httpclient/src/main/java/io/qameta/allure/httpclient/AllureHttpClientResponse.java
@@ -33,28 +33,44 @@
 import static io.qameta.allure.attachment.http.HttpResponseAttachment.Builder.create;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Captures Apache HttpClient 4 responses as Allure attachments.
+ *
+ * <p>Register an instance as an {@link org.apache.http.HttpResponseInterceptor} on the client. The default constructor uses the standard response template and writer; the explicit constructor accepts custom rendering and processing components.</p>
  */
 public class AllureHttpClientResponse implements HttpResponseInterceptor {
 
     private final AttachmentRenderer<AttachmentData> renderer;
     private final AttachmentProcessor<AttachmentData> processor;
 
+    /**
+     * Creates an Allure http client response with default configuration.
+     */
     public AllureHttpClientResponse() {
-        this(new FreemarkerAttachmentRenderer("http-response.ftl"),
+        this(
+                new FreemarkerAttachmentRenderer("http-response.ftl"),
                 new DefaultAttachmentProcessor()
         );
     }
 
+    /**
+     * Creates an Allure http client response with the supplied values.
+     *
+     * @param renderer the renderer used to turn attachment data into content
+     * @param processor the processor used to write rendered attachments
+     */
     public AllureHttpClientResponse(final AttachmentRenderer<AttachmentData> renderer,
                                     final AttachmentProcessor<AttachmentData> processor) {
         this.renderer = renderer;
         this.processor = processor;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void process(final HttpResponse response,
-                        final HttpContext context) throws IOException {
+                        final HttpContext context)
+            throws IOException {
 
         final HttpResponseAttachment.Builder builder = create("Response")
                 .setResponseCode(response.getStatusLine().getStatusCode());
diff --git a/allure-httpclient/src/test/java/io/qameta/allure/httpclient/AllureHttpClientTest.java b/allure-httpclient/src/test/java/io/qameta/allure/httpclient/AllureHttpClientTest.java
index 4126ca32..36289202 100644
--- a/allure-httpclient/src/test/java/io/qameta/allure/httpclient/AllureHttpClientTest.java
+++ b/allure-httpclient/src/test/java/io/qameta/allure/httpclient/AllureHttpClientTest.java
@@ -46,10 +46,6 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class AllureHttpClientTest {
 
     private static final String BODY_STRING = "Hello world!";
@@ -62,16 +58,26 @@ void setUp() {
         server.start();
         configureFor(server.port());
 
-        stubFor(get(urlEqualTo("/hello"))
-                .willReturn(aResponse()
-                        .withBody(BODY_STRING)));
-
-        stubFor(get(urlEqualTo("/empty"))
-                .willReturn(aResponse()
-                        .withStatus(304)));
-
-        stubFor(delete(urlEqualTo("/hello"))
-                .willReturn(noContent()));
+        stubFor(
+                get(urlEqualTo("/hello"))
+                        .willReturn(
+                                aResponse()
+                                        .withBody(BODY_STRING)
+                        )
+        );
+
+        stubFor(
+                get(urlEqualTo("/empty"))
+                        .willReturn(
+                                aResponse()
+                                        .withStatus(304)
+                        )
+        );
+
+        stubFor(
+                delete(urlEqualTo("/hello"))
+                        .willReturn(noContent())
+        );
     }
 
     @AfterEach
@@ -169,7 +175,7 @@ void shouldCreateRequestAttachmentWithEmptyBodyWhenNoContentIsReturned() throws
         final AttachmentProcessor<AttachmentData> processor = mock(AttachmentProcessor.class);
 
         final HttpClientBuilder builder = HttpClientBuilder.create()
-                                                           .addInterceptorLast(new AllureHttpClientRequest(renderer, processor));
+                .addInterceptorLast(new AllureHttpClientRequest(renderer, processor));
 
         try (CloseableHttpClient httpClient = builder.build()) {
             final HttpDelete httpDelete = new HttpDelete(String.format("http://localhost:%d/hello", server.port()));
@@ -195,16 +201,16 @@ void shouldNotConsumeBody() throws Exception {
         final AttachmentProcessor<AttachmentData> processor = mock(AttachmentProcessor.class);
 
         final HttpClientBuilder builder = HttpClientBuilder.create()
-                                                           .addInterceptorLast(new AllureHttpClientResponse(renderer, processor));
+                .addInterceptorLast(new AllureHttpClientResponse(renderer, processor));
 
         try (CloseableHttpClient httpClient = builder.build()) {
-          final HttpGet httpGet = new HttpGet(String.format("http://localhost:%d/hello", server.port()));
-          try (CloseableHttpResponse response = httpClient.execute(httpGet)) {
-              response.getStatusLine().getStatusCode();
-              BufferedHttpEntity ent = new BufferedHttpEntity(response.getEntity());
-              assertThat(EntityUtils.toString(ent))
-                      .isEqualTo(BODY_STRING);
-          }
+            final HttpGet httpGet = new HttpGet(String.format("http://localhost:%d/hello", server.port()));
+            try (CloseableHttpResponse response = httpClient.execute(httpGet)) {
+                response.getStatusLine().getStatusCode();
+                BufferedHttpEntity ent = new BufferedHttpEntity(response.getEntity());
+                assertThat(EntityUtils.toString(ent))
+                        .isEqualTo(BODY_STRING);
+            }
         }
     }
 }
diff --git a/allure-httpclient/src/test/resources/allure.properties b/allure-httpclient/src/test/resources/allure.properties
index 9c0b0a2d..0b9f016c 100644
--- a/allure-httpclient/src/test/resources/allure.properties
+++ b/allure-httpclient/src/test/resources/allure.properties
@@ -1,2 +1,3 @@
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-httpclient
diff --git a/allure-httpclient5/src/main/java/io/qameta/allure/httpclient5/AllureHttpClient5Request.java b/allure-httpclient5/src/main/java/io/qameta/allure/httpclient5/AllureHttpClient5Request.java
index 60aff399..75a30ef3 100644
--- a/allure-httpclient5/src/main/java/io/qameta/allure/httpclient5/AllureHttpClient5Request.java
+++ b/allure-httpclient5/src/main/java/io/qameta/allure/httpclient5/AllureHttpClient5Request.java
@@ -32,21 +32,37 @@
 import static io.qameta.allure.attachment.http.HttpRequestAttachment.Builder.create;
 
 /**
- * @author a-simeshin (Simeshin Artem)
+ * Captures Apache HttpClient 5 requests as Allure attachments.
+ *
+ * <p>Register an instance as an {@link org.apache.hc.core5.http.HttpRequestInterceptor}. The interceptor records request metadata and delegates attachment rendering to the configured Allure components.</p>
  */
 public class AllureHttpClient5Request implements HttpRequestInterceptor {
 
     private final AttachmentRenderer<AttachmentData> renderer;
     private final AttachmentProcessor<AttachmentData> processor;
 
+    /**
+     * Creates an Allure http client5 request with default configuration.
+     */
     public AllureHttpClient5Request() {
         this("http-request.ftl");
     }
 
+    /**
+     * Creates an Allure http client5 request with the supplied values.
+     *
+     * @param templateName the template name
+     */
     public AllureHttpClient5Request(final String templateName) {
         this(new FreemarkerAttachmentRenderer(templateName), new DefaultAttachmentProcessor());
     }
 
+    /**
+     * Creates an Allure http client5 request with the supplied values.
+     *
+     * @param renderer the renderer used to turn attachment data into content
+     * @param processor the processor used to write rendered attachments
+     */
     public AllureHttpClient5Request(final AttachmentRenderer<AttachmentData> renderer,
                                     final AttachmentProcessor<AttachmentData> processor) {
         this.renderer = renderer;
diff --git a/allure-httpclient5/src/main/java/io/qameta/allure/httpclient5/AllureHttpClient5Response.java b/allure-httpclient5/src/main/java/io/qameta/allure/httpclient5/AllureHttpClient5Response.java
index 5c9683b4..c2826041 100644
--- a/allure-httpclient5/src/main/java/io/qameta/allure/httpclient5/AllureHttpClient5Response.java
+++ b/allure-httpclient5/src/main/java/io/qameta/allure/httpclient5/AllureHttpClient5Response.java
@@ -35,24 +35,42 @@
 import static io.qameta.allure.attachment.http.HttpResponseAttachment.Builder.create;
 
 /**
- * @author a-simeshin (Simeshin Artem)
+ * Captures Apache HttpClient 5 responses as Allure attachments.
+ *
+ * <p>Register an instance as an {@link org.apache.hc.core5.http.HttpResponseInterceptor}. The interceptor records response metadata and delegates attachment rendering to the configured Allure components.</p>
  */
-@SuppressWarnings({
-        "checkstyle:ParameterAssignment",
-        "PMD.AvoidReassigningParameters"})
+@SuppressWarnings(
+    {
+            "checkstyle:ParameterAssignment",
+            "PMD.AvoidReassigningParameters"}
+)
 public class AllureHttpClient5Response implements HttpResponseInterceptor {
     private final AttachmentRenderer<AttachmentData> renderer;
     private final AttachmentProcessor<AttachmentData> processor;
     private static final String NO_BODY = "No body present";
 
+    /**
+     * Creates an Allure http client5 response with default configuration.
+     */
     public AllureHttpClient5Response() {
         this("http-response.ftl");
     }
 
+    /**
+     * Creates an Allure http client5 response with the supplied values.
+     *
+     * @param templateName the template name
+     */
     public AllureHttpClient5Response(final String templateName) {
         this(new FreemarkerAttachmentRenderer(templateName), new DefaultAttachmentProcessor());
     }
 
+    /**
+     * Creates an Allure http client5 response with the supplied values.
+     *
+     * @param renderer the renderer used to turn attachment data into content
+     * @param processor the processor used to write rendered attachments
+     */
     public AllureHttpClient5Response(final AttachmentRenderer<AttachmentData> renderer,
                                      final AttachmentProcessor<AttachmentData> processor) {
         this.renderer = renderer;
@@ -71,7 +89,8 @@ public AllureHttpClient5Response(final AttachmentRenderer<AttachmentData> render
     @Override
     public void process(final HttpResponse response,
                         EntityDetails entity,
-                        final HttpContext context) throws IOException {
+                        final HttpContext context)
+            throws IOException {
         final HttpResponseAttachment.Builder builder = create("Response");
         builder.setResponseCode(response.getCode());
 
@@ -82,8 +101,7 @@ public void process(final HttpResponse response,
             // Looks like a bug or completely new logic. It's not enough to replace chaining EntityDetails entity.
             // To read the response body twice, It needs to put in the context also
             entity = new BufferedHttpEntity(originalHttpEntity);
-            final BasicClassicHttpResponse responseEntity =
-                    (BasicClassicHttpResponse) context.getAttribute("http.response");
+            final BasicClassicHttpResponse responseEntity = (BasicClassicHttpResponse) context.getAttribute("http.response");
             responseEntity.setEntity((HttpEntity) entity);
 
             final String responseBody = AllureHttpEntityUtils.getBody((HttpEntity) entity);
diff --git a/allure-httpclient5/src/test/java/io/qameta/allure/httpclient5/AllureHttpClient5DeleteTest.java b/allure-httpclient5/src/test/java/io/qameta/allure/httpclient5/AllureHttpClient5DeleteTest.java
index 0b968856..f5de9d23 100644
--- a/allure-httpclient5/src/test/java/io/qameta/allure/httpclient5/AllureHttpClient5DeleteTest.java
+++ b/allure-httpclient5/src/test/java/io/qameta/allure/httpclient5/AllureHttpClient5DeleteTest.java
@@ -40,10 +40,6 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
-
-/**
- * @author a-simeshin (Simeshin Artem).
- */
 @SuppressWarnings({"unchecked", "PMD.JUnitTestContainsTooManyAsserts"})
 class AllureHttpClient5DeleteTest {
 
@@ -58,9 +54,11 @@ void setUp() {
         server.start();
         configureFor(server.port());
 
-        stubFor(delete(HELLO_RESOURCE_PATH).willReturn(
-                aResponse()
-                        .withStatus(204))
+        stubFor(
+                delete(HELLO_RESOURCE_PATH).willReturn(
+                        aResponse()
+                                .withStatus(204)
+                )
         );
     }
 
diff --git a/allure-httpclient5/src/test/java/io/qameta/allure/httpclient5/AllureHttpClient5GetTest.java b/allure-httpclient5/src/test/java/io/qameta/allure/httpclient5/AllureHttpClient5GetTest.java
index d750d5cc..4edadc80 100644
--- a/allure-httpclient5/src/test/java/io/qameta/allure/httpclient5/AllureHttpClient5GetTest.java
+++ b/allure-httpclient5/src/test/java/io/qameta/allure/httpclient5/AllureHttpClient5GetTest.java
@@ -41,10 +41,6 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
-
-/**
- * @author a-simeshin (Simeshin Artem).
- */
 @SuppressWarnings({"unchecked", "PMD.JUnitTestContainsTooManyAsserts"})
 class AllureHttpClient5GetTest {
 
@@ -53,7 +49,6 @@ class AllureHttpClient5GetTest {
     private static final String HELLO_GET_RETURN_BODY = "http://localhost:%d/hello";
     private static final String HELLO_GET_201_NO_BODY = "http://localhost:%d/empty";
 
-
     private WireMockServer server;
 
     @BeforeEach
@@ -62,14 +57,18 @@ void setUp() {
         server.start();
         configureFor(server.port());
 
-        stubFor(get(HELLO_RESOURCE_PATH).willReturn(
-                aResponse()
-                        .withHeader("Content-Type", "application/json")
-                        .withBody(BODY_STRING)
-        ));
-        stubFor(get("/empty").willReturn(
-                aResponse()
-                        .withStatus(200))
+        stubFor(
+                get(HELLO_RESOURCE_PATH).willReturn(
+                        aResponse()
+                                .withHeader("Content-Type", "application/json")
+                                .withBody(BODY_STRING)
+                )
+        );
+        stubFor(
+                get("/empty").willReturn(
+                        aResponse()
+                                .withStatus(200)
+                )
         );
     }
 
diff --git a/allure-httpclient5/src/test/java/io/qameta/allure/httpclient5/AllureHttpClient5PostTest.java b/allure-httpclient5/src/test/java/io/qameta/allure/httpclient5/AllureHttpClient5PostTest.java
index 3346e183..61d43da1 100644
--- a/allure-httpclient5/src/test/java/io/qameta/allure/httpclient5/AllureHttpClient5PostTest.java
+++ b/allure-httpclient5/src/test/java/io/qameta/allure/httpclient5/AllureHttpClient5PostTest.java
@@ -43,10 +43,6 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
-
-/**
- * @author a-simeshin (Simeshin Artem).
- */
 @SuppressWarnings({"unchecked", "PMD.JUnitTestContainsTooManyAsserts"})
 class AllureHttpClient5PostTest {
 
@@ -56,7 +52,6 @@ class AllureHttpClient5PostTest {
     private static final String HELLO_POST_RETURN_BODY = "http://localhost:%d/hello";
     private static final String HELLO_POST_201_NO_BODY = "http://localhost:%d/empty";
 
-
     private WireMockServer server;
 
     @BeforeEach
@@ -65,14 +60,18 @@ void setUp() {
         server.start();
         configureFor(server.port());
 
-        stubFor(post(HELLO_RESOURCE_PATH).willReturn(
-                aResponse()
-                        .withHeader("Content-Type", "application/json")
-                        .withBody(BODY_STRING)
-        ));
-        stubFor(post("/empty").willReturn(
-                aResponse()
-                        .withStatus(201))
+        stubFor(
+                post(HELLO_RESOURCE_PATH).willReturn(
+                        aResponse()
+                                .withHeader("Content-Type", "application/json")
+                                .withBody(BODY_STRING)
+                )
+        );
+        stubFor(
+                post("/empty").willReturn(
+                        aResponse()
+                                .withStatus(201)
+                )
         );
     }
 
diff --git a/allure-httpclient5/src/test/resources/allure.properties b/allure-httpclient5/src/test/resources/allure.properties
index 9c0b0a2d..a6feadd7 100644
--- a/allure-httpclient5/src/test/resources/allure.properties
+++ b/allure-httpclient5/src/test/resources/allure.properties
@@ -1,2 +1,3 @@
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-httpclient5
diff --git a/allure-java-commons-test/build.gradle.kts b/allure-java-commons-test/build.gradle.kts
index e1d5c399..92c4e2e0 100644
--- a/allure-java-commons-test/build.gradle.kts
+++ b/allure-java-commons-test/build.gradle.kts
@@ -6,6 +6,9 @@ dependencies {
     api("org.apache.commons:commons-lang3")
     api(project(":allure-java-commons"))
     implementation("com.fasterxml.jackson.core:jackson-databind")
+    testImplementation("org.junit.jupiter:junit-jupiter-api")
+    testImplementation(project(":allure-junit-platform"))
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
 }
 
 tasks.jar {
@@ -15,3 +18,7 @@ tasks.jar {
         ))
     }
 }
+
+tasks.test {
+    useJUnitPlatform()
+}
diff --git a/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllureFeatures.java b/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllureFeatures.java
index e3706d29..50e84637 100644
--- a/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllureFeatures.java
+++ b/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllureFeatures.java
@@ -25,7 +25,9 @@
 import java.lang.annotation.Target;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Integrates Allure Java test support with Allure reporting.
+ *
+ * <p>Register this type through the standard Allure Java test support extension, listener, interceptor, or plugin mechanism so framework execution events are written to Allure results. Use explicit dependencies when embedding the integration in tests or custom runtimes.</p>
  */
 @SuppressWarnings({"JavadocType"})
 @Target({})
diff --git a/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllurePredicates.java b/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllurePredicates.java
index cfb24b3d..2a5b7b00 100644
--- a/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllurePredicates.java
+++ b/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllurePredicates.java
@@ -23,7 +23,9 @@
 import java.util.function.Predicate;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Integrates Allure Java test support with Allure reporting.
+ *
+ * <p>Register this type through the standard Allure Java test support extension, listener, interceptor, or plugin mechanism so framework execution events are written to Allure results. Use explicit dependencies when embedding the integration in tests or custom runtimes.</p>
  */
 public final class AllurePredicates {
 
@@ -31,10 +33,23 @@ private AllurePredicates() {
         throw new IllegalStateException("Do not instance");
     }
 
+    /**
+     * Returns whether status is available.
+     *
+     * @param status the response status
+     * @return true when status; false otherwise
+     */
     public static Predicate<TestResult> hasStatus(final Status status) {
         return testResult -> status.equals(testResult.getStatus());
     }
 
+    /**
+     * Returns whether label is available.
+     *
+     * @param name the display name or logical name to use
+     * @param value the value to set
+     * @return true when label; false otherwise
+     */
     public static Predicate<TestResult> hasLabel(final String name, final String value) {
         final Predicate<Label> labelPredicate = label -> Objects.equals(label.getName(), name)
                 && Objects.equals(label.getValue(), value);
diff --git a/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllureResults.java b/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllureResults.java
index bc922572..69368e5b 100644
--- a/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllureResults.java
+++ b/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllureResults.java
@@ -25,23 +25,42 @@
 import java.util.stream.Collectors;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Integrates Allure Java test support with Allure reporting.
+ *
+ * <p>Register this type through the standard Allure Java test support extension, listener, interceptor, or plugin mechanism so framework execution events are written to Allure results. Use explicit dependencies when embedding the integration in tests or custom runtimes.</p>
  */
 public interface AllureResults {
 
+    /**
+     * Returns the test results.
+     *
+     * @return the test results
+     */
     List<TestResult> getTestResults();
 
+    /**
+     * Returns the test result containers.
+     *
+     * @return the test containers
+     */
     List<TestResultContainer> getTestResultContainers();
 
+    /**
+     * Returns the attachments.
+     *
+     * @return the attachments
+     */
     Map<String, byte[]> getAttachments();
 
     default TestResult getTestResultByName(final String name) {
         return getTestResults().stream()
                 .filter(tr -> Objects.equals(name, tr.getName()))
                 .findFirst()
-                .orElseThrow(() -> new NoSuchElementException(
-                        "test result with name " + name + " is not found"
-                ));
+                .orElseThrow(
+                        () -> new NoSuchElementException(
+                                "test result with name " + name + " is not found"
+                        )
+                );
     }
 
     default List<TestResultContainer> getTestResultContainersForTestResult(final TestResult testResult) {
diff --git a/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllureResultsWriterStub.java b/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllureResultsWriterStub.java
index 10501fee..f0b687f5 100644
--- a/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllureResultsWriterStub.java
+++ b/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllureResultsWriterStub.java
@@ -28,7 +28,9 @@
 import java.util.concurrent.CopyOnWriteArrayList;
 
 /**
- * @author Egor Borisov ehborisov@gmail.com
+ * Integrates Allure Java test support with Allure reporting.
+ *
+ * <p>Register this type through the standard Allure Java test support extension, listener, interceptor, or plugin mechanism so framework execution events are written to Allure results. Use explicit dependencies when embedding the integration in tests or custom runtimes.</p>
  */
 @SuppressWarnings("PMD.AvoidThrowingRawExceptionTypes")
 public class AllureResultsWriterStub implements AllureResultsWriter, AllureResults {
@@ -37,16 +39,25 @@ public class AllureResultsWriterStub implements AllureResultsWriter, AllureResul
     private final List<TestResultContainer> testContainers = new CopyOnWriteArrayList<>();
     private final Map<String, byte[]> attachments = new ConcurrentHashMap<>();
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void write(final TestResult testResult) {
         testResults.add(testResult);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void write(final TestResultContainer testResultContainer) {
         testContainers.add(testResultContainer);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void write(final String source, final InputStream attachment) {
         try {
@@ -57,16 +68,25 @@ public void write(final String source, final InputStream attachment) {
         }
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public List<TestResult> getTestResults() {
         return testResults;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public List<TestResultContainer> getTestResultContainers() {
         return testContainers;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public Map<String, byte[]> getAttachments() {
         return attachments;
diff --git a/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllureTestCommonsUtils.java b/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllureTestCommonsUtils.java
index 6a00c5c4..61345619 100644
--- a/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllureTestCommonsUtils.java
+++ b/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllureTestCommonsUtils.java
@@ -37,19 +37,27 @@
 import static com.fasterxml.jackson.databind.MapperFeature.USE_WRAPPER_NAME_AS_PROPERTY_NAME;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Provides utility methods for Allure Java test support support.
+ *
+ * <p>The methods are stateless helpers intended for integrations, tests, and extension code that need the same conventions as the built-in Allure adapters.</p>
  */
 public final class AllureTestCommonsUtils {
 
+    private static final String DOT = ".";
+    private static final String JSON_EXTENSION = "json";
+    private static final String JSON_TYPE = "application/json";
+    private static final String TEXT_EXTENSION = "txt";
+    private static final String TEXT_TYPE = "text/plain";
     private static final ObjectWriter WRITER = JsonMapper
             .builder()
             .configure(USE_WRAPPER_NAME_AS_PROPERTY_NAME, true)
             .serializationInclusion(NON_DEFAULT)
             .build()
-            .registerModule(new SimpleModule()
-                    .addSerializer(Status.class, new StatusSerializer())
-                    .addSerializer(Stage.class, new StageSerializer())
-                    .addSerializer(Parameter.Mode.class, new ParameterModeSerializer())
+            .registerModule(
+                    new SimpleModule()
+                            .addSerializer(Status.class, new StatusSerializer())
+                            .addSerializer(Stage.class, new StageSerializer())
+                            .addSerializer(Parameter.Mode.class, new ParameterModeSerializer())
             )
             .writerWithDefaultPrettyPrinter();
 
@@ -65,7 +73,9 @@ public static void attach(final AllureResults allureResults) {
             try {
                 Allure.addAttachment(
                         testResult.getUuid() + AllureConstants.TEST_RESULT_FILE_SUFFIX,
-                        WRITER.writeValueAsString(testResult)
+                        JSON_TYPE,
+                        WRITER.writeValueAsString(testResult),
+                        JSON_EXTENSION
                 );
             } catch (JsonProcessingException e) {
                 throw new UncheckedIOException(e);
@@ -76,21 +86,44 @@ public static void attach(final AllureResults allureResults) {
             try {
                 Allure.addAttachment(
                         container.getUuid() + AllureConstants.TEST_RESULT_CONTAINER_FILE_SUFFIX,
-                        WRITER.writeValueAsString(container)
+                        JSON_TYPE,
+                        WRITER.writeValueAsString(container),
+                        JSON_EXTENSION
                 );
             } catch (JsonProcessingException e) {
                 throw new UncheckedIOException(e);
             }
         });
 
-        allureResults.getAttachments().forEach((fileName, body) -> Allure
-                .addAttachment(
-                        fileName,
-                        new ByteArrayInputStream(body)
-                )
+        allureResults.getAttachments().forEach(
+                (fileName, body) -> Allure
+                        .addAttachment(
+                                fileName,
+                                type(fileName),
+                                new ByteArrayInputStream(body),
+                                extension(fileName)
+                        )
         );
     }
 
+    private static String type(final String fileName) {
+        if (fileName.endsWith(DOT + JSON_EXTENSION)) {
+            return JSON_TYPE;
+        }
+        if (fileName.endsWith(DOT + TEXT_EXTENSION)) {
+            return TEXT_TYPE;
+        }
+        return null;
+    }
+
+    private static String extension(final String fileName) {
+        final int index = fileName.lastIndexOf('.');
+        if (index < 0 || index == fileName.length() - 1) {
+            return null;
+        }
+        return fileName.substring(index + 1);
+    }
+
     /**
      * Parameter mode serializer.
      */
@@ -102,7 +135,8 @@ protected ParameterModeSerializer() {
         @Override
         public void serialize(final Parameter.Mode value,
                               final JsonGenerator gen,
-                              final SerializerProvider provider) throws IOException {
+                              final SerializerProvider provider)
+                throws IOException {
             gen.writeString(value.name().toLowerCase(Locale.ENGLISH));
         }
     }
@@ -118,7 +152,8 @@ protected StageSerializer() {
         @Override
         public void serialize(final Stage value,
                               final JsonGenerator gen,
-                              final SerializerProvider provider) throws IOException {
+                              final SerializerProvider provider)
+                throws IOException {
             gen.writeString(value.name().toLowerCase(Locale.ENGLISH));
         }
     }
@@ -134,7 +169,8 @@ protected StatusSerializer() {
         @Override
         public void serialize(final Status value,
                               final JsonGenerator gen,
-                              final SerializerProvider provider) throws IOException {
+                              final SerializerProvider provider)
+                throws IOException {
             gen.writeString(value.name().toLowerCase(Locale.ENGLISH));
         }
     }
diff --git a/allure-java-commons-test/src/main/java/io/qameta/allure/test/RunUtils.java b/allure-java-commons-test/src/main/java/io/qameta/allure/test/RunUtils.java
index d28a685e..780e4eee 100644
--- a/allure-java-commons-test/src/main/java/io/qameta/allure/test/RunUtils.java
+++ b/allure-java-commons-test/src/main/java/io/qameta/allure/test/RunUtils.java
@@ -32,7 +32,9 @@
 import static io.qameta.allure.util.ResultsUtils.getStatusDetails;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Provides utility methods for Allure Java test support support.
+ *
+ * <p>The methods are stateless helpers intended for integrations, tests, and extension code that need the same conventions as the built-in Allure adapters.</p>
  */
 public final class RunUtils {
 
@@ -40,8 +42,14 @@ private RunUtils() {
         throw new IllegalStateException("do not instance");
     }
 
+    /**
+     * Runs the supplied tests and returns collected Allure results.
+     *
+     * @param runnable the runnable
+     * @return the collected Allure results
+     */
     public static AllureResults runTests(
-            final Allure.ThrowableContextRunnableVoid<AllureLifecycle> runnable) {
+                                         final Allure.ThrowableContextRunnableVoid<AllureLifecycle> runnable) {
         return runTests(
                 runnable,
                 Allure::setLifecycle,
@@ -50,9 +58,16 @@ public static AllureResults runTests(
         );
     }
 
+    /**
+     * Runs the supplied tests and returns collected Allure results.
+     *
+     * @param lifecycleFactory the lifecycle factory
+     * @param runnable the runnable
+     * @return the collected Allure results
+     */
     public static AllureResults runTests(
-            final Function<AllureResultsWriter, AllureLifecycle> lifecycleFactory,
-            final Allure.ThrowableContextRunnableVoid<AllureLifecycle> runnable) {
+                                         final Function<AllureResultsWriter, AllureLifecycle> lifecycleFactory,
+                                         final Allure.ThrowableContextRunnableVoid<AllureLifecycle> runnable) {
         return runTests(
                 lifecycleFactory,
                 runnable,
@@ -62,18 +77,33 @@ public static AllureResults runTests(
         );
     }
 
+    /**
+     * Runs the supplied tests and returns collected Allure results.
+     *
+     * @param runnable the runnable
+     * @param configurers the configurers
+     * @return the collected Allure results
+     */
     @SafeVarargs
     public static AllureResults runTests(
-            final Allure.ThrowableContextRunnableVoid<AllureLifecycle> runnable,
-            final Consumer<AllureLifecycle>... configurers) {
+                                         final Allure.ThrowableContextRunnableVoid<AllureLifecycle> runnable,
+                                         final Consumer<AllureLifecycle>... configurers) {
         return runTests(AllureLifecycle::new, runnable, configurers);
     }
 
+    /**
+     * Runs the supplied tests and returns collected Allure results.
+     *
+     * @param lifecycleFactory the lifecycle factory
+     * @param runnable the runnable
+     * @param configurers the configurers
+     * @return the collected Allure results
+     */
     @SafeVarargs
     public static AllureResults runTests(
-            final Function<AllureResultsWriter, AllureLifecycle> lifecycleFactory,
-            final Allure.ThrowableContextRunnableVoid<AllureLifecycle> runnable,
-            final Consumer<AllureLifecycle>... configurers) {
+                                         final Function<AllureResultsWriter, AllureLifecycle> lifecycleFactory,
+                                         final Allure.ThrowableContextRunnableVoid<AllureLifecycle> runnable,
+                                         final Consumer<AllureLifecycle>... configurers) {
         final AllureResultsWriterStub writer = new AllureResultsWriterStub();
         final AllureLifecycle lifecycle = lifecycleFactory.apply(writer);
 
@@ -93,29 +123,57 @@ public static AllureResults runTests(
         }
     }
 
+    /**
+     * Runs the callback inside an Allure test context and returns collected results.
+     *
+     * @param runnable the runnable
+     * @return the collected Allure results
+     */
     public static AllureResults runWithinTestContext(
-            final Runnable runnable) {
+                                                     final Runnable runnable) {
         return runTests(lifecycle -> withTestContext(runnable, lifecycle));
     }
 
+    /**
+     * Runs the callback inside an Allure test context and returns collected results.
+     *
+     * @param lifecycleFactory the lifecycle factory
+     * @param runnable the runnable
+     * @return the collected Allure results
+     */
     public static AllureResults runWithinTestContext(
-            final Function<AllureResultsWriter, AllureLifecycle> lifecycleFactory,
-            final Runnable runnable) {
+                                                     final Function<AllureResultsWriter, AllureLifecycle> lifecycleFactory,
+                                                     final Runnable runnable) {
         return runTests(lifecycleFactory, lifecycle -> withTestContext(runnable, lifecycle));
     }
 
+    /**
+     * Runs the callback inside an Allure test context and returns collected results.
+     *
+     * @param runnable the runnable
+     * @param configurers the configurers
+     * @return the collected Allure results
+     */
     @SafeVarargs
     public static AllureResults runWithinTestContext(
-            final Runnable runnable,
-            final Consumer<AllureLifecycle>... configurers) {
+                                                     final Runnable runnable,
+                                                     final Consumer<AllureLifecycle>... configurers) {
         return runTests(lifecycle -> withTestContext(runnable, lifecycle), configurers);
     }
 
+    /**
+     * Runs the callback inside an Allure test context and returns collected results.
+     *
+     * @param lifecycleFactory the lifecycle factory
+     * @param runnable the runnable
+     * @param configurers the configurers
+     * @return the collected Allure results
+     */
     @SafeVarargs
     public static AllureResults runWithinTestContext(
-            final Function<AllureResultsWriter, AllureLifecycle> lifecycleFactory,
-            final Runnable runnable,
-            final Consumer<AllureLifecycle>... configurers) {
+                                                     final Function<AllureResultsWriter, AllureLifecycle> lifecycleFactory,
+                                                     final Runnable runnable,
+                                                     final Consumer<AllureLifecycle>... configurers) {
         return runTests(lifecycleFactory, lifecycle -> withTestContext(runnable, lifecycle), configurers);
     }
 
diff --git a/allure-java-commons-test/src/main/java/io/qameta/allure/test/TestData.java b/allure-java-commons-test/src/main/java/io/qameta/allure/test/TestData.java
index 13b035c8..811a8e6d 100644
--- a/allure-java-commons-test/src/main/java/io/qameta/allure/test/TestData.java
+++ b/allure-java-commons-test/src/main/java/io/qameta/allure/test/TestData.java
@@ -18,7 +18,9 @@
 import org.apache.commons.lang3.RandomStringUtils;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Supports Allure Java test support integration with Allure reporting.
+ *
+ * <p>Use this type through the module that owns it when translating framework execution, result metadata, or attachments into Allure report data.</p>
  */
 public final class TestData {
 
@@ -26,14 +28,30 @@ private TestData() {
         throw new IllegalStateException("do not instance");
     }
 
+    /**
+     * Returns the random name.
+     *
+     * @return the random name
+     */
     public static String randomName() {
         return RandomStringUtils.randomAlphabetic(10);
     }
 
+    /**
+     * Returns the random id.
+     *
+     * @return the random id
+     */
     public static String randomId() {
         return randomString(10);
     }
 
+    /**
+     * Returns the random string.
+     *
+     * @param count the count
+     * @return the random string
+     */
     public static String randomString(final int count) {
         return RandomStringUtils.randomAlphanumeric(count);
     }
diff --git a/allure-java-commons-test/src/main/java/io/qameta/allure/test/ThreadLocalEnhancedRandom.java b/allure-java-commons-test/src/main/java/io/qameta/allure/test/ThreadLocalEnhancedRandom.java
index 1c9b2718..4b36e5f3 100644
--- a/allure-java-commons-test/src/main/java/io/qameta/allure/test/ThreadLocalEnhancedRandom.java
+++ b/allure-java-commons-test/src/main/java/io/qameta/allure/test/ThreadLocalEnhancedRandom.java
@@ -19,7 +19,9 @@
 import io.github.benas.randombeans.api.EnhancedRandom;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Supports Allure Java test support integration with Allure reporting.
+ *
+ * <p>Use this type through the module that owns it when translating framework execution, result metadata, or attachments into Allure report data.</p>
  */
 public final class ThreadLocalEnhancedRandom {
 
@@ -30,6 +32,11 @@ private ThreadLocalEnhancedRandom() {
         throw new IllegalStateException("do not instance");
     }
 
+    /**
+     * Returns the current.
+     *
+     * @return the current
+     */
     public static EnhancedRandom current() {
         return INSTANCE.get();
     }
diff --git a/allure-java-commons-test/src/test/java/io/qameta/allure/test/AllurePredicatesTest.java b/allure-java-commons-test/src/test/java/io/qameta/allure/test/AllurePredicatesTest.java
new file mode 100644
index 00000000..4f5048a5
--- /dev/null
+++ b/allure-java-commons-test/src/test/java/io/qameta/allure/test/AllurePredicatesTest.java
@@ -0,0 +1,41 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.test;
+
+import io.qameta.allure.model.Label;
+import io.qameta.allure.model.Status;
+import io.qameta.allure.model.TestResult;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class AllurePredicatesTest {
+
+    @Test
+    void shouldMatchStatusAndLabels() {
+        final TestResult result = new TestResult()
+                .setStatus(Status.PASSED)
+                .setLabels(List.of(new Label().setName("feature").setValue("attachments")));
+
+        assertTrue(AllurePredicates.hasStatus(Status.PASSED).test(result));
+        assertTrue(AllurePredicates.hasLabel("feature", "attachments").test(result));
+        assertFalse(AllurePredicates.hasStatus(Status.FAILED).test(result));
+        assertFalse(AllurePredicates.hasLabel("feature", "steps").test(result));
+    }
+}
diff --git a/allure-java-commons-test/src/test/java/io/qameta/allure/test/AllureResultsWriterStubTest.java b/allure-java-commons-test/src/test/java/io/qameta/allure/test/AllureResultsWriterStubTest.java
new file mode 100644
index 00000000..607d7013
--- /dev/null
+++ b/allure-java-commons-test/src/test/java/io/qameta/allure/test/AllureResultsWriterStubTest.java
@@ -0,0 +1,55 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.test;
+
+import io.qameta.allure.Allure;
+import io.qameta.allure.model.TestResult;
+import io.qameta.allure.model.TestResultContainer;
+import org.junit.jupiter.api.Test;
+
+import java.io.ByteArrayInputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
+
+class AllureResultsWriterStubTest {
+
+    @Test
+    void shouldStoreResultsContainersAndAttachments() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        final TestResult testResult = new TestResult()
+                .setUuid("test-uuid")
+                .setName("demo");
+        final TestResultContainer container = new TestResultContainer()
+                .setUuid("container-uuid")
+                .setChildren(List.of("test-uuid"));
+
+        Allure.step("Store a test result, its container, and an attachment", () -> {
+            writer.write(testResult);
+            writer.write(container);
+            writer.write("payload.txt", new ByteArrayInputStream("payload".getBytes(StandardCharsets.UTF_8)));
+        });
+
+        Allure.step("Verify the stub exposes the written runtime artifacts", () -> {
+            assertSame(testResult, writer.getTestResultByName("demo"));
+            assertEquals(List.of(container), writer.getTestResultContainersForTestResult(testResult));
+            assertArrayEquals("payload".getBytes(StandardCharsets.UTF_8), writer.getAttachments().get("payload.txt"));
+        });
+    }
+}
diff --git a/allure-java-commons-test/src/test/java/io/qameta/allure/test/RunUtilsTest.java b/allure-java-commons-test/src/test/java/io/qameta/allure/test/RunUtilsTest.java
new file mode 100644
index 00000000..265ae9f9
--- /dev/null
+++ b/allure-java-commons-test/src/test/java/io/qameta/allure/test/RunUtilsTest.java
@@ -0,0 +1,60 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.test;
+
+import io.qameta.allure.Allure;
+import io.qameta.allure.model.Status;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class RunUtilsTest {
+
+    @Test
+    void shouldCaptureFailureStatusWithinSyntheticTestContext() {
+        final AllureResults results = Allure.step("Execute a synthetic test context that raises an assertion error", () -> RunUtils.runWithinTestContext(() -> {
+            throw new AssertionError("boom");
+        })
+        );
+
+        Allure.step("Verify the captured synthetic test result is marked as failed", () -> {
+            assertEquals(1, results.getTestResults().size());
+            assertEquals(Status.FAILED, results.getTestResults().get(0).getStatus());
+            assertTrue(results.getTestResults().get(0).getStatusDetails().getMessage().contains("boom"));
+        });
+    }
+
+    @Test
+    void shouldAttachNestedRunArtifactsToOuterLifecycle() {
+        final AllureResults results = Allure
+                .step("Execute a nested synthetic run and capture its emitted attachments", () -> RunUtils.runWithinTestContext(() -> RunUtils.runWithinTestContext(() -> {
+                })
+                )
+                );
+
+        Allure.addAttachment("nested-attachment-keys", String.join("\n", results.getAttachments().keySet()));
+        Allure.step("Verify the outer lifecycle receives serialized artifacts from the nested run", () -> {
+            assertFalse(results.getAttachments().isEmpty());
+            assertTrue(
+                    results.getAttachments().values().stream()
+                            .map(bytes -> new String(bytes, java.nio.charset.StandardCharsets.UTF_8))
+                            .anyMatch(body -> body.contains("\"uuid\""))
+            );
+        });
+    }
+}
diff --git a/allure-java-commons-test/src/test/java/io/qameta/allure/test/TestUtilitiesTest.java b/allure-java-commons-test/src/test/java/io/qameta/allure/test/TestUtilitiesTest.java
new file mode 100644
index 00000000..2ecb6292
--- /dev/null
+++ b/allure-java-commons-test/src/test/java/io/qameta/allure/test/TestUtilitiesTest.java
@@ -0,0 +1,65 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.test;
+
+import io.github.benas.randombeans.api.EnhancedRandom;
+import io.qameta.allure.Allure;
+import org.junit.jupiter.api.Test;
+
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class TestUtilitiesTest {
+
+    @Test
+    void shouldGenerateStableThreadLocalRandomPerThread() throws Exception {
+        final EnhancedRandom mainThread = ThreadLocalEnhancedRandom.current();
+        final AtomicReference<EnhancedRandom> workerThread = new AtomicReference<>();
+        final Thread thread = new Thread(
+                () -> workerThread.set(ThreadLocalEnhancedRandom.current())
+        );
+
+        Allure.step("Resolve thread-local random generators on two threads and compare their identities", () -> {
+            thread.start();
+            thread.join();
+            Allure.addAttachment(
+                    "thread-local-random-identities",
+                    "main=" + System.identityHashCode(mainThread)
+                            + "\nworker=" + System.identityHashCode(workerThread.get())
+            );
+            assertSame(mainThread, ThreadLocalEnhancedRandom.current());
+            assertNotSame(mainThread, workerThread.get());
+        });
+    }
+
+    @Test
+    void shouldGenerateExpectedRandomTestDataShapes() {
+        final String name = TestData.randomName();
+        final String id = TestData.randomId();
+        final String value = TestData.randomString(16);
+
+        assertEquals(10, name.length());
+        assertEquals(10, id.length());
+        assertEquals(16, value.length());
+        assertTrue(name.matches("[A-Za-z]+"));
+        assertTrue(id.matches("[A-Za-z0-9]+"));
+        assertTrue(value.matches("[A-Za-z0-9]+"));
+    }
+}
diff --git a/allure-java-commons-test/src/test/resources/allure.properties b/allure-java-commons-test/src/test/resources/allure.properties
new file mode 100644
index 00000000..c1b2f8a0
--- /dev/null
+++ b/allure-java-commons-test/src/test/resources/allure.properties
@@ -0,0 +1,3 @@
+allure.results.directory=build/allure-results
+allure.label.epic=#project.description#
+allure.label.module=allure-java-commons-test
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/Allure.java b/allure-java-commons/src/main/java/io/qameta/allure/Allure.java
index 25092818..9d600b60 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/Allure.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/Allure.java
@@ -45,6 +45,7 @@
 /**
  * The class contains some useful methods to work with {@link AllureLifecycle}.
  */
+@SuppressWarnings("PMD.TooManyMethods")
 public final class Allure {
 
     private static final String TXT_EXTENSION = ".txt";
@@ -181,9 +182,11 @@ public static <T> T step(final ThrowableContextRunnable<T, StepContext> runnable
             getLifecycle().updateStep(uuid, step -> step.setStatus(Status.PASSED));
             return result;
         } catch (Throwable throwable) {
-            getLifecycle().updateStep(s -> s
-                    .setStatus(getStatus(throwable).orElse(Status.BROKEN))
-                    .setStatusDetails(getStatusDetails(throwable).orElse(null)));
+            getLifecycle().updateStep(
+                    s -> s
+                            .setStatus(getStatus(throwable).orElse(Status.BROKEN))
+                            .setStatusDetails(getStatusDetails(throwable).orElse(null))
+            );
             throw ExceptionUtils.sneakyThrow(throwable);
         } finally {
             getLifecycle().stopStep(uuid);
@@ -434,48 +437,116 @@ public static void addDescriptionHtml(final String descriptionHtml) {
         descriptionHtml(descriptionHtml);
     }
 
+    /**
+     * Adds the attachment.
+     *
+     * @param name the display name or logical name to use
+     * @param content the attachment content
+     */
     public static void addAttachment(final String name, final String content) {
         getLifecycle().addAttachment(name, TEXT_PLAIN, TXT_EXTENSION, content.getBytes(StandardCharsets.UTF_8));
     }
 
+    /**
+     * Adds the attachment.
+     *
+     * @param name the display name or logical name to use
+     * @param type the event or label type
+     * @param content the attachment content
+     */
     public static void addAttachment(final String name, final String type, final String content) {
         getLifecycle().addAttachment(name, type, TXT_EXTENSION, content.getBytes(StandardCharsets.UTF_8));
     }
 
+    /**
+     * Adds the attachment.
+     *
+     * @param name the display name or logical name to use
+     * @param type the event or label type
+     * @param content the attachment content
+     * @param fileExtension the attachment file extension
+     */
     @SuppressWarnings("PMD.UseObjectForClearerAPI")
     public static void addAttachment(final String name, final String type,
                                      final String content, final String fileExtension) {
         getLifecycle().addAttachment(name, type, fileExtension, content.getBytes(StandardCharsets.UTF_8));
     }
 
+    /**
+     * Adds the attachment.
+     *
+     * @param name the display name or logical name to use
+     * @param content the attachment content
+     */
     public static void addAttachment(final String name, final InputStream content) {
         getLifecycle().addAttachment(name, null, null, content);
     }
 
+    /**
+     * Adds the attachment.
+     *
+     * @param name the display name or logical name to use
+     * @param type the event or label type
+     * @param content the attachment content
+     * @param fileExtension the attachment file extension
+     */
     public static void addAttachment(final String name, final String type,
                                      final InputStream content, final String fileExtension) {
         getLifecycle().addAttachment(name, type, fileExtension, content);
     }
 
+    /**
+     * Adds the byte attachment async.
+     *
+     * @param name the display name or logical name to use
+     * @param type the event or label type
+     * @param body the attachment body
+     * @return this instance for method chaining
+     */
     public static CompletableFuture<byte[]> addByteAttachmentAsync(
-            final String name, final String type, final Supplier<byte[]> body) {
+                                                                   final String name, final String type, final Supplier<byte[]> body) {
         return addByteAttachmentAsync(name, type, "", body);
     }
 
+    /**
+     * Adds the byte attachment async.
+     *
+     * @param name the display name or logical name to use
+     * @param type the event or label type
+     * @param fileExtension the attachment file extension
+     * @param body the attachment body
+     * @return this instance for method chaining
+     */
     public static CompletableFuture<byte[]> addByteAttachmentAsync(
-            final String name, final String type, final String fileExtension, final Supplier<byte[]> body) {
+                                                                   final String name, final String type, final String fileExtension, final Supplier<byte[]> body) {
         final String source = getLifecycle().prepareAttachment(name, type, fileExtension);
-        return supplyAsync(body).whenComplete((result, ex) ->
-                getLifecycle().writeAttachment(source, new ByteArrayInputStream(result)));
+        return supplyAsync(body).whenComplete((result, ex) -> getLifecycle().writeAttachment(source, new ByteArrayInputStream(result)));
     }
 
+    /**
+     * Adds the stream attachment async.
+     *
+     * @param name the display name or logical name to use
+     * @param type the event or label type
+     * @param body the attachment body
+     * @return this instance for method chaining
+     */
     public static CompletableFuture<InputStream> addStreamAttachmentAsync(
-            final String name, final String type, final Supplier<InputStream> body) {
+                                                                          final String name, final String type, final Supplier<InputStream> body) {
         return addStreamAttachmentAsync(name, type, "", body);
     }
 
+    /**
+     * Adds the stream attachment async.
+     *
+     * @param name the display name or logical name to use
+     * @param type the event or label type
+     * @param fileExtension the attachment file extension
+     * @param body the attachment body
+     * @return this instance for method chaining
+     */
     public static CompletableFuture<InputStream> addStreamAttachmentAsync(
-            final String name, final String type, final String fileExtension, final Supplier<InputStream> body) {
+                                                                          final String name, final String type, final String fileExtension, final Supplier<InputStream> body) {
         final String source = lifecycle.prepareAttachment(name, type, fileExtension);
         return supplyAsync(body).whenComplete((result, ex) -> lifecycle.writeAttachment(source, result));
     }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/AllureConstants.java b/allure-java-commons/src/main/java/io/qameta/allure/AllureConstants.java
index 7d932178..f135b0d6 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/AllureConstants.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/AllureConstants.java
@@ -16,22 +16,41 @@
 package io.qameta.allure;
 
 /**
- * @author @author charlie (Dmitry Baev baev@qameta.io)
- * @since 1.0-BETA1
+ * Defines common file naming constants for Allure result artifacts.
+ *
+ * <p>Use these constants when reading or writing result JSON files, container JSON files, and attachment files so custom tooling follows the same naming conventions as the Allure lifecycle.</p>
  */
 @SuppressWarnings({"unused"})
 public final class AllureConstants {
 
+    /**
+     * File suffix used for test result artifacts.
+     */
     public static final String TEST_RESULT_FILE_SUFFIX = "-result.json";
 
+    /**
+     * Glob pattern used to find test result artifacts.
+     */
     public static final String TEST_RESULT_FILE_GLOB = "*-result.json";
 
+    /**
+     * File suffix used for test result container artifacts.
+     */
     public static final String TEST_RESULT_CONTAINER_FILE_SUFFIX = "-container.json";
 
+    /**
+     * Glob pattern used to find test result container artifacts.
+     */
     public static final String TEST_RESULT_CONTAINER_FILE_GLOB = "*-container.json";
 
+    /**
+     * File suffix used for attachment artifacts.
+     */
     public static final String ATTACHMENT_FILE_SUFFIX = "-attachment";
 
+    /**
+     * Glob pattern used to find attachment artifacts.
+     */
     public static final String ATTACHMENT_FILE_GLOB = "*-attachment*";
 
     private AllureConstants() {
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/AllureId.java b/allure-java-commons/src/main/java/io/qameta/allure/AllureId.java
index 6e84162c..79a663b6 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/AllureId.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/AllureId.java
@@ -34,6 +34,11 @@
 @LabelAnnotation(name = ALLURE_ID_LABEL_NAME)
 public @interface AllureId {
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     String value();
 
 }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/AllureLifecycle.java b/allure-java-commons/src/main/java/io/qameta/allure/AllureLifecycle.java
index dc3f9d3b..46e7d447 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/AllureLifecycle.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/AllureLifecycle.java
@@ -49,7 +49,7 @@
 /**
  * The class contains Allure context and methods to change it.
  */
-@SuppressWarnings("PMD.AvoidSynchronizedStatement")
+@SuppressWarnings({"PMD.AvoidSynchronizedStatement", "PMD.TooManyMethods"})
 public class AllureLifecycle {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(AllureLifecycle.class);
@@ -641,9 +641,11 @@ private static FileSystemResultsWriter getDefaultWriter() {
         final Properties properties = PropertiesUtils.loadAllureProperties();
         final String path = properties.getProperty("allure.results.directory", "allure-results");
         final boolean cleanBeforeRun = Boolean.parseBoolean(
-                properties.getProperty("allure.results.clean.before.run", "false"));
+                properties.getProperty("allure.results.clean.before.run", "false")
+        );
         final boolean cleanOnlyOnce = Boolean.parseBoolean(
-                properties.getProperty("allure.results.clean.only.once", "true"));
+                properties.getProperty("allure.results.clean.only.once", "true")
+        );
         return new FileSystemResultsWriter(Paths.get(path), cleanBeforeRun, cleanOnlyOnce);
     }
 
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/AllureResultsWriteException.java b/allure-java-commons/src/main/java/io/qameta/allure/AllureResultsWriteException.java
index 1b1299a4..aad583be 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/AllureResultsWriteException.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/AllureResultsWriteException.java
@@ -16,10 +16,18 @@
 package io.qameta.allure;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Signals that Allure results could not be written.
+ *
+ * <p>The file-system writer throws this unchecked exception when creating directories, writing JSON files, or copying attachment streams fails. Let it fail the current run because report output is incomplete.</p>
  */
 public class AllureResultsWriteException extends RuntimeException {
 
+    /**
+     * Creates an Allure results write exception with the supplied values.
+     *
+     * @param message the message
+     * @param cause the failure cause reported by the framework
+     */
     public AllureResultsWriteException(final String message, final Throwable cause) {
         super(message, cause);
     }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/AllureResultsWriter.java b/allure-java-commons/src/main/java/io/qameta/allure/AllureResultsWriter.java
index 5d191ba1..1dbfa600 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/AllureResultsWriter.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/AllureResultsWriter.java
@@ -21,7 +21,6 @@
 import java.io.InputStream;
 
 /**
- * @author charlie (Dmitry Baev).
  * @since 1.0-BETA2
  */
 public interface AllureResultsWriter {
@@ -31,7 +30,7 @@ public interface AllureResultsWriter {
      *
      * @param testResult the given bean to write.
      * @throws AllureResultsWriteException if some error occurs
-     *                                     during operation.
+     * during operation.
      */
     void write(TestResult testResult);
 
@@ -40,7 +39,7 @@ public interface AllureResultsWriter {
      *
      * @param testResultContainer the given bean to write.
      * @throws AllureResultsWriteException if some error occurs
-     *                                     during operation.
+     * during operation.
      */
     void write(TestResultContainer testResultContainer);
 
@@ -48,9 +47,9 @@ public interface AllureResultsWriter {
      * Writes given attachment. Will close the given stream.
      *
      * @param source     the file name of the attachment. Make sure that file name
-     *                   matches the following glob: <pre>*-attachment*</pre>. The right way
-     *                   to generate attachment is generate UUID, determinate attachment
-     *                   extension and then use it as <pre>{UUID}-attachment.{ext}</pre>
+     * matches the following glob: <pre>*-attachment*</pre>. The right way
+     * to generate attachment is generate UUID, determinate attachment
+     * extension and then use it as <pre>{UUID}-attachment.{ext}</pre>
      * @param attachment the steam that contains attachment body.
      */
     void write(String source, InputStream attachment);
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/Epic.java b/allure-java-commons/src/main/java/io/qameta/allure/Epic.java
index 5d9edb8a..837e2c44 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/Epic.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/Epic.java
@@ -36,6 +36,11 @@
 @LabelAnnotation(name = EPIC_LABEL_NAME)
 public @interface Epic {
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     String value();
 
 }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/Epics.java b/allure-java-commons/src/main/java/io/qameta/allure/Epics.java
index 9ea7c080..6440dd44 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/Epics.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/Epics.java
@@ -31,6 +31,11 @@
 @Target({ElementType.METHOD, ElementType.TYPE})
 public @interface Epics {
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     Epic[] value();
 
 }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/Feature.java b/allure-java-commons/src/main/java/io/qameta/allure/Feature.java
index 5161a2f6..b7b5b9f0 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/Feature.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/Feature.java
@@ -36,6 +36,11 @@
 @LabelAnnotation(name = FEATURE_LABEL_NAME)
 public @interface Feature {
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     String value();
 
 }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/Features.java b/allure-java-commons/src/main/java/io/qameta/allure/Features.java
index 093b0a74..bd066bdc 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/Features.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/Features.java
@@ -31,6 +31,11 @@
 @Target({ElementType.METHOD, ElementType.TYPE})
 public @interface Features {
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     Feature[] value();
 
 }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/FileSystemResultsWriter.java b/allure-java-commons/src/main/java/io/qameta/allure/FileSystemResultsWriter.java
index f4b0e331..a7ea9da8 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/FileSystemResultsWriter.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/FileSystemResultsWriter.java
@@ -29,11 +29,13 @@
 import java.util.Comparator;
 import java.util.Objects;
 import java.util.UUID;
-import java.util.stream.Stream;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.stream.Stream;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Writes Allure result model objects and attachments to the file system.
+ *
+ * <p>Create a writer with an output directory and pass it to an {@link AllureLifecycle} when results should be persisted as standard Allure files. The writer creates directories as needed and names files consistently with the Allure format.</p>
  */
 public class FileSystemResultsWriter implements AllureResultsWriter {
 
@@ -49,19 +51,34 @@ public class FileSystemResultsWriter implements AllureResultsWriter {
 
     private final AtomicBoolean cleaned = new AtomicBoolean(false);
 
+    /**
+     * Creates a file system results writer with the supplied values.
+     *
+     * @param outputDirectory the output directory
+     */
     public FileSystemResultsWriter(final Path outputDirectory) {
         this(outputDirectory, false, true);
     }
 
+    /**
+     * Creates a file system results writer with the supplied values.
+     *
+     * @param outputDirectory the output directory
+     * @param cleanBeforeRun the clean before run
+     * @param cleanOnlyOnce the clean only once
+     */
     public FileSystemResultsWriter(final Path outputDirectory,
-                                    final boolean cleanBeforeRun,
-                                    final boolean cleanOnlyOnce) {
+                                   final boolean cleanBeforeRun,
+                                   final boolean cleanOnlyOnce) {
         this.outputDirectory = outputDirectory;
         this.cleanBeforeRun = cleanBeforeRun;
         this.cleanOnlyOnce = cleanOnlyOnce;
         this.mapper = Allure2ModelJackson.createMapper();
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void write(final TestResult testResult) {
         final String testResultName = Objects.isNull(testResult.getUuid())
@@ -76,6 +93,9 @@ public void write(final TestResult testResult) {
         }
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void write(final TestResultContainer testResultContainer) {
         final String testResultContainerName = Objects.isNull(testResultContainer.getUuid())
@@ -90,6 +110,9 @@ public void write(final TestResultContainer testResultContainer) {
         }
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void write(final String source, final InputStream attachment) {
         ensureInitialized();
@@ -138,18 +161,40 @@ private void cleanDirectoryContents(final Path directory) {
         }
     }
 
+    /**
+     * Generates and returns the test result name.
+     *
+     * @return the generated test result name
+     */
     protected static String generateTestResultName() {
         return generateTestResultName(UUID.randomUUID().toString());
     }
 
+    /**
+     * Generates and returns the test result name.
+     *
+     * @param uuid the Allure UUID of the model object
+     * @return the generated test result name
+     */
     protected static String generateTestResultName(final String uuid) {
         return uuid + AllureConstants.TEST_RESULT_FILE_SUFFIX;
     }
 
+    /**
+     * Generates and returns the test result container name.
+     *
+     * @return the generated test result container name
+     */
     protected static String generateTestResultContainerName() {
         return generateTestResultContainerName(UUID.randomUUID().toString());
     }
 
+    /**
+     * Generates and returns the test result container name.
+     *
+     * @param uuid the Allure UUID of the model object
+     * @return the generated test result container name
+     */
     protected static String generateTestResultContainerName(final String uuid) {
         return uuid + AllureConstants.TEST_RESULT_CONTAINER_FILE_SUFFIX;
     }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/Issue.java b/allure-java-commons/src/main/java/io/qameta/allure/Issue.java
index f909aad4..785e2518 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/Issue.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/Issue.java
@@ -36,6 +36,11 @@
 @Repeatable(Issues.class)
 public @interface Issue {
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     String value();
 
 }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/Issues.java b/allure-java-commons/src/main/java/io/qameta/allure/Issues.java
index 1f2c29f5..e73f558b 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/Issues.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/Issues.java
@@ -31,6 +31,11 @@
 @Target({ElementType.METHOD, ElementType.TYPE})
 public @interface Issues {
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     Issue[] value();
 
 }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/LabelAnnotations.java b/allure-java-commons/src/main/java/io/qameta/allure/LabelAnnotations.java
index 75f75b1d..9757d42f 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/LabelAnnotations.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/LabelAnnotations.java
@@ -31,6 +31,11 @@
 @Target({ElementType.ANNOTATION_TYPE})
 public @interface LabelAnnotations {
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     LabelAnnotation[] value();
 
 }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/Lead.java b/allure-java-commons/src/main/java/io/qameta/allure/Lead.java
index 27f53c05..11062b5a 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/Lead.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/Lead.java
@@ -36,6 +36,11 @@
 @LabelAnnotation(name = LEAD_LABEL_NAME)
 public @interface Lead {
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     String value();
 
 }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/LinkAnnotations.java b/allure-java-commons/src/main/java/io/qameta/allure/LinkAnnotations.java
index a1a2ccf6..c8826f31 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/LinkAnnotations.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/LinkAnnotations.java
@@ -31,6 +31,11 @@
 @Target({ElementType.ANNOTATION_TYPE})
 public @interface LinkAnnotations {
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     LinkAnnotation[] value();
 
 }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/Links.java b/allure-java-commons/src/main/java/io/qameta/allure/Links.java
index 76f1f7de..20b4cbd5 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/Links.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/Links.java
@@ -31,6 +31,11 @@
 @Target({ElementType.METHOD, ElementType.TYPE})
 public @interface Links {
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     Link[] value();
 
 }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/Owner.java b/allure-java-commons/src/main/java/io/qameta/allure/Owner.java
index 7101a5b8..541abfd9 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/Owner.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/Owner.java
@@ -37,6 +37,11 @@
 @LabelAnnotation(name = OWNER_LABEL_NAME)
 public @interface Owner {
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     String value();
 
 }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/Severity.java b/allure-java-commons/src/main/java/io/qameta/allure/Severity.java
index ccfb284d..9fd0c922 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/Severity.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/Severity.java
@@ -31,6 +31,11 @@
 @Target({ElementType.METHOD, ElementType.TYPE})
 public @interface Severity {
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     SeverityLevel value();
 
 }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/SeverityLevel.java b/allure-java-commons/src/main/java/io/qameta/allure/SeverityLevel.java
index 1abd896a..2876d929 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/SeverityLevel.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/SeverityLevel.java
@@ -16,7 +16,9 @@
 package io.qameta.allure;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Enumerates standard Allure severity levels.
+ *
+ * <p>Use these values with {@link Severity} to mark the business impact of a test case. The enum value is serialized as the lowercase Allure label value expected by report tooling.</p>
  */
 public enum SeverityLevel {
 
@@ -32,10 +34,18 @@ public enum SeverityLevel {
         value = v;
     }
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     public String value() {
         return value;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public String toString() {
         return value();
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/Step.java b/allure-java-commons/src/main/java/io/qameta/allure/Step.java
index 83e62af9..0c67ee35 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/Step.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/Step.java
@@ -29,6 +29,11 @@
 @Target(ElementType.METHOD)
 public @interface Step {
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     String value() default "";
 
 }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/Stories.java b/allure-java-commons/src/main/java/io/qameta/allure/Stories.java
index 5d352814..cf6006d9 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/Stories.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/Stories.java
@@ -31,6 +31,11 @@
 @Target({ElementType.METHOD, ElementType.TYPE})
 public @interface Stories {
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     Story[] value();
 
 }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/Story.java b/allure-java-commons/src/main/java/io/qameta/allure/Story.java
index 8d19605d..15221c2d 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/Story.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/Story.java
@@ -36,6 +36,11 @@
 @LabelAnnotation(name = STORY_LABEL_NAME)
 public @interface Story {
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     String value();
 
 }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/TmsLink.java b/allure-java-commons/src/main/java/io/qameta/allure/TmsLink.java
index 273354d0..869e64d9 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/TmsLink.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/TmsLink.java
@@ -36,6 +36,11 @@
 @Repeatable(TmsLinks.class)
 public @interface TmsLink {
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     String value();
 
 }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/TmsLinks.java b/allure-java-commons/src/main/java/io/qameta/allure/TmsLinks.java
index f862c3aa..998b2f92 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/TmsLinks.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/TmsLinks.java
@@ -31,6 +31,11 @@
 @Target({ElementType.METHOD, ElementType.TYPE})
 public @interface TmsLinks {
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     TmsLink[] value();
 
 }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/aspects/AttachmentsAspects.java b/allure-java-commons/src/main/java/io/qameta/allure/aspects/AttachmentsAspects.java
index 106a8069..137f4343 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/aspects/AttachmentsAspects.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/aspects/AttachmentsAspects.java
@@ -33,14 +33,11 @@
 /**
  * Aspects (AspectJ) for handling {@link Attachment}.
  *
- * @author Dmitry Baev charlie@yandex-team.ru
- * Date: 24.10.13
  */
 @Aspect
 public class AttachmentsAspects {
 
-    private static final InheritableThreadLocal<AllureLifecycle> LIFECYCLE =
-            new InheritableThreadLocal<AllureLifecycle>() {
+    private static final InheritableThreadLocal<AllureLifecycle> LIFECYCLE = new InheritableThreadLocal<AllureLifecycle>() {
         @Override
         protected AllureLifecycle initialValue() {
             return Allure.getLifecycle();
@@ -70,13 +67,25 @@ public void anyMethod() {
      * @param joinPoint the join point to process.
      * @param result    the returned value.
      */
-    @AfterReturning(pointcut = "anyMethod() && withAttachmentAnnotation()", returning = "result")
+    @AfterReturning(
+            pointcut = "anyMethod() && withAttachmentAnnotation()",
+            returning = "result"
+    )
+
+    /**
+     * Handles the attachment callback.
+     *
+     * @param joinPoint the join point
+     * @param result the model object or framework result to process
+     */
     public void attachment(final JoinPoint joinPoint, final Object result) {
         final MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
         final Attachment attachment = methodSignature.getMethod()
                 .getAnnotation(Attachment.class);
-        final byte[] bytes = (result instanceof byte[]) ? (byte[]) result : Objects.toString(result)
-                .getBytes(StandardCharsets.UTF_8);
+        final byte[] bytes = (result instanceof byte[])
+                ? (byte[]) result
+                : Objects.toString(result)
+                        .getBytes(StandardCharsets.UTF_8);
 
         final String name = attachment.value().isEmpty()
                 ? methodSignature.getName()
@@ -93,6 +102,11 @@ public static void setLifecycle(final AllureLifecycle allure) {
         LIFECYCLE.set(allure);
     }
 
+    /**
+     * Returns the lifecycle.
+     *
+     * @return the Allure lifecycle used by this integration
+     */
     public static AllureLifecycle getLifecycle() {
         return LIFECYCLE.get();
     }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/aspects/StepsAspects.java b/allure-java-commons/src/main/java/io/qameta/allure/aspects/StepsAspects.java
index 8f59189d..331b9569 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/aspects/StepsAspects.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/aspects/StepsAspects.java
@@ -38,31 +38,41 @@
 import static io.qameta.allure.util.ResultsUtils.getStatusDetails;
 
 /**
- * @author Dmitry Baev charlie@yandex-team.ru
- * Date: 24.10.13
- * @author sskorol (Sergey Korol)
+ * AspectJ advice that turns {@link io.qameta.allure.Step} methods into Allure steps.
+ *
+ * <p>The aspect is woven around annotated methods, starts a step before invocation, updates its name and parameters, and records the final status after the method returns or throws.</p>
  */
 @Aspect
 public class StepsAspects {
 
-    private static final InheritableThreadLocal<AllureLifecycle> LIFECYCLE
-            = new InheritableThreadLocal<AllureLifecycle>() {
+    private static final InheritableThreadLocal<AllureLifecycle> LIFECYCLE = new InheritableThreadLocal<AllureLifecycle>() {
         @Override
         protected AllureLifecycle initialValue() {
             return Allure.getLifecycle();
         }
     };
 
+    /**
+     * Configures the step annotation.
+     */
     @Pointcut("@annotation(io.qameta.allure.Step)")
     public void withStepAnnotation() {
         //pointcut body, should be empty
     }
 
+    /**
+     * Handles the any method callback.
+     */
     @Pointcut("execution(* *(..))")
     public void anyMethod() {
         //pointcut body, should be empty
     }
 
+    /**
+     * Handles the step start callback.
+     *
+     * @param joinPoint the join point
+     */
     @Before("anyMethod() && withStepAnnotation()")
     public void stepStart(final JoinPoint joinPoint) {
         final MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
@@ -79,14 +89,28 @@ public void stepStart(final JoinPoint joinPoint) {
         getLifecycle().startStep(uuid, result);
     }
 
-    @AfterThrowing(pointcut = "anyMethod() && withStepAnnotation()", throwing = "e")
+    @AfterThrowing(
+            pointcut = "anyMethod() && withStepAnnotation()",
+            throwing = "e"
+    )
+
+    /**
+     * Handles the step failed callback.
+     *
+     * @param e the e
+     */
     public void stepFailed(final Throwable e) {
-        getLifecycle().updateStep(s -> s
-                .setStatus(getStatus(e).orElse(Status.BROKEN))
-                .setStatusDetails(getStatusDetails(e).orElse(null)));
+        getLifecycle().updateStep(
+                s -> s
+                        .setStatus(getStatus(e).orElse(Status.BROKEN))
+                        .setStatusDetails(getStatusDetails(e).orElse(null))
+        );
         getLifecycle().stopStep();
     }
 
+    /**
+     * Handles the step stop callback.
+     */
     @AfterReturning(pointcut = "anyMethod() && withStepAnnotation()")
     public void stepStop() {
         getLifecycle().updateStep(s -> s.setStatus(Status.PASSED));
@@ -102,6 +126,11 @@ public static void setLifecycle(final AllureLifecycle allure) {
         LIFECYCLE.set(allure);
     }
 
+    /**
+     * Returns the lifecycle.
+     *
+     * @return the Allure lifecycle used by this integration
+     */
     public static AllureLifecycle getLifecycle() {
         return LIFECYCLE.get();
     }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/internal/Allure2ModelJackson.java b/allure-java-commons/src/main/java/io/qameta/allure/internal/Allure2ModelJackson.java
index 21d2250f..2bb7c13e 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/internal/Allure2ModelJackson.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/internal/Allure2ModelJackson.java
@@ -35,16 +35,23 @@
 /**
  * The type Allure 2 model jackson.
  *
- * @author baev (Dmitry Baev).
  */
 public final class Allure2ModelJackson {
 
+    /**
+     * Constant value for indent output property name.
+     */
     public static final String INDENT_OUTPUT_PROPERTY_NAME = "allure.results.indentOutput";
 
     private Allure2ModelJackson() {
         throw new IllegalStateException("Do not instance Allure2ModelJackson");
     }
 
+    /**
+     * Creates and returns the mapper.
+     *
+     * @return the mapper
+     */
     public static ObjectMapper createMapper() {
         return JsonMapper
                 .builder()
@@ -52,10 +59,11 @@ public static ObjectMapper createMapper() {
                 .serializationInclusion(NON_NULL)
                 .configure(INDENT_OUTPUT, Boolean.getBoolean(INDENT_OUTPUT_PROPERTY_NAME))
                 .build()
-                .registerModule(new SimpleModule()
-                        .addSerializer(Status.class, new StatusSerializer())
-                        .addSerializer(Stage.class, new StageSerializer())
-                        .addSerializer(Parameter.Mode.class, new ParameterModeSerializer())
+                .registerModule(
+                        new SimpleModule()
+                                .addSerializer(Status.class, new StatusSerializer())
+                                .addSerializer(Stage.class, new StageSerializer())
+                                .addSerializer(Parameter.Mode.class, new ParameterModeSerializer())
                 );
     }
 
@@ -70,7 +78,8 @@ protected ParameterModeSerializer() {
         @Override
         public void serialize(final Parameter.Mode value,
                               final JsonGenerator gen,
-                              final SerializerProvider provider) throws IOException {
+                              final SerializerProvider provider)
+                throws IOException {
             gen.writeString(value.name().toLowerCase(Locale.ENGLISH));
         }
     }
@@ -86,7 +95,8 @@ protected StageSerializer() {
         @Override
         public void serialize(final Stage value,
                               final JsonGenerator gen,
-                              final SerializerProvider provider) throws IOException {
+                              final SerializerProvider provider)
+                throws IOException {
             gen.writeString(value.name().toLowerCase(Locale.ENGLISH));
         }
     }
@@ -102,7 +112,8 @@ protected StatusSerializer() {
         @Override
         public void serialize(final Status value,
                               final JsonGenerator gen,
-                              final SerializerProvider provider) throws IOException {
+                              final SerializerProvider provider)
+                throws IOException {
             gen.writeString(value.name().toLowerCase(Locale.ENGLISH));
         }
     }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/internal/AllureStorage.java b/allure-java-commons/src/main/java/io/qameta/allure/internal/AllureStorage.java
index 458d0694..037700e7 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/internal/AllureStorage.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/internal/AllureStorage.java
@@ -38,22 +38,53 @@ public class AllureStorage {
 
     private final ReadWriteLock lock = new ReentrantReadWriteLock();
 
+    /**
+     * Returns the container.
+     *
+     * @param uuid the Allure UUID of the model object
+     * @return the container
+     */
     public Optional<TestResultContainer> getContainer(final String uuid) {
         return get(uuid, TestResultContainer.class);
     }
 
+    /**
+     * Returns the test.
+     *
+     * @param uuid the Allure UUID of the model object
+     * @return the test
+     */
     public Optional<TestResult> getTestResult(final String uuid) {
         return get(uuid, TestResult.class);
     }
 
+    /**
+     * Returns the fixture.
+     *
+     * @param uuid the Allure UUID of the model object
+     * @return the fixture
+     */
     public Optional<FixtureResult> getFixture(final String uuid) {
         return get(uuid, FixtureResult.class);
     }
 
+    /**
+     * Returns the step.
+     *
+     * @param uuid the Allure UUID of the model object
+     * @return the step
+     */
     public Optional<StepResult> getStep(final String uuid) {
         return get(uuid, StepResult.class);
     }
 
+    /**
+     * Returns the get.
+     *
+     * @param uuid the Allure UUID of the model object
+     * @param clazz the clazz
+     * @return the get
+     */
     public <T> Optional<T> get(final String uuid, final Class<T> clazz) {
         Objects.requireNonNull(uuid, "Can't get item from storage: uuid can't be null");
         lock.readLock().lock();
@@ -66,6 +97,13 @@ public <T> Optional<T> get(final String uuid, final Class<T> clazz) {
         }
     }
 
+    /**
+     * Returns the put.
+     *
+     * @param uuid the Allure UUID of the model object
+     * @param item the item
+     * @return the put
+     */
     public <T> T put(final String uuid, final T item) {
         Objects.requireNonNull(uuid, "Can't put item to storage: uuid can't be null");
         lock.writeLock().lock();
@@ -77,6 +115,11 @@ public <T> T put(final String uuid, final T item) {
         }
     }
 
+    /**
+     * Handles the remove callback.
+     *
+     * @param uuid the Allure UUID of the model object
+     */
     public void remove(final String uuid) {
         Objects.requireNonNull(uuid, "Can't remove item from storage: uuid can't be null");
         lock.writeLock().lock();
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/internal/AllureThreadContext.java b/allure-java-commons/src/main/java/io/qameta/allure/internal/AllureThreadContext.java
index 51dd8741..e1380f81 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/internal/AllureThreadContext.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/internal/AllureThreadContext.java
@@ -23,7 +23,6 @@
 /**
  * Storage that stores information about not finished tests and steps.
  *
- * @author charlie (Dmitry Baev).
  */
 public class AllureThreadContext {
 
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/listener/LifecycleListener.java b/allure-java-commons/src/main/java/io/qameta/allure/listener/LifecycleListener.java
index 3029dad9..d0ef6dc4 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/listener/LifecycleListener.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/listener/LifecycleListener.java
@@ -18,7 +18,6 @@
 /**
  * Marker interface for lifecycle listeners.
  *
- * @author charlie (Dmitry Baev).
  */
 public interface LifecycleListener {
 }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/listener/LifecycleNotifier.java b/allure-java-commons/src/main/java/io/qameta/allure/listener/LifecycleNotifier.java
index 29174ece..7684b66d 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/listener/LifecycleNotifier.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/listener/LifecycleNotifier.java
@@ -28,8 +28,13 @@
 /**
  * @since 2.0
  */
-public class LifecycleNotifier implements ContainerLifecycleListener,
-        TestLifecycleListener, FixtureLifecycleListener, StepLifecycleListener {
+@SuppressWarnings("PMD.TooManyMethods")
+public class LifecycleNotifier
+        implements
+            ContainerLifecycleListener,
+            TestLifecycleListener,
+            FixtureLifecycleListener,
+            StepLifecycleListener {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(LifecycleNotifier.class);
 
@@ -51,7 +56,6 @@ public LifecycleNotifier(final List<ContainerLifecycleListener> containerListene
         this.stepListeners = stepListeners;
     }
 
-
     @Override
     public void beforeTestSchedule(final TestResult result) {
         runSafely(testListeners, TestLifecycleListener::beforeTestSchedule, result);
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/util/AnnotationUtils.java b/allure-java-commons/src/main/java/io/qameta/allure/util/AnnotationUtils.java
index b032b35c..91fec588 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/util/AnnotationUtils.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/util/AnnotationUtils.java
@@ -45,7 +45,6 @@
  * Collection of utils used by Allure integration to extract meta information from
  * test cases via reflection.
  *
- * @author charlie (Dmitry Baev).
  */
 public final class AnnotationUtils {
 
@@ -141,9 +140,9 @@ public static Set<Label> getLabels(final Collection<Annotation> annotations) {
     }
 
     private static <T, U extends Annotation> Stream<T> extractMetaAnnotations(
-            final Class<U> annotationType,
-            final BiFunction<U, Annotation, Stream<T>> mapper,
-            final Collection<Annotation> candidates) {
+                                                                              final Class<U> annotationType,
+                                                                              final BiFunction<U, Annotation, Stream<T>> mapper,
+                                                                              final Collection<Annotation> candidates) {
         final Set<Annotation> visited = new HashSet<>();
         return candidates.stream()
                 .flatMap(AnnotationUtils::extractRepeatable)
@@ -151,15 +150,18 @@ private static <T, U extends Annotation> Stream<T> extractMetaAnnotations(
     }
 
     private static <T, U extends Annotation> Stream<T> extractMetaAnnotations(
-            final Class<U> annotationType,
-            final BiFunction<U, Annotation, Stream<T>> mapper,
-            final Annotation candidate,
-            final Set<Annotation> visited) {
+                                                                              final Class<U> annotationType,
+                                                                              final BiFunction<U, Annotation, Stream<T>> mapper,
+                                                                              final Annotation candidate,
+                                                                              final Set<Annotation> visited) {
         if (!isInJavaLangAnnotationPackage(candidate.annotationType()) && visited.add(candidate)) {
             final Stream<T> children = Stream.of(candidate.annotationType().getAnnotations())
                     .flatMap(AnnotationUtils::extractRepeatable)
-                    .flatMap(annotation -> extractMetaAnnotations(
-                            annotationType, mapper, annotation, visited));
+                    .flatMap(
+                            annotation -> extractMetaAnnotations(
+                                    annotationType, mapper, annotation, visited
+                            )
+                    );
             final Stream<T> current = Stream.of(candidate.annotationType().getAnnotationsByType(annotationType))
                     .flatMap(marker -> mapper.apply(marker, candidate));
             return Stream.concat(current, children);
@@ -203,10 +205,12 @@ private static Stream<String> callValueMethod(final Annotation annotation) {
         }
     }
 
-    @SuppressWarnings({
-            "CyclomaticComplexity",
-            "ReturnCount",
-    })
+    @SuppressWarnings(
+        {
+                "CyclomaticComplexity",
+                "ReturnCount",
+        }
+    )
     private static Stream<String> objectToStringStream(final Object object) {
         if (Objects.nonNull(object) && object.getClass().isArray()) {
             if (object instanceof Object[]) {
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/util/AspectUtils.java b/allure-java-commons/src/main/java/io/qameta/allure/util/AspectUtils.java
index 97921fc1..0fd27ae8 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/util/AspectUtils.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/util/AspectUtils.java
@@ -32,7 +32,9 @@
 import static io.qameta.allure.util.ResultsUtils.createParameter;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Utility methods used by AspectJ-based Allure integrations.
+ *
+ * <p>The helpers resolve step names from templates, extract method parameters, and format arguments so aspect advice can create meaningful Allure steps and parameters.</p>
  */
 public final class AspectUtils {
 
@@ -40,6 +42,13 @@ private AspectUtils() {
         throw new IllegalStateException("Do not instance");
     }
 
+    /**
+     * Returns the name.
+     *
+     * @param nameTemplate the name template
+     * @param joinPoint the join point
+     * @return the attachment or display name
+     */
     public static String getName(final String nameTemplate, final JoinPoint joinPoint) {
         return Optional.of(nameTemplate)
                 .filter(v -> !v.isEmpty())
@@ -62,6 +71,12 @@ public static Map<String, Object> getParametersMap(final MethodSignature signatu
         return params;
     }
 
+    /**
+     * Returns the parameters map.
+     *
+     * @param joinPoint the join point
+     * @return the parameters map
+     */
     public static Map<String, Object> getParametersMap(final JoinPoint joinPoint) {
         final MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
         final Map<String, Object> params = getParametersMap(methodSignature, joinPoint.getArgs());
@@ -69,6 +84,13 @@ public static Map<String, Object> getParametersMap(final JoinPoint joinPoint) {
         return params;
     }
 
+    /**
+     * Returns the parameters.
+     *
+     * @param signature the signature
+     * @param args the args
+     * @return the parameters
+     */
     public static List<Parameter> getParameters(final MethodSignature signature, final Object... args) {
         final java.lang.reflect.Parameter[] params = signature.getMethod().getParameters();
         return IntStream
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/util/ExceptionUtils.java b/allure-java-commons/src/main/java/io/qameta/allure/util/ExceptionUtils.java
index 3739ab54..2de91d49 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/util/ExceptionUtils.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/util/ExceptionUtils.java
@@ -16,7 +16,9 @@
 package io.qameta.allure.util;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Utility methods for translating exceptions into Allure status details.
+ *
+ * <p>Use these helpers when an integration needs the same message, trace, and known/unknown failure classification that the built-in lifecycle code applies.</p>
  */
 public final class ExceptionUtils {
 
@@ -24,6 +26,13 @@ private ExceptionUtils() {
         throw new IllegalStateException("Do not instance");
     }
 
+    /**
+     * Returns the sneaky throw.
+     *
+     * @param throwable the throwable
+     * @return the sneaky throw
+     * @throws T if the underlying framework operation fails
+     */
     @SuppressWarnings("unchecked")
     public static <T extends Throwable> T sneakyThrow(final Throwable throwable) throws T {
         throw (T) throwable;
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/util/NamingUtils.java b/allure-java-commons/src/main/java/io/qameta/allure/util/NamingUtils.java
index 6946aca2..360f6c52 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/util/NamingUtils.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/util/NamingUtils.java
@@ -18,7 +18,6 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.lang.reflect.Field;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
@@ -31,7 +30,9 @@
 import java.util.stream.StreamSupport;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Utility methods for resolving human-readable test and step names.
+ *
+ * <p>Use these helpers when framework metadata, annotations, and Java reflection names need to be combined into the display names shown in an Allure report.</p>
  */
 public final class NamingUtils {
 
@@ -43,6 +44,13 @@ private NamingUtils() {
         throw new IllegalStateException("Do not instance");
     }
 
+    /**
+     * Returns the process name template.
+     *
+     * @param template the template
+     * @param params the params
+     * @return the process name template
+     */
     public static String processNameTemplate(final String template, final Map<String, Object> params) {
         final Matcher matcher = Pattern.compile("\\{([^}]*)}").matcher(template);
         final StringBuffer sb = new StringBuffer();
@@ -94,42 +102,12 @@ private static String extractProperties(final Object object, final String[] part
     }
 
     private static Object extractChild(final Object object, final String part) {
-        final Class<?> type = object == null ? Object.class : object.getClass();
+        Objects.requireNonNull(object, "object");
+        final Class<?> type = object.getClass();
         try {
-            return extractField(object, part, type);
+            return ReflectionUtils.getFieldValue(object, part);
         } catch (ReflectiveOperationException e) {
             throw new IllegalStateException("Unable to extract " + part + " value from " + type.getName(), e);
         }
     }
-
-    @SuppressWarnings("PMD.EmptyCatchBlock")
-    private static Object extractField(final Object object, final String part, final Class<?> type)
-            throws ReflectiveOperationException {
-        try {
-            final Field field = type.getField(part);
-            return fieldValue(object, field);
-        } catch (NoSuchFieldException e) {
-            Class<?> t = type;
-            while (t != null) {
-                try {
-                    final Field declaredField = t.getDeclaredField(part);
-                    return fieldValue(object, declaredField);
-                } catch (NoSuchFieldException ignore) {
-                    // Ignore
-                }
-                t = t.getSuperclass();
-            }
-            throw e;
-        }
-    }
-
-    @SuppressWarnings("PMD.AvoidAccessibilityAlteration")
-    private static Object fieldValue(final Object object, final Field field) throws IllegalAccessException {
-        try {
-            return field.get(object);
-        } catch (IllegalAccessException e) {
-            field.setAccessible(true);
-            return field.get(object);
-        }
-    }
 }
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/util/ObjectUtils.java b/allure-java-commons/src/main/java/io/qameta/allure/util/ObjectUtils.java
index f409d81b..fec12a2a 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/util/ObjectUtils.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/util/ObjectUtils.java
@@ -24,7 +24,9 @@
 import java.util.stream.Collectors;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Utility methods for safe object string conversion.
+ *
+ * <p>Use these helpers from integrations and attachment builders when values may be arrays, maps, null, or objects whose {@code toString()} method can fail.</p>
  */
 public final class ObjectUtils {
 
@@ -43,15 +45,26 @@ private ObjectUtils() {
      * @param object the given object.
      * @return the string representation of given object.
      */
-    @SuppressWarnings({
-            "CyclomaticComplexity",
-            "ReturnCount",
-    })
+    @SuppressWarnings(
+        {
+                "CyclomaticComplexity",
+                "ReturnCount",
+        }
+    )
+
+    /**
+     * Converts and returns the string.
+     *
+     * @param object the object to convert
+     * @return a string representation of this object
+     */
     public static String toString(final Object object) {
         try {
             if (Objects.nonNull(object) && object.getClass().isArray()) {
                 if (object instanceof Object[]) {
-                    return Arrays.toString((Object[]) object);
+                    return Arrays.stream((Object[]) object)
+                            .map(ObjectUtils::toString)
+                            .collect(Collectors.joining(", ", "[", "]"));
                 } else if (object instanceof long[]) {
                     return Arrays.toString((long[]) object);
                 } else if (object instanceof short[]) {
@@ -77,6 +90,12 @@ public static String toString(final Object object) {
         }
     }
 
+    /**
+     * Returns the map to string.
+     *
+     * @param map the map
+     * @return the map to string
+     */
     public static String mapToString(final Map<String, String> map) {
         if (map == null || map.isEmpty()) {
             return "{}";
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/util/ParameterUtils.java b/allure-java-commons/src/main/java/io/qameta/allure/util/ParameterUtils.java
index 0ac0c43e..64bcf457 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/util/ParameterUtils.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/util/ParameterUtils.java
@@ -26,7 +26,9 @@
 import java.util.stream.Stream;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Utility methods for converting Java method arguments into Allure parameters.
+ *
+ * <p>Aspect and framework integrations use this class to apply {@link io.qameta.allure.Param} metadata, excluded flags, modes, and display names consistently.</p>
  */
 public final class ParameterUtils {
 
@@ -34,6 +36,13 @@ private ParameterUtils() {
         throw new IllegalStateException("do not instance");
     }
 
+    /**
+     * Creates and returns the parameters.
+     *
+     * @param method the framework or Java method to inspect
+     * @param args the args
+     * @return the parameters
+     */
     public static List<Parameter> createParameters(final Method method,
                                                    final Object... args) {
         final java.lang.reflect.Parameter[] parameters = method.getParameters();
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/util/PropertiesUtils.java b/allure-java-commons/src/main/java/io/qameta/allure/util/PropertiesUtils.java
index 9bae9abd..7d8f1f2b 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/util/PropertiesUtils.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/util/PropertiesUtils.java
@@ -34,6 +34,11 @@ public final class PropertiesUtils {
     private PropertiesUtils() {
     }
 
+    /**
+     * Loads and returns the allure properties.
+     *
+     * @return the loaded allure properties
+     */
     public static Properties loadAllureProperties() {
         final Properties properties = new Properties();
         loadPropertiesFrom(ClassLoader.getSystemClassLoader(), properties);
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/util/ReflectionUtils.java b/allure-java-commons/src/main/java/io/qameta/allure/util/ReflectionUtils.java
new file mode 100644
index 00000000..ec229664
--- /dev/null
+++ b/allure-java-commons/src/main/java/io/qameta/allure/util/ReflectionUtils.java
@@ -0,0 +1,181 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.util;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Optional;
+
+/**
+ * Common reflection helpers.
+ */
+final class ReflectionUtils {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(ReflectionUtils.class);
+    private static final String GET_PREFIX = "get";
+    private static final String IS_PREFIX = "is";
+    private static final String METHOD_READ_ERROR = "Unable to read value via method {}";
+    private static final String FIELD_READ_ERROR = "Unable to read value via field {}";
+
+    private ReflectionUtils() {
+        throw new IllegalStateException("Do not instance");
+    }
+
+    static Object getValue(final Object target, final String propertyName) {
+        if (target == null || propertyName == null || propertyName.isEmpty()) {
+            return null;
+        }
+        final Optional<Method> method = findGetter(target.getClass(), propertyName);
+        if (method.isPresent()) {
+            try {
+                return invokeMethod(target, method.get());
+            } catch (ReflectiveOperationException | SecurityException e) {
+                LOGGER.trace(METHOD_READ_ERROR, method.get().getName(), e);
+                return null;
+            }
+        }
+        try {
+            return getFieldValue(target, propertyName);
+        } catch (ReflectiveOperationException | SecurityException e) {
+            LOGGER.trace(FIELD_READ_ERROR, propertyName, e);
+            return null;
+        }
+    }
+
+    static Boolean getBooleanValue(final Object target, final String propertyName) {
+        if (target == null || propertyName == null || propertyName.isEmpty()) {
+            return absentBooleanValue();
+        }
+        final Optional<Method> method = findPrimitiveBooleanGetter(target.getClass(), propertyName);
+        if (method.isPresent()) {
+            return invokeBooleanMethod(target, method.get());
+        }
+        return toBooleanValue(getValue(target, propertyName), propertyName);
+    }
+
+    @SuppressWarnings("PMD.EmptyCatchBlock")
+    static Object getFieldValue(final Object target, final String fieldName) throws ReflectiveOperationException {
+        final Class<?> type = target.getClass();
+        try {
+            final Field field = type.getField(fieldName);
+            return getFieldValue(target, field);
+        } catch (NoSuchFieldException e) {
+            Class<?> currentType = type;
+            while (currentType != null) {
+                try {
+                    final Field declaredField = currentType.getDeclaredField(fieldName);
+                    return getFieldValue(target, declaredField);
+                } catch (NoSuchFieldException ignore) {
+                    // Ignore
+                }
+                currentType = currentType.getSuperclass();
+            }
+            throw e;
+        }
+    }
+
+    @SuppressWarnings("PMD.AvoidAccessibilityAlteration")
+    private static Object getFieldValue(final Object target, final Field field) throws IllegalAccessException {
+        try {
+            return field.get(target);
+        } catch (IllegalAccessException e) {
+            field.setAccessible(true);
+            return field.get(target);
+        }
+    }
+
+    @SuppressWarnings("PMD.AvoidAccessibilityAlteration")
+    private static Object invokeMethod(final Object target, final Method method) throws ReflectiveOperationException {
+        try {
+            return method.invoke(target);
+        } catch (IllegalAccessException e) {
+            method.setAccessible(true);
+            return method.invoke(target);
+        }
+    }
+
+    private static Optional<Method> findGetter(final Class<?> type, final String propertyName) {
+        final String capitalizedName = capitalize(propertyName);
+        final String[] methodNames = {GET_PREFIX + capitalizedName, propertyName};
+        Class<?> currentType = type;
+        while (currentType != null) {
+            for (String methodName : methodNames) {
+                try {
+                    return Optional.of(currentType.getDeclaredMethod(methodName));
+                } catch (NoSuchMethodException ignored) {
+                    // Ignore
+                } catch (SecurityException e) {
+                    LOGGER.trace(METHOD_READ_ERROR, methodName, e);
+                    return Optional.empty();
+                }
+            }
+            currentType = currentType.getSuperclass();
+        }
+        return Optional.empty();
+    }
+
+    private static Optional<Method> findPrimitiveBooleanGetter(final Class<?> type, final String propertyName) {
+        final String methodName = IS_PREFIX + capitalize(propertyName);
+        Class<?> currentType = type;
+        while (currentType != null) {
+            try {
+                final Method method = currentType.getDeclaredMethod(methodName);
+                return method.getReturnType() == boolean.class ? Optional.of(method) : Optional.empty();
+            } catch (NoSuchMethodException ignored) {
+                // Ignore
+            } catch (SecurityException e) {
+                LOGGER.trace(METHOD_READ_ERROR, methodName, e);
+                return Optional.empty();
+            }
+            currentType = currentType.getSuperclass();
+        }
+        return Optional.empty();
+    }
+
+    private static String capitalize(final String value) {
+        return Character.toUpperCase(value.charAt(0)) + value.substring(1);
+    }
+
+    private static Boolean invokeBooleanMethod(final Object target, final Method method) {
+        try {
+            return Boolean.class.cast(invokeMethod(target, method));
+        } catch (ReflectiveOperationException | SecurityException e) {
+            LOGGER.trace(METHOD_READ_ERROR, method.getName(), e);
+            return absentBooleanValue();
+        }
+    }
+
+    private static Boolean toBooleanValue(final Object value, final String propertyName) {
+        if (value instanceof Boolean) {
+            return (Boolean) value;
+        }
+        if (value != null) {
+            LOGGER.trace(
+                    "Unable to read boolean value {}: actual value type is {}",
+                    propertyName,
+                    value.getClass().getName()
+            );
+        }
+        return absentBooleanValue();
+    }
+
+    private static Boolean absentBooleanValue() {
+        return Optional.<Boolean>empty().orElse(null);
+    }
+}
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/util/ResultsUtils.java b/allure-java-commons/src/main/java/io/qameta/allure/util/ResultsUtils.java
index d8d3b7f8..2704eac5 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/util/ResultsUtils.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/util/ResultsUtils.java
@@ -31,24 +31,31 @@
 import org.slf4j.LoggerFactory;
 
 import java.io.ByteArrayOutputStream;
+import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.PrintWriter;
 import java.io.StringWriter;
+import java.lang.invoke.SerializedLambda;
 import java.lang.management.ManagementFactory;
 import java.lang.reflect.Method;
 import java.math.BigInteger;
 import java.net.InetAddress;
+import java.net.URI;
 import java.net.UnknownHostException;
 import java.nio.charset.StandardCharsets;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Properties;
 import java.util.Set;
 import java.util.function.Consumer;
+import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -57,46 +64,158 @@
 import static java.util.Objects.nonNull;
 
 /**
- * The collection of Allure utils methods.
+ * Utility methods for creating and enriching Allure result model objects.
+ *
+ * <p>Use these helpers when custom integrations need labels, links, parameters, names, descriptions, status details, or test plan identifiers in the same format as the built-in adapters.</p>
  */
-@SuppressWarnings({
-        "ClassFanOutComplexity",
-        "ClassDataAbstractionCoupling",
-})
+@SuppressWarnings(
+    {
+            "ClassFanOutComplexity",
+            "ClassDataAbstractionCoupling",
+            "PMD.GodClass",
+            "PMD.TooManyMethods",
+    }
+)
 public final class ResultsUtils {
 
+    /**
+     * System property name for allure host name.
+     */
     public static final String ALLURE_HOST_NAME_SYSPROP = "allure.hostName";
+
+    /**
+     * Environment variable name for allure host name.
+     */
     public static final String ALLURE_HOST_NAME_ENV = "ALLURE_HOST_NAME";
+
+    /**
+     * System property name for allure thread name.
+     */
     public static final String ALLURE_THREAD_NAME_SYSPROP = "allure.threadName";
+
+    /**
+     * Environment variable name for allure thread name.
+     */
     public static final String ALLURE_THREAD_NAME_ENV = "ALLURE_THREAD_NAME";
+
+    /**
+     * System property name for allure separate lines.
+     */
     public static final String ALLURE_SEPARATE_LINES_SYSPROP = "allure.description.javadoc.separateLines";
 
+    /**
+     * Allure link type for issue.
+     */
     public static final String ISSUE_LINK_TYPE = "issue";
+
+    /**
+     * Allure link type for tms.
+     */
     public static final String TMS_LINK_TYPE = "tms";
+
+    /**
+     * Allure link type for custom.
+     */
     public static final String CUSTOM_LINK_TYPE = "custom";
 
+    /**
+     * Allure label name for allure id.
+     */
     public static final String ALLURE_ID_LABEL_NAME = "AS_ID";
+
+    /**
+     * Allure label name for suite.
+     */
     public static final String SUITE_LABEL_NAME = "suite";
+
+    /**
+     * Allure label name for parent suite.
+     */
     public static final String PARENT_SUITE_LABEL_NAME = "parentSuite";
+
+    /**
+     * Allure label name for sub suite.
+     */
     public static final String SUB_SUITE_LABEL_NAME = "subSuite";
+
+    /**
+     * Allure label name for epic.
+     */
     public static final String EPIC_LABEL_NAME = "epic";
+
+    /**
+     * Allure label name for feature.
+     */
     public static final String FEATURE_LABEL_NAME = "feature";
+
+    /**
+     * Allure label name for story.
+     */
     public static final String STORY_LABEL_NAME = "story";
+
+    /**
+     * Allure label name for severity.
+     */
     public static final String SEVERITY_LABEL_NAME = "severity";
+
+    /**
+     * Allure label name for tag.
+     */
     public static final String TAG_LABEL_NAME = "tag";
+
+    /**
+     * Allure label name for owner.
+     */
     public static final String OWNER_LABEL_NAME = "owner";
+
+    /**
+     * Allure label name for lead.
+     */
     public static final String LEAD_LABEL_NAME = "lead";
+
+    /**
+     * Allure label name for host.
+     */
     public static final String HOST_LABEL_NAME = "host";
+
+    /**
+     * Allure label name for thread.
+     */
     public static final String THREAD_LABEL_NAME = "thread";
+
+    /**
+     * Allure label name for test method.
+     */
     public static final String TEST_METHOD_LABEL_NAME = "testMethod";
+
+    /**
+     * Allure label name for test class.
+     */
     public static final String TEST_CLASS_LABEL_NAME = "testClass";
+
+    /**
+     * Allure label name for package.
+     */
     public static final String PACKAGE_LABEL_NAME = "package";
+
+    /**
+     * Allure label name for framework.
+     */
     public static final String FRAMEWORK_LABEL_NAME = "framework";
+
+    /**
+     * Allure label name for language.
+     */
     public static final String LANGUAGE_LABEL_NAME = "language";
 
     private static final Logger LOGGER = LoggerFactory.getLogger(ResultsUtils.class);
     private static final String ALLURE_DESCRIPTIONS_FOLDER = "META-INF/allureDescriptions/";
     private static final String MD_5 = "MD5";
+    private static final String DOT = ".";
+    private static final String ACTUAL = "actual";
+    private static final String EXPECTED = "expected";
+    private static final String DEFINED_PROPERTY_SUFFIX = "Defined";
+    private static final String NEW_LINE = "\n";
 
     private static String cachedHost;
 
@@ -104,10 +223,26 @@ private ResultsUtils() {
         throw new IllegalStateException("Do not instance");
     }
 
+    /**
+     * Creates and returns the parameter.
+     *
+     * @param name the display name or logical name to use
+     * @param value the value to set
+     * @return the parameter
+     */
     public static Parameter createParameter(final String name, final Object value) {
         return createParameter(name, value, null, null);
     }
 
+    /**
+     * Creates and returns the parameter.
+     *
+     * @param name the display name or logical name to use
+     * @param value the value to set
+     * @param excluded the excluded
+     * @param mode the mode
+     * @return the parameter
+     */
     public static Parameter createParameter(final String name, final Object value,
                                             final Boolean excluded, final Parameter.Mode mode) {
         return new Parameter()
@@ -117,118 +252,382 @@ public static Parameter createParameter(final String name, final Object value,
                 .setMode(mode);
     }
 
+    /**
+     * Creates and returns the suite label.
+     *
+     * @param suite the TestNG suite callback argument
+     * @return the suite label
+     */
     public static Label createSuiteLabel(final String suite) {
         return createLabel(SUITE_LABEL_NAME, suite);
     }
 
+    /**
+     * Creates and returns the parent suite label.
+     *
+     * @param suite the TestNG suite callback argument
+     * @return the parent suite label
+     */
     public static Label createParentSuiteLabel(final String suite) {
         return createLabel(PARENT_SUITE_LABEL_NAME, suite);
     }
 
+    /**
+     * Creates and returns the sub suite label.
+     *
+     * @param suite the TestNG suite callback argument
+     * @return the sub suite label
+     */
     public static Label createSubSuiteLabel(final String suite) {
         return createLabel(SUB_SUITE_LABEL_NAME, suite);
     }
 
+    /**
+     * Creates and returns the test method label.
+     *
+     * @param testMethod the test method
+     * @return the test method label
+     */
     public static Label createTestMethodLabel(final String testMethod) {
         return createLabel(TEST_METHOD_LABEL_NAME, testMethod);
     }
 
+    /**
+     * Creates and returns the test class label.
+     *
+     * @param testClass the test class
+     * @return the test class label
+     */
     public static Label createTestClassLabel(final String testClass) {
         return createLabel(TEST_CLASS_LABEL_NAME, testClass);
     }
 
+    /**
+     * Creates and returns the package label.
+     *
+     * @param packageName the package name
+     * @return the package label
+     */
     public static Label createPackageLabel(final String packageName) {
         return createLabel(PACKAGE_LABEL_NAME, packageName);
     }
 
+    /**
+     * Creates and returns the title path.
+     *
+     * @param values the values
+     * @return the title path
+     */
+    public static List<String> createTitlePath(final String... values) {
+        return createTitlePath(Arrays.asList(values));
+    }
+
+    /**
+     * Creates and returns the title path.
+     *
+     * @param values the values
+     * @return the title path
+     */
+    public static List<String> createTitlePath(final Collection<String> values) {
+        if (Objects.isNull(values)) {
+            return new ArrayList<>();
+        }
+        return values.stream()
+                .filter(Objects::nonNull)
+                .map(String::trim)
+                .filter(value -> !value.isEmpty())
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * Creates and returns the title path from package and class.
+     *
+     * @param packageName the package name
+     * @param className the class name
+     * @return the title path from package and class
+     */
+    public static List<String> createTitlePathFromPackageAndClass(final String packageName, final String className) {
+        final List<String> result = createTitlePathFromPackage(packageName);
+        getClassTitle(packageName, className).ifPresent(result::add);
+        return result;
+    }
+
+    /**
+     * Creates and returns the title path from qualified class name.
+     *
+     * @param className the class name
+     * @return the title path from qualified class name
+     */
+    public static List<String> createTitlePathFromQualifiedClassName(final String className) {
+        return getPackageName(className)
+                .map(packageName -> createTitlePathFromPackageAndClass(packageName, className))
+                .orElseGet(() -> createTitlePath(className));
+    }
+
+    /**
+     * Creates and returns the title path from java class.
+     *
+     * @param clazz the clazz
+     * @return the title path from java class
+     */
+    public static List<String> createTitlePathFromJavaClass(final Class<?> clazz) {
+        if (Objects.isNull(clazz)) {
+            return createTitlePath();
+        }
+        final String packageName = Optional.ofNullable(clazz.getPackage())
+                .map(Package::getName)
+                .orElse("");
+        return createTitlePathFromPackageAndClass(packageName, clazz.getName());
+    }
+
+    /**
+     * Creates and returns the title path from package.
+     *
+     * @param packageName the package name
+     * @return the title path from package
+     */
+    public static List<String> createTitlePathFromPackage(final String packageName) {
+        return split(packageName, DOT);
+    }
+
+    /**
+     * Creates and returns the title path from source path.
+     *
+     * @param sourcePath the source path
+     * @return the title path from source path
+     */
+    public static List<String> createTitlePathFromSourcePath(final String sourcePath) {
+        return split(normalizeSourcePath(sourcePath), "/");
+    }
+
+    /**
+     * Creates and returns the epic label.
+     *
+     * @param epic the epic
+     * @return the epic label
+     */
     public static Label createEpicLabel(final String epic) {
         return createLabel(EPIC_LABEL_NAME, epic);
     }
 
+    /**
+     * Creates and returns the feature label.
+     *
+     * @param feature the feature
+     * @return the feature label
+     */
     public static Label createFeatureLabel(final String feature) {
         return createLabel(FEATURE_LABEL_NAME, feature);
     }
 
+    /**
+     * Creates and returns the story label.
+     *
+     * @param story the story
+     * @return the story label
+     */
     public static Label createStoryLabel(final String story) {
         return createLabel(STORY_LABEL_NAME, story);
     }
 
+    /**
+     * Creates and returns the tag label.
+     *
+     * @param tag the tag
+     * @return the tag label
+     */
     public static Label createTagLabel(final String tag) {
         return createLabel(TAG_LABEL_NAME, tag);
     }
 
+    /**
+     * Creates and returns the owner label.
+     *
+     * @param owner the owner
+     * @return the owner label
+     */
     public static Label createOwnerLabel(final String owner) {
         return createLabel(OWNER_LABEL_NAME, owner);
     }
 
+    /**
+     * Creates and returns the severity label.
+     *
+     * @param severity the severity
+     * @return the severity label
+     */
     public static Label createSeverityLabel(final SeverityLevel severity) {
         return createSeverityLabel(severity.value());
     }
 
+    /**
+     * Creates and returns the severity label.
+     *
+     * @param severity the severity
+     * @return the severity label
+     */
     public static Label createSeverityLabel(final String severity) {
         return createLabel(SEVERITY_LABEL_NAME, severity);
     }
 
+    /**
+     * Creates and returns the host label.
+     *
+     * @return the host label
+     */
     public static Label createHostLabel() {
         return createLabel(HOST_LABEL_NAME, getHostName());
     }
 
+    /**
+     * Creates and returns the thread label.
+     *
+     * @return the thread label
+     */
     public static Label createThreadLabel() {
         return createLabel(THREAD_LABEL_NAME, getThreadName());
     }
 
+    /**
+     * Creates and returns the framework label.
+     *
+     * @param framework the framework
+     * @return the framework label
+     */
     public static Label createFrameworkLabel(final String framework) {
         return createLabel(FRAMEWORK_LABEL_NAME, framework);
     }
 
+    /**
+     * Creates and returns the language label.
+     *
+     * @param language the language
+     * @return the language label
+     */
     public static Label createLanguageLabel(final String language) {
         return createLabel(LANGUAGE_LABEL_NAME, language);
     }
 
+    /**
+     * Creates and returns the label.
+     *
+     * @param name the display name or logical name to use
+     * @param value the value to set
+     * @return the label
+     */
     public static Label createLabel(final String name, final String value) {
         return new Label().setName(name).setValue(value);
     }
 
+    /**
+     * Creates and returns the label.
+     *
+     * @param owner the owner
+     * @return the label
+     */
     public static Label createLabel(final Owner owner) {
         return createOwnerLabel(owner.value());
     }
 
+    /**
+     * Creates and returns the label.
+     *
+     * @param severity the severity
+     * @return the label
+     */
     public static Label createLabel(final Severity severity) {
         return createSeverityLabel(severity.value());
     }
 
+    /**
+     * Creates and returns the label.
+     *
+     * @param story the story
+     * @return the label
+     */
     public static Label createLabel(final Story story) {
         return createStoryLabel(story.value());
     }
 
+    /**
+     * Creates and returns the label.
+     *
+     * @param feature the feature
+     * @return the label
+     */
     public static Label createLabel(final Feature feature) {
         return createFeatureLabel(feature.value());
     }
 
+    /**
+     * Creates and returns the label.
+     *
+     * @param epic the epic
+     * @return the label
+     */
     public static Label createLabel(final Epic epic) {
         return createEpicLabel(epic.value());
     }
 
+    /**
+     * Creates and returns the issue link.
+     *
+     * @param value the value to set
+     * @return the issue link
+     */
     public static Link createIssueLink(final String value) {
         return createLink(value, null, null, ISSUE_LINK_TYPE);
     }
 
+    /**
+     * Creates and returns the tms link.
+     *
+     * @param value the value to set
+     * @return the tms link
+     */
     public static Link createTmsLink(final String value) {
         return createLink(value, null, null, TMS_LINK_TYPE);
     }
 
+    /**
+     * Creates and returns the link.
+     *
+     * @param link the link
+     * @return the link
+     */
     public static Link createLink(final io.qameta.allure.Link link) {
         return createLink(link.value(), link.name(), link.url(), link.type());
     }
 
+    /**
+     * Creates and returns the link.
+     *
+     * @param link the link
+     * @return the link
+     */
     public static Link createLink(final io.qameta.allure.Issue link) {
         return createIssueLink(link.value());
     }
 
+    /**
+     * Creates and returns the link.
+     *
+     * @param link the link
+     * @return the link
+     */
     public static Link createLink(final io.qameta.allure.TmsLink link) {
         return createTmsLink(link.value());
     }
 
+    /**
+     * Creates and returns the link.
+     *
+     * @param value the value to set
+     * @param name the display name or logical name to use
+     * @param url the request URL or service method name
+     * @param type the event or label type
+     * @return the link
+     */
     @SuppressWarnings("PMD.UseObjectForClearerAPI")
     public static Link createLink(final String value, final String name,
                                   final String url, final String type) {
@@ -241,6 +640,11 @@ public static Link createLink(final String value, final String name,
                 .setType(type);
     }
 
+    /**
+     * Returns the provided labels.
+     *
+     * @return the provided labels
+     */
     public static Set<Label> getProvidedLabels() {
         final Properties properties = loadAllureProperties();
         final Set<String> propertyNames = properties.stringPropertyNames();
@@ -257,6 +661,11 @@ public static Set<Label> getProvidedLabels() {
                 .collect(Collectors.toSet());
     }
 
+    /**
+     * Returns the host name.
+     *
+     * @return the host name
+     */
     public static String getHostName() {
         final String fromProperty = System.getProperty(ALLURE_HOST_NAME_SYSPROP);
         final String fromEnv = System.getenv(ALLURE_HOST_NAME_ENV);
@@ -266,6 +675,11 @@ public static String getHostName() {
                 .orElseGet(ResultsUtils::getRealHostName);
     }
 
+    /**
+     * Returns the thread name.
+     *
+     * @return the thread name
+     */
     public static String getThreadName() {
         final String fromProperty = System.getProperty(ALLURE_THREAD_NAME_SYSPROP);
         final String fromEnv = System.getenv(ALLURE_THREAD_NAME_ENV);
@@ -275,22 +689,46 @@ public static String getThreadName() {
                 .orElseGet(ResultsUtils::getRealThreadName);
     }
 
+    /**
+     * Returns the status.
+     *
+     * @param throwable the throwable
+     * @return the status
+     */
     public static Optional<Status> getStatus(final Throwable throwable) {
         return Optional.ofNullable(throwable)
                 .map(t -> t instanceof AssertionError ? Status.FAILED : Status.BROKEN);
     }
 
+    /**
+     * Returns the status details.
+     *
+     * @param e the e
+     * @return the status details
+     */
     public static Optional<StatusDetails> getStatusDetails(final Throwable e) {
         return Optional.ofNullable(e)
-                .map(throwable -> new StatusDetails()
-                        .setMessage(Optional
-                                .ofNullable(throwable.getMessage())
-                                .orElse(throwable.getClass().getName())
-                        )
-                        .setTrace(getStackTraceAsString(throwable))
-                );
+                .map(throwable -> {
+                    final StatusDetails details = new StatusDetails()
+                            .setMessage(
+                                    Optional
+                                            .ofNullable(throwable.getMessage())
+                                            .orElse(throwable.getClass().getName())
+                            )
+                            .setTrace(getStackTraceAsString(throwable));
+                    getRichErrorProperty(throwable, ACTUAL).ifPresent(details::setActual);
+                    getRichErrorProperty(throwable, EXPECTED).ifPresent(details::setExpected);
+                    return details;
+                });
     }
 
+    /**
+     * Returns the javadoc description.
+     *
+     * @param classLoader the class loader to use for resource lookup
+     * @param method the framework or Java method to inspect
+     * @return the javadoc description
+     */
     public static Optional<String> getJavadocDescription(final ClassLoader classLoader,
                                                          final Method method) {
         final String name = method.getName();
@@ -301,12 +739,19 @@ public static Optional<String> getJavadocDescription(final ClassLoader classLoad
         final String signatureHash = generateMethodSignatureHash(
                 method.getDeclaringClass().getName(),
                 name,
-                parameterTypes);
+                parameterTypes
+        );
 
         return readResource(classLoader, ALLURE_DESCRIPTIONS_FOLDER + signatureHash)
                 .map(desc -> separateLines() ? toMarkdownLineBreaks(desc) : desc);
     }
 
+    /**
+     * Returns the first non empty.
+     *
+     * @param items the map entries to convert
+     * @return the first non empty
+     */
     public static Optional<String> firstNonEmpty(final String... items) {
         return Stream.of(items)
                 .filter(Objects::nonNull)
@@ -314,10 +759,24 @@ public static Optional<String> firstNonEmpty(final String... items) {
                 .findFirst();
     }
 
+    /**
+     * Returns the link type pattern property name.
+     *
+     * @param type the event or label type
+     * @return the link type pattern property name
+     */
     public static String getLinkTypePatternPropertyName(final String type) {
         return String.format("allure.link.%s.pattern", type);
     }
 
+    /**
+     * Generates and returns the method signature hash.
+     *
+     * @param className the class name
+     * @param methodName the method name
+     * @param parameterTypes the parameter types
+     * @return the generated method signature hash
+     */
     public static String generateMethodSignatureHash(final String className,
                                                      final String methodName,
                                                      final List<String> parameterTypes) {
@@ -331,15 +790,43 @@ public static String generateMethodSignatureHash(final String className,
         return bytesToHex(bytes);
     }
 
+    /**
+     * Returns the md5.
+     *
+     * @param source the source
+     * @return the md5
+     */
     public static String md5(final String source) {
         Objects.requireNonNull(source, "null source");
         return bytesToHex(getMd5Digest().digest(source.getBytes(StandardCharsets.UTF_8)));
     }
 
+    /**
+     * Returns the lambda name.
+     *
+     * @param lambda the lambda
+     * @return the lambda name
+     */
+    public static Optional<String> getLambdaName(final Object lambda) {
+        return getSerializedLambda(lambda)
+                .flatMap(ResultsUtils::formatLambdaName);
+    }
+
+    /**
+     * Returns the bytes to hex.
+     *
+     * @param bytes the bytes
+     * @return the bytes to hex
+     */
     public static String bytesToHex(final byte[] bytes) {
         return new BigInteger(1, bytes).toString(16);
     }
 
+    /**
+     * Returns the md5 digest.
+     *
+     * @return the md5 digest
+     */
     public static MessageDigest getMd5Digest() {
         try {
             return MessageDigest.getInstance(MD_5);
@@ -370,10 +857,12 @@ private static String getRealHostName() {
     }
 
     private static String getRealThreadName() {
-        return String.format("%s.%s(%s)",
+        return String.format(
+                "%s.%s(%s)",
                 ManagementFactory.getRuntimeMXBean().getName(),
                 Thread.currentThread().getName(),
-                Thread.currentThread().getId());
+                Thread.currentThread().getId()
+        );
     }
 
     private static String getStackTraceAsString(final Throwable throwable) {
@@ -382,6 +871,28 @@ private static String getStackTraceAsString(final Throwable throwable) {
         return stringWriter.toString();
     }
 
+    private static Optional<String> getRichErrorProperty(final Throwable throwable, final String propertyName) {
+        final Boolean propertyDefined = ReflectionUtils.getBooleanValue(
+                throwable,
+                propertyName + DEFINED_PROPERTY_SUFFIX
+        );
+        // Some assertion libraries expose isActualDefined/isExpectedDefined to distinguish absent values
+        // from values that are present but null.
+        if (Boolean.FALSE.equals(propertyDefined)) {
+            return Optional.empty();
+        }
+        final Object value = ReflectionUtils.getValue(throwable, propertyName);
+        return Optional.ofNullable(value).map(ObjectUtils::toString);
+    }
+
+    /**
+     * Handles the process description callback.
+     *
+     * @param classLoader the class loader to use for resource lookup
+     * @param method the framework or Java method to inspect
+     * @param setDescription the set description
+     * @param setDescriptionHtml the set description html
+     */
     public static void processDescription(final ClassLoader classLoader,
                                           final Method method,
                                           final Consumer<String> setDescription,
@@ -399,13 +910,13 @@ public static void processDescription(final ClassLoader classLoader,
     }
 
     private static String toMarkdownLineBreaks(final String description) {
-        final String[] lines = description.split("\n", -1);
+        final String[] lines = description.split(NEW_LINE, -1);
         final StringBuilder markdown = new StringBuilder();
         for (int index = 0; index < lines.length; index++) {
             if (index > 0) {
                 final String previousLine = lines[index - 1];
                 final String currentLine = lines[index];
-                markdown.append(previousLine.isEmpty() || currentLine.isEmpty() ? "\n" : "  \n");
+                markdown.append(previousLine.isEmpty() || currentLine.isEmpty() ? NEW_LINE : "  \n");
             }
             markdown.append(lines[index]);
         }
@@ -442,4 +953,103 @@ private static boolean separateLines() {
         return parseBoolean(loadAllureProperties().getProperty(ALLURE_SEPARATE_LINES_SYSPROP));
     }
 
+    @SuppressWarnings("PMD.AvoidAccessibilityAlteration")
+    private static Optional<SerializedLambda> getSerializedLambda(final Object value) {
+        if (Objects.isNull(value)) {
+            return Optional.empty();
+        }
+        try {
+            final Method writeReplace = value.getClass().getDeclaredMethod("writeReplace");
+            writeReplace.setAccessible(true);
+            final Object replacement = writeReplace.invoke(value);
+            if (replacement instanceof SerializedLambda) {
+                return Optional.of((SerializedLambda) replacement);
+            }
+        } catch (ReflectiveOperationException | RuntimeException ignored) {
+            return Optional.empty();
+        }
+        return Optional.empty();
+    }
+
+    private static Optional<String> formatLambdaName(final SerializedLambda lambda) {
+        final String methodName = lambda.getImplMethodName();
+        if (methodName.startsWith("lambda$")) {
+            return Optional.empty();
+        }
+        return Optional.of(simpleClassName(lambda.getImplClass()) + "::" + getLambdaMethodName(methodName));
+    }
+
+    private static Optional<String> getPackageName(final String className) {
+        if (Objects.isNull(className)) {
+            return Optional.empty();
+        }
+        final int index = className.lastIndexOf('.');
+        if (index < 0) {
+            return Optional.empty();
+        }
+        return Optional.of(className.substring(0, index));
+    }
+
+    private static Optional<String> getClassTitle(final String packageName, final String className) {
+        if (Objects.isNull(className) || className.isEmpty()) {
+            return Optional.empty();
+        }
+        final String prefix = packageName + DOT;
+        if (!packageName.isEmpty() && className.startsWith(prefix)) {
+            return Optional.of(className.substring(prefix.length()));
+        }
+        return Optional.of(className);
+    }
+
+    private static List<String> split(final String value, final String delimiter) {
+        if (Objects.isNull(value) || value.isEmpty()) {
+            return new ArrayList<>();
+        }
+        return Stream.of(value.split(Pattern.quote(delimiter)))
+                .map(String::trim)
+                .filter(item -> !item.isEmpty())
+                .collect(Collectors.toList());
+    }
+
+    private static String normalizeSourcePath(final String sourcePath) {
+        if (Objects.isNull(sourcePath)) {
+            return "";
+        }
+        try {
+            final URI uri = URI.create(sourcePath);
+            if (nonNull(uri.getScheme())) {
+                final URI normalized = uri.normalize();
+                if (!normalized.isOpaque()) {
+                    final URI relative = new File("").toURI().relativize(normalized);
+                    final String path = relative.getPath();
+                    if (nonNull(path) && !path.isEmpty()) {
+                        return path.replace('\\', '/');
+                    }
+                }
+                final String schemeSpecificPart = normalized.getSchemeSpecificPart();
+                if (nonNull(schemeSpecificPart)) {
+                    return schemeSpecificPart.replace('\\', '/');
+                }
+            }
+        } catch (IllegalArgumentException ignored) {
+            // Fall back to plain path normalization below.
+        }
+        return sourcePath.replace('\\', '/');
+    }
+
+    private static String getLambdaMethodName(final String methodName) {
+        if ("<init>".equals(methodName)) {
+            return "new";
+        }
+        return methodName;
+    }
+
+    private static String simpleClassName(final String name) {
+        final String normalized = name.replace('/', '.');
+        final int packageIndex = normalized.lastIndexOf('.');
+        final int nestedClassIndex = normalized.lastIndexOf('$');
+        final int index = Math.max(packageIndex, nestedClassIndex);
+        return index < 0 ? normalized : normalized.substring(index + 1);
+    }
+
 }
diff --git a/allure-java-commons/src/test/java/io/qameta/allure/AllureLifecycleTest.java b/allure-java-commons/src/test/java/io/qameta/allure/AllureLifecycleTest.java
index b24e489f..21255093 100644
--- a/allure-java-commons/src/test/java/io/qameta/allure/AllureLifecycleTest.java
+++ b/allure-java-commons/src/test/java/io/qameta/allure/AllureLifecycleTest.java
@@ -56,10 +56,6 @@
 import static org.mockito.ArgumentCaptor.forClass;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class AllureLifecycleTest {
 
     private AllureResultsWriter writer;
@@ -324,10 +320,16 @@ void shouldAttachAsync() {
         final String attachment2Content = randomString(100);
 
         final AllureResults writer = RunUtils.runWithinTestContext(() -> {
-            features.add(addStreamAttachmentAsync(
-                    attachment1Name, "video/mp4", getStreamWithTimeout(2, attachment1Content)));
-            features.add(addStreamAttachmentAsync(
-                    attachment2Name, "text/plain", getStreamWithTimeout(1, attachment2Content)));
+            features.add(
+                    addStreamAttachmentAsync(
+                            attachment1Name, "video/mp4", getStreamWithTimeout(2, attachment1Content)
+                    )
+            );
+            features.add(
+                    addStreamAttachmentAsync(
+                            attachment2Name, "text/plain", getStreamWithTimeout(1, attachment2Content)
+                    )
+            );
 
             allOf(features.toArray(new CompletableFuture[0])).join();
         });
@@ -352,7 +354,6 @@ void shouldAttachAsync() {
                 .map(io.qameta.allure.model.Attachment::getSource)
                 .toArray(String[]::new);
 
-
         final Map<String, byte[]> attachmentFiles = writer.getAttachments();
         assertThat(attachmentFiles)
                 .containsKeys(sources);
diff --git a/allure-java-commons/src/test/java/io/qameta/allure/AllureTest.java b/allure-java-commons/src/test/java/io/qameta/allure/AllureTest.java
index fa691623..8219f51a 100644
--- a/allure-java-commons/src/test/java/io/qameta/allure/AllureTest.java
+++ b/allure-java-commons/src/test/java/io/qameta/allure/AllureTest.java
@@ -48,10 +48,6 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.fail;
 import static org.assertj.core.api.Assertions.tuple;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @SuppressWarnings("unchecked")
 class AllureTest {
 
diff --git a/allure-java-commons/src/test/java/io/qameta/allure/FileSystemResultsWriterTest.java b/allure-java-commons/src/test/java/io/qameta/allure/FileSystemResultsWriterTest.java
index e84be69b..8403fc2e 100644
--- a/allure-java-commons/src/test/java/io/qameta/allure/FileSystemResultsWriterTest.java
+++ b/allure-java-commons/src/test/java/io/qameta/allure/FileSystemResultsWriterTest.java
@@ -15,6 +15,7 @@
  */
 package io.qameta.allure;
 
+import io.qameta.allure.model.StatusDetails;
 import io.qameta.allure.model.TestResult;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
@@ -22,15 +23,12 @@
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.Arrays;
 import java.util.UUID;
 
 import static io.qameta.allure.FileSystemResultsWriter.generateTestResultName;
 import static io.qameta.allure.test.ThreadLocalEnhancedRandom.current;
 import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class FileSystemResultsWriterTest {
 
     @Test
@@ -56,6 +54,42 @@ void shouldWriteTestResult(@TempDir final Path folder) {
                 .isRegularFile();
     }
 
+    @Test
+    void shouldWriteTitlePath(@TempDir final Path folder) throws IOException {
+        FileSystemResultsWriter writer = new FileSystemResultsWriter(folder);
+        final String uuid = UUID.randomUUID().toString();
+        final TestResult testResult = new TestResult()
+                .setUuid(uuid)
+                .setTitlePath(Arrays.asList("parent", "child"));
+
+        writer.write(testResult);
+
+        assertThat(Files.readString(folder.resolve(generateTestResultName(uuid))))
+                .contains("\"titlePath\"")
+                .contains("\"parent\"")
+                .contains("\"child\"");
+    }
+
+    @Test
+    void shouldWriteStatusDetailsActualAndExpected(@TempDir final Path folder) throws IOException {
+        FileSystemResultsWriter writer = new FileSystemResultsWriter(folder);
+        final String uuid = UUID.randomUUID().toString();
+        final TestResult testResult = new TestResult()
+                .setUuid(uuid)
+                .setStatusDetails(
+                        new StatusDetails()
+                                .setActual("actual value")
+                                .setExpected("expected value")
+                );
+
+        writer.write(testResult);
+
+        final String payload = Files.readString(folder.resolve(generateTestResultName(uuid)));
+        assertThat(payload)
+                .contains("\"actual\":\"actual value\"")
+                .contains("\"expected\":\"expected value\"");
+    }
+
     @Test
     void shouldPreserveOldResultsWhenCleanIsDisabled(@TempDir final Path folder) throws IOException {
         Path existingFile = folder.resolve("existing-result.json");
@@ -90,7 +124,7 @@ void shouldCleanOnlyOnceWhenCleanOnlyOnceEnabled(@TempDir final Path folder) thr
         Files.writeString(existingFile, "{}");
 
         FileSystemResultsWriter writer = new FileSystemResultsWriter(folder, true, true);
-        
+
         final String uuid1 = UUID.randomUUID().toString();
         final TestResult testResult1 = current().nextObject(TestResult.class, "steps").setUuid(uuid1);
         writer.write(testResult1);
diff --git a/allure-java-commons/src/test/java/io/qameta/allure/ResultsUtilsTest.java b/allure-java-commons/src/test/java/io/qameta/allure/ResultsUtilsTest.java
index 79b6505a..b42278ac 100644
--- a/allure-java-commons/src/test/java/io/qameta/allure/ResultsUtilsTest.java
+++ b/allure-java-commons/src/test/java/io/qameta/allure/ResultsUtilsTest.java
@@ -17,31 +17,53 @@
 
 import io.github.glytching.junit.extension.system.SystemProperty;
 import io.github.glytching.junit.extension.system.SystemPropertyExtension;
+import io.qameta.allure.model.StatusDetails;
 import io.qameta.allure.util.ResultsUtils;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
+import org.opentest4j.AssertionFailedError;
+import org.opentest4j.ValueWrapper;
 
+import java.io.Serializable;
 import java.lang.annotation.Annotation;
 import java.util.Objects;
+import java.util.function.Function;
 import java.util.stream.Stream;
 
 import static io.qameta.allure.util.ResultsUtils.ISSUE_LINK_TYPE;
 import static io.qameta.allure.util.ResultsUtils.TMS_LINK_TYPE;
 import static io.qameta.allure.util.ResultsUtils.createIssueLink;
 import static io.qameta.allure.util.ResultsUtils.createLink;
+import static io.qameta.allure.util.ResultsUtils.createTitlePath;
+import static io.qameta.allure.util.ResultsUtils.createTitlePathFromQualifiedClassName;
+import static io.qameta.allure.util.ResultsUtils.createTitlePathFromSourcePath;
 import static io.qameta.allure.util.ResultsUtils.createTmsLink;
 import static io.qameta.allure.util.ResultsUtils.getLinkTypePatternPropertyName;
 import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @ExtendWith(SystemPropertyExtension.class)
 class ResultsUtilsTest {
 
+    @Test
+    void shouldCreateTitlePath() {
+        assertThat(createTitlePath(" parent ", null, " ", "child"))
+                .containsExactly("parent", "child");
+    }
+
+    @Test
+    void shouldCreateTitlePathFromQualifiedClassName() {
+        assertThat(createTitlePathFromQualifiedClassName("io.qameta.allure.samples.MyTest"))
+                .containsExactly("io", "qameta", "allure", "samples", "MyTest");
+    }
+
+    @Test
+    void shouldCreateTitlePathFromSourcePath() {
+        assertThat(createTitlePathFromSourcePath("features/nested/my.test.feature"))
+                .containsExactly("features", "nested", "my.test.feature");
+    }
+
     @Test
     void shouldCreateLink() {
         io.qameta.allure.model.Link actual = createLink("a", "b", "c", "d");
@@ -87,7 +109,10 @@ public String type() {
                 .hasFieldOrPropertyWithValue("type", "d_from_annotation");
     }
 
-    @SystemProperty(name = "allure.link.issue.pattern", value = "https://example.org/issue/{}")
+    @SystemProperty(
+            name = "allure.link.issue.pattern",
+            value = "https://example.org/issue/{}"
+    )
     @Test
     void shouldCreateIssueLink() {
         io.qameta.allure.model.Link actual = createIssueLink("issue_link");
@@ -98,7 +123,10 @@ void shouldCreateIssueLink() {
                 .hasFieldOrPropertyWithValue("type", ISSUE_LINK_TYPE);
     }
 
-    @SystemProperty(name = "allure.link.issue.pattern", value = "https://example.org/issue/{}")
+    @SystemProperty(
+            name = "allure.link.issue.pattern",
+            value = "https://example.org/issue/{}"
+    )
     @Test
     void shouldCreateIssueLinkFromAnnotation() {
         io.qameta.allure.model.Link actual = createLink(new Issue() {
@@ -119,7 +147,10 @@ public String value() {
                 .hasFieldOrPropertyWithValue("type", ISSUE_LINK_TYPE);
     }
 
-    @SystemProperty(name = "allure.link.tms.pattern", value = "https://example.org/tms/{}")
+    @SystemProperty(
+            name = "allure.link.tms.pattern",
+            value = "https://example.org/tms/{}"
+    )
     @Test
     void shouldCreateTmsLink() {
         io.qameta.allure.model.Link actual = createTmsLink("tms_link");
@@ -130,7 +161,10 @@ void shouldCreateTmsLink() {
                 .hasFieldOrPropertyWithValue("type", TMS_LINK_TYPE);
     }
 
-    @SystemProperty(name = "allure.link.tms.pattern", value = "https://example.org/tms/{}")
+    @SystemProperty(
+            name = "allure.link.tms.pattern",
+            value = "https://example.org/tms/{}"
+    )
     @Test
     void shouldCreateTmsLinkFromAnnotation() {
         io.qameta.allure.model.Link actual = createLink(new TmsLink() {
@@ -151,6 +185,30 @@ public String value() {
                 .hasFieldOrPropertyWithValue("type", TMS_LINK_TYPE);
     }
 
+    @Test
+    void shouldGetSerializedLambdaName() {
+        final Function<LambdaSubject, String> getter = (Function<LambdaSubject, String> & Serializable) LambdaSubject::getName;
+
+        assertThat(ResultsUtils.getLambdaName(getter))
+                .hasValue("LambdaSubject::getName");
+    }
+
+    @Test
+    void shouldIgnoreGeneratedSerializedLambdaBody() {
+        final Function<LambdaSubject, String> getter = (Function<LambdaSubject, String> & Serializable) subject -> subject.getName();
+
+        assertThat(ResultsUtils.getLambdaName(getter))
+                .isEmpty();
+    }
+
+    @Test
+    void shouldIgnoreNonSerializedLambda() {
+        final Function<LambdaSubject, String> getter = LambdaSubject::getName;
+
+        assertThat(ResultsUtils.getLambdaName(getter))
+                .isEmpty();
+    }
+
     public static Stream<Arguments> data() {
         return Stream.of(
                 Arguments.of("a", "b", "c", "d", "e", link("a", "c", "d")),
@@ -191,6 +249,108 @@ public void shouldCreateLink(final String value,
         }
     }
 
+    @Test
+    void shouldExtractActualAndExpectedFromJunit4LikeComparisonFailure() {
+        final Junit4LikeComparisonFailure error = new Junit4LikeComparisonFailure(
+                "values differ",
+                "expected value",
+                "actual value"
+        );
+
+        final StatusDetails details = ResultsUtils.getStatusDetails(error).get();
+
+        assertThat(details.getActual()).isEqualTo("actual value");
+        assertThat(details.getExpected()).isEqualTo("expected value");
+    }
+
+    @Test
+    void shouldExtractActualAndExpectedFromOpenTest4jAssertionFailedError() {
+        final AssertionFailedError error = new AssertionFailedError(
+                "values differ",
+                "expected value",
+                "actual value"
+        );
+
+        final StatusDetails details = ResultsUtils.getStatusDetails(error).get();
+
+        assertThat(details.getActual()).startsWith("actual value (");
+        assertThat(details.getExpected()).startsWith("expected value (");
+    }
+
+    @Test
+    void shouldUseOpenTest4jValueWrapperToString() {
+        final AssertionFailedError error = new AssertionFailedError(
+                "values differ",
+                ValueWrapper.create("expected value", "expected representation"),
+                ValueWrapper.create("actual value", "actual representation")
+        );
+
+        final StatusDetails details = ResultsUtils.getStatusDetails(error).get();
+
+        assertThat(details.getActual()).startsWith("actual representation (");
+        assertThat(details.getExpected()).startsWith("expected representation (");
+    }
+
+    @Test
+    void shouldPreserveOpenTest4jNullValues() {
+        final AssertionFailedError error = new AssertionFailedError("values differ", null, null);
+
+        final StatusDetails details = ResultsUtils.getStatusDetails(error).get();
+
+        assertThat(details.getActual()).isEqualTo("null");
+        assertThat(details.getExpected()).isEqualTo("null");
+    }
+
+    @Test
+    void shouldSkipUndefinedOpenTest4jValues() {
+        final AssertionFailedError error = new AssertionFailedError("values differ");
+
+        final StatusDetails details = ResultsUtils.getStatusDetails(error).get();
+
+        assertThat(details.getActual()).isNull();
+        assertThat(details.getExpected()).isNull();
+    }
+
+    @Test
+    void shouldExtractActualAndExpectedFromGenericAssertionError() {
+        final StatusDetails details = ResultsUtils.getStatusDetails(new GenericRichAssertionError()).get();
+
+        assertThat(details.getActual()).isEqualTo("[1, 2]");
+        assertThat(details.getExpected()).isEqualTo("expected value");
+    }
+
+    @Test
+    void shouldExtractActualAndExpectedFromFieldAssertionError() {
+        final StatusDetails details = ResultsUtils.getStatusDetails(new FieldRichAssertionError()).get();
+
+        assertThat(details.getActual()).isEqualTo("actual value");
+        assertThat(details.getExpected()).isEqualTo("expected value");
+    }
+
+    @Test
+    void shouldExtractActualAndExpectedFromRecordStyleAssertionError() {
+        final StatusDetails details = ResultsUtils.getStatusDetails(new RecordStyleRichAssertionError()).get();
+
+        assertThat(details.getActual()).isEqualTo("actual value");
+        assertThat(details.getExpected()).isEqualTo("expected value");
+    }
+
+    @Test
+    void shouldSkipNullActualAndUnavailableExpected() {
+        final StatusDetails details = ResultsUtils.getStatusDetails(new PartiallyAvailableAssertionError()).get();
+
+        assertThat(details.getActual()).isNull();
+        assertThat(details.getExpected()).isNull();
+    }
+
+    @Test
+    void shouldRespectGenericDefinedFlags() {
+        final StatusDetails details = ResultsUtils.getStatusDetails(new UndefinedActualAssertionError()).get();
+
+        assertThat(details.getActual()).isNull();
+        assertThat(details.getExpected()).isEqualTo("expected value");
+    }
+
     public void clearSystemProperty(final String type, final String sysProp) {
         if (Objects.nonNull(type) && Objects.nonNull(sysProp)) {
             System.clearProperty(getLinkTypePatternPropertyName(type));
@@ -200,4 +360,109 @@ public void clearSystemProperty(final String type, final String sysProp) {
     private static io.qameta.allure.model.Link link(String name, String url, String type) {
         return new io.qameta.allure.model.Link().setName(name).setUrl(url).setType(type);
     }
+
+    private static final class LambdaSubject {
+
+        private final String name;
+
+        LambdaSubject(final String name) {
+            this.name = name;
+        }
+
+        String getName() {
+            return name;
+        }
+    }
+
+    public static class Junit4LikeComparisonFailure extends AssertionError {
+
+        private static final long serialVersionUID = 1L;
+
+        private final String expected;
+        private final String actual;
+
+        public Junit4LikeComparisonFailure(final String message,
+                                           final String expected,
+                                           final String actual) {
+            super(message);
+            this.expected = expected;
+            this.actual = actual;
+        }
+
+        public String getExpected() {
+            return expected;
+        }
+
+        public String getActual() {
+            return actual;
+        }
+    }
+
+    public static class GenericRichAssertionError extends AssertionError {
+
+        private static final long serialVersionUID = 1L;
+
+        public Object getActual() {
+            return new int[]{1, 2};
+        }
+
+        public Object getExpected() {
+            return "expected value";
+        }
+    }
+
+    public static class PartiallyAvailableAssertionError extends AssertionError {
+
+        private static final long serialVersionUID = 1L;
+
+        public Object getActual() {
+            return null;
+        }
+
+        public Object getExpected() {
+            throw new IllegalStateException("not available");
+        }
+    }
+
+    public static class FieldRichAssertionError extends AssertionError {
+
+        private static final long serialVersionUID = 1L;
+
+        private final Object actual = "actual value";
+        private final Object expected = "expected value";
+    }
+
+    public static class RecordStyleRichAssertionError extends AssertionError {
+
+        private static final long serialVersionUID = 1L;
+
+        public Object actual() {
+            return "actual value";
+        }
+
+        public Object expected() {
+            return "expected value";
+        }
+    }
+
+    public static class UndefinedActualAssertionError extends AssertionError {
+
+        private static final long serialVersionUID = 1L;
+
+        public boolean isActualDefined() {
+            return false;
+        }
+
+        public Object getActual() {
+            return "actual value";
+        }
+
+        public boolean isExpectedDefined() {
+            return true;
+        }
+
+        public Object getExpected() {
+            return "expected value";
+        }
+    }
 }
diff --git a/allure-java-commons/src/test/java/io/qameta/allure/StepLifecycleListenerTest.java b/allure-java-commons/src/test/java/io/qameta/allure/StepLifecycleListenerTest.java
index 8fce16e2..f9589098 100644
--- a/allure-java-commons/src/test/java/io/qameta/allure/StepLifecycleListenerTest.java
+++ b/allure-java-commons/src/test/java/io/qameta/allure/StepLifecycleListenerTest.java
@@ -30,10 +30,6 @@
 import java.util.stream.Stream;
 
 import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class StepLifecycleListenerTest {
 
     @Test
diff --git a/allure-java-commons/src/test/java/io/qameta/allure/aspects/StepsAspectsTest.java b/allure-java-commons/src/test/java/io/qameta/allure/aspects/StepsAspectsTest.java
index a3add35c..c8df6770 100644
--- a/allure-java-commons/src/test/java/io/qameta/allure/aspects/StepsAspectsTest.java
+++ b/allure-java-commons/src/test/java/io/qameta/allure/aspects/StepsAspectsTest.java
@@ -35,10 +35,6 @@
 import static java.util.Arrays.asList;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.tuple;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @SuppressWarnings({"Convert2MethodRef", "SameParameterValue", "unused"})
 class StepsAspectsTest {
 
@@ -224,13 +220,15 @@ void shouldTransformPlaceholdersToPropertyValues() {
         assertThat(results.getTestResults())
                 .flatExtracting(TestResult::getSteps)
                 .extracting(StepResult::getName)
-                .containsExactly("\"[test1@email.com, test2@email.com, null]\"," +
-                        " \"[{address='test1@email.com', attachments='[txt, png]'}," +
-                        " {address='test2@email.com', attachments='[jpg, mp4]'}," +
-                        " null]\"," +
-                        " \"[[txt, png], [jpg, mp4], null]\"," +
-                        " \"12345678\", \"{}\","
-                        + " \"1111222233334444\", \"{missing}\", true");
+                .containsExactly(
+                        "\"[test1@email.com, test2@email.com, null]\"," +
+                                " \"[{address='test1@email.com', attachments='[txt, png]'}," +
+                                " {address='test2@email.com', attachments='[jpg, mp4]'}," +
+                                " null]\"," +
+                                " \"[[txt, png], [jpg, mp4], null]\"," +
+                                " \"12345678\", \"{}\","
+                                + " \"1111222233334444\", \"{missing}\", true"
+                );
     }
 
     @Test
@@ -310,10 +308,19 @@ void shouldProcessParamAnnotation() {
 
     @Step
     void stepWithParamAnnotation(
-            @Param("Named") final String named,
-            @Param(name = "Excluded", excluded = true) final String excluded,
-            @Param(name = "Masked", mode = Parameter.Mode.MASKED) final String masked,
-            @Param(name = "Masked", mode = Parameter.Mode.HIDDEN) final String hidden) {
+                                 @Param("Named") final String named,
+                                 @Param(
+                                         name = "Excluded",
+                                         excluded = true
+                                 ) final String excluded,
+                                 @Param(
+                                         name = "Masked",
+                                         mode = Parameter.Mode.MASKED
+                                 ) final String masked,
+                                 @Param(
+                                         name = "Masked",
+                                         mode = Parameter.Mode.HIDDEN
+                                 ) final String hidden) {
     }
 
     @Step
@@ -362,8 +369,10 @@ void stepWithAssertion() {
     void stepWithVarargs(final String... values) {
     }
 
-    @Step("\"{user.emails.address}\", \"{user.emails}\", \"{user.emails.attachments}\", \"{user.password}\", \"{}\"," +
-            " \"{user.card.number}\", \"{missing}\", {staySignedIn}")
+    @Step(
+        "\"{user.emails.address}\", \"{user.emails}\", \"{user.emails.attachments}\", \"{user.password}\", \"{}\"," +
+                " \"{user.card.number}\", \"{missing}\", {staySignedIn}"
+    )
     private void loginWith(final DummyUser user, final boolean staySignedIn) {
     }
 
@@ -414,5 +423,4 @@ public String toString() {
         }
     }
 
-
 }
diff --git a/allure-java-commons/src/test/java/io/qameta/allure/internal/AllureThreadContextTest.java b/allure-java-commons/src/test/java/io/qameta/allure/internal/AllureThreadContextTest.java
index 1a15d4a7..255e2cd9 100644
--- a/allure-java-commons/src/test/java/io/qameta/allure/internal/AllureThreadContextTest.java
+++ b/allure-java-commons/src/test/java/io/qameta/allure/internal/AllureThreadContextTest.java
@@ -28,10 +28,6 @@
 import java.util.concurrent.Future;
 
 import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class AllureThreadContextTest {
 
     @Test
diff --git a/allure-java-commons/src/test/java/io/qameta/allure/testdata/DummyCard.java b/allure-java-commons/src/test/java/io/qameta/allure/testdata/DummyCard.java
index cbf16ecf..6522ac56 100644
--- a/allure-java-commons/src/test/java/io/qameta/allure/testdata/DummyCard.java
+++ b/allure-java-commons/src/test/java/io/qameta/allure/testdata/DummyCard.java
@@ -14,10 +14,6 @@
  *  limitations under the License.
  */
 package io.qameta.allure.testdata;
-
-/**
- * @author sskorol (Sergey Korol)
- */
 public class DummyCard {
 
     private final String number;
diff --git a/allure-java-commons/src/test/java/io/qameta/allure/testdata/DummyEmail.java b/allure-java-commons/src/test/java/io/qameta/allure/testdata/DummyEmail.java
index f6edd82a..3294281d 100644
--- a/allure-java-commons/src/test/java/io/qameta/allure/testdata/DummyEmail.java
+++ b/allure-java-commons/src/test/java/io/qameta/allure/testdata/DummyEmail.java
@@ -16,10 +16,6 @@
 package io.qameta.allure.testdata;
 
 import java.util.List;
-
-/**
- * @author sskorol (Sergey Korol)
- */
 public class DummyEmail {
 
     private final String address;
diff --git a/allure-java-commons/src/test/java/io/qameta/allure/testdata/DummyUser.java b/allure-java-commons/src/test/java/io/qameta/allure/testdata/DummyUser.java
index 7f084236..544d2a87 100644
--- a/allure-java-commons/src/test/java/io/qameta/allure/testdata/DummyUser.java
+++ b/allure-java-commons/src/test/java/io/qameta/allure/testdata/DummyUser.java
@@ -16,10 +16,6 @@
 package io.qameta.allure.testdata;
 
 import java.util.Arrays;
-
-/**
- * @author sskorol (Sergey Korol)
- */
 public class DummyUser {
 
     private final DummyEmail[] emails;
diff --git a/allure-java-commons/src/test/java/io/qameta/allure/util/AnnotationUtilsTest.java b/allure-java-commons/src/test/java/io/qameta/allure/util/AnnotationUtilsTest.java
index 16629b7b..f7112e57 100644
--- a/allure-java-commons/src/test/java/io/qameta/allure/util/AnnotationUtilsTest.java
+++ b/allure-java-commons/src/test/java/io/qameta/allure/util/AnnotationUtilsTest.java
@@ -48,10 +48,6 @@
 import static org.assertj.core.api.Assertions.tuple;
 import static org.junit.jupiter.api.parallel.ResourceAccessMode.READ_WRITE;
 import static org.junit.jupiter.api.parallel.Resources.SYSTEM_PROPERTIES;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class AnnotationUtilsTest {
 
     @Epic("e1")
@@ -88,10 +84,12 @@ void shouldExtractRepeatableLabels() {
                 );
     }
 
-    @Epics({
-            @Epic("e1"),
-            @Epic("e2")
-    })
+    @Epics(
+        {
+                @Epic("e1"),
+                @Epic("e2")
+        }
+    )
     class DirectRepeatableAnnotations {
     }
 
@@ -155,7 +153,10 @@ void shouldSupportMultiValueAnnotations() {
 
     @Retention(RetentionPolicy.RUNTIME)
     @Target({ElementType.METHOD, ElementType.TYPE})
-    @LabelAnnotation(name = "custom", value = "fixed")
+    @LabelAnnotation(
+            name = "custom",
+            value = "fixed"
+    )
     @interface CustomFixed {
     }
 
@@ -175,10 +176,22 @@ void shouldSupportCustomFixedAnnotations() {
 
     @Retention(RetentionPolicy.RUNTIME)
     @Target({ElementType.METHOD, ElementType.TYPE})
-    @LabelAnnotation(name = "a", value = "a1")
-    @LabelAnnotation(name = "a", value = "a2")
-    @LabelAnnotation(name = "b", value = "b1")
-    @LabelAnnotation(name = "b", value = "b2")
+    @LabelAnnotation(
+            name = "a",
+            value = "a1"
+    )
+    @LabelAnnotation(
+            name = "a",
+            value = "a2"
+    )
+    @LabelAnnotation(
+            name = "b",
+            value = "b1"
+    )
+    @LabelAnnotation(
+            name = "b",
+            value = "b2"
+    )
     @interface CustomMultiLabel {
     }
 
@@ -200,34 +213,56 @@ void shouldSupportCustomMultiLabelAnnotations() {
     }
 
     @Link(name = "LINK-1")
-    @Links({
-            @Link(name = "LINK-2", url = "https://example.org/link/2"),
-            @Link(url = "https://example.org/some-custom-link")
-    })
+    @Links(
+        {
+                @Link(
+                        name = "LINK-2",
+                        url = "https://example.org/link/2"
+                ),
+                @Link(url = "https://example.org/some-custom-link")
+        }
+    )
     @TmsLink("TMS-1")
-    @TmsLinks({
-            @TmsLink("TMS-2"),
-            @TmsLink("TMS-3")
-    })
+    @TmsLinks(
+        {
+                @TmsLink("TMS-2"),
+                @TmsLink("TMS-3")
+        }
+    )
     @Issue("ISSUE-1")
-    @Issues({
-            @Issue("ISSUE-2"),
-            @Issue("ISSUE-3")
-    })
+    @Issues(
+        {
+                @Issue("ISSUE-2"),
+                @Issue("ISSUE-3")
+        }
+    )
     class WithLinks {
     }
 
-    @ResourceLock(value = SYSTEM_PROPERTIES, mode = READ_WRITE)
-    @SystemProperty(name = "allure.link.issue.pattern", value = "https://example.org/issue/{}")
-    @SystemProperty(name = "allure.link.tms.pattern", value = "https://example.org/tms/{}")
-    @SystemProperty(name = "allure.link.custom.pattern", value = "https://example.org/custom/{}")
+    @ResourceLock(
+            value = SYSTEM_PROPERTIES,
+            mode = READ_WRITE
+    )
+    @SystemProperty(
+            name = "allure.link.issue.pattern",
+            value = "https://example.org/issue/{}"
+    )
+    @SystemProperty(
+            name = "allure.link.tms.pattern",
+            value = "https://example.org/tms/{}"
+    )
+    @SystemProperty(
+            name = "allure.link.custom.pattern",
+            value = "https://example.org/custom/{}"
+    )
     @Test
     void shouldExtractLinks() {
         assertThat(getLinks(WithLinks.class))
                 .extracting(
                         io.qameta.allure.model.Link::getName,
                         io.qameta.allure.model.Link::getType,
-                        io.qameta.allure.model.Link::getUrl)
+                        io.qameta.allure.model.Link::getUrl
+                )
                 .contains(
                         tuple("LINK-1", "custom", "https://example.org/custom/LINK-1"),
                         tuple("LINK-2", "custom", "https://example.org/link/2"),
@@ -261,9 +296,18 @@ void shouldExtractLinks() {
     class WithCustomLink {
     }
 
-    @ResourceLock(value = SYSTEM_PROPERTIES, mode = READ_WRITE)
-    @SystemProperty(name = "allure.link.custom.pattern", value = "https://example.org/custom/{}")
-    @SystemProperty(name = "allure.link.issue.pattern", value = "https://example.org/issue/{}")
+    @ResourceLock(
+            value = SYSTEM_PROPERTIES,
+            mode = READ_WRITE
+    )
+    @SystemProperty(
+            name = "allure.link.custom.pattern",
+            value = "https://example.org/custom/{}"
+    )
+    @SystemProperty(
+            name = "allure.link.issue.pattern",
+            value = "https://example.org/issue/{}"
+    )
     @Test
     void shouldExtractCustomLinks() {
         assertThat(getLinks(WithCustomLink.class))
diff --git a/allure-java-commons/src/test/java/io/qameta/allure/util/NamingUtilsTest.java b/allure-java-commons/src/test/java/io/qameta/allure/util/NamingUtilsTest.java
index 37d21a70..9ffd5baf 100644
--- a/allure-java-commons/src/test/java/io/qameta/allure/util/NamingUtilsTest.java
+++ b/allure-java-commons/src/test/java/io/qameta/allure/util/NamingUtilsTest.java
@@ -27,13 +27,8 @@
 
 import static io.qameta.allure.util.NamingUtils.processNameTemplate;
 import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class NamingUtilsTest {
 
-
     public static Stream<Arguments> data() {
         return Stream.of(
                 Arguments.of("", Collections.singletonMap("a", "b"), ""),
@@ -52,7 +47,10 @@ public static Stream<Arguments> data() {
                 Arguments.of("Password: {user.password}", Collections.singletonMap("user", new DummyUser(null, "123", null)), "Password: 123"),
                 Arguments.of("Passwords: {users.password}", Collections.singletonMap("users", new DummyUser[]{new DummyUser(null, "123", null)}), "Passwords: [123]"),
                 Arguments.of("Passwords: {users.password}", Collections.singletonMap("users", new DummyUser[]{null, new DummyUser(null, "123", null)}), "Passwords: [null, 123]"),
-                Arguments.of("Passwords: {users.password}", Collections.singletonMap("users", new DummyUser[][]{null, {null, new DummyUser(null, "123", null)}}), "Passwords: [null, [null, 123]]")
+                Arguments.of(
+                        "Passwords: {users.password}", Collections.singletonMap("users", new DummyUser[][]{null, {null, new DummyUser(null, "123", null)}}),
+                        "Passwords: [null, [null, 123]]"
+                )
         );
     }
 
diff --git a/allure-java-commons/src/test/java/io/qameta/allure/util/ObjectUtilsTest.java b/allure-java-commons/src/test/java/io/qameta/allure/util/ObjectUtilsTest.java
index e28ee2cf..2a6ce280 100644
--- a/allure-java-commons/src/test/java/io/qameta/allure/util/ObjectUtilsTest.java
+++ b/allure-java-commons/src/test/java/io/qameta/allure/util/ObjectUtilsTest.java
@@ -19,10 +19,6 @@
 import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class ObjectUtilsTest {
 
     @Issue("191")
@@ -34,6 +30,20 @@ void shouldProcessToStringNpe() {
                 .isEqualTo("<NPE>");
     }
 
+    @Test
+    void shouldProcessArraysItemByItem() {
+        final Object[] array = {
+                "value",
+                "binary".getBytes(),
+                new MyNpeClass(),
+        };
+
+        final String string = ObjectUtils.toString(array);
+
+        assertThat(string)
+                .isEqualTo("[value, <BINARY>, <NPE>]");
+    }
+
     public class MyNpeClass {
 
         Integer value = null;
diff --git a/allure-java-commons/src/test/java/io/qameta/allure/util/ReflectionUtilsTest.java b/allure-java-commons/src/test/java/io/qameta/allure/util/ReflectionUtilsTest.java
new file mode 100644
index 00000000..d44db617
--- /dev/null
+++ b/allure-java-commons/src/test/java/io/qameta/allure/util/ReflectionUtilsTest.java
@@ -0,0 +1,180 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.util;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class ReflectionUtilsTest {
+
+    @Test
+    void shouldReadValueFromGetter() {
+        final Object value = ReflectionUtils.getValue(new GetterSample(), "value");
+
+        assertThat(value).isEqualTo("getter value");
+    }
+
+    @Test
+    void shouldPreferGetterOverField() {
+        final Object value = ReflectionUtils.getValue(new GetterAndFieldSample(), "value");
+
+        assertThat(value).isEqualTo("getter value");
+    }
+
+    @Test
+    void shouldReadValueFromRecordStyleMethod() {
+        final Object value = ReflectionUtils.getValue(new RecordStyleSample(), "value");
+
+        assertThat(value).isEqualTo("record value");
+    }
+
+    @Test
+    void shouldReadValueFromField() {
+        final Object value = ReflectionUtils.getValue(new FieldSample(), "value");
+
+        assertThat(value).isEqualTo("field value");
+    }
+
+    @Test
+    void shouldReadValueFromInheritedField() {
+        final Object value = ReflectionUtils.getValue(new ChildFieldSample(), "value");
+
+        assertThat(value).isEqualTo("parent field value");
+    }
+
+    @Test
+    void shouldReturnNullForMissingValue() {
+        final Object value = ReflectionUtils.getValue(new GetterSample(), "missing");
+
+        assertThat(value).isNull();
+    }
+
+    @Test
+    void shouldReadBooleanValueFromPrimitiveIsGetter() {
+        final Boolean value = ReflectionUtils.getBooleanValue(new PrimitiveBooleanSample(), "value");
+
+        assertThat(value).isFalse();
+    }
+
+    @Test
+    void shouldPreferPrimitiveIsGetterForBooleanValue() {
+        final Boolean value = ReflectionUtils.getBooleanValue(new PrimitiveIsAndGetSample(), "value");
+
+        assertThat(value).isFalse();
+    }
+
+    @Test
+    void shouldReadBooleanValueFromGetter() {
+        final Boolean value = ReflectionUtils.getBooleanValue(new BooleanGetterSample(), "value");
+
+        assertThat(value).isTrue();
+    }
+
+    @Test
+    void shouldReadBooleanValueFromField() {
+        final Boolean value = ReflectionUtils.getBooleanValue(new BooleanFieldSample(), "value");
+
+        assertThat(value).isFalse();
+    }
+
+    @Test
+    void shouldIgnoreBoxedBooleanIsGetter() {
+        final Boolean value = ReflectionUtils.getBooleanValue(new BoxedBooleanIsSample(), "value");
+
+        assertThat(value).isNull();
+    }
+
+    @Test
+    void shouldReturnNullForNonBooleanValue() {
+        final Boolean value = ReflectionUtils.getBooleanValue(new GetterSample(), "value");
+
+        assertThat(value).isNull();
+    }
+
+    static class GetterSample {
+
+        public String getValue() {
+            return "getter value";
+        }
+    }
+
+    static class GetterAndFieldSample {
+
+        private final String value = "field value";
+
+        public String getValue() {
+            return "getter value";
+        }
+    }
+
+    static class RecordStyleSample {
+
+        public String value() {
+            return "record value";
+        }
+    }
+
+    static class FieldSample {
+
+        private final String value = "field value";
+    }
+
+    static class ParentFieldSample {
+
+        private final String value = "parent field value";
+    }
+
+    static class ChildFieldSample extends ParentFieldSample {
+    }
+
+    static class PrimitiveBooleanSample {
+
+        public boolean isValue() {
+            return false;
+        }
+    }
+
+    static class PrimitiveIsAndGetSample {
+
+        public boolean isValue() {
+            return false;
+        }
+
+        public Boolean getValue() {
+            return true;
+        }
+    }
+
+    static class BooleanGetterSample {
+
+        public Boolean getValue() {
+            return true;
+        }
+    }
+
+    static class BooleanFieldSample {
+
+        private final Boolean value = false;
+    }
+
+    static class BoxedBooleanIsSample {
+
+        public Boolean isValue() {
+            return true;
+        }
+    }
+}
diff --git a/allure-java-commons/src/test/resources/allure.properties b/allure-java-commons/src/test/resources/allure.properties
index e4f1d9fc..9f941c45 100644
--- a/allure-java-commons/src/test/resources/allure.properties
+++ b/allure-java-commons/src/test/resources/allure.properties
@@ -1,3 +1,4 @@
 allure.results.directory=build/allure-results
 allure.link.issue.pattern=https://github.com/allure-framework/allure-java/issues/{}
 allure.label.epic=#project.description#
+allure.label.module=allure-java-commons
diff --git a/allure-jax-rs/src/main/java/io/qameta/allure/jaxrs/AllureJaxRs.java b/allure-jax-rs/src/main/java/io/qameta/allure/jaxrs/AllureJaxRs.java
index c6f83127..cdfcbaf5 100644
--- a/allure-jax-rs/src/main/java/io/qameta/allure/jaxrs/AllureJaxRs.java
+++ b/allure-jax-rs/src/main/java/io/qameta/allure/jaxrs/AllureJaxRs.java
@@ -28,6 +28,7 @@
 import javax.ws.rs.client.ClientResponseContext;
 import javax.ws.rs.client.ClientResponseFilter;
 import javax.ws.rs.core.MultivaluedMap;
+
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
@@ -46,6 +47,9 @@ public class AllureJaxRs implements ClientRequestFilter, ClientResponseFilter {
     private final AttachmentRenderer<AttachmentData> responseRenderer;
     private final AttachmentProcessor<AttachmentData> processor;
 
+    /**
+     * Creates an Allure jax rs with default configuration.
+     */
     @SuppressWarnings("unused")
     public AllureJaxRs() {
         this(
@@ -55,6 +59,13 @@ public AllureJaxRs() {
         );
     }
 
+    /**
+     * Creates an Allure jax rs with the supplied values.
+     *
+     * @param requestRenderer the renderer used for request attachments
+     * @param responseRenderer the renderer used for response attachments
+     * @param processor the processor used to write rendered attachments
+     */
     public AllureJaxRs(final AttachmentRenderer<AttachmentData> requestRenderer,
                        final AttachmentRenderer<AttachmentData> responseRenderer,
                        final AttachmentProcessor<AttachmentData> processor) {
@@ -63,6 +74,9 @@ public AllureJaxRs(final AttachmentRenderer<AttachmentData> requestRenderer,
         this.processor = processor;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void filter(final ClientRequestContext requestContext) {
 
@@ -82,9 +96,13 @@ public void filter(final ClientRequestContext requestContext) {
         processor.addAttachment(responseAttachment, requestRenderer);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void filter(final ClientRequestContext requestContext,
-                       final ClientResponseContext responseContext) throws IOException {
+                       final ClientResponseContext responseContext)
+            throws IOException {
 
         final HttpResponseAttachment.Builder responseAttachmentBuilder = HttpResponseAttachment.Builder
                 .create("Response")
@@ -106,7 +124,7 @@ private static Map<String, String> toMapConverter(final MultivaluedMap<String, O
 
     private String getBody(final ClientResponseContext responseContext) throws IOException {
         try (InputStream stream = responseContext.getEntityStream();
-             ByteArrayOutputStream result = new ByteArrayOutputStream()) {
+                ByteArrayOutputStream result = new ByteArrayOutputStream()) {
             final byte[] buffer = new byte[1024];
 
             int length = stream.read(buffer);
diff --git a/allure-jax-rs/src/test/java/io/qameta/allure/httpclient/AllureJaxRsTest.java b/allure-jax-rs/src/test/java/io/qameta/allure/httpclient/AllureJaxRsTest.java
index 30b1d724..42a34830 100644
--- a/allure-jax-rs/src/test/java/io/qameta/allure/httpclient/AllureJaxRsTest.java
+++ b/allure-jax-rs/src/test/java/io/qameta/allure/httpclient/AllureJaxRsTest.java
@@ -30,6 +30,7 @@
 import javax.ws.rs.client.ClientBuilder;
 import javax.ws.rs.core.Response;
 import javax.ws.rs.core.UriBuilder;
+
 import java.net.URI;
 import java.util.List;
 import java.util.Objects;
@@ -45,10 +46,6 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @Disabled("failures due to closed stream")
 class AllureJaxRsTest {
 
@@ -63,9 +60,13 @@ void setUp() {
         server.start();
         configureFor(server.port());
 
-        stubFor(get(urlEqualTo("/hello"))
-                .willReturn(aResponse()
-                        .withBody(BODY_STRING)));
+        stubFor(
+                get(urlEqualTo("/hello"))
+                        .willReturn(
+                                aResponse()
+                                        .withBody(BODY_STRING)
+                        )
+        );
     }
 
     @AfterEach
@@ -137,7 +138,6 @@ void shouldCreateResponseAttachment() {
             }
         }
 
-
         final ArgumentCaptor<AttachmentData> captor = ArgumentCaptor.forClass(AttachmentData.class);
         verify(processor, times(1))
                 .addAttachment(captor.capture(), eq(responseRenderer));
diff --git a/allure-jax-rs/src/test/resources/allure.properties b/allure-jax-rs/src/test/resources/allure.properties
index 9c0b0a2d..cd2d7056 100644
--- a/allure-jax-rs/src/test/resources/allure.properties
+++ b/allure-jax-rs/src/test/resources/allure.properties
@@ -1,2 +1,3 @@
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-jax-rs
diff --git a/allure-jbehave/src/main/java/io/qameta/allure/jbehave/AllureJbehave.java b/allure-jbehave/src/main/java/io/qameta/allure/jbehave/AllureJbehave.java
index 2acd047d..bd685a85 100644
--- a/allure-jbehave/src/main/java/io/qameta/allure/jbehave/AllureJbehave.java
+++ b/allure-jbehave/src/main/java/io/qameta/allure/jbehave/AllureJbehave.java
@@ -50,6 +50,7 @@
 import static io.qameta.allure.util.ResultsUtils.createParameter;
 import static io.qameta.allure.util.ResultsUtils.createStoryLabel;
 import static io.qameta.allure.util.ResultsUtils.createThreadLabel;
+import static io.qameta.allure.util.ResultsUtils.createTitlePath;
 import static io.qameta.allure.util.ResultsUtils.getMd5Digest;
 import static io.qameta.allure.util.ResultsUtils.getStatus;
 import static io.qameta.allure.util.ResultsUtils.getStatusDetails;
@@ -60,7 +61,9 @@
 import static java.util.Comparator.comparing;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Reports JBehave story execution to Allure.
+ *
+ * <p>Configure this reporter in JBehave so story, scenario, example, and step events become Allure containers, test results, steps, labels, and parameters. Use the default lifecycle for normal runs or pass a lifecycle for tests and embedded runtimes.</p>
  */
 public class AllureJbehave extends NullStoryReporter {
 
@@ -76,15 +79,26 @@ public class AllureJbehave extends NullStoryReporter {
 
     private final ReadWriteLock lock = new ReentrantReadWriteLock();
 
+    /**
+     * Creates an Allure jbehave with default configuration.
+     */
     @SuppressWarnings("unused")
     public AllureJbehave() {
         this(Allure.getLifecycle());
     }
 
+    /**
+     * Creates an Allure jbehave with the supplied values.
+     *
+     * @param lifecycle the Allure lifecycle to use
+     */
     public AllureJbehave(final AllureLifecycle lifecycle) {
         this.lifecycle = lifecycle;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void beforeStory(final Story story, final boolean givenStory) {
         if (givenStory) {
@@ -94,6 +108,9 @@ public void beforeStory(final Story story, final boolean givenStory) {
         }
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void afterStory(final boolean givenStory) {
         if (givenStory) {
@@ -103,6 +120,9 @@ public void afterStory(final boolean givenStory) {
         }
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void beforeScenario(final Scenario scenario) {
         if (isGivenStory()) {
@@ -119,6 +139,9 @@ public void beforeScenario(final Scenario scenario) {
         }
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void beforeExamples(final List<String> steps, final ExamplesTable table) {
         if (isGivenStory()) {
@@ -133,6 +156,9 @@ public void beforeExamples(final List<String> steps, final ExamplesTable table)
         }
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void example(final Map<String, String> tableRow, final int exampleIndex) {
         if (isGivenStory()) {
@@ -144,6 +170,9 @@ public void example(final Map<String, String> tableRow, final int exampleIndex)
         startTestCase(uuid, scenario, tableRow);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void afterScenario() {
         if (isGivenStory()) {
@@ -158,12 +187,18 @@ public void afterScenario() {
         usingWriteLock(() -> scenarioUuids.remove(scenario));
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void beforeStep(final String step) {
         final String stepUuid = UUID.randomUUID().toString();
         getLifecycle().startStep(stepUuid, new StepResult().setName(step));
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void successful(final String step) {
         getLifecycle().updateTestCase(result -> result.setStatus(Status.PASSED));
@@ -171,12 +206,18 @@ public void successful(final String step) {
         getLifecycle().stopStep();
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void ignorable(final String step) {
         beforeStep(step);
         getLifecycle().stopStep();
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void pending(final String step) {
         beforeStep(step);
@@ -184,19 +225,24 @@ public void pending(final String step) {
         getLifecycle().stopStep();
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void notPerformed(final String step) {
         beforeStep(step);
         getLifecycle().stopStep();
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void failed(final String step, final Throwable cause) {
         final Throwable unwrapped = cause instanceof UUIDExceptionWrapper
                 ? cause.getCause()
                 : cause;
 
-
         final Status status = getStatus(unwrapped).orElse(Status.FAILED);
         final StatusDetails statusDetails = getStatusDetails(unwrapped).orElseGet(StatusDetails::new);
 
@@ -213,11 +259,22 @@ public void failed(final String step, final Throwable cause) {
         getLifecycle().stopStep();
     }
 
-
+    /**
+     * Returns the lifecycle.
+     *
+     * @return the Allure lifecycle used by this integration
+     */
     public AllureLifecycle getLifecycle() {
         return lifecycle;
     }
 
+    /**
+     * Handles the start test case callback.
+     *
+     * @param uuid the Allure UUID of the model object
+     * @param scenario the scenario
+     * @param tableRow the table row
+     */
     protected void startTestCase(final String uuid,
                                  final Scenario scenario,
                                  final Map<String, String> tableRow) {
@@ -245,6 +302,7 @@ protected void startTestCase(final String uuid,
                 .setName(name)
                 .setFullName(fullName)
                 .setStage(Stage.SCHEDULED)
+                .setTitlePath(getTitlePath(story))
                 .setLabels(labels)
                 .setParameters(parameters)
                 .setDescription(story.getDescription().asString())
@@ -254,15 +312,40 @@ protected void startTestCase(final String uuid,
         getLifecycle().startTestCase(result.getUuid());
     }
 
+    private List<String> getTitlePath(final Story story) {
+        if (story.getPath() == null) {
+            return createTitlePath();
+        }
+        return createTitlePath(Arrays.asList(story.getPath().replace('\\', '/').split("/")));
+    }
+
+    /**
+     * Handles the stop test case callback.
+     *
+     * @param uuid the Allure UUID of the model object
+     */
     protected void stopTestCase(final String uuid) {
         getLifecycle().stopTestCase(uuid);
         getLifecycle().writeTestCase(uuid);
     }
 
+    /**
+     * Returns the not parameterised.
+     *
+     * @param scenario the scenario
+     * @return true when the condition is satisfied; false otherwise
+     */
     protected boolean notParameterised(final Scenario scenario) {
         return scenario.getExamplesTable().getRowCount() == 0;
     }
 
+    /**
+     * Returns the history id.
+     *
+     * @param fullName the fully qualified test name
+     * @param parameters the Allure parameters associated with the test
+     * @return the history id
+     */
     protected String getHistoryId(final String fullName, final List<Parameter> parameters) {
         final MessageDigest digest = getMd5Digest();
         digest.update(fullName.getBytes(UTF_8));
diff --git a/allure-jbehave/src/test/java/io/qameta/allure/jbehave/AllureJbehaveTest.java b/allure-jbehave/src/test/java/io/qameta/allure/jbehave/AllureJbehaveTest.java
index c57a6e45..65c741d3 100644
--- a/allure-jbehave/src/test/java/io/qameta/allure/jbehave/AllureJbehaveTest.java
+++ b/allure-jbehave/src/test/java/io/qameta/allure/jbehave/AllureJbehaveTest.java
@@ -46,10 +46,6 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.tuple;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class AllureJbehaveTest {
 
     @TempDir
@@ -99,7 +95,6 @@ void shouldSetStatus() {
                 .containsExactlyInAnyOrder(Status.PASSED);
     }
 
-
     @Test
     void shouldSetFailedStatus() {
         final AllureResults results = runStories("stories/failed.story");
@@ -167,6 +162,8 @@ void shouldSetFullName() {
         assertThat(results.getTestResults())
                 .extracting(TestResult::getFullName)
                 .containsExactlyInAnyOrder("simple.story: Add a to b");
+        assertThat(results.getTestResults().get(0).getTitlePath())
+                .containsExactly("stories", "simple.story");
     }
 
     @Test
@@ -174,7 +171,7 @@ void shouldSetDescription() {
         final AllureResults results = runStories("stories/description.story");
 
         final String expected = "This is description for current story.\n"
-                                + "It should appear on each scenario in report";
+                + "It should appear on each scenario in report";
 
         assertThat(results.getTestResults())
                 .extracting(TestResult::getDescription)
@@ -268,22 +265,25 @@ private AllureResults runStories(final String... storyResources) {
         return RunUtils.runTests(lifecycle -> {
             final Embedder embedder = new Embedder();
             embedder.useEmbedderMonitor(new NullEmbedderMonitor());
-            embedder.useEmbedderControls(new EmbedderControls()
-                    .doGenerateViewAfterStories(false)
-                    .doFailOnStoryTimeout(false)
-                    .doBatch(false)
-                    .doIgnoreFailureInStories(true)
-                    .doIgnoreFailureInView(true)
-                    .doVerboseFailures(false)
-                    .doVerboseFiltering(false)
+            embedder.useEmbedderControls(
+                    new EmbedderControls()
+                            .doGenerateViewAfterStories(false)
+                            .doFailOnStoryTimeout(false)
+                            .doBatch(false)
+                            .doIgnoreFailureInStories(true)
+                            .doIgnoreFailureInView(true)
+                            .doVerboseFailures(false)
+                            .doVerboseFiltering(false)
             );
             final AllureJbehave allureJbehave = new AllureJbehave(lifecycle);
-            embedder.useConfiguration(new MostUsefulConfiguration()
-                    .useStoryLoader(new LoadFromClasspath(this.getClass()))
-                    .useStoryReporterBuilder(new ReportlessStoryReporterBuilder(temp.toFile())
-                            .withReporters(allureJbehave)
-                    )
-                    .useDefaultStoryReporter(new NullStoryReporter())
+            embedder.useConfiguration(
+                    new MostUsefulConfiguration()
+                            .useStoryLoader(new LoadFromClasspath(this.getClass()))
+                            .useStoryReporterBuilder(
+                                    new ReportlessStoryReporterBuilder(temp.toFile())
+                                            .withReporters(allureJbehave)
+                            )
+                            .useDefaultStoryReporter(new NullStoryReporter())
             );
             final InjectableStepsFactory stepsFactory = new InstanceStepsFactory(
                     embedder.configuration(),
diff --git a/allure-jbehave/src/test/java/io/qameta/allure/jbehave/LoggingReporter.java b/allure-jbehave/src/test/java/io/qameta/allure/jbehave/LoggingReporter.java
index 4f3d3f53..49c56cc7 100644
--- a/allure-jbehave/src/test/java/io/qameta/allure/jbehave/LoggingReporter.java
+++ b/allure-jbehave/src/test/java/io/qameta/allure/jbehave/LoggingReporter.java
@@ -26,10 +26,6 @@
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @SuppressWarnings("unused")
 class LoggingReporter extends NullStoryReporter {
 
diff --git a/allure-jbehave/src/test/java/io/qameta/allure/jbehave/samples/BrokenStorySteps.java b/allure-jbehave/src/test/java/io/qameta/allure/jbehave/samples/BrokenStorySteps.java
index 67cd8893..edf377c0 100644
--- a/allure-jbehave/src/test/java/io/qameta/allure/jbehave/samples/BrokenStorySteps.java
+++ b/allure-jbehave/src/test/java/io/qameta/allure/jbehave/samples/BrokenStorySteps.java
@@ -16,10 +16,6 @@
 package io.qameta.allure.jbehave.samples;
 
 import org.jbehave.core.annotations.Given;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class BrokenStorySteps {
 
     @Given("everything is broken")
diff --git a/allure-jbehave/src/test/java/io/qameta/allure/jbehave/samples/SimpleStorySteps.java b/allure-jbehave/src/test/java/io/qameta/allure/jbehave/samples/SimpleStorySteps.java
index 3189964b..274a52c7 100644
--- a/allure-jbehave/src/test/java/io/qameta/allure/jbehave/samples/SimpleStorySteps.java
+++ b/allure-jbehave/src/test/java/io/qameta/allure/jbehave/samples/SimpleStorySteps.java
@@ -20,10 +20,6 @@
 import org.jbehave.core.annotations.When;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class SimpleStorySteps {
 
     private int a;
diff --git a/allure-jbehave/src/test/resources/allure.properties b/allure-jbehave/src/test/resources/allure.properties
index 9c0b0a2d..04f5f5b6 100644
--- a/allure-jbehave/src/test/resources/allure.properties
+++ b/allure-jbehave/src/test/resources/allure.properties
@@ -1,2 +1,3 @@
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-jbehave
diff --git a/allure-jbehave5/src/main/java/io/qameta/allure/jbehave5/AllureJbehave5.java b/allure-jbehave5/src/main/java/io/qameta/allure/jbehave5/AllureJbehave5.java
index 81e34736..a2818a94 100644
--- a/allure-jbehave5/src/main/java/io/qameta/allure/jbehave5/AllureJbehave5.java
+++ b/allure-jbehave5/src/main/java/io/qameta/allure/jbehave5/AllureJbehave5.java
@@ -54,6 +54,7 @@
 import static io.qameta.allure.util.ResultsUtils.createParameter;
 import static io.qameta.allure.util.ResultsUtils.createStoryLabel;
 import static io.qameta.allure.util.ResultsUtils.createThreadLabel;
+import static io.qameta.allure.util.ResultsUtils.createTitlePath;
 import static io.qameta.allure.util.ResultsUtils.getMd5Digest;
 import static io.qameta.allure.util.ResultsUtils.getStatus;
 import static io.qameta.allure.util.ResultsUtils.getStatusDetails;
@@ -63,6 +64,11 @@
 import static java.util.Collections.singletonList;
 import static java.util.Comparator.comparing;
 
+/**
+ * Reports JBehave 5 story execution to Allure.
+ *
+ * <p>Configure this reporter in JBehave so story, scenario, example, and step events become Allure containers, test results, steps, labels, and parameters. Use the default lifecycle for normal runs or pass a lifecycle for tests and embedded runtimes.</p>
+ */
 public class AllureJbehave5 extends NullStoryReporter {
 
     private final AllureLifecycle lifecycle;
@@ -77,15 +83,26 @@ public class AllureJbehave5 extends NullStoryReporter {
 
     private final ReadWriteLock lock = new ReentrantReadWriteLock();
 
+    /**
+     * Creates an Allure jbehave5 with default configuration.
+     */
     @SuppressWarnings("unused")
     public AllureJbehave5() {
         this(Allure.getLifecycle());
     }
 
+    /**
+     * Creates an Allure jbehave5 with the supplied values.
+     *
+     * @param lifecycle the Allure lifecycle to use
+     */
     public AllureJbehave5(final AllureLifecycle lifecycle) {
         this.lifecycle = lifecycle;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void beforeStory(final Story story, final boolean givenStory) {
         if (givenStory) {
@@ -95,6 +112,9 @@ public void beforeStory(final Story story, final boolean givenStory) {
         }
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void afterStory(final boolean givenStory) {
         if (givenStory) {
@@ -104,6 +124,9 @@ public void afterStory(final boolean givenStory) {
         }
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void beforeScenario(final Scenario scenario) {
         if (isGivenStory()) {
@@ -120,6 +143,9 @@ public void beforeScenario(final Scenario scenario) {
         }
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void beforeExamples(final List<String> steps, final ExamplesTable table) {
         if (isGivenStory()) {
@@ -134,6 +160,9 @@ public void beforeExamples(final List<String> steps, final ExamplesTable table)
         }
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void example(final Map<String, String> tableRow, final int exampleIndex) {
         if (isGivenStory()) {
@@ -145,6 +174,9 @@ public void example(final Map<String, String> tableRow, final int exampleIndex)
         startTestCase(uuid, scenario, tableRow);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void afterScenario(final Timing timing) {
         if (isGivenStory()) {
@@ -159,12 +191,18 @@ public void afterScenario(final Timing timing) {
         usingWriteLock(() -> scenarioUuids.remove(scenario));
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void beforeStep(final Step step) {
         final String stepUuid = UUID.randomUUID().toString();
         getLifecycle().startStep(stepUuid, new StepResult().setName(step.getStepAsString()));
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void successful(final String step) {
         getLifecycle().updateTestCase(result -> result.setStatus(Status.PASSED));
@@ -172,29 +210,40 @@ public void successful(final String step) {
         getLifecycle().stopStep();
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void ignorable(final String step) {
         getLifecycle().stopStep();
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void pending(final StepCreator.PendingStep step) {
         getLifecycle().updateStep(result -> result.setStatus(Status.SKIPPED));
         getLifecycle().stopStep();
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void notPerformed(final String step) {
         getLifecycle().stopStep();
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void failed(final String step, final Throwable cause) {
         final Throwable unwrapped = cause instanceof UUIDExceptionWrapper
                 ? cause.getCause()
                 : cause;
 
-
         final Status status = getStatus(unwrapped).orElse(Status.FAILED);
         final StatusDetails statusDetails = getStatusDetails(unwrapped).orElseGet(StatusDetails::new);
 
@@ -211,11 +260,22 @@ public void failed(final String step, final Throwable cause) {
         getLifecycle().stopStep();
     }
 
-
+    /**
+     * Returns the lifecycle.
+     *
+     * @return the Allure lifecycle used by this integration
+     */
     public AllureLifecycle getLifecycle() {
         return lifecycle;
     }
 
+    /**
+     * Handles the start test case callback.
+     *
+     * @param uuid the Allure UUID of the model object
+     * @param scenario the scenario
+     * @param tableRow the table row
+     */
     protected void startTestCase(final String uuid,
                                  final Scenario scenario,
                                  final Map<String, String> tableRow) {
@@ -228,13 +288,15 @@ protected void startTestCase(final String uuid,
                 .map(entry -> createParameter(entry.getKey(), entry.getValue()))
                 .collect(Collectors.toList());
 
-        final List<Label> labels = new ArrayList<>(Arrays.asList(
-                createStoryLabel(story.getName()),
-                createHostLabel(),
-                createThreadLabel(),
-                createFrameworkLabel("jbehave"),
-                createLanguageLabel("java")
-        ));
+        final List<Label> labels = new ArrayList<>(
+                Arrays.asList(
+                        createStoryLabel(story.getName()),
+                        createHostLabel(),
+                        createThreadLabel(),
+                        createFrameworkLabel("jbehave"),
+                        createLanguageLabel("java")
+                )
+        );
 
         labels.addAll(ResultsUtils.getProvidedLabels());
 
@@ -245,6 +307,7 @@ protected void startTestCase(final String uuid,
                 .setName(name)
                 .setFullName(fullName)
                 .setStage(Stage.SCHEDULED)
+                .setTitlePath(getTitlePath(story))
                 .setLabels(labels)
                 .setParameters(parameters)
                 .setDescription(story.getDescription().asString())
@@ -254,15 +317,40 @@ protected void startTestCase(final String uuid,
         getLifecycle().startTestCase(result.getUuid());
     }
 
+    private List<String> getTitlePath(final Story story) {
+        if (story.getPath() == null) {
+            return createTitlePath();
+        }
+        return createTitlePath(Arrays.asList(story.getPath().replace('\\', '/').split("/")));
+    }
+
+    /**
+     * Handles the stop test case callback.
+     *
+     * @param uuid the Allure UUID of the model object
+     */
     protected void stopTestCase(final String uuid) {
         getLifecycle().stopTestCase(uuid);
         getLifecycle().writeTestCase(uuid);
     }
 
+    /**
+     * Returns the not parameterised.
+     *
+     * @param scenario the scenario
+     * @return true when the condition is satisfied; false otherwise
+     */
     protected boolean notParameterised(final Scenario scenario) {
         return scenario.getExamplesTable().getRowCount() == 0;
     }
 
+    /**
+     * Returns the history id.
+     *
+     * @param fullName the fully qualified test name
+     * @param parameters the Allure parameters associated with the test
+     * @return the history id
+     */
     protected String getHistoryId(final String fullName, final List<Parameter> parameters) {
         final MessageDigest digest = getMd5Digest();
         digest.update(fullName.getBytes(UTF_8));
diff --git a/allure-jbehave5/src/test/java/io/qameta/allure/jbehave5/AllureJbehave5Test.java b/allure-jbehave5/src/test/java/io/qameta/allure/jbehave5/AllureJbehave5Test.java
index 1c5c153d..30ad5203 100644
--- a/allure-jbehave5/src/test/java/io/qameta/allure/jbehave5/AllureJbehave5Test.java
+++ b/allure-jbehave5/src/test/java/io/qameta/allure/jbehave5/AllureJbehave5Test.java
@@ -98,7 +98,6 @@ void shouldSetStatus() {
                 .containsExactlyInAnyOrder(Status.PASSED);
     }
 
-
     @Test
     void shouldSetFailedStatus() {
         final AllureResults results = runStories("stories/failed.story");
@@ -166,6 +165,8 @@ void shouldSetFullName() {
         assertThat(results.getTestResults())
                 .extracting(TestResult::getFullName)
                 .containsExactlyInAnyOrder("simple.story: Add a to b");
+        assertThat(results.getTestResults().get(0).getTitlePath())
+                .containsExactly("stories", "simple.story");
     }
 
     @Test
@@ -173,7 +174,7 @@ void shouldSetDescription() {
         final AllureResults results = runStories("stories/description.story");
 
         final String expected = "This is description for current story.\n"
-                                + "It should appear on each scenario in report";
+                + "It should appear on each scenario in report";
 
         assertThat(results.getTestResults())
                 .extracting(TestResult::getDescription)
@@ -307,22 +308,25 @@ private AllureResults runStories(final String... storyResources) {
         return RunUtils.runTests(lifecycle -> {
             final Embedder embedder = new Embedder();
             embedder.useEmbedderMonitor(new NullEmbedderMonitor());
-            embedder.useEmbedderControls(new EmbedderControls()
-                    .doGenerateViewAfterStories(false)
-                    .doFailOnStoryTimeout(false)
-                    .doBatch(false)
-                    .doIgnoreFailureInStories(true)
-                    .doIgnoreFailureInView(true)
-                    .doVerboseFailures(false)
-                    .doVerboseFiltering(false)
+            embedder.useEmbedderControls(
+                    new EmbedderControls()
+                            .doGenerateViewAfterStories(false)
+                            .doFailOnStoryTimeout(false)
+                            .doBatch(false)
+                            .doIgnoreFailureInStories(true)
+                            .doIgnoreFailureInView(true)
+                            .doVerboseFailures(false)
+                            .doVerboseFiltering(false)
             );
             final AllureJbehave5 allureJbehave5 = new AllureJbehave5(lifecycle);
-            embedder.useConfiguration(new MostUsefulConfiguration()
-                    .useStoryLoader(new LoadFromClasspath(this.getClass()))
-                    .useStoryReporterBuilder(new ReportlessStoryReporterBuilder(temp.toFile())
-                            .withReporters(allureJbehave5)
-                    )
-                    .useDefaultStoryReporter(new NullStoryReporter())
+            embedder.useConfiguration(
+                    new MostUsefulConfiguration()
+                            .useStoryLoader(new LoadFromClasspath(this.getClass()))
+                            .useStoryReporterBuilder(
+                                    new ReportlessStoryReporterBuilder(temp.toFile())
+                                            .withReporters(allureJbehave5)
+                            )
+                            .useDefaultStoryReporter(new NullStoryReporter())
             );
             final InjectableStepsFactory stepsFactory = new InstanceStepsFactory(
                     embedder.configuration(),
diff --git a/allure-jbehave5/src/test/resources/allure.properties b/allure-jbehave5/src/test/resources/allure.properties
index 9c0b0a2d..d61e9c1d 100644
--- a/allure-jbehave5/src/test/resources/allure.properties
+++ b/allure-jbehave5/src/test/resources/allure.properties
@@ -1,2 +1,3 @@
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-jbehave5
diff --git a/allure-jooq/src/main/java/io/qameta/allure/jooq/AllureJooq.java b/allure-jooq/src/main/java/io/qameta/allure/jooq/AllureJooq.java
index c9f4600c..4015a1d8 100644
--- a/allure-jooq/src/main/java/io/qameta/allure/jooq/AllureJooq.java
+++ b/allure-jooq/src/main/java/io/qameta/allure/jooq/AllureJooq.java
@@ -32,26 +32,36 @@
 import static java.lang.Boolean.FALSE;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Captures jOOQ query execution as Allure steps.
+ *
+ * <p>Register this execute listener in jOOQ configuration to report SQL rendering, record fetching, result processing, and execution failures. Pass a lifecycle when tests or embedded runtimes need isolation.</p>
  */
-@SuppressWarnings("PMD.NonSerializableClass")
 public class AllureJooq implements ExecuteListener {
 
-    private static final String STEP_UUID
-            = "io.qameta.allure.jooq.AllureJooq.STEP_UUID";
-    private static final String DO_BUFFER
-            = "io.qameta.allure.jooq.AllureJooq.DO_BUFFER";
+    private static final String STEP_UUID = "io.qameta.allure.jooq.AllureJooq.STEP_UUID";
+    private static final String DO_BUFFER = "io.qameta.allure.jooq.AllureJooq.DO_BUFFER";
 
     private final AllureLifecycle lifecycle;
 
+    /**
+     * Creates an Allure jooq with default configuration.
+     */
     public AllureJooq() {
         this(Allure.getLifecycle());
     }
 
+    /**
+     * Creates an Allure jooq with the supplied values.
+     *
+     * @param lifecycle the Allure lifecycle to use
+     */
     public AllureJooq(final AllureLifecycle lifecycle) {
         this.lifecycle = lifecycle;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void renderEnd(final ExecuteContext ctx) {
         if (!lifecycle.getCurrentTestCaseOrStep().isPresent()) {
@@ -61,8 +71,9 @@ public void renderEnd(final ExecuteContext ctx) {
         final String stepName = stepName(ctx);
         final String uuid = UUID.randomUUID().toString();
         ctx.data(STEP_UUID, uuid);
-        lifecycle.startStep(uuid, new StepResult()
-                .setName(stepName)
+        lifecycle.startStep(
+                uuid, new StepResult()
+                        .setName(stepName)
         );
     }
 
@@ -89,6 +100,9 @@ private String stepName(final ExecuteContext ctx) {
         return "UNKNOWN";
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void recordEnd(final ExecuteContext ctx) {
         if (ctx.recordLevel() > 0) {
@@ -105,11 +119,17 @@ public void recordEnd(final ExecuteContext ctx) {
         }
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void resultStart(final ExecuteContext ctx) {
         ctx.data(DO_BUFFER, false);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void resultEnd(final ExecuteContext ctx) {
         if (!lifecycle.getCurrentTestCaseOrStep().isPresent()) {
@@ -119,6 +139,9 @@ public void resultEnd(final ExecuteContext ctx) {
         attachResultSet(ctx.result());
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void end(final ExecuteContext ctx) {
         if (!lifecycle.getCurrentTestCaseOrStep().isPresent()) {
diff --git a/allure-jooq/src/test/java/io/qameta/allure/jooq/AllureJooqTest.java b/allure-jooq/src/test/java/io/qameta/allure/jooq/AllureJooqTest.java
index bd0b241b..2c273cb5 100644
--- a/allure-jooq/src/test/java/io/qameta/allure/jooq/AllureJooqTest.java
+++ b/allure-jooq/src/test/java/io/qameta/allure/jooq/AllureJooqTest.java
@@ -36,6 +36,7 @@
 import org.junit.jupiter.api.Test;
 
 import javax.sql.DataSource;
+
 import java.io.IOException;
 import java.io.UncheckedIOException;
 import java.nio.charset.StandardCharsets;
@@ -44,10 +45,6 @@
 import static io.qameta.allure.test.RunUtils.runWithinTestContext;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.tuple;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class AllureJooqTest {
 
     @Test
diff --git a/allure-junit5-assert/src/test/resources/allure.properties b/allure-jooq/src/test/resources/allure.properties
similarity index 72%
rename from allure-junit5-assert/src/test/resources/allure.properties
rename to allure-jooq/src/test/resources/allure.properties
index 9c0b0a2d..d86adbae 100644
--- a/allure-junit5-assert/src/test/resources/allure.properties
+++ b/allure-jooq/src/test/resources/allure.properties
@@ -1,2 +1,3 @@
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-jooq
diff --git a/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/AbstractJsonPatchMatcher.java b/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/AbstractJsonPatchMatcher.java
index ba0f0647..46ff50ee 100644
--- a/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/AbstractJsonPatchMatcher.java
+++ b/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/AbstractJsonPatchMatcher.java
@@ -15,10 +15,6 @@
  */
 package io.qameta.allure.jsonunit;
 
-import java.math.BigDecimal;
-
-import org.hamcrest.Matcher;
-
 import net.javacrumbs.jsonunit.core.Configuration;
 import net.javacrumbs.jsonunit.core.ConfigurationWhen.ApplicableForPath;
 import net.javacrumbs.jsonunit.core.ConfigurationWhen.PathsParam;
@@ -26,6 +22,9 @@
 import net.javacrumbs.jsonunit.core.internal.Diff;
 import net.javacrumbs.jsonunit.core.internal.Options;
 import net.javacrumbs.jsonunit.core.listener.DifferenceListener;
+import org.hamcrest.Matcher;
+
+import java.math.BigDecimal;
 
 /**
  * Contains basic matcher functionality and implementation of methods for matching configuration.
@@ -41,46 +40,104 @@ public abstract class AbstractJsonPatchMatcher<T> {
     private Configuration configuration = Configuration.empty();
     private String differences;
 
+    /**
+     * Configures the tolerance.
+     *
+     * @param tolerance the tolerance
+     * @return this instance for method chaining
+     */
     public T withTolerance(final BigDecimal tolerance) {
         this.configuration = configuration.withTolerance(tolerance);
         return (T) this;
     }
 
+    /**
+     * Configures the tolerance.
+     *
+     * @param tolerance the tolerance
+     * @return this instance for method chaining
+     */
     public T withTolerance(final double tolerance) {
         this.configuration = configuration.withTolerance(tolerance);
         return (T) this;
     }
 
+    /**
+     * Applies JsonUnit matching options.
+     *
+     * @param first the first
+     * @param next the next
+     * @return this matcher for method chaining
+     */
     public T when(final Option first, final Option... next) {
         this.configuration = configuration.when(first, next);
         return (T) this;
     }
 
+    /**
+     * Applies JsonUnit matching options.
+     *
+     * @param pathsParam the paths param
+     * @param applicableForPaths the applicable for paths
+     * @return this matcher for method chaining
+     */
     public T when(final PathsParam pathsParam, final ApplicableForPath... applicableForPaths) {
         this.configuration = this.configuration.when(pathsParam, applicableForPaths);
         return (T) this;
     }
 
+    /**
+     * Configures the options.
+     *
+     * @param options the options
+     * @return this instance for method chaining
+     */
     public T withOptions(final Options options) {
         this.configuration = configuration.withOptions(options);
         return (T) this;
     }
 
+    /**
+     * Configures the matcher.
+     *
+     * @param matcherName the matcher name
+     * @param matcher the matcher
+     * @return this instance for method chaining
+     */
     public T withMatcher(final String matcherName, final Matcher matcher) {
         this.configuration = configuration.withMatcher(matcherName, matcher);
         return (T) this;
     }
 
+    /**
+     * Applies JsonUnit matching options.
+     *
+     * @param paths the paths
+     * @return this matcher for method chaining
+     */
     public T whenIgnoringPaths(final String... paths) {
         this.configuration = configuration.whenIgnoringPaths(paths);
         return (T) this;
     }
 
+    /**
+     * Configures the difference listener.
+     *
+     * @param differenceListener the difference listener
+     * @return this instance for method chaining
+     */
     public T withDifferenceListener(final DifferenceListener differenceListener) {
         this.configuration = configuration.withDifferenceListener(differenceListener);
         return (T) this;
     }
 
+    /**
+     * Returns the matches.
+     *
+     * @param expected the expected
+     * @param actual the actual
+     * @return true when the condition is satisfied; false otherwise
+     */
     public boolean matches(final Object expected, final Object actual) {
         final Diff diff = Diff.create(expected, actual, FULL_JSON, EMPTY_PATH, configuration);
         final boolean similar = diff.similar();
@@ -91,12 +148,27 @@ public boolean matches(final Object expected, final Object actual) {
         return similar;
     }
 
+    /**
+     * Handles the render callback.
+     *
+     * @param listener the listener
+     */
     protected abstract void render(DifferenceListener listener);
 
+    /**
+     * Returns the differences.
+     *
+     * @return the differences
+     */
     public String getDifferences() {
         return differences;
     }
 
+    /**
+     * Returns the configuration.
+     *
+     * @return the configuration
+     */
     public Configuration getConfiguration() {
         return configuration;
     }
diff --git a/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/AllureConfigurableJsonMatcher.java b/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/AllureConfigurableJsonMatcher.java
index fa45c703..54eca4be 100644
--- a/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/AllureConfigurableJsonMatcher.java
+++ b/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/AllureConfigurableJsonMatcher.java
@@ -30,17 +30,61 @@
 @Deprecated
 public interface AllureConfigurableJsonMatcher<T> extends Matcher<T> {
 
+    /**
+     * Configures the tolerance.
+     *
+     * @param tolerance the tolerance
+     * @return this instance for method chaining
+     */
     AllureConfigurableJsonMatcher<T> withTolerance(BigDecimal tolerance);
 
+    /**
+     * Configures the tolerance.
+     *
+     * @param tolerance the tolerance
+     * @return this instance for method chaining
+     */
     AllureConfigurableJsonMatcher<T> withTolerance(double tolerance);
 
+    /**
+     * Applies JsonUnit matching options.
+     *
+     * @param first the first
+     * @param next the next
+     * @return this matcher for method chaining
+     */
     AllureConfigurableJsonMatcher<T> when(Option first, Option... next);
 
+    /**
+     * Configures the options.
+     *
+     * @param options the options
+     * @return this instance for method chaining
+     */
     AllureConfigurableJsonMatcher<T> withOptions(Options options);
 
+    /**
+     * Configures the matcher.
+     *
+     * @param matcherName the matcher name
+     * @param matcher the matcher
+     * @return this instance for method chaining
+     */
     AllureConfigurableJsonMatcher<T> withMatcher(String matcherName, Matcher<?> matcher);
 
+    /**
+     * Applies JsonUnit matching options.
+     *
+     * @param paths the paths
+     * @return this matcher for method chaining
+     */
     AllureConfigurableJsonMatcher<T> whenIgnoringPaths(String... paths);
 
+    /**
+     * Configures the difference listener.
+     *
+     * @param differenceListener the difference listener
+     * @return this instance for method chaining
+     */
     AllureConfigurableJsonMatcher<T> withDifferenceListener(DifferenceListener differenceListener);
 }
diff --git a/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/DiffAttachment.java b/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/DiffAttachment.java
index 055f0ce2..a1134e31 100644
--- a/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/DiffAttachment.java
+++ b/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/DiffAttachment.java
@@ -18,14 +18,24 @@
 import io.qameta.allure.attachment.AttachmentData;
 
 /**
- * @author Victor Orlovsky
+ * Describes a diff attachment used by Allure attachment rendering.
+ *
+ * <p>Create instances when an integration has collected the data that should be shown in the report. Renderers consume this model and turn it into attachment content for the current test or step.</p>
  */
 public class DiffAttachment extends DiffModel implements AttachmentData {
 
+    /**
+     * Creates a diff attachment with the supplied values.
+     *
+     * @param diffModel the diff model
+     */
     public DiffAttachment(final DiffModel diffModel) {
         super(diffModel.getActual(), diffModel.getExpected(), diffModel.getPatch());
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public String getName() {
         return "JSON difference";
diff --git a/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/DiffModel.java b/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/DiffModel.java
index 68772ee1..c563464f 100644
--- a/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/DiffModel.java
+++ b/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/DiffModel.java
@@ -24,20 +24,42 @@ public class DiffModel {
     private final String actual;
     private final String expected;
 
+    /**
+     * Creates a diff model with the supplied values.
+     *
+     * @param actual the actual
+     * @param expected the expected
+     * @param patch the patch
+     */
     public DiffModel(final String actual, final String expected, final String patch) {
         this.actual = actual;
         this.expected = expected;
         this.patch = patch;
     }
 
+    /**
+     * Returns the patch.
+     *
+     * @return the patch
+     */
     public String getPatch() {
         return patch;
     }
 
+    /**
+     * Returns the actual.
+     *
+     * @return the actual
+     */
     public String getActual() {
         return actual;
     }
 
+    /**
+     * Returns the expected.
+     *
+     * @return the expected
+     */
     public String getExpected() {
         return expected;
     }
diff --git a/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/JsonPatchListener.java b/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/JsonPatchListener.java
index 2744359b..33702603 100644
--- a/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/JsonPatchListener.java
+++ b/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/JsonPatchListener.java
@@ -40,16 +40,29 @@ public class JsonPatchListener implements DifferenceListener {
 
     private DifferenceContext context;
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void diff(final Difference difference, final DifferenceContext differenceContext) {
         this.context = differenceContext;
         differences.add(difference);
     }
 
+    /**
+     * Returns the differences.
+     *
+     * @return the differences
+     */
     public List<Difference> getDifferences() {
         return differences;
     }
 
+    /**
+     * Returns the context.
+     *
+     * @return the context
+     */
     public DifferenceContext getContext() {
         return context;
     }
@@ -95,13 +108,24 @@ private List<Object> getPatch(final Difference difference) {
         }
     }
 
+    /**
+     * Returns the diff model.
+     *
+     * @return the diff model
+     */
     public DiffModel getDiffModel() {
         return new DiffModel(
                 writeAsString(context.getActualSource(), "actual"),
                 writeAsString(context.getExpectedSource(), "expected"),
-                getJsonPatch());
+                getJsonPatch()
+        );
     }
 
+    /**
+     * Returns the json patch.
+     *
+     * @return the json patch
+     */
     @SuppressWarnings({"all", "unchecked"})
     public String getJsonPatch() {
         final Map<String, Object> jsonDiffPatch = new HashMap<>();
diff --git a/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/JsonPatchMatcher.java b/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/JsonPatchMatcher.java
index 078c9957..a832b3d4 100644
--- a/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/JsonPatchMatcher.java
+++ b/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/JsonPatchMatcher.java
@@ -19,7 +19,6 @@
 import io.qameta.allure.attachment.FreemarkerAttachmentRenderer;
 import net.javacrumbs.jsonunit.ConfigurableJsonMatcher;
 import net.javacrumbs.jsonunit.core.listener.DifferenceListener;
-
 import org.hamcrest.Description;
 
 /**
@@ -30,7 +29,8 @@
  */
 @SuppressWarnings("unused")
 public final class JsonPatchMatcher<T> extends AbstractJsonPatchMatcher<ConfigurableJsonMatcher<T>>
-        implements ConfigurableJsonMatcher<T> {
+        implements
+            ConfigurableJsonMatcher<T> {
 
     private final Object expected;
 
@@ -68,7 +68,9 @@ public void _dont_implement_Matcher___instead_extend_BaseMatcher_() {
     protected void render(final DifferenceListener listener) {
         final JsonPatchListener jsonDiffListener = (JsonPatchListener) listener;
         final DiffAttachment attachment = new DiffAttachment(jsonDiffListener.getDiffModel());
-        new DefaultAttachmentProcessor().addAttachment(attachment,
-                new FreemarkerAttachmentRenderer("diff.ftl"));
+        new DefaultAttachmentProcessor().addAttachment(
+                attachment,
+                new FreemarkerAttachmentRenderer("diff.ftl")
+        );
     }
 }
diff --git a/allure-jsonunit/src/test/java/io/qameta/allure/jsonunit/JsonPatchListenerTest.java b/allure-jsonunit/src/test/java/io/qameta/allure/jsonunit/JsonPatchListenerTest.java
index 74a96e5f..d09adab7 100644
--- a/allure-jsonunit/src/test/java/io/qameta/allure/jsonunit/JsonPatchListenerTest.java
+++ b/allure-jsonunit/src/test/java/io/qameta/allure/jsonunit/JsonPatchListenerTest.java
@@ -80,7 +80,6 @@ void shouldSeeEmptyForCheckAnyStringNode() {
         assertThat(listener.getJsonPatch()).isEqualTo("{}");
     }
 
-
     @Test
     void shouldSeeChangedStringNode() {
         Diff diff = Diff.create("{\"test\": \"1\"}", "{\"test\": \"2\"}", "", "", commonConfig());
@@ -149,8 +148,7 @@ void shouldSeeNullNode() {
     void shouldWorkWhenIgnoringArrayOrder() {
         Diff diff = Diff.create("{\"test\": [[1,2],[2,3]]}", "{\"test\":[[4,2],[1,2]]}", "", "", commonConfig().when(Option.IGNORING_ARRAY_ORDER));
         diff.similar();
-        assertThat(listener.getJsonPatch()).
-                isEqualTo("{\"test\":{\"0\":{\"0\":[3,4],\"_t\":\"a\"},\"_t\":\"a\"}}");
+        assertThat(listener.getJsonPatch()).isEqualTo("{\"test\":{\"0\":{\"0\":[3,4],\"_t\":\"a\"},\"_t\":\"a\"}}");
     }
 
     @Test
diff --git a/allure-jsonunit/src/test/java/io/qameta/allure/jsonunit/JsonPatchMatcherTests.java b/allure-jsonunit/src/test/java/io/qameta/allure/jsonunit/JsonPatchMatcherTests.java
index e0dcbdfb..3bfa9cf3 100644
--- a/allure-jsonunit/src/test/java/io/qameta/allure/jsonunit/JsonPatchMatcherTests.java
+++ b/allure-jsonunit/src/test/java/io/qameta/allure/jsonunit/JsonPatchMatcherTests.java
@@ -15,30 +15,28 @@
  */
 package io.qameta.allure.jsonunit;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import net.javacrumbs.jsonunit.core.Configuration;
+import net.javacrumbs.jsonunit.core.Option;
+import net.javacrumbs.jsonunit.core.internal.Options;
+import net.javacrumbs.jsonunit.core.listener.DifferenceListener;
+import org.hamcrest.Description;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
 
+import java.lang.reflect.Field;
+import java.math.BigDecimal;
+import java.util.function.BiConsumer;
+
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.hamcrest.CoreMatchers.equalTo;
+import static org.mockito.ArgumentCaptor.forClass;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.spy;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.ArgumentCaptor.forClass;
-
-import java.lang.reflect.Field;
-import java.math.BigDecimal;
-import java.util.function.BiConsumer;
-
-import org.hamcrest.Description;
-import org.junit.jupiter.api.Test;
-import org.mockito.ArgumentCaptor;
-
-import net.javacrumbs.jsonunit.core.Configuration;
-import net.javacrumbs.jsonunit.core.Option;
-import net.javacrumbs.jsonunit.core.internal.Options;
-import net.javacrumbs.jsonunit.core.listener.DifferenceListener;
 
 class JsonPatchMatcherTests {
 
diff --git a/allure-jsonunit/src/test/resources/allure.properties b/allure-jsonunit/src/test/resources/allure.properties
index 9c0b0a2d..5f86fe63 100644
--- a/allure-jsonunit/src/test/resources/allure.properties
+++ b/allure-jsonunit/src/test/resources/allure.properties
@@ -1,2 +1,3 @@
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-jsonunit
diff --git a/allure-junit-platform/build.gradle.kts b/allure-junit-platform/build.gradle.kts
index 4cf244bf..b090e9ec 100644
--- a/allure-junit-platform/build.gradle.kts
+++ b/allure-junit-platform/build.gradle.kts
@@ -29,11 +29,21 @@ tasks.jar {
 }
 
 tasks.test {
+    // The Allure Gradle adapter adds this module's published artifact to the
+    // test runtime classpath, so make the jar/task relationship explicit when
+    // jar and test are scheduled in the same build.
+    dependsOn(tasks.jar)
     systemProperty("junit.jupiter.execution.parallel.enabled", "false")
     useJUnitPlatform()
     exclude("**/features/*")
 }
 
+tasks.named<Pmd>("pmdMain") {
+    // PMD type resolution reads the main compile classpath, which also
+    // contains this module's published artifact via the Allure adapter setup.
+    dependsOn(tasks.jar)
+}
+
 val spiOffJar: Jar by tasks.creating(Jar::class) {
     from(sourceSets.getByName("main").output)
     archiveClassifier.set("spi-off")
diff --git a/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllureJunitPlatform.java b/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllureJunitPlatform.java
index a336ee2a..7a21a276 100644
--- a/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllureJunitPlatform.java
+++ b/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllureJunitPlatform.java
@@ -82,30 +82,79 @@
 import static java.nio.charset.StandardCharsets.UTF_8;
 
 /**
- * @author ehborisov
+ * Reports JUnit Platform execution to Allure.
+ *
+ * <p>Register this listener with the JUnit Platform launcher to translate test plan, container, test, fixture, report-entry, and failure events into Allure results. It is the core listener used by Platform-based Allure adapters.</p>
  */
-@SuppressWarnings({
-        "ClassDataAbstractionCoupling",
-        "ClassFanOutComplexity",
-        "MultipleStringLiterals",
-})
+@SuppressWarnings(
+    {
+            "ClassDataAbstractionCoupling",
+            "ClassFanOutComplexity",
+            "MultipleStringLiterals",
+            "PMD.GodClass",
+            "PMD.TooManyMethods",
+    }
+)
 public class AllureJunitPlatform implements TestExecutionListener {
 
-    public static final String ALLURE_REPORT_ENTRY_BLANK_PREFIX
-            = "ALLURE_REPORT_ENTRY_BLANK_PREFIX__";
+    /**
+     * Configuration key for allure report entry blank prefix.
+     */
+    public static final String ALLURE_REPORT_ENTRY_BLANK_PREFIX = "ALLURE_REPORT_ENTRY_BLANK_PREFIX__";
 
+    /**
+     * Configuration key for allure parameter.
+     */
     public static final String ALLURE_PARAMETER = "allure.parameter";
+
+    /**
+     * Configuration key for allure parameter value key.
+     */
     public static final String ALLURE_PARAMETER_VALUE_KEY = "value";
+
+    /**
+     * Configuration key for allure parameter mode key.
+     */
     public static final String ALLURE_PARAMETER_MODE_KEY = "mode";
+
+    /**
+     * Configuration key for allure parameter excluded key.
+     */
     public static final String ALLURE_PARAMETER_EXCLUDED_KEY = "excluded";
 
+    /**
+     * Configuration key for allure fixture.
+     */
     public static final String ALLURE_FIXTURE = "allure.fixture";
+
+    /**
+     * Constant value for prepare.
+     */
     public static final String PREPARE = "prepare";
+
+    /**
+     * Constant value for tear down.
+     */
     public static final String TEAR_DOWN = "tear_down";
+
+    /**
+     * Constant value for event start.
+     */
     public static final String EVENT_START = "start";
+
+    /**
+     * Constant value for event stop.
+     */
     public static final String EVENT_STOP = "stop";
+
+    /**
+     * Constant value for event failure.
+     */
     public static final String EVENT_FAILURE = "failure";
 
+    /**
+     * Constant value for junit platform unique id.
+     */
     public static final String JUNIT_PLATFORM_UNIQUE_ID = "junit.platform.uniqueid";
     private static final Logger LOGGER = LoggerFactory.getLogger(AllureJunitPlatform.class);
     private static final String STDOUT = "stdout";
@@ -113,20 +162,15 @@ public class AllureJunitPlatform implements TestExecutionListener {
     private static final String TEXT_PLAIN = "text/plain";
     private static final String TXT_EXTENSION = ".txt";
 
-    private static final boolean HAS_SPOCK2_IN_CLASSPATH
-            = isClassAvailableOnClasspath("io.qameta.allure.spock2.AllureSpock2");
+    private static final boolean HAS_SPOCK2_IN_CLASSPATH = isClassAvailableOnClasspath("io.qameta.allure.spock2.AllureSpock2");
 
-    private static final boolean HAS_CUCUMBERJVM7_IN_CLASSPATH
-            = isClassAvailableOnClasspath("io.qameta.allure.cucumber7jvm.AllureCucumber7Jvm");
+    private static final boolean HAS_CUCUMBERJVM7_IN_CLASSPATH = isClassAvailableOnClasspath("io.qameta.allure.cucumber7jvm.AllureCucumber7Jvm");
 
-    private static final boolean HAS_CUCUMBERJVM6_IN_CLASSPATH
-            = isClassAvailableOnClasspath("io.qameta.allure.cucumber6jvm.AllureCucumber6Jvm");
+    private static final boolean HAS_CUCUMBERJVM6_IN_CLASSPATH = isClassAvailableOnClasspath("io.qameta.allure.cucumber6jvm.AllureCucumber6Jvm");
 
-    private static final boolean HAS_CUCUMBERJVM5_IN_CLASSPATH
-            = isClassAvailableOnClasspath("io.qameta.allure.cucumber5jvm.AllureCucumber5Jvm");
+    private static final boolean HAS_CUCUMBERJVM5_IN_CLASSPATH = isClassAvailableOnClasspath("io.qameta.allure.cucumber5jvm.AllureCucumber5Jvm");
 
-    private static final boolean HAS_CUCUMBERJVM4_IN_CLASSPATH
-            = isClassAvailableOnClasspath("io.qameta.allure.cucumber4jvm.AllureCucumber4Jvm");
+    private static final boolean HAS_CUCUMBERJVM4_IN_CLASSPATH = isClassAvailableOnClasspath("io.qameta.allure.cucumber4jvm.AllureCucumber4Jvm");
 
     private static final String ENGINE_SPOCK2 = "spock";
     private static final String ENGINE_CUCUMBER = "cucumber";
@@ -148,14 +192,27 @@ protected Uuids initialValue() {
 
     private final AllureLifecycle lifecycle;
 
+    /**
+     * Creates an Allure junit platform with the supplied values.
+     *
+     * @param lifecycle the Allure lifecycle to use
+     */
     public AllureJunitPlatform(final AllureLifecycle lifecycle) {
         this.lifecycle = lifecycle;
     }
 
+    /**
+     * Creates an Allure junit platform with default configuration.
+     */
     public AllureJunitPlatform() {
         this.lifecycle = Allure.getLifecycle();
     }
 
+    /**
+     * Returns the lifecycle.
+     *
+     * @return the Allure lifecycle used by this integration
+     */
     public AllureLifecycle getLifecycle() {
         return lifecycle;
     }
@@ -176,13 +233,11 @@ private boolean shouldSkipReportingFor(final TestIdentifier testIdentifier) {
 
         final String engine = maybeEngine.get();
 
-
         return HAS_SPOCK2_IN_CLASSPATH && ENGINE_SPOCK2.equals(engine)
-               || (HAS_CUCUMBERJVM7_IN_CLASSPATH
-                   || HAS_CUCUMBERJVM6_IN_CLASSPATH
-                   || HAS_CUCUMBERJVM5_IN_CLASSPATH
-                   || HAS_CUCUMBERJVM4_IN_CLASSPATH
-                  ) && ENGINE_CUCUMBER.equals(engine);
+                || (HAS_CUCUMBERJVM7_IN_CLASSPATH
+                        || HAS_CUCUMBERJVM6_IN_CLASSPATH
+                        || HAS_CUCUMBERJVM5_IN_CLASSPATH
+                        || HAS_CUCUMBERJVM4_IN_CLASSPATH) && ENGINE_CUCUMBER.equals(engine);
     }
 
     private Optional<String> getEngine(final TestIdentifier testIdentifier) {
@@ -210,6 +265,9 @@ private static boolean isClassAvailableOnClasspath(final String clazz) {
         }
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void testPlanExecutionStarted(final TestPlan testPlan) {
         testPlanStorage.set(testPlan);
@@ -217,6 +275,9 @@ public void testPlanExecutionStarted(final TestPlan testPlan) {
         containers.set(new Uuids());
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void testPlanExecutionFinished(final TestPlan testPlan) {
         testPlanStorage.remove();
@@ -224,6 +285,9 @@ public void testPlanExecutionFinished(final TestPlan testPlan) {
         containers.remove();
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void executionStarted(final TestIdentifier testIdentifier) {
         if (shouldSkipReportingFor(testIdentifier)) {
@@ -238,6 +302,9 @@ public void executionStarted(final TestIdentifier testIdentifier) {
         }
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void executionFinished(final TestIdentifier testIdentifier,
                                   final TestExecutionResult testExecutionResult) {
@@ -259,6 +326,9 @@ public void executionFinished(final TestIdentifier testIdentifier,
         stopTestContainer(testIdentifier);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void executionSkipped(final TestIdentifier testIdentifier,
                                  final String reason) {
@@ -278,6 +348,9 @@ public void executionSkipped(final TestIdentifier testIdentifier,
         );
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @SuppressWarnings({"ReturnCount", "CyclomaticComplexity"})
     @Override
     public void reportingEntryPublished(final TestIdentifier testIdentifier,
@@ -311,14 +384,14 @@ public void reportingEntryPublished(final TestIdentifier testIdentifier,
     private Map<String, String> unwrap(final Map<String, String> data) {
         final Map<String, String> res = new HashMap<>();
         data.forEach((key, value) -> {
-                    if (Objects.nonNull(value)
-                        && value.trim().isEmpty()
-                        && value.startsWith(ALLURE_REPORT_ENTRY_BLANK_PREFIX)) {
-                        res.put(key, value.substring(ALLURE_REPORT_ENTRY_BLANK_PREFIX.length()));
-                    } else {
-                        res.put(key, value);
-                    }
-                }
+            if (Objects.nonNull(value)
+                    && value.trim().isEmpty()
+                    && value.startsWith(ALLURE_REPORT_ENTRY_BLANK_PREFIX)) {
+                res.put(key, value.substring(ALLURE_REPORT_ENTRY_BLANK_PREFIX.length()));
+            } else {
+                res.put(key, value);
+            }
+        }
         );
         return res;
     }
@@ -349,8 +422,9 @@ private void processParameterEvent(final Map<String, String> keyValuePairs) {
                     .ifPresent(parameter::setExcluded);
         }
 
-        getLifecycle().updateTestCase(tr -> tr.getParameters()
-                .add(parameter)
+        getLifecycle().updateTestCase(
+                tr -> tr.getParameters()
+                        .add(parameter)
         );
     }
 
@@ -412,6 +486,12 @@ private void reportNested(final TestPlan testPlan,
                 .forEach(child -> reportNested(testPlan, child, status, statusDetails, visited));
     }
 
+    /**
+     * Returns the status.
+     *
+     * @param throwable the throwable
+     * @return the status
+     */
     protected Status getStatus(final Throwable throwable) {
         return ResultsUtils.getStatus(throwable).orElse(FAILED);
     }
@@ -488,6 +568,10 @@ private void failFixture(final Map<String, String> keyValue) {
                     .ifPresent(fixtureResult.getStatusDetails()::setMessage);
             Optional.of(keyValue.get("trace"))
                     .ifPresent(fixtureResult.getStatusDetails()::setTrace);
+            Optional.of(keyValue.get("actual"))
+                    .ifPresent(fixtureResult.getStatusDetails()::setActual);
+            Optional.of(keyValue.get("expected"))
+                    .ifPresent(fixtureResult.getStatusDetails()::setExpected);
         });
         getLifecycle().stopFixture(uuid);
     }
@@ -519,30 +603,36 @@ private void startTestCase(final TestIdentifier testIdentifier) {
 
         final TestResult result = new TestResult()
                 .setUuid(uuid)
-                .setName(testTemplate && maybeParent.isPresent()
-                        ? maybeParent.get().getDisplayName() + " " + testIdentifier.getDisplayName()
-                        : testIdentifier.getDisplayName()
+                .setName(
+                        testTemplate && maybeParent.isPresent()
+                                ? maybeParent.get().getDisplayName() + " " + testIdentifier.getDisplayName()
+                                : testIdentifier.getDisplayName()
                 )
+                .setTitlePath(getTitlePath(testIdentifier, testClass))
                 .setLabels(getTags(testIdentifier))
-                .setTestCaseId(testTemplate
-                        ? maybeParent.map(TestIdentifier::getUniqueId)
-                        .orElseGet(testIdentifier::getUniqueId)
-                        : testIdentifier.getUniqueId()
+                .setTestCaseId(
+                        testTemplate
+                                ? maybeParent.map(TestIdentifier::getUniqueId)
+                                        .orElseGet(testIdentifier::getUniqueId)
+                                : testIdentifier.getUniqueId()
+                )
+                .setTestCaseName(
+                        testTemplate
+                                ? maybeParent.map(TestIdentifier::getDisplayName)
+                                        .orElseGet(testIdentifier::getDisplayName)
+                                : testIdentifier.getDisplayName()
                 )
-                .setTestCaseName(testTemplate
-                        ? maybeParent.map(TestIdentifier::getDisplayName)
-                        .orElseGet(testIdentifier::getDisplayName)
-                        : testIdentifier.getDisplayName())
                 .setHistoryId(getHistoryId(testIdentifier))
                 .setStage(Stage.RUNNING);
 
         if (testTemplate) {
             // history id is ignored in Allure TestOps, so we add a hidden parameter
             // to make sure different results are not considered as retries
-            result.getParameters().add(new Parameter()
-                    .setMode(Parameter.Mode.HIDDEN)
-                    .setName("UniqueId")
-                    .setValue(testIdentifier.getUniqueId())
+            result.getParameters().add(
+                    new Parameter()
+                            .setMode(Parameter.Mode.HIDDEN)
+                            .setName("UniqueId")
+                            .setValue(testIdentifier.getUniqueId())
             );
         }
 
@@ -565,12 +655,14 @@ private void startTestCase(final TestIdentifier testIdentifier) {
         testClass.map(AnnotationUtils::getLinks).ifPresent(result.getLinks()::addAll);
         testMethod.map(AnnotationUtils::getLinks).ifPresent(result.getLinks()::addAll);
 
-        result.getLabels().addAll(Arrays.asList(
-                createHostLabel(),
-                createThreadLabel(),
-                createFrameworkLabel("junit-platform"),
-                createLanguageLabel("java")
-        ));
+        result.getLabels().addAll(
+                Arrays.asList(
+                        createHostLabel(),
+                        createThreadLabel(),
+                        createFrameworkLabel("junit-platform"),
+                        createLanguageLabel("java")
+                )
+        );
 
         testSource.flatMap(AllureJunitPlatformUtils::getFullName).ifPresent(result::setFullName);
         testSource.map(this::getSourceLabels).ifPresent(result.getLabels()::addAll);
@@ -595,12 +687,14 @@ private void startTestCase(final TestIdentifier testIdentifier) {
                 .map(ResultsUtils::createSeverityLabel)
                 .ifPresent(result.getLabels()::add);
 
-        testMethod.ifPresent(method -> ResultsUtils.processDescription(
-                method.getDeclaringClass().getClassLoader(),
-                method,
-                result::setDescription,
-                result::setDescriptionHtml
-        ));
+        testMethod.ifPresent(
+                method -> ResultsUtils.processDescription(
+                        method.getDeclaringClass().getClassLoader(),
+                        method,
+                        result::setDescription,
+                        result::setDescriptionHtml
+                )
+        );
 
         getLifecycle().scheduleTestCase(result);
         getLifecycle().startTestCase(uuid);
@@ -633,6 +727,14 @@ private void stopTestCase(final TestIdentifier testIdentifier,
                         .map(StatusDetails::getTrace)
                         .ifPresent(currentSd::setTrace);
 
+                Optional.of(statusDetails)
+                        .map(StatusDetails::getActual)
+                        .ifPresent(currentSd::setActual);
+
+                Optional.of(statusDetails)
+                        .map(StatusDetails::getExpected)
+                        .ifPresent(currentSd::setExpected);
+
                 currentSd.setMuted(currentSd.isMuted() || statusDetails.isMuted());
                 currentSd.setFlaky(currentSd.isFlaky() || statusDetails.isFlaky());
                 currentSd.setKnown(currentSd.isKnown() || statusDetails.isKnown());
@@ -662,6 +764,58 @@ private List<Label> getTags(final TestIdentifier testIdentifier) {
                 .collect(Collectors.toList());
     }
 
+    private List<String> getTitlePath(final TestIdentifier testIdentifier,
+                                      final Optional<Class<?>> testClass) {
+        final List<String> result = testClass
+                .map(this::getClassTitlePath)
+                .orElseGet(ArrayList::new);
+
+        getParents(testIdentifier).stream()
+                .filter(parent -> !"engine".equals(parent.getUniqueIdObject().getLastSegment().getType()))
+                .filter(parent -> !parent.isTest())
+                .filter(parent -> !parent.getSource().filter(ClassSource.class::isInstance).isPresent())
+                .map(TestIdentifier::getDisplayName)
+                .forEach(result::add);
+
+        return ResultsUtils.createTitlePath(result);
+    }
+
+    private List<String> getClassTitlePath(final Class<?> testClass) {
+        final String packageName = Optional.ofNullable(testClass.getPackage())
+                .map(Package::getName)
+                .orElse("");
+        final List<String> result = ResultsUtils.createTitlePathFromPackage(packageName);
+        final List<String> classNames = new ArrayList<>();
+        Class<?> current = testClass;
+        while (Objects.nonNull(current)) {
+            classNames.add(getDisplayName(current).orElse(current.getSimpleName()));
+            current = current.getDeclaringClass();
+        }
+        Collections.reverse(classNames);
+        result.addAll(classNames);
+        return result;
+    }
+
+    private List<TestIdentifier> getParents(final TestIdentifier testIdentifier) {
+        final List<TestIdentifier> result = new ArrayList<>();
+        Optional<TestIdentifier> parent = Optional.ofNullable(testPlanStorage.get())
+                .flatMap(testPlan -> testPlan.getParent(testIdentifier));
+        while (parent.isPresent()) {
+            final TestIdentifier value = parent.get();
+            result.add(value);
+            parent = Optional.ofNullable(testPlanStorage.get())
+                    .flatMap(testPlan -> testPlan.getParent(value));
+        }
+        Collections.reverse(result);
+        return result;
+    }
+
+    /**
+     * Returns the history id.
+     *
+     * @param testIdentifier the test identifier
+     * @return the history id
+     */
     protected String getHistoryId(final TestIdentifier testIdentifier) {
         return md5(testIdentifier.getUniqueId());
     }
diff --git a/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllureJunitPlatformUtils.java b/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllureJunitPlatformUtils.java
index e985458d..e2b9f519 100644
--- a/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllureJunitPlatformUtils.java
+++ b/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllureJunitPlatformUtils.java
@@ -25,10 +25,6 @@
 import java.lang.reflect.Method;
 import java.util.Optional;
 import java.util.stream.Stream;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 /* package-private */ final class AllureJunitPlatformUtils {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(AllureJunitPlatformUtils.class);
diff --git a/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllurePostDiscoveryFilter.java b/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllurePostDiscoveryFilter.java
index 64606310..7d6a8d0b 100644
--- a/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllurePostDiscoveryFilter.java
+++ b/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllurePostDiscoveryFilter.java
@@ -35,7 +35,9 @@
 import static io.qameta.allure.util.ResultsUtils.ALLURE_ID_LABEL_NAME;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Integrates JUnit Platform with Allure reporting.
+ *
+ * <p>Register this type through the standard JUnit Platform extension, listener, interceptor, or plugin mechanism so framework execution events are written to Allure results. Use explicit dependencies when embedding the integration in tests or custom runtimes.</p>
  */
 public class AllurePostDiscoveryFilter implements PostDiscoveryFilter {
 
@@ -43,14 +45,25 @@ public class AllurePostDiscoveryFilter implements PostDiscoveryFilter {
 
     private final TestPlan testPlan;
 
+    /**
+     * Creates an Allure post discovery filter with default configuration.
+     */
     public AllurePostDiscoveryFilter() {
         this(new FileTestPlanSupplier().supply().orElse(null));
     }
 
+    /**
+     * Creates an Allure post discovery filter with the supplied values.
+     *
+     * @param testPlan the Allure test plan to evaluate against
+     */
     public AllurePostDiscoveryFilter(final TestPlan testPlan) {
         this.testPlan = testPlan;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public FilterResult apply(final TestDescriptor object) {
         if (Objects.isNull(testPlan)) {
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllureJunitPlatformTest.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllureJunitPlatformTest.java
index 29de4f12..a5febb8f 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllureJunitPlatformTest.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllureJunitPlatformTest.java
@@ -17,6 +17,7 @@
 
 import io.github.glytching.junit.extension.system.SystemProperty;
 import io.qameta.allure.Issue;
+import io.qameta.allure.junitplatform.features.ActualExpectedStatusDetailsTests;
 import io.qameta.allure.junitplatform.features.AllureIdAnnotationSupport;
 import io.qameta.allure.junitplatform.features.BrokenInAfterAllTests;
 import io.qameta.allure.junitplatform.features.BrokenInBeforeAllTests;
@@ -75,6 +76,7 @@
 import org.junit.platform.launcher.core.LauncherFactory;
 
 import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
@@ -103,10 +105,6 @@
 import static org.assertj.core.api.Assertions.tuple;
 import static org.junit.jupiter.api.parallel.ResourceAccessMode.READ_WRITE;
 import static org.junit.jupiter.api.parallel.Resources.SYSTEM_PROPERTIES;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @SuppressWarnings("unchecked")
 public class AllureJunitPlatformTest {
 
@@ -168,6 +166,23 @@ void shouldProcessFailedTests() {
 
     }
 
+    @Test
+    @AllureFeatures.FailedTests
+    void shouldReportActualAndExpectedStatusDetails() {
+        final AllureResults results = runClasses(ActualExpectedStatusDetailsTests.class);
+        final TestResult testResult = results.getTestResults().stream()
+                .filter(
+                        result -> ("io.qameta.allure.junitplatform.features.ActualExpectedStatusDetailsTests"
+                                + ".failingComparison").equals(result.getFullName())
+                )
+                .findFirst()
+                .get();
+
+        assertThat(testResult.getStatus()).isEqualTo(Status.FAILED);
+        assertThat(testResult.getStatusDetails().getActual()).startsWith("actual value (");
+        assertThat(testResult.getStatusDetails().getExpected()).startsWith("expected value (");
+    }
+
     @Test
     @AllureFeatures.BrokenTests
     void shouldProcessBrokenTests() {
@@ -199,7 +214,8 @@ void shouldProcessBrokenInBeforeAllTests() {
                 .extracting(
                         TestResult::getName,
                         TestResult::getStatus,
-                        tr -> Optional.of(tr).map(TestResult::getStatusDetails).map(StatusDetails::getMessage).orElse(null))
+                        tr -> Optional.of(tr).map(TestResult::getStatusDetails).map(StatusDetails::getMessage).orElse(null)
+                )
                 .containsExactlyInAnyOrder(
                         tuple("BrokenInBeforeAllTests", Status.BROKEN, "Exception in @BeforeAll")
                 );
@@ -216,7 +232,8 @@ void shouldProcessBrokenInAfterAllTests() {
                 .extracting(
                         TestResult::getName,
                         TestResult::getStatus,
-                        tr -> Optional.of(tr).map(TestResult::getStatusDetails).map(StatusDetails::getMessage).orElse(null))
+                        tr -> Optional.of(tr).map(TestResult::getStatusDetails).map(StatusDetails::getMessage).orElse(null)
+                )
                 .containsExactlyInAnyOrder(
                         tuple("BrokenInAfterAllTests", Status.BROKEN, "Exception in @AfterAll"),
                         tuple("parameterisedTest(String) [1] value=a", Status.PASSED, null),
@@ -442,10 +459,22 @@ void shouldProcessClassLabels() {
     }
 
     @AllureFeatures.Links
-    @ResourceLock(value = SYSTEM_PROPERTIES, mode = READ_WRITE)
-    @SystemProperty(name = "allure.link.issue.pattern", value = "https://example.org/issue/{}")
-    @SystemProperty(name = "allure.link.tms.pattern", value = "https://example.org/tms/{}")
-    @SystemProperty(name = "allure.link.custom.pattern", value = "https://example.org/custom/{}")
+    @ResourceLock(
+            value = SYSTEM_PROPERTIES,
+            mode = READ_WRITE
+    )
+    @SystemProperty(
+            name = "allure.link.issue.pattern",
+            value = "https://example.org/issue/{}"
+    )
+    @SystemProperty(
+            name = "allure.link.tms.pattern",
+            value = "https://example.org/tms/{}"
+    )
+    @SystemProperty(
+            name = "allure.link.custom.pattern",
+            value = "https://example.org/custom/{}"
+    )
     @Test
     void shouldProcessMethodLinks() {
         final AllureResults results = runClasses(TestWithMethodLinks.class);
@@ -468,10 +497,22 @@ void shouldProcessMethodLinks() {
     }
 
     @AllureFeatures.Links
-    @ResourceLock(value = SYSTEM_PROPERTIES, mode = READ_WRITE)
-    @SystemProperty(name = "allure.link.issue.pattern", value = "https://example.org/issue/{}")
-    @SystemProperty(name = "allure.link.tms.pattern", value = "https://example.org/tms/{}")
-    @SystemProperty(name = "allure.link.custom.pattern", value = "https://example.org/custom/{}")
+    @ResourceLock(
+            value = SYSTEM_PROPERTIES,
+            mode = READ_WRITE
+    )
+    @SystemProperty(
+            name = "allure.link.issue.pattern",
+            value = "https://example.org/issue/{}"
+    )
+    @SystemProperty(
+            name = "allure.link.tms.pattern",
+            value = "https://example.org/tms/{}"
+    )
+    @SystemProperty(
+            name = "allure.link.custom.pattern",
+            value = "https://example.org/custom/{}"
+    )
     @Test
     void shouldProcessClassLinks() {
         final AllureResults results = runClasses(TestWithClassLinks.class);
@@ -599,9 +640,15 @@ void shouldSetJavadocDescription() {
     }
 
     @AllureFeatures.Attachments
-    @ResourceLock(value = SYSTEM_PROPERTIES, mode = READ_WRITE)
+    @ResourceLock(
+            value = SYSTEM_PROPERTIES,
+            mode = READ_WRITE
+    )
     @SuppressWarnings("OptionalGetWithoutIsPresent")
-    @SystemProperty(name = "junit.platform.output.capture.stdout", value = "true")
+    @SystemProperty(
+            name = "junit.platform.output.capture.stdout",
+            value = "true"
+    )
     @Test
     void shouldCaptureSystemOut() {
         final AllureResults results = runClasses(TestWithSystemOut.class);
@@ -622,7 +669,6 @@ void shouldCaptureSystemOut() {
                 .findAny()
                 .get();
 
-
         final Map<String, byte[]> attachmentFiles = results.getAttachments();
         assertThat(attachmentFiles)
                 .containsKeys(found.getSource());
@@ -636,9 +682,15 @@ void shouldCaptureSystemOut() {
     }
 
     @AllureFeatures.Attachments
-    @ResourceLock(value = SYSTEM_PROPERTIES, mode = READ_WRITE)
+    @ResourceLock(
+            value = SYSTEM_PROPERTIES,
+            mode = READ_WRITE
+    )
     @SuppressWarnings("OptionalGetWithoutIsPresent")
-    @SystemProperty(name = "junit.platform.output.capture.stderr", value = "true")
+    @SystemProperty(
+            name = "junit.platform.output.capture.stderr",
+            value = "true"
+    )
     @Test
     void shouldCaptureSystemErr() {
         final AllureResults results = runClasses(TestWithSystemErr.class);
@@ -659,7 +711,6 @@ void shouldCaptureSystemErr() {
                 .findAny()
                 .get();
 
-
         final Map<String, byte[]> attachmentFiles = results.getAttachments();
         assertThat(attachmentFiles)
                 .containsKeys(found.getSource());
@@ -673,8 +724,14 @@ void shouldCaptureSystemErr() {
     }
 
     @AllureFeatures.Parallel
-    @ResourceLock(value = SYSTEM_PROPERTIES, mode = READ_WRITE)
-    @SystemProperty(name = "junit.jupiter.execution.parallel.enabled", value = "true")
+    @ResourceLock(
+            value = SYSTEM_PROPERTIES,
+            mode = READ_WRITE
+    )
+    @SystemProperty(
+            name = "junit.jupiter.execution.parallel.enabled",
+            value = "true"
+    )
     @Test
     void shouldRunTestsInParallel() {
         final AllureResults results = runClasses(ParallelTests.class);
@@ -854,7 +911,6 @@ void shouldSetDifferentUuidsInDifferentRuns() {
             launcher.execute(request);
         });
 
-
         final List<TestResult> testResults = results.getTestResults();
         assertThat(testResults)
                 .hasSize(2);
@@ -885,6 +941,16 @@ void shouldSupportNestedClasses() {
                         "story1Test()"
                 );
 
+        assertThat(allureResults.getTestResults())
+                .filteredOn("name", "story1Test()")
+                .extracting(TestResult::getTitlePath)
+                .containsExactly(
+                        Arrays.asList(
+                                "io", "qameta", "allure", "junitplatform", "features",
+                                "NestedTests", "Feature2", "Story1"
+                        )
+                );
+
         assertThat(allureResults.getTestResults())
                 .filteredOn("name", "parentTest()")
                 .flatExtracting(TestResult::getLabels)
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllureJunitPlatformTestUtils.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllureJunitPlatformTestUtils.java
index a72cf8e9..9e638236 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllureJunitPlatformTestUtils.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllureJunitPlatformTestUtils.java
@@ -28,10 +28,6 @@
 import org.junit.platform.launcher.core.LauncherFactory;
 
 import java.util.stream.Stream;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public final class AllureJunitPlatformTestUtils {
 
     private AllureJunitPlatformTestUtils() {
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllurePostDiscoveryFilterTest.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllurePostDiscoveryFilterTest.java
index 6c0b58a4..1690b65e 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllurePostDiscoveryFilterTest.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllurePostDiscoveryFilterTest.java
@@ -26,10 +26,6 @@
 
 import static io.qameta.allure.junitplatform.AllureJunitPlatformTestUtils.runClasses;
 import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class AllurePostDiscoveryFilterTest {
 
     @Test
@@ -64,11 +60,13 @@ void shouldRunAllParameterizedTestsIfEmptyTestPlanProvided() {
 
     @Test
     void shouldFilterTestCasesByFullName() {
-        final TestPlan testPlan = new TestPlanV1_0().setTests(Arrays.asList(
-                new TestPlanV1_0.TestCase()
-                        .setSelector(String.format("%s.second", FilterSimpleTests.class.getCanonicalName())),
-                new TestPlanV1_0.TestCase()
-                        .setSelector(String.format("%s.first", FilterSimpleTests.class.getCanonicalName())))
+        final TestPlan testPlan = new TestPlanV1_0().setTests(
+                Arrays.asList(
+                        new TestPlanV1_0.TestCase()
+                                .setSelector(String.format("%s.second", FilterSimpleTests.class.getCanonicalName())),
+                        new TestPlanV1_0.TestCase()
+                                .setSelector(String.format("%s.first", FilterSimpleTests.class.getCanonicalName()))
+                )
         );
 
         final AllureResults results = runClasses(testPlan, FilterSimpleTests.class);
@@ -78,12 +76,14 @@ void shouldFilterTestCasesByFullName() {
 
     @Test
     void shouldFilterParameterizedTestCasesByFullName() {
-        final TestPlan testPlan = new TestPlanV1_0().setTests(Arrays.asList(
-                new TestPlanV1_0.TestCase()
-                        .setSelector(String.format("%s.second", FilterParameterizedTests.class.getCanonicalName())),
-                new TestPlanV1_0.TestCase()
-                        .setSelector(String.format("%s.first", FilterParameterizedTests.class.getCanonicalName()))
-        ));
+        final TestPlan testPlan = new TestPlanV1_0().setTests(
+                Arrays.asList(
+                        new TestPlanV1_0.TestCase()
+                                .setSelector(String.format("%s.second", FilterParameterizedTests.class.getCanonicalName())),
+                        new TestPlanV1_0.TestCase()
+                                .setSelector(String.format("%s.first", FilterParameterizedTests.class.getCanonicalName()))
+                )
+        );
 
         final AllureResults results = runClasses(testPlan, FilterParameterizedTests.class);
         assertThat(results.getTestResults())
@@ -92,12 +92,14 @@ void shouldFilterParameterizedTestCasesByFullName() {
 
     @Test
     void shouldFilterTestCasesByUniqueId() {
-        final TestPlan testPlan = new TestPlanV1_0().setTests(Arrays.asList(
-                new TestPlanV1_0.TestCase()
-                        .setSelector(testId(FilterSimpleTests.class, "first")),
-                new TestPlanV1_0.TestCase()
-                        .setSelector(testId(FilterSimpleTests.class, "third"))
-        ));
+        final TestPlan testPlan = new TestPlanV1_0().setTests(
+                Arrays.asList(
+                        new TestPlanV1_0.TestCase()
+                                .setSelector(testId(FilterSimpleTests.class, "first")),
+                        new TestPlanV1_0.TestCase()
+                                .setSelector(testId(FilterSimpleTests.class, "third"))
+                )
+        );
 
         final AllureResults results = runClasses(testPlan, FilterSimpleTests.class);
         assertThat(results.getTestResults())
@@ -106,14 +108,16 @@ void shouldFilterTestCasesByUniqueId() {
 
     @Test
     void shouldFilterTestCasesByAllureId() {
-        final TestPlan testPlan = new TestPlanV1_0().setTests(Arrays.asList(
-                new TestPlanV1_0.TestCase()
-                        .setId("10"),
-                new TestPlanV1_0.TestCase()
-                        .setId("20"),
-                new TestPlanV1_0.TestCase()
-                        .setId("30")
-        ));
+        final TestPlan testPlan = new TestPlanV1_0().setTests(
+                Arrays.asList(
+                        new TestPlanV1_0.TestCase()
+                                .setId("10"),
+                        new TestPlanV1_0.TestCase()
+                                .setId("20"),
+                        new TestPlanV1_0.TestCase()
+                                .setId("30")
+                )
+        );
 
         final AllureResults results = runClasses(testPlan, FilterSimpleTests.class);
         assertThat(results.getTestResults())
@@ -122,25 +126,27 @@ void shouldFilterTestCasesByAllureId() {
 
     @Test
     void shouldFilterParameterizedTestCasesByAllureId() {
-        final TestPlan testPlan = new TestPlanV1_0().setTests(Arrays.asList(
-                new TestPlanV1_0.TestCase()
-                        .setId("10"),
-                new TestPlanV1_0.TestCase()
-                        .setId("20")
-        ));
+        final TestPlan testPlan = new TestPlanV1_0().setTests(
+                Arrays.asList(
+                        new TestPlanV1_0.TestCase()
+                                .setId("10"),
+                        new TestPlanV1_0.TestCase()
+                                .setId("20")
+                )
+        );
 
         final AllureResults results = runClasses(testPlan, FilterParameterizedTests.class);
         assertThat(results.getTestResults())
                 .hasSize(4);
     }
 
-
     private String testId(final Class<?> testClass, String method) {
-        return String.format("[engine:%s]/[class:%s]/[method:%s()]",
+        return String.format(
+                "[engine:%s]/[class:%s]/[method:%s()]",
                 "junit-jupiter",
                 testClass.getCanonicalName(),
-                method);
+                method
+        );
     }
 
-
 }
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ActualExpectedStatusDetailsTests.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ActualExpectedStatusDetailsTests.java
new file mode 100644
index 00000000..b9138b6d
--- /dev/null
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ActualExpectedStatusDetailsTests.java
@@ -0,0 +1,27 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.junitplatform.features;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+public class ActualExpectedStatusDetailsTests {
+
+    @Test
+    void failingComparison() {
+        assertEquals("expected value", "actual value");
+    }
+}
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/AllureIdAnnotationSupport.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/AllureIdAnnotationSupport.java
index 713baedd..ec657f0f 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/AllureIdAnnotationSupport.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/AllureIdAnnotationSupport.java
@@ -17,10 +17,6 @@
 
 import io.qameta.allure.AllureId;
 import org.junit.jupiter.api.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class AllureIdAnnotationSupport {
 
     @AllureId("123")
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/BrokenTests.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/BrokenTests.java
index e7c36c2e..1ca8c98f 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/BrokenTests.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/BrokenTests.java
@@ -16,10 +16,6 @@
 package io.qameta.allure.junitplatform.features;
 
 import org.junit.jupiter.api.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class BrokenTests {
 
     @Test
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DescriptionJavadocTest.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DescriptionJavadocTest.java
index d0247b9d..032d5aaa 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DescriptionJavadocTest.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DescriptionJavadocTest.java
@@ -17,10 +17,6 @@
 
 import io.qameta.allure.Description;
 import org.junit.jupiter.api.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class DescriptionJavadocTest {
 
     /**
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DisabledRepeatedTests.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DisabledRepeatedTests.java
index b61a852d..3e128100 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DisabledRepeatedTests.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DisabledRepeatedTests.java
@@ -18,10 +18,6 @@
 import io.qameta.allure.Owner;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.RepeatedTest;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class DisabledRepeatedTests {
 
     @Owner("other guy")
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DisplayNameOnClassTests.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DisplayNameOnClassTests.java
index 773972b6..e9e49313 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DisplayNameOnClassTests.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DisplayNameOnClassTests.java
@@ -17,10 +17,6 @@
 
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @DisplayName("Custom suite name")
 public class DisplayNameOnClassTests {
 
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DynamicTests.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DynamicTests.java
index 3a778417..3eb9d628 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DynamicTests.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DynamicTests.java
@@ -26,10 +26,6 @@
 import java.util.stream.Stream;
 
 import static org.junit.jupiter.api.DynamicTest.dynamicTest;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @Epic("epic4")
 @Feature("feature4")
 @Story("story4")
@@ -42,16 +38,19 @@ public class DynamicTests {
     @Feature("feature2")
     @Feature("feature3")
     @Story("story1")
-    @Stories({
-            @Story("story2"),
-            @Story("story3")
-    })
+    @Stories(
+        {
+                @Story("story2"),
+                @Story("story3")
+        }
+    )
     @Owner("some-owner")
     @TestFactory
     Stream<DynamicTest> dynamicTestsFromStream() {
         return Stream.of("A", "B", "C").map(
                 str -> dynamicTest("test" + str, () -> {
-                }));
+                })
+        );
     }
 
 }
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/FailedTests.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/FailedTests.java
index f8f2cdec..127da0a1 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/FailedTests.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/FailedTests.java
@@ -18,10 +18,6 @@
 import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.fail;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class FailedTests {
 
     @Test
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/FilterParameterizedTests.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/FilterParameterizedTests.java
index 814fe4dd..7603586e 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/FilterParameterizedTests.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/FilterParameterizedTests.java
@@ -19,10 +19,6 @@
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class FilterParameterizedTests {
 
     @BeforeAll
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/FilterSimpleTests.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/FilterSimpleTests.java
index cc323b52..6f0dc19b 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/FilterSimpleTests.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/FilterSimpleTests.java
@@ -18,14 +18,10 @@
 import io.qameta.allure.AllureId;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class FilterSimpleTests {
 
     @BeforeAll
-    static void doNothing(){
+    static void doNothing() {
 
     }
 
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/JupiterUniqueIdTest.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/JupiterUniqueIdTest.java
index 943ad3e7..ae0aff04 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/JupiterUniqueIdTest.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/JupiterUniqueIdTest.java
@@ -16,10 +16,6 @@
 package io.qameta.allure.junitplatform.features;
 
 import org.junit.jupiter.api.Test;
-
-/**
- * @author naresha (Naresha K)
- */
 public class JupiterUniqueIdTest {
 
     @Test
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/MarkerAnnotationSupport.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/MarkerAnnotationSupport.java
index 6a03203d..1dd43e5d 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/MarkerAnnotationSupport.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/MarkerAnnotationSupport.java
@@ -27,10 +27,6 @@
 
 import static io.qameta.allure.util.ResultsUtils.FEATURE_LABEL_NAME;
 import static io.qameta.allure.util.ResultsUtils.STORY_LABEL_NAME;
-
-/**
- * @author jkttt on 05.07.17.
- */
 public class MarkerAnnotationSupport {
 
     @Custom
@@ -42,8 +38,14 @@ void single() {
     @Inherited
     @Retention(RetentionPolicy.RUNTIME)
     @Target({ElementType.METHOD, ElementType.TYPE})
-    @LabelAnnotation(name = FEATURE_LABEL_NAME, value = "Basic framework support")
-    @LabelAnnotation(name = STORY_LABEL_NAME, value = "Core features")
+    @LabelAnnotation(
+            name = FEATURE_LABEL_NAME,
+            value = "Basic framework support"
+    )
+    @LabelAnnotation(
+            name = STORY_LABEL_NAME,
+            value = "Core features"
+    )
     public @interface Custom {
     }
 }
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/NestedTests.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/NestedTests.java
index 48fa3c34..a3e41f21 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/NestedTests.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/NestedTests.java
@@ -20,10 +20,6 @@
 import io.qameta.allure.Story;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @Epic("Parent epic")
 public class NestedTests {
 
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/OneTest.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/OneTest.java
index 6cf10d14..fd75e990 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/OneTest.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/OneTest.java
@@ -16,10 +16,6 @@
 package io.qameta.allure.junitplatform.features;
 
 import org.junit.jupiter.api.Test;
-
-/**
- * @author jkttt on 05.07.17.
- */
 public class OneTest {
 
     @Test
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/OwnerTest.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/OwnerTest.java
index ba31c5e4..2638c7d1 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/OwnerTest.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/OwnerTest.java
@@ -17,10 +17,6 @@
 
 import io.qameta.allure.Owner;
 import org.junit.jupiter.api.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @Owner("first")
 public class OwnerTest {
 
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ParallelTests.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ParallelTests.java
index 085b9720..be2221ed 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ParallelTests.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ParallelTests.java
@@ -20,10 +20,6 @@
 import org.junit.jupiter.api.parallel.ExecutionMode;
 
 import java.util.concurrent.TimeUnit;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @Execution(ExecutionMode.CONCURRENT)
 public class ParallelTests {
 
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ParameterisedTests.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ParameterisedTests.java
index adf7dfa2..a6fb8da1 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ParameterisedTests.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ParameterisedTests.java
@@ -17,10 +17,6 @@
 
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class ParameterisedTests {
 
     @ParameterizedTest
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ParameterisedTestsWithDisplayName.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ParameterisedTestsWithDisplayName.java
index 2f3809fa..fdcff92a 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ParameterisedTestsWithDisplayName.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ParameterisedTestsWithDisplayName.java
@@ -18,10 +18,6 @@
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class ParameterisedTestsWithDisplayName {
 
     @DisplayName("Second Test")
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/PassedTests.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/PassedTests.java
index 12587b37..8e6edd3f 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/PassedTests.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/PassedTests.java
@@ -17,14 +17,10 @@
 
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class PassedTests {
 
     @BeforeAll
-    static void doNothing(){
+    static void doNothing() {
 
     }
 
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/RepeatedTests.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/RepeatedTests.java
index f1723b82..bbde927a 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/RepeatedTests.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/RepeatedTests.java
@@ -17,10 +17,6 @@
 
 import io.qameta.allure.Owner;
 import org.junit.jupiter.api.RepeatedTest;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class RepeatedTests {
 
     @Owner("me")
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ReportEntryParameter.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ReportEntryParameter.java
index f51f82ec..a3c905b2 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ReportEntryParameter.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ReportEntryParameter.java
@@ -27,10 +27,6 @@
 import static io.qameta.allure.junitplatform.AllureJunitPlatform.ALLURE_PARAMETER_EXCLUDED_KEY;
 import static io.qameta.allure.junitplatform.AllureJunitPlatform.ALLURE_PARAMETER_MODE_KEY;
 import static io.qameta.allure.junitplatform.AllureJunitPlatform.ALLURE_PARAMETER_VALUE_KEY;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class ReportEntryParameter {
 
     @Test
@@ -47,24 +43,30 @@ void multipleParameterEvent(TestReporter testReporter) {
 
     @Test
     void modeAndExcluded(TestReporter testReporter) {
-        testReporter.publishEntry(buildEvent(
-                "hidden excluded",
-                "hidden excluded value",
-                Parameter.Mode.HIDDEN,
-                true
-        ));
-        testReporter.publishEntry(buildEvent(
-                "default excluded",
-                "default excluded value",
-                Parameter.Mode.DEFAULT,
-                true
-        ));
-        testReporter.publishEntry(buildEvent(
-                "masked not excluded",
-                "masked not excluded value",
-                Parameter.Mode.MASKED,
-                false
-        ));
+        testReporter.publishEntry(
+                buildEvent(
+                        "hidden excluded",
+                        "hidden excluded value",
+                        Parameter.Mode.HIDDEN,
+                        true
+                )
+        );
+        testReporter.publishEntry(
+                buildEvent(
+                        "default excluded",
+                        "default excluded value",
+                        Parameter.Mode.DEFAULT,
+                        true
+                )
+        );
+        testReporter.publishEntry(
+                buildEvent(
+                        "masked not excluded",
+                        "masked not excluded value",
+                        Parameter.Mode.MASKED,
+                        false
+                )
+        );
     }
 
     private Map<String, String> buildEvent(final String name,
@@ -89,5 +91,4 @@ private Map<String, String> buildEvent(final String name,
         return data;
     }
 
-
 }
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/SeverityTest.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/SeverityTest.java
index a9262a45..3dbab0e2 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/SeverityTest.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/SeverityTest.java
@@ -18,10 +18,6 @@
 import io.qameta.allure.Severity;
 import io.qameta.allure.SeverityLevel;
 import org.junit.jupiter.api.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @Severity(SeverityLevel.TRIVIAL)
 public class SeverityTest {
 
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/SkippedInBeforeAllTests.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/SkippedInBeforeAllTests.java
index f984955d..6bfac8bf 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/SkippedInBeforeAllTests.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/SkippedInBeforeAllTests.java
@@ -22,8 +22,8 @@
 public class SkippedInBeforeAllTests {
 
     @BeforeAll
-    static void skip(){
-        Assumptions.assumeTrue(false,"Skip in @BeforeAll");
+    static void skip() {
+        Assumptions.assumeTrue(false, "Skip in @BeforeAll");
     }
     @Test
     void test() {
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/SkippedTests.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/SkippedTests.java
index 080dc618..b79783af 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/SkippedTests.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/SkippedTests.java
@@ -18,10 +18,6 @@
 import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assumptions.assumeTrue;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class SkippedTests {
 
     @Test
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TaggedTests.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TaggedTests.java
index bacf18e4..9d06beba 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TaggedTests.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TaggedTests.java
@@ -17,10 +17,6 @@
 
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
-
-/**
- * @author jkttt on 05.07.17.
- */
 @Tag(TaggedTests.CLASS_TAG)
 public class TaggedTests {
 
@@ -29,5 +25,6 @@ public class TaggedTests {
 
     @Test
     @Tag(METHOD_TAG)
-    void taggedTest() {}
+    void taggedTest() {
+    }
 }
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestClassDisabled.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestClassDisabled.java
index 7a7e1e23..801ad2c5 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestClassDisabled.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestClassDisabled.java
@@ -20,10 +20,6 @@
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @Disabled
 public class TestClassDisabled {
 
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestClassWithDisplayNameAnnotation.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestClassWithDisplayNameAnnotation.java
index b8bec7bf..4d9d8d92 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestClassWithDisplayNameAnnotation.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestClassWithDisplayNameAnnotation.java
@@ -17,10 +17,6 @@
 
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
-
-/**
- * @author a.afrikanov (Andrey Afrikanov).
- */
 @DisplayName("Display name of test class")
 public class TestClassWithDisplayNameAnnotation {
 
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestClassWithoutDisplayNameAnnotation.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestClassWithoutDisplayNameAnnotation.java
index 91699e2e..bce92a1e 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestClassWithoutDisplayNameAnnotation.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestClassWithoutDisplayNameAnnotation.java
@@ -16,10 +16,6 @@
 package io.qameta.allure.junitplatform.features;
 
 import org.junit.jupiter.api.Test;
-
-/**
- * @author a.afrikanov (Andrey Afrikanov).
- */
 public class TestClassWithoutDisplayNameAnnotation {
 
     @Test
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithClassLabels.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithClassLabels.java
index 260a0bec..8ea13e49 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithClassLabels.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithClassLabels.java
@@ -21,10 +21,6 @@
 import io.qameta.allure.Stories;
 import io.qameta.allure.Story;
 import org.junit.jupiter.api.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @Epic("epic1")
 @Epic("epic2")
 @Epic("epic3")
@@ -32,10 +28,12 @@
 @Feature("feature2")
 @Feature("feature3")
 @Story("story1")
-@Stories({
-        @Story("story2"),
-        @Story("story3")
-})
+@Stories(
+    {
+            @Story("story2"),
+            @Story("story3")
+    }
+)
 @Owner("some-owner")
 public class TestWithClassLabels {
 
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithClassLinks.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithClassLinks.java
index decfd287..ac7034a2 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithClassLinks.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithClassLinks.java
@@ -24,20 +24,29 @@
 import org.junit.jupiter.api.Test;
 
 @Link(name = "LINK-1")
-@Links({
-        @Link(name = "LINK-2", url = "https://example.org/link/2"),
-        @Link(url = "https://example.org/some-custom-link")
-})
+@Links(
+    {
+            @Link(
+                    name = "LINK-2",
+                    url = "https://example.org/link/2"
+            ),
+            @Link(url = "https://example.org/some-custom-link")
+    }
+)
 @TmsLink("TMS-1")
-@TmsLinks({
-        @TmsLink("TMS-2"),
-        @TmsLink("TMS-3")
-})
+@TmsLinks(
+    {
+            @TmsLink("TMS-2"),
+            @TmsLink("TMS-3")
+    }
+)
 @Issue("ISSUE-1")
-@Issues({
-        @Issue("ISSUE-2"),
-        @Issue("ISSUE-3")
-})
+@Issues(
+    {
+            @Issue("ISSUE-2"),
+            @Issue("ISSUE-3")
+    }
+)
 public class TestWithClassLinks {
 
     @Test
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithDescription.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithDescription.java
index b6ccc170..0e723f59 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithDescription.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithDescription.java
@@ -17,10 +17,6 @@
 
 import io.qameta.allure.Description;
 import org.junit.jupiter.api.Test;
-
-/**
- * @author a.afrikanov (Andrey Afrikanov).
- */
 public class TestWithDescription {
 
     @Test
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithDisplayName.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithDisplayName.java
index b82280be..f883acac 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithDisplayName.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithDisplayName.java
@@ -17,10 +17,6 @@
 
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class TestWithDisplayName {
 
     @Test
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithMethodLabels.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithMethodLabels.java
index 419036bb..36a45653 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithMethodLabels.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithMethodLabels.java
@@ -21,10 +21,6 @@
 import io.qameta.allure.Stories;
 import io.qameta.allure.Story;
 import org.junit.jupiter.api.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class TestWithMethodLabels {
 
     @Test
@@ -35,10 +31,12 @@ public class TestWithMethodLabels {
     @Feature("feature2")
     @Feature("feature3")
     @Story("story1")
-    @Stories({
-            @Story("story2"),
-            @Story("story3")
-    })
+    @Stories(
+        {
+                @Story("story2"),
+                @Story("story3")
+        }
+    )
     @Owner("some-owner")
     void someTest() {
     }
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithMethodLinks.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithMethodLinks.java
index 91ee2570..f04fd7b6 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithMethodLinks.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithMethodLinks.java
@@ -27,20 +27,29 @@ public class TestWithMethodLinks {
 
     @Test
     @Link(name = "LINK-1")
-    @Links({
-            @Link(name = "LINK-2", url = "https://example.org/link/2"),
-            @Link(url = "https://example.org/some-custom-link")
-    })
+    @Links(
+        {
+                @Link(
+                        name = "LINK-2",
+                        url = "https://example.org/link/2"
+                ),
+                @Link(url = "https://example.org/some-custom-link")
+        }
+    )
     @TmsLink("TMS-1")
-    @TmsLinks({
-            @TmsLink("TMS-2"),
-            @TmsLink("TMS-3")
-    })
+    @TmsLinks(
+        {
+                @TmsLink("TMS-2"),
+                @TmsLink("TMS-3")
+        }
+    )
     @Issue("ISSUE-1")
-    @Issues({
-            @Issue("ISSUE-2"),
-            @Issue("ISSUE-3")
-    })
+    @Issues(
+        {
+                @Issue("ISSUE-2"),
+                @Issue("ISSUE-3")
+        }
+    )
     void someTest() {
     }
 
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithSteps.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithSteps.java
index e33bea57..4b1d5ca5 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithSteps.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithSteps.java
@@ -21,10 +21,6 @@
 import org.junit.jupiter.api.Test;
 
 import java.util.UUID;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class TestWithSteps {
 
     @Test
@@ -37,9 +33,10 @@ void testWithSteps() {
     protected final void step(final String stepName) {
         final String uuid = UUID.randomUUID().toString();
         try {
-            Allure.getLifecycle().startStep(uuid, new StepResult()
-                    .setName(stepName)
-                    .setStatus(Status.PASSED)
+            Allure.getLifecycle().startStep(
+                    uuid, new StepResult()
+                            .setName(stepName)
+                            .setStatus(Status.PASSED)
             );
         } finally {
             Allure.getLifecycle().stopStep(uuid);
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithSystemErr.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithSystemErr.java
index df3ac996..9caf994c 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithSystemErr.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithSystemErr.java
@@ -16,10 +16,6 @@
 package io.qameta.allure.junitplatform.features;
 
 import org.junit.jupiter.api.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class TestWithSystemErr {
 
     @Test
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithSystemOut.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithSystemOut.java
index b142de5e..89757491 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithSystemOut.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithSystemOut.java
@@ -16,10 +16,6 @@
 package io.qameta.allure.junitplatform.features;
 
 import org.junit.jupiter.api.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class TestWithSystemOut {
 
     @Test
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestsWithAllureId.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestsWithAllureId.java
index d8f62c11..b80a7c4d 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestsWithAllureId.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestsWithAllureId.java
@@ -19,14 +19,10 @@
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class TestsWithAllureId {
 
     @BeforeAll
-    static void doNothing(){
+    static void doNothing() {
 
     }
 
diff --git a/allure-junit-platform/src/test/resources/allure.properties b/allure-junit-platform/src/test/resources/allure.properties
index 9c0b0a2d..cff9d085 100644
--- a/allure-junit-platform/src/test/resources/allure.properties
+++ b/allure-junit-platform/src/test/resources/allure.properties
@@ -1,2 +1,3 @@
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-junit-platform
diff --git a/allure-junit4-aspect/build.gradle.kts b/allure-junit4-aspect/build.gradle.kts
index 79d3bc53..df743502 100644
--- a/allure-junit4-aspect/build.gradle.kts
+++ b/allure-junit4-aspect/build.gradle.kts
@@ -6,6 +6,13 @@ dependencies {
     api(project(":allure-junit4"))
     compileOnly("junit:junit:$junitVersion")
     compileOnly("org.aspectj:aspectjrt")
+    testImplementation("junit:junit:$junitVersion")
+    testImplementation("org.junit.jupiter:junit-jupiter-api")
+    testImplementation("org.aspectj:aspectjrt")
+    testImplementation("org.mockito:mockito-core")
+    testImplementation("org.slf4j:slf4j-simple")
+    testImplementation(project(":allure-junit-platform"))
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
 }
 
 tasks.jar {
@@ -15,3 +22,7 @@ tasks.jar {
         ))
     }
 }
+
+tasks.test {
+    useJUnitPlatform()
+}
diff --git a/allure-junit4-aspect/src/main/java/io/qameta/allure/junit4/aspect/AllureJunit4FilterAspect.java b/allure-junit4-aspect/src/main/java/io/qameta/allure/junit4/aspect/AllureJunit4FilterAspect.java
index 2e7e6612..c8344981 100644
--- a/allure-junit4-aspect/src/main/java/io/qameta/allure/junit4/aspect/AllureJunit4FilterAspect.java
+++ b/allure-junit4-aspect/src/main/java/io/qameta/allure/junit4/aspect/AllureJunit4FilterAspect.java
@@ -23,7 +23,9 @@
 import org.junit.runner.manipulation.NoTestsRemainException;
 
 /**
- * @author Egor Borisov ehborisov@gmail.com
+ * Integrates JUnit 4 with AspectJ with Allure reporting.
+ *
+ * <p>Register this type through the standard JUnit 4 with AspectJ extension, listener, interceptor, or plugin mechanism so framework execution events are written to Allure results. Use explicit dependencies when embedding the integration in tests or custom runtimes.</p>
  */
 @Aspect
 public class AllureJunit4FilterAspect {
@@ -32,6 +34,12 @@ public class AllureJunit4FilterAspect {
             value = "execution(public org.junit.runner.Runner org.junit.runner.Request+.getRunner())",
             returning = "runner"
     )
+
+    /**
+     * Handles the filter before run callback.
+     *
+     * @param runner the runner
+     */
     public void filterBeforeRun(final Runner runner) {
         if (runner instanceof Filterable) {
             try {
diff --git a/allure-junit4-aspect/src/main/java/io/qameta/allure/junit4/aspect/AllureJunit4ListenerAspect.java b/allure-junit4-aspect/src/main/java/io/qameta/allure/junit4/aspect/AllureJunit4ListenerAspect.java
index a7dd916f..82bd11e2 100644
--- a/allure-junit4-aspect/src/main/java/io/qameta/allure/junit4/aspect/AllureJunit4ListenerAspect.java
+++ b/allure-junit4-aspect/src/main/java/io/qameta/allure/junit4/aspect/AllureJunit4ListenerAspect.java
@@ -22,13 +22,20 @@
 import org.junit.runner.notification.RunNotifier;
 
 /**
- * @author Egor Borisov ehborisov@gmail.com
+ * Integrates JUnit 4 with AspectJ with Allure reporting.
+ *
+ * <p>Register this type through the standard JUnit 4 with AspectJ extension, listener, interceptor, or plugin mechanism so framework execution events are written to Allure results. Use explicit dependencies when embedding the integration in tests or custom runtimes.</p>
  */
 @Aspect
 public class AllureJunit4ListenerAspect {
 
     private final AllureJunit4 allure = new AllureJunit4();
 
+    /**
+     * Adds the listener.
+     *
+     * @param point the point
+     */
     @After("execution(org.junit.runner.notification.RunNotifier.new())")
     public void addListener(final JoinPoint point) {
         final RunNotifier notifier = (RunNotifier) point.getThis();
diff --git a/allure-junit4-aspect/src/test/java/io/qameta/allure/junit4/aspect/AllureJunit4AspectTest.java b/allure-junit4-aspect/src/test/java/io/qameta/allure/junit4/aspect/AllureJunit4AspectTest.java
new file mode 100644
index 00000000..5b0d0c5b
--- /dev/null
+++ b/allure-junit4-aspect/src/test/java/io/qameta/allure/junit4/aspect/AllureJunit4AspectTest.java
@@ -0,0 +1,124 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.junit4.aspect;
+
+import io.qameta.allure.Allure;
+import io.qameta.allure.junit4.AllureJunit4;
+import io.qameta.allure.junit4.AllureJunit4Filter;
+import org.aspectj.lang.JoinPoint;
+import org.junit.jupiter.api.Test;
+import org.junit.runner.Description;
+import org.junit.runner.Runner;
+import org.junit.runner.manipulation.Filter;
+import org.junit.runner.manipulation.Filterable;
+import org.junit.runner.manipulation.NoTestsRemainException;
+import org.junit.runner.notification.RunListener;
+import org.junit.runner.notification.RunNotifier;
+
+import java.lang.reflect.Field;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class AllureJunit4AspectTest {
+
+    @Test
+    void shouldApplyAllureFilterToFilterableRunner() {
+        final TrackingRunner runner = new TrackingRunner(false);
+
+        new AllureJunit4FilterAspect().filterBeforeRun(runner);
+
+        assertNotNull(runner.appliedFilter);
+        assertInstanceOf(AllureJunit4Filter.class, runner.appliedFilter);
+    }
+
+    @Test
+    void shouldIgnoreNoTestsRemainExceptionDuringFiltering() {
+        final TrackingRunner runner = new TrackingRunner(true);
+
+        assertDoesNotThrow(() -> new AllureJunit4FilterAspect().filterBeforeRun(runner));
+        assertNotNull(runner.appliedFilter);
+    }
+
+    @Test
+    void shouldAddListenerToPlainRunNotifier() throws Exception {
+        final RunNotifier notifier = new RunNotifier();
+        final JoinPoint point = mock(JoinPoint.class);
+        when(point.getThis()).thenReturn(notifier);
+
+        Allure.step(
+                "Invoke the listener aspect against a plain RunNotifier", () -> new AllureJunit4ListenerAspect().addListener(point)
+        );
+
+        Allure.step(
+                "Verify the notifier now contains the Allure JUnit 4 listener", () -> assertTrue(getListeners(notifier).stream().anyMatch(AllureJunit4.class::isInstance))
+        );
+    }
+
+    @Test
+    void shouldSkipDerivedRunNotifierInstances() throws Exception {
+        final DerivedRunNotifier notifier = new DerivedRunNotifier();
+        final JoinPoint point = mock(JoinPoint.class);
+        when(point.getThis()).thenReturn(notifier);
+
+        new AllureJunit4ListenerAspect().addListener(point);
+
+        assertFalse(getListeners(notifier).stream().anyMatch(AllureJunit4.class::isInstance));
+    }
+
+    @SuppressWarnings("unchecked")
+    private static List<RunListener> getListeners(final RunNotifier notifier) throws Exception {
+        final Field listeners = RunNotifier.class.getDeclaredField("listeners");
+        listeners.setAccessible(true);
+        return (List<RunListener>) listeners.get(notifier);
+    }
+
+    private static final class TrackingRunner extends Runner implements Filterable {
+        private final boolean throwNoTestsRemain;
+        private Filter appliedFilter;
+
+        private TrackingRunner(final boolean throwNoTestsRemain) {
+            this.throwNoTestsRemain = throwNoTestsRemain;
+        }
+
+        @Override
+        public Description getDescription() {
+            return Description.EMPTY;
+        }
+
+        @Override
+        public void run(final RunNotifier notifier) {
+            // no-op
+        }
+
+        @Override
+        public void filter(final Filter filter) throws NoTestsRemainException {
+            this.appliedFilter = filter;
+            if (throwNoTestsRemain) {
+                throw new NoTestsRemainException();
+            }
+        }
+    }
+
+    private static final class DerivedRunNotifier extends RunNotifier {
+    }
+}
diff --git a/allure-junit4-aspect/src/test/resources/allure.properties b/allure-junit4-aspect/src/test/resources/allure.properties
new file mode 100644
index 00000000..3d37acf1
--- /dev/null
+++ b/allure-junit4-aspect/src/test/resources/allure.properties
@@ -0,0 +1,3 @@
+allure.results.directory=build/allure-results
+allure.label.epic=#project.description#
+allure.label.module=allure-junit4-aspect
diff --git a/allure-junit4/src/main/java/io/qameta/allure/junit4/AllureJunit4.java b/allure-junit4/src/main/java/io/qameta/allure/junit4/AllureJunit4.java
index b79cff7a..b3a00089 100644
--- a/allure-junit4/src/main/java/io/qameta/allure/junit4/AllureJunit4.java
+++ b/allure-junit4/src/main/java/io/qameta/allure/junit4/AllureJunit4.java
@@ -49,6 +49,7 @@
 import static io.qameta.allure.util.ResultsUtils.createTestClassLabel;
 import static io.qameta.allure.util.ResultsUtils.createTestMethodLabel;
 import static io.qameta.allure.util.ResultsUtils.createThreadLabel;
+import static io.qameta.allure.util.ResultsUtils.createTitlePathFromPackageAndClass;
 import static io.qameta.allure.util.ResultsUtils.getJavadocDescription;
 import static io.qameta.allure.util.ResultsUtils.getProvidedLabels;
 import static io.qameta.allure.util.ResultsUtils.getStatus;
@@ -62,17 +63,13 @@
 @SuppressWarnings({"checkstyle:ClassFanOutComplexity"})
 public class AllureJunit4 extends RunListener {
 
-    private static final boolean HAS_CUCUMBERJVM7_IN_CLASSPATH
-            = isClassAvailableOnClasspath("io.qameta.allure.cucumber7jvm.AllureCucumber7Jvm");
+    private static final boolean HAS_CUCUMBERJVM7_IN_CLASSPATH = isClassAvailableOnClasspath("io.qameta.allure.cucumber7jvm.AllureCucumber7Jvm");
 
-    private static final boolean HAS_CUCUMBERJVM6_IN_CLASSPATH
-            = isClassAvailableOnClasspath("io.qameta.allure.cucumber6jvm.AllureCucumber6Jvm");
+    private static final boolean HAS_CUCUMBERJVM6_IN_CLASSPATH = isClassAvailableOnClasspath("io.qameta.allure.cucumber6jvm.AllureCucumber6Jvm");
 
-    private static final boolean HAS_CUCUMBERJVM5_IN_CLASSPATH
-            = isClassAvailableOnClasspath("io.qameta.allure.cucumber5jvm.AllureCucumber5Jvm");
+    private static final boolean HAS_CUCUMBERJVM5_IN_CLASSPATH = isClassAvailableOnClasspath("io.qameta.allure.cucumber5jvm.AllureCucumber5Jvm");
 
-    private static final boolean HAS_CUCUMBERJVM4_IN_CLASSPATH
-            = isClassAvailableOnClasspath("io.qameta.allure.cucumber4jvm.AllureCucumber4Jvm");
+    private static final boolean HAS_CUCUMBERJVM4_IN_CLASSPATH = isClassAvailableOnClasspath("io.qameta.allure.cucumber4jvm.AllureCucumber4Jvm");
 
     private final ThreadLocal<String> testCases = new InheritableThreadLocal<String>() {
         @Override
@@ -83,28 +80,50 @@ protected String initialValue() {
 
     private final AllureLifecycle lifecycle;
 
+    /**
+     * Creates an Allure junit4 with default configuration.
+     */
     public AllureJunit4() {
         this(Allure.getLifecycle());
     }
 
+    /**
+     * Creates an Allure junit4 with the supplied values.
+     *
+     * @param lifecycle the Allure lifecycle to use
+     */
     public AllureJunit4(final AllureLifecycle lifecycle) {
         this.lifecycle = lifecycle;
     }
 
+    /**
+     * Returns the lifecycle.
+     *
+     * @return the Allure lifecycle used by this integration
+     */
     public AllureLifecycle getLifecycle() {
         return lifecycle;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void testRunStarted(final Description description) {
         //do nothing
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void testRunFinished(final Result result) {
         //do nothing
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void testStarted(final Description description) {
         if (shouldIgnore(description)) {
@@ -116,6 +135,9 @@ public void testStarted(final Description description) {
         getLifecycle().startTestCase(uuid);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void testFinished(final Description description) {
         if (shouldIgnore(description)) {
@@ -133,30 +155,40 @@ public void testFinished(final Description description) {
         getLifecycle().writeTestCase(uuid);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void testFailure(final Failure failure) {
         if (shouldIgnore(failure.getDescription())) {
             return;
         }
         final String uuid = testCases.get();
-        getLifecycle().updateTestCase(uuid, testResult -> testResult
-                .setStatus(getStatus(failure.getException()).orElse(null))
-                .setStatusDetails(getStatusDetails(failure.getException()).orElse(null))
+        getLifecycle().updateTestCase(
+                uuid, testResult -> testResult
+                        .setStatus(getStatus(failure.getException()).orElse(null))
+                        .setStatusDetails(getStatusDetails(failure.getException()).orElse(null))
         );
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void testAssumptionFailure(final Failure failure) {
         if (shouldIgnore(failure.getDescription())) {
             return;
         }
         final String uuid = testCases.get();
-        getLifecycle().updateTestCase(uuid, testResult ->
-                testResult.setStatus(Status.SKIPPED)
+        getLifecycle().updateTestCase(
+                uuid, testResult -> testResult.setStatus(Status.SKIPPED)
                         .setStatusDetails(getStatusDetails(failure.getException()).orElse(null))
         );
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void testIgnored(final Description description) {
         if (shouldIgnore(description)) {
@@ -247,7 +279,8 @@ private String getPackage(final Class<?> testClass) {
     private StatusDetails getIgnoredMessage(final Description description) {
         final Ignore ignore = description.getAnnotation(Ignore.class);
         final String message = Objects.nonNull(ignore) && !ignore.value().isEmpty()
-                ? ignore.value() : "Test ignored (without reason)!";
+                ? ignore.value()
+                : "Test ignored (without reason)!";
         return new StatusDetails().setMessage(message);
     }
 
@@ -264,19 +297,22 @@ private TestResult createTestResult(final String uuid, final Description descrip
                 .setUuid(uuid)
                 .setHistoryId(getHistoryId(description))
                 .setFullName(fullName)
-                .setName(name);
+                .setName(name)
+                .setTitlePath(createTitlePathFromPackageAndClass(getPackage(description.getTestClass()), suite));
 
         testResult.getLabels().addAll(getProvidedLabels());
-        testResult.getLabels().addAll(Arrays.asList(
-                createPackageLabel(getPackage(description.getTestClass())),
-                createTestClassLabel(className),
-                createTestMethodLabel(name),
-                createSuiteLabel(suite),
-                createHostLabel(),
-                createThreadLabel(),
-                createFrameworkLabel("junit4"),
-                createLanguageLabel("java")
-        ));
+        testResult.getLabels().addAll(
+                Arrays.asList(
+                        createPackageLabel(getPackage(description.getTestClass())),
+                        createTestClassLabel(className),
+                        createTestMethodLabel(name),
+                        createSuiteLabel(suite),
+                        createHostLabel(),
+                        createThreadLabel(),
+                        createFrameworkLabel("junit4"),
+                        createLanguageLabel("java")
+                )
+        );
         testResult.getLabels().addAll(extractLabels(description));
         testResult.getLinks().addAll(extractLinks(description));
 
@@ -291,8 +327,7 @@ private boolean shouldIgnore(final Description description) {
         return (HAS_CUCUMBERJVM7_IN_CLASSPATH
                 || HAS_CUCUMBERJVM6_IN_CLASSPATH
                 || HAS_CUCUMBERJVM5_IN_CLASSPATH
-                || HAS_CUCUMBERJVM4_IN_CLASSPATH
-               ) && AllureJunit4Utils.isCucumberTest(description);
+                || HAS_CUCUMBERJVM4_IN_CLASSPATH) && AllureJunit4Utils.isCucumberTest(description);
     }
 
     private static boolean isClassAvailableOnClasspath(final String clazz) {
diff --git a/allure-junit4/src/main/java/io/qameta/allure/junit4/AllureJunit4Filter.java b/allure-junit4/src/main/java/io/qameta/allure/junit4/AllureJunit4Filter.java
index a4a46d58..03c9f79f 100644
--- a/allure-junit4/src/main/java/io/qameta/allure/junit4/AllureJunit4Filter.java
+++ b/allure-junit4/src/main/java/io/qameta/allure/junit4/AllureJunit4Filter.java
@@ -29,20 +29,33 @@
 import static io.qameta.allure.util.ResultsUtils.ALLURE_ID_LABEL_NAME;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Integrates JUnit 4 with Allure reporting.
+ *
+ * <p>Register this type through the standard JUnit 4 extension, listener, interceptor, or plugin mechanism so framework execution events are written to Allure results. Use explicit dependencies when embedding the integration in tests or custom runtimes.</p>
  */
 public class AllureJunit4Filter extends Filter {
 
     private final TestPlan testPlan;
 
+    /**
+     * Creates an Allure junit4 filter with default configuration.
+     */
     public AllureJunit4Filter() {
         this(new FileTestPlanSupplier().supply().orElse(null));
     }
 
+    /**
+     * Creates an Allure junit4 filter with the supplied values.
+     *
+     * @param testPlan the Allure test plan to evaluate against
+     */
     public AllureJunit4Filter(final TestPlan testPlan) {
         this.testPlan = testPlan;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public boolean shouldRun(final Description description) {
         if (Objects.isNull(testPlan)) {
@@ -59,6 +72,9 @@ public boolean shouldRun(final Description description) {
         return isIncluded(testPlan, allureId, fullName);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public String describe() {
         return "allure testplan filter";
@@ -82,7 +98,7 @@ private boolean match(final TestPlanV1_0.TestCase tc,
                           final String allureId,
                           final String fullName) {
         return Objects.nonNull(tc.getId()) && tc.getId().equals(allureId)
-               || Objects.nonNull(tc.getSelector()) && tc.getSelector().equals(fullName);
+                || Objects.nonNull(tc.getSelector()) && tc.getSelector().equals(fullName);
     }
 
     private static Optional<String> findAllureId(final Description description) {
diff --git a/allure-junit4/src/main/java/io/qameta/allure/junit4/AllureJunit4Utils.java b/allure-junit4/src/main/java/io/qameta/allure/junit4/AllureJunit4Utils.java
index 1f5ec302..6163100a 100644
--- a/allure-junit4/src/main/java/io/qameta/allure/junit4/AllureJunit4Utils.java
+++ b/allure-junit4/src/main/java/io/qameta/allure/junit4/AllureJunit4Utils.java
@@ -20,10 +20,6 @@
 import java.io.Serializable;
 import java.nio.file.Paths;
 import java.util.Objects;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 /* package-private */ final class AllureJunit4Utils {
 
     private static final Description CUCUMBER_CHECK_DESCRIPTION = Description
@@ -62,7 +58,8 @@ public static String getFullName(final Description description) {
         final String className = description.getClassName();
         final String methodName = description.getMethodName();
         return Objects.nonNull(methodName)
-                ? String.format("%s.%s", className, methodName) : className;
+                ? String.format("%s.%s", className, methodName)
+                : className;
     }
 
     public static boolean isCucumberTest(final Description description) {
diff --git a/allure-junit4/src/main/java/io/qameta/allure/junit4/DisplayName.java b/allure-junit4/src/main/java/io/qameta/allure/junit4/DisplayName.java
index 165ab849..c56d1d53 100644
--- a/allure-junit4/src/main/java/io/qameta/allure/junit4/DisplayName.java
+++ b/allure-junit4/src/main/java/io/qameta/allure/junit4/DisplayName.java
@@ -31,6 +31,11 @@
 @Target({ElementType.METHOD, ElementType.TYPE})
 public @interface DisplayName {
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     String value();
 
 }
diff --git a/allure-junit4/src/main/java/io/qameta/allure/junit4/Tag.java b/allure-junit4/src/main/java/io/qameta/allure/junit4/Tag.java
index 6813f5aa..e6787f95 100644
--- a/allure-junit4/src/main/java/io/qameta/allure/junit4/Tag.java
+++ b/allure-junit4/src/main/java/io/qameta/allure/junit4/Tag.java
@@ -27,7 +27,9 @@
 import static io.qameta.allure.util.ResultsUtils.TAG_LABEL_NAME;
 
 /**
- * @author jkttt on 05.07.17.
+ * Adds Allure tag metadata to supported test elements.
+ *
+ * <p>Users normally apply {@code @Tag} to test classes or methods; Java creates the container annotation when several tags are declared on the same element.</p>
  */
 @Target({ElementType.TYPE, ElementType.METHOD})
 @Retention(RetentionPolicy.RUNTIME)
@@ -36,6 +38,11 @@
 @LabelAnnotation(name = TAG_LABEL_NAME)
 public @interface Tag {
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     String value();
 
 }
diff --git a/allure-junit4/src/main/java/io/qameta/allure/junit4/Tags.java b/allure-junit4/src/main/java/io/qameta/allure/junit4/Tags.java
index 73e6c779..fbd32078 100644
--- a/allure-junit4/src/main/java/io/qameta/allure/junit4/Tags.java
+++ b/allure-junit4/src/main/java/io/qameta/allure/junit4/Tags.java
@@ -22,13 +22,20 @@
 import java.lang.annotation.Target;
 
 /**
- * @author jkttt on 05.07.17.
+ * Container annotation for repeatable Allure tag annotations.
+ *
+ * <p>Users normally apply {@code @Tag} to test classes or methods; Java creates the container annotation when several tags are declared on the same element.</p>
  */
-@Target({ ElementType.TYPE, ElementType.METHOD })
+@Target({ElementType.TYPE, ElementType.METHOD})
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
 public @interface Tags {
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     Tag[] value();
 
 }
diff --git a/allure-junit4/src/test/java/SampleTestInDefaultPackage.java b/allure-junit4/src/test/java/SampleTestInDefaultPackage.java
index 62c2f6f2..d11f11ba 100644
--- a/allure-junit4/src/test/java/SampleTestInDefaultPackage.java
+++ b/allure-junit4/src/test/java/SampleTestInDefaultPackage.java
@@ -14,10 +14,6 @@
  *  limitations under the License.
  */
 import org.junit.Test;
-
-/**
- * @author jkt on 15.08.17.
- */
 public class SampleTestInDefaultPackage {
 
     @Test
diff --git a/allure-junit4/src/test/java/io/qameta/allure/junit4/AllureJunit4Test.java b/allure-junit4/src/test/java/io/qameta/allure/junit4/AllureJunit4Test.java
index b9835917..7ab71279 100644
--- a/allure-junit4/src/test/java/io/qameta/allure/junit4/AllureJunit4Test.java
+++ b/allure-junit4/src/test/java/io/qameta/allure/junit4/AllureJunit4Test.java
@@ -16,6 +16,7 @@
 package io.qameta.allure.junit4;
 
 import io.qameta.allure.Step;
+import io.qameta.allure.junit4.samples.ActualExpectedStatusDetailsTest;
 import io.qameta.allure.junit4.samples.AssumptionFailedTest;
 import io.qameta.allure.junit4.samples.BrokenTest;
 import io.qameta.allure.junit4.samples.BrokenWithoutMessageTest;
@@ -70,6 +71,11 @@ void shouldSetTestFullName() {
                 .hasSize(1)
                 .extracting(TestResult::getFullName)
                 .containsExactly("io.qameta.allure.junit4.samples.OneTest.simpleTest");
+        assertThat(testResults.get(0).getTitlePath())
+                .containsExactly(
+                        "io", "qameta", "allure", "junit4", "samples",
+                        "Should be overwritten by method annotation"
+                );
     }
 
     @Test
@@ -138,6 +144,26 @@ void shouldProcessFailedTest() {
                 .containsExactly(Status.FAILED);
     }
 
+    @Test
+    @AllureFeatures.FailedTests
+    void shouldReportActualAndExpectedStatusDetails() {
+        final AllureResults results = runClasses(ActualExpectedStatusDetailsTest.class);
+
+        assertThat(results.getTestResults())
+                .filteredOn(
+                        "fullName",
+                        "io.qameta.allure.junit4.samples.ActualExpectedStatusDetailsTest.failingComparison"
+                )
+                .extracting(
+                        TestResult::getStatus,
+                        testResult -> testResult.getStatusDetails().getActual(),
+                        testResult -> testResult.getStatusDetails().getExpected()
+                )
+                .containsExactly(
+                        tuple(Status.FAILED, "actual value", "expected value")
+                );
+    }
+
     @Test
     @AllureFeatures.BrokenTests
     void shouldProcessBrokenTest() {
@@ -350,10 +376,12 @@ void shouldSupportTestsNotBasedOnClasses() {
     void shouldFilterByFullName() {
         final AllureResults results = runClasses(
                 new TestPlanV1_0()
-                        .setTests(Collections.singletonList(
-                                new TestPlanV1_0.TestCase()
-                                        .setSelector("io.qameta.allure.junit4.samples.OneTest.simpleTest")
-                        )),
+                        .setTests(
+                                Collections.singletonList(
+                                        new TestPlanV1_0.TestCase()
+                                                .setSelector("io.qameta.allure.junit4.samples.OneTest.simpleTest")
+                                )
+                        ),
                 OneTest.class, FailedTest.class,
                 TaggedTests.class, BrokenTest.class
         );
@@ -369,11 +397,13 @@ void shouldFilterByFullName() {
     void shouldFilterByAllureId() {
         final AllureResults results = runClasses(
                 new TestPlanV1_0()
-                        .setTests(Collections.singletonList(
-                                new TestPlanV1_0.TestCase()
-                                        .setId("771")
-                                        .setSelector("invalid")
-                        )),
+                        .setTests(
+                                Collections.singletonList(
+                                        new TestPlanV1_0.TestCase()
+                                                .setId("771")
+                                                .setSelector("invalid")
+                                )
+                        ),
                 OneTest.class, FailedTest.class,
                 TaggedTests.class, BrokenTest.class,
                 FilterSimpleTests.class
diff --git a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/ActualExpectedStatusDetailsTest.java b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/ActualExpectedStatusDetailsTest.java
new file mode 100644
index 00000000..a479a440
--- /dev/null
+++ b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/ActualExpectedStatusDetailsTest.java
@@ -0,0 +1,27 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.junit4.samples;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+public class ActualExpectedStatusDetailsTest {
+
+    @Test
+    public void failingComparison() {
+        assertEquals("expected value", "actual value");
+    }
+}
diff --git a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/AssumptionFailedTest.java b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/AssumptionFailedTest.java
index 8ec481ee..fbb86132 100644
--- a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/AssumptionFailedTest.java
+++ b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/AssumptionFailedTest.java
@@ -19,10 +19,6 @@
 
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assume.assumeThat;
-
-/**
- * @author gladnik (Nikolai Gladkov)
- */
 public class AssumptionFailedTest {
 
     @Test
diff --git a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/BrokenTest.java b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/BrokenTest.java
index 33872917..96bdc25f 100644
--- a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/BrokenTest.java
+++ b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/BrokenTest.java
@@ -16,10 +16,6 @@
 package io.qameta.allure.junit4.samples;
 
 import org.junit.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class BrokenTest {
 
     @Test
diff --git a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/BrokenWithoutMessageTest.java b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/BrokenWithoutMessageTest.java
index 3095e3c6..7fdc2750 100644
--- a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/BrokenWithoutMessageTest.java
+++ b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/BrokenWithoutMessageTest.java
@@ -16,10 +16,6 @@
 package io.qameta.allure.junit4.samples;
 
 import org.junit.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class BrokenWithoutMessageTest {
 
     @Test
diff --git a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/DescriptionsJavadoc.java b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/DescriptionsJavadoc.java
index 0fbb5f9c..b9d0cd3d 100644
--- a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/DescriptionsJavadoc.java
+++ b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/DescriptionsJavadoc.java
@@ -17,10 +17,6 @@
 
 import io.qameta.allure.Description;
 import org.junit.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class DescriptionsJavadoc {
 
     /**
diff --git a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/FailedTest.java b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/FailedTest.java
index 28bb566a..79cad4b7 100644
--- a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/FailedTest.java
+++ b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/FailedTest.java
@@ -21,10 +21,6 @@
 import org.junit.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class FailedTest {
 
     @Test
diff --git a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/FilterSimpleTests.java b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/FilterSimpleTests.java
index f97d5e5b..c6b4225b 100644
--- a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/FilterSimpleTests.java
+++ b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/FilterSimpleTests.java
@@ -17,10 +17,6 @@
 
 import io.qameta.allure.AllureId;
 import org.junit.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class FilterSimpleTests {
 
     @Test
diff --git a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/IgnoredClassTest.java b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/IgnoredClassTest.java
index 5baa7b6a..74b0061f 100644
--- a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/IgnoredClassTest.java
+++ b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/IgnoredClassTest.java
@@ -17,10 +17,6 @@
 
 import org.junit.Ignore;
 import org.junit.Test;
-
-/**
- * @author gladnik (Nikolai Gladkov)
- */
 @Ignore
 public class IgnoredClassTest {
 
diff --git a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/IgnoredTests.java b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/IgnoredTests.java
index f6d3474f..c6b9feed 100644
--- a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/IgnoredTests.java
+++ b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/IgnoredTests.java
@@ -17,10 +17,6 @@
 
 import org.junit.Ignore;
 import org.junit.Test;
-
-/**
- * @author gladnik (Nikolai Gladkov)
- */
 public class IgnoredTests {
 
     @Test
diff --git a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/OneTest.java b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/OneTest.java
index 52156e04..41e2c523 100644
--- a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/OneTest.java
+++ b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/OneTest.java
@@ -18,10 +18,6 @@
 import io.qameta.allure.Description;
 import io.qameta.allure.junit4.DisplayName;
 import org.junit.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @DisplayName("Should be overwritten by method annotation")
 public class OneTest {
 
diff --git a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/TaggedTests.java b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/TaggedTests.java
index 6cd462d8..5f60dca3 100644
--- a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/TaggedTests.java
+++ b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/TaggedTests.java
@@ -18,10 +18,6 @@
 import io.qameta.allure.junit4.Tag;
 import io.qameta.allure.junit4.Tags;
 import org.junit.Test;
-
-/**
- * @author jkttt on 05.07.17.
- */
 @Tags({@Tag(TaggedTests.CLASS_TAG1), @Tag(TaggedTests.CLASS_TAG2)})
 public class TaggedTests {
 
@@ -31,7 +27,10 @@ public class TaggedTests {
     public static final String CLASS_TAG2 = "class_tag2";
 
     @Test
-    @Tags({@Tag(METHOD_TAG1),
-            @Tag(METHOD_TAG2)})
-    public void taggedTest() {}
+    @Tags(
+        {@Tag(METHOD_TAG1),
+                @Tag(METHOD_TAG2)}
+    )
+    public void taggedTest() {
+    }
 }
diff --git a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/TestWithAnnotations.java b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/TestWithAnnotations.java
index c0e9aaee..27edcd17 100644
--- a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/TestWithAnnotations.java
+++ b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/TestWithAnnotations.java
@@ -21,10 +21,6 @@
 import io.qameta.allure.Stories;
 import io.qameta.allure.Story;
 import org.junit.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class TestWithAnnotations {
 
     @Test
@@ -35,10 +31,12 @@ public class TestWithAnnotations {
     @Feature("feature2")
     @Feature("feature3")
     @Story("story1")
-    @Stories({
-            @Story("story2"),
-            @Story("story3")
-    })
+    @Stories(
+        {
+                @Story("story2"),
+                @Story("story3")
+        }
+    )
     @Owner("some-owner")
     public void someTest() throws Exception {
     }
diff --git a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/TestWithSteps.java b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/TestWithSteps.java
index 55da4e72..06a2f401 100644
--- a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/TestWithSteps.java
+++ b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/TestWithSteps.java
@@ -17,10 +17,6 @@
 
 import io.qameta.allure.Allure;
 import org.junit.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class TestWithSteps {
 
     @Test
diff --git a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/TheoriesTest.java b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/TheoriesTest.java
index f5a7a378..1ffc380d 100644
--- a/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/TheoriesTest.java
+++ b/allure-junit4/src/test/java/io/qameta/allure/junit4/samples/TheoriesTest.java
@@ -20,10 +20,6 @@
 import org.junit.experimental.theories.Theories;
 import org.junit.experimental.theories.Theory;
 import org.junit.runner.RunWith;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @RunWith(Theories.class)
 public class TheoriesTest {
 
diff --git a/allure-junit4/src/test/resources/allure.properties b/allure-junit4/src/test/resources/allure.properties
index 9c0b0a2d..b68758d1 100644
--- a/allure-junit4/src/test/resources/allure.properties
+++ b/allure-junit4/src/test/resources/allure.properties
@@ -1,2 +1,3 @@
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-junit4
diff --git a/allure-junit5-assert/build.gradle.kts b/allure-junit5-assert/build.gradle.kts
deleted file mode 100644
index dd541015..00000000
--- a/allure-junit5-assert/build.gradle.kts
+++ /dev/null
@@ -1,26 +0,0 @@
-description = "Allure Junit5 Assertions Integration"
-
-dependencies {
-    api(project(":allure-junit5"))
-    compileOnly("org.aspectj:aspectjrt")
-    compileOnly("org.junit.jupiter:junit-jupiter-api")
-    testAnnotationProcessor(project(":allure-descriptions-javadoc"))
-    testImplementation("org.assertj:assertj-core")
-    testImplementation("org.junit.jupiter:junit-jupiter-api")
-    testImplementation("org.slf4j:slf4j-simple")
-    testImplementation(project(":allure-java-commons-test"))
-    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
-}
-
-tasks.jar {
-    manifest {
-        attributes(mapOf(
-                "Automatic-Module-Name" to "io.qameta.allure.junit5-assert"
-        ))
-    }
-}
-
-tasks.test {
-    useJUnitPlatform()
-}
-
diff --git a/allure-junit5/src/main/services/org.junit.jupiter.api.extension.Extension b/allure-junit5/src/main/services/org.junit.jupiter.api.extension.Extension
deleted file mode 100644
index 4a1ec18c..00000000
--- a/allure-junit5/src/main/services/org.junit.jupiter.api.extension.Extension
+++ /dev/null
@@ -1 +0,0 @@
-io.qameta.allure.junit5.AllureJunit5
diff --git a/allure-junit5/src/test/resources/META-INF/services/org.junit.jupiter.api.extension.Extension b/allure-junit5/src/test/resources/META-INF/services/org.junit.jupiter.api.extension.Extension
deleted file mode 100644
index 4a1ec18c..00000000
--- a/allure-junit5/src/test/resources/META-INF/services/org.junit.jupiter.api.extension.Extension
+++ /dev/null
@@ -1 +0,0 @@
-io.qameta.allure.junit5.AllureJunit5
diff --git a/allure-junit5-assert/README.MD b/allure-jupiter-assert/README.MD
similarity index 78%
rename from allure-junit5-assert/README.MD
rename to allure-jupiter-assert/README.MD
index 5124d63c..c468960a 100644
--- a/allure-junit5-assert/README.MD
+++ b/allure-jupiter-assert/README.MD
@@ -1,4 +1,6 @@
-Adding JUnit5-assert may lead to java.lang.OutOfMemoryError: Java heap space
+Adding Jupiter assert may lead to java.lang.OutOfMemoryError: Java heap space
+
+The primary artifact is now `allure-jupiter-assert`. `allure-junit5-assert` remains available as a deprecated relocation coordinate during the transition.
 
 Having a huge class path may lead to OOM, because AspectJ processes all the classes. [Link to documentation](https://www.eclipse.org/aspectj/doc/released/devguide/ltw.html) 
 
diff --git a/allure-jupiter-assert/build.gradle.kts b/allure-jupiter-assert/build.gradle.kts
new file mode 100644
index 00000000..b0c9d6dd
--- /dev/null
+++ b/allure-jupiter-assert/build.gradle.kts
@@ -0,0 +1,44 @@
+description = "Allure Jupiter Assertions Integration"
+
+dependencies {
+    api(project(":allure-jupiter"))
+    compileOnly("org.aspectj:aspectjrt")
+    compileOnly("org.junit.jupiter:junit-jupiter-api")
+    testAnnotationProcessor(project(":allure-descriptions-javadoc"))
+    testImplementation("org.assertj:assertj-core")
+    testImplementation("org.junit.jupiter:junit-jupiter-api")
+    testImplementation("org.slf4j:slf4j-simple")
+    testImplementation(project(":allure-java-commons-test"))
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
+}
+
+tasks.jar {
+    manifest {
+        attributes(mapOf(
+                "Automatic-Module-Name" to "io.qameta.allure.jupiterassert"
+        ))
+    }
+}
+
+tasks.test {
+    useJUnitPlatform()
+}
+
+publishing {
+    publications {
+        create<MavenPublication>("legacyJunit5Assert") {
+            artifactId = "allure-junit5-assert"
+            pom {
+                packaging = "pom"
+                distributionManagement {
+                    relocation {
+                        groupId.set(project.group.toString())
+                        artifactId.set("allure-jupiter-assert")
+                        version.set(project.version.toString())
+                        message.set("allure-junit5-assert has been renamed to allure-jupiter-assert.")
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/allure-jupiter-assert/src/main/java/io/qameta/allure/junit5assert/AllureJunit5Assert.java b/allure-jupiter-assert/src/main/java/io/qameta/allure/junit5assert/AllureJunit5Assert.java
new file mode 100644
index 00000000..d52e2cd4
--- /dev/null
+++ b/allure-jupiter-assert/src/main/java/io/qameta/allure/junit5assert/AllureJunit5Assert.java
@@ -0,0 +1,25 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.junit5assert;
+
+import io.qameta.allure.jupiterassert.AllureJupiterAssert;
+
+/**
+ * @deprecated use {@link AllureJupiterAssert}.
+ */
+@Deprecated
+public class AllureJunit5Assert extends AllureJupiterAssert {
+}
diff --git a/allure-junit5-assert/src/main/java/io/qameta/allure/junit5assert/AllureJunit5Assert.java b/allure-jupiter-assert/src/main/java/io/qameta/allure/jupiterassert/AllureJupiterAssert.java
similarity index 67%
rename from allure-junit5-assert/src/main/java/io/qameta/allure/junit5assert/AllureJunit5Assert.java
rename to allure-jupiter-assert/src/main/java/io/qameta/allure/jupiterassert/AllureJupiterAssert.java
index e7fad008..fbc0ba95 100644
--- a/allure-junit5-assert/src/main/java/io/qameta/allure/junit5assert/AllureJunit5Assert.java
+++ b/allure-jupiter-assert/src/main/java/io/qameta/allure/jupiterassert/AllureJupiterAssert.java
@@ -13,7 +13,7 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
-package io.qameta.allure.junit5assert;
+package io.qameta.allure.jupiterassert;
 
 import io.qameta.allure.Allure;
 import io.qameta.allure.AllureLifecycle;
@@ -37,43 +37,54 @@
 import static io.qameta.allure.util.ResultsUtils.getStatus;
 
 /**
- * @author legionivo (Andrey Konovka).
+ * Integrates JUnit Jupiter assertion with Allure reporting.
+ *
+ * <p>Register this type through the standard JUnit Jupiter assertion extension, listener, interceptor, or plugin mechanism so framework execution events are written to Allure results. Use explicit dependencies when embedding the integration in tests or custom runtimes.</p>
  */
 @SuppressWarnings("all")
 @Aspect
-public class AllureJunit5Assert {
+public class AllureJupiterAssert {
 
-    private static final Logger LOGGER = LoggerFactory.getLogger(AllureJunit5Assert.class);
+    private static final Logger LOGGER = LoggerFactory.getLogger(AllureJupiterAssert.class);
     private StepResult stepResult;
 
-
-    private static InheritableThreadLocal<AllureLifecycle> lifecycle = new InheritableThreadLocal<AllureLifecycle>() {
+    private static final InheritableThreadLocal<AllureLifecycle> LIFECYCLE = new InheritableThreadLocal<AllureLifecycle>() {
         @Override
         protected AllureLifecycle initialValue() {
             return Allure.getLifecycle();
         }
     };
 
+    /**
+     * Handles the any assert callback.
+     */
     @Pointcut("call(void org.junit.jupiter.api.Assertions.*(..)) || throwable()")
     public void anyAssert() {
 
     }
 
+    /**
+     * Handles the throwable callback.
+     */
     @Pointcut("call(Throwable org.junit.jupiter.api.Assertions.*(..))")
     public void throwable() {
 
     }
 
+    /**
+     * Handles the step start callback.
+     *
+     * @param joinPoint the join point
+     */
     @Before("anyAssert()")
     public void stepStart(final JoinPoint joinPoint) {
         if (joinPoint.getArgs().length > 1) {
             final String uuid = UUID.randomUUID().toString();
             final String assertName = joinPoint.getSignature().getName();
-            String name;
+            final String name;
             if (joinPoint.getSignature().getName().equalsIgnoreCase("assertAll")) {
-                name = String.format("assert All in " + " \'%s\'", joinPoint.getArgs()[0].toString());
+                name = String.format("assert All in " + " '%s'", joinPoint.getArgs()[0].toString());
             } else {
-
                 final String actual = joinPoint.getArgs().length > 0
                         ? ObjectUtils.toString(joinPoint.getArgs()[1])
                         : "<?>";
@@ -83,12 +94,16 @@ public void stepStart(final JoinPoint joinPoint) {
 
                 final List<String> assertArray = Arrays.asList(assertName.split("(?=[A-Z])"));
                 if (assertArray.size() >= 3) {
-                    name = String.format(assertArray.get(0) + " " + assertArray.get(1) + " \'%s\'", expected)
-                            + " " + String.format(assertArray.stream()
-                            .skip(2)
-                            .collect(Collectors.joining(" ")) + " \'%s\'", actual);
+                    name = String.format(assertArray.get(0) + " " + assertArray.get(1) + " '%s'", expected)
+                            + " " + String.format(
+                                    assertArray.stream()
+                                            .skip(2)
+                                            .collect(Collectors.joining(" ")) + " '%s'",
+                                    actual
+                            );
                 } else {
-                    name = String.format(assertArray.get(0) + " \'%s\'", expected) + " " + String.format(assertArray.get(1) + " \'%s\'", actual);
+                    name = String.format(assertArray.get(0) + " '%s'", expected)
+                            + " " + String.format(assertArray.get(1) + " '%s'", actual);
                 }
             }
             final StepResult result = new StepResult()
@@ -101,7 +116,7 @@ public void stepStart(final JoinPoint joinPoint) {
                     : "<?>";
             final String uuid = UUID.randomUUID().toString();
             final String assertName = joinPoint.getSignature().getName();
-            final String name = String.format(assertName + " \'%s\'", actual);
+            final String name = String.format(assertName + " '%s'", actual);
 
             final StepResult result = new StepResult()
                     .setName(name)
@@ -110,13 +125,27 @@ public void stepStart(final JoinPoint joinPoint) {
         }
     }
 
-    @AfterThrowing(pointcut = "anyAssert()", throwing = "e")
+    @AfterThrowing(
+            pointcut = "anyAssert()",
+            throwing = "e"
+    )
+
+    /**
+     * Handles the step failed callback.
+     *
+     * @param e the e
+     */
     public void stepFailed(final Throwable e) {
-        getLifecycle().updateStep(s -> s
-                .setStatus(getStatus(e).orElse(Status.BROKEN)));
+        getLifecycle().updateStep(
+                s -> s
+                        .setStatus(getStatus(e).orElse(Status.BROKEN))
+        );
         getLifecycle().stopStep();
     }
 
+    /**
+     * Handles the step stop callback.
+     */
     @AfterReturning(pointcut = "anyAssert()")
     public void stepStop() {
         getLifecycle().updateStep(s -> s.setStatus(Status.PASSED));
@@ -129,11 +158,15 @@ public void stepStop() {
      * @param allure allure lifecycle to set.
      */
     public static void setLifecycle(final AllureLifecycle allure) {
-        lifecycle.set(allure);
+        LIFECYCLE.set(allure);
     }
 
+    /**
+     * Returns the lifecycle.
+     *
+     * @return the Allure lifecycle used by this integration
+     */
     public static AllureLifecycle getLifecycle() {
-        return lifecycle.get();
+        return LIFECYCLE.get();
     }
-
 }
diff --git a/allure-junit5-assert/src/main/resources/META-INF/aop-ajc.xml b/allure-jupiter-assert/src/main/resources/META-INF/aop-ajc.xml
similarity index 56%
rename from allure-junit5-assert/src/main/resources/META-INF/aop-ajc.xml
rename to allure-jupiter-assert/src/main/resources/META-INF/aop-ajc.xml
index 1ce84d6d..f4a03961 100644
--- a/allure-junit5-assert/src/main/resources/META-INF/aop-ajc.xml
+++ b/allure-jupiter-assert/src/main/resources/META-INF/aop-ajc.xml
@@ -1,6 +1,6 @@
 <aspectj>
     <weaver options="-warn:none -Xlint:ignore"/>
     <aspects>
-        <aspect name="io.qameta.allure.junit5assert.AllureJunit5Assert"/>
+        <aspect name="io.qameta.allure.jupiterassert.AllureJupiterAssert"/>
     </aspects>
 </aspectj>
diff --git a/allure-junit5-assert/src/test/java/io/qameta/allure/junit5assert/AllureJunit5AssertTest.java b/allure-jupiter-assert/src/test/java/io/qameta/allure/junit5assert/AllureJunit5AssertTest.java
similarity index 64%
rename from allure-junit5-assert/src/test/java/io/qameta/allure/junit5assert/AllureJunit5AssertTest.java
rename to allure-jupiter-assert/src/test/java/io/qameta/allure/junit5assert/AllureJunit5AssertTest.java
index d8ad7b7b..8a113f8a 100644
--- a/allure-junit5-assert/src/test/java/io/qameta/allure/junit5assert/AllureJunit5AssertTest.java
+++ b/allure-jupiter-assert/src/test/java/io/qameta/allure/junit5assert/AllureJunit5AssertTest.java
@@ -29,10 +29,6 @@
 import static io.qameta.allure.test.RunUtils.runWithinTestContext;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * @author legionivo (Andrey Konovka).
- */
 @TestInstance(TestInstance.Lifecycle.PER_METHOD)
 class AllureJunit5AssertTest {
 
@@ -45,16 +41,21 @@ void shouldHandleAssertAll() {
         person.setFirstName(FIRST_NAME);
         person.setLastName(LAST_NAME);
 
-        final AllureResults results = runWithinTestContext(() -> assertAll("name",
-                () -> assertEquals(FIRST_NAME,
-                        person.getFirstName(),
-                        "The first name is incorrect"
-                ),
-                () -> assertEquals(LAST_NAME,
-                        person.getLastName(),
-                        "The last name is incorrect"
-                )
-        ), AllureJunit5Assert::setLifecycle);
+        final AllureResults results = runWithinTestContext(
+                () -> assertAll(
+                        "name",
+                        () -> assertEquals(
+                                FIRST_NAME,
+                                person.getFirstName(),
+                                "The first name is incorrect"
+                        ),
+                        () -> assertEquals(
+                                LAST_NAME,
+                                person.getLastName(),
+                                "The last name is incorrect"
+                        )
+                ), AllureJunit5Assert::setLifecycle
+        );
 
         final TestResult testResult = results.getTestResults().get(0);
 
@@ -62,17 +63,21 @@ void shouldHandleAssertAll() {
                 .flatExtracting(StepResult::getName)
                 .containsExactly("assert All in  'name'");
 
-        List<StepResult> childSteps = Objects.requireNonNull(testResult
-                .getSteps()
-                .stream()
-                .findFirst()
-                .orElse(null))
+        List<StepResult> childSteps = Objects.requireNonNull(
+                testResult
+                        .getSteps()
+                        .stream()
+                        .findFirst()
+                        .orElse(null)
+        )
                 .getSteps();
 
         assertThat(childSteps)
                 .flatExtracting(StepResult::getName)
-                .containsExactly("assert 'Jane' Equals 'Jane'",
-                        "assert 'Doe' Equals 'Doe'");
+                .containsExactly(
+                        "assert 'Jane' Equals 'Jane'",
+                        "assert 'Doe' Equals 'Doe'"
+                );
 
     }
 
@@ -85,16 +90,21 @@ void shouldHandleAssertAllFailure() {
         person.setFirstName(FIRST_NAME);
         person.setLastName("LAST_NAME");
 
-        final AllureResults results = runWithinTestContext(() -> assertAll("name",
-                () -> assertEquals(FIRST_NAME,
-                        person.getFirstName(),
-                        "The first name is incorrect"
-                ),
-                () -> assertEquals(LAST_NAME,
-                        person.getLastName(),
-                        "The last name is incorrect"
-                )
-        ), AllureJunit5Assert::setLifecycle);
+        final AllureResults results = runWithinTestContext(
+                () -> assertAll(
+                        "name",
+                        () -> assertEquals(
+                                FIRST_NAME,
+                                person.getFirstName(),
+                                "The first name is incorrect"
+                        ),
+                        () -> assertEquals(
+                                LAST_NAME,
+                                person.getLastName(),
+                                "The last name is incorrect"
+                        )
+                ), AllureJunit5Assert::setLifecycle
+        );
 
         final TestResult testResult = results.getTestResults().get(0);
 
@@ -105,14 +115,18 @@ void shouldHandleAssertAllFailure() {
         List<StepResult> childSteps = Objects.requireNonNull(testResult.getSteps().stream().findFirst().orElse(null)).getSteps();
         assertThat(childSteps)
                 .flatExtracting(StepResult::getName, StepResult::getStatus)
-                .containsExactly("assert 'Jane' Equals 'Jane'", Status.PASSED,
-                        "assert 'Doe' Equals 'LAST_NAME'", Status.FAILED);
+                .containsExactly(
+                        "assert 'Jane' Equals 'Jane'", Status.PASSED,
+                        "assert 'Doe' Equals 'LAST_NAME'", Status.FAILED
+                );
     }
 
     @Test
     void shouldHandleAssertEquals() {
-        final AllureResults results = runWithinTestContext(() -> assertEquals("expectedString", "actualString"),
-                AllureJunit5Assert::setLifecycle);
+        final AllureResults results = runWithinTestContext(
+                () -> assertEquals("expectedString", "actualString"),
+                AllureJunit5Assert::setLifecycle
+        );
         assertThat(results.getTestResults())
                 .flatExtracting(TestResult::getSteps)
                 .extracting(StepResult::getName)
@@ -123,8 +137,10 @@ void shouldHandleAssertEquals() {
     void shouldHandleAssertArrayEquals() {
         final int[] ACTUAL = new int[]{2, 5, 7};
         final int[] EXPECTED = new int[]{2, 5, 7};
-        final AllureResults results = runWithinTestContext(() -> assertArrayEquals(EXPECTED, ACTUAL),
-                AllureJunit5Assert::setLifecycle);
+        final AllureResults results = runWithinTestContext(
+                () -> assertArrayEquals(EXPECTED, ACTUAL),
+                AllureJunit5Assert::setLifecycle
+        );
         assertThat(results.getTestResults())
                 .flatExtracting(TestResult::getSteps)
                 .extracting(StepResult::getName)
@@ -133,8 +149,10 @@ void shouldHandleAssertArrayEquals() {
 
     @Test
     void shouldHandleAssertTrue() {
-        final AllureResults results = runWithinTestContext(() -> assertTrue(true),
-                AllureJunit5Assert::setLifecycle);
+        final AllureResults results = runWithinTestContext(
+                () -> assertTrue(true),
+                AllureJunit5Assert::setLifecycle
+        );
         assertThat(results.getTestResults())
                 .flatExtracting(TestResult::getSteps)
                 .extracting(StepResult::getName)
@@ -145,20 +163,23 @@ void shouldHandleAssertTrue() {
     void shouldHandleAssertIterableEquals() {
         final List<Integer> FIRST = Arrays.asList(1, 2, 3);
         final List<Integer> SECOND = Arrays.asList(1, 2, 3);
-        final AllureResults results = runWithinTestContext(() -> assertIterableEquals(FIRST, SECOND),
-                AllureJunit5Assert::setLifecycle);
+        final AllureResults results = runWithinTestContext(
+                () -> assertIterableEquals(FIRST, SECOND),
+                AllureJunit5Assert::setLifecycle
+        );
         assertThat(results.getTestResults())
                 .flatExtracting(TestResult::getSteps)
                 .extracting(StepResult::getName)
                 .containsExactly("assert Iterable '[1, 2, 3]' Equals '[1, 2, 3]'");
     }
 
-
     @Test
     void shouldHandleAssertNotNull() {
         String argument = "someArgument";
-        final AllureResults results = runWithinTestContext(() -> assertNotNull(argument),
-                AllureJunit5Assert::setLifecycle);
+        final AllureResults results = runWithinTestContext(
+                () -> assertNotNull(argument),
+                AllureJunit5Assert::setLifecycle
+        );
         assertThat(results.getTestResults())
                 .flatExtracting(TestResult::getSteps)
                 .extracting(StepResult::getName)
@@ -167,8 +188,10 @@ void shouldHandleAssertNotNull() {
 
     @Test
     void shouldHandleAssertNull() {
-        final AllureResults results = runWithinTestContext(() -> assertNull(null),
-                AllureJunit5Assert::setLifecycle);
+        final AllureResults results = runWithinTestContext(
+                () -> assertNull(null),
+                AllureJunit5Assert::setLifecycle
+        );
         assertThat(results.getTestResults())
                 .flatExtracting(TestResult::getSteps)
                 .extracting(StepResult::getName)
@@ -179,8 +202,10 @@ void shouldHandleAssertNull() {
     void shouldHandleAssertLinesMatch() {
         List<String> expected = Arrays.asList("Java", "\\d+", "JUnit");
         List<String> actual = Arrays.asList("Java", "11", "JUnit");
-        final AllureResults results = runWithinTestContext(() -> assertLinesMatch(expected, actual),
-                AllureJunit5Assert::setLifecycle);
+        final AllureResults results = runWithinTestContext(
+                () -> assertLinesMatch(expected, actual),
+                AllureJunit5Assert::setLifecycle
+        );
         assertThat(results.getTestResults())
                 .flatExtracting(TestResult::getSteps)
                 .extracting(StepResult::getName)
@@ -189,8 +214,10 @@ void shouldHandleAssertLinesMatch() {
 
     @Test
     void shouldHandleAssertNotEquals() {
-        final AllureResults results = runWithinTestContext(() -> assertNotEquals(13, 0),
-                AllureJunit5Assert::setLifecycle);
+        final AllureResults results = runWithinTestContext(
+                () -> assertNotEquals(13, 0),
+                AllureJunit5Assert::setLifecycle
+        );
         assertThat(results.getTestResults())
                 .flatExtracting(TestResult::getSteps)
                 .extracting(StepResult::getName)
@@ -201,8 +228,10 @@ void shouldHandleAssertNotEquals() {
     void shouldHandleAssertNotSame() {
         final List<Integer> FIRST = Arrays.asList(1, 2, 3);
         final List<Integer> SECOND = Arrays.asList(1, 2, 5);
-        final AllureResults results = runWithinTestContext(() -> assertNotSame(FIRST, SECOND),
-                AllureJunit5Assert::setLifecycle);
+        final AllureResults results = runWithinTestContext(
+                () -> assertNotSame(FIRST, SECOND),
+                AllureJunit5Assert::setLifecycle
+        );
         assertThat(results.getTestResults())
                 .flatExtracting(TestResult::getSteps)
                 .extracting(StepResult::getName)
diff --git a/allure-jupiter-assert/src/test/java/io/qameta/allure/jupiterassert/AllureJupiterAssertTest.java b/allure-jupiter-assert/src/test/java/io/qameta/allure/jupiterassert/AllureJupiterAssertTest.java
new file mode 100644
index 00000000..1da892a9
--- /dev/null
+++ b/allure-jupiter-assert/src/test/java/io/qameta/allure/jupiterassert/AllureJupiterAssertTest.java
@@ -0,0 +1,41 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.jupiterassert;
+
+import io.qameta.allure.model.StepResult;
+import io.qameta.allure.model.TestResult;
+import io.qameta.allure.test.AllureResults;
+import org.junit.jupiter.api.Test;
+
+import static io.qameta.allure.test.RunUtils.runWithinTestContext;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class AllureJupiterAssertTest {
+
+    @Test
+    void shouldHandleAssertEquals() {
+        final AllureResults results = runWithinTestContext(
+                () -> assertEquals("expectedString", "actualString"),
+                AllureJupiterAssert::setLifecycle
+        );
+
+        assertThat(results.getTestResults())
+                .flatExtracting(TestResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly("assert 'expectedString' Equals 'actualString'");
+    }
+}
diff --git a/allure-jupiter-assert/src/test/resources/allure.properties b/allure-jupiter-assert/src/test/resources/allure.properties
new file mode 100644
index 00000000..2f82d5fa
--- /dev/null
+++ b/allure-jupiter-assert/src/test/resources/allure.properties
@@ -0,0 +1,3 @@
+allure.results.directory=build/allure-results
+allure.label.epic=#project.description#
+allure.label.module=allure-jupiter-assert
diff --git a/allure-junit5/build.gradle.kts b/allure-jupiter/build.gradle.kts
similarity index 66%
rename from allure-junit5/build.gradle.kts
rename to allure-jupiter/build.gradle.kts
index 37288580..5d66deaf 100644
--- a/allure-junit5/build.gradle.kts
+++ b/allure-jupiter/build.gradle.kts
@@ -1,4 +1,4 @@
-description = "Allure JUnit 5 Integration"
+description = "Allure Jupiter Integration"
 
 dependencies {
     api(project(":allure-junit-platform"))
@@ -19,7 +19,7 @@ dependencies {
 tasks.jar {
     manifest {
         attributes(mapOf(
-                "Automatic-Module-Name" to "io.qameta.allure.junit5"
+                "Automatic-Module-Name" to "io.qameta.allure.jupiter"
         ))
     }
     from("src/main/services") {
@@ -43,6 +43,19 @@ publishing {
         named<MavenPublication>("maven") {
             artifact(spiOffJar)
         }
+        create<MavenPublication>("legacyJunit5") {
+            artifactId = "allure-junit5"
+            pom {
+                packaging = "pom"
+                distributionManagement {
+                    relocation {
+                        groupId.set(project.group.toString())
+                        artifactId.set("allure-jupiter")
+                        version.set(project.version.toString())
+                        message.set("allure-junit5 has been renamed to allure-jupiter.")
+                    }
+                }
+            }
+        }
     }
 }
-
diff --git a/allure-jupiter/src/main/java/io/qameta/allure/junit5/AllureJunit5.java b/allure-jupiter/src/main/java/io/qameta/allure/junit5/AllureJunit5.java
new file mode 100644
index 00000000..8a570bac
--- /dev/null
+++ b/allure-jupiter/src/main/java/io/qameta/allure/junit5/AllureJunit5.java
@@ -0,0 +1,25 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.junit5;
+
+import io.qameta.allure.jupiter.AllureJupiter;
+
+/**
+ * @deprecated use {@link AllureJupiter}.
+ */
+@Deprecated
+public class AllureJunit5 extends AllureJupiter {
+}
diff --git a/allure-junit5/src/main/java/io/qameta/allure/junit5/AllureJunit5.java b/allure-jupiter/src/main/java/io/qameta/allure/jupiter/AllureJupiter.java
similarity index 57%
rename from allure-junit5/src/main/java/io/qameta/allure/junit5/AllureJunit5.java
rename to allure-jupiter/src/main/java/io/qameta/allure/jupiter/AllureJupiter.java
index 3d1019a2..c3823562 100644
--- a/allure-junit5/src/main/java/io/qameta/allure/junit5/AllureJunit5.java
+++ b/allure-jupiter/src/main/java/io/qameta/allure/jupiter/AllureJupiter.java
@@ -13,7 +13,7 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
-package io.qameta.allure.junit5;
+package io.qameta.allure.jupiter;
 
 import io.qameta.allure.Param;
 import io.qameta.allure.model.Status;
@@ -27,8 +27,8 @@
 import java.lang.reflect.Method;
 import java.lang.reflect.Parameter;
 import java.util.HashMap;
-import java.util.Map;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.UUID;
@@ -47,19 +47,32 @@
 import static io.qameta.allure.junitplatform.AllureJunitPlatform.TEAR_DOWN;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Reports JUnit Jupiter fixture execution details to Allure.
+ *
+ * <p>Register this extension when Jupiter lifecycle methods should appear as Allure fixtures with start, stop, and failure metadata. The extension is also the compatibility base used by the legacy {@code allure-junit5} module.</p>
  */
 @SuppressWarnings("MultipleStringLiterals")
-public class AllureJunit5 implements InvocationInterceptor {
+public class AllureJupiter implements InvocationInterceptor {
+
+    private static final ExtensionContext.Namespace NAMESPACE = ExtensionContext.Namespace.create(AllureJupiter.class);
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void interceptTestTemplateMethod(final Invocation<Void> invocation,
                                             final ReflectiveInvocationContext<Method> invocationContext,
-                                            final ExtensionContext extensionContext) throws Throwable {
+                                            final ExtensionContext extensionContext)
+            throws Throwable {
+        if (!shouldHandle(extensionContext, "template", invocationContext.getExecutable())) {
+            invocation.proceed();
+            return;
+        }
         sendParameterEvent(invocationContext, extensionContext);
         invocation.proceed();
     }
 
+    @SuppressWarnings("PMD.AvoidInstantiatingObjectsInLoops")
     private void sendParameterEvent(final ReflectiveInvocationContext<Method> invocationContext,
                                     final ExtensionContext extensionContext) {
         final Parameter[] parameters = invocationContext.getExecutable().getParameters();
@@ -98,64 +111,114 @@ private void sendParameterEvent(final ReflectiveInvocationContext<Method> invoca
         }
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void interceptBeforeAllMethod(
-            final Invocation<Void> invocation,
-            final ReflectiveInvocationContext<Method> invocationContext,
-            final ExtensionContext extensionContext) throws Throwable {
+                                         final Invocation<Void> invocation,
+                                         final ReflectiveInvocationContext<Method> invocationContext,
+                                         final ExtensionContext extensionContext)
+            throws Throwable {
         processFixture(PREPARE, invocation, invocationContext, extensionContext);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void interceptAfterAllMethod(
-            final Invocation<Void> invocation,
-            final ReflectiveInvocationContext<Method> invocationContext,
-            final ExtensionContext extensionContext) throws Throwable {
+                                        final Invocation<Void> invocation,
+                                        final ReflectiveInvocationContext<Method> invocationContext,
+                                        final ExtensionContext extensionContext)
+            throws Throwable {
         processFixture(TEAR_DOWN, invocation, invocationContext, extensionContext);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void interceptBeforeEachMethod(
-            final Invocation<Void> invocation,
-            final ReflectiveInvocationContext<Method> invocationContext,
-            final ExtensionContext extensionContext) throws Throwable {
+                                          final Invocation<Void> invocation,
+                                          final ReflectiveInvocationContext<Method> invocationContext,
+                                          final ExtensionContext extensionContext)
+            throws Throwable {
         processFixture(PREPARE, invocation, invocationContext, extensionContext);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void interceptAfterEachMethod(
-            final Invocation<Void> invocation,
-            final ReflectiveInvocationContext<Method> invocationContext,
-            final ExtensionContext extensionContext) throws Throwable {
+                                         final Invocation<Void> invocation,
+                                         final ReflectiveInvocationContext<Method> invocationContext,
+                                         final ExtensionContext extensionContext)
+            throws Throwable {
         processFixture(TEAR_DOWN, invocation, invocationContext, extensionContext);
     }
 
+    /**
+     * Handles the process fixture callback.
+     *
+     * @param type the event or label type
+     * @param invocation the invocation
+     * @param invocationContext the invocation context
+     * @param extensionContext the extension context
+     * @throws Throwable if the underlying framework operation fails
+     */
     protected void processFixture(final String type,
                                   final Invocation<Void> invocation,
                                   final ReflectiveInvocationContext<Method> invocationContext,
-                                  final ExtensionContext extensionContext) throws Throwable {
+                                  final ExtensionContext extensionContext)
+            throws Throwable {
+        if (!shouldHandle(extensionContext, type, invocationContext.getExecutable())) {
+            invocation.proceed();
+            return;
+        }
         final String uuid = UUID.randomUUID().toString();
         try {
-            extensionContext.publishReportEntry(wrap(buildStartEvent(
-                    type,
-                    uuid,
-                    invocationContext.getExecutable()
-            )));
+            extensionContext.publishReportEntry(
+                    wrap(
+                            buildStartEvent(
+                                    type,
+                                    uuid,
+                                    invocationContext.getExecutable()
+                            )
+                    )
+            );
             invocation.proceed();
-            extensionContext.publishReportEntry(wrap(buildStopEvent(
-                    type,
-                    uuid
-            )));
+            extensionContext.publishReportEntry(
+                    wrap(
+                            buildStopEvent(
+                                    type,
+                                    uuid
+                            )
+                    )
+            );
         } catch (Throwable throwable) {
-            extensionContext.publishReportEntry(wrap(buildFailureEvent(
-                    type,
-                    uuid,
-                    throwable
-            )));
+            extensionContext.publishReportEntry(
+                    wrap(
+                            buildFailureEvent(
+                                    type,
+                                    uuid,
+                                    throwable
+                            )
+                    )
+            );
             throw throwable;
         }
     }
 
+    /**
+     * Builds and returns the start event.
+     *
+     * @param type the event or label type
+     * @param uuid the Allure UUID of the model object
+     * @param method the framework or Java method to inspect
+     * @return the start event
+     */
     public Map<String, String> buildStartEvent(final String type,
                                                final String uuid,
                                                final Method method) {
@@ -167,6 +230,13 @@ public Map<String, String> buildStartEvent(final String type,
         return map;
     }
 
+    /**
+     * Builds and returns the stop event.
+     *
+     * @param type the event or label type
+     * @param uuid the Allure UUID of the model object
+     * @return the stop event
+     */
     public Map<String, String> buildStopEvent(final String type,
                                               final String uuid) {
         final Map<String, String> map = new HashMap<>();
@@ -176,6 +246,14 @@ public Map<String, String> buildStopEvent(final String type,
         return map;
     }
 
+    /**
+     * Builds and returns the failure event.
+     *
+     * @param type the event or label type
+     * @param uuid the Allure UUID of the model object
+     * @param throwable the throwable
+     * @return the failure event
+     */
     public Map<String, String> buildFailureEvent(final String type,
                                                  final String uuid,
                                                  final Throwable throwable) {
@@ -190,20 +268,44 @@ public Map<String, String> buildFailureEvent(final String type,
         final Optional<StatusDetails> maybeDetails = ResultsUtils.getStatusDetails(throwable);
         maybeDetails.map(StatusDetails::getMessage).ifPresent(message -> map.put("message", message));
         maybeDetails.map(StatusDetails::getTrace).ifPresent(trace -> map.put("trace", trace));
+        maybeDetails.map(StatusDetails::getActual).ifPresent(actual -> map.put("actual", actual));
+        maybeDetails.map(StatusDetails::getExpected).ifPresent(expected -> map.put("expected", expected));
         return map;
     }
 
+    /**
+     * Returns the wrap.
+     *
+     * @param data the data map to wrap or process
+     * @return the wrap
+     */
     @SuppressWarnings("PMD.InefficientEmptyStringCheck")
     public Map<String, String> wrap(final Map<String, String> data) {
         final Map<String, String> res = new HashMap<>();
         data.forEach((key, value) -> {
-                    if (Objects.isNull(value) || value.trim().isEmpty()) {
-                        res.put(key, ALLURE_REPORT_ENTRY_BLANK_PREFIX + value);
-                    } else {
-                        res.put(key, value);
-                    }
-                }
+            if (Objects.isNull(value) || value.trim().isEmpty()) {
+                res.put(key, ALLURE_REPORT_ENTRY_BLANK_PREFIX + value);
+            } else {
+                res.put(key, value);
+            }
+        }
         );
         return res;
     }
+
+    private boolean shouldHandle(final ExtensionContext extensionContext,
+                                 final String eventType,
+                                 final Method method) {
+        final Object marker = new Object();
+        final String key = String.join(
+                ":",
+                extensionContext.getUniqueId(),
+                eventType,
+                method.toGenericString()
+        );
+        final Object storedMarker = extensionContext.getRoot()
+                .getStore(NAMESPACE)
+                .getOrComputeIfAbsent(key, ignored -> marker);
+        return marker.equals(storedMarker);
+    }
 }
diff --git a/allure-jupiter/src/main/services/org.junit.jupiter.api.extension.Extension b/allure-jupiter/src/main/services/org.junit.jupiter.api.extension.Extension
new file mode 100644
index 00000000..17a07514
--- /dev/null
+++ b/allure-jupiter/src/main/services/org.junit.jupiter.api.extension.Extension
@@ -0,0 +1 @@
+io.qameta.allure.jupiter.AllureJupiter
diff --git a/allure-junit5/src/test/java/io/qameta/allure/junit5/AllureJunit5Junit6CompatibilityTest.java b/allure-jupiter/src/test/java/io/qameta/allure/junit5/AllureJunit5Junit6CompatibilityTest.java
similarity index 64%
rename from allure-junit5/src/test/java/io/qameta/allure/junit5/AllureJunit5Junit6CompatibilityTest.java
rename to allure-jupiter/src/test/java/io/qameta/allure/junit5/AllureJunit5Junit6CompatibilityTest.java
index a9d85cc2..f85e4294 100644
--- a/allure-junit5/src/test/java/io/qameta/allure/junit5/AllureJunit5Junit6CompatibilityTest.java
+++ b/allure-jupiter/src/test/java/io/qameta/allure/junit5/AllureJunit5Junit6CompatibilityTest.java
@@ -86,16 +86,21 @@ void shouldCaptureParametersWithParamAnnotationOnJunit6() {
         assertThat(results.getTestResults()).isNotEmpty();
 
         List<Parameter> allParams = results.getTestResults().stream()
-            .flatMap(tr -> tr.getParameters().stream())
-            .toList();
+                .flatMap(tr -> tr.getParameters().stream())
+                .toList();
 
         assertThat(allParams)
-            .isNotEmpty()
-            .extracting(Parameter::getName, Parameter::getValue)
-            .contains(
-                tuple("id", "a"),
-                tuple("id", "b")
-            );
+                .filteredOn(parameter -> "id".equals(parameter.getName()))
+                .extracting(Parameter::getName, Parameter::getValue)
+                .containsExactlyInAnyOrder(
+                        tuple("id", "a"),
+                        tuple("id", "b")
+                );
+
+        assertThat(allParams)
+                .filteredOn(parameter -> "id".equals(parameter.getName()))
+                .extracting(Parameter::getName, Parameter::getValue)
+                .doesNotHaveDuplicates();
     }
 
     @Test
@@ -106,53 +111,57 @@ void shouldCaptureFixturesAndStepsOnJunit6() {
         TestResult testResult = results.getTestResults().get(0);
 
         assertThat(results.getTestResultContainers())
-            .flatExtracting(TestResultContainer::getChildren)
-            .contains(testResult.getUuid());
+                .flatExtracting(TestResultContainer::getChildren)
+                .contains(testResult.getUuid());
 
         assertThat(results.getTestResultContainers())
-            .flatExtracting(TestResultContainer::getBefores)
-            .extracting(FixtureResult::getStatus)
-            .contains(Status.PASSED);
+                .flatExtracting(TestResultContainer::getBefores)
+                .extracting(FixtureResult::getName, FixtureResult::getStatus)
+                .containsExactly(
+                        tuple("setUp", Status.PASSED)
+                );
 
         assertThat(results.getTestResultContainers())
-            .flatExtracting(TestResultContainer::getAfters)
-            .extracting(FixtureResult::getStatus)
-            .contains(Status.PASSED);
+                .flatExtracting(TestResultContainer::getAfters)
+                .extracting(FixtureResult::getName, FixtureResult::getStatus)
+                .containsExactly(
+                        tuple("tearDown", Status.PASSED)
+                );
 
         assertThat(results.getTestResultContainers())
-            .flatExtracting(TestResultContainer::getBefores)
-            .flatExtracting(FixtureResult::getSteps)
-            .extracting(StepResult::getName)
-            .contains("before step");
+                .flatExtracting(TestResultContainer::getBefores)
+                .flatExtracting(FixtureResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly("before step");
 
         assertThat(results.getTestResults())
-            .flatExtracting(TestResult::getSteps)
-            .extracting(StepResult::getName)
-            .contains("test step");
+                .flatExtracting(TestResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly("test step");
 
         assertThat(results.getTestResultContainers())
-            .flatExtracting(TestResultContainer::getAfters)
-            .flatExtracting(FixtureResult::getSteps)
-            .extracting(StepResult::getName)
-            .contains("after step");
+                .flatExtracting(TestResultContainer::getAfters)
+                .flatExtracting(FixtureResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly("after step");
     }
 
     @io.qameta.allure.Step("Run classes {classes}")
     private AllureResults runWithLauncher(Class<?>... classes) {
         return RunUtils.runTests(lifecycle -> {
             ClassSelector[] selectors = Stream.of(classes)
-                .map(DiscoverySelectors::selectClass)
-                .toArray(ClassSelector[]::new);
+                    .map(DiscoverySelectors::selectClass)
+                    .toArray(ClassSelector[]::new);
 
             LauncherDiscoveryRequest request = LauncherDiscoveryRequestBuilder.request()
-                .configurationParameter("junit.jupiter.extensions.autodetection.enabled", "true")
-                .selectors(selectors)
-                .build();
+                    .configurationParameter("junit.jupiter.extensions.autodetection.enabled", "true")
+                    .selectors(selectors)
+                    .build();
 
             LauncherConfig config = LauncherConfig.builder()
-                .enableTestExecutionListenerAutoRegistration(false)
-                .addTestExecutionListeners(new AllureJunitPlatform(lifecycle))
-                .build();
+                    .enableTestExecutionListenerAutoRegistration(false)
+                    .addTestExecutionListeners(new AllureJunitPlatform(lifecycle))
+                    .build();
 
             Launcher launcher = LauncherFactory.create(config);
             launcher.execute(request);
diff --git a/allure-junit5/src/test/java/io/qameta/allure/junit5/AllureJunit5Test.java b/allure-jupiter/src/test/java/io/qameta/allure/junit5/AllureJunit5Test.java
similarity index 96%
rename from allure-junit5/src/test/java/io/qameta/allure/junit5/AllureJunit5Test.java
rename to allure-jupiter/src/test/java/io/qameta/allure/junit5/AllureJunit5Test.java
index 66d102e2..c8808cc6 100644
--- a/allure-junit5/src/test/java/io/qameta/allure/junit5/AllureJunit5Test.java
+++ b/allure-jupiter/src/test/java/io/qameta/allure/junit5/AllureJunit5Test.java
@@ -17,6 +17,7 @@
 
 import io.qameta.allure.Issue;
 import io.qameta.allure.Step;
+import io.qameta.allure.junit5.features.ActualExpectedStatusDetailsTests;
 import io.qameta.allure.junit5.features.AfterEachFixtureBrokenSupport;
 import io.qameta.allure.junit5.features.AllFixtureSupport;
 import io.qameta.allure.junit5.features.BeforeAllFixtureFailureSupport;
@@ -50,10 +51,6 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.tuple;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @AllureFeatures.Fixtures
 class AllureJunit5Test {
 
@@ -148,6 +145,22 @@ void shouldSupportParamAnnotationForParameters() {
 
     }
 
+    @Test
+    void shouldReportActualAndExpectedStatusDetails() {
+        final AllureResults results = runClasses(ActualExpectedStatusDetailsTests.class);
+        final TestResult testResult = results.getTestResults().stream()
+                .filter(
+                        result -> "io.qameta.allure.junit5.features.ActualExpectedStatusDetailsTests.failingComparison"
+                                .equals(result.getFullName())
+                )
+                .findFirst()
+                .get();
+
+        assertThat(testResult.getStatus()).isEqualTo(Status.FAILED);
+        assertThat(testResult.getStatusDetails().getActual()).startsWith("actual value (");
+        assertThat(testResult.getStatusDetails().getExpected()).startsWith("expected value (");
+    }
+
     @Test
     void shouldSkipReportingOfTestInjectablesTestReporterForRegularTest() {
         final AllureResults results = runClasses(SkipOtherInjectables.class);
diff --git a/allure-jupiter/src/test/java/io/qameta/allure/junit5/features/ActualExpectedStatusDetailsTests.java b/allure-jupiter/src/test/java/io/qameta/allure/junit5/features/ActualExpectedStatusDetailsTests.java
new file mode 100644
index 00000000..412ed181
--- /dev/null
+++ b/allure-jupiter/src/test/java/io/qameta/allure/junit5/features/ActualExpectedStatusDetailsTests.java
@@ -0,0 +1,27 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.junit5.features;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+public class ActualExpectedStatusDetailsTests {
+
+    @Test
+    void failingComparison() {
+        assertEquals("expected value", "actual value");
+    }
+}
diff --git a/allure-junit5/src/test/java/io/qameta/allure/junit5/features/AfterEachFixtureBrokenSupport.java b/allure-jupiter/src/test/java/io/qameta/allure/junit5/features/AfterEachFixtureBrokenSupport.java
similarity index 96%
rename from allure-junit5/src/test/java/io/qameta/allure/junit5/features/AfterEachFixtureBrokenSupport.java
rename to allure-jupiter/src/test/java/io/qameta/allure/junit5/features/AfterEachFixtureBrokenSupport.java
index dc2931c2..f737b1a9 100644
--- a/allure-junit5/src/test/java/io/qameta/allure/junit5/features/AfterEachFixtureBrokenSupport.java
+++ b/allure-jupiter/src/test/java/io/qameta/allure/junit5/features/AfterEachFixtureBrokenSupport.java
@@ -18,10 +18,6 @@
 import io.qameta.allure.Allure;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class AfterEachFixtureBrokenSupport {
 
     @AfterEach
diff --git a/allure-junit5/src/test/java/io/qameta/allure/junit5/features/AllFixtureSupport.java b/allure-jupiter/src/test/java/io/qameta/allure/junit5/features/AllFixtureSupport.java
similarity index 96%
rename from allure-junit5/src/test/java/io/qameta/allure/junit5/features/AllFixtureSupport.java
rename to allure-jupiter/src/test/java/io/qameta/allure/junit5/features/AllFixtureSupport.java
index 871159d6..3e04941f 100644
--- a/allure-junit5/src/test/java/io/qameta/allure/junit5/features/AllFixtureSupport.java
+++ b/allure-jupiter/src/test/java/io/qameta/allure/junit5/features/AllFixtureSupport.java
@@ -19,10 +19,6 @@
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class AllFixtureSupport {
 
     @BeforeAll
diff --git a/allure-junit5/src/test/java/io/qameta/allure/junit5/features/BeforeAllFixtureFailureSupport.java b/allure-jupiter/src/test/java/io/qameta/allure/junit5/features/BeforeAllFixtureFailureSupport.java
similarity index 96%
rename from allure-junit5/src/test/java/io/qameta/allure/junit5/features/BeforeAllFixtureFailureSupport.java
rename to allure-jupiter/src/test/java/io/qameta/allure/junit5/features/BeforeAllFixtureFailureSupport.java
index 0ec87a71..6a3c47fd 100644
--- a/allure-junit5/src/test/java/io/qameta/allure/junit5/features/BeforeAllFixtureFailureSupport.java
+++ b/allure-jupiter/src/test/java/io/qameta/allure/junit5/features/BeforeAllFixtureFailureSupport.java
@@ -20,10 +20,6 @@
 import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.fail;
-
-/**
- * @author prafair (Pavel Novikov).
- */
 public class BeforeAllFixtureFailureSupport {
 
     @BeforeAll
diff --git a/allure-junit5/src/test/java/io/qameta/allure/junit5/features/BeforeEachFixtureBrokenSupport.java b/allure-jupiter/src/test/java/io/qameta/allure/junit5/features/BeforeEachFixtureBrokenSupport.java
similarity index 96%
rename from allure-junit5/src/test/java/io/qameta/allure/junit5/features/BeforeEachFixtureBrokenSupport.java
rename to allure-jupiter/src/test/java/io/qameta/allure/junit5/features/BeforeEachFixtureBrokenSupport.java
index 6fc33d93..3de32b25 100644
--- a/allure-junit5/src/test/java/io/qameta/allure/junit5/features/BeforeEachFixtureBrokenSupport.java
+++ b/allure-jupiter/src/test/java/io/qameta/allure/junit5/features/BeforeEachFixtureBrokenSupport.java
@@ -18,10 +18,6 @@
 import io.qameta.allure.Allure;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class BeforeEachFixtureBrokenSupport {
 
     @BeforeEach
diff --git a/allure-junit5/src/test/java/io/qameta/allure/junit5/features/EachFixtureSupport.java b/allure-jupiter/src/test/java/io/qameta/allure/junit5/features/EachFixtureSupport.java
similarity index 96%
rename from allure-junit5/src/test/java/io/qameta/allure/junit5/features/EachFixtureSupport.java
rename to allure-jupiter/src/test/java/io/qameta/allure/junit5/features/EachFixtureSupport.java
index c38c7f73..51b63a8e 100644
--- a/allure-junit5/src/test/java/io/qameta/allure/junit5/features/EachFixtureSupport.java
+++ b/allure-jupiter/src/test/java/io/qameta/allure/junit5/features/EachFixtureSupport.java
@@ -19,10 +19,6 @@
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class EachFixtureSupport {
 
     @BeforeEach
diff --git a/allure-junit5/src/test/java/io/qameta/allure/junit5/features/ParameterisedBlankParameterValueTests.java b/allure-jupiter/src/test/java/io/qameta/allure/junit5/features/ParameterisedBlankParameterValueTests.java
similarity index 96%
rename from allure-junit5/src/test/java/io/qameta/allure/junit5/features/ParameterisedBlankParameterValueTests.java
rename to allure-jupiter/src/test/java/io/qameta/allure/junit5/features/ParameterisedBlankParameterValueTests.java
index 9442cc31..fac20fec 100644
--- a/allure-junit5/src/test/java/io/qameta/allure/junit5/features/ParameterisedBlankParameterValueTests.java
+++ b/allure-jupiter/src/test/java/io/qameta/allure/junit5/features/ParameterisedBlankParameterValueTests.java
@@ -19,10 +19,6 @@
 import org.junit.jupiter.params.provider.MethodSource;
 
 import java.util.stream.Stream;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class ParameterisedBlankParameterValueTests {
 
     @ParameterizedTest
diff --git a/allure-junit5/src/test/java/io/qameta/allure/junit5/features/ParameterisedPrimitivesTests.java b/allure-jupiter/src/test/java/io/qameta/allure/junit5/features/ParameterisedPrimitivesTests.java
similarity index 98%
rename from allure-junit5/src/test/java/io/qameta/allure/junit5/features/ParameterisedPrimitivesTests.java
rename to allure-jupiter/src/test/java/io/qameta/allure/junit5/features/ParameterisedPrimitivesTests.java
index 62c3be09..769d2793 100644
--- a/allure-junit5/src/test/java/io/qameta/allure/junit5/features/ParameterisedPrimitivesTests.java
+++ b/allure-jupiter/src/test/java/io/qameta/allure/junit5/features/ParameterisedPrimitivesTests.java
@@ -21,10 +21,6 @@
 import org.junit.jupiter.params.provider.ValueSource;
 
 import java.util.stream.Stream;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class ParameterisedPrimitivesTests {
 
     @ParameterizedTest
@@ -93,5 +89,4 @@ static Stream<Arguments> nulls() {
         );
     }
 
-
 }
diff --git a/allure-junit5/src/test/java/io/qameta/allure/junit5/features/ParameterisedTests.java b/allure-jupiter/src/test/java/io/qameta/allure/junit5/features/ParameterisedTests.java
similarity index 96%
rename from allure-junit5/src/test/java/io/qameta/allure/junit5/features/ParameterisedTests.java
rename to allure-jupiter/src/test/java/io/qameta/allure/junit5/features/ParameterisedTests.java
index d0b67f08..64afb345 100644
--- a/allure-junit5/src/test/java/io/qameta/allure/junit5/features/ParameterisedTests.java
+++ b/allure-jupiter/src/test/java/io/qameta/allure/junit5/features/ParameterisedTests.java
@@ -19,10 +19,6 @@
 import org.junit.jupiter.api.TestReporter;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class ParameterisedTests {
 
     @ParameterizedTest
@@ -40,7 +36,6 @@ void second(String value) {
     void third(@Param("some value") String value) {
     }
 
-
     @ParameterizedTest
     @ValueSource(strings = {"a", "b"})
     void testReporterInjection(String value, TestReporter testReporter) {
diff --git a/allure-junit5/src/test/java/io/qameta/allure/junit5/features/ParameterisedWithInjectablesTests.java b/allure-jupiter/src/test/java/io/qameta/allure/junit5/features/ParameterisedWithInjectablesTests.java
similarity index 100%
rename from allure-junit5/src/test/java/io/qameta/allure/junit5/features/ParameterisedWithInjectablesTests.java
rename to allure-jupiter/src/test/java/io/qameta/allure/junit5/features/ParameterisedWithInjectablesTests.java
diff --git a/allure-junit5/src/test/java/io/qameta/allure/junit5/features/SkipOtherInjectables.java b/allure-jupiter/src/test/java/io/qameta/allure/junit5/features/SkipOtherInjectables.java
similarity index 96%
rename from allure-junit5/src/test/java/io/qameta/allure/junit5/features/SkipOtherInjectables.java
rename to allure-jupiter/src/test/java/io/qameta/allure/junit5/features/SkipOtherInjectables.java
index 63a9db24..06863873 100644
--- a/allure-junit5/src/test/java/io/qameta/allure/junit5/features/SkipOtherInjectables.java
+++ b/allure-jupiter/src/test/java/io/qameta/allure/junit5/features/SkipOtherInjectables.java
@@ -19,10 +19,6 @@
 import org.junit.jupiter.api.TestReporter;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class SkipOtherInjectables {
 
     @Test
diff --git a/allure-jupiter/src/test/java/io/qameta/allure/jupiter/AllureJupiterJunit6CompatibilityTest.java b/allure-jupiter/src/test/java/io/qameta/allure/jupiter/AllureJupiterJunit6CompatibilityTest.java
new file mode 100644
index 00000000..f40fe2bd
--- /dev/null
+++ b/allure-jupiter/src/test/java/io/qameta/allure/jupiter/AllureJupiterJunit6CompatibilityTest.java
@@ -0,0 +1,165 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.jupiter;
+
+import io.qameta.allure.Allure;
+import io.qameta.allure.Param;
+import io.qameta.allure.junitplatform.AllureJunitPlatform;
+import io.qameta.allure.model.FixtureResult;
+import io.qameta.allure.model.Parameter;
+import io.qameta.allure.model.Status;
+import io.qameta.allure.model.StepResult;
+import io.qameta.allure.model.TestResult;
+import io.qameta.allure.model.TestResultContainer;
+import io.qameta.allure.test.AllureResults;
+import io.qameta.allure.test.RunUtils;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.platform.engine.discovery.ClassSelector;
+import org.junit.platform.engine.discovery.DiscoverySelectors;
+import org.junit.platform.launcher.Launcher;
+import org.junit.platform.launcher.LauncherDiscoveryRequest;
+import org.junit.platform.launcher.core.LauncherConfig;
+import org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder;
+import org.junit.platform.launcher.core.LauncherFactory;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.tuple;
+
+@Tag("junit6-compat")
+@SuppressWarnings("unused")
+class AllureJupiterJunit6CompatibilityTest {
+
+    @ExtendWith(AllureJupiter.class)
+    static class CompatParametersTest {
+
+        @org.junit.jupiter.params.ParameterizedTest
+        @org.junit.jupiter.params.provider.ValueSource(strings = {"a", "b"})
+        void paramTest(@Param("id") final String value) {
+        }
+    }
+
+    @Nested
+    @ExtendWith(AllureJupiter.class)
+    class CompatFixtures {
+
+        @BeforeEach
+        void setUp() {
+            Allure.step("before step");
+        }
+
+        @Test
+        void testBody() {
+            Allure.step("test step");
+        }
+
+        @AfterEach
+        void tearDown() {
+            Allure.step("after step");
+        }
+    }
+
+    @Test
+    void shouldCaptureParametersWithParamAnnotationOnJunit6() {
+        final AllureResults results = runWithLauncher(CompatParametersTest.class);
+
+        assertThat(results.getTestResults()).isNotEmpty();
+
+        final List<Parameter> allParams = results.getTestResults().stream()
+                .flatMap(tr -> tr.getParameters().stream())
+                .toList();
+
+        assertThat(allParams)
+                .filteredOn(parameter -> "id".equals(parameter.getName()))
+                .extracting(Parameter::getName, Parameter::getValue)
+                .containsExactlyInAnyOrder(
+                        tuple("id", "a"),
+                        tuple("id", "b")
+                );
+    }
+
+    @Test
+    void shouldCaptureFixturesAndStepsOnJunit6() {
+        final AllureResults results = runWithLauncher(CompatFixtures.class);
+
+        assertThat(results.getTestResults()).hasSize(1);
+        final TestResult testResult = results.getTestResults().get(0);
+
+        assertThat(results.getTestResultContainers())
+                .flatExtracting(TestResultContainer::getChildren)
+                .contains(testResult.getUuid());
+
+        assertThat(results.getTestResultContainers())
+                .flatExtracting(TestResultContainer::getBefores)
+                .extracting(FixtureResult::getName, FixtureResult::getStatus)
+                .containsExactly(
+                        tuple("setUp", Status.PASSED)
+                );
+
+        assertThat(results.getTestResultContainers())
+                .flatExtracting(TestResultContainer::getAfters)
+                .extracting(FixtureResult::getName, FixtureResult::getStatus)
+                .containsExactly(
+                        tuple("tearDown", Status.PASSED)
+                );
+
+        assertThat(results.getTestResultContainers())
+                .flatExtracting(TestResultContainer::getBefores)
+                .flatExtracting(FixtureResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly("before step");
+
+        assertThat(results.getTestResults())
+                .flatExtracting(TestResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly("test step");
+
+        assertThat(results.getTestResultContainers())
+                .flatExtracting(TestResultContainer::getAfters)
+                .flatExtracting(FixtureResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly("after step");
+    }
+
+    @io.qameta.allure.Step("Run classes {classes}")
+    private AllureResults runWithLauncher(final Class<?>... classes) {
+        return RunUtils.runTests(lifecycle -> {
+            final ClassSelector[] selectors = Stream.of(classes)
+                    .map(DiscoverySelectors::selectClass)
+                    .toArray(ClassSelector[]::new);
+
+            final LauncherDiscoveryRequest request = LauncherDiscoveryRequestBuilder.request()
+                    .configurationParameter("junit.jupiter.extensions.autodetection.enabled", "true")
+                    .selectors(selectors)
+                    .build();
+
+            final LauncherConfig config = LauncherConfig.builder()
+                    .enableTestExecutionListenerAutoRegistration(false)
+                    .addTestExecutionListeners(new AllureJunitPlatform(lifecycle))
+                    .build();
+
+            final Launcher launcher = LauncherFactory.create(config);
+            launcher.execute(request);
+        });
+    }
+}
diff --git a/allure-jupiter/src/test/resources/META-INF/services/org.junit.jupiter.api.extension.Extension b/allure-jupiter/src/test/resources/META-INF/services/org.junit.jupiter.api.extension.Extension
new file mode 100644
index 00000000..17a07514
--- /dev/null
+++ b/allure-jupiter/src/test/resources/META-INF/services/org.junit.jupiter.api.extension.Extension
@@ -0,0 +1 @@
+io.qameta.allure.jupiter.AllureJupiter
diff --git a/allure-junit5/src/test/resources/allure.properties b/allure-jupiter/src/test/resources/allure.properties
similarity index 82%
rename from allure-junit5/src/test/resources/allure.properties
rename to allure-jupiter/src/test/resources/allure.properties
index 4c9c3b8e..36ea007c 100644
--- a/allure-junit5/src/test/resources/allure.properties
+++ b/allure-jupiter/src/test/resources/allure.properties
@@ -1,3 +1,4 @@
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
 allure.link.issue.pattern=https://github.com/allure-framework/allure-java/issues/{}
+allure.label.module=allure-jupiter
diff --git a/allure-karate/build.gradle.kts b/allure-karate/build.gradle.kts
index 3a2c1ea7..18c7b4e0 100644
--- a/allure-karate/build.gradle.kts
+++ b/allure-karate/build.gradle.kts
@@ -23,6 +23,7 @@ dependencies {
     testImplementation("org.slf4j:slf4j-simple")
     testImplementation(project(":allure-java-commons-test"))
     testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
+    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 }
 
 tasks.jar {
diff --git a/allure-karate/src/main/java/io/qameta/allure/karate/AllureKarate.java b/allure-karate/src/main/java/io/qameta/allure/karate/AllureKarate.java
index f49f31d6..1a9c49e3 100644
--- a/allure-karate/src/main/java/io/qameta/allure/karate/AllureKarate.java
+++ b/allure-karate/src/main/java/io/qameta/allure/karate/AllureKarate.java
@@ -54,10 +54,14 @@
 import static io.qameta.allure.util.ResultsUtils.createLabel;
 import static io.qameta.allure.util.ResultsUtils.createLink;
 import static io.qameta.allure.util.ResultsUtils.createParameter;
+import static io.qameta.allure.util.ResultsUtils.createTitlePath;
+import static io.qameta.allure.util.ResultsUtils.createTitlePathFromSourcePath;
 import static io.qameta.allure.util.ResultsUtils.md5;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Reports Karate runtime events to Allure.
+ *
+ * <p>Register this runtime hook with Karate so features, scenarios, steps, and attachments are converted into Allure results. The hook uses the Allure lifecycle to write standard result files.</p>
  */
 @SuppressWarnings("MultipleStringLiterals")
 public class AllureKarate implements RuntimeHook {
@@ -70,14 +74,25 @@ public class AllureKarate implements RuntimeHook {
 
     private final List<String> tcUuids = new ArrayList<>();
 
+    /**
+     * Creates an Allure karate with default configuration.
+     */
     public AllureKarate() {
         this(Allure.getLifecycle());
     }
 
+    /**
+     * Creates an Allure karate with the supplied values.
+     *
+     * @param lifecycle the Allure lifecycle to use
+     */
     public AllureKarate(final AllureLifecycle lifecycle) {
         this.lifecycle = lifecycle;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public boolean beforeScenario(final ScenarioRuntime sr) {
         final Feature feature = sr.featureRuntime.result.getFeature();
@@ -91,6 +106,8 @@ public boolean beforeScenario(final ScenarioRuntime sr) {
         final String nameOrLine = getName(scenario, String.valueOf(scenario.getLine()));
         final String testCaseId = md5(String.format("%s:%s", featureNameQualified, nameOrLine));
         final String fullName = String.format("%s:%d", featureNameQualified, scenario.getLine());
+        final List<String> titlePath = createTitlePathFromSourcePath(featureNameQualified);
+        titlePath.addAll(createTitlePath(featureName));
         final TestResult result = new TestResult()
                 .setUuid(uuid)
                 .setFullName(fullName)
@@ -98,6 +115,7 @@ public boolean beforeScenario(final ScenarioRuntime sr) {
                 .setDescription(scenario.getDescription())
                 .setTestCaseId(testCaseId)
                 .setHistoryId(md5(scenario.getUniqueId()))
+                .setTitlePath(titlePath)
                 .setStage(Stage.RUNNING);
 
         final List<String> labels = sr.tags.getTags();
@@ -124,6 +142,9 @@ private static String getName(final Scenario scenario, final String defaultValue
         return blank ? defaultValue : scenario.getName().trim();
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void afterScenario(final ScenarioRuntime sr) {
         final String uuid = (String) sr.magicVariables.get(ALLURE_UUID);
@@ -165,6 +186,9 @@ public void afterScenario(final ScenarioRuntime sr) {
         tcUuids.add(uuid);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public boolean beforeStep(final Step step,
                               final ScenarioRuntime sr) {
@@ -186,6 +210,9 @@ public boolean beforeStep(final Step step,
         return true;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void afterStep(final StepResult result,
                           final ScenarioRuntime sr) {
@@ -238,6 +265,9 @@ public void afterStep(final StepResult result,
 
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void afterFeature(final FeatureRuntime fr) {
         tcUuids.forEach(lifecycle::writeTestCase);
diff --git a/allure-karate/src/test/java/io/qameta/allure/karate/AllureKarateTest.java b/allure-karate/src/test/java/io/qameta/allure/karate/AllureKarateTest.java
index 5d18e9f0..313f204d 100644
--- a/allure-karate/src/test/java/io/qameta/allure/karate/AllureKarateTest.java
+++ b/allure-karate/src/test/java/io/qameta/allure/karate/AllureKarateTest.java
@@ -16,6 +16,8 @@
 package io.qameta.allure.karate;
 
 import com.intuit.karate.Runner;
+import io.qameta.allure.AllureLifecycle;
+import io.qameta.allure.FileSystemResultsWriter;
 import io.qameta.allure.model.Label;
 import io.qameta.allure.model.Link;
 import io.qameta.allure.model.Parameter;
@@ -26,15 +28,13 @@
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
+import java.nio.file.Path;
+
 import static io.qameta.allure.model.Status.BROKEN;
 import static io.qameta.allure.model.Status.PASSED;
 import static io.qameta.allure.util.ResultsUtils.md5;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.tuple;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @SuppressWarnings({"MultipleStringLiterals", "PMD.AvoidDuplicateLiterals"})
 class AllureKarateTest extends TestRunner {
 
@@ -334,13 +334,25 @@ void shouldSkipCallAndCallOnceStepsInBeforeStep() {
 
     @Test
     void buildTest() {
+        final Path allureResults = temp.resolve("allure-results");
+
         Runner.builder()
                 .path("classpath:testdata/greeting.feature")
-                .hook(new AllureKarate())
+                .hook(
+                        new AllureKarate(
+                                new AllureLifecycle(
+                                        new FileSystemResultsWriter(allureResults)
+                                )
+                        )
+                )
                 .backupReportDir(false)
+                .reportDir(temp.resolve("karate-reports").toString())
                 .outputJunitXml(false)
                 .outputCucumberJson(false)
                 .outputHtmlReport(false)
                 .parallel(1);
+
+        assertThat(allureResults)
+                .isDirectoryContaining(path -> path.getFileName().toString().endsWith("-result.json"));
     }
 }
diff --git a/allure-karate/src/test/java/io/qameta/allure/karate/TestRunner.java b/allure-karate/src/test/java/io/qameta/allure/karate/TestRunner.java
index 1149317c..677e5757 100644
--- a/allure-karate/src/test/java/io/qameta/allure/karate/TestRunner.java
+++ b/allure-karate/src/test/java/io/qameta/allure/karate/TestRunner.java
@@ -17,11 +17,14 @@
 
 import io.qameta.allure.test.AllureResults;
 import io.qameta.allure.test.RunUtils;
+import org.junit.jupiter.api.io.TempDir;
 import org.mockserver.client.MockServerClient;
 import org.mockserver.model.HttpRequest;
 import org.mockserver.model.HttpResponse;
 import org.mockserver.netty.MockServer;
 
+import java.nio.file.Path;
+
 import static org.mockserver.model.HttpRequest.request;
 import static org.mockserver.model.HttpResponse.response;
 
@@ -31,6 +34,9 @@ public class TestRunner {
     private MockServer server;
     private MockServerClient client;
 
+    @TempDir
+    protected Path temp;
+
     AllureResults runApi(final String... featurePath) {
         server = new MockServer(8081);
         client = new MockServerClient("localhost", server.getLocalPort());
@@ -63,6 +69,7 @@ AllureResults run(final String... path) {
                         .path(path)
                         .hook(allureKarate)
                         .backupReportDir(false)
+                        .reportDir(temp.resolve("karate-reports").toString())
                         .outputJunitXml(false)
                         .outputCucumberJson(false)
                         .outputHtmlReport(false)
diff --git a/allure-karate/src/test/resources/allure.properties b/allure-karate/src/test/resources/allure.properties
new file mode 100644
index 00000000..a4cd2a54
--- /dev/null
+++ b/allure-karate/src/test/resources/allure.properties
@@ -0,0 +1,3 @@
+allure.results.directory=build/allure-results
+allure.label.epic=#project.description#
+allure.label.module=allure-karate
diff --git a/allure-model/src/main/java/io/qameta/allure/model/Attachment.java b/allure-model/src/main/java/io/qameta/allure/model/Attachment.java
index af5c7845..7c8f92f2 100644
--- a/allure-model/src/main/java/io/qameta/allure/model/Attachment.java
+++ b/allure-model/src/main/java/io/qameta/allure/model/Attachment.java
@@ -21,7 +21,6 @@
  * The model object that used to link attachment files, stored in results directory,
  * to test results.
  *
- * @author baev (Dmitry Baev)
  * @see io.qameta.allure.model.WithAttachments
  * @since 2.0
  */
diff --git a/allure-model/src/main/java/io/qameta/allure/model/AttachmentType.java b/allure-model/src/main/java/io/qameta/allure/model/AttachmentType.java
new file mode 100644
index 00000000..65f0eee2
--- /dev/null
+++ b/allure-model/src/main/java/io/qameta/allure/model/AttachmentType.java
@@ -0,0 +1,83 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.model;
+
+/**
+ * Common attachment media types and file extensions.
+ */
+public final class AttachmentType {
+
+    /**
+     * Predefined attachment type for png content.
+     */
+    public static final AttachmentType PNG = new AttachmentType("image/png", "png");
+
+    /**
+     * Predefined attachment type for jpeg content.
+     */
+    public static final AttachmentType JPEG = new AttachmentType("image/jpeg", "jpg");
+
+    /**
+     * Predefined attachment type for text content.
+     */
+    public static final AttachmentType TEXT = new AttachmentType("text/plain", "txt");
+
+    /**
+     * Predefined attachment type for html content.
+     */
+    public static final AttachmentType HTML = new AttachmentType("text/html", "html");
+
+    /**
+     * Predefined attachment type for zip content.
+     */
+    public static final AttachmentType ZIP = new AttachmentType("application/zip", "zip");
+
+    /**
+     * Predefined attachment type for webm content.
+     */
+    public static final AttachmentType WEBM = new AttachmentType("video/webm", "webm");
+
+    /**
+     * Predefined attachment type for octet stream content.
+     */
+    public static final AttachmentType OCTET_STREAM = new AttachmentType("application/octet-stream", "");
+
+    private final String mediaType;
+    private final String extension;
+
+    private AttachmentType(final String mediaType, final String extension) {
+        this.mediaType = mediaType;
+        this.extension = extension;
+    }
+
+    /**
+     * Returns the media type.
+     *
+     * @return the media type
+     */
+    public String getMediaType() {
+        return mediaType;
+    }
+
+    /**
+     * Returns the extension.
+     *
+     * @return the extension
+     */
+    public String getExtension() {
+        return extension;
+    }
+}
diff --git a/allure-model/src/main/java/io/qameta/allure/model/ExecutableItem.java b/allure-model/src/main/java/io/qameta/allure/model/ExecutableItem.java
index 05bcc254..8e596336 100644
--- a/allure-model/src/main/java/io/qameta/allure/model/ExecutableItem.java
+++ b/allure-model/src/main/java/io/qameta/allure/model/ExecutableItem.java
@@ -19,12 +19,15 @@
  * Marker interface for model objects that holds information about
  * executable items, like test results, fixture results or steps.
  *
- * @author charlie (Dmitry Baev).
  * @see TestResult
  * @see FixtureResult
  * @see StepResult
  */
-public interface ExecutableItem extends WithAttachments,
-        WithParameters, WithStatusDetails, WithSteps {
+public interface ExecutableItem
+        extends
+            WithAttachments,
+            WithParameters,
+            WithStatusDetails,
+            WithSteps {
 
 }
diff --git a/allure-model/src/main/java/io/qameta/allure/model/FixtureResult.java b/allure-model/src/main/java/io/qameta/allure/model/FixtureResult.java
index e51d940a..64af5eaa 100644
--- a/allure-model/src/main/java/io/qameta/allure/model/FixtureResult.java
+++ b/allure-model/src/main/java/io/qameta/allure/model/FixtureResult.java
@@ -24,7 +24,6 @@
  * The model object that stores information about executed test fixtures (set up and tear down methods).
  * In order to link test fixture to test result {@link TestResultContainer} is used.
  *
- * @author baev (Dmitry Baev)
  * @see io.qameta.allure.model.TestResult
  * @see io.qameta.allure.model.TestResultContainer
  * @since 2.0
diff --git a/allure-model/src/main/java/io/qameta/allure/model/Label.java b/allure-model/src/main/java/io/qameta/allure/model/Label.java
index fe13509e..8ce45c92 100644
--- a/allure-model/src/main/java/io/qameta/allure/model/Label.java
+++ b/allure-model/src/main/java/io/qameta/allure/model/Label.java
@@ -22,7 +22,6 @@
  * The model object that could be used to pass additional metadata to test results.
  * Note that labels with empty (blank) name will be omitted during report generation.
  *
- * @author baev (Dmitry Baev)
  * @see io.qameta.allure.model.TestResult
  * @since 2.0
  */
diff --git a/allure-model/src/main/java/io/qameta/allure/model/Link.java b/allure-model/src/main/java/io/qameta/allure/model/Link.java
index 5b0175fe..532c5892 100644
--- a/allure-model/src/main/java/io/qameta/allure/model/Link.java
+++ b/allure-model/src/main/java/io/qameta/allure/model/Link.java
@@ -21,7 +21,6 @@
 /**
  * Model object that could be used to pass links to external resources to test results.
  *
- * @author baev (Dmitry Baev)
  * @see io.qameta.allure.model.WithLinks
  * @see io.qameta.allure.model.TestResult
  * @since 2.0
diff --git a/allure-model/src/main/java/io/qameta/allure/model/Parameter.java b/allure-model/src/main/java/io/qameta/allure/model/Parameter.java
index 4022c85d..504666f3 100644
--- a/allure-model/src/main/java/io/qameta/allure/model/Parameter.java
+++ b/allure-model/src/main/java/io/qameta/allure/model/Parameter.java
@@ -30,7 +30,6 @@
  * You can exclude parameters from history key calculation by setting {@link #excluded} property
  * to <code>true</code>.
  *
- * @author baev (Dmitry Baev)
  * @see io.qameta.allure.model.TestResult
  * @see io.qameta.allure.model.WithParameters
  * @since 2.0
@@ -151,7 +150,6 @@ public int hashCode() {
     /**
      * The parameter render mode.
      *
-     * @author baev (Dmitry Baev)
      * @since 2.15
      */
     public enum Mode {
diff --git a/allure-model/src/main/java/io/qameta/allure/model/Stage.java b/allure-model/src/main/java/io/qameta/allure/model/Stage.java
index aec91583..6b639aae 100644
--- a/allure-model/src/main/java/io/qameta/allure/model/Stage.java
+++ b/allure-model/src/main/java/io/qameta/allure/model/Stage.java
@@ -18,7 +18,6 @@
 /**
  * Test stages.
  *
- * @author baev (Dmitry Baev)
  * @since 2.0
  */
 public enum Stage {
@@ -27,18 +26,22 @@ public enum Stage {
      * Scheduled stage.
      */
     SCHEDULED("scheduled"),
+
     /**
      * Running stage.
      */
     RUNNING("running"),
+
     /**
      * Finished stage.
      */
     FINISHED("finished"),
+
     /**
      * Pending stage.
      */
     PENDING("pending"),
+
     /**
      * Interrupted stage.
      */
diff --git a/allure-model/src/main/java/io/qameta/allure/model/Status.java b/allure-model/src/main/java/io/qameta/allure/model/Status.java
index 42563609..85edf99f 100644
--- a/allure-model/src/main/java/io/qameta/allure/model/Status.java
+++ b/allure-model/src/main/java/io/qameta/allure/model/Status.java
@@ -18,7 +18,6 @@
 /**
  * Test statuses.
  *
- * @author baev (Dmitry Baev)
  * @see io.qameta.allure.model.WithStatus
  * @since 2.0
  */
@@ -28,14 +27,17 @@ public enum Status {
      * Marks tests that have some failed checks (assertions).
      */
     FAILED("failed"),
+
     /**
      * Marks tests with unexpected failures during test execution.
      */
     BROKEN("broken"),
+
     /**
      * Marks passed tests.
      */
     PASSED("passed"),
+
     /**
      * Marks skipped/interrupted tests.
      */
diff --git a/allure-model/src/main/java/io/qameta/allure/model/StatusDetails.java b/allure-model/src/main/java/io/qameta/allure/model/StatusDetails.java
index 10ca653f..5df03de2 100644
--- a/allure-model/src/main/java/io/qameta/allure/model/StatusDetails.java
+++ b/allure-model/src/main/java/io/qameta/allure/model/StatusDetails.java
@@ -21,7 +21,6 @@
 /**
  * The type Status details.
  *
- * @author baev (Dmitry Baev)
  * @see io.qameta.allure.model.WithStatusDetails
  * @since 2.0
  */
@@ -34,6 +33,8 @@ public class StatusDetails implements Serializable {
     private boolean flaky;
     private String message;
     private String trace;
+    private String actual;
+    private String expected;
 
     /**
      * Is known boolean.
@@ -135,6 +136,46 @@ public StatusDetails setTrace(final String value) {
         return this;
     }
 
+    /**
+     * Gets actual.
+     *
+     * @return the actual
+     */
+    public String getActual() {
+        return actual;
+    }
+
+    /**
+     * Sets actual.
+     *
+     * @param value the value
+     * @return self for method chaining
+     */
+    public StatusDetails setActual(final String value) {
+        this.actual = value;
+        return this;
+    }
+
+    /**
+     * Gets expected.
+     *
+     * @return the expected
+     */
+    public String getExpected() {
+        return expected;
+    }
+
+    /**
+     * Sets expected.
+     *
+     * @param value the value
+     * @return self for method chaining
+     */
+    public StatusDetails setExpected(final String value) {
+        this.expected = value;
+        return this;
+    }
+
     /**
      * {@inheritDoc}
      */
@@ -148,7 +189,9 @@ public boolean equals(final Object o) {
         }
         final StatusDetails that = (StatusDetails) o;
         return Objects.equals(message, that.message)
-                && Objects.equals(trace, that.trace);
+                && Objects.equals(trace, that.trace)
+                && Objects.equals(actual, that.actual)
+                && Objects.equals(expected, that.expected);
     }
 
     /**
@@ -156,6 +199,6 @@ public boolean equals(final Object o) {
      */
     @Override
     public int hashCode() {
-        return Objects.hash(message, trace);
+        return Objects.hash(message, trace, actual, expected);
     }
 }
diff --git a/allure-model/src/main/java/io/qameta/allure/model/StepResult.java b/allure-model/src/main/java/io/qameta/allure/model/StepResult.java
index 0e293f36..d25a1001 100644
--- a/allure-model/src/main/java/io/qameta/allure/model/StepResult.java
+++ b/allure-model/src/main/java/io/qameta/allure/model/StepResult.java
@@ -23,7 +23,6 @@
 /**
  * The model object that stores information about test steps that was run.
  *
- * @author baev (Dmitry Baev)
  * @see io.qameta.allure.model.ExecutableItem
  * @see io.qameta.allure.model.WithAttachments
  * @see io.qameta.allure.model.WithParameters
diff --git a/allure-model/src/main/java/io/qameta/allure/model/TestResult.java b/allure-model/src/main/java/io/qameta/allure/model/TestResult.java
index f1039c23..d7498e34 100644
--- a/allure-model/src/main/java/io/qameta/allure/model/TestResult.java
+++ b/allure-model/src/main/java/io/qameta/allure/model/TestResult.java
@@ -24,7 +24,6 @@
  * The model object that stores information about test that was run.
  * Test results are the main entity of Allure.
  *
- * @author baev (Dmitry Baev)
  * @see io.qameta.allure.model.ExecutableItem
  * @see io.qameta.allure.model.WithAttachments
  * @see io.qameta.allure.model.WithLinks
@@ -34,6 +33,7 @@
  * @see io.qameta.allure.model.WithSteps
  * @since 2.0
  */
+@SuppressWarnings("PMD.TooManyMethods")
 public class TestResult implements Serializable, ExecutableItem, WithLinks {
 
     private static final long serialVersionUID = 1L;
@@ -43,6 +43,7 @@ public class TestResult implements Serializable, ExecutableItem, WithLinks {
     private String testCaseId;
     private String testCaseName;
     private String fullName;
+    private List<String> titlePath = new ArrayList<>();
     private List<Label> labels = new ArrayList<>();
     private List<Link> links = new ArrayList<>();
     private String name;
@@ -157,6 +158,26 @@ public TestResult setFullName(final String value) {
         return this;
     }
 
+    /**
+     * Gets title path.
+     *
+     * @return the title path
+     */
+    public List<String> getTitlePath() {
+        return titlePath;
+    }
+
+    /**
+     * Sets title path.
+     *
+     * @param titlePath the title path
+     * @return self for method chaining.
+     */
+    public TestResult setTitlePath(final List<String> titlePath) {
+        this.titlePath = titlePath;
+        return this;
+    }
+
     /**
      * Gets labels.
      *
@@ -177,7 +198,6 @@ public TestResult setLabels(final List<Label> labels) {
         return this;
     }
 
-
     /**
      * Gets links.
      *
@@ -240,7 +260,6 @@ public TestResult setStatus(final Status value) {
         return this;
     }
 
-
     /**
      * Gets status details.
      *
@@ -322,7 +341,6 @@ public TestResult setDescriptionHtml(final String value) {
         return this;
     }
 
-
     /**
      * Gets steps.
      *
@@ -365,7 +383,6 @@ public TestResult setAttachments(final List<Attachment> attachments) {
         return this;
     }
 
-
     /**
      * Gets parameters.
      *
@@ -416,7 +433,6 @@ public Long getStop() {
         return stop;
     }
 
-
     /**
      * Sets stop.
      *
diff --git a/allure-model/src/main/java/io/qameta/allure/model/TestResultContainer.java b/allure-model/src/main/java/io/qameta/allure/model/TestResultContainer.java
index 7ca8bcc7..1ddcc588 100644
--- a/allure-model/src/main/java/io/qameta/allure/model/TestResultContainer.java
+++ b/allure-model/src/main/java/io/qameta/allure/model/TestResultContainer.java
@@ -28,7 +28,6 @@
  * <p>
  * Containers that have empty {@link #children} are simply ignored.
  *
- * @author baev (Dmitry Baev)
  * @see io.qameta.allure.model.TestResult
  * @see io.qameta.allure.model.WithLinks
  * @since 2.0
diff --git a/allure-model/src/main/java/io/qameta/allure/model/WithAttachments.java b/allure-model/src/main/java/io/qameta/allure/model/WithAttachments.java
index b253548f..966890d2 100644
--- a/allure-model/src/main/java/io/qameta/allure/model/WithAttachments.java
+++ b/allure-model/src/main/java/io/qameta/allure/model/WithAttachments.java
@@ -20,7 +20,6 @@
 /**
  * The marker interface for model objects with attachments.
  *
- * @author baev (Dmitry Baev).
  * @see TestResult
  * @see FixtureResult
  * @see StepResult
diff --git a/allure-model/src/main/java/io/qameta/allure/model/WithLinks.java b/allure-model/src/main/java/io/qameta/allure/model/WithLinks.java
index 122ce964..eaa602f3 100644
--- a/allure-model/src/main/java/io/qameta/allure/model/WithLinks.java
+++ b/allure-model/src/main/java/io/qameta/allure/model/WithLinks.java
@@ -20,7 +20,6 @@
 /**
  * The marker interface for model objects with links.
  *
- * @author baev (Dmitry Baev).
  * @see TestResult
  * @see FixtureResult
  * @see StepResult
diff --git a/allure-model/src/main/java/io/qameta/allure/model/WithParameters.java b/allure-model/src/main/java/io/qameta/allure/model/WithParameters.java
index aeb40454..97345eea 100644
--- a/allure-model/src/main/java/io/qameta/allure/model/WithParameters.java
+++ b/allure-model/src/main/java/io/qameta/allure/model/WithParameters.java
@@ -20,7 +20,6 @@
 /**
  * The marker interface for model objects that could be parameterised.
  *
- * @author baev (Dmitry Baev).
  * @see TestResult
  * @see FixtureResult
  * @see StepResult
diff --git a/allure-model/src/main/java/io/qameta/allure/model/WithStatus.java b/allure-model/src/main/java/io/qameta/allure/model/WithStatus.java
index b11bf6a4..ecb70f57 100644
--- a/allure-model/src/main/java/io/qameta/allure/model/WithStatus.java
+++ b/allure-model/src/main/java/io/qameta/allure/model/WithStatus.java
@@ -18,7 +18,6 @@
 /**
  * The marker interface for model objects with status.
  *
- * @author baev (Dmitry Baev).
  * @see TestResult
  * @see FixtureResult
  * @see StepResult
diff --git a/allure-model/src/main/java/io/qameta/allure/model/WithStatusDetails.java b/allure-model/src/main/java/io/qameta/allure/model/WithStatusDetails.java
index 1ff71732..f0647ec1 100644
--- a/allure-model/src/main/java/io/qameta/allure/model/WithStatusDetails.java
+++ b/allure-model/src/main/java/io/qameta/allure/model/WithStatusDetails.java
@@ -18,7 +18,6 @@
 /**
  * The marker interface for model objects with status details.
  *
- * @author baev (Dmitry Baev).
  * @see TestResult
  * @see FixtureResult
  * @see StepResult
diff --git a/allure-model/src/main/java/io/qameta/allure/model/WithSteps.java b/allure-model/src/main/java/io/qameta/allure/model/WithSteps.java
index 83829a3e..dd2efb60 100644
--- a/allure-model/src/main/java/io/qameta/allure/model/WithSteps.java
+++ b/allure-model/src/main/java/io/qameta/allure/model/WithSteps.java
@@ -20,7 +20,6 @@
 /**
  * The marker interface for model objects with steps.
  *
- * @author baev (Dmitry Baev).
  * @see TestResult
  * @see FixtureResult
  * @see StepResult
diff --git a/allure-model/src/test/java/io/qameta/allure/model/TestResultTest.java b/allure-model/src/test/java/io/qameta/allure/model/TestResultTest.java
new file mode 100644
index 00000000..c60a0e0f
--- /dev/null
+++ b/allure-model/src/test/java/io/qameta/allure/model/TestResultTest.java
@@ -0,0 +1,41 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.model;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class TestResultTest {
+
+    @Test
+    void shouldHaveEmptyTitlePathByDefault() {
+        assertThat(new TestResult().getTitlePath())
+                .isEmpty();
+    }
+
+    @Test
+    void shouldSetTitlePath() {
+        assertThat(
+                new TestResult()
+                        .setTitlePath(Arrays.asList("parent", "child"))
+                        .getTitlePath()
+        )
+                .containsExactly("parent", "child");
+    }
+}
diff --git a/allure-model/src/test/resources/allure.properties b/allure-model/src/test/resources/allure.properties
index cb77d0a3..5002f01c 100644
--- a/allure-model/src/test/resources/allure.properties
+++ b/allure-model/src/test/resources/allure.properties
@@ -1 +1,2 @@
-allure.results.directory=build/allure-results
\ No newline at end of file
+allure.results.directory=build/allure-results
+allure.label.module=allure-model
diff --git a/allure-okhttp/src/main/java/io/qameta/allure/okhttp/AllureOkHttp.java b/allure-okhttp/src/main/java/io/qameta/allure/okhttp/AllureOkHttp.java
index 4987e093..941b3079 100644
--- a/allure-okhttp/src/main/java/io/qameta/allure/okhttp/AllureOkHttp.java
+++ b/allure-okhttp/src/main/java/io/qameta/allure/okhttp/AllureOkHttp.java
@@ -43,11 +43,23 @@ public class AllureOkHttp implements Interceptor {
     private String requestTemplatePath = "http-request.ftl";
     private String responseTemplatePath = "http-response.ftl";
 
+    /**
+     * Sets the request template.
+     *
+     * @param templatePath the classpath path to the FreeMarker template
+     * @return this instance for method chaining
+     */
     public AllureOkHttp setRequestTemplate(final String templatePath) {
         this.requestTemplatePath = templatePath;
         return this;
     }
 
+    /**
+     * Sets the response template.
+     *
+     * @param templatePath the classpath path to the FreeMarker template
+     * @return this instance for method chaining
+     */
     public AllureOkHttp setResponseTemplate(final String templatePath) {
         this.responseTemplatePath = templatePath;
         return this;
@@ -71,7 +83,9 @@ public AllureOkHttp withResponseTemplate(final String templatePath) {
         return setResponseTemplate(templatePath);
     }
 
-    @SuppressWarnings("PMD.CloseResource")
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public Response intercept(final Chain chain) throws IOException {
         final AttachmentProcessor<AttachmentData> processor = new DefaultAttachmentProcessor();
diff --git a/allure-okhttp/src/test/java/io/qameta/allure/okhttp/AllureOkHttp3Test.java b/allure-okhttp/src/test/java/io/qameta/allure/okhttp/AllureOkHttp3Test.java
index c05b0e20..1e4de4d2 100644
--- a/allure-okhttp/src/test/java/io/qameta/allure/okhttp/AllureOkHttp3Test.java
+++ b/allure-okhttp/src/test/java/io/qameta/allure/okhttp/AllureOkHttp3Test.java
@@ -16,13 +16,13 @@
 package io.qameta.allure.okhttp;
 
 import com.github.tomakehurst.wiremock.WireMockServer;
-import io.qameta.allure.model.Attachment;
-import io.qameta.allure.model.TestResult;
-import io.qameta.allure.test.AllureResults;
 import com.squareup.okhttp.OkHttpClient;
 import com.squareup.okhttp.Request;
 import com.squareup.okhttp.Response;
 import com.squareup.okhttp.ResponseBody;
+import io.qameta.allure.model.Attachment;
+import io.qameta.allure.model.TestResult;
+import io.qameta.allure.test.AllureResults;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -41,10 +41,6 @@
 import static io.qameta.allure.test.RunUtils.runWithinTestContext;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.fail;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class AllureOkHttp3Test {
 
     private static final String BODY_STRING = "Hello world!";
@@ -57,9 +53,13 @@ void setUp() {
         server.start();
         configureFor(server.port());
 
-        stubFor(get(urlEqualTo("/hello"))
-                .willReturn(aResponse()
-                        .withBody(BODY_STRING)));
+        stubFor(
+                get(urlEqualTo("/hello"))
+                        .willReturn(
+                                aResponse()
+                                        .withBody(BODY_STRING)
+                        )
+        );
     }
 
     @AfterEach
diff --git a/allure-okhttp/src/test/resources/allure.properties b/allure-okhttp/src/test/resources/allure.properties
index 9c0b0a2d..2182ac90 100644
--- a/allure-okhttp/src/test/resources/allure.properties
+++ b/allure-okhttp/src/test/resources/allure.properties
@@ -1,2 +1,3 @@
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-okhttp
diff --git a/allure-okhttp3/src/main/java/io/qameta/allure/okhttp3/AllureOkHttp3.java b/allure-okhttp3/src/main/java/io/qameta/allure/okhttp3/AllureOkHttp3.java
index e843434d..15663195 100644
--- a/allure-okhttp3/src/main/java/io/qameta/allure/okhttp3/AllureOkHttp3.java
+++ b/allure-okhttp3/src/main/java/io/qameta/allure/okhttp3/AllureOkHttp3.java
@@ -43,11 +43,23 @@ public class AllureOkHttp3 implements Interceptor {
     private String requestTemplatePath = "http-request.ftl";
     private String responseTemplatePath = "http-response.ftl";
 
+    /**
+     * Sets the request template.
+     *
+     * @param templatePath the classpath path to the FreeMarker template
+     * @return this instance for method chaining
+     */
     public AllureOkHttp3 setRequestTemplate(final String templatePath) {
         this.requestTemplatePath = templatePath;
         return this;
     }
 
+    /**
+     * Sets the response template.
+     *
+     * @param templatePath the classpath path to the FreeMarker template
+     * @return this instance for method chaining
+     */
     public AllureOkHttp3 setResponseTemplate(final String templatePath) {
         this.responseTemplatePath = templatePath;
         return this;
@@ -71,7 +83,9 @@ public AllureOkHttp3 withResponseTemplate(final String templatePath) {
         return setResponseTemplate(templatePath);
     }
 
-    @SuppressWarnings("PMD.CloseResource")
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public Response intercept(final Chain chain) throws IOException {
         final AttachmentProcessor<AttachmentData> processor = new DefaultAttachmentProcessor();
diff --git a/allure-okhttp3/src/test/java/io/qameta/allure/okhttp3/AllureOkHttp3Test.java b/allure-okhttp3/src/test/java/io/qameta/allure/okhttp3/AllureOkHttp3Test.java
index 350790a0..5a1e1fc4 100644
--- a/allure-okhttp3/src/test/java/io/qameta/allure/okhttp3/AllureOkHttp3Test.java
+++ b/allure-okhttp3/src/test/java/io/qameta/allure/okhttp3/AllureOkHttp3Test.java
@@ -41,10 +41,6 @@
 import static io.qameta.allure.test.RunUtils.runWithinTestContext;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.fail;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class AllureOkHttp3Test {
 
     private static final String BODY_STRING = "Hello world!";
@@ -57,9 +53,13 @@ void setUp() {
         server.start();
         configureFor(server.port());
 
-        stubFor(get(urlEqualTo("/hello"))
-                .willReturn(aResponse()
-                        .withBody(BODY_STRING)));
+        stubFor(
+                get(urlEqualTo("/hello"))
+                        .willReturn(
+                                aResponse()
+                                        .withBody(BODY_STRING)
+                        )
+        );
     }
 
     @AfterEach
diff --git a/allure-okhttp3/src/test/resources/allure.properties b/allure-okhttp3/src/test/resources/allure.properties
index 9c0b0a2d..a835d79e 100644
--- a/allure-okhttp3/src/test/resources/allure.properties
+++ b/allure-okhttp3/src/test/resources/allure.properties
@@ -1,2 +1,3 @@
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-okhttp3
diff --git a/allure-playwright/build.gradle.kts b/allure-playwright/build.gradle.kts
new file mode 100644
index 00000000..55bec923
--- /dev/null
+++ b/allure-playwright/build.gradle.kts
@@ -0,0 +1,36 @@
+description = "Allure Playwright Integration"
+
+val agent: Configuration by configurations.creating
+
+val playwrightVersion = "1.59.0"
+
+dependencies {
+    agent("org.aspectj:aspectjweaver")
+    api(project(":allure-java-commons"))
+    compileOnly("com.microsoft.playwright:playwright:$playwrightVersion")
+    compileOnly("org.aspectj:aspectjrt")
+    testAnnotationProcessor(project(":allure-descriptions-javadoc"))
+    testImplementation("com.microsoft.playwright:playwright:$playwrightVersion")
+    testImplementation("org.assertj:assertj-core")
+    testImplementation("org.junit.jupiter:junit-jupiter-api")
+    testImplementation("org.slf4j:slf4j-simple")
+    testImplementation(project(":allure-assertj"))
+    testImplementation(project(":allure-java-commons-test"))
+    testImplementation(project(":allure-junit-platform"))
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
+}
+
+tasks.jar {
+    manifest {
+        attributes(mapOf(
+                "Automatic-Module-Name" to "io.qameta.allure.playwright"
+        ))
+    }
+}
+
+tasks.test {
+    useJUnitPlatform()
+    doFirst {
+        jvmArgs("-javaagent:${agent.singleFile}")
+    }
+}
diff --git a/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywright.java b/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywright.java
new file mode 100644
index 00000000..aa01b216
--- /dev/null
+++ b/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywright.java
@@ -0,0 +1,565 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.playwright;
+
+import com.microsoft.playwright.Browser;
+import com.microsoft.playwright.BrowserContext;
+import com.microsoft.playwright.ConsoleMessage;
+import com.microsoft.playwright.Page;
+import com.microsoft.playwright.Tracing;
+import com.microsoft.playwright.Video;
+import io.qameta.allure.Allure;
+import io.qameta.allure.AllureLifecycle;
+import io.qameta.allure.model.AttachmentType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.function.Supplier;
+
+/**
+ * Utility methods for attaching Playwright Java diagnostics to the current Allure test.
+ */
+@SuppressWarnings({"PMD.GodClass", "PMD.TooManyMethods"})
+public final class AllurePlaywright {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(AllurePlaywright.class);
+
+    private static final String SCREENSHOT = "Screenshot";
+    private static final String PAGE_SOURCE = "Page source";
+    private static final String TRACE = "Playwright trace";
+    private static final String VIDEO = "Playwright video";
+    private static final String CONSOLE_MESSAGES = "Console messages";
+    private static final String PAGE_ERRORS = "Page errors";
+
+    private static final ThreadLocal<Boolean> SUPPRESS_ASPECT = new ThreadLocal<Boolean>() {
+        @Override
+        protected Boolean initialValue() {
+            return Boolean.FALSE;
+        }
+    };
+
+    private AllurePlaywright() {
+        throw new IllegalStateException("Do not instance");
+    }
+
+    /**
+     * Clears Playwright reporting state before a test starts.
+     */
+    public static void beforeTest() {
+        clear();
+    }
+
+    /**
+     * Attaches final Playwright artifacts and clears reporting state after a test finishes.
+     */
+    public static void afterTest() {
+        attachRegisteredCloseArtifacts();
+        clear();
+    }
+
+    /**
+     * Attaches failure diagnostics for the current test.
+     */
+    public static void afterTestFailure() {
+        attachFailureArtifacts();
+    }
+
+    /**
+     * Attaches failure diagnostics for the current test.
+     *
+     * @param throwable the test failure.
+     */
+    public static void afterTestFailure(final Throwable throwable) {
+        LOGGER.debug("Attaching Playwright failure artifacts", throwable);
+        afterTestFailure();
+    }
+
+    /**
+     * Registers a Playwright page for failure diagnostics produced by reporting lifecycle hooks.
+     *
+     * @param page the page to register.
+     */
+    public static void register(final Page page) {
+        AllurePlaywrightRegistry.register(page);
+    }
+
+    /**
+     * Registers a Playwright browser context for failure diagnostics produced by reporting lifecycle hooks.
+     *
+     * @param context the browser context to register.
+     */
+    public static void register(final BrowserContext context) {
+        AllurePlaywrightRegistry.register(context);
+    }
+
+    /**
+     * Captures and attaches a page screenshot.
+     *
+     * @param name the attachment name.
+     * @param page the page to capture.
+     */
+    public static void attachScreenshot(final String name, final Page page) {
+        if (page == null || !hasAllureContext()) {
+            return;
+        }
+        try {
+            final byte[] screenshot = withAspectSuppressed(new Supplier<byte[]>() {
+                @Override
+                public byte[] get() {
+                    return page.screenshot();
+                }
+            });
+            attachBytes(defaultName(name, SCREENSHOT), AttachmentType.PNG, screenshot);
+        } catch (RuntimeException e) {
+            LOGGER.warn("Could not capture Playwright screenshot", e);
+        }
+    }
+
+    /**
+     * Captures and attaches page source.
+     *
+     * @param name the attachment name.
+     * @param page the page to capture.
+     */
+    public static void attachPageSource(final String name, final Page page) {
+        if (page == null || !hasAllureContext()) {
+            return;
+        }
+        try {
+            final String content = withAspectSuppressed(new Supplier<String>() {
+                @Override
+                public String get() {
+                    return page.content();
+                }
+            });
+            attachBytes(defaultName(name, PAGE_SOURCE), AttachmentType.HTML, content.getBytes(StandardCharsets.UTF_8));
+        } catch (RuntimeException e) {
+            LOGGER.warn("Could not capture Playwright page source", e);
+        }
+    }
+
+    /**
+     * Captures and attaches Playwright console messages retained by the page.
+     *
+     * @param name the attachment name.
+     * @param page the page to capture.
+     */
+    public static void attachConsoleMessages(final String name, final Page page) {
+        if (page == null || !hasAllureContext()) {
+            return;
+        }
+        try {
+            final String content = formatConsoleMessages(page.consoleMessages());
+            attachText(defaultName(name, CONSOLE_MESSAGES), content);
+        } catch (RuntimeException e) {
+            LOGGER.warn("Could not capture Playwright console messages", e);
+        }
+    }
+
+    /**
+     * Captures and attaches Playwright page errors retained by the page.
+     *
+     * @param name the attachment name.
+     * @param page the page to capture.
+     */
+    public static void attachPageErrors(final String name, final Page page) {
+        if (page == null || !hasAllureContext()) {
+            return;
+        }
+        try {
+            final String content = formatLines(page.pageErrors());
+            attachText(defaultName(name, PAGE_ERRORS), content);
+        } catch (RuntimeException e) {
+            LOGGER.warn("Could not capture Playwright page errors", e);
+        }
+    }
+
+    /**
+     * Attaches a Playwright trace archive.
+     *
+     * @param name the attachment name.
+     * @param traceZip the path to the trace zip file.
+     */
+    public static void attachTrace(final String name, final Path traceZip) {
+        attachPath(defaultName(name, TRACE), AttachmentType.ZIP, traceZip);
+    }
+
+    /**
+     * Attaches a Playwright video file.
+     *
+     * @param name the attachment name.
+     * @param videoFile the path to the video file.
+     */
+    public static void attachVideo(final String name, final Path videoFile) {
+        attachPath(defaultName(name, VIDEO), videoType(videoFile), videoFile);
+    }
+
+    /**
+     * Starts Playwright tracing and registers the trace for failure diagnostics.
+     *
+     * @param context the browser context to trace.
+     * @return trace session that stops tracing and attaches the generated archive when closed.
+     */
+    public static TraceSession startTracing(final BrowserContext context) {
+        return startTracing(TRACE, context);
+    }
+
+    /**
+     * Starts Playwright tracing and registers the trace for failure diagnostics.
+     *
+     * @param name the attachment name to use when the trace is attached.
+     * @param context the browser context to trace.
+     * @return trace session that stops tracing and attaches the generated archive when closed.
+     */
+    public static TraceSession startTracing(final String name, final BrowserContext context) {
+        if (context == null) {
+            throw new IllegalArgumentException("context must not be null");
+        }
+        final Tracing.StartOptions options = new Tracing.StartOptions()
+                .setScreenshots(true)
+                .setSnapshots(true);
+        context.tracing().start(options);
+        final DefaultTraceSession traceSession = new DefaultTraceSession(context, defaultName(name, TRACE));
+        AllurePlaywrightRegistry.register(context);
+        AllurePlaywrightRegistry.register(traceSession);
+        return traceSession;
+    }
+
+    static CloseArtifacts beforeClose(final Object target) {
+        final CloseArtifacts closeArtifacts = new CloseArtifacts();
+        if (target instanceof Page) {
+            collectPageCloseArtifacts((Page) target, closeArtifacts);
+        } else if (target instanceof BrowserContext) {
+            collectContextCloseArtifacts((BrowserContext) target, closeArtifacts);
+        } else if (target instanceof Browser) {
+            collectBrowserCloseArtifacts((Browser) target, closeArtifacts);
+        }
+        return closeArtifacts;
+    }
+
+    static void attachScreenshotBytes(final String name, final AttachmentType type, final byte[] bytes) {
+        if (!AllurePlaywrightConfig.shouldAttachScreenshots()) {
+            return;
+        }
+        attachBytes(defaultName(name, SCREENSHOT), type, bytes);
+    }
+
+    static AttachmentType screenshotType(final Object... args) {
+        final Object options = args.length == 0 ? null : args[0];
+        if (isJpegType(options)) {
+            return AttachmentType.JPEG;
+        }
+        if (isJpegPath(options)) {
+            return AttachmentType.JPEG;
+        }
+        return AttachmentType.PNG;
+    }
+
+    static boolean hasAllureContext() {
+        return Allure.getLifecycle().getCurrentTestCaseOrStep().isPresent();
+    }
+
+    static boolean isAspectSuppressed() {
+        return SUPPRESS_ASPECT.get();
+    }
+
+    static <T> T withAspectSuppressed(final Supplier<T> supplier) {
+        final Boolean previous = SUPPRESS_ASPECT.get();
+        SUPPRESS_ASPECT.set(Boolean.TRUE);
+        try {
+            return supplier.get();
+        } finally {
+            SUPPRESS_ASPECT.set(previous);
+        }
+    }
+
+    static void clear() {
+        for (DefaultTraceSession traceSession : AllurePlaywrightRegistry.getTraceSessions()) {
+            traceSession.stopWithoutAttachment();
+        }
+        AllurePlaywrightRegistry.clear();
+    }
+
+    static void attachFailureArtifacts() {
+        if (!AllurePlaywrightRegistry.markFailureArtifactsAttached()) {
+            return;
+        }
+        if (AllurePlaywrightConfig.shouldAttachFailureScreenshot()) {
+            attachFailureScreenshots();
+        }
+        if (AllurePlaywrightConfig.shouldAttachFailurePageSource()) {
+            attachFailurePageSources();
+        }
+        attachFailureTraces();
+    }
+
+    static void attachRegisteredCloseArtifacts() {
+        if (!hasAllureContext()) {
+            return;
+        }
+        if (AllurePlaywrightConfig.shouldAttachClosePageLogs()) {
+            for (Page page : AllurePlaywrightRegistry.getPages()) {
+                attachPageCloseLogs(page);
+            }
+        }
+        if (AllurePlaywrightConfig.shouldAttachCloseTrace()) {
+            attachFailureTraces();
+        }
+    }
+
+    private static void collectBrowserCloseArtifacts(final Browser browser, final CloseArtifacts closeArtifacts) {
+        for (BrowserContext context : contexts(browser)) {
+            collectContextCloseArtifacts(context, closeArtifacts);
+        }
+    }
+
+    private static void collectContextCloseArtifacts(final BrowserContext context,
+                                                     final CloseArtifacts closeArtifacts) {
+        register(context);
+        for (Page page : pages(context)) {
+            collectPageCloseArtifacts(page, closeArtifacts);
+        }
+        if (AllurePlaywrightConfig.shouldAttachCloseTrace()) {
+            attachCloseTraces(context);
+        }
+    }
+
+    private static void collectPageCloseArtifacts(final Page page, final CloseArtifacts closeArtifacts) {
+        register(page);
+        attachPageCloseLogs(page);
+        if (AllurePlaywrightRegistry.markCloseVideoAttached(page)) {
+            closeArtifacts.addVideo(video(page));
+        }
+    }
+
+    private static void attachPageCloseLogs(final Page page) {
+        if (AllurePlaywrightConfig.shouldAttachClosePageLogs()
+                && AllurePlaywrightRegistry.markClosePageLogsAttached(page)) {
+            attachConsoleMessages(CONSOLE_MESSAGES, page);
+            attachPageErrors(PAGE_ERRORS, page);
+        }
+    }
+
+    private static void attachCloseTraces(final BrowserContext context) {
+        for (DefaultTraceSession traceSession : AllurePlaywrightRegistry.getTraceSessions(context)) {
+            traceSession.attach();
+        }
+    }
+
+    private static void attachFailureScreenshots() {
+        for (Page page : AllurePlaywrightRegistry.getPages()) {
+            attachScreenshot(SCREENSHOT, page);
+        }
+    }
+
+    private static void attachFailurePageSources() {
+        for (Page page : AllurePlaywrightRegistry.getPages()) {
+            attachPageSource(PAGE_SOURCE, page);
+        }
+    }
+
+    private static void attachFailureTraces() {
+        for (DefaultTraceSession traceSession : AllurePlaywrightRegistry.getTraceSessions()) {
+            traceSession.attach();
+        }
+    }
+
+    private static List<BrowserContext> contexts(final Browser browser) {
+        try {
+            return browser.contexts();
+        } catch (RuntimeException e) {
+            LOGGER.warn("Could not collect Playwright browser contexts", e);
+            return Collections.emptyList();
+        }
+    }
+
+    private static List<Page> pages(final BrowserContext context) {
+        try {
+            return context.pages();
+        } catch (RuntimeException e) {
+            LOGGER.warn("Could not collect Playwright pages", e);
+            return Collections.emptyList();
+        }
+    }
+
+    private static Video video(final Page page) {
+        try {
+            return page.video();
+        } catch (RuntimeException e) {
+            LOGGER.warn("Could not collect Playwright video", e);
+            return null;
+        }
+    }
+
+    private static AttachmentType videoType(final Path path) {
+        if (path == null) {
+            return AttachmentType.WEBM;
+        }
+        final String name = path.getFileName().toString().toLowerCase(Locale.ROOT);
+        if (name.endsWith(".webm")) {
+            return AttachmentType.WEBM;
+        }
+        return AttachmentType.OCTET_STREAM;
+    }
+
+    private static void attachPath(final String name, final AttachmentType type, final Path path) {
+        if (path == null || !hasAllureContext() || !Files.isRegularFile(path)) {
+            return;
+        }
+        try {
+            attachBytes(name, type, Files.readAllBytes(path));
+        } catch (IOException e) {
+            LOGGER.warn("Could not attach Playwright artifact {}", path, e);
+        }
+    }
+
+    private static void attachBytes(final String name, final AttachmentType type, final byte[] bytes) {
+        if (bytes == null || !hasAllureContext()) {
+            return;
+        }
+        final AllureLifecycle lifecycle = Allure.getLifecycle();
+        lifecycle.addAttachment(name, type.getMediaType(), type.getExtension(), bytes);
+    }
+
+    private static void attachText(final String name, final String content) {
+        if (content == null || content.isEmpty()) {
+            return;
+        }
+        attachBytes(name, AttachmentType.TEXT, content.getBytes(StandardCharsets.UTF_8));
+    }
+
+    private static String defaultName(final String name, final String fallback) {
+        return name == null || name.isEmpty() ? fallback : name;
+    }
+
+    private static boolean isJpegType(final Object options) {
+        final Object type = readField(options, "type");
+        return type != null && "JPEG".equals(type.toString());
+    }
+
+    private static boolean isJpegPath(final Object options) {
+        final Object path = readField(options, "path");
+        if (!(path instanceof Path)) {
+            return false;
+        }
+        final String name = ((Path) path).getFileName().toString().toLowerCase(Locale.ROOT);
+        return name.endsWith(".jpg") || name.endsWith(".jpeg");
+    }
+
+    private static Object readField(final Object target, final String name) {
+        if (target == null) {
+            return null;
+        }
+        try {
+            final Field field = target.getClass().getField(name);
+            return field.get(target);
+        } catch (ReflectiveOperationException ignored) {
+            return null;
+        }
+    }
+
+    @SuppressWarnings("PMD.AvoidInstantiatingObjectsInLoops")
+    private static String formatConsoleMessages(final List<ConsoleMessage> messages) {
+        if (messages == null || messages.isEmpty()) {
+            return "";
+        }
+        final StringBuilder builder = new StringBuilder();
+        for (ConsoleMessage message : messages) {
+            final String type = safe(new Supplier<String>() {
+                @Override
+                public String get() {
+                    return message.type();
+                }
+            });
+            final String text = safe(new Supplier<String>() {
+                @Override
+                public String get() {
+                    return message.text();
+                }
+            });
+            final String location = safe(new Supplier<String>() {
+                @Override
+                public String get() {
+                    return message.location();
+                }
+            });
+            builder.append('[').append(type).append("] ").append(text);
+            if (!location.isEmpty()) {
+                builder.append(" (").append(location).append(')');
+            }
+            builder.append(System.lineSeparator());
+        }
+        return builder.toString();
+    }
+
+    private static String formatLines(final List<String> lines) {
+        if (lines == null || lines.isEmpty()) {
+            return "";
+        }
+        final StringBuilder builder = new StringBuilder();
+        for (String line : lines) {
+            builder.append(line).append(System.lineSeparator());
+        }
+        return builder.toString();
+    }
+
+    private static String safe(final Supplier<String> supplier) {
+        try {
+            final String value = supplier.get();
+            return value == null ? "" : value;
+        } catch (RuntimeException ignored) {
+            return "";
+        }
+    }
+
+    static final class CloseArtifacts {
+
+        private final List<Video> videos = new ArrayList<>();
+
+        private void addVideo(final Video video) {
+            if (video != null) {
+                videos.add(video);
+            }
+        }
+
+        void attachAfterClose() {
+            if (!AllurePlaywrightConfig.shouldAttachCloseVideo()) {
+                return;
+            }
+            for (Video video : videos) {
+                attachVideo(VIDEO, path(video));
+            }
+        }
+
+        private static Path path(final Video video) {
+            try {
+                return video.path();
+            } catch (RuntimeException e) {
+                LOGGER.warn("Could not resolve Playwright video path", e);
+                return null;
+            }
+        }
+    }
+}
diff --git a/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightAspect.java b/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightAspect.java
new file mode 100644
index 00000000..5837a85a
--- /dev/null
+++ b/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightAspect.java
@@ -0,0 +1,291 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.playwright;
+
+import io.qameta.allure.Allure;
+import io.qameta.allure.AllureLifecycle;
+import io.qameta.allure.model.AttachmentType;
+import io.qameta.allure.model.Status;
+import io.qameta.allure.model.StepResult;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Pointcut;
+
+import java.util.UUID;
+import java.util.function.Supplier;
+
+import static io.qameta.allure.util.ResultsUtils.getStatus;
+import static io.qameta.allure.util.ResultsUtils.getStatusDetails;
+
+/**
+ * Aspect that logs Playwright Java browser actions as Allure steps.
+ */
+@Aspect
+public class AllurePlaywrightAspect {
+
+    private static final ThreadLocal<Integer> DEPTH = new ThreadLocal<Integer>() {
+        @Override
+        protected Integer initialValue() {
+            return 0;
+        }
+    };
+
+    private static final InheritableThreadLocal<AllureLifecycle> LIFECYCLE = new InheritableThreadLocal<AllureLifecycle>() {
+        @Override
+        protected AllureLifecycle initialValue() {
+            return Allure.getLifecycle();
+        }
+    };
+
+    @Pointcut(
+        "execution(public * com.microsoft.playwright.Page+.*(..))"
+                + " || execution(public * com.microsoft.playwright.Frame+.*(..))"
+                + " || execution(public * com.microsoft.playwright.Locator+.*(..))"
+                + " || execution(public * com.microsoft.playwright.ElementHandle+.*(..))"
+                + " || execution(public * com.microsoft.playwright.assertions.*Assertions+.*(..))"
+    )
+
+    /**
+     * Handles the playwright api callback.
+     */
+    public void playwrightApi() {
+        //pointcut body, should be empty
+    }
+
+    @Pointcut(
+        "execution(public byte[] com.microsoft.playwright.Page+.screenshot(..))"
+                + " || execution(public byte[] com.microsoft.playwright.Locator+.screenshot(..))"
+                + " || execution(public byte[] com.microsoft.playwright.ElementHandle+.screenshot(..))"
+    )
+
+    /**
+     * Handles the screenshot api callback.
+     */
+    public void screenshotApi() {
+        //pointcut body, should be empty
+    }
+
+    @Pointcut(
+        "execution(public com.microsoft.playwright.BrowserContext "
+                + "com.microsoft.playwright.Browser+.newContext(..))"
+    )
+
+    /**
+     * Handles the new context api callback.
+     */
+    public void newContextApi() {
+        //pointcut body, should be empty
+    }
+
+    @Pointcut(
+        "execution(public com.microsoft.playwright.Page com.microsoft.playwright.Browser+.newPage(..))"
+                + " || execution(public com.microsoft.playwright.Page "
+                + "com.microsoft.playwright.BrowserContext+.newPage(..))"
+    )
+
+    /**
+     * Handles the new page api callback.
+     */
+    public void newPageApi() {
+        //pointcut body, should be empty
+    }
+
+    @Pointcut(
+        "execution(public void com.microsoft.playwright.Browser+.close(..))"
+                + " || execution(public void com.microsoft.playwright.BrowserContext+.close(..))"
+                + " || execution(public void com.microsoft.playwright.Page+.close(..))"
+    )
+
+    /**
+     * Handles the close api callback.
+     */
+    public void closeApi() {
+        //pointcut body, should be empty
+    }
+
+    /**
+     * Returns the log playwright step.
+     *
+     * @param joinPoint the join point
+     * @return the log playwright step
+     * @throws Throwable if the underlying framework operation fails
+     */
+    @Around("playwrightApi() && !screenshotApi()")
+    public Object logPlaywrightStep(final ProceedingJoinPoint joinPoint) throws Throwable {
+        registerTarget(joinPoint.getTarget());
+        if (shouldSkip()) {
+            return joinPoint.proceed();
+        }
+        final PlaywrightAction action = PlaywrightAction.from(joinPoint, false);
+        if (!action.isLogged()) {
+            return joinPoint.proceed();
+        }
+        return runStep(joinPoint, action, false);
+    }
+
+    /**
+     * Returns the log screenshot step.
+     *
+     * @param joinPoint the join point
+     * @return the log screenshot step
+     * @throws Throwable if the underlying framework operation fails
+     */
+    @Around("screenshotApi()")
+    public Object logScreenshotStep(final ProceedingJoinPoint joinPoint) throws Throwable {
+        registerTarget(joinPoint.getTarget());
+        if (shouldSkip()) {
+            return joinPoint.proceed();
+        }
+        return runStep(joinPoint, PlaywrightAction.from(joinPoint, true), true);
+    }
+
+    /**
+     * Returns the register created playwright object.
+     *
+     * @param joinPoint the join point
+     * @return the register created playwright object
+     * @throws Throwable if the underlying framework operation fails
+     */
+    @Around("newContextApi() || newPageApi()")
+    public Object registerCreatedPlaywrightObject(final ProceedingJoinPoint joinPoint) throws Throwable {
+        final Object result = joinPoint.proceed();
+        if (!shouldSkipArtifacts()) {
+            register(result);
+        }
+        return result;
+    }
+
+    /**
+     * Returns the attach close artifacts.
+     *
+     * @param joinPoint the join point
+     * @return the attach close artifacts
+     * @throws Throwable if the underlying framework operation fails
+     */
+    @Around("closeApi()")
+    public Object attachCloseArtifacts(final ProceedingJoinPoint joinPoint) throws Throwable {
+        if (shouldSkipArtifacts()) {
+            return joinPoint.proceed();
+        }
+        final AllurePlaywright.CloseArtifacts closeArtifacts = beforeClose(joinPoint.getTarget());
+        final Object result = joinPoint.proceed();
+        afterClose(closeArtifacts);
+        return result;
+    }
+
+    /**
+     * For tests only.
+     *
+     * @param lifecycle allure lifecycle to set.
+     */
+    public static void setLifecycle(final AllureLifecycle lifecycle) {
+        LIFECYCLE.set(lifecycle);
+    }
+
+    /**
+     * Returns the lifecycle.
+     *
+     * @return the Allure lifecycle used by this integration
+     */
+    public static AllureLifecycle getLifecycle() {
+        return LIFECYCLE.get();
+    }
+
+    private static Object runStep(final ProceedingJoinPoint joinPoint, final PlaywrightAction action,
+                                  final boolean screenshot)
+            throws Throwable {
+        final String uuid = UUID.randomUUID().toString();
+        DEPTH.set(DEPTH.get() + 1);
+        getLifecycle().startStep(uuid, new StepResult().setName(action.getName()));
+        try {
+            final Object result = joinPoint.proceed();
+            if (screenshot && result instanceof byte[]) {
+                attachScreenshot(joinPoint, (byte[]) result);
+            }
+            getLifecycle().updateStep(uuid, step -> step.setStatus(Status.PASSED));
+            return result;
+        } catch (Throwable e) {
+            getLifecycle().updateStep(
+                    uuid, step -> step
+                            .setStatus(getStatus(e).orElse(Status.BROKEN))
+                            .setStatusDetails(getStatusDetails(e).orElse(null))
+            );
+            throw e;
+        } finally {
+            getLifecycle().stopStep(uuid);
+            DEPTH.set(DEPTH.get() - 1);
+        }
+    }
+
+    private static void attachScreenshot(final ProceedingJoinPoint joinPoint, final byte[] bytes) {
+        if (AllurePlaywrightConfig.shouldAttachScreenshots()) {
+            final AttachmentType type = AllurePlaywright.screenshotType(joinPoint.getArgs());
+            getLifecycle().addAttachment("Screenshot", type.getMediaType(), type.getExtension(), bytes);
+        }
+    }
+
+    private static void registerTarget(final Object target) {
+        if (!shouldSkipArtifacts()) {
+            register(target);
+        }
+    }
+
+    private static void register(final Object result) {
+        AllurePlaywright.withAspectSuppressed(new Supplier<Object>() {
+            @Override
+            public Object get() {
+                if (result instanceof com.microsoft.playwright.Page) {
+                    AllurePlaywrightRegistry.registerPage((com.microsoft.playwright.Page) result);
+                } else if (result instanceof com.microsoft.playwright.BrowserContext) {
+                    AllurePlaywright.register((com.microsoft.playwright.BrowserContext) result);
+                }
+                return null;
+            }
+        });
+    }
+
+    private static AllurePlaywright.CloseArtifacts beforeClose(final Object target) {
+        return AllurePlaywright.withAspectSuppressed(new Supplier<AllurePlaywright.CloseArtifacts>() {
+            @Override
+            public AllurePlaywright.CloseArtifacts get() {
+                return AllurePlaywright.beforeClose(target);
+            }
+        });
+    }
+
+    private static void afterClose(final AllurePlaywright.CloseArtifacts closeArtifacts) {
+        AllurePlaywright.withAspectSuppressed(new Supplier<Object>() {
+            @Override
+            public Object get() {
+                closeArtifacts.attachAfterClose();
+                return null;
+            }
+        });
+    }
+
+    private static boolean shouldSkip() {
+        return !AllurePlaywrightConfig.isStepsEnabled()
+                || AllurePlaywright.isAspectSuppressed()
+                || DEPTH.get() > 0
+                || !getLifecycle().getCurrentTestCaseOrStep().isPresent();
+    }
+
+    private static boolean shouldSkipArtifacts() {
+        return AllurePlaywright.isAspectSuppressed()
+                || !AllurePlaywright.hasAllureContext();
+    }
+}
diff --git a/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightConfig.java b/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightConfig.java
new file mode 100644
index 00000000..8bdf5065
--- /dev/null
+++ b/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightConfig.java
@@ -0,0 +1,97 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.playwright;
+
+import io.qameta.allure.util.PropertiesUtils;
+
+import java.util.Locale;
+import java.util.Properties;
+
+final class AllurePlaywrightConfig {
+
+    static final String STEPS_ENABLED = "allure.playwright.steps.enabled";
+    static final String STEPS_MODE = "allure.playwright.steps.mode";
+    static final String PARAMETERS = "allure.playwright.parameters";
+    static final String SCREENSHOTS_ATTACH = "allure.playwright.screenshots.attach";
+    static final String FAILURE_SCREENSHOT = "allure.playwright.failure.screenshot";
+    static final String FAILURE_PAGE_SOURCE = "allure.playwright.failure.page-source";
+    static final String CLOSE_TRACE = "allure.playwright.close.trace";
+    static final String CLOSE_VIDEO = "allure.playwright.close.video";
+    static final String CLOSE_PAGE_LOGS = "allure.playwright.close.page-logs";
+
+    private static final String ACTIONS = "actions";
+    private static final String ALL = "all";
+    private static final String REDACTED = "redacted";
+
+    private AllurePlaywrightConfig() {
+    }
+
+    static boolean isStepsEnabled() {
+        return getBoolean(STEPS_ENABLED, true);
+    }
+
+    static boolean isActionsMode() {
+        return ACTIONS.equals(getString(STEPS_MODE, ACTIONS));
+    }
+
+    static boolean isAllMode() {
+        return ALL.equals(getString(STEPS_MODE, ACTIONS));
+    }
+
+    static boolean isParametersRedacted() {
+        return REDACTED.equals(getString(PARAMETERS, REDACTED));
+    }
+
+    static boolean shouldAttachScreenshots() {
+        return getBoolean(SCREENSHOTS_ATTACH, true);
+    }
+
+    static boolean shouldAttachFailureScreenshot() {
+        return getBoolean(FAILURE_SCREENSHOT, true);
+    }
+
+    static boolean shouldAttachFailurePageSource() {
+        return getBoolean(FAILURE_PAGE_SOURCE, true);
+    }
+
+    static boolean shouldAttachCloseTrace() {
+        return getBoolean(CLOSE_TRACE, true);
+    }
+
+    static boolean shouldAttachCloseVideo() {
+        return getBoolean(CLOSE_VIDEO, true);
+    }
+
+    static boolean shouldAttachClosePageLogs() {
+        return getBoolean(CLOSE_PAGE_LOGS, true);
+    }
+
+    private static boolean getBoolean(final String key, final boolean defaultValue) {
+        return Boolean.parseBoolean(getProperties().getProperty(key, Boolean.toString(defaultValue)));
+    }
+
+    private static String getString(final String key, final String defaultValue) {
+        return getProperties()
+                .getProperty(key, defaultValue)
+                .trim()
+                .toLowerCase(Locale.ROOT);
+    }
+
+    private static Properties getProperties() {
+        return PropertiesUtils.loadAllureProperties();
+    }
+
+}
diff --git a/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightLifecycle.java b/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightLifecycle.java
new file mode 100644
index 00000000..5e1a2b91
--- /dev/null
+++ b/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightLifecycle.java
@@ -0,0 +1,49 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.playwright;
+
+import io.qameta.allure.listener.TestLifecycleListener;
+import io.qameta.allure.model.Status;
+import io.qameta.allure.model.TestResult;
+
+/**
+ * Allure lifecycle listener that attaches Playwright diagnostics for any supported test framework.
+ */
+public class AllurePlaywrightLifecycle implements TestLifecycleListener {
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void afterTestStart(final TestResult result) {
+        AllurePlaywright.beforeTest();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void beforeTestStop(final TestResult result) {
+        if (isFailed(result)) {
+            AllurePlaywright.afterTestFailure();
+        }
+        AllurePlaywright.afterTest();
+    }
+
+    private static boolean isFailed(final TestResult result) {
+        return result != null && (Status.FAILED == result.getStatus() || Status.BROKEN == result.getStatus());
+    }
+}
diff --git a/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightRegistry.java b/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightRegistry.java
new file mode 100644
index 00000000..42c3d8f1
--- /dev/null
+++ b/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightRegistry.java
@@ -0,0 +1,126 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.playwright;
+
+import com.microsoft.playwright.BrowserContext;
+import com.microsoft.playwright.Page;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Set;
+
+final class AllurePlaywrightRegistry {
+
+    private static final ThreadLocal<State> STATE = new ThreadLocal<State>() {
+        @Override
+        protected State initialValue() {
+            return new State();
+        }
+    };
+
+    private AllurePlaywrightRegistry() {
+    }
+
+    static void register(final Page page) {
+        if (page == null) {
+            return;
+        }
+        registerPage(page);
+        try {
+            register(page.context());
+        } catch (RuntimeException ignored) {
+            // The page may already be closed. Failure diagnostics must not alter test behavior.
+        }
+    }
+
+    static void register(final BrowserContext context) {
+        if (context != null) {
+            STATE.get().contexts.add(context);
+        }
+    }
+
+    static void register(final DefaultTraceSession traceSession) {
+        STATE.get().traceSessions.add(traceSession);
+    }
+
+    static void registerPage(final Page page) {
+        if (page != null) {
+            STATE.get().pages.add(page);
+        }
+    }
+
+    static Set<Page> getPages() {
+        final State state = STATE.get();
+        for (BrowserContext context : state.contexts) {
+            try {
+                state.pages.addAll(context.pages());
+            } catch (RuntimeException ignored) {
+                // The context may already be closed. Failure diagnostics must not alter test behavior.
+            }
+        }
+        return state.pages;
+    }
+
+    static Set<DefaultTraceSession> getTraceSessions() {
+        return STATE.get().traceSessions;
+    }
+
+    static List<DefaultTraceSession> getTraceSessions(final BrowserContext context) {
+        final List<DefaultTraceSession> result = new ArrayList<>();
+        for (DefaultTraceSession traceSession : STATE.get().traceSessions) {
+            if (traceSession.isFor(context)) {
+                result.add(traceSession);
+            }
+        }
+        return result;
+    }
+
+    static boolean markFailureArtifactsAttached() {
+        final State state = STATE.get();
+        if (state.failureArtifactsAttached) {
+            return false;
+        }
+        state.failureArtifactsAttached = true;
+        return true;
+    }
+
+    static boolean markClosePageLogsAttached(final Page page) {
+        return STATE.get().pagesWithCloseLogs.add(page);
+    }
+
+    static boolean markCloseVideoAttached(final Page page) {
+        return STATE.get().pagesWithCloseVideo.add(page);
+    }
+
+    static void clear() {
+        STATE.remove();
+    }
+
+    private static final class State {
+        private final Set<Page> pages = identitySet();
+        private final Set<BrowserContext> contexts = identitySet();
+        private final Set<DefaultTraceSession> traceSessions = identitySet();
+        private final Set<Page> pagesWithCloseLogs = identitySet();
+        private final Set<Page> pagesWithCloseVideo = identitySet();
+        private boolean failureArtifactsAttached;
+
+        private static <T> Set<T> identitySet() {
+            return Collections.newSetFromMap(new IdentityHashMap<T, Boolean>());
+        }
+    }
+}
diff --git a/allure-playwright/src/main/java/io/qameta/allure/playwright/DefaultTraceSession.java b/allure-playwright/src/main/java/io/qameta/allure/playwright/DefaultTraceSession.java
new file mode 100644
index 00000000..10054581
--- /dev/null
+++ b/allure-playwright/src/main/java/io/qameta/allure/playwright/DefaultTraceSession.java
@@ -0,0 +1,87 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.playwright;
+
+import com.microsoft.playwright.BrowserContext;
+import com.microsoft.playwright.Tracing;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+final class DefaultTraceSession implements TraceSession {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultTraceSession.class);
+
+    private final BrowserContext context;
+    private final String name;
+    private boolean stopped;
+
+    DefaultTraceSession(final BrowserContext context, final String name) {
+        this.context = context;
+        this.name = name;
+    }
+
+    @Override
+    public void attach() {
+        stop(true);
+    }
+
+    @Override
+    public void close() {
+        attach();
+    }
+
+    void stopWithoutAttachment() {
+        stop(false);
+    }
+
+    boolean isFor(final BrowserContext candidate) {
+        return context == candidate;
+    }
+
+    private void stop(final boolean attach) {
+        if (stopped) {
+            return;
+        }
+        stopped = true;
+        Path trace = null;
+        try {
+            trace = Files.createTempFile("allure-playwright-trace-", ".zip");
+            context.tracing().stop(new Tracing.StopOptions().setPath(trace));
+            if (attach) {
+                AllurePlaywright.attachTrace(name, trace);
+            }
+        } catch (IOException | RuntimeException e) {
+            LOGGER.warn("Could not stop Playwright tracing", e);
+        } finally {
+            delete(trace);
+        }
+    }
+
+    private static void delete(final Path path) {
+        if (path == null) {
+            return;
+        }
+        try {
+            Files.deleteIfExists(path);
+        } catch (IOException e) {
+            LOGGER.debug("Could not delete temporary Playwright trace {}", path, e);
+        }
+    }
+}
diff --git a/allure-playwright/src/main/java/io/qameta/allure/playwright/PlaywrightAction.java b/allure-playwright/src/main/java/io/qameta/allure/playwright/PlaywrightAction.java
new file mode 100644
index 00000000..f15c7755
--- /dev/null
+++ b/allure-playwright/src/main/java/io/qameta/allure/playwright/PlaywrightAction.java
@@ -0,0 +1,295 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.playwright;
+
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.reflect.MethodSignature;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
+@SuppressWarnings("PMD.GodClass")
+final class PlaywrightAction {
+
+    private static final String METHOD_NAVIGATE = "navigate";
+    private static final String METHOD_CLICK = "click";
+    private static final String METHOD_DBLCLICK = "dblclick";
+    private static final String METHOD_CHECK = "check";
+    private static final String METHOD_UNCHECK = "uncheck";
+    private static final String METHOD_TAP = "tap";
+    private static final String METHOD_FILL = "fill";
+    private static final String METHOD_CLEAR = "clear";
+    private static final String METHOD_PRESS = "press";
+    private static final String METHOD_TYPE = "type";
+    private static final String METHOD_HOVER = "hover";
+    private static final String METHOD_DRAG_TO = "dragTo";
+    private static final String METHOD_DRAG_AND_DROP = "dragAndDrop";
+    private static final String METHOD_SET_INPUT_FILES = "setInputFiles";
+    private static final String METHOD_SELECT_OPTION = "selectOption";
+    private static final String METHOD_DISPATCH_EVENT = "dispatchEvent";
+    private static final String DRAG_PREFIX = "Drag ";
+    private static final String ON = " on ";
+    private static final String ASSERTIONS_PACKAGE = ".assertions.";
+    private static final String SELECTOR = "selector";
+    private static final String LOCATOR = "locator";
+    private static final String ELEMENT = "element";
+    private static final String REDACTED = "<redacted>";
+    private static final String SPACE = " ";
+
+    private static final Set<String> ACTION_METHODS = Collections.unmodifiableSet(
+            new HashSet<String>(
+                    Arrays.asList(
+                            METHOD_NAVIGATE,
+                            METHOD_CLICK,
+                            METHOD_DBLCLICK,
+                            METHOD_CHECK,
+                            METHOD_UNCHECK,
+                            METHOD_TAP,
+                            METHOD_FILL,
+                            METHOD_CLEAR,
+                            METHOD_PRESS,
+                            METHOD_TYPE,
+                            METHOD_HOVER,
+                            METHOD_DRAG_TO,
+                            METHOD_DRAG_AND_DROP,
+                            METHOD_SET_INPUT_FILES,
+                            METHOD_SELECT_OPTION,
+                            METHOD_DISPATCH_EVENT,
+                            "focus",
+                            "blur",
+                            "setChecked",
+                            "setContent",
+                            "reload",
+                            "goBack",
+                            "goForward",
+                            "bringToFront",
+                            "close",
+                            "waitForCondition",
+                            "waitForClose",
+                            "waitForConsoleMessage",
+                            "waitForDownload",
+                            "waitForFileChooser",
+                            "waitForFunction",
+                            "waitForLoadState",
+                            "waitForNavigation",
+                            "waitForPopup",
+                            "waitForRequest",
+                            "waitForRequestFinished",
+                            "waitForResponse",
+                            "waitForSelector",
+                            "waitForTimeout",
+                            "waitForURL",
+                            "waitForWebSocket",
+                            "waitForWorker"
+                    )
+            )
+    );
+
+    private static final Map<String, String> ACTION_PREFIXES = createActionPrefixes();
+
+    private static final Set<String> IGNORED_METHODS = Collections.unmodifiableSet(
+            new HashSet<String>(
+                    Arrays.asList(
+                            "equals",
+                            "hashCode",
+                            "toString",
+                            "not"
+                    )
+            )
+    );
+
+    private final boolean logged;
+    private final String name;
+
+    private PlaywrightAction(final boolean logged, final String name) {
+        this.logged = logged;
+        this.name = name;
+    }
+
+    boolean isLogged() {
+        return logged;
+    }
+
+    String getName() {
+        return name;
+    }
+
+    static PlaywrightAction from(final JoinPoint joinPoint, final boolean screenshot) {
+        final MethodSignature signature = (MethodSignature) joinPoint.getSignature();
+        final String method = signature.getName();
+        if (screenshot) {
+            return new PlaywrightAction(true, "Take screenshot");
+        }
+        if (!shouldLog(joinPoint, method)) {
+            return new PlaywrightAction(false, method);
+        }
+        return new PlaywrightAction(true, name(joinPoint, method));
+    }
+
+    private static boolean shouldLog(final JoinPoint joinPoint, final String method) {
+        if (IGNORED_METHODS.contains(method)) {
+            return false;
+        }
+        if (AllurePlaywrightConfig.isAllMode()) {
+            return true;
+        }
+        return isAssertion(joinPoint) || ACTION_METHODS.contains(method);
+    }
+
+    private static String name(final JoinPoint joinPoint, final String method) {
+        final String result;
+        if (isAssertion(joinPoint)) {
+            result = "Expect " + target(joinPoint) + SPACE + method;
+        } else if (METHOD_NAVIGATE.equals(method)) {
+            result = "Navigate to " + arg(joinPoint, 0, "url");
+        } else if (METHOD_FILL.equals(method)) {
+            result = "Fill " + target(joinPoint) + " with " + secret(joinPoint, 1);
+        } else if (METHOD_PRESS.equals(method)) {
+            result = "Press " + secret(joinPoint, 0) + ON + target(joinPoint);
+        } else if (METHOD_TYPE.equals(method)) {
+            result = "Type " + secret(joinPoint, 1) + " into " + target(joinPoint);
+        } else if (METHOD_DISPATCH_EVENT.equals(method)) {
+            result = "Dispatch " + arg(joinPoint, 1, "event") + ON + target(joinPoint);
+        } else {
+            result = prefix(method) + target(joinPoint);
+        }
+        return result;
+    }
+
+    private static String prefix(final String method) {
+        final String prefix = ACTION_PREFIXES.get(method);
+        return prefix == null ? humanize(method) + SPACE : prefix;
+    }
+
+    private static Map<String, String> createActionPrefixes() {
+        final Map<String, String> prefixes = new HashMap<>();
+        prefixes.put(METHOD_CLICK, "Click ");
+        prefixes.put(METHOD_DBLCLICK, "Double click ");
+        prefixes.put(METHOD_HOVER, "Hover ");
+        prefixes.put(METHOD_DRAG_TO, DRAG_PREFIX);
+        prefixes.put(METHOD_DRAG_AND_DROP, DRAG_PREFIX);
+        prefixes.put(METHOD_SET_INPUT_FILES, "Set input files for ");
+        prefixes.put(METHOD_SELECT_OPTION, "Select option in ");
+        return Collections.unmodifiableMap(prefixes);
+    }
+
+    private static boolean isAssertion(final JoinPoint joinPoint) {
+        final String name = joinPoint.getSignature().getDeclaringTypeName();
+        final String targetName = joinPoint.getTarget() == null ? "" : joinPoint.getTarget().getClass().getName();
+        return name.contains(ASSERTIONS_PACKAGE) || targetName.contains(ASSERTIONS_PACKAGE);
+    }
+
+    private static String target(final JoinPoint joinPoint) {
+        final Object[] args = joinPoint.getArgs();
+        if (args.length > 0 && args[0] instanceof String) {
+            return String.valueOf(args[0]);
+        }
+        final String locator = locatorDescription(joinPoint.getTarget());
+        if (locator != null && !locator.isEmpty()) {
+            return locator;
+        }
+        return targetKind(joinPoint);
+    }
+
+    private static String targetKind(final JoinPoint joinPoint) {
+        final String simpleName = joinPoint.getSignature().getDeclaringType().getSimpleName();
+        if (simpleName.contains("Locator")) {
+            return LOCATOR;
+        }
+        if (simpleName.contains("Element")) {
+            return ELEMENT;
+        }
+        return simpleName.toLowerCase(Locale.ROOT);
+    }
+
+    private static String arg(final JoinPoint joinPoint, final int index, final String fallback) {
+        final Object[] args = joinPoint.getArgs();
+        if (index >= args.length || args[index] == null) {
+            return fallback;
+        }
+        return String.valueOf(args[index]);
+    }
+
+    private static String secret(final JoinPoint joinPoint, final int index) {
+        if (AllurePlaywrightConfig.isParametersRedacted()) {
+            return REDACTED;
+        }
+        return arg(joinPoint, index, REDACTED);
+    }
+
+    private static String humanize(final String method) {
+        final StringBuilder builder = new StringBuilder();
+        for (int i = 0; i < method.length(); i++) {
+            final char ch = method.charAt(i);
+            if (Character.isUpperCase(ch)) {
+                builder.append(' ').append(Character.toLowerCase(ch));
+            } else {
+                builder.append(ch);
+            }
+        }
+        builder.setCharAt(0, Character.toUpperCase(builder.charAt(0)));
+        return builder.toString();
+    }
+
+    private static String locatorDescription(final Object target) {
+        final String description = invokeDescription(target);
+        if (description != null && !description.isEmpty()) {
+            return description;
+        }
+        return readSelector(target);
+    }
+
+    private static String invokeDescription(final Object target) {
+        if (target == null) {
+            return null;
+        }
+        try {
+            final Method method = target.getClass().getMethod("description");
+            final Object value = method.invoke(target);
+            return value == null ? null : String.valueOf(value);
+        } catch (ReflectiveOperationException ignored) {
+            return null;
+        }
+    }
+
+    @SuppressWarnings("PMD.AvoidAccessibilityAlteration")
+    private static String readSelector(final Object target) {
+        if (target == null) {
+            return null;
+        }
+        Class<?> type = target.getClass();
+        while (type != null) {
+            try {
+                final Field field = type.getDeclaredField(SELECTOR);
+                field.setAccessible(true);
+                final Object value = field.get(target);
+                return value == null ? null : String.valueOf(value);
+            } catch (NoSuchFieldException e) {
+                type = type.getSuperclass();
+            } catch (ReflectiveOperationException e) {
+                return null;
+            }
+        }
+        return null;
+    }
+}
diff --git a/allure-playwright/src/main/java/io/qameta/allure/playwright/TraceSession.java b/allure-playwright/src/main/java/io/qameta/allure/playwright/TraceSession.java
new file mode 100644
index 00000000..5085a8fe
--- /dev/null
+++ b/allure-playwright/src/main/java/io/qameta/allure/playwright/TraceSession.java
@@ -0,0 +1,33 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.playwright;
+
+/**
+ * Playwright trace session started through {@link AllurePlaywright#startTracing}.
+ */
+public interface TraceSession extends AutoCloseable {
+
+    /**
+     * Stops tracing and attaches the generated trace archive.
+     */
+    void attach();
+
+    /**
+     * Stops tracing and attaches the generated trace archive.
+     */
+    @Override
+    void close();
+}
diff --git a/allure-playwright/src/main/resources/META-INF/aop-ajc.xml b/allure-playwright/src/main/resources/META-INF/aop-ajc.xml
new file mode 100644
index 00000000..62e24509
--- /dev/null
+++ b/allure-playwright/src/main/resources/META-INF/aop-ajc.xml
@@ -0,0 +1,6 @@
+<aspectj>
+    <weaver options="-warn:none -Xlint:ignore"/>
+    <aspects>
+        <aspect name="io.qameta.allure.playwright.AllurePlaywrightAspect"/>
+    </aspects>
+</aspectj>
diff --git a/allure-playwright/src/main/resources/META-INF/services/io.qameta.allure.listener.TestLifecycleListener b/allure-playwright/src/main/resources/META-INF/services/io.qameta.allure.listener.TestLifecycleListener
new file mode 100644
index 00000000..1f0ef821
--- /dev/null
+++ b/allure-playwright/src/main/resources/META-INF/services/io.qameta.allure.listener.TestLifecycleListener
@@ -0,0 +1 @@
+io.qameta.allure.playwright.AllurePlaywrightLifecycle
diff --git a/allure-playwright/src/test/java/io/qameta/allure/playwright/AllurePlaywrightTest.java b/allure-playwright/src/test/java/io/qameta/allure/playwright/AllurePlaywrightTest.java
new file mode 100644
index 00000000..62fb8e99
--- /dev/null
+++ b/allure-playwright/src/test/java/io/qameta/allure/playwright/AllurePlaywrightTest.java
@@ -0,0 +1,649 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.playwright;
+
+import com.microsoft.playwright.Browser;
+import com.microsoft.playwright.BrowserContext;
+import com.microsoft.playwright.BrowserType;
+import com.microsoft.playwright.Page;
+import com.microsoft.playwright.Playwright;
+import com.microsoft.playwright.PlaywrightException;
+import io.qameta.allure.Allure;
+import io.qameta.allure.AllureLifecycle;
+import io.qameta.allure.Description;
+import io.qameta.allure.Param;
+import io.qameta.allure.Step;
+import io.qameta.allure.model.Attachment;
+import io.qameta.allure.model.Status;
+import io.qameta.allure.model.StatusDetails;
+import io.qameta.allure.model.StepResult;
+import io.qameta.allure.model.TestResult;
+import io.qameta.allure.test.AllureFeatures;
+import io.qameta.allure.test.AllureResults;
+import io.qameta.allure.test.AllureResultsWriterStub;
+import io.qameta.allure.test.AllureTestCommonsUtils;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.api.parallel.ResourceLock;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static io.qameta.allure.model.Parameter.Mode.HIDDEN;
+import static io.qameta.allure.util.ResultsUtils.getStatus;
+import static io.qameta.allure.util.ResultsUtils.getStatusDetails;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.tuple;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
+import static org.junit.jupiter.api.parallel.ResourceAccessMode.READ_WRITE;
+
+@ResourceLock(
+        value = "io.qameta.allure.playwright.lifecycle",
+        mode = READ_WRITE
+)
+class AllurePlaywrightTest {
+
+    private static final byte[] PNG_HEADER = new byte[]{(byte) 0x89, 'P', 'N', 'G'};
+    private static final byte[] ZIP_HEADER = new byte[]{'P', 'K'};
+    private static final String FAILURE_HTML = "<html><body><h1>Failure diagnostics</h1></body></html>";
+
+    private static Playwright playwright;
+    private static Browser browser;
+
+    private final List<BrowserContext> contexts = new ArrayList<>();
+
+    @BeforeAll
+    static void startBrowser() {
+        try {
+            playwright = Playwright.create();
+            browser = playwright.chromium().launch(
+                    new BrowserType.LaunchOptions()
+                            .setHeadless(true)
+                            .setArgs(Collections.singletonList("--no-sandbox"))
+            );
+        } catch (PlaywrightException e) {
+            closeBrowser();
+            assumeTrue(false, "Chromium is not available for Playwright integration tests: " + e.getMessage());
+        }
+    }
+
+    @AfterAll
+    static void closeBrowser() {
+        if (browser != null) {
+            close(browser::close);
+        }
+        if (playwright != null) {
+            close(playwright::close);
+        }
+        browser = null;
+        playwright = null;
+    }
+
+    @AfterEach
+    void clearRegistry() {
+        for (BrowserContext context : contexts) {
+            close(context::close);
+        }
+        contexts.clear();
+        AllurePlaywright.clear();
+    }
+
+    /**
+     * Checks that a real Playwright browser action is reported as an Allure step.
+     *
+     * The test clicks a button on a Chromium page and verifies that the aspect records one passed action step with the
+     * expected human-readable name.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Steps
+    @Test
+    void shouldLogPlaywrightActionSteps() {
+        final Page page = newPageWithContent("<button>Save</button>");
+
+        final AllureResults results = runWithPlaywrightContext(() -> page.click("button"));
+
+        assertThat(results.getTestResults())
+                .flatExtracting(TestResult::getSteps)
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactly(tuple("Click button", Status.PASSED));
+    }
+
+    /**
+     * Checks that Playwright action steps are nested under user-created Allure runtime steps.
+     *
+     * The test wraps a real Playwright click in {@code Allure.step(...)} and verifies that Allure keeps the user step as
+     * the parent while reporting the Playwright action as its child step.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Steps
+    @Test
+    void shouldNestPlaywrightActionStepsInsideRuntimeSteps() {
+        final Page page = newPageWithContent("<button>Pay</button>");
+
+        final AllureResults results = runWithPlaywrightContext(
+                () -> Allure.step("Checkout flow", () -> page.click("button"))
+        );
+
+        final StepResult step = results.getTestResults().iterator().next().getSteps().iterator().next();
+        assertThat(step)
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactly("Checkout flow", Status.PASSED);
+        assertThat(step.getSteps())
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactly(tuple("Click button", Status.PASSED));
+    }
+
+    /**
+     * Checks that sensitive action parameters are redacted in generated step names.
+     *
+     * The test fills an input with a real value and verifies that the reported Playwright step contains the selector but
+     * replaces the typed value with the configured redaction marker.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Steps
+    @Test
+    void shouldRedactTypedValuesInActionStepNames() {
+        final Page page = newPageWithContent("<input id='password'>");
+
+        final AllureResults results = runWithPlaywrightContext(() -> page.fill("#password", "secret"));
+
+        assertThat(results.getTestResults())
+                .flatExtracting(TestResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly("Fill #password with <redacted>");
+    }
+
+    /**
+     * Checks that Playwright action failures keep their original exception details in Allure.
+     *
+     * The test clicks a missing element with a short timeout and verifies that the reported action step is marked broken
+     * and includes the Playwright failure message.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Steps
+    @Test
+    void shouldPreservePlaywrightActionFailures() {
+        final Page page = newPageWithContent("<button>Present</button>");
+
+        final AllureResults results = runWithPlaywrightContext(
+                () -> page.click("#missing", new Page.ClickOptions().setTimeout(100))
+        );
+
+        final StepResult step = results.getTestResults().iterator().next().getSteps().iterator().next();
+        assertThat(step)
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactly("Click #missing", Status.BROKEN);
+        assertThat(message(step.getStatusDetails()))
+                .contains("#missing");
+    }
+
+    /**
+     * Checks that user-created Playwright screenshots are attached automatically.
+     *
+     * The test calls the real {@code Page.screenshot(...)} API and verifies that the returned bytes are attached to the
+     * screenshot step without changing the value returned to the test.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachUserScreenshotsAutomatically() {
+        final AtomicReference<byte[]> screenshot = new AtomicReference<>();
+        final Page page = newPageWithContent("<main style='width: 100px; height: 40px'>Screenshot</main>");
+
+        final AllureResults results = runWithPlaywrightContext(
+                () -> screenshot.set(page.screenshot(new Page.ScreenshotOptions()))
+        );
+
+        final StepResult step = results.getTestResults().iterator().next().getSteps().iterator().next();
+        final Attachment attachment = step.getAttachments().iterator().next();
+
+        assertThat(step)
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactly("Take screenshot", Status.PASSED);
+        assertThat(attachment)
+                .extracting(Attachment::getName, Attachment::getType)
+                .containsExactly("Screenshot", "image/png");
+        assertAttachmentContent(results, screenshot.get());
+    }
+
+    /**
+     * Checks that the public screenshot helper attaches a page image without creating an extra action step.
+     *
+     * The helper suppresses the Playwright aspect while it captures the screenshot, so the test verifies that only the
+     * attachment is written and the generated PNG bytes are present in Allure results.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachScreenshotThroughHelperWithoutDuplicateAspectAttachment() {
+        final Page page = newPageWithContent("<main style='width: 100px; height: 40px'>Current page</main>");
+
+        final AllureResults results = runWithPlaywrightContext(
+                () -> AllurePlaywright.attachScreenshot("Current page", page)
+        );
+
+        assertThat(results.getTestResults())
+                .flatExtracting(TestResult::getSteps)
+                .isEmpty();
+        assertThat(results.getAttachments())
+                .hasSize(1);
+        assertAttachmentStartsWith(results, PNG_HEADER);
+    }
+
+    /**
+     * Checks that explicitly registered pages produce failure diagnostics.
+     *
+     * The test registers a real page, invokes the failure hook, and verifies that Allure receives both a screenshot and
+     * the current page source for the failed test.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachFailureDiagnosticsForRegisteredPages() {
+        final Page page = newPageWithContent(FAILURE_HTML);
+
+        final AllureResults results = runWithPlaywrightContext(() -> {
+            AllurePlaywright.register(page);
+            AllurePlaywright.afterTestFailure(new AssertionError("boom"));
+        });
+
+        assertFailureDiagnostics(results);
+    }
+
+    /**
+     * Checks that the Allure test lifecycle listener attaches diagnostics for failed tests.
+     *
+     * The test marks the current Allure test as failed and verifies that the Playwright lifecycle hook adds screenshot
+     * and page source artifacts before the test result is written.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachFailureDiagnosticsFromAllureLifecycle() {
+        final Page page = newPageWithContent(FAILURE_HTML);
+
+        final AllureResults results = runWithPlaywrightContext(() -> {
+            AllurePlaywright.register(page);
+            Allure.getLifecycle().updateTestCase(testResult -> testResult.setStatus(Status.FAILED));
+        });
+
+        assertFailureDiagnostics(results);
+    }
+
+    /**
+     * Checks that pages touched by reported Playwright actions are registered automatically.
+     *
+     * The test performs a real click, triggers failure diagnostics, and verifies that the page observed by the aspect is
+     * used for screenshot and page source attachments.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldRegisterPageWhenPlaywrightActionIsReported() {
+        final Page page = newPageWithContent("<button>Attach diagnostics</button>" + FAILURE_HTML);
+
+        final AllureResults results = runWithPlaywrightContext(() -> {
+            page.click("button");
+            AllurePlaywright.afterTestFailure(new AssertionError("boom"));
+        });
+
+        assertFailureDiagnostics(results);
+    }
+
+    /**
+     * Checks that pages created through Playwright contexts are registered automatically.
+     *
+     * The test creates a page from a real browser context, triggers failure diagnostics, and verifies that the created
+     * page contributes screenshot and page source artifacts even without manual registration.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldRegisterCreatedPagesAutomatically() {
+        final AllureResults results = runWithPlaywrightContext(() -> {
+            final BrowserContext context = newContext();
+            final Page page = context.newPage();
+            AllurePlaywright.withAspectSuppressed(() -> {
+                page.setContent(FAILURE_HTML);
+                return null;
+            });
+            AllurePlaywright.afterTestFailure(new AssertionError("boom"));
+        });
+
+        assertFailureDiagnostics(results);
+    }
+
+    /**
+     * Checks that a tracing session attaches its trace archive when closed.
+     *
+     * The test starts Playwright tracing on a real context, performs browser activity, closes the returned session, and
+     * verifies that Allure receives a zip trace attachment.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachTraceWhenSessionIsClosed() {
+        final BrowserContext context = newContext();
+        final Page page = context.newPage();
+
+        final AllureResults results = runWithPlaywrightContext(() -> {
+            final TraceSession traceSession = AllurePlaywright.startTracing("Trace", context);
+            page.setContent("<button>Trace</button>");
+            page.click("button");
+            traceSession.close();
+        });
+
+        assertThat(results.getAttachments())
+                .hasSize(1);
+        assertAttachmentStartsWith(results, ZIP_HEADER);
+    }
+
+    /**
+     * Checks that registered tracing is attached when a browser context closes.
+     *
+     * The test starts tracing, closes the real Playwright context, and verifies that the close hook stops tracing and
+     * writes the generated trace archive to Allure.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachTraceWhenContextIsClosed() {
+        final BrowserContext context = newContext();
+        final Page page = context.newPage();
+
+        final AllureResults results = runWithPlaywrightContext(() -> {
+            AllurePlaywright.startTracing("Trace", context);
+            page.setContent("<button>Trace</button>");
+            context.close();
+        });
+
+        assertThat(results.getAttachments())
+                .hasSize(1);
+        assertAttachmentStartsWith(results, ZIP_HEADER);
+    }
+
+    /**
+     * Checks that unfinished tracing sessions are attached during Allure test shutdown.
+     *
+     * The test leaves an active Playwright trace open and verifies that the Allure lifecycle hook stops it and attaches
+     * the generated trace archive before clearing per-test state.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachTraceWhenAllureLifecycleStopsTest() {
+        final BrowserContext context = newContext();
+        final Page page = context.newPage();
+
+        final AllureResults results = runWithPlaywrightContext(() -> {
+            AllurePlaywright.startTracing("Trace", context);
+            page.setContent("<button>Trace</button>");
+        });
+
+        assertThat(results.getAttachments())
+                .hasSize(1);
+        assertAttachmentStartsWith(results, ZIP_HEADER);
+    }
+
+    /**
+     * Checks that page console messages and page errors are attached when a context closes.
+     *
+     * The test emits a browser console error and an uncaught page error, closes the real context, and verifies that both
+     * diagnostic text attachments are present.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachPageLogsWhenContextIsClosed() {
+        final BrowserContext context = newContext();
+        final Page page = context.newPage();
+
+        final AllureResults results = runWithPlaywrightContext(() -> {
+            page.setContent(
+                    "<script>"
+                            + "console.error('console boom');"
+                            + "setTimeout(() => { throw new Error('page boom'); }, 0);"
+                            + "</script>"
+            );
+            page.waitForTimeout(250);
+            context.close();
+        });
+
+        assertThat(results.getAttachments())
+                .hasSize(2);
+        assertTextAttachmentContent(results, "console boom");
+        assertTextAttachmentContent(results, "page boom");
+    }
+
+    /**
+     * Checks that Playwright-recorded videos are attached when a video context closes.
+     *
+     * The test enables video recording on a real context, closes it after page activity, and verifies that exactly one
+     * non-empty video attachment is written.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachVideoWhenContextIsClosed(@TempDir final Path videoDir) {
+        final BrowserContext context = newVideoContext(videoDir);
+        final Page page = context.newPage();
+
+        final AllureResults results = runWithPlaywrightContext(() -> {
+            page.setContent("<h1>Video</h1>");
+            page.waitForTimeout(100);
+            context.close();
+        });
+
+        assertThat(results.getAttachments())
+                .hasSize(1);
+        assertThat(results.getAttachments().values())
+                .anySatisfy(actual -> assertThat(actual).isNotEmpty());
+    }
+
+    /**
+     * Checks that the public video helper attaches an existing video file.
+     *
+     * The test writes a temporary WebM file, passes it to {@code AllurePlaywright.attachVideo(...)}, and verifies that
+     * the exact file bytes are stored as an Allure attachment.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachVideoFile(@TempDir final Path tempDir) throws IOException {
+        final byte[] video = "video".getBytes(StandardCharsets.UTF_8);
+        final Path path = tempDir.resolve("video.webm");
+        Files.write(path, video);
+
+        final AllureResults results = runWithPlaywrightContext(() -> AllurePlaywright.attachVideo("Video", path));
+
+        assertThat(results.getAttachments())
+                .hasSize(1);
+        assertAttachmentContent(results, video);
+    }
+
+    /**
+     * Checks that helper attachments are ignored when no Allure test or step is active.
+     *
+     * The test installs a lifecycle without a running test, calls the video helper, and verifies that no attachment is
+     * written outside an Allure context.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldIgnoreMissingAllureContext(@TempDir final Path tempDir) throws IOException {
+        final byte[] video = "video".getBytes(StandardCharsets.UTF_8);
+        final Path path = tempDir.resolve("video.webm");
+        Files.write(path, video);
+
+        final AllureResultsWriterStub writer = runWithoutAllureContext(
+                () -> AllurePlaywright.attachVideo("Video", path)
+        );
+
+        assertThat(writer.getAttachments())
+                .isEmpty();
+    }
+
+    @Step("Create Playwright page with HTML content")
+    private Page newPageWithContent(@Param(mode = HIDDEN) final String html) {
+        final Page page = newContext().newPage();
+        page.setContent(html);
+        return page;
+    }
+
+    @Step("Create Playwright browser context")
+    private BrowserContext newContext() {
+        final BrowserContext context = browser.newContext();
+        contexts.add(context);
+        return context;
+    }
+
+    @Step("Create Playwright browser context with video recording")
+    private BrowserContext newVideoContext(final Path videoDir) {
+        final BrowserContext context = browser.newContext(new Browser.NewContextOptions().setRecordVideoDir(videoDir));
+        contexts.add(context);
+        return context;
+    }
+
+    @Step("Close Playwright resource")
+    private static void close(@Param(mode = HIDDEN) final Runnable close) {
+        try {
+            AllurePlaywright.withAspectSuppressed(() -> {
+                close.run();
+                return null;
+            });
+        } catch (RuntimeException ignored) {
+            // The test may have already closed this Playwright resource.
+        }
+    }
+
+    @Step("Run Playwright adapter scenario")
+    private static AllureResults runWithPlaywrightContext(@Param(mode = HIDDEN) final Runnable runnable) {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        final AllureLifecycle lifecycle = new AllureLifecycle(writer);
+        final AllureLifecycle defaultLifecycle = Allure.getLifecycle();
+        final AllureLifecycle defaultAspectLifecycle = AllurePlaywrightAspect.getLifecycle();
+        try {
+            Allure.setLifecycle(lifecycle);
+            AllurePlaywrightAspect.setLifecycle(lifecycle);
+            runSyntheticTest(runnable, lifecycle);
+            return writer;
+        } finally {
+            Allure.setLifecycle(defaultLifecycle);
+            AllurePlaywrightAspect.setLifecycle(defaultAspectLifecycle);
+            attachResults(writer);
+        }
+    }
+
+    @Step("Run helper without active Allure context")
+    private static AllureResultsWriterStub runWithoutAllureContext(@Param(mode = HIDDEN) final Runnable runnable) {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        final AllureLifecycle lifecycle = new AllureLifecycle(writer);
+        final AllureLifecycle defaultLifecycle = Allure.getLifecycle();
+        final AllureLifecycle defaultAspectLifecycle = AllurePlaywrightAspect.getLifecycle();
+        try {
+            Allure.setLifecycle(lifecycle);
+            AllurePlaywrightAspect.setLifecycle(lifecycle);
+            runnable.run();
+            return writer;
+        } finally {
+            Allure.setLifecycle(defaultLifecycle);
+            AllurePlaywrightAspect.setLifecycle(defaultAspectLifecycle);
+            attachResults(writer);
+        }
+    }
+
+    private static void runSyntheticTest(final Runnable runnable, final AllureLifecycle lifecycle) {
+        final String uuid = UUID.randomUUID().toString();
+        final TestResult result = new TestResult().setUuid(uuid);
+        try {
+            lifecycle.scheduleTestCase(result);
+            lifecycle.startTestCase(uuid);
+            runnable.run();
+        } catch (Throwable e) {
+            lifecycle.updateTestCase(uuid, testResult -> {
+                getStatus(e).ifPresent(testResult::setStatus);
+                getStatusDetails(e).ifPresent(testResult::setStatusDetails);
+            });
+        } finally {
+            lifecycle.stopTestCase(uuid);
+            lifecycle.writeTestCase(uuid);
+        }
+    }
+
+    @Step("Attach collected Allure results")
+    private static void attachResults(@Param(mode = HIDDEN) final AllureResults results) {
+        AllureTestCommonsUtils.attach(results);
+    }
+
+    @Step("Assert failure diagnostics attachments")
+    private static void assertFailureDiagnostics(@Param(mode = HIDDEN) final AllureResults results) {
+        assertThat(attachments(results))
+                .extracting(Attachment::getName, Attachment::getType)
+                .contains(
+                        tuple("Screenshot", "image/png"),
+                        tuple("Page source", "text/html")
+                );
+        assertAttachmentStartsWith(results, PNG_HEADER);
+        assertTextAttachmentContent(results, "Failure diagnostics");
+    }
+
+    private static List<Attachment> attachments(final AllureResults results) {
+        final List<Attachment> attachments = new ArrayList<>();
+        for (TestResult testResult : results.getTestResults()) {
+            attachments.addAll(testResult.getAttachments());
+            for (StepResult step : testResult.getSteps()) {
+                attachments.addAll(step.getAttachments());
+            }
+        }
+        return attachments;
+    }
+
+    @Step("Assert exact attachment payload")
+    private static void assertAttachmentContent(@Param(mode = HIDDEN) final AllureResults results,
+                                                @Param(mode = HIDDEN) final byte[] expected) {
+        assertThat(results.getAttachments().values())
+                .anySatisfy(actual -> assertThat(actual).containsExactly(expected));
+    }
+
+    @Step("Assert attachment payload prefix")
+    private static void assertAttachmentStartsWith(@Param(mode = HIDDEN) final AllureResults results,
+                                                   @Param(mode = HIDDEN) final byte[] expected) {
+        assertThat(results.getAttachments().values())
+                .anySatisfy(actual -> assertThat(actual).startsWith(expected));
+    }
+
+    private static String message(final StatusDetails statusDetails) {
+        return statusDetails == null ? null : statusDetails.getMessage();
+    }
+
+    @Step("Assert text attachment contains {expected}")
+    private static void assertTextAttachmentContent(@Param(mode = HIDDEN) final AllureResults results,
+                                                    final String expected) {
+        assertThat(results.getAttachments().values())
+                .map(actual -> new String(actual, StandardCharsets.UTF_8))
+                .anySatisfy(actual -> assertThat(actual).contains(expected));
+    }
+}
diff --git a/allure-playwright/src/test/resources/allure.properties b/allure-playwright/src/test/resources/allure.properties
new file mode 100644
index 00000000..e3a692e0
--- /dev/null
+++ b/allure-playwright/src/test/resources/allure.properties
@@ -0,0 +1,3 @@
+allure.model.indentOutput=true
+allure.results.directory=build/allure-results
+allure.label.module=allure-playwright
diff --git a/allure-reader/build.gradle.kts b/allure-reader/build.gradle.kts
index 432fd815..6d05533e 100644
--- a/allure-reader/build.gradle.kts
+++ b/allure-reader/build.gradle.kts
@@ -7,6 +7,7 @@ dependencies {
     testImplementation("org.junit.jupiter:junit-jupiter-api")
     testImplementation("org.mockito:mockito-core")
     testImplementation("org.slf4j:slf4j-simple")
+    testImplementation(project(":allure-junit-platform"))
     testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
 }
 
diff --git a/allure-reader/src/main/java/io/qameta/allure/reader/AllureEnumDeserializer.java b/allure-reader/src/main/java/io/qameta/allure/reader/AllureEnumDeserializer.java
index 037cf28a..d5e85b74 100644
--- a/allure-reader/src/main/java/io/qameta/allure/reader/AllureEnumDeserializer.java
+++ b/allure-reader/src/main/java/io/qameta/allure/reader/AllureEnumDeserializer.java
@@ -25,7 +25,6 @@
 
 /**
  * @param <T> the enum's type
- * @author charlie (Dmitry Baev).
  * @deprecated in favor of {@link com.fasterxml.jackson.databind.MapperFeature#ACCEPT_CASE_INSENSITIVE_ENUMS}
  * and {@link com.fasterxml.jackson.databind.DeserializationFeature#READ_UNKNOWN_ENUM_VALUES_AS_NULL}
  */
@@ -41,7 +40,8 @@ protected AllureEnumDeserializer(final Class<T> vc) {
 
     @Override
     public T deserialize(final JsonParser p,
-                         final DeserializationContext ctxt) throws IOException {
+                         final DeserializationContext ctxt)
+            throws IOException {
         final String value = p.readValueAs(String.class);
         if (Objects.isNull(value)) {
             return null;
diff --git a/allure-reader/src/main/java/io/qameta/allure/reader/AllureObjectMapperFactory.java b/allure-reader/src/main/java/io/qameta/allure/reader/AllureObjectMapperFactory.java
index d516eda0..ac71fe42 100644
--- a/allure-reader/src/main/java/io/qameta/allure/reader/AllureObjectMapperFactory.java
+++ b/allure-reader/src/main/java/io/qameta/allure/reader/AllureObjectMapperFactory.java
@@ -21,7 +21,9 @@
 import com.fasterxml.jackson.databind.json.JsonMapper;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Integrates Allure result reader with Allure reporting.
+ *
+ * <p>Register this type through the standard Allure result reader extension, listener, interceptor, or plugin mechanism so framework execution events are written to Allure results. Use explicit dependencies when embedding the integration in tests or custom runtimes.</p>
  */
 public final class AllureObjectMapperFactory {
 
@@ -29,6 +31,11 @@ private AllureObjectMapperFactory() {
         throw new IllegalStateException("do not instance");
     }
 
+    /**
+     * Creates and returns the mapper.
+     *
+     * @return the mapper
+     */
     public static ObjectMapper createMapper() {
         return JsonMapper.builder()
                 .enable(MapperFeature.USE_WRAPPER_NAME_AS_PROPERTY_NAME)
diff --git a/allure-reader/src/main/java/io/qameta/allure/reader/ParameterModeDeserializer.java b/allure-reader/src/main/java/io/qameta/allure/reader/ParameterModeDeserializer.java
index 4e5fb9aa..643af8be 100644
--- a/allure-reader/src/main/java/io/qameta/allure/reader/ParameterModeDeserializer.java
+++ b/allure-reader/src/main/java/io/qameta/allure/reader/ParameterModeDeserializer.java
@@ -18,12 +18,15 @@
 import io.qameta.allure.model.Parameter;
 
 /**
- * @author charlie (Dmitry Baev).
  * @deprecated in favor of {@link com.fasterxml.jackson.databind.MapperFeature#ACCEPT_CASE_INSENSITIVE_ENUMS}
  * and {@link com.fasterxml.jackson.databind.DeserializationFeature#READ_UNKNOWN_ENUM_VALUES_AS_NULL}
  */
 @Deprecated
 public class ParameterModeDeserializer extends AllureEnumDeserializer<Parameter.Mode> {
+
+    /**
+     * Creates a parameter mode deserializer with default configuration.
+     */
     public ParameterModeDeserializer() {
         super(Parameter.Mode.class);
     }
diff --git a/allure-reader/src/main/java/io/qameta/allure/reader/StageDeserializer.java b/allure-reader/src/main/java/io/qameta/allure/reader/StageDeserializer.java
index a99be6c9..240c2979 100644
--- a/allure-reader/src/main/java/io/qameta/allure/reader/StageDeserializer.java
+++ b/allure-reader/src/main/java/io/qameta/allure/reader/StageDeserializer.java
@@ -18,12 +18,15 @@
 import io.qameta.allure.model.Stage;
 
 /**
- * @author charlie (Dmitry Baev).
  * @deprecated in favor of {@link com.fasterxml.jackson.databind.MapperFeature#ACCEPT_CASE_INSENSITIVE_ENUMS}
  * and {@link com.fasterxml.jackson.databind.DeserializationFeature#READ_UNKNOWN_ENUM_VALUES_AS_NULL}
  */
 @Deprecated
 public class StageDeserializer extends AllureEnumDeserializer<Stage> {
+
+    /**
+     * Creates a stage deserializer with default configuration.
+     */
     public StageDeserializer() {
         super(Stage.class);
     }
diff --git a/allure-reader/src/main/java/io/qameta/allure/reader/StatusDeserializer.java b/allure-reader/src/main/java/io/qameta/allure/reader/StatusDeserializer.java
index 99a61913..a716e8d6 100644
--- a/allure-reader/src/main/java/io/qameta/allure/reader/StatusDeserializer.java
+++ b/allure-reader/src/main/java/io/qameta/allure/reader/StatusDeserializer.java
@@ -18,12 +18,15 @@
 import io.qameta.allure.model.Status;
 
 /**
- * @author charlie (Dmitry Baev).
  * @deprecated in favor of {@link com.fasterxml.jackson.databind.MapperFeature#ACCEPT_CASE_INSENSITIVE_ENUMS}
  * and {@link com.fasterxml.jackson.databind.DeserializationFeature#READ_UNKNOWN_ENUM_VALUES_AS_NULL}
  */
 @Deprecated
 public class StatusDeserializer extends AllureEnumDeserializer<Status> {
+
+    /**
+     * Creates a status deserializer with default configuration.
+     */
     public StatusDeserializer() {
         super(Status.class);
     }
diff --git a/allure-reader/src/test/java/io/qameta/allure/reader/AllureObjectMapperFactoryTest.java b/allure-reader/src/test/java/io/qameta/allure/reader/AllureObjectMapperFactoryTest.java
new file mode 100644
index 00000000..f289d55b
--- /dev/null
+++ b/allure-reader/src/test/java/io/qameta/allure/reader/AllureObjectMapperFactoryTest.java
@@ -0,0 +1,111 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.reader;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import io.qameta.allure.Allure;
+import io.qameta.allure.model.Parameter;
+import io.qameta.allure.model.Stage;
+import io.qameta.allure.model.Status;
+import io.qameta.allure.model.TestResult;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+class AllureObjectMapperFactoryTest {
+
+    @Test
+    void shouldCreateMapperThatReadsEnumsCaseInsensitively() throws Exception {
+        final TestResult result = Allure.step("Deserialize a mixed-case payload with extra fields", () -> {
+            final ObjectMapper mapper = AllureObjectMapperFactory.createMapper();
+            return mapper.readValue(
+                    "{"
+                            + "\"name\":\"demo\","
+                            + "\"titlePath\":[\"parent\",\"child\"],"
+                            + "\"status\":\"pAsSeD\","
+                            + "\"stage\":\"fInIsHeD\","
+                            + "\"parameters\":[{\"name\":\"secret\",\"value\":\"42\",\"mode\":\"MaSkEd\"}],"
+                            + "\"unknown\":\"ignored\""
+                            + "}",
+                    TestResult.class
+            );
+        });
+
+        Allure.step("Verify the mapper normalizes enums and keeps the expected payload", () -> {
+            assertEquals("demo", result.getName());
+            assertEquals("parent", result.getTitlePath().get(0));
+            assertEquals("child", result.getTitlePath().get(1));
+            assertEquals(Status.PASSED, result.getStatus());
+            assertEquals(Stage.FINISHED, result.getStage());
+            assertEquals(Parameter.Mode.MASKED, result.getParameters().get(0).getMode());
+        });
+    }
+
+    @Test
+    void deprecatedDeserializersShouldTrimInputAndReturnNullForUnknownValues() throws Exception {
+        final ObjectMapper mapper = AllureObjectMapperFactory.createMapper();
+
+        final DeprecatedEnumHolder trimmed = mapper.readValue(
+                "{"
+                        + "\"status\":\" broken \","
+                        + "\"stage\":\" pending \","
+                        + "\"mode\":\" hidden \""
+                        + "}",
+                DeprecatedEnumHolder.class
+        );
+        final DeprecatedEnumHolder unknown = mapper.readValue(
+                "{"
+                        + "\"status\":\"not-a-status\","
+                        + "\"stage\":\"   \","
+                        + "\"mode\":\"not-a-mode\""
+                        + "}",
+                DeprecatedEnumHolder.class
+        );
+
+        Allure.step("Compare deprecated deserializer output for trimmed and unknown enum values", () -> {
+            Allure.addAttachment(
+                    "enum-deserialization-summary",
+                    "trimmed.status=" + trimmed.status
+                            + "\ntrimmed.stage=" + trimmed.stage
+                            + "\ntrimmed.mode=" + trimmed.mode
+                            + "\nunknown.status=" + unknown.status
+                            + "\nunknown.stage=" + unknown.stage
+                            + "\nunknown.mode=" + unknown.mode
+            );
+            assertEquals(Status.BROKEN, trimmed.status);
+            assertEquals(Stage.PENDING, trimmed.stage);
+            assertEquals(Parameter.Mode.HIDDEN, trimmed.mode);
+
+            assertNull(unknown.status);
+            assertNull(unknown.stage);
+            assertNull(unknown.mode);
+        });
+    }
+
+    private static final class DeprecatedEnumHolder {
+
+        @JsonDeserialize(using = StatusDeserializer.class)
+        private Status status;
+
+        @JsonDeserialize(using = StageDeserializer.class)
+        private Stage stage;
+
+        @JsonDeserialize(using = ParameterModeDeserializer.class)
+        private Parameter.Mode mode;
+    }
+}
diff --git a/allure-reader/src/test/resources/allure.properties b/allure-reader/src/test/resources/allure.properties
new file mode 100644
index 00000000..364aa6de
--- /dev/null
+++ b/allure-reader/src/test/resources/allure.properties
@@ -0,0 +1,3 @@
+allure.results.directory=build/allure-results
+allure.label.epic=#project.description#
+allure.label.module=allure-reader
diff --git a/allure-rest-assured/src/main/java/io/qameta/allure/restassured/AllureRestAssured.java b/allure-rest-assured/src/main/java/io/qameta/allure/restassured/AllureRestAssured.java
index 51c166ae..8fc485f4 100644
--- a/allure-rest-assured/src/main/java/io/qameta/allure/restassured/AllureRestAssured.java
+++ b/allure-rest-assured/src/main/java/io/qameta/allure/restassured/AllureRestAssured.java
@@ -52,26 +52,56 @@ public class AllureRestAssured implements OrderedFilter {
     private String requestAttachmentName = "Request";
     private String responseAttachmentName;
 
+    /**
+     * Sets the max allowed prettify length.
+     *
+     * @param maxAllowedPrettifyLength the max allowed prettify length
+     * @return this instance for method chaining
+     */
     public AllureRestAssured setMaxAllowedPrettifyLength(final int maxAllowedPrettifyLength) {
         this.maxAllowedPrettifyLength = maxAllowedPrettifyLength;
         return this;
     }
 
+    /**
+     * Sets the request template.
+     *
+     * @param templatePath the classpath path to the FreeMarker template
+     * @return this instance for method chaining
+     */
     public AllureRestAssured setRequestTemplate(final String templatePath) {
         this.requestTemplatePath = templatePath;
         return this;
     }
 
+    /**
+     * Sets the response template.
+     *
+     * @param templatePath the classpath path to the FreeMarker template
+     * @return this instance for method chaining
+     */
     public AllureRestAssured setResponseTemplate(final String templatePath) {
         this.responseTemplatePath = templatePath;
         return this;
     }
 
+    /**
+     * Sets the request attachment name.
+     *
+     * @param requestAttachmentName the request attachment name
+     * @return this instance for method chaining
+     */
     public AllureRestAssured setRequestAttachmentName(final String requestAttachmentName) {
         this.requestAttachmentName = requestAttachmentName;
         return this;
     }
 
+    /**
+     * Sets the response attachment name.
+     *
+     * @param responseAttachmentName the response attachment name
+     * @return this instance for method chaining
+     */
     public AllureRestAssured setResponseAttachmentName(final String responseAttachmentName) {
         this.responseAttachmentName = responseAttachmentName;
         return this;
@@ -95,6 +125,9 @@ public AllureRestAssured withResponseTemplate(final String templatePath) {
         return setResponseTemplate(templatePath);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public Response filter(final FilterableRequestSpecification requestSpec,
                            final FilterableResponseSpecification responseSpec,
@@ -150,7 +183,7 @@ public Response filter(final FilterableRequestSpecification requestSpec,
     }
 
     private static Map<String, String> toMapConverter(final Iterable<? extends NameAndValue> items,
-                                                          final Set<String> toHide) {
+                                                      final Set<String> toHide) {
         final Map<String, String> result = new HashMap<>();
         items.forEach(h -> result.put(h.getName(), toHide.contains(h.getName()) ? HIDDEN_PLACEHOLDER : h.getValue()));
         return result;
@@ -162,6 +195,9 @@ private static Map<String, String> toStringMapConverter(final Map<String, ?> ite
         return result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public int getOrder() {
         return Integer.MAX_VALUE;
diff --git a/allure-rest-assured/src/test/java/io/qameta/allure/restassured/AllureRestAssuredTest.java b/allure-rest-assured/src/test/java/io/qameta/allure/restassured/AllureRestAssuredTest.java
index c35cef0d..57bb5ad4 100644
--- a/allure-rest-assured/src/test/java/io/qameta/allure/restassured/AllureRestAssuredTest.java
+++ b/allure-rest-assured/src/test/java/io/qameta/allure/restassured/AllureRestAssuredTest.java
@@ -52,13 +52,19 @@ class AttachmentArgumentProvider implements ArgumentsProvider {
     public Stream<? extends Arguments> provideArguments(final ExtensionContext context) {
         return Stream.of(
                 arguments(ImmutableList.of("Request", "HTTP/1.1 200 OK"), new AllureRestAssured()),
-                arguments(ImmutableList.of("Allure Request", "Allure Response"), new AllureRestAssured()
-                        .setRequestAttachmentName("Allure Request")
-                        .setResponseAttachmentName("Allure Response")),
-                arguments(ImmutableList.of("Request", "Allure Response"), new AllureRestAssured()
-                        .setResponseAttachmentName("Allure Response")),
-                arguments(ImmutableList.of("Allure Request", "HTTP/1.1 200 OK"), new AllureRestAssured()
-                        .setRequestAttachmentName("Allure Request"))
+                arguments(
+                        ImmutableList.of("Allure Request", "Allure Response"), new AllureRestAssured()
+                                .setRequestAttachmentName("Allure Request")
+                                .setResponseAttachmentName("Allure Response")
+                ),
+                arguments(
+                        ImmutableList.of("Request", "Allure Response"), new AllureRestAssured()
+                                .setResponseAttachmentName("Allure Response")
+                ),
+                arguments(
+                        ImmutableList.of("Allure Request", "HTTP/1.1 200 OK"), new AllureRestAssured()
+                                .setRequestAttachmentName("Allure Request")
+                )
         );
     }
 }
@@ -95,18 +101,16 @@ public Stream<? extends Arguments> provideArguments(final ExtensionContext conte
         );
     }
 }
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class AllureRestAssuredTest {
 
     @ParameterizedTest
     @ArgumentsSource(AttachmentArgumentProvider.class)
     void shouldCreateAttachment(final List<String> attachmentNames, final AllureRestAssured filter) {
         final AllureResults results = executeWithStub(
-                server -> WireMock.stubFor(WireMock.get(WireMock.urlEqualTo("/hello?Allure=Form"))
-                        .willReturn(WireMock.aResponse().withStatus(200).withBody("some body"))),
+                server -> WireMock.stubFor(
+                        WireMock.get(WireMock.urlEqualTo("/hello?Allure=Form"))
+                                .willReturn(WireMock.aResponse().withStatus(200).withBody("some body"))
+                ),
                 server -> RestAssured.given()
                         .contentType(ContentType.URLENC)
                         .formParams("Allure", "Form")
@@ -114,11 +118,13 @@ void shouldCreateAttachment(final List<String> attachmentNames, final AllureRest
                 filter
         );
 
-        assertThat(results.getTestResults()
-                .stream()
-                .map(TestResult::getAttachments)
-                .flatMap(Collection::stream)
-                .map(Attachment::getName))
+        assertThat(
+                results.getTestResults()
+                        .stream()
+                        .map(TestResult::getAttachments)
+                        .flatMap(Collection::stream)
+                        .map(Attachment::getName)
+        )
                 .containsExactlyElementsOf(attachmentNames);
     }
 
@@ -136,8 +142,10 @@ void shouldProperlySetAttachmentNameForSingleFilterInstance() {
 
         // Reuse the same filter instance for both requests to verify names are not cached.
         final AllureResults resultsOne = executeWithStub(
-                server -> WireMock.stubFor(WireMock.get(WireMock.urlEqualTo("/hello?Allure=Form"))
-                        .willReturn(responseBuilderOne)),
+                server -> WireMock.stubFor(
+                        WireMock.get(WireMock.urlEqualTo("/hello?Allure=Form"))
+                                .willReturn(responseBuilderOne)
+                ),
                 server -> RestAssured.given()
                         .contentType(ContentType.URLENC)
                         .formParams("Allure", "Form")
@@ -146,8 +154,10 @@ void shouldProperlySetAttachmentNameForSingleFilterInstance() {
         );
 
         final AllureResults resultsTwo = executeWithStub(
-                server -> WireMock.stubFor(WireMock.get(WireMock.urlEqualTo("/hello?Allure=Form"))
-                        .willReturn(responseBuilderTwo)),
+                server -> WireMock.stubFor(
+                        WireMock.get(WireMock.urlEqualTo("/hello?Allure=Form"))
+                                .willReturn(responseBuilderTwo)
+                ),
                 server -> RestAssured.given()
                         .contentType(ContentType.URLENC)
                         .formParams("Allure", "Form")
@@ -155,19 +165,23 @@ void shouldProperlySetAttachmentNameForSingleFilterInstance() {
                 filter
         );
 
-        assertThat(resultsOne.getTestResults()
-                .stream()
-                .map(TestResult::getAttachments)
-                .flatMap(Collection::stream)
-                .map(Attachment::getName))
+        assertThat(
+                resultsOne.getTestResults()
+                        .stream()
+                        .map(TestResult::getAttachments)
+                        .flatMap(Collection::stream)
+                        .map(Attachment::getName)
+        )
                 .hasSize(2)
                 .anyMatch(res -> res.equals("HTTP/1.1 200 OK"));
 
-        assertThat(resultsTwo.getTestResults()
-                .stream()
-                .map(TestResult::getAttachments)
-                .flatMap(Collection::stream)
-                .map(Attachment::getName))
+        assertThat(
+                resultsTwo.getTestResults()
+                        .stream()
+                        .map(TestResult::getAttachments)
+                        .flatMap(Collection::stream)
+                        .map(Attachment::getName)
+        )
                 .hasSize(2)
                 .anyMatch(res -> res.equals("HTTP/1.1 400 Bad Request"));
     }
@@ -176,8 +190,10 @@ void shouldProperlySetAttachmentNameForSingleFilterInstance() {
     @ArgumentsSource(AttachmentArgumentProvider.class)
     void shouldCatchAttachmentBody(final List<String> attachmentNames, final AllureRestAssured filter) {
         final AllureResults results = executeWithStub(
-                server -> WireMock.stubFor(WireMock.get(WireMock.urlEqualTo("/hello?Allure=Form"))
-                        .willReturn(WireMock.aResponse().withStatus(200).withBody("some body"))),
+                server -> WireMock.stubFor(
+                        WireMock.get(WireMock.urlEqualTo("/hello?Allure=Form"))
+                                .willReturn(WireMock.aResponse().withStatus(200).withBody("some body"))
+                ),
                 server -> RestAssured.given()
                         .contentType(ContentType.URLENC)
                         .formParams("Allure", "Form")
@@ -213,8 +229,10 @@ void shouldHideHeadersInAttachments(final Map<String, String> headers,
         RestAssured.config = new RestAssuredConfig().logConfig(LogConfig.logConfig().blacklistHeaders(List.of(hiddenHeader)));
 
         final AllureResults results = executeWithStub(
-                server -> WireMock.stubFor(WireMock.get(WireMock.urlEqualTo("/hello?Allure=Form"))
-                        .willReturn(responseBuilder)),
+                server -> WireMock.stubFor(
+                        WireMock.get(WireMock.urlEqualTo("/hello?Allure=Form"))
+                                .willReturn(responseBuilder)
+                ),
                 server -> RestAssured.with()
                         .headers(headers)
                         .contentType(ContentType.URLENC)
@@ -240,8 +258,10 @@ void responseJsonPrettified(final AllureRestAssured filter, final String formatt
                 .withStatus(200);
 
         final AllureResults results = executeWithStub(
-                server -> WireMock.stubFor(WireMock.get(WireMock.urlEqualTo("/hello?Allure=Form"))
-                        .willReturn(responseBuilder)),
+                server -> WireMock.stubFor(
+                        WireMock.get(WireMock.urlEqualTo("/hello?Allure=Form"))
+                                .willReturn(responseBuilder)
+                ),
                 server -> RestAssured.with()
                         .contentType(ContentType.URLENC)
                         .formParams("Allure", "Form")
@@ -271,19 +291,23 @@ void shouldRenderListValuedFormParams() {
                 .withBody("some body");
 
         final AllureResults results = executeWithStub(
-                server -> WireMock.stubFor(WireMock.post(WireMock.urlPathEqualTo("/hello"))
-                        .willReturn(responseBuilder)),
+                server -> WireMock.stubFor(
+                        WireMock.post(WireMock.urlPathEqualTo("/hello"))
+                                .willReturn(responseBuilder)
+                ),
                 server -> RestAssured.given()
                         .contentType(ContentType.URLENC)
                         .formParam("data", List.of("a", "b"))
                         .post(server.url("/hello")).then().statusCode(200)
         );
 
-        assertThat(results.getTestResults()
-                .stream()
-                .map(TestResult::getAttachments)
-                .flatMap(Collection::stream)
-                .map(Attachment::getName))
+        assertThat(
+                results.getTestResults()
+                        .stream()
+                        .map(TestResult::getAttachments)
+                        .flatMap(Collection::stream)
+                        .map(Attachment::getName)
+        )
                 .containsExactly("Request", "HTTP/1.1 200 OK");
 
         final Attachment requestAttachment = results.getTestResults()
@@ -313,19 +337,23 @@ void shouldNotFailForNullValuedFormParamsMap() {
         formParams.put("param2", null);
 
         final AllureResults results = executeWithStub(
-                server -> WireMock.stubFor(WireMock.post(WireMock.urlPathEqualTo("/hello"))
-                        .willReturn(responseBuilder)),
+                server -> WireMock.stubFor(
+                        WireMock.post(WireMock.urlPathEqualTo("/hello"))
+                                .willReturn(responseBuilder)
+                ),
                 server -> RestAssured.given()
                         .contentType(ContentType.URLENC)
                         .formParams(formParams)
                         .post(server.url("/hello")).then().statusCode(200)
         );
 
-        assertThat(results.getTestResults()
-                .stream()
-                .map(TestResult::getAttachments)
-                .flatMap(Collection::stream)
-                .map(Attachment::getName))
+        assertThat(
+                results.getTestResults()
+                        .stream()
+                        .map(TestResult::getAttachments)
+                        .flatMap(Collection::stream)
+                        .map(Attachment::getName)
+        )
                 .containsExactly("Request", "HTTP/1.1 200 OK");
     }
 
diff --git a/allure-rest-assured/src/test/resources/allure.properties b/allure-rest-assured/src/test/resources/allure.properties
index 9c0b0a2d..89b92e23 100644
--- a/allure-rest-assured/src/test/resources/allure.properties
+++ b/allure-rest-assured/src/test/resources/allure.properties
@@ -1,2 +1,3 @@
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-rest-assured
diff --git a/allure-scalatest/build.gradle.kts b/allure-scalatest/build.gradle.kts
index a5ecc550..f16998fe 100644
--- a/allure-scalatest/build.gradle.kts
+++ b/allure-scalatest/build.gradle.kts
@@ -74,13 +74,6 @@ publishing {
     }
 }
 
-signing {
-    sign(
-        publishing.publications["crossBuildScala_212"],
-        publishing.publications["crossBuildScala_213"]
-    )
-}
-
 dependencies {
     api(project(":allure-java-commons"))
     compileOnly("org.scalatest:scalatest_$scala213:3.2.19")
diff --git a/allure-scalatest/src/main/scala/io/qameta/allure/scalatest/AllureScalatest.scala b/allure-scalatest/src/main/scala/io/qameta/allure/scalatest/AllureScalatest.scala
index e42e0184..1fc9f70e 100644
--- a/allure-scalatest/src/main/scala/io/qameta/allure/scalatest/AllureScalatest.scala
+++ b/allure-scalatest/src/main/scala/io/qameta/allure/scalatest/AllureScalatest.scala
@@ -29,10 +29,6 @@ import org.scalatest.exceptions.TestFailedException
 
 import scala.jdk.CollectionConverters._
 import scala.collection.mutable
-
-/**
-  * @author charlie (Dmitry Baev).
-  */
 trait AllureScalatestContext {
   AllureScalatestContextHolder.populate()
 }
@@ -89,15 +85,15 @@ class AllureScalatest(val lifecycle: AllureLifecycle) extends Reporter {
   def this() = this(Allure.getLifecycle)
 
   override def apply(event: Event): Unit = event match {
-    case event: SuiteStarting => startSuite(event)
+    case event: SuiteStarting  => startSuite(event)
     case event: SuiteCompleted => completeSuite(event)
-    case event: SuiteAborted => abortSuite(event)
-    case event: TestStarting => startTestCase(event)
-    case event: TestFailed => failTestCase(event)
-    case event: TestCanceled => cancelTestCase(event)
-    case event: TestSucceeded => passTestCase(event)
-    case event: TestIgnored => ignoreTestCase(event)
-    case _ => ()
+    case event: SuiteAborted   => abortSuite(event)
+    case event: TestStarting   => startTestCase(event)
+    case event: TestFailed     => failTestCase(event)
+    case event: TestCanceled   => cancelTestCase(event)
+    case event: TestSucceeded  => passTestCase(event)
+    case event: TestIgnored    => ignoreTestCase(event)
+    case _                     => ()
   }
 
   def startSuite(event: SuiteStarting): Unit = {
@@ -127,7 +123,7 @@ class AllureScalatest(val lifecycle: AllureLifecycle) extends Reporter {
     val throwable = event.throwable.getOrElse(new RuntimeException(event.message))
     val status = throwable match {
       case _: TestFailedException => Status.FAILED
-      case _ => Status.BROKEN
+      case _                      => Status.BROKEN
     }
     val statusDetails = getStatusDetails(throwable)
       .orElse(new StatusDetails().setMessage(event.message))
@@ -171,12 +167,7 @@ class AllureScalatest(val lifecycle: AllureLifecycle) extends Reporter {
     )
   }
 
-  private def startTest(suiteId: String,
-                        suiteName: String,
-                        suiteClassName: Option[String],
-                        location: Option[Location],
-                        testName: String,
-                        threadId: Option[String]): Unit = {
+  private def startTest(suiteId: String, suiteName: String, suiteClassName: Option[String], location: Option[Location], testName: String, threadId: Option[String]): Unit = {
     val uuid = UUID.randomUUID().toString
     var labels = mutable.ListBuffer(
       createSuiteLabel(suiteName),
@@ -195,24 +186,30 @@ class AllureScalatest(val lifecycle: AllureLifecycle) extends Reporter {
       .setUuid(uuid)
       .setTestCaseId(md5(suiteId + testName))
       .setHistoryId(md5(suiteId + testName))
+      .setTitlePath(
+        suiteClassName
+          .map(createTitlePathFromQualifiedClassName)
+          .getOrElse(createTitlePath(suiteName))
+      )
 
     val testAnnotations = getAnnotations(location)
     val suiteAnnotations = getAnnotations(getSuiteLocation(suiteId))
 
     (testAnnotations ::: suiteAnnotations).foreach {
-      case annotation: Severity => labels += createSeverityLabel(annotation.value())
-      case annotation: Owner => labels += createOwnerLabel(annotation.value())
+      case annotation: Severity    => labels += createSeverityLabel(annotation.value())
+      case annotation: Owner       => labels += createOwnerLabel(annotation.value())
       case annotation: Description => result.setDescription(annotation.value())
-      case annotation: Epic => labels += createEpicLabel(annotation.value())
-      case annotation: Feature => labels += createFeatureLabel(annotation.value())
-      case annotation: Story => labels += createStoryLabel(annotation.value())
-      case annotation: Link => links += createLink(annotation)
-      case annotation: Issue => links += createIssueLink(annotation.value())
-      case annotation: TmsLink => links += createTmsLink(annotation.value())
-      case _ => None
+      case annotation: Epic        => labels += createEpicLabel(annotation.value())
+      case annotation: Feature     => labels += createFeatureLabel(annotation.value())
+      case annotation: Story       => labels += createStoryLabel(annotation.value())
+      case annotation: Link        => links += createLink(annotation)
+      case annotation: Issue       => links += createIssueLink(annotation.value())
+      case annotation: TmsLink     => links += createTmsLink(annotation.value())
+      case _                       => None
     }
 
-    suiteClassName.map(className => createTestClassLabel(className))
+    suiteClassName
+      .map(className => createTestClassLabel(className))
       .fold {} { value => labels += value }
 
     result.setLabels(labels.asJava)
@@ -220,34 +217,36 @@ class AllureScalatest(val lifecycle: AllureLifecycle) extends Reporter {
     lifecycle.scheduleTestCase(result)
     lifecycle.startTestCase(uuid)
 
-    //this should be called after test case scheduled
+    // this should be called after test case scheduled
     threadId.fold {} { thread => AllureScalatestContextHolder.add(thread, uuid) }
   }
 
-  private def stopTest(status: Option[Status],
-                       statusDetails: Option[StatusDetails],
-                       threadName: Option[String]): Unit = {
-    threadName.fold {} {
-      thread => {
-        AllureScalatestContextHolder.get(thread).fold {} {
-          uuid => {
-            lifecycle.updateTestCase(uuid, (result: TestResult) => {
-              status.fold {} { st => result.setStatus(st) }
-              statusDetails.fold {} { details => result.setStatusDetails(details) }
-            }: Unit)
+  private def stopTest(status: Option[Status], statusDetails: Option[StatusDetails], threadName: Option[String]): Unit = {
+    threadName.fold {} { thread =>
+      {
+        AllureScalatestContextHolder.get(thread).fold {} { uuid =>
+          {
+            lifecycle.updateTestCase(
+              uuid,
+              (result: TestResult) =>
+                {
+                  status.fold {} { st => result.setStatus(st) }
+                  statusDetails.fold {} { details => result.setStatusDetails(details) }
+                }: Unit
+            )
             lifecycle.stopTestCase(uuid)
             lifecycle.writeTestCase(uuid)
           }
-            AllureScalatestContextHolder.remove(thread)
+          AllureScalatestContextHolder.remove(thread)
         }
       }
     }
   }
 
   private def getAnnotations(location: Option[Location]): List[Annotation] = location match {
-    case Some(TopOfClass(className)) => Class.forName(className).getAnnotations.toList
+    case Some(TopOfClass(className))              => Class.forName(className).getAnnotations.toList
     case Some(TopOfMethod(className, methodName)) => Class.forName(className).getMethod(methodName).getDeclaredAnnotations.toList
-    case _ => List()
+    case _                                        => List()
   }
 
   private def setSuiteLocation(suiteId: String, location: Option[Location]): Unit = {
@@ -282,8 +281,8 @@ class AllureScalatest(val lifecycle: AllureLifecycle) extends Reporter {
   private def getScalaTestThreadName(threadId: Option[String]): String = {
     val fromProperty = System.getProperty(ALLURE_THREAD_NAME_SYSPROP)
     val fromEnv = System.getenv(ALLURE_THREAD_NAME_ENV)
-    val realThreadName = threadId.getOrElse {getThreadName}
-    Seq(fromProperty, fromEnv).find(el => Objects.nonNull(el)).getOrElse {realThreadName}
+    val realThreadName = threadId.getOrElse { getThreadName }
+    Seq(fromProperty, fromEnv).find(el => Objects.nonNull(el)).getOrElse { realThreadName }
   }
 
 }
diff --git a/allure-scalatest/src/test/resources/allure.properties b/allure-scalatest/src/test/resources/allure.properties
index 9c0b0a2d..760733e9 100644
--- a/allure-scalatest/src/test/resources/allure.properties
+++ b/allure-scalatest/src/test/resources/allure.properties
@@ -1,2 +1,3 @@
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-scalatest
diff --git a/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/AllureScalatestTest.scala b/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/AllureScalatestTest.scala
index 2519f799..85c592a0 100644
--- a/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/AllureScalatestTest.scala
+++ b/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/AllureScalatestTest.scala
@@ -26,10 +26,6 @@ import org.scalatest.tools.Runner
 
 import scala.collection.mutable.ListBuffer
 import scala.jdk.CollectionConverters._
-
-/**
-  * @author charlie (Dmitry Baev).
-  */
 class AllureScalatestTest {
 
   @Test
@@ -37,6 +33,14 @@ class AllureScalatestTest {
     val results = run(classOf[SimpleSpec])
     results.getTestResults.asScala
       .map(item => item.getName) should contain("test should be passed")
+    results.getTestResults.asScala.head.getTitlePath.asScala.toList shouldBe List(
+      "io",
+      "qameta",
+      "allure",
+      "scalatest",
+      "testdata",
+      "SimpleSpec"
+    )
   }
 
   @Test
@@ -44,7 +48,8 @@ class AllureScalatestTest {
     val results = run(classOf[SimpleSpec])
 
     val starts = results.getTestResults.asScala
-      .map(item => item.getStart).toList
+      .map(item => item.getStart)
+      .toList
 
     every(starts) should not be null
   }
@@ -98,7 +103,8 @@ class AllureScalatestTest {
     results.getTestResults should have length 1
 
     val statuses = results.getTestResults.asScala
-      .map(item => item.getStatus).toList
+      .map(item => item.getStatus)
+      .toList
 
     every(statuses) should be(Status.BROKEN)
   }
@@ -110,7 +116,8 @@ class AllureScalatestTest {
     results.getTestResults should have length 1
 
     val statuses = results.getTestResults.asScala
-      .map(item => item.getStatus).toList
+      .map(item => item.getStatus)
+      .toList
 
     every(statuses) should be(Status.SKIPPED)
   }
@@ -156,12 +163,14 @@ class AllureScalatestTest {
       .map(item => item.getName) should contain("test should be ignored")
 
     val statuses = results.getTestResults.asScala
-      .map(item => item.getStatus).toList
+      .map(item => item.getStatus)
+      .toList
 
     every(statuses) should be(null)
 
     val stages = results.getTestResults.asScala
-      .map(item => item.getStage).toList
+      .map(item => item.getStage)
+      .toList
 
     every(stages) should be(Stage.FINISHED)
   }
@@ -173,11 +182,12 @@ class AllureScalatestTest {
       .flatMap(item => item.getSteps.asScala)
 
     steps
-      .map(step => step.getName) should contain inOrder("first", "second", "third")
+      .map(step => step.getName) should contain inOrder ("first", "second", "third")
 
-    steps.filter(step => step.getName == "second")
+    steps
+      .filter(step => step.getName == "second")
       .flatMap(step => step.getSteps.asScala)
-      .map(step => step.getName) should contain inOrder("child1", "child2", "child3")
+      .map(step => step.getName) should contain inOrder ("child1", "child2", "child3")
 
   }
 
diff --git a/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/AllureApiSpec.scala b/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/AllureApiSpec.scala
index f3f97845..abb3ebe2 100644
--- a/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/AllureApiSpec.scala
+++ b/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/AllureApiSpec.scala
@@ -18,25 +18,27 @@ package io.qameta.allure.scalatest.testdata
 import io.qameta.allure.Allure.{StepContext, step}
 import io.qameta.allure.scalatest.AllureScalatestContext
 import org.scalatest.flatspec.AnyFlatSpec
-
-/**
-  * @author charlie (Dmitry Baev).
-  */
 class AllureApiSpec extends AnyFlatSpec {
 
   "test" should "be passed" in new AllureScalatestContext {
     step("first")
-    step("second", () => {
-      step("child1")
-      step("child2")
-      step("child3")
-      () =>
-    })
-    step("third", (context: StepContext) => {
-      val a = context.parameter("a", 123L)
-      val b = context.parameter("b", "hello")
-      () =>
-    })
+    step(
+      "second",
+      () => {
+        step("child1")
+        step("child2")
+        step("child3")
+        () =>
+      }
+    )
+    step(
+      "third",
+      (context: StepContext) => {
+        val a = context.parameter("a", 123L)
+        val b = context.parameter("b", "hello")
+        () =>
+      }
+    )
   }
 
 }
diff --git a/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/AnnotationsOnClassSpec.scala b/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/AnnotationsOnClassSpec.scala
index 58b0d6a6..769a4049 100644
--- a/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/AnnotationsOnClassSpec.scala
+++ b/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/AnnotationsOnClassSpec.scala
@@ -17,10 +17,6 @@ package io.qameta.allure.scalatest.testdata
 
 import io.qameta.allure._
 import org.scalatest.funsuite.AnyFunSuite
-
-/**
-  * @author charlie (Dmitry Baev).
-  */
 @Owner("charlie")
 @Epic("E1")
 @Feature("F1")
@@ -30,7 +26,6 @@ import org.scalatest.funsuite.AnyFunSuite
 @TmsLink("https://example.org/tms/1")
 class AnnotationsOnClassSpec extends AnyFunSuite {
 
-  test("demo test") {
-  }
+  test("demo test") {}
 
 }
diff --git a/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/BrokenSpec.scala b/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/BrokenSpec.scala
index eef70481..516368aa 100644
--- a/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/BrokenSpec.scala
+++ b/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/BrokenSpec.scala
@@ -17,10 +17,6 @@ package io.qameta.allure.scalatest.testdata
 
 import org.scalatest.matchers.should.Matchers._
 import org.scalatest.flatspec.AnyFlatSpec
-
-/**
-  * @author charlie (Dmitry Baev).
-  */
 class BrokenSpec extends AnyFlatSpec {
 
   "test" should "be failed" in {
diff --git a/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/CancelledSpec.scala b/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/CancelledSpec.scala
index 713b46b6..1a882b05 100644
--- a/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/CancelledSpec.scala
+++ b/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/CancelledSpec.scala
@@ -17,10 +17,6 @@ package io.qameta.allure.scalatest.testdata
 
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers._
-
-/**
-  * @author charlie (Dmitry Baev).
-  */
 class CancelledSpec extends AnyFlatSpec {
 
   "test" should "be cancelled" in {
diff --git a/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/FailedSpec.scala b/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/FailedSpec.scala
index 91ab06e5..553699be 100644
--- a/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/FailedSpec.scala
+++ b/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/FailedSpec.scala
@@ -17,10 +17,6 @@ package io.qameta.allure.scalatest.testdata
 
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers._
-
-/**
-  * @author charlie (Dmitry Baev).
-  */
 class FailedSpec extends AnyFlatSpec {
 
   "test" should "be failed" in {
diff --git a/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/IgnoredSpec.scala b/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/IgnoredSpec.scala
index 642d554a..c183b735 100644
--- a/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/IgnoredSpec.scala
+++ b/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/IgnoredSpec.scala
@@ -17,14 +17,9 @@ package io.qameta.allure.scalatest.testdata
 
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.Ignore
-
-/**
-  * @author charlie (Dmitry Baev).
-  */
 @Ignore
 class IgnoredSpec extends AnyFlatSpec {
 
-  "test" should "be ignored" in {
-  }
+  "test" should "be ignored" in {}
 
 }
diff --git a/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/SeveritySpec.scala b/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/SeveritySpec.scala
index c5e10b06..7ecf993a 100644
--- a/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/SeveritySpec.scala
+++ b/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/SeveritySpec.scala
@@ -17,14 +17,9 @@ package io.qameta.allure.scalatest.testdata
 
 import io.qameta.allure.{Severity, SeverityLevel}
 import org.scalatest.flatspec.AnyFlatSpec
-
-/**
-  * @author charlie (Dmitry Baev).
-  */
 @Severity(SeverityLevel.BLOCKER)
 class SeveritySpec extends AnyFlatSpec {
 
-  "test" should "be passed" in {
-  }
+  "test" should "be passed" in {}
 
 }
diff --git a/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/SimpleSpec.scala b/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/SimpleSpec.scala
index a77849a1..ef498a65 100644
--- a/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/SimpleSpec.scala
+++ b/allure-scalatest/src/test/scala/io/qameta/allure/scalatest/testdata/SimpleSpec.scala
@@ -16,13 +16,8 @@
 package io.qameta.allure.scalatest.testdata
 
 import org.scalatest.flatspec.AnyFlatSpec
-
-/**
-  * @author charlie (Dmitry Baev).
-  */
 class SimpleSpec extends AnyFlatSpec {
 
-  "test" should "be passed" in {
-  }
+  "test" should "be passed" in {}
 
 }
diff --git a/allure-selenide/src/main/java/io/qameta/allure/selenide/AllureSelenide.java b/allure-selenide/src/main/java/io/qameta/allure/selenide/AllureSelenide.java
index 12f94213..afe7f98e 100644
--- a/allure-selenide/src/main/java/io/qameta/allure/selenide/AllureSelenide.java
+++ b/allure-selenide/src/main/java/io/qameta/allure/selenide/AllureSelenide.java
@@ -42,7 +42,9 @@
 import static java.nio.charset.StandardCharsets.UTF_8;
 
 /**
- * @author Artem Eroshenko.
+ * Integrates Selenide with Allure reporting.
+ *
+ * <p>Register this type through the standard Selenide extension, listener, interceptor, or plugin mechanism so framework execution events are written to Allure results. Use explicit dependencies when embedding the integration in tests or custom runtimes.</p>
  */
 @SuppressWarnings("unused")
 public class AllureSelenide implements LogEventListener {
@@ -55,35 +57,74 @@ public class AllureSelenide implements LogEventListener {
     private final Map<LogType, Level> logTypesToSave = new EnumMap<>(LogType.class);
     private final AllureLifecycle lifecycle;
 
+    /**
+     * Creates an Allure selenide with default configuration.
+     */
     public AllureSelenide() {
         this(Allure.getLifecycle());
     }
 
+    /**
+     * Creates an Allure selenide with the supplied values.
+     *
+     * @param lifecycle the Allure lifecycle to use
+     */
     public AllureSelenide(final AllureLifecycle lifecycle) {
         this.lifecycle = lifecycle;
     }
 
+    /**
+     * Configures screenshots.
+     *
+     * @param saveScreenshots the save screenshots
+     * @return this instance for method chaining
+     */
     public AllureSelenide screenshots(final boolean saveScreenshots) {
         this.saveScreenshots = saveScreenshots;
         return this;
     }
 
+    /**
+     * Configures save page source.
+     *
+     * @param savePageHtml the save page html
+     * @return this instance for method chaining
+     */
     public AllureSelenide savePageSource(final boolean savePageHtml) {
         this.savePageHtml = savePageHtml;
         return this;
     }
 
+    /**
+     * Configures include selenide steps.
+     *
+     * @param includeSelenideSteps the include selenide steps
+     * @return this instance for method chaining
+     */
     public AllureSelenide includeSelenideSteps(final boolean includeSelenideSteps) {
         this.includeSelenideLocatorsSteps = includeSelenideSteps;
         return this;
     }
 
+    /**
+     * Configures enable logs.
+     *
+     * @param logType the log type
+     * @param logLevel the log level
+     * @return this instance for method chaining
+     */
     public AllureSelenide enableLogs(final LogType logType, final Level logLevel) {
         logTypesToSave.put(logType, logLevel);
 
         return this;
     }
 
+    /**
+     * Configures disable logs.
+     *
+     * @param logType the log type
+     * @return this instance for method chaining
+     */
     public AllureSelenide disableLogs(final LogType logType) {
         logTypesToSave.remove(logType);
 
@@ -116,6 +157,9 @@ private static String getBrowserLogs(final LogType logType, final Level level) {
         return String.join("\n\n", Selenide.getWebDriverLogs(logType.toString(), level));
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void beforeEvent(final LogEvent event) {
         if (stepsShouldBeLogged(event)) {
@@ -126,6 +170,9 @@ public void beforeEvent(final LogEvent event) {
         }
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void afterEvent(final LogEvent event) {
         if (event.getStatus().equals(LogEvent.EventStatus.FAIL)) {
@@ -169,7 +216,6 @@ public void afterEvent(final LogEvent event) {
         }
     }
 
-
     private boolean stepsShouldBeLogged(final LogEvent event) {
         //  other customer Loggers could be configured, they should be logged
         return includeSelenideLocatorsSteps || !(event instanceof SelenideLog);
diff --git a/allure-selenide/src/main/java/io/qameta/allure/selenide/LogType.java b/allure-selenide/src/main/java/io/qameta/allure/selenide/LogType.java
index 726d173d..e4e7824d 100644
--- a/allure-selenide/src/main/java/io/qameta/allure/selenide/LogType.java
+++ b/allure-selenide/src/main/java/io/qameta/allure/selenide/LogType.java
@@ -17,8 +17,7 @@
 
 /**
  * Enum wrapper of Selenium {@link org.openqa.selenium.logging.LogType}.
-
- * @author Yevhen Holiakhovskyi.
+ *
  */
 public enum LogType {
 
@@ -58,6 +57,9 @@ public enum LogType {
         this.logType = logType;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public String toString() {
         return logType;
diff --git a/allure-selenide/src/test/java/io/qameta/allure/selenide/AllureSelenideTest.java b/allure-selenide/src/test/java/io/qameta/allure/selenide/AllureSelenideTest.java
index 7db0358a..4b5d86ce 100644
--- a/allure-selenide/src/test/java/io/qameta/allure/selenide/AllureSelenideTest.java
+++ b/allure-selenide/src/test/java/io/qameta/allure/selenide/AllureSelenideTest.java
@@ -30,8 +30,8 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.openqa.selenium.OutputType;
-import org.openqa.selenium.WebDriverException;
 import org.openqa.selenium.WebDriver.Options;
+import org.openqa.selenium.WebDriverException;
 import org.openqa.selenium.chrome.ChromeDriver;
 import org.openqa.selenium.logging.LogEntries;
 import org.openqa.selenium.logging.LogEntry;
@@ -47,10 +47,6 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class AllureSelenideTest {
 
     @BeforeEach
@@ -221,12 +217,12 @@ void shouldSavePageSourceOnFail() {
     void shouldNotFailIfBrowserIsNotOpened() {
         final AllureResults results = runWithinTestContext(() -> {
             final AllureSelenide selenide = new AllureSelenide()
-                .savePageSource(false)
-                .screenshots(true);
+                    .savePageSource(false)
+                    .screenshots(true);
             SelenideLogger.addListener(UUID.randomUUID().toString(), selenide);
             final SelenideLog log = SelenideLogger.beginStep(
-                "open",
-                "https://some.url"
+                    "open",
+                    "https://some.url"
             );
             SelenideLogger.commitStep(log, new WebDriverException("failed to open a browser"));
         });
@@ -263,10 +259,11 @@ void shouldSaveLogs() {
             SelenideLogger.addListener(UUID.randomUUID().toString(), selenide);
 
             final SelenideLog log = SelenideLogger.beginStep(
-                "dummy source",
-                "dummyMethod()",
-                "param1",
-                "param2");
+                    "dummy source",
+                    "dummyMethod()",
+                    "param1",
+                    "param2"
+            );
 
             SelenideLogger.commitStep(log, new Exception("something went wrong"));
         });
@@ -274,8 +271,8 @@ void shouldSaveLogs() {
         final StepResult selenideStep = extractStepFromResults(results);
         final Attachment attachment = selenideStep.getAttachments().iterator().next();
         final String attachmentContent = new String(
-            results.getAttachments().get(attachment.getSource()),
-            StandardCharsets.UTF_8
+                results.getAttachments().get(attachment.getSource()),
+                StandardCharsets.UTF_8
         );
 
         assertThat(selenideStep.getAttachments()).hasSize(1);
diff --git a/allure-selenide/src/test/resources/allure.properties b/allure-selenide/src/test/resources/allure.properties
index 9c0b0a2d..cfcad4a8 100644
--- a/allure-selenide/src/test/resources/allure.properties
+++ b/allure-selenide/src/test/resources/allure.properties
@@ -1,2 +1,3 @@
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-selenide
diff --git a/allure-selenium-bidi/build.gradle.kts b/allure-selenium-bidi/build.gradle.kts
new file mode 100644
index 00000000..392d791e
--- /dev/null
+++ b/allure-selenium-bidi/build.gradle.kts
@@ -0,0 +1,47 @@
+description = "Allure Selenium WebDriver BiDi Integration"
+
+val agent: Configuration by configurations.creating
+
+val seleniumVersion = "4.23.0"
+val testcontainersVersion = "1.21.4"
+
+dependencies {
+    agent("org.aspectj:aspectjweaver")
+    api(project(":allure-java-commons"))
+    compileOnly("org.seleniumhq.selenium:selenium-java:$seleniumVersion")
+    testAnnotationProcessor(project(":allure-descriptions-javadoc"))
+    testImplementation("org.seleniumhq.selenium:selenium-java:$seleniumVersion")
+    testImplementation("org.assertj:assertj-core")
+    testImplementation("org.junit.jupiter:junit-jupiter-api")
+    testImplementation("org.slf4j:slf4j-simple")
+    testImplementation("org.testcontainers:junit-jupiter:$testcontainersVersion")
+    testImplementation("org.testcontainers:testcontainers:$testcontainersVersion")
+    testImplementation(project(":allure-assertj"))
+    testImplementation(project(":allure-java-commons-test"))
+    testImplementation(project(":allure-junit-platform"))
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
+}
+
+tasks {
+    compileJava {
+        options.release.set(17)
+    }
+    compileTestJava {
+        options.release.set(17)
+    }
+    jar {
+        manifest {
+            attributes(
+                mapOf(
+                    "Automatic-Module-Name" to "io.qameta.allure.seleniumbidi"
+                )
+            )
+        }
+    }
+    test {
+        useJUnitPlatform()
+        jvmArgs("-javaagent:${agent.singleFile}")
+        systemProperty("allure.model.indentOutput", "true")
+        systemProperty("org.slf4j.simpleLogger.defaultLogLevel", "warn")
+    }
+}
diff --git a/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/AllureWebDriverBiDi.java b/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/AllureWebDriverBiDi.java
new file mode 100644
index 00000000..1f71284c
--- /dev/null
+++ b/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/AllureWebDriverBiDi.java
@@ -0,0 +1,236 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.seleniumbidi;
+
+import io.qameta.allure.Allure;
+import io.qameta.allure.AllureLifecycle;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.support.events.EventFiringDecorator;
+import org.openqa.selenium.support.events.WebDriverListener;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * Selenium WebDriver BiDi listener that captures browser log and network events
+ * as aggregated Allure attachments.
+ */
+@SuppressWarnings("unused")
+public class AllureWebDriverBiDi implements WebDriverListener, AutoCloseable {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(AllureWebDriverBiDi.class);
+
+    private final AllureLifecycle lifecycle;
+    private final BiDiSessionFactory sessionFactory;
+    private final BiDiConfiguration configuration = new BiDiConfiguration();
+    private final Map<WebDriver, BiDiSessionState> sessions = new IdentityHashMap<>();
+    private final Lock sessionsLock = new ReentrantLock();
+
+    /**
+     * Creates an Allure web driver bi di with default configuration.
+     */
+    public AllureWebDriverBiDi() {
+        this(Allure.getLifecycle(), new SeleniumBiDiSessionFactory());
+    }
+
+    AllureWebDriverBiDi(final AllureLifecycle lifecycle,
+                        final BiDiSessionFactory sessionFactory) {
+        this.lifecycle = lifecycle;
+        this.sessionFactory = sessionFactory;
+    }
+
+    /**
+     * Decorates the supplied object with Allure reporting behavior.
+     *
+     * @param driver the WebDriver instance to decorate or observe
+     * @return the decorate
+     */
+    public <T extends WebDriver> T decorate(final T driver) {
+        return new EventFiringDecorator<T>(this).decorate(driver);
+    }
+
+    /**
+     * Configures logs.
+     *
+     * @param enabled whether the option should be enabled
+     * @return this instance for method chaining
+     */
+    public AllureWebDriverBiDi logs(final boolean enabled) {
+        configuration.setLogsEnabled(enabled);
+        return this;
+    }
+
+    /**
+     * Configures network.
+     *
+     * @param enabled whether the option should be enabled
+     * @return this instance for method chaining
+     */
+    public AllureWebDriverBiDi network(final boolean enabled) {
+        configuration.setNetworkEnabled(enabled);
+        return this;
+    }
+
+    /**
+     * Configures max log entries.
+     *
+     * @param maxLogEntries the maximum number of log entries to keep
+     * @return this instance for method chaining
+     */
+    public AllureWebDriverBiDi maxLogEntries(final int maxLogEntries) {
+        configuration.setMaxLogEntries(maxLogEntries);
+        return this;
+    }
+
+    /**
+     * Configures max network events.
+     *
+     * @param maxNetworkEvents the maximum number of network events to keep
+     * @return this instance for method chaining
+     */
+    public AllureWebDriverBiDi maxNetworkEvents(final int maxNetworkEvents) {
+        configuration.setMaxNetworkEvents(maxNetworkEvents);
+        return this;
+    }
+
+    /**
+     * Configures redact headers.
+     *
+     * @param headerNames the header names whose values should be redacted
+     * @return this instance for method chaining
+     */
+    public AllureWebDriverBiDi redactHeaders(final String... headerNames) {
+        configuration.redactHeaders(headerNames);
+        return this;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void beforeAnyWebDriverCall(final WebDriver driver,
+                                       final Method method,
+                                       final Object[] args) {
+        captureActiveAllureContext(driver);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void afterAnyWebDriverCall(final WebDriver driver,
+                                      final Method method,
+                                      final Object[] args,
+                                      final Object result) {
+        captureActiveAllureContext(driver);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void beforeQuit(final WebDriver driver) {
+        closeSession(driver);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void afterQuit(final WebDriver driver) {
+        closeSession(driver);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void close() {
+        final List<BiDiSessionState> activeSessions = new ArrayList<>();
+        sessionsLock.lock();
+        try {
+            activeSessions.addAll(sessions.values());
+            sessions.clear();
+        } finally {
+            sessionsLock.unlock();
+        }
+        activeSessions.forEach(this::safeFlushAndClose);
+    }
+
+    private void captureActiveAllureContext(final WebDriver driver) {
+        if (!configuration.isAnyEnabled()) {
+            return;
+        }
+
+        if (!lifecycle.getCurrentTestCaseOrStep().isPresent()) {
+            return;
+        }
+
+        getOrCreateSession(driver);
+    }
+
+    private BiDiSessionState getOrCreateSession(final WebDriver driver) {
+        sessionsLock.lock();
+        try {
+            final BiDiSessionState existing = sessions.get(driver);
+            if (existing != null) {
+                return existing;
+            }
+
+            try {
+                final BiDiSessionState created = BiDiSessionState.start(driver, configuration, sessionFactory);
+                if (created != null) {
+                    sessions.put(driver, created);
+                }
+                return created;
+            } catch (RuntimeException e) {
+                LOGGER.debug("Could not start WebDriver BiDi capture", e);
+                return null;
+            }
+        } finally {
+            sessionsLock.unlock();
+        }
+    }
+
+    private void closeSession(final WebDriver driver) {
+        final BiDiSessionState state;
+        sessionsLock.lock();
+        try {
+            state = sessions.remove(driver);
+        } finally {
+            sessionsLock.unlock();
+        }
+        safeFlushAndClose(state);
+    }
+
+    private void safeFlushAndClose(final BiDiSessionState state) {
+        if (state == null) {
+            return;
+        }
+        try {
+            state.flushAndClose(lifecycle);
+        } catch (RuntimeException e) {
+            LOGGER.debug("Could not flush WebDriver BiDi capture", e);
+        }
+    }
+}
diff --git a/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/BiDiAttachmentStorage.java b/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/BiDiAttachmentStorage.java
new file mode 100644
index 00000000..3743b74c
--- /dev/null
+++ b/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/BiDiAttachmentStorage.java
@@ -0,0 +1,144 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.seleniumbidi;
+
+import io.qameta.allure.AllureLifecycle;
+import org.openqa.selenium.json.Json;
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+final class BiDiAttachmentStorage {
+
+    static final String LOG_ATTACHMENT_NAME = "WebDriver BiDi logs";
+    static final String NETWORK_ATTACHMENT_NAME = "WebDriver BiDi network";
+
+    private static final String JSON_TYPE = "application/json";
+    private static final String JSON_EXTENSION = "json";
+    private static final Json JSON = new Json();
+
+    private final List<Map<String, Object>> logs = new ArrayList<>();
+    private final List<Map<String, Object>> network = new ArrayList<>();
+    private final Lock lock = new ReentrantLock();
+    private long droppedLogs;
+    private long droppedNetworkEvents;
+
+    void addLog(final BiDiLogEvent event, final int maxEntries) {
+        lock.lock();
+        try {
+            if (logs.size() < maxEntries) {
+                logs.add(event.toMap());
+            } else {
+                droppedLogs++;
+            }
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    void addNetwork(final BiDiNetworkEvent event,
+                    final int maxEntries,
+                    final HeaderRedactor redactor) {
+        lock.lock();
+        try {
+            if (network.size() < maxEntries) {
+                network.add(event.toMap(redactor));
+            } else {
+                droppedNetworkEvents++;
+            }
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    void flush(final AllureLifecycle lifecycle) {
+        try {
+            if (!lifecycle.getCurrentTestCaseOrStep().isPresent()) {
+                return;
+            }
+
+            logsAttachment()
+                    .ifPresent(
+                            body -> lifecycle.addAttachment(
+                                    LOG_ATTACHMENT_NAME,
+                                    JSON_TYPE,
+                                    JSON_EXTENSION,
+                                    body
+                            )
+                    );
+            networkAttachment()
+                    .ifPresent(
+                            body -> lifecycle.addAttachment(
+                                    NETWORK_ATTACHMENT_NAME,
+                                    JSON_TYPE,
+                                    JSON_EXTENSION,
+                                    body
+                            )
+                    );
+        } finally {
+            clear();
+        }
+    }
+
+    void clear() {
+        lock.lock();
+        try {
+            logs.clear();
+            network.clear();
+            droppedLogs = 0;
+            droppedNetworkEvents = 0;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    Optional<byte[]> logsAttachment() {
+        lock.lock();
+        try {
+            if (logs.isEmpty() && droppedLogs == 0) {
+                return Optional.empty();
+            }
+            return Optional.of(toJson(new ArrayList<>(logs), droppedLogs));
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    Optional<byte[]> networkAttachment() {
+        lock.lock();
+        try {
+            if (network.isEmpty() && droppedNetworkEvents == 0) {
+                return Optional.empty();
+            }
+            return Optional.of(toJson(new ArrayList<>(network), droppedNetworkEvents));
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    private static byte[] toJson(final List<Map<String, Object>> entries, final long dropped) {
+        final Map<String, Object> payload = new LinkedHashMap<>();
+        payload.put("entries", entries);
+        payload.put("dropped", dropped);
+        return JSON.toJson(payload).getBytes(StandardCharsets.UTF_8);
+    }
+}
diff --git a/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/BiDiConfiguration.java b/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/BiDiConfiguration.java
new file mode 100644
index 00000000..e313ca8b
--- /dev/null
+++ b/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/BiDiConfiguration.java
@@ -0,0 +1,83 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.seleniumbidi;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+final class BiDiConfiguration {
+
+    static final int DEFAULT_MAX_LOG_ENTRIES = 1_000;
+    static final int DEFAULT_MAX_NETWORK_EVENTS = 2_000;
+
+    private final AtomicBoolean logsEnabled = new AtomicBoolean(true);
+    private final AtomicBoolean networkEnabled = new AtomicBoolean(true);
+    private final AtomicInteger maxLogEntries = new AtomicInteger(DEFAULT_MAX_LOG_ENTRIES);
+    private final AtomicInteger maxNetworkEvents = new AtomicInteger(DEFAULT_MAX_NETWORK_EVENTS);
+    private final AtomicReference<HeaderRedactor> headerRedactor = new AtomicReference<>(HeaderRedactor.defaults());
+
+    boolean isLogsEnabled() {
+        return logsEnabled.get();
+    }
+
+    void setLogsEnabled(final boolean logsEnabled) {
+        this.logsEnabled.set(logsEnabled);
+    }
+
+    boolean isNetworkEnabled() {
+        return networkEnabled.get();
+    }
+
+    void setNetworkEnabled(final boolean networkEnabled) {
+        this.networkEnabled.set(networkEnabled);
+    }
+
+    boolean isAnyEnabled() {
+        return logsEnabled.get() || networkEnabled.get();
+    }
+
+    int getMaxLogEntries() {
+        return maxLogEntries.get();
+    }
+
+    void setMaxLogEntries(final int maxLogEntries) {
+        this.maxLogEntries.set(requireNonNegative(maxLogEntries, "maxLogEntries"));
+    }
+
+    int getMaxNetworkEvents() {
+        return maxNetworkEvents.get();
+    }
+
+    void setMaxNetworkEvents(final int maxNetworkEvents) {
+        this.maxNetworkEvents.set(requireNonNegative(maxNetworkEvents, "maxNetworkEvents"));
+    }
+
+    HeaderRedactor getHeaderRedactor() {
+        return headerRedactor.get();
+    }
+
+    void redactHeaders(final String... headerNames) {
+        this.headerRedactor.set(HeaderRedactor.defaults().withAdditionalHeaders(headerNames));
+    }
+
+    private static int requireNonNegative(final int value, final String name) {
+        if (value < 0) {
+            throw new IllegalArgumentException(name + " must be greater than or equal to zero");
+        }
+        return value;
+    }
+}
diff --git a/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/BiDiJsonKeys.java b/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/BiDiJsonKeys.java
new file mode 100644
index 00000000..d0720c0d
--- /dev/null
+++ b/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/BiDiJsonKeys.java
@@ -0,0 +1,32 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.seleniumbidi;
+
+final class BiDiJsonKeys {
+
+    static final String EVENT = "event";
+    static final String HEADERS = "headers";
+    static final String HEADERS_SIZE = "headersSize";
+    static final String REQUEST_ID = "requestId";
+    static final String TEXT = "text";
+    static final String TYPE = "type";
+    static final String URL = "url";
+    static final String VALUE = "value";
+
+    private BiDiJsonKeys() {
+        throw new IllegalStateException("Do not instance");
+    }
+}
diff --git a/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/BiDiLogEvent.java b/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/BiDiLogEvent.java
new file mode 100644
index 00000000..7d04ad6e
--- /dev/null
+++ b/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/BiDiLogEvent.java
@@ -0,0 +1,144 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.seleniumbidi;
+
+import org.openqa.selenium.bidi.log.BaseLogEntry;
+import org.openqa.selenium.bidi.log.ConsoleLogEntry;
+import org.openqa.selenium.bidi.log.GenericLogEntry;
+import org.openqa.selenium.bidi.log.JavascriptLogEntry;
+import org.openqa.selenium.bidi.log.LogEntry;
+import org.openqa.selenium.bidi.log.StackFrame;
+import org.openqa.selenium.bidi.log.StackTrace;
+import org.openqa.selenium.bidi.script.RemoteValue;
+import org.openqa.selenium.bidi.script.Source;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+@SuppressWarnings("PMD.ReturnEmptyCollectionRatherThanNull")
+final class BiDiLogEvent {
+
+    private final Map<String, Object> values;
+
+    private BiDiLogEvent(final Map<String, Object> values) {
+        this.values = values;
+    }
+
+    static List<BiDiLogEvent> from(final LogEntry entry) {
+        final List<BiDiLogEvent> events = new ArrayList<>(3);
+        entry.getConsoleLogEntry().ifPresent(console -> events.add(console(console)));
+        entry.getJavascriptLogEntry().ifPresent(javascript -> events.add(javascript(javascript)));
+        entry.getGenericLogEntry().ifPresent(generic -> events.add(generic(generic)));
+        return events;
+    }
+
+    static BiDiLogEvent generic(final GenericLogEntry entry) {
+        final Map<String, Object> values = base("generic", entry);
+        putIfNotNull(values, BiDiJsonKeys.TYPE, entry.getType());
+        return new BiDiLogEvent(values);
+    }
+
+    static BiDiLogEvent console(final ConsoleLogEntry entry) {
+        final Map<String, Object> values = base("console", entry);
+        putIfNotNull(values, BiDiJsonKeys.TYPE, entry.getType());
+        putIfNotNull(values, "method", entry.getMethod());
+        values.put("args", remoteValues(entry.getArgs()));
+        return new BiDiLogEvent(values);
+    }
+
+    static BiDiLogEvent javascript(final JavascriptLogEntry entry) {
+        final Map<String, Object> values = base("javascript", entry);
+        putIfNotNull(values, BiDiJsonKeys.TYPE, entry.getType());
+        return new BiDiLogEvent(values);
+    }
+
+    static BiDiLogEvent of(final String text) {
+        final Map<String, Object> values = new LinkedHashMap<>();
+        values.put(BiDiJsonKeys.EVENT, "log");
+        values.put(BiDiJsonKeys.TEXT, text);
+        return new BiDiLogEvent(values);
+    }
+
+    Map<String, Object> toMap() {
+        return new LinkedHashMap<>(values);
+    }
+
+    private static Map<String, Object> base(final String event, final BaseLogEntry entry) {
+        final Map<String, Object> values = new LinkedHashMap<>();
+        values.put(BiDiJsonKeys.EVENT, event);
+        putIfNotNull(values, "level", entry.getLevel());
+        putIfNotNull(values, BiDiJsonKeys.TEXT, entry.getText());
+        values.put("timestamp", entry.getTimestamp());
+        putIfNotNull(values, "source", source(entry.getSource()));
+        putIfNotNull(values, "stackTrace", stackTrace(entry.getStackTrace()));
+        return values;
+    }
+
+    private static Map<String, Object> source(final Source source) {
+        if (source == null) {
+            return null;
+        }
+        final Map<String, Object> values = new LinkedHashMap<>();
+        putIfNotNull(values, "realm", source.getRealm());
+        source.getBrowsingContext().ifPresent(context -> values.put("browsingContextId", context));
+        return values;
+    }
+
+    private static List<Map<String, Object>> remoteValues(final List<RemoteValue> remoteValues) {
+        final List<Map<String, Object>> result = new ArrayList<>();
+        if (remoteValues == null) {
+            return result;
+        }
+        remoteValues.forEach(remoteValue -> {
+            final Map<String, Object> value = new LinkedHashMap<>();
+            putIfNotNull(value, BiDiJsonKeys.TYPE, remoteValue.getType());
+            remoteValue.getValue().ifPresent(content -> value.put(BiDiJsonKeys.VALUE, content));
+            remoteValue.getHandle().ifPresent(handle -> value.put("handle", handle));
+            remoteValue.getInternalId().ifPresent(id -> value.put("internalId", id));
+            remoteValue.getSharedId().ifPresent(id -> value.put("sharedId", id));
+            result.add(value);
+        });
+        return result;
+    }
+
+    static Map<String, Object> stackTrace(final StackTrace stackTrace) {
+        if (stackTrace == null) {
+            return null;
+        }
+        final Map<String, Object> values = new LinkedHashMap<>();
+        final List<Map<String, Object>> frames = new ArrayList<>();
+        stackTrace.getCallFrames().forEach(frame -> frames.add(stackFrame(frame)));
+        values.put("callFrames", frames);
+        return values;
+    }
+
+    private static Map<String, Object> stackFrame(final StackFrame frame) {
+        final Map<String, Object> values = new LinkedHashMap<>();
+        putIfNotNull(values, "url", frame.getUrl());
+        putIfNotNull(values, "functionName", frame.getFunctionName());
+        values.put("lineNumber", frame.getLineNumber());
+        values.put("columnNumber", frame.getColumnNumber());
+        return values;
+    }
+
+    static void putIfNotNull(final Map<String, Object> values, final String name, final Object value) {
+        if (value != null) {
+            values.put(name, value);
+        }
+    }
+}
diff --git a/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/BiDiNetworkEvent.java b/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/BiDiNetworkEvent.java
new file mode 100644
index 00000000..d7bfa5c8
--- /dev/null
+++ b/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/BiDiNetworkEvent.java
@@ -0,0 +1,198 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.seleniumbidi;
+
+import org.openqa.selenium.bidi.network.BaseParameters;
+import org.openqa.selenium.bidi.network.BeforeRequestSent;
+import org.openqa.selenium.bidi.network.BytesValue;
+import org.openqa.selenium.bidi.network.FetchError;
+import org.openqa.selenium.bidi.network.FetchTimingInfo;
+import org.openqa.selenium.bidi.network.Header;
+import org.openqa.selenium.bidi.network.Initiator;
+import org.openqa.selenium.bidi.network.RequestData;
+import org.openqa.selenium.bidi.network.ResponseData;
+import org.openqa.selenium.bidi.network.ResponseDetails;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+@SuppressWarnings("PMD.ReturnEmptyCollectionRatherThanNull")
+final class BiDiNetworkEvent {
+
+    private final Map<String, Object> values;
+
+    private BiDiNetworkEvent(final Map<String, Object> values) {
+        this.values = values;
+    }
+
+    static BiDiNetworkEvent beforeRequestSent(final BeforeRequestSent event) {
+        final Map<String, Object> values = base("beforeRequestSent", event);
+        BiDiLogEvent.putIfNotNull(values, "initiator", initiator(event.getInitiator()));
+        return new BiDiNetworkEvent(values);
+    }
+
+    static BiDiNetworkEvent fetchError(final FetchError event) {
+        final Map<String, Object> values = base("fetchError", event);
+        BiDiLogEvent.putIfNotNull(values, "errorText", event.getErrorText());
+        return new BiDiNetworkEvent(values);
+    }
+
+    static BiDiNetworkEvent responseStarted(final ResponseDetails event) {
+        return response("responseStarted", event);
+    }
+
+    static BiDiNetworkEvent responseCompleted(final ResponseDetails event) {
+        return response("responseCompleted", event);
+    }
+
+    static BiDiNetworkEvent authRequired(final ResponseDetails event) {
+        return response("authRequired", event);
+    }
+
+    static BiDiNetworkEvent of(final String event, final Map<String, Object> values) {
+        final Map<String, Object> copy = new LinkedHashMap<>();
+        copy.put(BiDiJsonKeys.EVENT, event);
+        copy.putAll(values);
+        return new BiDiNetworkEvent(copy);
+    }
+
+    Map<String, Object> toMap(final HeaderRedactor redactor) {
+        return redactor.redact(values);
+    }
+
+    private static BiDiNetworkEvent response(final String name, final ResponseDetails event) {
+        final Map<String, Object> values = base(name, event);
+        BiDiLogEvent.putIfNotNull(values, "response", responseData(event.getResponseData()));
+        return new BiDiNetworkEvent(values);
+    }
+
+    private static Map<String, Object> responseData(final ResponseData response) {
+        if (response == null) {
+            return null;
+        }
+        final Map<String, Object> values = new LinkedHashMap<>();
+        BiDiLogEvent.putIfNotNull(values, BiDiJsonKeys.URL, response.getUrl());
+        BiDiLogEvent.putIfNotNull(values, "protocol", response.getProtocol());
+        values.put("status", response.getStatus());
+        BiDiLogEvent.putIfNotNull(values, "statusText", response.getStatusText());
+        values.put("fromCache", response.isFromCache());
+        values.put(BiDiJsonKeys.HEADERS, headers(response.getHeaders()));
+        BiDiLogEvent.putIfNotNull(values, "mimeType", response.getMimeType());
+        values.put("bytesReceived", response.getBytesReceived());
+        values.put(BiDiJsonKeys.HEADERS_SIZE, response.getHeadersSize());
+        values.put("bodySize", response.getBodySize());
+        response.getContent().ifPresent(content -> values.put("contentLength", content));
+        response.getAuthChallenge().ifPresent(challenge -> {
+            final Map<String, Object> authChallenge = new LinkedHashMap<>();
+            BiDiLogEvent.putIfNotNull(authChallenge, "scheme", challenge.getScheme());
+            BiDiLogEvent.putIfNotNull(authChallenge, "realm", challenge.getRealm());
+            values.put("authChallenge", authChallenge);
+        });
+        return values;
+    }
+
+    private static Map<String, Object> base(final String event, final BaseParameters parameters) {
+        final Map<String, Object> values = new LinkedHashMap<>();
+        values.put(BiDiJsonKeys.EVENT, event);
+        BiDiLogEvent.putIfNotNull(values, "browsingContextId", parameters.getBrowsingContextId());
+        values.put("blocked", parameters.isBlocked());
+        BiDiLogEvent.putIfNotNull(values, "navigationId", parameters.getNavigationId());
+        values.put("redirectCount", parameters.getRedirectCount());
+        BiDiLogEvent.putIfNotNull(values, "request", request(parameters.getRequest()));
+        values.put("timestamp", parameters.getTimestamp());
+        values.put("intercepts", parameters.getIntercepts());
+        return values;
+    }
+
+    private static Map<String, Object> request(final RequestData request) {
+        if (request == null) {
+            return null;
+        }
+        final Map<String, Object> values = new LinkedHashMap<>();
+        BiDiLogEvent.putIfNotNull(values, BiDiJsonKeys.REQUEST_ID, request.getRequestId());
+        BiDiLogEvent.putIfNotNull(values, BiDiJsonKeys.URL, request.getUrl());
+        BiDiLogEvent.putIfNotNull(values, "method", request.getMethod());
+        values.put(BiDiJsonKeys.HEADERS, headers(request.getHeaders()));
+        BiDiLogEvent.putIfNotNull(values, BiDiJsonKeys.HEADERS_SIZE, request.getHeadersSize());
+        BiDiLogEvent.putIfNotNull(values, "timings", timings(request.getTimings()));
+        return values;
+    }
+
+    private static List<Map<String, Object>> headers(final List<Header> headers) {
+        final List<Map<String, Object>> result = new ArrayList<>();
+        if (headers == null) {
+            return result;
+        }
+        headers.forEach(header -> {
+            final Map<String, Object> value = new LinkedHashMap<>();
+            BiDiLogEvent.putIfNotNull(value, "name", header.getName());
+            BiDiLogEvent.putIfNotNull(value, BiDiJsonKeys.VALUE, bytesValue(header.getValue()));
+            result.add(value);
+        });
+        return result;
+    }
+
+    private static Map<String, Object> bytesValue(final BytesValue bytesValue) {
+        if (bytesValue == null) {
+            return null;
+        }
+        final Map<String, Object> value = new LinkedHashMap<>();
+        BiDiLogEvent.putIfNotNull(value, BiDiJsonKeys.TYPE, bytesValue.getType());
+        BiDiLogEvent.putIfNotNull(value, BiDiJsonKeys.VALUE, bytesValue.getValue());
+        return value;
+    }
+
+    private static Map<String, Object> timings(final FetchTimingInfo timings) {
+        if (timings == null) {
+            return null;
+        }
+        final Map<String, Object> values = new LinkedHashMap<>();
+        values.put("timeOrigin", timings.getTimeOrigin());
+        values.put("requestTime", timings.getRequestTime());
+        values.put("redirectStart", timings.getRedirectStart());
+        values.put("redirectEnd", timings.getRedirectEnd());
+        values.put("fetchStart", timings.getFetchStart());
+        values.put("dnsStart", timings.getDnsStart());
+        values.put("dnsEnd", timings.getDnsEnd());
+        values.put("connectStart", timings.getConnectStart());
+        values.put("connectEnd", timings.getConnectEnd());
+        values.put("tlsStart", timings.getTlsStart());
+        values.put("requestStart", timings.getRequestStart());
+        values.put("responseStart", timings.getResponseStart());
+        values.put("responseEnd", timings.getResponseEnd());
+        return values;
+    }
+
+    private static Map<String, Object> initiator(final Initiator initiator) {
+        if (initiator == null) {
+            return null;
+        }
+        final Map<String, Object> values = new LinkedHashMap<>();
+        BiDiLogEvent.putIfNotNull(values, BiDiJsonKeys.TYPE, initiator.getType());
+        initiator.getColumnNumber().ifPresent(column -> values.put("columnNumber", column));
+        initiator.getLineNumber().ifPresent(line -> values.put("lineNumber", line));
+        initiator.getRequestId().ifPresent(requestId -> values.put(BiDiJsonKeys.REQUEST_ID, requestId));
+        initiator.getStackTrace().ifPresent(
+                stackTrace -> values.put(
+                        "stackTrace",
+                        BiDiLogEvent.stackTrace(stackTrace)
+                )
+        );
+        return values;
+    }
+}
diff --git a/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/BiDiSessionFactory.java b/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/BiDiSessionFactory.java
new file mode 100644
index 00000000..e0578beb
--- /dev/null
+++ b/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/BiDiSessionFactory.java
@@ -0,0 +1,29 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.seleniumbidi;
+
+import org.openqa.selenium.WebDriver;
+
+import java.util.function.Consumer;
+
+@FunctionalInterface
+interface BiDiSessionFactory {
+
+    RecordingSession start(WebDriver driver,
+                           BiDiConfiguration configuration,
+                           Consumer<BiDiLogEvent> logConsumer,
+                           Consumer<BiDiNetworkEvent> networkConsumer);
+}
diff --git a/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/BiDiSessionState.java b/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/BiDiSessionState.java
new file mode 100644
index 00000000..c1332a83
--- /dev/null
+++ b/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/BiDiSessionState.java
@@ -0,0 +1,97 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.seleniumbidi;
+
+import io.qameta.allure.AllureLifecycle;
+import org.openqa.selenium.WebDriver;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+final class BiDiSessionState {
+
+    private final BiDiConfiguration configuration;
+    private final BiDiAttachmentStorage storage = new BiDiAttachmentStorage();
+    private final AtomicBoolean closed = new AtomicBoolean();
+    private final AtomicReference<RecordingSession> recordingSession = new AtomicReference<>();
+
+    private BiDiSessionState(final BiDiConfiguration configuration) {
+        this.configuration = configuration;
+    }
+
+    static BiDiSessionState start(final WebDriver driver,
+                                  final BiDiConfiguration configuration,
+                                  final BiDiSessionFactory sessionFactory) {
+        final BiDiSessionState state = new BiDiSessionState(configuration);
+        final RecordingSession session = sessionFactory.start(
+                driver,
+                configuration,
+                state::recordLog,
+                state::recordNetwork
+        );
+        if (session == null) {
+            return null;
+        }
+        state.recordingSession.set(session);
+        return state;
+    }
+
+    void recordLog(final BiDiLogEvent event) {
+        if (closed.get() || !configuration.isLogsEnabled()) {
+            return;
+        }
+        storage.addLog(
+                event,
+                configuration.getMaxLogEntries()
+        );
+    }
+
+    void recordNetwork(final BiDiNetworkEvent event) {
+        if (closed.get() || !configuration.isNetworkEnabled()) {
+            return;
+        }
+        storage.addNetwork(
+                event,
+                configuration.getMaxNetworkEvents(),
+                configuration.getHeaderRedactor()
+        );
+    }
+
+    void flushAndClose(final AllureLifecycle lifecycle) {
+        closed.set(true);
+        try {
+            closeRecordingSession();
+        } finally {
+            storage.flush(lifecycle);
+        }
+    }
+
+    void close() {
+        closed.set(true);
+        try {
+            closeRecordingSession();
+        } finally {
+            storage.clear();
+        }
+    }
+
+    private void closeRecordingSession() {
+        final RecordingSession session = recordingSession.getAndSet(null);
+        if (session != null) {
+            session.close();
+        }
+    }
+}
diff --git a/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/HeaderRedactor.java b/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/HeaderRedactor.java
new file mode 100644
index 00000000..1367233d
--- /dev/null
+++ b/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/HeaderRedactor.java
@@ -0,0 +1,129 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.seleniumbidi;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+final class HeaderRedactor {
+
+    static final String REDACTED = "[REDACTED]";
+
+    private static final Set<String> DEFAULT_HEADERS = new LinkedHashSet<>(
+            Arrays.asList(
+                    "authorization",
+                    "proxy-authorization",
+                    "cookie",
+                    "set-cookie",
+                    "x-api-key"
+            )
+    );
+
+    private final Set<String> headerNames;
+
+    private HeaderRedactor(final Set<String> headerNames) {
+        this.headerNames = headerNames;
+    }
+
+    static HeaderRedactor defaults() {
+        return new HeaderRedactor(DEFAULT_HEADERS);
+    }
+
+    HeaderRedactor withAdditionalHeaders(final String... additionalHeaders) {
+        final Set<String> headers = new LinkedHashSet<>(headerNames);
+        if (additionalHeaders != null) {
+            Arrays.stream(additionalHeaders)
+                    .map(HeaderRedactor::normalize)
+                    .filter(value -> !value.isEmpty())
+                    .forEach(headers::add);
+        }
+        return new HeaderRedactor(headers);
+    }
+
+    Map<String, Object> redact(final Map<String, Object> values) {
+        return redactMap(values);
+    }
+
+    private Map<String, Object> redactMap(final Map<String, Object> values) {
+        final Map<String, Object> result = new LinkedHashMap<>();
+        values.forEach((key, value) -> {
+            if (BiDiJsonKeys.HEADERS.equals(key) && value instanceof List) {
+                result.put(key, redactHeaders((List<?>) value));
+            } else if (value instanceof Map) {
+                result.put(key, redactMap(castMap(value)));
+            } else if (value instanceof List) {
+                result.put(key, redactList((List<?>) value));
+            } else {
+                result.put(key, value);
+            }
+        });
+        return result;
+    }
+
+    private List<Object> redactList(final List<?> values) {
+        final List<Object> result = new ArrayList<>();
+        values.forEach(value -> {
+            if (value instanceof Map) {
+                result.add(redactMap(castMap(value)));
+            } else if (value instanceof List) {
+                result.add(redactList((List<?>) value));
+            } else {
+                result.add(value);
+            }
+        });
+        return result;
+    }
+
+    private List<Object> redactHeaders(final List<?> headers) {
+        return headers.stream()
+                .map(header -> header instanceof Map ? redactHeader(castMap(header)) : header)
+                .collect(Collectors.toList());
+    }
+
+    private Map<String, Object> redactHeader(final Map<String, Object> header) {
+        final Map<String, Object> result = new LinkedHashMap<>(header);
+        final Object name = result.get("name");
+        if (name instanceof String && headerNames.contains(normalize((String) name))) {
+            result.put(BiDiJsonKeys.VALUE, redactedValue(result.get(BiDiJsonKeys.VALUE)));
+        }
+        return result;
+    }
+
+    private Object redactedValue(final Object value) {
+        if (value instanceof Map) {
+            final Map<String, Object> redacted = new LinkedHashMap<>(castMap(value));
+            redacted.put(BiDiJsonKeys.VALUE, REDACTED);
+            return redacted;
+        }
+        return REDACTED;
+    }
+
+    @SuppressWarnings("unchecked")
+    private static Map<String, Object> castMap(final Object value) {
+        return (Map<String, Object>) value;
+    }
+
+    private static String normalize(final String headerName) {
+        return headerName == null ? "" : headerName.toLowerCase(Locale.ROOT);
+    }
+}
diff --git a/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/RecordingSession.java b/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/RecordingSession.java
new file mode 100644
index 00000000..b1db141c
--- /dev/null
+++ b/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/RecordingSession.java
@@ -0,0 +1,22 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.seleniumbidi;
+
+@FunctionalInterface
+interface RecordingSession {
+
+    void close();
+}
diff --git a/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/SeleniumBiDiSessionFactory.java b/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/SeleniumBiDiSessionFactory.java
new file mode 100644
index 00000000..2285813d
--- /dev/null
+++ b/allure-selenium-bidi/src/main/java/io/qameta/allure/seleniumbidi/SeleniumBiDiSessionFactory.java
@@ -0,0 +1,90 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.seleniumbidi;
+
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.bidi.HasBiDi;
+import org.openqa.selenium.bidi.module.LogInspector;
+import org.openqa.selenium.bidi.module.Network;
+import org.openqa.selenium.remote.Augmenter;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+
+final class SeleniumBiDiSessionFactory implements BiDiSessionFactory {
+
+    @Override
+    public RecordingSession start(final WebDriver driver,
+                                  final BiDiConfiguration configuration,
+                                  final Consumer<BiDiLogEvent> logConsumer,
+                                  final Consumer<BiDiNetworkEvent> networkConsumer) {
+        final WebDriver bidiDriver = toBiDiDriver(driver);
+        if (bidiDriver == null) {
+            return null;
+        }
+
+        final List<AutoCloseable> inspectors = new ArrayList<>();
+        if (configuration.isLogsEnabled()) {
+            final LogInspector logInspector = new LogInspector(bidiDriver);
+            logInspector.onLog(entry -> BiDiLogEvent.from(entry).forEach(logConsumer));
+            inspectors.add(logInspector);
+        }
+        if (configuration.isNetworkEnabled()) {
+            final Network network = new Network(bidiDriver);
+            network.onBeforeRequestSent(event -> networkConsumer.accept(BiDiNetworkEvent.beforeRequestSent(event)));
+            network.onFetchError(event -> networkConsumer.accept(BiDiNetworkEvent.fetchError(event)));
+            network.onResponseStarted(event -> networkConsumer.accept(BiDiNetworkEvent.responseStarted(event)));
+            network.onResponseCompleted(event -> networkConsumer.accept(BiDiNetworkEvent.responseCompleted(event)));
+            network.onAuthRequired(event -> networkConsumer.accept(BiDiNetworkEvent.authRequired(event)));
+            inspectors.add(network);
+        }
+        return new SeleniumRecordingSession(inspectors);
+    }
+
+    private WebDriver toBiDiDriver(final WebDriver driver) {
+        if (isBiDiAvailable(driver)) {
+            return driver;
+        }
+
+        final WebDriver augmented = new Augmenter().augment(driver);
+        return isBiDiAvailable(augmented) ? augmented : null;
+    }
+
+    private boolean isBiDiAvailable(final WebDriver driver) {
+        return driver instanceof HasBiDi && ((HasBiDi) driver).maybeGetBiDi().isPresent();
+    }
+
+    private static final class SeleniumRecordingSession implements RecordingSession {
+
+        private final List<AutoCloseable> inspectors;
+
+        private SeleniumRecordingSession(final List<AutoCloseable> inspectors) {
+            this.inspectors = inspectors;
+        }
+
+        @Override
+        public void close() {
+            inspectors.forEach(inspector -> {
+                try {
+                    inspector.close();
+                } catch (Exception ignored) {
+                    // ignore cleanup failures; reporting must not affect WebDriver teardown
+                }
+            });
+        }
+    }
+}
diff --git a/allure-selenium-bidi/src/test/java/io/qameta/allure/seleniumbidi/AllureWebDriverBiDiTest.java b/allure-selenium-bidi/src/test/java/io/qameta/allure/seleniumbidi/AllureWebDriverBiDiTest.java
new file mode 100644
index 00000000..5a0e16e1
--- /dev/null
+++ b/allure-selenium-bidi/src/test/java/io/qameta/allure/seleniumbidi/AllureWebDriverBiDiTest.java
@@ -0,0 +1,908 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.seleniumbidi;
+
+import com.sun.net.httpserver.HttpExchange;
+import com.sun.net.httpserver.HttpServer;
+import io.qameta.allure.Allure;
+import io.qameta.allure.Description;
+import io.qameta.allure.Param;
+import io.qameta.allure.Step;
+import io.qameta.allure.model.Attachment;
+import io.qameta.allure.model.Status;
+import io.qameta.allure.model.StepResult;
+import io.qameta.allure.model.TestResult;
+import io.qameta.allure.test.AllureFeatures;
+import io.qameta.allure.test.AllureResults;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.parallel.ResourceLock;
+import org.openqa.selenium.By;
+import org.openqa.selenium.JavascriptExecutor;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.chrome.ChromeOptions;
+import org.openqa.selenium.json.Json;
+import org.openqa.selenium.remote.RemoteWebDriver;
+import org.openqa.selenium.support.ui.WebDriverWait;
+import org.testcontainers.Testcontainers;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.utility.DockerImageName;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.ServerSocket;
+import java.net.URI;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+import static io.qameta.allure.model.Parameter.Mode.HIDDEN;
+import static io.qameta.allure.test.RunUtils.runWithinTestContext;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.tuple;
+import static org.junit.jupiter.api.parallel.ResourceAccessMode.READ_WRITE;
+
+/**
+ * Real browser integration tests for the Selenium WebDriver BiDi adapter.
+ */
+@ResourceLock(
+        value = "io.qameta.allure.seleniumbidi.lifecycle",
+        mode = READ_WRITE
+)
+class AllureWebDriverBiDiTest {
+
+    private static final Json JSON = new Json();
+    private static final int SELENIUM_PORT = 4444;
+    private static final long SELENIUM_SHARED_MEMORY = 2L * 1024 * 1024 * 1024;
+    private static final String IMAGE_PROPERTY = "allure.selenium.bidi.integration.image";
+    private static final String SELENIUM_IMAGE_TAG = "4.23.0";
+    private static final String LOCALHOST_URL_FORMAT = "http://localhost:%d";
+    private static final String DEFAULT_PAGE = "/";
+    private static final String LOGS_PAGE = "/logs";
+    private static final String NETWORK_PAGE = "/network";
+    private static final String PING_PATH = "/ping";
+    private static final String HTML_TYPE = "text/html";
+    private static final String WAIT_FOR_BIDI_INTERRUPTED = "Interrupted while waiting for BiDi events";
+    private static final String DROPPED_KEY = "dropped";
+    private static final String ENTRIES_KEY = "entries";
+    private static final String CONSOLE_LOG = "bidi-it-console";
+    private static final String FETCH_LOG = "bidi-it-fetch-ok";
+    private static final String SECOND_CONSOLE_LOG = "bidi-it-second-console";
+    private static final String CUSTOM_PAGE = "/custom";
+    private static final String API_KEY_HEADER_NAME = "X-Api-Key";
+    private static final String CUSTOM_HEADER_NAME = "X-Secret-Token";
+    private static final String TRACE_HEADER_NAME = "X-Trace-Id";
+    private static final String CUSTOM_SECRET = "custom-integration-secret";
+    private static final String VISIBLE_HEADER_VALUE = "visible-integration-value";
+    private static final String API_KEY = "integration-secret";
+    private static final ThreadLocal<Integer> SERVER_PORT = new ThreadLocal<>();
+
+    /**
+     * Checks that console log entries are attached as WebDriver BiDi log data.
+     *
+     * The test emits two browser console messages and verifies that the log attachment contains exactly those messages
+     * without exercising network assertions.
+     */
+    @Description
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachConsoleLogs() throws IOException {
+        final AllureResults results = runTestWithSeleniumBidi(
+                chromeOptions(),
+                listener -> listener.network(false),
+                driver -> {
+                    driver.get(testServerUrl(LOGS_PAGE));
+                    waitUntilPageDone(driver);
+                    driver.findElement(By.tagName("body"));
+                }
+        );
+
+        assertThat(attachmentNames(results))
+                .containsExactly(BiDiAttachmentStorage.LOG_ATTACHMENT_NAME);
+        final Map<String, Object> payload = attachmentPayload(results, BiDiAttachmentStorage.LOG_ATTACHMENT_NAME);
+        assertThat(entries(payload))
+                .hasSize(2)
+                .extracting(entry -> entry.get("text"))
+                .containsExactlyInAnyOrder(CONSOLE_LOG, SECOND_CONSOLE_LOG);
+        assertDropped(payload, 0);
+    }
+
+    /**
+     * Checks that console log metadata is attached as WebDriver BiDi log data.
+     *
+     * The test emits a browser console message and verifies event metadata such as level, method, source, stack trace,
+     * timestamp, and argument data.
+     */
+    @Description
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachConsoleLogMetadata() throws IOException {
+        final AllureResults results = runTestWithSeleniumBidi(
+                chromeOptions(),
+                listener -> listener.network(false),
+                driver -> {
+                    driver.get(testServerUrl(LOGS_PAGE));
+                    waitUntilPageDone(driver);
+                    driver.findElement(By.tagName("body"));
+                }
+        );
+
+        final Map<String, Object> payload = attachmentPayload(results, BiDiAttachmentStorage.LOG_ATTACHMENT_NAME);
+        final Map<String, Object> entry = entries(payload).stream()
+                .filter(item -> CONSOLE_LOG.equals(item.get("text")))
+                .findFirst()
+                .orElseThrow(() -> new AssertionError("Console log entry not found"));
+        assertThat(entry)
+                .containsEntry("event", "console")
+                .containsEntry("level", "info")
+                .containsEntry("method", "log")
+                .containsEntry("type", "console");
+        assertThat(((Number) entry.get("timestamp")).longValue()).isPositive();
+        assertThat(object(entry, "source").get("browsingContextId"))
+                .isInstanceOf(String.class)
+                .asString()
+                .isNotBlank();
+        assertThat(objects(object(entry, "stackTrace"), "callFrames"))
+                .extracting(frame -> String.valueOf(frame.get("url")))
+                .anyMatch(url -> url.contains(LOGS_PAGE));
+        final Map<String, Object> argument = objects(entry, "args").get(0);
+        assertThat(argument)
+                .containsEntry("type", "string")
+                .containsEntry("value", CONSOLE_LOG);
+    }
+
+    /**
+     * Checks that request and response metadata are attached as WebDriver BiDi network data.
+     *
+     * The test performs a browser fetch and verifies that the network attachment contains request and completed response
+     * events for the fetched URL.
+     */
+    @Description
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachNetworkEvents() throws IOException {
+        final AllureResults results = runTestWithSeleniumBidi(
+                chromeOptions(),
+                listener -> listener.logs(false),
+                driver -> {
+                    driver.get(testServerUrl(NETWORK_PAGE));
+                    waitUntilPageDone(driver);
+                    driver.findElement(By.tagName("body"));
+                }
+        );
+
+        assertThat(attachmentNames(results))
+                .containsExactly(BiDiAttachmentStorage.NETWORK_ATTACHMENT_NAME);
+        final Map<String, Object> payload = attachmentPayload(results, BiDiAttachmentStorage.NETWORK_ATTACHMENT_NAME);
+        assertThat(object(networkEntry(payload, "beforeRequestSent", PING_PATH), "request").get("url"))
+                .asString()
+                .contains(PING_PATH);
+        assertThat(object(networkEntry(payload, "responseCompleted", PING_PATH), "response").get("url"))
+                .asString()
+                .contains(PING_PATH);
+        assertDropped(payload, 0);
+    }
+
+    /**
+     * Checks that request metadata is attached as WebDriver BiDi network data.
+     *
+     * The test performs a browser fetch and verifies the captured request URL, method, request id, timing object, and
+     * browser context fields.
+     */
+    @Description
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachNetworkRequestMetadata() throws IOException {
+        final AllureResults results = runTestWithSeleniumBidi(
+                chromeOptions(),
+                listener -> listener.logs(false),
+                driver -> {
+                    driver.get(testServerUrl(NETWORK_PAGE));
+                    waitUntilPageDone(driver);
+                    driver.findElement(By.tagName("body"));
+                }
+        );
+
+        final Map<String, Object> payload = attachmentPayload(results, BiDiAttachmentStorage.NETWORK_ATTACHMENT_NAME);
+        final Map<String, Object> entry = networkEntry(payload, "beforeRequestSent", PING_PATH);
+        final Map<String, Object> request = object(entry, "request");
+        assertThat(String.valueOf(request.get("url"))).contains(PING_PATH);
+        assertThat(request.get("method")).isEqualTo("GET");
+        assertThat(request.get("requestId"))
+                .isInstanceOf(String.class)
+                .asString()
+                .isNotBlank();
+        assertThat(object(request, "timings"))
+                .containsKeys("requestStart", "responseEnd");
+        assertThat(entry.get("browsingContextId"))
+                .isInstanceOf(String.class)
+                .asString()
+                .isNotBlank();
+        assertThat(((Number) entry.get("timestamp")).longValue()).isPositive();
+        assertThat(entry.get("blocked")).isEqualTo(false);
+        assertThat(((Number) entry.get("redirectCount")).longValue()).isZero();
+        assertThat(objects(entry, "intercepts")).isEmpty();
+        assertThat(object(entry, "initiator").get("type")).isEqualTo("script");
+    }
+
+    /**
+     * Checks that response metadata is attached as WebDriver BiDi network data.
+     *
+     * The test performs a browser fetch and verifies the captured response URL, status, MIME type, protocol, cache flag,
+     * size counters, and headers.
+     */
+    @Description
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachNetworkResponseMetadata() throws IOException {
+        final AllureResults results = runTestWithSeleniumBidi(
+                chromeOptions(),
+                listener -> listener.logs(false),
+                driver -> {
+                    driver.get(testServerUrl(NETWORK_PAGE));
+                    waitUntilPageDone(driver);
+                    driver.findElement(By.tagName("body"));
+                }
+        );
+
+        final Map<String, Object> payload = attachmentPayload(results, BiDiAttachmentStorage.NETWORK_ATTACHMENT_NAME);
+        final Map<String, Object> response = object(networkEntry(payload, "responseCompleted", PING_PATH), "response");
+        assertThat(String.valueOf(response.get("url"))).contains(PING_PATH);
+        assertThat(response)
+                .containsEntry("protocol", "http/1.1")
+                .containsEntry("statusText", "OK")
+                .containsEntry("fromCache", false)
+                .containsEntry("mimeType", "text/plain");
+        assertThat(((Number) response.get("status")).longValue()).isEqualTo(200L);
+        assertThat(((Number) response.get("bytesReceived")).longValue()).isPositive();
+        assertThat(((Number) response.get("headersSize")).longValue()).isPositive();
+        assertThat(headerValue(response, "Content-type")).isEqualTo("text/plain");
+    }
+
+    /**
+     * Checks that built-in sensitive headers are redacted in network attachments.
+     *
+     * The test sends an API key request header and verifies that the attached request metadata contains the header name
+     * but not the header value.
+     */
+    @Description
+    @AllureFeatures.Attachments
+    @Test
+    void shouldRedactDefaultSensitiveHeaders() throws IOException {
+        final AllureResults results = runTestWithSeleniumBidi(
+                chromeOptions(),
+                listener -> listener.logs(false),
+                driver -> {
+                    driver.get(testServerUrl(NETWORK_PAGE));
+                    waitUntilPageDone(driver);
+                    driver.findElement(By.tagName("body"));
+                }
+        );
+
+        final Map<String, Object> payload = attachmentPayload(results, BiDiAttachmentStorage.NETWORK_ATTACHMENT_NAME);
+        final Map<String, Object> request = object(networkEntry(payload, "beforeRequestSent", PING_PATH), "request");
+        assertThat(headerValue(request, API_KEY_HEADER_NAME)).isEqualTo(HeaderRedactor.REDACTED);
+        assertThat(attachmentContent(results, BiDiAttachmentStorage.NETWORK_ATTACHMENT_NAME))
+                .doesNotContain(API_KEY);
+    }
+
+    /**
+     * Checks that user-configured sensitive headers are redacted in network attachments.
+     *
+     * The test sends one custom secret header and one visible tracing header, then verifies that only the tracing value
+     * survives redaction.
+     */
+    @Description
+    @AllureFeatures.Attachments
+    @Test
+    void shouldRedactCustomHeaders() throws IOException {
+        final AllureResults results = runTestWithSeleniumBidi(
+                chromeOptions(),
+                listener -> listener.logs(false).redactHeaders(CUSTOM_HEADER_NAME),
+                driver -> {
+                    driver.get(testServerUrl(CUSTOM_PAGE));
+                    waitUntilPageDone(driver);
+                    driver.findElement(By.tagName("body"));
+                }
+        );
+
+        final Map<String, Object> payload = attachmentPayload(results, BiDiAttachmentStorage.NETWORK_ATTACHMENT_NAME);
+        final Map<String, Object> request = object(networkEntry(payload, "beforeRequestSent", PING_PATH), "request");
+        assertThat(headerValue(request, CUSTOM_HEADER_NAME)).isEqualTo(HeaderRedactor.REDACTED);
+        assertThat(headerValue(request, TRACE_HEADER_NAME)).isEqualTo(VISIBLE_HEADER_VALUE);
+        assertThat(attachmentContent(results, BiDiAttachmentStorage.NETWORK_ATTACHMENT_NAME))
+                .doesNotContain(CUSTOM_SECRET);
+    }
+
+    /**
+     * Checks that disabled log capture does not write a log attachment.
+     *
+     * The test opens a page that emits console logs while log capture is disabled and verifies that only network data is
+     * attached.
+     */
+    @Description
+    @AllureFeatures.Attachments
+    @Test
+    void shouldDisableLogCapture() throws IOException {
+        final AllureResults results = runTestWithSeleniumBidi(
+                chromeOptions(),
+                listener -> listener.logs(false),
+                driver -> {
+                    driver.get(testServerUrl(LOGS_PAGE));
+                    waitUntilPageDone(driver);
+                    driver.findElement(By.tagName("body"));
+                }
+        );
+
+        assertThat(attachmentNames(results))
+                .containsExactly(BiDiAttachmentStorage.NETWORK_ATTACHMENT_NAME);
+    }
+
+    /**
+     * Checks that disabled network capture does not write a network attachment.
+     *
+     * The test opens a page that emits both console logs and network activity while network capture is disabled, then
+     * verifies that only log data is attached.
+     */
+    @Description
+    @AllureFeatures.Attachments
+    @Test
+    void shouldDisableNetworkCapture() throws IOException {
+        final AllureResults results = runTestWithSeleniumBidi(
+                chromeOptions(),
+                listener -> listener.network(false),
+                driver -> {
+                    driver.get(testServerUrl(DEFAULT_PAGE));
+                    waitUntilPageDone(driver);
+                    driver.findElement(By.tagName("body"));
+                }
+        );
+
+        assertThat(attachmentNames(results))
+                .containsExactly(BiDiAttachmentStorage.LOG_ATTACHMENT_NAME);
+        final Map<String, Object> payload = attachmentPayload(results, BiDiAttachmentStorage.LOG_ATTACHMENT_NAME);
+        assertThat(entries(payload))
+                .extracting(entry -> entry.get("text"))
+                .contains(CONSOLE_LOG, SECOND_CONSOLE_LOG, FETCH_LOG);
+    }
+
+    /**
+     * Checks that the log attachment reports dropped entries when the log cap is reached.
+     *
+     * The test limits log capture to one entry, emits two console messages, and verifies both the retained entry count
+     * and dropped counter.
+     */
+    @Description
+    @AllureFeatures.Attachments
+    @Test
+    void shouldTrackDroppedLogEntries() throws IOException {
+        final AllureResults results = runTestWithSeleniumBidi(
+                chromeOptions(),
+                listener -> listener.network(false).maxLogEntries(1),
+                driver -> {
+                    driver.get(testServerUrl(LOGS_PAGE));
+                    waitUntilPageDone(driver);
+                    driver.findElement(By.tagName("body"));
+                }
+        );
+
+        final Map<String, Object> payload = attachmentPayload(results, BiDiAttachmentStorage.LOG_ATTACHMENT_NAME);
+        assertThat(entries(payload)).hasSize(1);
+        assertDropped(payload, 1);
+    }
+
+    /**
+     * Checks that the network attachment reports dropped events when the network cap is reached.
+     *
+     * The test limits network capture to one event, performs browser network activity, and verifies that additional
+     * events are counted as dropped.
+     */
+    @Description
+    @AllureFeatures.Attachments
+    @Test
+    void shouldTrackDroppedNetworkEvents() throws IOException {
+        final AllureResults results = runTestWithSeleniumBidi(
+                chromeOptions(),
+                listener -> listener.logs(false).maxNetworkEvents(1),
+                driver -> {
+                    driver.get(testServerUrl(NETWORK_PAGE));
+                    waitUntilPageDone(driver);
+                    driver.findElement(By.tagName("body"));
+                }
+        );
+
+        final Map<String, Object> payload = attachmentPayload(results, BiDiAttachmentStorage.NETWORK_ATTACHMENT_NAME);
+        assertThat(entries(payload)).hasSize(1);
+        assertThat(((Number) payload.get(DROPPED_KEY)).longValue()).isPositive();
+    }
+
+    /**
+     * Checks that closing the listener flushes buffered BiDi data.
+     *
+     * The test closes {@link AllureWebDriverBiDi} before WebDriver quit and verifies that collected log data is still
+     * attached.
+     */
+    @Description
+    @AllureFeatures.Attachments
+    @Test
+    void shouldFlushBufferedEventsWhenListenerCloses() throws IOException {
+        final AllureResults results = runTestWithSeleniumBidi(
+                chromeOptions(),
+                listener -> listener.network(false),
+                true,
+                driver -> {
+                    driver.get(testServerUrl(LOGS_PAGE));
+                    waitUntilPageDone(driver);
+                    driver.findElement(By.tagName("body"));
+                }
+        );
+
+        final Map<String, Object> payload = attachmentPayload(results, BiDiAttachmentStorage.LOG_ATTACHMENT_NAME);
+        assertThat(entries(payload))
+                .extracting(entry -> entry.get("text"))
+                .contains(CONSOLE_LOG, SECOND_CONSOLE_LOG);
+    }
+
+    /**
+     * Checks that a driver session without BiDi support does not attach data.
+     *
+     * The test starts Chrome without BiDi enabled and verifies that browser activity does not produce BiDi attachments.
+     */
+    @Description
+    @AllureFeatures.Attachments
+    @Test
+    void shouldNotAttachDataWhenBiDiIsUnavailable() throws IOException {
+        final AllureResults results = runTestWithSeleniumBidi(chromeOptionsWithoutBiDi(), driver -> {
+            driver.get(testServerUrl(DEFAULT_PAGE));
+            waitUntilPageDone(driver);
+            driver.findElement(By.tagName("body"));
+        });
+
+        assertThat(attachmentNames(results)).isEmpty();
+    }
+
+    /**
+     * Checks that WebDriver interactions inside a user-created runtime step keep the expected Allure step tree.
+     *
+     * The test opens a real browser page inside {@code Allure.step(...)} and verifies that the runtime step is preserved
+     * as the parent for helper steps executed from the lambda, while BiDi data is still attached to the generated result.
+     */
+    @Description
+    @AllureFeatures.Attachments
+    @AllureFeatures.Steps
+    @Test
+    void shouldNestRuntimeStepAroundWebDriverInteractions() throws IOException {
+        final AllureResults results = runTestWithSeleniumBidi(
+                chromeOptions(),
+                listener -> listener.network(false),
+                driver -> Allure.step("Open page in runtime step", () -> {
+                    driver.get(testServerUrl(LOGS_PAGE));
+                    waitUntilPageDone(driver);
+                    driver.findElement(By.tagName("body"));
+                })
+        );
+
+        final TestResult testResult = singleTestResult(results);
+        assertThat(attachments(testResult))
+                .extracting(Attachment::getName)
+                .contains(BiDiAttachmentStorage.LOG_ATTACHMENT_NAME);
+
+        final StepResult scenarioStep = step(testResult.getSteps(), "Run ready Selenium WebDriver scenario");
+        assertThat(scenarioStep.getSteps())
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsSubsequence(
+                        tuple("Open page in runtime step", Status.PASSED),
+                        tuple("Wait for asynchronous WebDriver BiDi events", Status.PASSED)
+                );
+
+        final StepResult runtimeStep = step(scenarioStep.getSteps(), "Open page in runtime step");
+        assertThat(runtimeStep)
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactly("Open page in runtime step", Status.PASSED);
+        assertThat(runtimeStep.getSteps())
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactly(tuple("Wait until test page finishes browser activity", Status.PASSED));
+    }
+
+    @Step("Start Selenium Testcontainers browser")
+    private static GenericContainer<?> startSeleniumContainer(final int seleniumPort) {
+        final GenericContainer<?> selenium = seleniumContainer(seleniumPort);
+        selenium.start();
+        return selenium;
+    }
+
+    private static GenericContainer<?> seleniumContainer(final int seleniumPort) {
+        final GenericContainer<?> container = new GenericContainer<>(seleniumImage())
+                .withExposedPorts(SELENIUM_PORT)
+                .withSharedMemorySize(SELENIUM_SHARED_MEMORY)
+                .withEnv("SE_NODE_GRID_URL", seleniumEndpoint(seleniumPort))
+                .waitingFor(Wait.forHttp("/status").forPort(SELENIUM_PORT).forStatusCode(200));
+        container.setPortBindings(Collections.singletonList(String.format("%d:%d", seleniumPort, SELENIUM_PORT)));
+        return container;
+    }
+
+    private static DockerImageName seleniumImage() {
+        return DockerImageName.parse(System.getProperty(IMAGE_PROPERTY, defaultImage()));
+    }
+
+    private static String defaultImage() {
+        final String architecture = System.getProperty("os.arch", "");
+        final String image = architecture.contains("aarch64") || architecture.contains("arm64")
+                ? "selenium/standalone-chromium"
+                : "selenium/standalone-chrome";
+        return String.format("%s:%s", image, SELENIUM_IMAGE_TAG);
+    }
+
+    @Step("Start local HTTP server")
+    private static HttpServer startServer() throws IOException {
+        final HttpServer server = HttpServer.create(
+                new InetSocketAddress(InetAddress.getLoopbackAddress(), 0),
+                0
+        );
+        server.createContext(DEFAULT_PAGE, AllureWebDriverBiDiTest::handleIndex);
+        server.createContext(LOGS_PAGE, AllureWebDriverBiDiTest::handleLogs);
+        server.createContext(NETWORK_PAGE, AllureWebDriverBiDiTest::handleNetwork);
+        server.createContext(CUSTOM_PAGE, AllureWebDriverBiDiTest::handleCustom);
+        server.createContext(PING_PATH, AllureWebDriverBiDiTest::handlePing);
+        server.start();
+        return server;
+    }
+
+    private static void handleIndex(final HttpExchange exchange) throws IOException {
+        respond(
+                exchange,
+                HTML_TYPE,
+                pageScript(
+                        consoleLog(CONSOLE_LOG)
+                                + consoleLog(SECOND_CONSOLE_LOG)
+                                + fetchPing(header(API_KEY_HEADER_NAME, API_KEY))
+                                + ".then(response=>response.text())"
+                                + ".then(text=>console.log('bidi-it-fetch-'+text))"
+                )
+        );
+    }
+
+    private static void handleLogs(final HttpExchange exchange) throws IOException {
+        respond(
+                exchange,
+                HTML_TYPE,
+                pageScript(
+                        consoleLog(CONSOLE_LOG)
+                                + consoleLog(SECOND_CONSOLE_LOG)
+                                + "Promise.resolve()"
+                )
+        );
+    }
+
+    private static void handleNetwork(final HttpExchange exchange) throws IOException {
+        respond(
+                exchange,
+                HTML_TYPE,
+                pageScript(fetchPing(header(API_KEY_HEADER_NAME, API_KEY)))
+        );
+    }
+
+    private static void handleCustom(final HttpExchange exchange) throws IOException {
+        respond(
+                exchange,
+                HTML_TYPE,
+                pageScript(
+                        fetchPing(
+                                header(CUSTOM_HEADER_NAME, CUSTOM_SECRET)
+                                        + "," + header(TRACE_HEADER_NAME, VISIBLE_HEADER_VALUE)
+                        )
+                )
+        );
+    }
+
+    private static void handlePing(final HttpExchange exchange) throws IOException {
+        exchange.getResponseHeaders().add("Set-Cookie", "session=server-secret");
+        respond(exchange, "text/plain", "ok");
+    }
+
+    private static void respond(final HttpExchange exchange,
+                                final String contentType,
+                                final String body)
+            throws IOException {
+        final byte[] bytes = body.getBytes(StandardCharsets.UTF_8);
+        exchange.getResponseHeaders().add("Content-Type", contentType);
+        exchange.sendResponseHeaders(200, bytes.length);
+        try (OutputStream output = exchange.getResponseBody()) {
+            output.write(bytes);
+        }
+    }
+
+    private static AllureResults runTestWithSeleniumBidi(final ChromeOptions options,
+                                                         final WebDriverScenario scenario)
+            throws IOException {
+        return runTestWithSeleniumBidi(options, listener -> listener, false, scenario);
+    }
+
+    private static AllureResults runTestWithSeleniumBidi(final ChromeOptions options,
+                                                         final ListenerConfigurer configurer,
+                                                         final WebDriverScenario scenario)
+            throws IOException {
+        return runTestWithSeleniumBidi(options, configurer, false, scenario);
+    }
+
+    @Step("Run Selenium WebDriver BiDi test")
+    private static AllureResults runTestWithSeleniumBidi(@Param(mode = HIDDEN) final ChromeOptions options,
+                                                         @Param(mode = HIDDEN) final ListenerConfigurer configurer,
+                                                         final boolean closeListener,
+                                                         @Param(mode = HIDDEN) final WebDriverScenario scenario)
+            throws IOException {
+        final HttpServer server = startServer();
+        try {
+            final int serverPort = server.getAddress().getPort();
+            SERVER_PORT.set(serverPort);
+            Testcontainers.exposeHostPorts(serverPort);
+
+            final int seleniumPort = availableTcpPort();
+            try (GenericContainer<?> selenium = startSeleniumContainer(seleniumPort)) {
+                final URL remoteUrl = seleniumUrl(seleniumPort);
+                return runWithinTestContext(() -> {
+                    final AllureWebDriverBiDi listener = configurer.configure(
+                            new AllureWebDriverBiDi(Allure.getLifecycle(), new SeleniumBiDiSessionFactory())
+                    );
+                    runWebDriverScenario(
+                            listener,
+                            new RemoteWebDriver(remoteUrl, options),
+                            closeListener,
+                            scenario
+                    );
+                });
+            }
+        } finally {
+            SERVER_PORT.remove();
+            server.stop(0);
+        }
+    }
+
+    @Step("Run ready Selenium WebDriver scenario")
+    private static void runWebDriverScenario(@Param(mode = HIDDEN) final AllureWebDriverBiDi listener,
+                                             @Param(mode = HIDDEN) final WebDriver rawDriver,
+                                             final boolean closeListener,
+                                             @Param(mode = HIDDEN) final WebDriverScenario scenario) {
+        WebDriver driver = null;
+        boolean closed = false;
+        try {
+            driver = listener.decorate(rawDriver);
+            scenario.run(driver);
+            waitForBiDiEvents();
+            if (closeListener) {
+                listener.close();
+                rawDriver.quit();
+            } else {
+                driver.quit();
+            }
+            closed = true;
+        } finally {
+            if (!closed) {
+                quit(driver, rawDriver);
+            }
+        }
+    }
+
+    private static ChromeOptions chromeOptions() {
+        final ChromeOptions options = new ChromeOptions().enableBiDi();
+        addChromeArguments(options);
+        return options;
+    }
+
+    private static ChromeOptions chromeOptionsWithoutBiDi() {
+        final ChromeOptions options = new ChromeOptions();
+        addChromeArguments(options);
+        return options;
+    }
+
+    private static void addChromeArguments(final ChromeOptions options) {
+        options.addArguments("--headless=new", "--disable-gpu", "--no-sandbox", "--disable-dev-shm-usage");
+    }
+
+    @Step("Wait until test page finishes browser activity")
+    private static void waitUntilPageDone(@Param(mode = HIDDEN) final WebDriver driver) {
+        new WebDriverWait(driver, Duration.ofSeconds(10))
+                .until(AllureWebDriverBiDiTest::isPageDone);
+    }
+
+    @Step("Wait for asynchronous WebDriver BiDi events")
+    private static void waitForBiDiEvents() {
+        try {
+            TimeUnit.MILLISECONDS.sleep(500);
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            throw new IllegalStateException(WAIT_FOR_BIDI_INTERRUPTED, e);
+        }
+    }
+
+    private static boolean isPageDone(final WebDriver driver) {
+        return Boolean.TRUE.equals(((JavascriptExecutor) driver).executeScript("return window.__bidiDone === true;"));
+    }
+
+    private static URL seleniumUrl(final int seleniumPort) throws IOException {
+        return URI.create(seleniumEndpoint(seleniumPort)).toURL();
+    }
+
+    private static String seleniumEndpoint(final int seleniumPort) {
+        return String.format(LOCALHOST_URL_FORMAT, seleniumPort);
+    }
+
+    private static int availableTcpPort() throws IOException {
+        try (ServerSocket socket = new ServerSocket(0)) {
+            return socket.getLocalPort();
+        }
+    }
+
+    private static String testServerUrl(final String path) {
+        final Integer port = SERVER_PORT.get();
+        if (port == null) {
+            throw new IllegalStateException("Test server is not running");
+        }
+        return containerHostServerUrl(port, path);
+    }
+
+    private static String containerHostServerUrl(final int port, final String path) {
+        return String.format("http://host.testcontainers.internal:%d%s", port, path);
+    }
+
+    private static void quit(final WebDriver driver, final WebDriver rawDriver) {
+        if (driver != null) {
+            driver.quit();
+        } else {
+            rawDriver.quit();
+        }
+    }
+
+    @Step("Get single generated test result")
+    private static TestResult singleTestResult(@Param(mode = HIDDEN) final AllureResults results) {
+        assertThat(results.getTestResults()).hasSize(1);
+        final TestResult result = results.getTestResults().iterator().next();
+        assertThat(result.getStatus()).isNull();
+        return result;
+    }
+
+    private static List<String> attachmentNames(final AllureResults results) {
+        final List<String> names = new ArrayList<>();
+        attachments(singleTestResult(results)).forEach(attachment -> names.add(attachment.getName()));
+        return names;
+    }
+
+    private static String attachmentContent(final AllureResults results, final String name) {
+        return attachmentContent(results, attachments(singleTestResult(results)), name);
+    }
+
+    @Step("Read attachment {name}")
+    private static String attachmentContent(@Param(mode = HIDDEN) final AllureResults results,
+                                            @Param(mode = HIDDEN) final List<Attachment> attachments,
+                                            final String name) {
+        final Attachment attachment = attachments.stream()
+                .filter(item -> name.equals(item.getName()))
+                .findFirst()
+                .orElseThrow(() -> new AssertionError("Attachment not found: " + name));
+        return new String(results.getAttachments().get(attachment.getSource()), StandardCharsets.UTF_8);
+    }
+
+    @Step("Read JSON attachment {name}")
+    private static Map<String, Object> attachmentPayload(@Param(mode = HIDDEN) final AllureResults results,
+                                                         final String name) {
+        return JSON.toType(attachmentContent(results, name), Json.MAP_TYPE);
+    }
+
+    private static List<Attachment> attachments(final TestResult testResult) {
+        final List<Attachment> attachments = new ArrayList<>(testResult.getAttachments());
+        testResult.getSteps().forEach(step -> collectAttachments(step, attachments));
+        return attachments;
+    }
+
+    private static void collectAttachments(final StepResult step, final List<Attachment> attachments) {
+        attachments.addAll(step.getAttachments());
+        step.getSteps().forEach(child -> collectAttachments(child, attachments));
+    }
+
+    private static void assertDropped(final Map<String, Object> payload, final long expected) {
+        assertThat(((Number) payload.get(DROPPED_KEY)).longValue()).isEqualTo(expected);
+    }
+
+    @SuppressWarnings("unchecked")
+    private static List<Map<String, Object>> entries(final Map<String, Object> payload) {
+        return objects(payload, ENTRIES_KEY);
+    }
+
+    @SuppressWarnings("unchecked")
+    private static Map<String, Object> object(final Map<String, Object> payload, final String key) {
+        return (Map<String, Object>) payload.get(key);
+    }
+
+    @SuppressWarnings("unchecked")
+    private static List<Map<String, Object>> objects(final Map<String, Object> payload, final String key) {
+        return (List<Map<String, Object>>) payload.get(key);
+    }
+
+    private static Map<String, Object> networkEntry(final Map<String, Object> payload,
+                                                    final String event,
+                                                    final String path) {
+        return entries(payload).stream()
+                .filter(entry -> event.equals(entry.get("event")))
+                .filter(entry -> networkUrl(entry).contains(path))
+                .findFirst()
+                .orElseThrow(() -> new AssertionError("Network entry not found: " + event + " " + path));
+    }
+
+    private static String networkUrl(final Map<String, Object> entry) {
+        final Map<String, Object> response = object(entry, "response");
+        if (response != null) {
+            return String.valueOf(response.get("url"));
+        }
+        return String.valueOf(object(entry, "request").get("url"));
+    }
+
+    private static String headerValue(final Map<String, Object> owner, final String name) {
+        return objects(owner, "headers").stream()
+                .filter(header -> name.equalsIgnoreCase(String.valueOf(header.get("name"))))
+                .map(header -> object(header, "value"))
+                .map(value -> String.valueOf(value.get("value")))
+                .findFirst()
+                .orElseThrow(() -> new AssertionError("Header not found: " + name));
+    }
+
+    private static StepResult step(final List<StepResult> steps, final String name) {
+        return steps.stream()
+                .filter(step -> name.equals(step.getName()))
+                .findFirst()
+                .orElseThrow(() -> new AssertionError("Step not found: " + name));
+    }
+
+    private static String consoleLog(final String text) {
+        return String.format("console.log('%s');", text);
+    }
+
+    private static String fetchPing(final String headers) {
+        return String.format("fetch('%s',{headers:{%s}})", PING_PATH, headers);
+    }
+
+    private static String header(final String name, final String value) {
+        return String.format("'%s':'%s'", name, value);
+    }
+
+    private static String pageScript(final String script) {
+        return "<!doctype html><html><body>"
+                + "<script>"
+                + "window.__bidiDone=false;"
+                + script
+                + ".finally(()=>window.__bidiDone=true);"
+                + "</script>"
+                + "</body></html>";
+    }
+
+    @FunctionalInterface
+    private interface ListenerConfigurer {
+
+        AllureWebDriverBiDi configure(AllureWebDriverBiDi listener);
+    }
+
+    @FunctionalInterface
+    private interface WebDriverScenario {
+
+        void run(WebDriver driver);
+    }
+}
diff --git a/allure-selenium-bidi/src/test/resources/allure.properties b/allure-selenium-bidi/src/test/resources/allure.properties
new file mode 100644
index 00000000..1176dba4
--- /dev/null
+++ b/allure-selenium-bidi/src/test/resources/allure.properties
@@ -0,0 +1,3 @@
+allure.results.directory=build/allure-results
+allure.label.epic=#project.description#
+allure.label.module=allure-selenium-bidi
diff --git a/allure-servlet-api/build.gradle.kts b/allure-servlet-api/build.gradle.kts
index 55c4bdcd..52c92821 100644
--- a/allure-servlet-api/build.gradle.kts
+++ b/allure-servlet-api/build.gradle.kts
@@ -6,6 +6,11 @@ dependencies {
     api(project(":allure-attachments"))
     compileOnly("javax.servlet:javax.servlet-api:$servletApiVersion")
     testImplementation("javax.servlet:javax.servlet-api:$servletApiVersion")
+    testImplementation("org.junit.jupiter:junit-jupiter-api")
+    testImplementation("org.mockito:mockito-core")
+    testImplementation("org.slf4j:slf4j-simple")
+    testImplementation(project(":allure-junit-platform"))
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
 }
 
 tasks.jar {
@@ -15,3 +20,7 @@ tasks.jar {
         ))
     }
 }
+
+tasks.test {
+    useJUnitPlatform()
+}
diff --git a/allure-servlet-api/src/main/java/io/qameta/allure/servletapi/HttpServletAttachmentBuilder.java b/allure-servlet-api/src/main/java/io/qameta/allure/servletapi/HttpServletAttachmentBuilder.java
index fe1c3abc..04e5968c 100644
--- a/allure-servlet-api/src/main/java/io/qameta/allure/servletapi/HttpServletAttachmentBuilder.java
+++ b/allure-servlet-api/src/main/java/io/qameta/allure/servletapi/HttpServletAttachmentBuilder.java
@@ -22,16 +22,19 @@
 
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
+
 import java.io.BufferedReader;
 import java.io.IOException;
+import java.util.Arrays;
 import java.util.Collections;
-import java.util.stream.Stream;
 
 import static io.qameta.allure.attachment.http.HttpRequestAttachment.Builder.create;
 import static io.qameta.allure.attachment.http.HttpResponseAttachment.Builder.create;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Supports Servlet API integration with Allure reporting.
+ *
+ * <p>Use this type through the module that owns it when translating framework execution, result metadata, or attachments into Allure report data.</p>
  */
 public final class HttpServletAttachmentBuilder {
 
@@ -41,6 +44,12 @@ private HttpServletAttachmentBuilder() {
         throw new IllegalStateException();
     }
 
+    /**
+     * Builds and returns the request.
+     *
+     * @param request the request to capture or convert
+     * @return the request
+     */
     public static HttpRequestAttachment buildRequest(final HttpServletRequest request) {
         final HttpRequestAttachment.Builder requestBuilder = create("Request", request.getRequestURI());
         Collections.list(request.getHeaderNames())
@@ -49,20 +58,37 @@ public static HttpRequestAttachment buildRequest(final HttpServletRequest reques
                     requestBuilder.setHeader(name, value);
                 });
 
-        Stream.of(request.getCookies())
-                .forEach(cookie -> requestBuilder.setCookie(cookie.getName(), cookie.getValue()));
+        final javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            Arrays.stream(cookies)
+                    .forEach(cookie -> requestBuilder.setCookie(cookie.getName(), cookie.getValue()));
+        }
         requestBuilder.setBody(getBody(request));
         return requestBuilder.build();
     }
 
+    /**
+     * Builds and returns the response.
+     *
+     * @param response the response to capture or convert
+     * @return the response
+     */
     public static HttpResponseAttachment buildResponse(final HttpServletResponse response) {
         final HttpResponseAttachment.Builder responseBuilder = create("Response");
         response.getHeaderNames()
-                .forEach(name -> response.getHeaders(name)
-                        .forEach(value -> responseBuilder.setHeader(name, value)));
+                .forEach(
+                        name -> response.getHeaders(name)
+                                .forEach(value -> responseBuilder.setHeader(name, value))
+                );
         return responseBuilder.build();
     }
 
+    /**
+     * Returns the body.
+     *
+     * @param request the request to capture or convert
+     * @return the body
+     */
     public static String getBody(final HttpServletRequest request) {
         final StringBuilder sb = new StringBuilder();
         try (BufferedReader reader = request.getReader()) {
@@ -73,8 +99,16 @@ public static String getBody(final HttpServletRequest request) {
         return sb.toString();
     }
 
+    /**
+     * Handles the read body callback.
+     *
+     * @param sb the buffer that receives the body content
+     * @param reader the reader that provides body content
+     * @throws IOException if the underlying framework operation fails
+     */
     public static void readBody(final StringBuilder sb,
-                                final BufferedReader reader) throws IOException {
+                                final BufferedReader reader)
+            throws IOException {
         String line;
         while ((line = reader.readLine()) != null) {
             sb.append(line);
diff --git a/allure-servlet-api/src/test/java/io/qameta/allure/servletapi/HttpServletAttachmentBuilderTest.java b/allure-servlet-api/src/test/java/io/qameta/allure/servletapi/HttpServletAttachmentBuilderTest.java
new file mode 100644
index 00000000..e9df3f77
--- /dev/null
+++ b/allure-servlet-api/src/test/java/io/qameta/allure/servletapi/HttpServletAttachmentBuilderTest.java
@@ -0,0 +1,102 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.servletapi;
+
+import io.qameta.allure.Allure;
+import io.qameta.allure.attachment.http.HttpRequestAttachment;
+import io.qameta.allure.attachment.http.HttpResponseAttachment;
+import org.junit.jupiter.api.Test;
+
+import javax.servlet.http.Cookie;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class HttpServletAttachmentBuilderTest {
+
+    @Test
+    void shouldBuildRequestWithHeadersCookiesAndBody() throws Exception {
+        final HttpServletRequest request = mock(HttpServletRequest.class);
+        when(request.getRequestURI()).thenReturn("/orders");
+        when(request.getHeaderNames()).thenReturn(Collections.enumeration(List.of("X-Trace", "Accept")));
+        when(request.getHeader("X-Trace")).thenReturn("trace-1");
+        when(request.getHeader("Accept")).thenReturn("application/json");
+        when(request.getCookies()).thenReturn(new Cookie[]{new Cookie("session", "abc123")});
+        when(request.getReader()).thenReturn(new BufferedReader(new StringReader("{\"ok\":true}")));
+
+        final HttpRequestAttachment attachment = HttpServletAttachmentBuilder.buildRequest(request);
+
+        assertEquals("Request", attachment.getName());
+        assertEquals("/orders", attachment.getUrl());
+        assertEquals("{\"ok\":true}", attachment.getBody());
+        assertEquals(Map.of("X-Trace", "trace-1", "Accept", "application/json"), attachment.getHeaders());
+        assertEquals(Map.of("session", "abc123"), attachment.getCookies());
+    }
+
+    @Test
+    void shouldHandleRequestsWithoutCookies() throws Exception {
+        final HttpServletRequest request = mock(HttpServletRequest.class);
+        when(request.getRequestURI()).thenReturn("/orders");
+        when(request.getHeaderNames()).thenReturn(Collections.emptyEnumeration());
+        when(request.getCookies()).thenReturn(null);
+        when(request.getReader()).thenReturn(new BufferedReader(new StringReader("")));
+
+        final HttpRequestAttachment attachment = Allure.step(
+                "Build a request attachment when the servlet container returns null cookies",
+                () -> assertDoesNotThrow(() -> HttpServletAttachmentBuilder.buildRequest(request))
+        );
+
+        Allure.step(
+                "Verify the request attachment keeps an empty cookie map", () -> assertTrue(attachment.getCookies().isEmpty())
+        );
+    }
+
+    @Test
+    void shouldBuildResponseWithHeaders() {
+        final HttpServletResponse response = mock(HttpServletResponse.class);
+        when(response.getHeaderNames()).thenReturn(List.of("Content-Type"));
+        when(response.getHeaders("Content-Type")).thenReturn(List.of("application/json"));
+
+        final HttpResponseAttachment attachment = HttpServletAttachmentBuilder.buildResponse(response);
+
+        assertEquals("Response", attachment.getName());
+        assertEquals(Map.of("Content-Type", "application/json"), attachment.getHeaders());
+    }
+
+    @Test
+    void shouldReturnEmptyBodyWhenRequestReaderFails() throws Exception {
+        final HttpServletRequest request = mock(HttpServletRequest.class);
+        when(request.getReader()).thenThrow(new IOException("boom"));
+
+        final String body = Allure.step(
+                "Read the request body when the servlet reader throws", () -> HttpServletAttachmentBuilder.getBody(request)
+        );
+
+        Allure.step("Verify the fallback body is empty", () -> assertEquals("", body));
+    }
+}
diff --git a/allure-servlet-api/src/test/resources/allure.properties b/allure-servlet-api/src/test/resources/allure.properties
new file mode 100644
index 00000000..8f58f812
--- /dev/null
+++ b/allure-servlet-api/src/test/resources/allure.properties
@@ -0,0 +1,3 @@
+allure.results.directory=build/allure-results
+allure.label.epic=#project.description#
+allure.label.module=allure-servlet-api
diff --git a/allure-spock/src/main/java/io/qameta/allure/spock/AllureSpock.java b/allure-spock/src/main/java/io/qameta/allure/spock/AllureSpock.java
index 6e44d270..ea3c14b7 100644
--- a/allure-spock/src/main/java/io/qameta/allure/spock/AllureSpock.java
+++ b/allure-spock/src/main/java/io/qameta/allure/spock/AllureSpock.java
@@ -61,6 +61,8 @@
 import static io.qameta.allure.util.ResultsUtils.createTestClassLabel;
 import static io.qameta.allure.util.ResultsUtils.createTestMethodLabel;
 import static io.qameta.allure.util.ResultsUtils.createThreadLabel;
+import static io.qameta.allure.util.ResultsUtils.createTitlePath;
+import static io.qameta.allure.util.ResultsUtils.createTitlePathFromPackage;
 import static io.qameta.allure.util.ResultsUtils.firstNonEmpty;
 import static io.qameta.allure.util.ResultsUtils.getProvidedLabels;
 import static io.qameta.allure.util.ResultsUtils.getStatus;
@@ -69,44 +71,67 @@
 import static java.util.Comparator.comparing;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Reports Spock 1 specifications to Allure.
+ *
+ * <p>Register this extension with Spock to convert specification, feature, iteration, fixture, and error events into Allure results. Use the default constructor for normal runs or pass a lifecycle for tests and embedded runtimes.</p>
  */
-@SuppressWarnings({
-        "ClassFanOutComplexity",
-})
+@SuppressWarnings(
+    {
+            "ClassFanOutComplexity",
+    }
+)
 public class AllureSpock extends AbstractRunListener implements IGlobalExtension {
 
     private static final String MD_5 = "md5";
 
-    private final ThreadLocal<String> testResults
-            = InheritableThreadLocal.withInitial(() -> UUID.randomUUID().toString());
+    private final ThreadLocal<String> testResults = InheritableThreadLocal.withInitial(() -> UUID.randomUUID().toString());
 
     private final AllureLifecycle lifecycle;
 
+    /**
+     * Creates an Allure spock with default configuration.
+     */
     @SuppressWarnings("unused")
     public AllureSpock() {
         this(Allure.getLifecycle());
     }
 
+    /**
+     * Creates an Allure spock with the supplied values.
+     *
+     * @param lifecycle the Allure lifecycle to use
+     */
     public AllureSpock(final AllureLifecycle lifecycle) {
         this.lifecycle = lifecycle;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void start() {
         //do nothing at this point
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void visitSpec(final SpecInfo spec) {
         spec.addListener(this);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void stop() {
         //do nothing at this point
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void beforeIteration(final IterationInfo iteration) {
         final String uuid = testResults.get();
@@ -120,16 +145,18 @@ public void beforeIteration(final IterationInfo iteration) {
         final String testClassName = feature.getDescription().getClassName();
         final String testMethodName = iteration.getName();
 
-        final List<Label> labels = new ArrayList<>(Arrays.asList(
-                createPackageLabel(packageName),
-                createTestClassLabel(testClassName),
-                createTestMethodLabel(testMethodName),
-                createSuiteLabel(specName),
-                createHostLabel(),
-                createThreadLabel(),
-                createFrameworkLabel("spock"),
-                createLanguageLabel("java")
-        ));
+        final List<Label> labels = new ArrayList<>(
+                Arrays.asList(
+                        createPackageLabel(packageName),
+                        createTestClassLabel(testClassName),
+                        createTestMethodLabel(testMethodName),
+                        createSuiteLabel(specName),
+                        createHostLabel(),
+                        createThreadLabel(),
+                        createFrameworkLabel("spock"),
+                        createLanguageLabel("java")
+                )
+        );
         if (Objects.nonNull(subSpec)) {
             labels.add(createSubSuiteLabel(subSpec.getName()));
         }
@@ -139,17 +166,31 @@ public void beforeIteration(final IterationInfo iteration) {
         labels.addAll(getLabels(iteration));
         labels.addAll(getProvidedLabels());
 
+        final List<String> titlePath = new ArrayList<>(createTitlePathFromPackage(packageName));
+        titlePath.addAll(
+                createTitlePath(
+                        Objects.nonNull(superSpec) ? superSpec.getName() : null,
+                        specName,
+                        Objects.nonNull(subSpec) ? subSpec.getName() : null
+                )
+        );
         final TestResult result = new TestResult()
                 .setUuid(uuid)
                 .setHistoryId(getHistoryId(getQualifiedName(iteration), parameters))
-                .setName(firstNonEmpty(
-                        testMethodName,
-                        feature.getDescription().getDisplayName(),
-                        getQualifiedName(iteration)).orElse("Unknown"))
+                .setName(
+                        firstNonEmpty(
+                                testMethodName,
+                                feature.getDescription().getDisplayName(),
+                                getQualifiedName(iteration)
+                        ).orElse("Unknown")
+                )
                 .setFullName(getQualifiedName(iteration))
-                .setStatusDetails(new StatusDetails()
-                        .setFlaky(isFlaky(iteration))
-                        .setMuted(isMuted(iteration)))
+                .setTitlePath(titlePath)
+                .setStatusDetails(
+                        new StatusDetails()
+                                .setFlaky(isFlaky(iteration))
+                                .setMuted(isMuted(iteration))
+                )
                 .setParameters(parameters)
                 .setLinks(getLinks(iteration))
                 .setLabels(labels);
@@ -162,15 +203,18 @@ private List<Label> getLabels(final IterationInfo iterationInfo) {
         final Set<Label> labels = AnnotationUtils.getLabels(
                 iterationInfo.getFeature().getDescription().getAnnotations()
         );
-        labels.addAll(AnnotationUtils.getLabels(
-                iterationInfo.getFeature().getSpec().getDescription().getAnnotations()
-        ));
+        labels.addAll(
+                AnnotationUtils.getLabels(
+                        iterationInfo.getFeature().getSpec().getDescription().getAnnotations()
+                )
+        );
         return new ArrayList<>(labels);
     }
 
     private void processDescription(final IterationInfo iterationInfo, final TestResult item) {
         final List<io.qameta.allure.Description> annotationsOnFeature = getFeatureAnnotations(
-                iterationInfo, io.qameta.allure.Description.class);
+                iterationInfo, io.qameta.allure.Description.class
+        );
         if (!annotationsOnFeature.isEmpty()) {
             item.setDescription(annotationsOnFeature.get(0).value());
         }
@@ -272,16 +316,22 @@ private <T extends Annotation> List<T> getSpecAnnotations(final IterationInfo it
         return getAnnotationsOnClass(spec.getDescription(), clazz);
     }
 
-
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void error(final ErrorInfo error) {
         final String uuid = testResults.get();
-        getLifecycle().updateTestCase(uuid, testResult -> testResult
-                .setStatus(getStatus(error.getException()).orElse(null))
-                .setStatusDetails(getStatusDetails(error.getException()).orElse(null))
+        getLifecycle().updateTestCase(
+                uuid, testResult -> testResult
+                        .setStatus(getStatus(error.getException()).orElse(null))
+                        .setStatusDetails(getStatusDetails(error.getException()).orElse(null))
         );
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void afterIteration(final IterationInfo iteration) {
         final String uuid = testResults.get();
@@ -302,6 +352,11 @@ private List<Parameter> getParameters(final List<String> names, final Object...
                 .collect(Collectors.toList());
     }
 
+    /**
+     * Returns the lifecycle.
+     *
+     * @return the Allure lifecycle used by this integration
+     */
     public AllureLifecycle getLifecycle() {
         return lifecycle;
     }
diff --git a/allure-spock/src/test/groovy/io/qameta/allure/spock/AllureSpockTest.java b/allure-spock/src/test/groovy/io/qameta/allure/spock/AllureSpockTest.java
index 7788d169..04df6e3a 100644
--- a/allure-spock/src/test/groovy/io/qameta/allure/spock/AllureSpockTest.java
+++ b/allure-spock/src/test/groovy/io/qameta/allure/spock/AllureSpockTest.java
@@ -47,10 +47,6 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.tuple;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @SuppressWarnings("unchecked")
 class AllureSpockTest {
 
diff --git a/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/BrokenTest.groovy b/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/BrokenTest.groovy
index 574a1cba..73cefc30 100644
--- a/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/BrokenTest.groovy
+++ b/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/BrokenTest.groovy
@@ -16,10 +16,6 @@
 package io.qameta.allure.spock.samples
 
 import spock.lang.Specification
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class BrokenTest extends Specification {
 
     def "brokenTest"() throws Exception {
diff --git a/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/DataDrivenTest.groovy b/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/DataDrivenTest.groovy
index f21b7518..19d76cb9 100644
--- a/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/DataDrivenTest.groovy
+++ b/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/DataDrivenTest.groovy
@@ -16,10 +16,6 @@
 package io.qameta.allure.spock.samples
 
 import spock.lang.Specification
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class DataDrivenTest extends Specification {
 
     def "Simple Test"() {
diff --git a/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/FailedTest.groovy b/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/FailedTest.groovy
index 29ef77e9..7777a784 100644
--- a/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/FailedTest.groovy
+++ b/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/FailedTest.groovy
@@ -23,24 +23,20 @@ import io.qameta.allure.TmsLink
 import io.qameta.allure.TmsLinks
 import org.junit.Test
 import spock.lang.Specification
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class FailedTest extends Specification {
 
     @Test
     @Links([
-            @Link("link-1"),
-            @Link("link-2")
+        @Link("link-1"),
+        @Link("link-2")
     ])
     @Issues([
-            @Issue("issue-1"),
-            @Issue("issue-2")
+        @Issue("issue-1"),
+        @Issue("issue-2")
     ])
     @TmsLinks([
-            @TmsLink("tms-1"),
-            @TmsLink("tms-2")
+        @TmsLink("tms-1"),
+        @TmsLink("tms-2")
     ])
     def "failedTest"() {
         expect:
diff --git a/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/JiraIssue.groovy b/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/JiraIssue.groovy
index f149b7b9..a101cf40 100644
--- a/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/JiraIssue.groovy
+++ b/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/JiraIssue.groovy
@@ -23,10 +23,6 @@ import java.lang.annotation.Inherited
 import java.lang.annotation.Retention
 import java.lang.annotation.RetentionPolicy
 import java.lang.annotation.Target
-
-/**
- * @author vbragin
- */
 @Documented
 @Inherited
 @Retention(RetentionPolicy.RUNTIME)
diff --git a/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/OneTest.groovy b/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/OneTest.groovy
index a2dab839..cefc086c 100644
--- a/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/OneTest.groovy
+++ b/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/OneTest.groovy
@@ -16,10 +16,6 @@
 package io.qameta.allure.spock.samples
 
 import spock.lang.Specification
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class OneTest extends Specification {
 
     def "Simple Test"() {
diff --git a/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/ParametersTest.groovy b/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/ParametersTest.groovy
index 7d120ba1..6dd52b21 100644
--- a/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/ParametersTest.groovy
+++ b/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/ParametersTest.groovy
@@ -16,10 +16,6 @@
 package io.qameta.allure.spock.samples
 
 import spock.lang.Specification
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class ParametersTest extends Specification {
 
     def "Simple Test"() {
diff --git a/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/TestWithAnnotations.groovy b/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/TestWithAnnotations.groovy
index 51af6154..037f96de 100644
--- a/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/TestWithAnnotations.groovy
+++ b/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/TestWithAnnotations.groovy
@@ -26,28 +26,25 @@ import io.qameta.allure.Stories
 import io.qameta.allure.Story
 import org.junit.Test
 import spock.lang.Specification
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class TestWithAnnotations extends Specification {
 
     @Test
     @Epic("epic1")
     @Epics([
-            @Epic("epic2"),
-            @Epic("epic3")
+        @Epic("epic2"),
+        @Epic("epic3")
     ])
 
     @Features([
-            @Feature("feature1"),
-            @Feature("feature2")
+        @Feature("feature1"),
+        @Feature("feature2")
     ])
     @Feature("feature3")
     @Story("story1")
     @Stories([
-            @Story("story2"),
-            @Story("story3")]
+        @Story("story2"),
+        @Story("story3")
+    ]
     )
     @Owner("some-owner")
     @Flaky
diff --git a/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/TestWithAnnotationsOnClass.groovy b/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/TestWithAnnotationsOnClass.groovy
index fb1e6329..7c984ce7 100644
--- a/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/TestWithAnnotationsOnClass.groovy
+++ b/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/TestWithAnnotationsOnClass.groovy
@@ -26,28 +26,24 @@ import io.qameta.allure.Stories
 import io.qameta.allure.Story
 import org.junit.Test
 import spock.lang.Specification
-
-/**
- * @author vbragin
- */
 @Epic("epic1")
 @Features([
-        @Feature("feature1"),
-        @Feature("feature2")
+    @Feature("feature1"),
+    @Feature("feature2")
 ])
 @Feature("feature3")
 @Story("story1")
 @Stories([
-        @Story("story2"),
-        @Story("story3")]
+    @Story("story2"),
+    @Story("story3")]
 )
 class TestWithAnnotationsOnClass extends Specification {
 
     @Test
     @Flaky
     @Epics([
-            @Epic("epic2"),
-            @Epic("epic3")
+        @Epic("epic2"),
+        @Epic("epic3")
     ])
     @Muted
     @Owner("some-owner")
diff --git a/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/TestWithCustomAnnotations.groovy b/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/TestWithCustomAnnotations.groovy
index 8a2c6962..9a597d4a 100644
--- a/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/TestWithCustomAnnotations.groovy
+++ b/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/TestWithCustomAnnotations.groovy
@@ -20,10 +20,6 @@ import io.qameta.allure.Feature
 import io.qameta.allure.Story
 import org.junit.Test
 import spock.lang.Specification
-
-/**
- * @author vbragin
- */
 class TestWithCustomAnnotations extends Specification {
 
     @Test
diff --git a/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/TestWithSteps.groovy b/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/TestWithSteps.groovy
index ab4cdfd9..da156527 100644
--- a/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/TestWithSteps.groovy
+++ b/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/TestWithSteps.groovy
@@ -18,10 +18,6 @@ package io.qameta.allure.spock.samples
 import spock.lang.Specification
 
 import static io.qameta.allure.Allure.step
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class TestWithSteps extends Specification {
 
     def "testWithSteps"() {
diff --git a/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/XrayId.groovy b/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/XrayId.groovy
index 0aae4cac..8c38ee0a 100644
--- a/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/XrayId.groovy
+++ b/allure-spock/src/test/groovy/io/qameta/allure/spock/samples/XrayId.groovy
@@ -23,10 +23,6 @@ import java.lang.annotation.Inherited
 import java.lang.annotation.Retention
 import java.lang.annotation.RetentionPolicy
 import java.lang.annotation.Target
-
-/**
- * @author vbragin
- */
 @Documented
 @Inherited
 @Retention(RetentionPolicy.RUNTIME)
diff --git a/allure-spock/src/test/resources/allure.properties b/allure-spock/src/test/resources/allure.properties
index 9c0b0a2d..92d17a33 100644
--- a/allure-spock/src/test/resources/allure.properties
+++ b/allure-spock/src/test/resources/allure.properties
@@ -1,2 +1,3 @@
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-spock
diff --git a/allure-spock2/src/main/java/io/qameta/allure/spock2/AllureSpock2.java b/allure-spock2/src/main/java/io/qameta/allure/spock2/AllureSpock2.java
index 2a852407..84159607 100644
--- a/allure-spock2/src/main/java/io/qameta/allure/spock2/AllureSpock2.java
+++ b/allure-spock2/src/main/java/io/qameta/allure/spock2/AllureSpock2.java
@@ -68,6 +68,8 @@
 import static io.qameta.allure.util.ResultsUtils.createTestClassLabel;
 import static io.qameta.allure.util.ResultsUtils.createTestMethodLabel;
 import static io.qameta.allure.util.ResultsUtils.createThreadLabel;
+import static io.qameta.allure.util.ResultsUtils.createTitlePath;
+import static io.qameta.allure.util.ResultsUtils.createTitlePathFromPackage;
 import static io.qameta.allure.util.ResultsUtils.firstNonEmpty;
 import static io.qameta.allure.util.ResultsUtils.getMd5Digest;
 import static io.qameta.allure.util.ResultsUtils.getProvidedLabels;
@@ -78,7 +80,9 @@
 import static java.util.Comparator.comparing;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Reports Spock 2 specifications to Allure.
+ *
+ * <p>Register this extension with Spock to convert specification, feature, iteration, fixture, and error events into Allure results. The constructor accepting a test plan enables Allure test plan filtering before execution.</p>
  */
 public class AllureSpock2 extends AbstractRunListener implements IGlobalExtension {
 
@@ -88,20 +92,37 @@ public class AllureSpock2 extends AbstractRunListener implements IGlobalExtensio
 
     private final TestPlan testPlan;
 
+    /**
+     * Creates an Allure spock2 with default configuration.
+     */
     @SuppressWarnings("unused")
     public AllureSpock2() {
         this(Allure.getLifecycle());
     }
 
+    /**
+     * Creates an Allure spock2 with the supplied values.
+     *
+     * @param lifecycle the Allure lifecycle to use
+     */
     public AllureSpock2(final AllureLifecycle lifecycle) {
         this(lifecycle, new FileTestPlanSupplier().supply().orElse(null));
     }
 
+    /**
+     * Creates an Allure spock2 with the supplied values.
+     *
+     * @param lifecycle the Allure lifecycle to use
+     * @param plan the plan
+     */
     public AllureSpock2(final AllureLifecycle lifecycle, final TestPlan plan) {
         this.lifecycle = lifecycle;
         this.testPlan = plan;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void visitSpec(final SpecInfo spec) {
         spec.getAllFeatures().forEach(methodInfo -> methodInfo.setSkipped(this.isSkipped(methodInfo)));
@@ -135,6 +156,9 @@ public void visitSpec(final SpecInfo spec) {
                 }));
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void beforeIteration(final IterationInfo iteration) {
         final String uuid = UUID.randomUUID().toString();
@@ -159,16 +183,18 @@ public void beforeIteration(final IterationInfo iteration) {
         final String testClassName = feature.getSpec().getReflection().getName();
         final String testMethodName = iteration.getDisplayName();
 
-        final List<Label> labels = new ArrayList<>(Arrays.asList(
-                createPackageLabel(packageName),
-                createTestClassLabel(testClassName),
-                createTestMethodLabel(testMethodName),
-                createSuiteLabel(specName),
-                createHostLabel(),
-                createThreadLabel(),
-                createFrameworkLabel("spock"),
-                createLanguageLabel("java")
-        ));
+        final List<Label> labels = new ArrayList<>(
+                Arrays.asList(
+                        createPackageLabel(packageName),
+                        createTestClassLabel(testClassName),
+                        createTestMethodLabel(testMethodName),
+                        createSuiteLabel(specName),
+                        createHostLabel(),
+                        createThreadLabel(),
+                        createFrameworkLabel("spock"),
+                        createLanguageLabel("java")
+                )
+        );
 
         if (Objects.nonNull(subSpec)) {
             labels.add(createSubSuiteLabel(subSpec.getName()));
@@ -192,19 +218,29 @@ public void beforeIteration(final IterationInfo iteration) {
         links.addAll(specLinks);
 
         final String qualifiedName = getQualifiedName(iteration);
+        final List<String> titlePath = new ArrayList<>(createTitlePathFromPackage(packageName));
+        titlePath.addAll(
+                createTitlePath(
+                        Objects.nonNull(superSpec) ? superSpec.getName() : null,
+                        specName,
+                        Objects.nonNull(subSpec) ? subSpec.getName() : null
+                )
+        );
         final TestResult result = new TestResult()
                 .setUuid(uuid)
                 .setHistoryId(getHistoryId(qualifiedName, parameters))
                 .setTestCaseName(iteration.getName())
                 .setTestCaseId(md5(qualifiedName))
                 .setFullName(qualifiedName)
+                .setTitlePath(titlePath)
                 .setName(
                         firstNonEmpty(testMethodName, iteration.getName(), qualifiedName)
                                 .orElse("Unknown")
                 )
-                .setStatusDetails(new StatusDetails()
-                        .setFlaky(flaky)
-                        .setMuted(muted)
+                .setStatusDetails(
+                        new StatusDetails()
+                                .setFlaky(flaky)
+                                .setMuted(muted)
                 )
                 .setParameters(parameters)
                 .setLinks(links)
@@ -257,10 +293,12 @@ private boolean isSkipped(final FeatureInfo featureInfo) {
             return !Objects.isNull(tp.getTests()) && tp.getTests()
                     .stream()
                     .filter(Objects::nonNull)
-                    .noneMatch(tc -> this.match(
-                            tc,
-                            this.getAllureId(featureInfo),
-                            this.getQualifiedName(featureInfo))
+                    .noneMatch(
+                            tc -> this.match(
+                                    tc,
+                                    this.getAllureId(featureInfo),
+                                    this.getQualifiedName(featureInfo)
+                            )
                     );
         }
         return false;
@@ -278,18 +316,25 @@ private boolean match(final TestPlanV1_0.TestCase tc, final String allureId, fin
         return Objects.equals(allureId, tc.getId()) || Objects.equals(qualifiedName, tc.getSelector());
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void error(final ErrorInfo error) {
         final String uuid = testResults.get();
         if (Objects.isNull(uuid)) {
             return;
         }
-        getLifecycle().updateTestCase(uuid, testResult -> testResult
-                .setStatus(getStatus(error.getException()).orElse(null))
-                .setStatusDetails(getStatusDetails(error.getException()).orElse(null))
+        getLifecycle().updateTestCase(
+                uuid, testResult -> testResult
+                        .setStatus(getStatus(error.getException()).orElse(null))
+                        .setStatusDetails(getStatusDetails(error.getException()).orElse(null))
         );
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void afterIteration(final IterationInfo iteration) {
         final String uuid = testResults.get();
@@ -317,6 +362,11 @@ private List<Parameter> getParameters(final List<String> names, final Object...
                 .collect(Collectors.toList());
     }
 
+    /**
+     * Returns the lifecycle.
+     *
+     * @return the Allure lifecycle used by this integration
+     */
     public AllureLifecycle getLifecycle() {
         return lifecycle;
     }
@@ -328,8 +378,7 @@ public AllureLifecycle getLifecycle() {
      * from Allure context. But then we need to not forget to restore it to context, because
      * thread context is cleared on fixture start event.
      */
-    @SuppressWarnings("FinalClass")
-    private class AllureFeatureFixtureMethodInterceptor extends AllureSpecFixtureMethodInterceptor {
+    private final class AllureFeatureFixtureMethodInterceptor extends AllureSpecFixtureMethodInterceptor {
 
         private AllureFeatureFixtureMethodInterceptor() {
             this(UUID.randomUUID().toString());
@@ -425,8 +474,7 @@ public void intercept(final IMethodInvocation invocation) throws Throwable {
     /**
      * IMethodInterceptor that creates container per spec.
      */
-    @SuppressWarnings("FinalClass")
-    private class AllureContainerInterceptor implements IMethodInterceptor {
+    private final class AllureContainerInterceptor implements IMethodInterceptor {
 
         private final String containerUuid;
 
diff --git a/allure-spock2/src/main/java/io/qameta/allure/spock2/compiler/AllureStatementsLabelsToStepsTransformation.java b/allure-spock2/src/main/java/io/qameta/allure/spock2/compiler/AllureStatementsLabelsToStepsTransformation.java
index 477edd5b..fac8e775 100644
--- a/allure-spock2/src/main/java/io/qameta/allure/spock2/compiler/AllureStatementsLabelsToStepsTransformation.java
+++ b/allure-spock2/src/main/java/io/qameta/allure/spock2/compiler/AllureStatementsLabelsToStepsTransformation.java
@@ -46,11 +46,16 @@
 import java.util.stream.Stream;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Integrates Spock 2 with Allure reporting.
+ *
+ * <p>Register this type through the standard Spock 2 extension, listener, interceptor, or plugin mechanism so framework execution events are written to Allure results. Use explicit dependencies when embedding the integration in tests or custom runtimes.</p>
  */
 @GroovyASTTransformation(phase = CompilePhase.SEMANTIC_ANALYSIS)
 public class AllureStatementsLabelsToStepsTransformation implements ASTTransformation {
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void visit(final ASTNode[] nodes, final SourceUnit sourceUnit) {
         new Impl().visit(sourceUnit);
@@ -90,7 +95,7 @@ private void processSpec(final SourceUnit sourceUnit,
             } catch (Exception e) {
                 errorReporter.error(
                         "Unexpected error during compilation of spec '%s'."
-                        + " Please file a bug report at https://github.com/allure-framework/allure-java.",
+                                + " Please file a bug report at https://github.com/allure-framework/allure-java.",
                         e, clazz.getName()
                 );
             }
@@ -117,15 +122,19 @@ public void visitConstructor(final ConstructorNode node) {
         @Override
         public void visitMethod(final MethodNode node) {
             final List<Statement> newStatements = AstUtil.getStatements(node).stream()
-                    .flatMap(statement -> Stream.concat(
-                            getAllureStepStatements(statement),
-                            Stream.of(statement)
-                    ))
+                    .flatMap(
+                            statement -> Stream.concat(
+                                    getAllureStepStatements(statement),
+                                    Stream.of(statement)
+                            )
+                    )
                     .collect(Collectors.toList());
 
-            node.setCode(new BlockStatement(
-                    newStatements,
-                    ((BlockStatement) node.getCode()).getVariableScope())
+            node.setCode(
+                    new BlockStatement(
+                            newStatements,
+                            ((BlockStatement) node.getCode()).getVariableScope()
+                    )
             );
         }
 
@@ -142,7 +151,7 @@ public void visitProperty(final PropertyNode node) {
         @SuppressWarnings("PMD.AvoidDeeplyNestedIfStmts")
         private static Stream<Statement> getAllureStepStatements(final Statement statement) {
             if (Objects.nonNull(statement.getStatementLabels())
-                && !statement.getStatementLabels().isEmpty()) {
+                    && !statement.getStatementLabels().isEmpty()) {
                 final String labels = String.join(" ", statement.getStatementLabels());
                 final StringBuilder builder = new StringBuilder(labels);
 
@@ -158,15 +167,17 @@ private static Stream<Statement> getAllureStepStatements(final Statement stateme
 
                 final String stepName = builder.toString();
 
-                return Stream.of(new ExpressionStatement(
-                        new StaticMethodCallExpression(
-                                ALLURE,
-                                "step",
-                                new ArgumentListExpression(
-                                        new ConstantExpression(stepName)
+                return Stream.of(
+                        new ExpressionStatement(
+                                new StaticMethodCallExpression(
+                                        ALLURE,
+                                        "step",
+                                        new ArgumentListExpression(
+                                                new ConstantExpression(stepName)
+                                        )
                                 )
                         )
-                ));
+                );
             }
             return Stream.empty();
         }
diff --git a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/AllureSpock2Test.java b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/AllureSpock2Test.java
index 3771a655..a10dd3c7 100644
--- a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/AllureSpock2Test.java
+++ b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/AllureSpock2Test.java
@@ -26,6 +26,7 @@
 import io.qameta.allure.model.StepResult;
 import io.qameta.allure.model.TestResult;
 import io.qameta.allure.model.TestResultContainer;
+import io.qameta.allure.spock2.samples.ActualExpectedStatusDetailsTest;
 import io.qameta.allure.spock2.samples.BrokenTest;
 import io.qameta.allure.spock2.samples.DataDrivenTest;
 import io.qameta.allure.spock2.samples.DerivedSpec;
@@ -58,10 +59,10 @@
 import org.junit.platform.launcher.core.LauncherConfig;
 import org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder;
 import org.junit.platform.launcher.core.LauncherFactory;
+import org.mockito.ArgumentCaptor;
 import org.spockframework.runtime.GlobalExtensionRegistry;
 import org.spockframework.runtime.RunContext;
 import org.spockframework.runtime.SpockEngine;
-import org.mockito.ArgumentCaptor;
 
 import java.lang.reflect.Method;
 import java.time.Instant;
@@ -80,10 +81,6 @@
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.when;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class AllureSpock2Test {
 
     @Test
@@ -245,6 +242,17 @@ void shouldProcessFailedTest() {
                 .containsExactly(Status.FAILED);
     }
 
+    @Test
+    void shouldReportActualAndExpectedStatusDetails() {
+        final AllureResults results = runClasses(ActualExpectedStatusDetailsTest.class);
+        final TestResult testResult = results.getTestResults().get(0);
+
+        assertThat(results.getTestResults()).hasSize(1);
+        assertThat(testResult.getStatus()).isEqualTo(Status.FAILED);
+        assertThat(testResult.getStatusDetails().getActual()).startsWith("actual value\n (");
+        assertThat(testResult.getStatusDetails().getExpected()).startsWith("expected value\n (");
+    }
+
     @Test
     void shouldProcessBrokenTest() {
         final AllureResults results = runClasses(BrokenTest.class);
@@ -437,7 +445,6 @@ void shouldSupportFixtures() {
                         tuple("cleanup", "cleanup step 1, cleanup step 2")
                 );
 
-
         final TestResult tr1 = results.getTestResults().stream()
                 .filter(tr -> "First Test".equals(tr.getName()))
                 .findFirst()
@@ -509,26 +516,25 @@ private List<Triple<String, List<String>, List<String>>> getTrFixtures(final All
                 .collect(Collectors.groupingBy(Pair::getKey, Collectors.mapping(Pair::getValue, Collectors.toList())));
 
         return results.getTestResults().stream().map(tr -> {
-                    final List<TestResultContainer> containers = trContainers
-                            .getOrDefault(tr.getUuid(), Collections.emptyList());
-
-                    final List<String> befores = containers.stream()
-                            .map(TestResultContainer::getBefores)
-                            .flatMap(Collection::stream)
-                            .map(fr -> fr.getName() + " [ " + printSteps(fr) + " ] ")
-                            .sorted()
-                            .collect(Collectors.toList());
-
-
-                    final List<String> afters = containers.stream()
-                            .map(TestResultContainer::getAfters)
-                            .flatMap(Collection::stream)
-                            .map(fr -> fr.getName() + " [ " + printSteps(fr) + " ] ")
-                            .sorted()
-                            .collect(Collectors.toList());
-
-                    return Triple.of(tr.getName(), befores, afters);
-                })
+            final List<TestResultContainer> containers = trContainers
+                    .getOrDefault(tr.getUuid(), Collections.emptyList());
+
+            final List<String> befores = containers.stream()
+                    .map(TestResultContainer::getBefores)
+                    .flatMap(Collection::stream)
+                    .map(fr -> fr.getName() + " [ " + printSteps(fr) + " ] ")
+                    .sorted()
+                    .collect(Collectors.toList());
+
+            final List<String> afters = containers.stream()
+                    .map(TestResultContainer::getAfters)
+                    .flatMap(Collection::stream)
+                    .map(fr -> fr.getName() + " [ " + printSteps(fr) + " ] ")
+                    .sorted()
+                    .collect(Collectors.toList());
+
+            return Triple.of(tr.getName(), befores, afters);
+        })
                 .collect(Collectors.toList());
 
     }
diff --git a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/ActualExpectedStatusDetailsTest.groovy b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/ActualExpectedStatusDetailsTest.groovy
new file mode 100644
index 00000000..6427a1df
--- /dev/null
+++ b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/ActualExpectedStatusDetailsTest.groovy
@@ -0,0 +1,25 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.spock2.samples
+
+import spock.lang.Specification
+class ActualExpectedStatusDetailsTest extends Specification {
+
+    def "failing comparison"() {
+        expect:
+        "actual value" == "expected value"
+    }
+}
diff --git a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/BrokenTest.groovy b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/BrokenTest.groovy
index f9f2e3fa..b3908aba 100644
--- a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/BrokenTest.groovy
+++ b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/BrokenTest.groovy
@@ -16,10 +16,6 @@
 package io.qameta.allure.spock2.samples
 
 import spock.lang.Specification
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class BrokenTest extends Specification {
 
     def "brokenTest"() throws Exception {
diff --git a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/DataDrivenTest.groovy b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/DataDrivenTest.groovy
index 457bdf35..37f57725 100644
--- a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/DataDrivenTest.groovy
+++ b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/DataDrivenTest.groovy
@@ -16,10 +16,6 @@
 package io.qameta.allure.spock2.samples
 
 import spock.lang.Specification
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class DataDrivenTest extends Specification {
 
     def "Simple Test"() {
diff --git a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/FailedTest.groovy b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/FailedTest.groovy
index d264a1ba..15e0d3e0 100644
--- a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/FailedTest.groovy
+++ b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/FailedTest.groovy
@@ -17,23 +17,19 @@ package io.qameta.allure.spock2.samples
 
 import io.qameta.allure.*
 import spock.lang.Specification
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class FailedTest extends Specification {
 
     @Links([
-            @Link("link-1"),
-            @Link("link-2")
+        @Link("link-1"),
+        @Link("link-2")
     ])
     @Issues([
-            @Issue("issue-1"),
-            @Issue("issue-2")
+        @Issue("issue-1"),
+        @Issue("issue-2")
     ])
     @TmsLinks([
-            @TmsLink("tms-1"),
-            @TmsLink("tms-2")
+        @TmsLink("tms-1"),
+        @TmsLink("tms-2")
     ])
     def "failedTest"() {
         expect:
diff --git a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/FixturesTest.groovy b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/FixturesTest.groovy
index 15f21f1d..cf857e0f 100644
--- a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/FixturesTest.groovy
+++ b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/FixturesTest.groovy
@@ -19,10 +19,6 @@ package io.qameta.allure.spock2.samples
 import spock.lang.Specification
 
 import static io.qameta.allure.Allure.step
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class FixturesTest extends Specification {
 
     def setupSpec() {
diff --git a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/HelloSpockSpec.groovy b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/HelloSpockSpec.groovy
index 4a65efb6..ae9800ab 100644
--- a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/HelloSpockSpec.groovy
+++ b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/HelloSpockSpec.groovy
@@ -18,14 +18,14 @@ package io.qameta.allure.spock2.samples
 import spock.lang.Specification
 
 class HelloSpockSpec extends Specification {
-  def "length of Spock's and his friends' names"() {
-    expect:
-    name.size() == length
+    def "length of Spock's and his friends' names"() {
+        expect:
+        name.size() == length
 
-    where:
-    name     | length
-    "Spock"  | 5
-    "Kirk"   | 4
-    "Scotty" | 6
-  }
+        where:
+        name     | length
+        "Spock"  | 5
+        "Kirk"   | 4
+        "Scotty" | 6
+    }
 }
diff --git a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/JiraIssue.groovy b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/JiraIssue.groovy
index cd0ec554..a1e3cd5d 100644
--- a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/JiraIssue.groovy
+++ b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/JiraIssue.groovy
@@ -23,10 +23,6 @@ import java.lang.annotation.Inherited
 import java.lang.annotation.Retention
 import java.lang.annotation.RetentionPolicy
 import java.lang.annotation.Target
-
-/**
- * @author vbragin
- */
 @Documented
 @Inherited
 @Retention(RetentionPolicy.RUNTIME)
diff --git a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/OneTest.groovy b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/OneTest.groovy
index 9a547f43..d1cb290a 100644
--- a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/OneTest.groovy
+++ b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/OneTest.groovy
@@ -18,10 +18,6 @@ package io.qameta.allure.spock2.samples
 import spock.lang.Specification
 
 import static io.qameta.allure.Allure.step
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class OneTest extends Specification {
 
     def setup() {
diff --git a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/ParametersTest.groovy b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/ParametersTest.groovy
index b6f108bd..333de6fe 100644
--- a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/ParametersTest.groovy
+++ b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/ParametersTest.groovy
@@ -16,10 +16,6 @@
 package io.qameta.allure.spock2.samples
 
 import spock.lang.Specification
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class ParametersTest extends Specification {
 
     def "Simple Test"() {
diff --git a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/SpecFixtures.groovy b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/SpecFixtures.groovy
index ef80eb4e..e7d73688 100644
--- a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/SpecFixtures.groovy
+++ b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/SpecFixtures.groovy
@@ -18,10 +18,6 @@ package io.qameta.allure.spock2.samples
 import spock.lang.Specification
 
 import static io.qameta.allure.Allure.step
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class SpecFixtures extends Specification {
 
     def setupSpec() {
@@ -40,5 +36,4 @@ class SpecFixtures extends Specification {
         expect:
         "the end"
     }
-
 }
diff --git a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/SpecInheritanceSpec.groovy b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/SpecInheritanceSpec.groovy
index 9bea32a5..fdb09c61 100644
--- a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/SpecInheritanceSpec.groovy
+++ b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/SpecInheritanceSpec.groovy
@@ -20,13 +20,21 @@ import spock.lang.Specification
 import static io.qameta.allure.Allure.step
 
 abstract class BaseSpec extends Specification {
-    def setupSpec() { step 'base setupSpec()' }
+    def setupSpec() {
+        step 'base setupSpec()'
+    }
 
-    def cleanupSpec() { step 'base cleanupSpec()' }
+    def cleanupSpec() {
+        step 'base cleanupSpec()'
+    }
 
-    def setup() { step 'base setup()' }
+    def setup() {
+        step 'base setup()'
+    }
 
-    def cleanup() { step 'base cleanup()' }
+    def cleanup() {
+        step 'base cleanup()'
+    }
 
     def baseSpecMethod() {
         setup:
@@ -35,13 +43,21 @@ abstract class BaseSpec extends Specification {
 }
 
 class DerivedSpec extends BaseSpec {
-    def setupSpec() { step 'derived setupSpec()' }
+    def setupSpec() {
+        step 'derived setupSpec()'
+    }
 
-    def cleanupSpec() { step 'derived cleanupSpec()' }
+    def cleanupSpec() {
+        step 'derived cleanupSpec()'
+    }
 
-    def setup() { step 'derived setup()' }
+    def setup() {
+        step 'derived setup()'
+    }
 
-    def cleanup() { step 'derived cleanup()' }
+    def cleanup() {
+        step 'derived cleanup()'
+    }
 
     def derivedSpecMethod() {
         setup:
diff --git a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/SpockTags.groovy b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/SpockTags.groovy
index 3c6210b8..cd259ec5 100644
--- a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/SpockTags.groovy
+++ b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/SpockTags.groovy
@@ -17,10 +17,6 @@ package io.qameta.allure.spock2.samples
 
 import spock.lang.Specification
 import spock.lang.Tag
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class SpockTags extends Specification {
 
     @Tag("first")
diff --git a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/StepsAndBlocks.groovy b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/StepsAndBlocks.groovy
index 29a0307a..b6725989 100644
--- a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/StepsAndBlocks.groovy
+++ b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/StepsAndBlocks.groovy
@@ -19,11 +19,6 @@ import io.qameta.allure.Step
 import spock.lang.Specification
 
 import static io.qameta.allure.Allure.step
-
-/**
- * @author charlie (Dmitry Baev).
- */
-
 class StepsAndBlocks extends Specification {
 
     def "test with steps and blocks"() {
diff --git a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/TestWithAnnotations.groovy b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/TestWithAnnotations.groovy
index 844fce1d..88e7fd91 100644
--- a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/TestWithAnnotations.groovy
+++ b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/TestWithAnnotations.groovy
@@ -17,26 +17,23 @@ package io.qameta.allure.spock2.samples
 
 import io.qameta.allure.*
 import spock.lang.Specification
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class TestWithAnnotations extends Specification {
 
     @Epic("epic1")
     @Epics([
-            @Epic("epic2"),
-            @Epic("epic3")
+        @Epic("epic2"),
+        @Epic("epic3")
     ])
     @Features([
-            @Feature("feature1"),
-            @Feature("feature2")
+        @Feature("feature1"),
+        @Feature("feature2")
     ])
     @Feature("feature3")
     @Story("story1")
     @Stories([
-            @Story("story2"),
-            @Story("story3")]
+        @Story("story2"),
+        @Story("story3")
+    ]
     )
     @Owner("some-owner")
     @Flaky
diff --git a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/TestWithAnnotationsOnClass.groovy b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/TestWithAnnotationsOnClass.groovy
index 9e22496e..e8297f6a 100644
--- a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/TestWithAnnotationsOnClass.groovy
+++ b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/TestWithAnnotationsOnClass.groovy
@@ -17,27 +17,23 @@ package io.qameta.allure.spock2.samples
 
 import io.qameta.allure.*
 import spock.lang.Specification
-
-/**
- * @author vbragin
- */
 @Epic("epic1")
 @Features([
-        @Feature("feature1"),
-        @Feature("feature2")
+    @Feature("feature1"),
+    @Feature("feature2")
 ])
 @Feature("feature3")
 @Story("story1")
 @Stories([
-        @Story("story2"),
-        @Story("story3")]
+    @Story("story2"),
+    @Story("story3")]
 )
 class TestWithAnnotationsOnClass extends Specification {
 
     @Flaky
     @Epics([
-            @Epic("epic2"),
-            @Epic("epic3")
+        @Epic("epic2"),
+        @Epic("epic3")
     ])
     @Muted
     @Owner("some-owner")
diff --git a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/TestWithCustomAnnotations.groovy b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/TestWithCustomAnnotations.groovy
index 891e59cc..d67c4a97 100644
--- a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/TestWithCustomAnnotations.groovy
+++ b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/TestWithCustomAnnotations.groovy
@@ -19,10 +19,6 @@ import io.qameta.allure.Epic
 import io.qameta.allure.Feature
 import io.qameta.allure.Story
 import spock.lang.Specification
-
-/**
- * @author vbragin
- */
 class TestWithCustomAnnotations extends Specification {
 
     @Epic("epic")
diff --git a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/TestWithSteps.groovy b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/TestWithSteps.groovy
index 95b8b821..dc9315a9 100644
--- a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/TestWithSteps.groovy
+++ b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/TestWithSteps.groovy
@@ -18,10 +18,6 @@ package io.qameta.allure.spock2.samples
 import spock.lang.Specification
 
 import static io.qameta.allure.Allure.step
-
-/**
- * @author charlie (Dmitry Baev).
- */
 class TestWithSteps extends Specification {
 
     def "testWithSteps"() {
diff --git a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/XrayId.groovy b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/XrayId.groovy
index f9dbe175..5429e625 100644
--- a/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/XrayId.groovy
+++ b/allure-spock2/src/test/groovy/io/qameta/allure/spock2/samples/XrayId.groovy
@@ -23,10 +23,6 @@ import java.lang.annotation.Inherited
 import java.lang.annotation.Retention
 import java.lang.annotation.RetentionPolicy
 import java.lang.annotation.Target
-
-/**
- * @author vbragin
- */
 @Documented
 @Inherited
 @Retention(RetentionPolicy.RUNTIME)
diff --git a/allure-spock2/src/test/resources/allure.properties b/allure-spock2/src/test/resources/allure.properties
index 9c0b0a2d..19503db3 100644
--- a/allure-spock2/src/test/resources/allure.properties
+++ b/allure-spock2/src/test/resources/allure.properties
@@ -1,2 +1,3 @@
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-spock2
diff --git a/allure-spring-web/build.gradle.kts b/allure-spring-web/build.gradle.kts
index b7956681..ab11b8b2 100644
--- a/allure-spring-web/build.gradle.kts
+++ b/allure-spring-web/build.gradle.kts
@@ -1,6 +1,6 @@
 description = "Allure Spring Web Integration"
 
-val springWebVersion = "6.2.12"
+val springWebVersion = "6.2.17"
 
 dependencies {
     api(project(":allure-attachments"))
@@ -32,4 +32,4 @@ tasks.test {
 
 tasks.compileJava {
     options.release.set(17)
-}
\ No newline at end of file
+}
diff --git a/allure-spring-web/src/main/java/io/qameta/allure/springweb/AllureRestTemplate.java b/allure-spring-web/src/main/java/io/qameta/allure/springweb/AllureRestTemplate.java
index fbf57c41..837a8c17 100644
--- a/allure-spring-web/src/main/java/io/qameta/allure/springweb/AllureRestTemplate.java
+++ b/allure-spring-web/src/main/java/io/qameta/allure/springweb/AllureRestTemplate.java
@@ -36,47 +36,93 @@
 import java.util.Map;
 
 /**
- * Allure interceptor for spring rest template.
+ * Allure interceptor for Spring synchronous HTTP clients such as
+ * {@code RestTemplate} and {@code RestClient}.
+ * <p>
+ * Since this interceptor reads the response body to create an attachment,
+ * configure a buffering request factory when the caller also needs to consume
+ * the response body after interception.
  */
 public class AllureRestTemplate implements ClientHttpRequestInterceptor {
 
     private String requestTemplatePath = "http-request.ftl";
     private String responseTemplatePath = "http-response.ftl";
 
+    /**
+     * Returns the request template path.
+     *
+     * @return the request template path
+     */
     public String getRequestTemplatePath() {
         return requestTemplatePath;
     }
 
+    /**
+     * Returns the response template path.
+     *
+     * @return the response template path
+     */
     public String getResponseTemplatePath() {
         return responseTemplatePath;
     }
 
+    /**
+     * Sets the request template.
+     *
+     * @param templatePath the classpath path to the FreeMarker template
+     * @return this instance for method chaining
+     */
     public AllureRestTemplate setRequestTemplate(final String templatePath) {
         this.requestTemplatePath = templatePath;
         return this;
     }
 
+    /**
+     * Sets the response template.
+     *
+     * @param templatePath the classpath path to the FreeMarker template
+     * @return this instance for method chaining
+     */
     public AllureRestTemplate setResponseTemplate(final String templatePath) {
         this.responseTemplatePath = templatePath;
         return this;
     }
 
+    /**
+     * Returns the request renderer.
+     *
+     * @return the request renderer
+     */
     protected AttachmentRenderer<AttachmentData> getRequestRenderer() {
         return new FreemarkerAttachmentRenderer(getRequestTemplatePath());
     }
 
+    /**
+     * Returns the response renderer.
+     *
+     * @return the response renderer
+     */
     protected AttachmentRenderer<AttachmentData> getResponseRenderer() {
         return new FreemarkerAttachmentRenderer(getResponseTemplatePath());
     }
 
+    /**
+     * Returns the attachment processor.
+     *
+     * @return the attachment processor
+     */
     protected AttachmentProcessor<AttachmentData> getAttachmentProcessor() {
         return new DefaultAttachmentProcessor();
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @SuppressWarnings("NullableProblems")
     @Override
     public ClientHttpResponse intercept(@NonNull final HttpRequest request, final byte[] body,
-                                        @NonNull final ClientHttpRequestExecution execution) throws IOException {
+                                        @NonNull final ClientHttpRequestExecution execution)
+            throws IOException {
         final AttachmentProcessor<AttachmentData> processor = getAttachmentProcessor();
 
         final HttpRequestAttachment.Builder requestAttachmentBuilder = HttpRequestAttachment.Builder
@@ -103,6 +149,12 @@ public ClientHttpResponse intercept(@NonNull final HttpRequest request, final by
         return clientHttpResponse;
     }
 
+    /**
+     * Converts and returns the map converter.
+     *
+     * @param items the map entries to convert
+     * @return the converted map converter
+     */
     protected static Map<String, String> toMapConverter(final Map<String, List<String>> items) {
         final Map<String, String> result = new HashMap<>();
         items.forEach((key, value) -> result.put(key, String.join("; ", value)));
diff --git a/allure-spring-web/src/test/java/io/qameta/allure/springweb/AllureRestTemplateTest.java b/allure-spring-web/src/test/java/io/qameta/allure/springweb/AllureRestTemplateTest.java
index 3298e093..bc9bcb77 100644
--- a/allure-spring-web/src/test/java/io/qameta/allure/springweb/AllureRestTemplateTest.java
+++ b/allure-spring-web/src/test/java/io/qameta/allure/springweb/AllureRestTemplateTest.java
@@ -33,71 +33,135 @@
 import org.springframework.http.ResponseEntity;
 import org.springframework.http.client.BufferingClientHttpRequestFactory;
 import org.springframework.http.client.SimpleClientHttpRequestFactory;
+import org.springframework.web.client.RestClient;
 import org.springframework.web.client.RestTemplate;
 
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Objects;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Stream;
 
 import static io.qameta.allure.test.RunUtils.runWithinTestContext;
 import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * @author choojoykin (Vladimir Pavlov).
- */
 @SuppressWarnings("unchecked")
 public class AllureRestTemplateTest {
 
-    static Stream<String> attachmentNameProvider() {
-        return Stream.of("Request", "Response");
+    static Stream<SpringClientType> clientTypeProvider() {
+        return Stream.of(SpringClientType.values());
     }
 
     @ParameterizedTest
-    @MethodSource(value = "attachmentNameProvider")
-    void shouldCreateAttachment(final String attachmentName) {
-        final AllureResults results = execute();
+    @MethodSource("clientTypeProvider")
+    void shouldCreateAttachment(final SpringClientType clientType) {
+        final AllureResults results = execute(clientType).getAllureResults();
         assertThat(results.getTestResults())
                 .flatExtracting(TestResult::getAttachments)
                 .flatExtracting(Attachment::getName)
-                .contains(attachmentName);
+                .contains("Request", "Response");
     }
 
     @ParameterizedTest
-    @MethodSource(value = "attachmentNameProvider")
-    void shouldCatchAttachmentBody(final String attachmentName) {
-        final AllureResults results = execute();
+    @MethodSource("clientTypeProvider")
+    void shouldCatchAttachmentBody(final SpringClientType clientType) {
+        final AllureResults results = execute(clientType).getAllureResults();
 
-        final Attachment found = results.getTestResults().stream()
-                .map(TestResult::getAttachments)
-                .flatMap(Collection::stream)
-                .filter(attachment -> Objects.equals(attachmentName, attachment.getName()))
-                .findAny()
-                .orElseThrow(() -> new RuntimeException("attachment not found"));
-
-        assertThat(results.getAttachments())
-                .containsKeys(found.getSource());
+        Stream.of("Request", "Response")
+                .map(attachmentName -> findAttachment(results, attachmentName))
+                .forEach(
+                        found -> assertThat(results.getAttachments())
+                                .containsKeys(found.getSource())
+                );
     }
 
-    protected final AllureResults execute() {
-        final RestTemplate restTemplate = new RestTemplate(new BufferingClientHttpRequestFactory(new SimpleClientHttpRequestFactory()));
-        restTemplate.setInterceptors(Collections.singletonList(new AllureRestTemplate()));
+    @ParameterizedTest
+    @MethodSource("clientTypeProvider")
+    void shouldAllowResponseBodyConsumptionAfterInterception(final SpringClientType clientType) {
+        final ExecutionResult executionResult = execute(clientType);
+        assertThat(executionResult.getResponse().getBody()).isEqualTo("some body");
+    }
 
+    protected final ExecutionResult execute(final SpringClientType clientType) {
         final WireMockServer server = new WireMockServer(WireMockConfiguration.options().dynamicPort());
+        final AtomicReference<ResponseEntity<String>> response = new AtomicReference<>();
 
-        return runWithinTestContext(() -> {
+        final AllureResults results = runWithinTestContext(() -> {
             server.start();
             WireMock.configureFor(server.port());
             WireMock.stubFor(WireMock.get(WireMock.urlEqualTo("/hello")).willReturn(WireMock.aResponse().withBody("some body")));
             try {
-                HttpHeaders headers = new HttpHeaders();
-                headers.setContentType(MediaType.APPLICATION_JSON);
-                HttpEntity<JsonNode> entity = new HttpEntity<>(headers);
-                ResponseEntity<String> result = restTemplate.exchange(server.url("/hello"), HttpMethod.GET, entity, String.class);
+                final ResponseEntity<String> result = clientType.execute(server.url("/hello"));
+                response.set(result);
                 Assertions.assertEquals(result.getStatusCode(), HttpStatus.OK);
+                Assertions.assertEquals(result.getBody(), "some body");
             } finally {
                 server.stop();
             }
         });
+
+        return new ExecutionResult(results, response.get());
+    }
+
+    private static Attachment findAttachment(final AllureResults results, final String attachmentName) {
+        return results.getTestResults().stream()
+                .map(TestResult::getAttachments)
+                .flatMap(Collection::stream)
+                .filter(attachment -> Objects.equals(attachmentName, attachment.getName()))
+                .findAny()
+                .orElseThrow(() -> new RuntimeException("attachment not found"));
+    }
+
+    private static BufferingClientHttpRequestFactory createBufferingRequestFactory() {
+        return new BufferingClientHttpRequestFactory(new SimpleClientHttpRequestFactory());
+    }
+
+    private enum SpringClientType {
+        REST_TEMPLATE {
+            @Override
+            ResponseEntity<String> execute(final String url) {
+                final RestTemplate restTemplate = new RestTemplate(createBufferingRequestFactory());
+                restTemplate.setInterceptors(Collections.singletonList(new AllureRestTemplate()));
+
+                final HttpHeaders headers = new HttpHeaders();
+                headers.setContentType(MediaType.APPLICATION_JSON);
+                final HttpEntity<JsonNode> entity = new HttpEntity<>(headers);
+                return restTemplate.exchange(url, HttpMethod.GET, entity, String.class);
+            }
+        },
+        REST_CLIENT {
+            @Override
+            ResponseEntity<String> execute(final String url) {
+                final RestClient restClient = RestClient.builder()
+                        .requestFactory(createBufferingRequestFactory())
+                        .requestInterceptor(new AllureRestTemplate())
+                        .build();
+                return restClient.get()
+                        .uri(url)
+                        .accept(MediaType.APPLICATION_JSON)
+                        .retrieve()
+                        .toEntity(String.class);
+            }
+        };
+
+        abstract ResponseEntity<String> execute(String url);
+    }
+
+    private static final class ExecutionResult {
+
+        private final AllureResults allureResults;
+        private final ResponseEntity<String> response;
+
+        private ExecutionResult(final AllureResults allureResults, final ResponseEntity<String> response) {
+            this.allureResults = allureResults;
+            this.response = response;
+        }
+
+        AllureResults getAllureResults() {
+            return allureResults;
+        }
+
+        ResponseEntity<String> getResponse() {
+            return response;
+        }
     }
 }
diff --git a/allure-spring-web/src/test/resources/allure.properties b/allure-spring-web/src/test/resources/allure.properties
index 9c0b0a2d..594c44e1 100644
--- a/allure-spring-web/src/test/resources/allure.properties
+++ b/allure-spring-web/src/test/resources/allure.properties
@@ -1,2 +1,3 @@
 allure.results.directory=build/allure-results
 allure.label.epic=#project.description#
+allure.label.module=allure-spring-web
diff --git a/allure-test-filter/build.gradle.kts b/allure-test-filter/build.gradle.kts
index b2198ce3..2c96987f 100644
--- a/allure-test-filter/build.gradle.kts
+++ b/allure-test-filter/build.gradle.kts
@@ -16,6 +16,7 @@ dependencies {
     testImplementation("org.slf4j:slf4j-simple")
     testImplementation(project(":allure-assertj"))
     testImplementation(project(":allure-java-commons-test"))
+    testImplementation(project(":allure-junit-platform"))
     testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
 }
 
@@ -68,4 +69,3 @@ tasks {
         exclude("**/features/*")
     }
 }
-
diff --git a/allure-test-filter/src/main/java/io/qameta/allure/testfilter/FileTestPlanSupplier.java b/allure-test-filter/src/main/java/io/qameta/allure/testfilter/FileTestPlanSupplier.java
index e179d20b..f25f3ef9 100644
--- a/allure-test-filter/src/main/java/io/qameta/allure/testfilter/FileTestPlanSupplier.java
+++ b/allure-test-filter/src/main/java/io/qameta/allure/testfilter/FileTestPlanSupplier.java
@@ -33,7 +33,6 @@
  * The {@link TestPlanSupplier} that reads test plan from file, specified
  * in {@code ALLURE_TESTPLAN_PATH} environment variable.
  *
- * @author charlie (Dmitry Baev).
  */
 public class FileTestPlanSupplier implements TestPlanSupplier {
 
diff --git a/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlan.java b/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlan.java
index 55a0b44f..4080f01b 100644
--- a/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlan.java
+++ b/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlan.java
@@ -19,17 +19,19 @@
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
 
 /**
- * Common interface for all test plan implementations.
+ * Represents a loaded Allure test plan.
  *
- * @author charlie (Dmitry Baev).
+ * <p>Integrations use this interface to decide whether discovered tests should run. Implementations may model a known plan version or an unknown plan shape while still exposing plan presence to filtering code.</p>
  */
 @JsonTypeInfo(
         use = JsonTypeInfo.Id.NAME,
         property = "version",
         defaultImpl = TestPlanUnknown.class
 )
-@JsonSubTypes({
-        @JsonSubTypes.Type(TestPlanV1_0.class)
-})
+@JsonSubTypes(
+    {
+            @JsonSubTypes.Type(TestPlanV1_0.class)
+    }
+)
 public interface TestPlan {
 }
diff --git a/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlanSupplier.java b/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlanSupplier.java
index c76659c3..501d2510 100644
--- a/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlanSupplier.java
+++ b/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlanSupplier.java
@@ -20,7 +20,6 @@
 /**
  * Marker interface for all test plan suppliers.
  *
- * @author charlie (Dmitry Baev).
  */
 @FunctionalInterface
 public interface TestPlanSupplier {
diff --git a/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlanUnknown.java b/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlanUnknown.java
index 68eeeaa5..890fb920 100644
--- a/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlanUnknown.java
+++ b/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlanUnknown.java
@@ -18,7 +18,9 @@
 import java.io.Serializable;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Fallback model for an Allure test plan with an unknown schema.
+ *
+ * <p>Use this implementation when a plan file exists but cannot be parsed as a supported version. Integrations can still treat the plan as present while avoiding unsafe filtering decisions.</p>
  */
 public class TestPlanUnknown implements TestPlan, Serializable {
 
diff --git a/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlanV1_0.java b/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlanV1_0.java
index 71f7f793..fa5c5206 100644
--- a/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlanV1_0.java
+++ b/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlanV1_0.java
@@ -23,10 +23,12 @@
 import java.util.Objects;
 
 /**
- * @author charlie (Dmitry Baev).
+ * Allure test plan model for version 1.0.
+ *
+ * <p>The model stores selected test cases and helper lookup methods used by framework integrations. It is typically created by deserializing an Allure test plan JSON file.</p>
  */
 @JsonTypeName("1.0")
-@SuppressWarnings({"TypeName"})
+@SuppressWarnings({"TypeName", "PMD.ClassNamingConventions"})
 public class TestPlanV1_0 implements TestPlan, Serializable {
 
     private static final long serialVersionUID = 1L;
diff --git a/allure-test-filter/src/test/java/io/qameta/allure/testfilter/FileTestPlanSupplierTest.java b/allure-test-filter/src/test/java/io/qameta/allure/testfilter/FileTestPlanSupplierTest.java
new file mode 100644
index 00000000..2e2071d8
--- /dev/null
+++ b/allure-test-filter/src/test/java/io/qameta/allure/testfilter/FileTestPlanSupplierTest.java
@@ -0,0 +1,124 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.testfilter;
+
+import io.qameta.allure.Allure;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.time.Duration;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class FileTestPlanSupplierTest {
+
+    @Test
+    void shouldReadPlanFromPrimaryEnvironmentVariable() throws Exception {
+        final ProbeResult result = Allure.step(
+                "Run the supplier probe with ALLURE_TESTPLAN_PATH", () -> runProbe("ALLURE_TESTPLAN_PATH")
+        );
+
+        recordProbe(result);
+        Allure.step("Verify the probe selects the configured test plan entry", () -> {
+            assertEquals(0, result.exitCode);
+            assertEquals("selected=true", result.stdout.strip());
+        });
+    }
+
+    @Test
+    void shouldReadPlanFromLegacyEnvironmentVariable() throws Exception {
+        final ProbeResult result = Allure.step(
+                "Run the supplier probe with AS_TESTPLAN_PATH", () -> runProbe("AS_TESTPLAN_PATH")
+        );
+
+        recordProbe(result);
+        Allure.step("Verify the legacy environment alias still loads the plan", () -> {
+            assertEquals(0, result.exitCode);
+            assertEquals("selected=true", result.stdout.strip());
+        });
+    }
+
+    private ProbeResult runProbe(final String variableName) throws IOException, InterruptedException {
+        final Path plan = Files.createTempFile("allure-testplan-", ".json");
+        Files.writeString(
+                plan,
+                "{"
+                        + "\"version\":\"1.0\","
+                        + "\"tests\":[{\"id\":\"A-1\",\"selector\":\"pkg.Test#name\"}]"
+                        + "}",
+                StandardCharsets.UTF_8
+        );
+
+        final String javaBin = Path.of(System.getProperty("java.home"), "bin", "java").toString();
+        final ProcessBuilder builder = new ProcessBuilder(
+                javaBin,
+                "-cp",
+                System.getProperty("java.class.path"),
+                SupplierProbe.class.getName()
+        );
+        final Map<String, String> environment = builder.environment();
+        environment.remove("ALLURE_TESTPLAN_PATH");
+        environment.remove("AS_TESTPLAN_PATH");
+        environment.put(variableName, plan.toString());
+
+        final Process process = builder.start();
+        final boolean finished = process.waitFor(Duration.ofSeconds(10).toMillis(), java.util.concurrent.TimeUnit.MILLISECONDS);
+        if (!finished) {
+            process.destroyForcibly();
+            throw new IllegalStateException("supplier probe timed out");
+        }
+
+        final String stdout = new String(process.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
+        final String stderr = new String(process.getErrorStream().readAllBytes(), StandardCharsets.UTF_8);
+        return new ProbeResult(process.exitValue(), stdout, stderr);
+    }
+
+    private void recordProbe(final ProbeResult result) {
+        Allure.addAttachment("probe-stdout", result.stdout);
+        Allure.addAttachment("probe-stderr", result.stderr);
+    }
+
+    private static final class ProbeResult {
+        private final int exitCode;
+        private final String stdout;
+        private final String stderr;
+
+        private ProbeResult(final int exitCode, final String stdout, final String stderr) {
+            this.exitCode = exitCode;
+            this.stdout = stdout;
+            this.stderr = stderr;
+        }
+    }
+
+    public static final class SupplierProbe {
+        private SupplierProbe() {
+        }
+
+        public static void main(final String[] args) {
+            final FileTestPlanSupplier supplier = new FileTestPlanSupplier();
+            final String result = supplier.supply()
+                    .filter(TestPlanV1_0.class::isInstance)
+                    .map(TestPlanV1_0.class::cast)
+                    .map(plan -> "selected=" + plan.isSelected("A-1", "pkg.Test#name"))
+                    .orElse("selected=false");
+            System.out.println(result);
+        }
+    }
+}
diff --git a/allure-test-filter/src/test/java/io/qameta/allure/testfilter/TestPlanV1_0Test.java b/allure-test-filter/src/test/java/io/qameta/allure/testfilter/TestPlanV1_0Test.java
new file mode 100644
index 00000000..6bfab40e
--- /dev/null
+++ b/allure-test-filter/src/test/java/io/qameta/allure/testfilter/TestPlanV1_0Test.java
@@ -0,0 +1,73 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.testfilter;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.qameta.allure.Allure;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class TestPlanV1_0Test {
+
+    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
+
+    @Test
+    void shouldMatchByAllureIdOrSelector() {
+        final TestPlanV1_0 plan = new TestPlanV1_0().setTests(
+                List.of(
+                        new TestPlanV1_0.TestCase().setId("A-1"),
+                        new TestPlanV1_0.TestCase().setSelector("pkg.Test#name")
+                )
+        );
+
+        assertTrue(plan.isSelected("A-1", "other.Test#name"));
+        assertTrue(plan.isSelected("other-id", "pkg.Test#name"));
+        assertFalse(plan.isSelected("other-id", "other.Test#name"));
+    }
+
+    @Test
+    void shouldDeserializeVersionedPlans() throws Exception {
+        final TestPlan plan = OBJECT_MAPPER.readValue(
+                "{"
+                        + "\"version\":\"1.0\","
+                        + "\"tests\":[{\"id\":\"A-1\",\"selector\":\"pkg.Test#name\"}]"
+                        + "}",
+                TestPlan.class
+        );
+
+        assertInstanceOf(TestPlanV1_0.class, plan);
+        assertTrue(((TestPlanV1_0) plan).isSelected("A-1", "pkg.Test#name"));
+    }
+
+    @Test
+    void shouldFallbackToUnknownPlanForUnknownVersion() throws Exception {
+        final TestPlan plan = Allure.step(
+                "Deserialize a plan with an unsupported version", () -> OBJECT_MAPPER.readValue(
+                        "{\"version\":\"2.0\"}",
+                        TestPlan.class
+                )
+        );
+
+        Allure.step(
+                "Verify the parser falls back to the unknown plan representation", () -> assertInstanceOf(TestPlanUnknown.class, plan)
+        );
+    }
+}
diff --git a/allure-test-filter/src/test/resources/allure.properties b/allure-test-filter/src/test/resources/allure.properties
new file mode 100644
index 00000000..08b61b47
--- /dev/null
+++ b/allure-test-filter/src/test/resources/allure.properties
@@ -0,0 +1,3 @@
+allure.results.directory=build/allure-results
+allure.label.epic=#project.description#
+allure.label.module=allure-test-filter
diff --git a/allure-testng/build.gradle.kts b/allure-testng/build.gradle.kts
index 7d6fe56a..7113509d 100644
--- a/allure-testng/build.gradle.kts
+++ b/allure-testng/build.gradle.kts
@@ -10,10 +10,14 @@ dependencies {
     testAnnotationProcessor(project(":allure-descriptions-javadoc"))
     testImplementation("com.google.inject:guice")
     testImplementation("org.assertj:assertj-core")
+    testImplementation("org.junit.jupiter:junit-jupiter-api")
+    testImplementation("org.junit.jupiter:junit-jupiter-params")
+    testImplementation(project(":allure-jupiter"))
     testImplementation("org.mockito:mockito-core")
     testImplementation("org.slf4j:slf4j-simple")
     testImplementation("org.testng:testng:$testNgVersion")
     testImplementation(project(":allure-java-commons-test"))
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
 }
 
 tasks.jar {
@@ -28,9 +32,7 @@ tasks.jar {
 }
 
 tasks.test {
-    useTestNG(closureOf<TestNGOptions> {
-        suites("src/test/resources/testng.xml")
-    })
+    useJUnitPlatform()
     exclude("**/samples/*")
 }
 
diff --git a/allure-testng/src/main/java/io/qameta/allure/testng/AllureTestNg.java b/allure-testng/src/main/java/io/qameta/allure/testng/AllureTestNg.java
index 1461065f..79385742 100644
--- a/allure-testng/src/main/java/io/qameta/allure/testng/AllureTestNg.java
+++ b/allure-testng/src/main/java/io/qameta/allure/testng/AllureTestNg.java
@@ -91,6 +91,8 @@
 import static io.qameta.allure.util.ResultsUtils.createTestClassLabel;
 import static io.qameta.allure.util.ResultsUtils.createTestMethodLabel;
 import static io.qameta.allure.util.ResultsUtils.createThreadLabel;
+import static io.qameta.allure.util.ResultsUtils.createTitlePath;
+import static io.qameta.allure.util.ResultsUtils.createTitlePathFromQualifiedClassName;
 import static io.qameta.allure.util.ResultsUtils.firstNonEmpty;
 import static io.qameta.allure.util.ResultsUtils.getMd5Digest;
 import static io.qameta.allure.util.ResultsUtils.getProvidedLabels;
@@ -101,19 +103,26 @@
 import static java.util.Objects.nonNull;
 
 /**
- * Allure TestNG listener.
+ * Reports TestNG execution to Allure.
+ *
+ * <p>Register this listener with TestNG to translate suites, test contexts, classes, configuration methods, data providers, and test methods into Allure containers, fixtures, and test results. It also applies Allure test plan filtering when a plan is configured.</p>
  */
-@SuppressWarnings({
-        "ClassDataAbstractionCoupling",
-        "ClassFanOutComplexity",
-})
-public class AllureTestNg implements
-        ISuiteListener,
-        ITestListener,
-        IInvokedMethodListener,
-        IConfigurationListener,
-        IMethodInterceptor,
-        IDataProviderListener {
+@SuppressWarnings(
+    {
+            "ClassDataAbstractionCoupling",
+            "ClassFanOutComplexity",
+            "PMD.GodClass",
+            "PMD.TooManyMethods",
+    }
+)
+public class AllureTestNg
+        implements
+            ISuiteListener,
+            ITestListener,
+            IInvokedMethodListener,
+            IConfigurationListener,
+            IMethodInterceptor,
+            IDataProviderListener {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(AllureTestNg.class);
 
@@ -122,37 +131,37 @@ public class AllureTestNg implements
             ITestContext.class, ITestResult.class, XmlTest.class, Method.class, Object[].class
     );
 
-    private static final boolean HAS_CUCUMBERJVM7_IN_CLASSPATH
-            = isClassAvailableOnClasspath("io.qameta.allure.cucumber7jvm.AllureCucumber7Jvm");
+    private static final boolean HAS_CUCUMBERJVM7_IN_CLASSPATH = isClassAvailableOnClasspath("io.qameta.allure.cucumber7jvm.AllureCucumber7Jvm");
 
-    private static final boolean HAS_CUCUMBERJVM6_IN_CLASSPATH
-            = isClassAvailableOnClasspath("io.qameta.allure.cucumber6jvm.AllureCucumber6Jvm");
+    private static final boolean HAS_CUCUMBERJVM6_IN_CLASSPATH = isClassAvailableOnClasspath("io.qameta.allure.cucumber6jvm.AllureCucumber6Jvm");
 
-    private static final boolean HAS_CUCUMBERJVM5_IN_CLASSPATH
-            = isClassAvailableOnClasspath("io.qameta.allure.cucumber5jvm.AllureCucumber5Jvm");
+    private static final boolean HAS_CUCUMBERJVM5_IN_CLASSPATH = isClassAvailableOnClasspath("io.qameta.allure.cucumber5jvm.AllureCucumber5Jvm");
 
-    private static final boolean HAS_CUCUMBERJVM4_IN_CLASSPATH
-            = isClassAvailableOnClasspath("io.qameta.allure.cucumber4jvm.AllureCucumber4Jvm");
+    private static final boolean HAS_CUCUMBERJVM4_IN_CLASSPATH = isClassAvailableOnClasspath("io.qameta.allure.cucumber4jvm.AllureCucumber4Jvm");
 
     /**
      * Store current testng result uuid to attach before/after methods into.
      */
     private final ThreadLocal<Current> currentTestResult = ThreadLocal
             .withInitial(Current::new);
+
     /**
      * Store current container uuid for fake containers around before/after methods.
      */
     private final ThreadLocal<String> currentTestContainer = ThreadLocal
             .withInitial(() -> UUID.randomUUID().toString());
+
     /**
      * Store uuid for current executable item to catch steps and attachments.
      */
     private final ThreadLocal<String> currentExecutable = ThreadLocal
             .withInitial(() -> UUID.randomUUID().toString());
+
     /**
      * Store uuid for class test containers.
      */
     private final Map<ITestClass, String> classContainerUuidStorage = new ConcurrentHashMap<>();
+
     /**
      * Store uuid for data provider containers.
      */
@@ -338,8 +347,7 @@ protected boolean shouldSkipReportingFor(final ITestResult testResult) {
         return (HAS_CUCUMBERJVM7_IN_CLASSPATH
                 || HAS_CUCUMBERJVM6_IN_CLASSPATH
                 || HAS_CUCUMBERJVM5_IN_CLASSPATH
-                || HAS_CUCUMBERJVM4_IN_CLASSPATH
-               ) && groupsSet.contains("cucumber");
+                || HAS_CUCUMBERJVM4_IN_CLASSPATH) && groupsSet.contains("cucumber");
     }
 
     protected void startTestCase(final ITestResult testResult,
@@ -365,24 +373,26 @@ protected void startTestCase(final ITestContext context,
         final ITestClass testClass = method.getTestClass();
         final List<Label> labels = new ArrayList<>();
         labels.addAll(getProvidedLabels());
-        labels.addAll(Arrays.asList(
-                //Packages grouping
-                createPackageLabel(testClass.getName()),
-                createTestClassLabel(testClass.getName()),
-                createTestMethodLabel(method.getMethodName()),
-
-                //xUnit grouping
-                createParentSuiteLabel(safeExtractSuiteName(testClass)),
-                createSuiteLabel(safeExtractTestTag(testClass)),
-                createSubSuiteLabel(safeExtractTestClassName(testClass)),
-
-                //Timeline grouping
-                createHostLabel(),
-                createThreadLabel(),
-
-                createFrameworkLabel("testng"),
-                createLanguageLabel("java")
-        ));
+        labels.addAll(
+                Arrays.asList(
+                        //Packages grouping
+                        createPackageLabel(testClass.getName()),
+                        createTestClassLabel(testClass.getName()),
+                        createTestMethodLabel(method.getMethodName()),
+
+                        //xUnit grouping
+                        createParentSuiteLabel(safeExtractSuiteName(testClass)),
+                        createSuiteLabel(safeExtractTestTag(testClass)),
+                        createSubSuiteLabel(safeExtractTestClassName(testClass)),
+
+                        //Timeline grouping
+                        createHostLabel(),
+                        createThreadLabel(),
+
+                        createFrameworkLabel("testng"),
+                        createLanguageLabel("java")
+                )
+        );
         labels.addAll(getLabels(method, iClass));
         final List<Parameter> parameters = getParameters(context, method, params);
         final TestResult result = new TestResult()
@@ -390,9 +400,12 @@ protected void startTestCase(final ITestContext context,
                 .setHistoryId(getHistoryId(method, parameters))
                 .setName(getMethodName(method))
                 .setFullName(getQualifiedName(method))
-                .setStatusDetails(new StatusDetails()
-                        .setFlaky(isFlaky(method, iClass))
-                        .setMuted(isMuted(method, iClass)))
+                .setTitlePath(getTitlePath(testClass))
+                .setStatusDetails(
+                        new StatusDetails()
+                                .setFlaky(isFlaky(method, iClass))
+                                .setMuted(isMuted(method, iClass))
+                )
                 .setParameters(parameters)
                 .setLinks(getLinks(method, iClass))
                 .setLabels(labels);
@@ -408,6 +421,17 @@ protected void startTestCase(final ITestContext context,
         getLifecycle().startTestCase(uuid);
     }
 
+    private List<String> getTitlePath(final ITestClass testClass) {
+        final List<String> result = new ArrayList<>(
+                createTitlePath(
+                        safeExtractSuiteName(testClass),
+                        safeExtractTestTag(testClass)
+                )
+        );
+        result.addAll(createTitlePathFromQualifiedClassName(testClass.getName()));
+        return result;
+    }
+
     @Override
     public void onTestSuccess(final ITestResult testResult) {
         if (shouldSkipReportingFor(testResult)) {
@@ -594,9 +618,11 @@ public void afterInvocation(final IInvokedMethod method, final ITestResult testR
             if (testResult.isSuccess()) {
                 getLifecycle().updateFixture(executableUuid, result -> result.setStatus(Status.PASSED));
             } else {
-                getLifecycle().updateFixture(executableUuid, result -> result
-                        .setStatus(getStatus(testResult.getThrowable()))
-                        .setStatusDetails(getStatusDetails(testResult.getThrowable()).orElse(null)));
+                getLifecycle().updateFixture(
+                        executableUuid, result -> result
+                                .setStatus(getStatus(testResult.getThrowable()))
+                                .setStatusDetails(getStatusDetails(testResult.getThrowable()).orElse(null))
+                );
             }
             getLifecycle().stopFixture(executableUuid);
 
@@ -697,9 +723,11 @@ public void onDataProviderFailure(final ITestNGMethod method,
                                       final ITestContext ctx,
                                       final RuntimeException t) {
         final String uuid = currentExecutable.get();
-        getLifecycle().updateFixture(uuid, result -> result
-                .setStatus(getStatus(t))
-                .setStatusDetails(getStatusDetails(t).orElse(null)));
+        getLifecycle().updateFixture(
+                uuid, result -> result
+                        .setStatus(getStatus(t))
+                        .setStatusDetails(getStatusDetails(t).orElse(null))
+        );
         getLifecycle().stopFixture(uuid);
         currentExecutable.remove();
     }
@@ -727,9 +755,9 @@ protected Status getStatus(final Throwable throwable) {
     @SuppressWarnings("BooleanExpressionComplexity")
     private boolean isSupportedConfigurationFixture(final ITestNGMethod testMethod) {
         return testMethod.isBeforeMethodConfiguration() || testMethod.isAfterMethodConfiguration()
-               || testMethod.isBeforeTestConfiguration() || testMethod.isAfterTestConfiguration()
-               || testMethod.isBeforeClassConfiguration() || testMethod.isAfterClassConfiguration()
-               || testMethod.isBeforeSuiteConfiguration() || testMethod.isAfterSuiteConfiguration();
+                || testMethod.isBeforeTestConfiguration() || testMethod.isAfterTestConfiguration()
+                || testMethod.isBeforeClassConfiguration() || testMethod.isAfterClassConfiguration()
+                || testMethod.isBeforeSuiteConfiguration() || testMethod.isAfterSuiteConfiguration();
     }
 
     private void validateContainerExists(final String fixtureName, final String containerUuid) {
@@ -816,7 +844,7 @@ private String getUniqueUuid(final IAttributes suite) {
         return Objects.toString(suite.getAttribute(ALLURE_UUID));
     }
 
-    @SuppressWarnings("PMD.AvoidAccessibilityAlteration")
+    @SuppressWarnings({"PMD.AvoidAccessibilityAlteration", "PMD.CognitiveComplexity"})
     private List<Parameter> getParameters(final ITestContext context,
                                           final ITestNGMethod method,
                                           final Object... parameters) {
@@ -887,7 +915,8 @@ private String getMethodName(final ITestNGMethod method) {
         return firstNonEmpty(
                 method.getDescription(),
                 method.getMethodName(),
-                getQualifiedName(method)).orElse("Unknown");
+                getQualifiedName(method)
+        ).orElse("Unknown");
     }
 
     @SuppressWarnings("SameParameterValue")
@@ -901,6 +930,8 @@ private Consumer<TestResult> setStatus(final Status status, final StatusDetails
             if (nonNull(details)) {
                 result.getStatusDetails().setTrace(details.getTrace());
                 result.getStatusDetails().setMessage(details.getMessage());
+                result.getStatusDetails().setActual(details.getActual());
+                result.getStatusDetails().setExpected(details.getExpected());
             }
         };
     }
diff --git a/allure-testng/src/main/java/io/qameta/allure/testng/AllureTestNgTestFilter.java b/allure-testng/src/main/java/io/qameta/allure/testng/AllureTestNgTestFilter.java
index 2c0f6cfe..91511914 100644
--- a/allure-testng/src/main/java/io/qameta/allure/testng/AllureTestNgTestFilter.java
+++ b/allure-testng/src/main/java/io/qameta/allure/testng/AllureTestNgTestFilter.java
@@ -32,35 +32,68 @@
 import java.util.Optional;
 import java.util.stream.Collectors;
 
+/**
+ * Filters TestNG methods using an Allure test plan.
+ *
+ * <p>TestNG calls this interceptor before execution. It keeps only methods selected by the configured Allure test plan so local and CI runs execute the requested subset.</p>
+ */
 public class AllureTestNgTestFilter implements IMethodInterceptor {
 
     private final TestPlan testPlan;
 
+    /**
+     * Creates an Allure test ng test filter with default configuration.
+     */
     public AllureTestNgTestFilter() {
         this.testPlan = new FileTestPlanSupplier().supply().orElse(new TestPlanUnknown());
     }
 
+    /**
+     * Creates an Allure test ng test filter with the supplied values.
+     *
+     * @param testPlan the Allure test plan to evaluate against
+     */
     public AllureTestNgTestFilter(final TestPlan testPlan) {
         this.testPlan = testPlan;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public List<IMethodInstance> intercept(final List<IMethodInstance> methods,
                                            final ITestContext context) {
         return methods.stream()
                 .filter(this::isSelected)
-                .sorted(Comparator.comparing(
-                        IMethodInstance::getMethod,
-                        Comparator.nullsFirst(Comparator.comparingInt(
-                                ITestNGMethod::getPriority
-                        ))))
+                .sorted(
+                        Comparator.comparing(
+                                IMethodInstance::getMethod,
+                                Comparator.nullsFirst(
+                                        Comparator.comparingInt(
+                                                ITestNGMethod::getPriority
+                                        )
+                                )
+                        )
+                )
                 .collect(Collectors.toList());
     }
 
+    /**
+     * Returns whether selected.
+     *
+     * @param instance the TestNG method instance to evaluate
+     * @return true when selected; false otherwise
+     */
     public boolean isSelected(final IMethodInstance instance) {
         return isSelected(instance.getMethod());
     }
 
+    /**
+     * Returns whether selected.
+     *
+     * @param method the framework or Java method to inspect
+     * @return true when selected; false otherwise
+     */
     public boolean isSelected(final ITestNGMethod method) {
         if (testPlan instanceof TestPlanV1_0) {
             return isSelected(method, (TestPlanV1_0) testPlan);
@@ -69,6 +102,13 @@ public boolean isSelected(final ITestNGMethod method) {
         }
     }
 
+    /**
+     * Returns whether selected.
+     *
+     * @param testNGMethod the TestNG method to evaluate
+     * @param testPlan the Allure test plan to evaluate against
+     * @return true when selected; false otherwise
+     */
     public boolean isSelected(final ITestNGMethod testNGMethod, final TestPlanV1_0 testPlan) {
         final Optional<Method> method = Optional.ofNullable(testNGMethod)
                 .map(ITestNGMethod::getConstructorOrMethod)
@@ -86,8 +126,10 @@ public boolean isSelected(final ITestNGMethod testNGMethod, final TestPlanV1_0 t
     }
 
     private String getSelector(final Method method) {
-        return String.format("%s.%s",
+        return String.format(
+                "%s.%s",
                 method.getDeclaringClass().getCanonicalName(),
-                method.getName());
+                method.getName()
+        );
     }
 }
diff --git a/allure-testng/src/main/java/io/qameta/allure/testng/Tag.java b/allure-testng/src/main/java/io/qameta/allure/testng/Tag.java
index 37570fcd..5cc050b5 100644
--- a/allure-testng/src/main/java/io/qameta/allure/testng/Tag.java
+++ b/allure-testng/src/main/java/io/qameta/allure/testng/Tag.java
@@ -27,7 +27,9 @@
 import static io.qameta.allure.util.ResultsUtils.TAG_LABEL_NAME;
 
 /**
- * @author neparij (Nikolay Laptev).
+ * Adds Allure tag metadata to supported test elements.
+ *
+ * <p>Users normally apply {@code @Tag} to test classes or methods; Java creates the container annotation when several tags are declared on the same element.</p>
  */
 @Target({ElementType.TYPE, ElementType.METHOD})
 @Retention(RetentionPolicy.RUNTIME)
@@ -36,6 +38,11 @@
 @LabelAnnotation(name = TAG_LABEL_NAME)
 public @interface Tag {
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     String value();
 
 }
diff --git a/allure-testng/src/main/java/io/qameta/allure/testng/Tags.java b/allure-testng/src/main/java/io/qameta/allure/testng/Tags.java
index 46139cfd..90c96b5e 100644
--- a/allure-testng/src/main/java/io/qameta/allure/testng/Tags.java
+++ b/allure-testng/src/main/java/io/qameta/allure/testng/Tags.java
@@ -22,13 +22,20 @@
 import java.lang.annotation.Target;
 
 /**
- * @author neparij (Nikolay Laptev).
+ * Container annotation for repeatable Allure tag annotations.
+ *
+ * <p>Users normally apply {@code @Tag} to test classes or methods; Java creates the container annotation when several tags are declared on the same element.</p>
  */
 @Target({ElementType.TYPE, ElementType.METHOD})
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
 public @interface Tags {
 
+    /**
+     * Returns the annotation value.
+     *
+     * @return the annotation value
+     */
     Tag[] value();
 
 }
diff --git a/allure-testng/src/main/java/io/qameta/allure/testng/config/AllureTestNgConfig.java b/allure-testng/src/main/java/io/qameta/allure/testng/config/AllureTestNgConfig.java
index 7fc1738a..7b28fa55 100644
--- a/allure-testng/src/main/java/io/qameta/allure/testng/config/AllureTestNgConfig.java
+++ b/allure-testng/src/main/java/io/qameta/allure/testng/config/AllureTestNgConfig.java
@@ -21,38 +21,82 @@
 
 import static java.lang.Boolean.parseBoolean;
 
+/**
+ * Stores configuration options for the Allure TestNG integration.
+ *
+ * <p>Create an instance from {@link java.util.Properties} when tests need explicit options, or use {@link #loadConfigProperties()} to read the standard Allure properties file. The fluent setters support programmatic configuration.</p>
+ */
 public class AllureTestNgConfig {
 
+    /**
+     * Configuration key for allure testng hide disabled tests.
+     */
     public static final String ALLURE_TESTNG_HIDE_DISABLED_TESTS = "allure.testng.hide.disabled.tests";
+
+    /**
+     * Configuration key for allure testng hide configuration failures.
+     */
     public static final String ALLURE_TESTNG_HIDE_CONFIGURATION_FAILURES = "allure.testng.hide.configuration.failures";
     private boolean hideDisabledTests;
     private boolean hideConfigurationFailures;
 
+    /**
+     * Creates an Allure test ng config with the supplied values.
+     *
+     * @param properties the properties to read configuration values from
+     */
     public AllureTestNgConfig(final Properties properties) {
         this.hideDisabledTests = parseBoolean(properties.getProperty(ALLURE_TESTNG_HIDE_DISABLED_TESTS));
         this.hideConfigurationFailures = parseBoolean(
-            properties.getProperty(ALLURE_TESTNG_HIDE_CONFIGURATION_FAILURES)
+                properties.getProperty(ALLURE_TESTNG_HIDE_CONFIGURATION_FAILURES)
         );
     }
 
+    /**
+     * Returns whether hide disabled tests.
+     *
+     * @return true when hide disabled tests; false otherwise
+     */
     public boolean isHideDisabledTests() {
         return hideDisabledTests;
     }
 
+    /**
+     * Sets the hide disabled tests.
+     *
+     * @param hide whether disabled tests should be hidden
+     * @return this instance for method chaining
+     */
     public AllureTestNgConfig setHideDisabledTests(final boolean hide) {
         this.hideDisabledTests = hide;
         return this;
     }
 
+    /**
+     * Returns whether hide configuration failures.
+     *
+     * @return true when hide configuration failures; false otherwise
+     */
     public boolean isHideConfigurationFailures() {
         return hideConfigurationFailures;
     }
 
+    /**
+     * Sets the hide configuration failures.
+     *
+     * @param hideConfigurationFailure whether configuration failures should be hidden
+     * @return this instance for method chaining
+     */
     public AllureTestNgConfig setHideConfigurationFailures(final boolean hideConfigurationFailure) {
         this.hideConfigurationFailures = hideConfigurationFailure;
         return this;
     }
 
+    /**
+     * Loads and returns the config properties.
+     *
+     * @return the configuration loaded from standard Allure properties
+     */
     public static AllureTestNgConfig loadConfigProperties() {
         final Properties properties = PropertiesUtils.loadAllureProperties();
         return new AllureTestNgConfig(properties);
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/AllureTestNgTest.java b/allure-testng/src/test/java/io/qameta/allure/testng/AllureTestNgTest.java
index bc1f54bf..180eacbc 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/AllureTestNgTest.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/AllureTestNgTest.java
@@ -39,9 +39,12 @@
 import io.qameta.allure.testng.samples.TestsWithIdForFilter;
 import org.assertj.core.api.Condition;
 import org.assertj.core.groups.Tuple;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.testng.TestNG;
-import org.testng.annotations.DataProvider;
-import org.testng.annotations.Test;
 import org.testng.xml.XmlSuite;
 
 import java.net.URL;
@@ -54,6 +57,7 @@
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static io.qameta.allure.util.ResultsUtils.ALLURE_SEPARATE_LINES_SYSPROP;
 import static java.lang.String.format;
@@ -61,46 +65,44 @@
 import static java.util.Collections.singletonList;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.tuple;
-
-/**
- * @author Egor Borisov ehborisov@gmail.com
- */
+import static org.junit.jupiter.params.provider.Arguments.arguments;
 @SuppressWarnings("deprecation")
 public class AllureTestNgTest {
 
-
-    private static final Condition<List<? extends FixtureResult>> ALL_FINISHED = new Condition<>(items ->
-            items.stream().allMatch(item -> item.getStage() == Stage.FINISHED),
-            "All items should have be in a finished stage");
-
-    private static final Condition<List<? extends WithSteps>> WITH_STEPS = new Condition<>(items ->
-            items.stream().allMatch(item -> item.getSteps().size() == 1),
-            "All items should have a step attached");
-
-    @DataProvider(name = "parallelConfiguration")
-    public static Object[][] parallelConfiguration() {
-        return new Object[][]{
-                new Object[]{XmlSuite.ParallelMode.NONE, 10},
-                new Object[]{XmlSuite.ParallelMode.NONE, 5},
-                new Object[]{XmlSuite.ParallelMode.NONE, 2},
-                new Object[]{XmlSuite.ParallelMode.NONE, 1},
-                new Object[]{XmlSuite.ParallelMode.METHODS, 10},
-                new Object[]{XmlSuite.ParallelMode.METHODS, 5},
-                new Object[]{XmlSuite.ParallelMode.METHODS, 2},
-                new Object[]{XmlSuite.ParallelMode.METHODS, 1},
-                new Object[]{XmlSuite.ParallelMode.CLASSES, 10},
-                new Object[]{XmlSuite.ParallelMode.CLASSES, 5},
-                new Object[]{XmlSuite.ParallelMode.CLASSES, 2},
-                new Object[]{XmlSuite.ParallelMode.CLASSES, 1},
-                new Object[]{XmlSuite.ParallelMode.INSTANCES, 10},
-                new Object[]{XmlSuite.ParallelMode.INSTANCES, 5},
-                new Object[]{XmlSuite.ParallelMode.INSTANCES, 2},
-                new Object[]{XmlSuite.ParallelMode.INSTANCES, 1},
-                new Object[]{XmlSuite.ParallelMode.TESTS, 10},
-                new Object[]{XmlSuite.ParallelMode.TESTS, 5},
-                new Object[]{XmlSuite.ParallelMode.TESTS, 2},
-                new Object[]{XmlSuite.ParallelMode.TESTS, 1},
-        };
+    private static final Condition<List<? extends FixtureResult>> ALL_FINISHED = new Condition<>(
+            items -> items.stream().allMatch(item -> item.getStage() == Stage.FINISHED),
+            "All items should have be in a finished stage"
+    );
+
+    private static final Condition<List<? extends WithSteps>> WITH_STEPS = new Condition<>(
+            items -> items.stream().allMatch(item -> item.getSteps().size() == 1),
+            "All items should have a step attached"
+    );
+
+    @SuppressWarnings("unused")
+    private static Stream<Arguments> parallelConfiguration() {
+        return Stream.of(
+                arguments(XmlSuite.ParallelMode.NONE, 10),
+                arguments(XmlSuite.ParallelMode.NONE, 5),
+                arguments(XmlSuite.ParallelMode.NONE, 2),
+                arguments(XmlSuite.ParallelMode.NONE, 1),
+                arguments(XmlSuite.ParallelMode.METHODS, 10),
+                arguments(XmlSuite.ParallelMode.METHODS, 5),
+                arguments(XmlSuite.ParallelMode.METHODS, 2),
+                arguments(XmlSuite.ParallelMode.METHODS, 1),
+                arguments(XmlSuite.ParallelMode.CLASSES, 10),
+                arguments(XmlSuite.ParallelMode.CLASSES, 5),
+                arguments(XmlSuite.ParallelMode.CLASSES, 2),
+                arguments(XmlSuite.ParallelMode.CLASSES, 1),
+                arguments(XmlSuite.ParallelMode.INSTANCES, 10),
+                arguments(XmlSuite.ParallelMode.INSTANCES, 5),
+                arguments(XmlSuite.ParallelMode.INSTANCES, 2),
+                arguments(XmlSuite.ParallelMode.INSTANCES, 1),
+                arguments(XmlSuite.ParallelMode.TESTS, 10),
+                arguments(XmlSuite.ParallelMode.TESTS, 5),
+                arguments(XmlSuite.ParallelMode.TESTS, 2),
+                arguments(XmlSuite.ParallelMode.TESTS, 1)
+        );
     }
 
     @AllureFeatures.Fixtures
@@ -133,7 +135,8 @@ public void shouldSetConfigurationProperty() {
     }
 
     @AllureFeatures.Parallel
-    @Test(description = "Parallel data provider tests")
+    @Test
+    @DisplayName("Parallel data provider tests")
     public void parallelDataProvider() {
         final AllureResults results = runTestNgSuites("suites/parallel-data-provider.xml");
         List<TestResult> testResult = results.getTestResults();
@@ -143,7 +146,8 @@ public void parallelDataProvider() {
     }
 
     @AllureFeatures.Base
-    @Test(description = "Singe testng")
+    @Test
+    @DisplayName("Singe testng")
     public void singleTest() {
         final String testName = "testWithOneStep";
         final AllureResults results = runTestNgSuites("suites/single-test.xml");
@@ -154,6 +158,11 @@ public void singleTest() {
                 .hasFieldOrPropertyWithValue("status", Status.PASSED)
                 .hasFieldOrPropertyWithValue("stage", Stage.FINISHED)
                 .hasFieldOrPropertyWithValue("name", testName);
+        assertThat(testResult.get(0).getTitlePath())
+                .containsExactly(
+                        "Test suite 7", "Test tag 7",
+                        "io", "qameta", "allure", "testng", "samples", "TestsWithSteps"
+                );
         assertThat(testResult)
                 .flatExtracting(TestResult::getSteps)
                 .hasSize(1)
@@ -162,7 +171,9 @@ public void singleTest() {
     }
 
     @AllureFeatures.Base
-    @Test(description = "Test with timeout", dataProvider = "parallelConfiguration")
+    @ParameterizedTest
+    @MethodSource("parallelConfiguration")
+    @DisplayName("Test with timeout")
     public void testWithTimeout(final XmlSuite.ParallelMode mode, final int threadCount) {
 
         final String testNameWithTimeout = "testWithTimeout";
@@ -174,27 +185,34 @@ public void testWithTimeout(final XmlSuite.ParallelMode mode, final int threadCo
                 .as("Test case results have not been written")
                 .hasSize(2)
                 .as("Unexpectedly passed status or stage of tests")
-                .allMatch(testResult -> testResult.getStatus().equals(Status.PASSED) &&
-                                        testResult.getStage().equals(Stage.FINISHED))
+                .allMatch(
+                        testResult -> testResult.getStatus().equals(Status.PASSED) &&
+                                testResult.getStage().equals(Stage.FINISHED)
+                )
                 .extracting(TestResult::getName)
                 .as("Unexpectedly passed name of tests")
-                .containsOnlyElementsOf(asList(
-                        testNameWithoutTimeout,
-                        testNameWithTimeout)
+                .containsOnlyElementsOf(
+                        asList(
+                                testNameWithoutTimeout,
+                                testNameWithTimeout
+                        )
                 );
         assertThat(testResults)
                 .flatExtracting(TestResult::getSteps)
                 .as("No steps present for test with timeout")
                 .hasSize(2)
                 .extracting(StepResult::getName)
-                .containsOnlyElementsOf(asList(
-                        "Step of the test with timeout",
-                        "Step of the test with no timeout")
+                .containsOnlyElementsOf(
+                        asList(
+                                "Step of the test with timeout",
+                                "Step of the test with no timeout"
+                        )
                 );
     }
 
     @AllureFeatures.Descriptions
-    @Test(description = "Javadoc description with line separation")
+    @Test
+    @DisplayName("Javadoc description with line separation")
     public void descriptionsWithLineSeparationTest() {
         String initialSeparateLines = System.getProperty(ALLURE_SEPARATE_LINES_SYSPROP);
         if (!Boolean.parseBoolean(initialSeparateLines)) {
@@ -217,7 +235,8 @@ public void descriptionsWithLineSeparationTest() {
     }
 
     @AllureFeatures.Descriptions
-    @Test(description = "Javadoc description of tests")
+    @Test
+    @DisplayName("Javadoc description of tests")
     public void descriptionsTest() {
         final String testDescription = "Sample test description";
         final AllureResults results = runTestNgSuites("suites/descriptions-test.xml");
@@ -232,7 +251,9 @@ public void descriptionsTest() {
     }
 
     @AllureFeatures.Descriptions
-    @Test(description = "Javadoc description of befores", dataProvider = "parallelConfiguration")
+    @ParameterizedTest
+    @MethodSource("parallelConfiguration")
+    @DisplayName("Javadoc description of befores")
     public void descriptionsBefores(final XmlSuite.ParallelMode mode, final int threadCount) {
         final String beforeClassDescription = "Before class description";
         final String beforeMethodDescription = "Before method description";
@@ -257,7 +278,8 @@ public void descriptionsBefores(final XmlSuite.ParallelMode mode, final int thre
     }
 
     @AllureFeatures.Descriptions
-    @Test(description = "Javadoc description of befores with the same names")
+    @Test
+    @DisplayName("Javadoc description of befores with the same names")
     public void javadocDescriptionsOfBeforesWithTheSameNames() {
         final AllureResults results = runTestNgSuites("suites/descriptions-test-two-classes.xml");
         List<TestResultContainer> testContainers = results.getTestResultContainers();
@@ -265,12 +287,15 @@ public void javadocDescriptionsOfBeforesWithTheSameNames() {
         checkBeforeJavadocDescriptions(testContainers, "io.qameta.allure.testng.samples.DescriptionsTest.setUpMethod", "Before method description");
         checkBeforeJavadocDescriptions(testContainers, "io.qameta.allure.testng.samples.DescriptionsTest", "Before class description");
 
-        checkBeforeJavadocDescriptions(testContainers, "io.qameta.allure.testng.samples.DescriptionsAnotherTest.setUpMethod", "Before method description from DescriptionsAnotherTest");
+        checkBeforeJavadocDescriptions(
+                testContainers, "io.qameta.allure.testng.samples.DescriptionsAnotherTest.setUpMethod", "Before method description from DescriptionsAnotherTest"
+        );
         checkBeforeJavadocDescriptions(testContainers, "io.qameta.allure.testng.samples.DescriptionsAnotherTest", "Before class description from DescriptionsAnotherTest");
     }
 
     @AllureFeatures.Descriptions
-    @Test(description = "Javadoc description of tests with the same names")
+    @Test
+    @DisplayName("Javadoc description of tests with the same names")
     public void javadocDescriptionsOfTestsWithTheSameNames() {
         final AllureResults results = runTestNgSuites("suites/descriptions-test-two-classes.xml");
         List<TestResult> testResults = results.getTestResults();
@@ -281,7 +306,8 @@ public void javadocDescriptionsOfTestsWithTheSameNames() {
     }
 
     @AllureFeatures.FailedTests
-    @Test(description = "Test failing by assertion")
+    @Test
+    @DisplayName("Test failing by assertion")
     public void failingByAssertion() {
         String testName = "failingByAssertion";
         final AllureResults results = runTestNgSuites("suites/failing-by-assertion.xml");
@@ -300,7 +326,8 @@ public void failingByAssertion() {
     }
 
     @AllureFeatures.BrokenTests
-    @Test(description = "Broken testng")
+    @Test
+    @DisplayName("Broken testng")
     public void brokenTest() {
         String testName = "brokenTest";
         final AllureResults results = runTestNgSuites("suites/broken.xml");
@@ -322,7 +349,8 @@ public void brokenTest() {
     }
 
     @AllureFeatures.BrokenTests
-    @Test(description = "Broken testng - Exception without message")
+    @Test
+    @DisplayName("Broken testng - Exception without message")
     public void brokenTestWithOutMessage() {
         String testName = "brokenTestWithoutMessage";
         final AllureResults results = runTestNgSuites("suites/brokenWithoutMessage.xml");
@@ -345,7 +373,9 @@ public void brokenTestWithOutMessage() {
     }
 
     @AllureFeatures.Fixtures
-    @Test(description = "Suite fixtures", dataProvider = "parallelConfiguration")
+    @ParameterizedTest
+    @MethodSource("parallelConfiguration")
+    @DisplayName("Suite fixtures")
     public void perSuiteFixtures(final XmlSuite.ParallelMode mode, final int threadCount) {
         String suiteName = "Test suite 12";
         String testTagName = "Test tag 12";
@@ -372,7 +402,9 @@ public void perSuiteFixtures(final XmlSuite.ParallelMode mode, final int threadC
     }
 
     @AllureFeatures.Fixtures
-    @Test(description = "Class fixtures", dataProvider = "parallelConfiguration")
+    @ParameterizedTest
+    @MethodSource("parallelConfiguration")
+    @DisplayName("Class fixtures")
     public void perClassFixtures(final XmlSuite.ParallelMode mode, final int threadCount) {
         final AllureResults results = runTestNgSuites(
                 parallel(mode, threadCount),
@@ -401,7 +433,9 @@ public void perClassFixtures(final XmlSuite.ParallelMode mode, final int threadC
     }
 
     @AllureFeatures.Fixtures
-    @Test(description = "Method fixtures", dataProvider = "parallelConfiguration")
+    @ParameterizedTest
+    @MethodSource("parallelConfiguration")
+    @DisplayName("Method fixtures")
     public void perMethodFixtures(final XmlSuite.ParallelMode mode, final int threadCount) {
         String suiteName = "Test suite 11";
         String testTagName = "Test tag 11";
@@ -430,7 +464,9 @@ public void perMethodFixtures(final XmlSuite.ParallelMode mode, final int thread
     }
 
     @AllureFeatures.Fixtures
-    @Test(description = "Test fixtures", dataProvider = "parallelConfiguration")
+    @ParameterizedTest
+    @MethodSource("parallelConfiguration")
+    @DisplayName("Test fixtures")
     public void perTestTagFixtures(final XmlSuite.ParallelMode mode, final int threadCount) {
         String suiteName = "Test suite 13";
         String testTagName = "Test tag 13";
@@ -457,11 +493,13 @@ public void perTestTagFixtures(final XmlSuite.ParallelMode mode, final int threa
     }
 
     @AllureFeatures.SkippedTests
-    @Test(description = "Skipped suite")
+    @Test
+    @DisplayName("Skipped suite")
     public void skippedSuiteTest() {
-        final Condition<StepResult> skipReason = new Condition<>(step ->
-                step.getStatusDetails().getTrace().startsWith("java.lang.RuntimeException: Skip all"),
-                "Suite should be skipped because of an exception in before suite");
+        final Condition<StepResult> skipReason = new Condition<>(
+                step -> step.getStatusDetails().getTrace().startsWith("java.lang.RuntimeException: Skip all"),
+                "Suite should be skipped because of an exception in before suite"
+        );
 
         final AllureResults results = runTestNgSuites("suites/skipped-suite.xml");
         List<TestResult> testResults = results.getTestResults();
@@ -494,7 +532,8 @@ public void skippedSuiteTest() {
     }
 
     @AllureFeatures.Base
-    @Test(description = "Multi suites")
+    @Test
+    @DisplayName("Multi suites")
     public void multipleSuites() {
         String beforeMethodName = "io.qameta.allure.testng.samples.ParameterizedTest.beforeMethod";
         String firstSuiteName = "Test suite 6";
@@ -512,8 +551,10 @@ public void multipleSuites() {
         List<String> uids = testResults.stream().map(TestResult::getUuid).collect(Collectors.toList());
         assertThat(testContainers).as("Unexpected quantity of testng containers has been written")
                 .hasSize(9).extracting(TestResultContainer::getName)
-                .contains(beforeMethodName, beforeMethodName, firstTagName, firstSuiteName, secondTagName,
-                        secondSuiteName);
+                .contains(
+                        beforeMethodName, beforeMethodName, firstTagName, firstSuiteName, secondTagName,
+                        secondSuiteName
+                );
 
         final List<String> firstSuite = uids.subList(0, 2);
         assertContainersChildren(beforeMethodName, testContainers, firstSuite);
@@ -526,7 +567,8 @@ public void multipleSuites() {
 
     @SuppressWarnings("unchecked")
     @AllureFeatures.Parameters
-    @Test(description = "Before Suite Parameter")
+    @Test
+    @DisplayName("Before Suite Parameter")
     public void testBeforeSuiteParameter() {
         final AllureResults results = runTestNgSuites("suites/parameterized-suite1.xml", "suites/parameterized-suite2.xml");
         List<TestResult> testResults = results.getTestResults();
@@ -543,7 +585,8 @@ public void testBeforeSuiteParameter() {
     }
 
     @AllureFeatures.Parallel
-    @Test(description = "Parallel methods")
+    @Test
+    @DisplayName("Parallel methods")
     public void parallelMethods() {
         String before1 = "io.qameta.allure.testng.samples.ParallelMethods.beforeMethod";
         String before2 = "io.qameta.allure.testng.samples.ParallelMethods.beforeMethod2";
@@ -566,15 +609,17 @@ public void parallelMethods() {
     }
 
     @AllureFeatures.Steps
-    @Test(description = "Nested steps")
+    @Test
+    @DisplayName("Nested steps")
     public void nestedSteps() {
         String beforeMethod = "io.qameta.allure.testng.samples.NestedSteps.beforeMethod";
         String nestedStep = "nestedStep";
         String stepInBefore = "stepTwo";
         String stepInTest = "stepThree";
-        final Condition<StepResult> substep = new Condition<>(step ->
-                step.getSteps().get(0).getName().equals(nestedStep),
-                "Given step should have a substep with name " + nestedStep);
+        final Condition<StepResult> substep = new Condition<>(
+                step -> step.getSteps().get(0).getName().equals(nestedStep),
+                "Given step should have a substep with name " + nestedStep
+        );
 
         final AllureResults results = runTestNgSuites("suites/nested-steps.xml");
         List<TestResult> testResults = results.getTestResults();
@@ -599,7 +644,8 @@ public void nestedSteps() {
     }
 
     @AllureFeatures.MarkerAnnotations
-    @Test(description = "Flaky tests")
+    @Test
+    @DisplayName("Flaky tests")
     public void flakyTests() {
         final AllureResults results = runTestNgSuites("suites/flaky.xml");
 
@@ -621,7 +667,8 @@ public void flakyTests() {
     }
 
     @AllureFeatures.MarkerAnnotations
-    @Test(description = "Muted tests")
+    @Test
+    @DisplayName("Muted tests")
     public void mutedTests() {
         final AllureResults results = runTestNgSuites("suites/muted.xml");
 
@@ -643,7 +690,8 @@ public void mutedTests() {
     }
 
     @AllureFeatures.Links
-    @Test(description = "Tests with links")
+    @Test
+    @DisplayName("Tests with links")
     public void linksTest() {
         final AllureResults results = runTestNgSuites("suites/links.xml");
 
@@ -654,7 +702,8 @@ public void linksTest() {
                 .hasSize(4)
                 .flatExtracting(TestResult::getLinks)
                 .extracting(Link::getName)
-                .contains("testClass", "a", "b", "c", "testClassIssue", "testClassTmsLink",
+                .contains(
+                        "testClass", "a", "b", "c", "testClassIssue", "testClassTmsLink",
                         "testClass", "nested1", "nested2", "nested3", "testClassIssue", "issue1", "issue2", "issue3",
                         "testClassTmsLink", "tms1", "tms2", "tms3", "testClass", "a", "b", "c", "testClassIssue",
                         "testClassTmsLink", "testClass", "inheritedLink1", "inheritedLink2", "testClassIssue",
@@ -663,7 +712,8 @@ public void linksTest() {
     }
 
     @AllureFeatures.MarkerAnnotations
-    @Test(description = "BDD annotations")
+    @Test
+    @DisplayName("BDD annotations")
     public void bddAnnotationsTest() {
         final AllureResults results = runTestNgSuites("suites/bdd-annotations.xml");
 
@@ -689,7 +739,8 @@ public void bddAnnotationsTest() {
     }
 
     @AllureFeatures.Base
-    @Test(description = "Should support TestNG retries")
+    @Test
+    @DisplayName("Should support TestNG retries")
     public void retryTest() {
         final AllureResults results = runTestNgSuites("suites/retry.xml");
         List<TestResult> testResults = results.getTestResults();
@@ -698,7 +749,8 @@ public void retryTest() {
     }
 
     @AllureFeatures.Severity
-    @Test(description = "Should add severity for tests")
+    @Test
+    @DisplayName("Should add severity for tests")
     public void severityTest() {
         final AllureResults results = runTestNgSuites("suites/severity.xml");
         List<TestResult> testResults = results.getTestResults();
@@ -711,17 +763,19 @@ public void severityTest() {
     }
 
     @AllureFeatures.MarkerAnnotations
-    @Test(description = "Should add owner to tests")
+    @Test
+    @DisplayName("Should add owner to tests")
     public void ownerTest() {
         final AllureResults results = runTestNgSuites("suites/owner.xml");
         List<TestResult> testResults = results.getTestResults();
         assertThat(testResults)
-                .extracting(TestResult::getFullName, tr -> tr.getLabels()
-                        .stream()
-                        .filter(label -> "owner".equals(label.getName()))
-                        .map(Label::getValue)
-                        .sorted()
-                        .collect(Collectors.joining(",", "[", "]"))
+                .extracting(
+                        TestResult::getFullName, tr -> tr.getLabels()
+                                .stream()
+                                .filter(label -> "owner".equals(label.getName()))
+                                .map(Label::getValue)
+                                .sorted()
+                                .collect(Collectors.joining(",", "[", "]"))
                 )
                 .containsExactlyInAnyOrder(
                         tuple("io.qameta.allure.testng.samples.OwnerMethodTest.testWithOwner", "[charlie]"),
@@ -736,17 +790,19 @@ public void ownerTest() {
     }
 
     @AllureFeatures.MarkerAnnotations
-    @Test(description = "Should add tag to tests")
+    @Test
+    @DisplayName("Should add tag to tests")
     public void tagTest() {
         final AllureResults results = runTestNgSuites("suites/tags.xml");
         List<TestResult> testResults = results.getTestResults();
         assertThat(testResults)
-                .extracting(TestResult::getFullName, tr -> tr.getLabels()
-                        .stream()
-                        .filter(label -> "tag".equals(label.getName()))
-                        .map(Label::getValue)
-                        .sorted()
-                        .collect(Collectors.joining(",", "[", "]"))
+                .extracting(
+                        TestResult::getFullName, tr -> tr.getLabels()
+                                .stream()
+                                .filter(label -> "tag".equals(label.getName()))
+                                .map(Label::getValue)
+                                .sorted()
+                                .collect(Collectors.joining(",", "[", "]"))
                 )
                 .containsExactlyInAnyOrder(
                         tuple("io.qameta.allure.testng.samples.TagMethodTest.testWithTag", "[regress]"),
@@ -759,7 +815,8 @@ public void tagTest() {
     }
 
     @AllureFeatures.Attachments
-    @Test(description = "Should add attachments to tests")
+    @Test
+    @DisplayName("Should add attachments to tests")
     public void attachmentsTest() {
         final AllureResults results = runTestNgSuites("suites/attachments.xml");
         List<TestResult> testResults = results.getTestResults();
@@ -773,7 +830,8 @@ public void attachmentsTest() {
 
     @AllureFeatures.MarkerAnnotations
     @Issue("42")
-    @Test(description = "Should process flaky for failed tests")
+    @Test
+    @DisplayName("Should process flaky for failed tests")
     public void shouldAddFlakyToFailedTests() {
         final AllureResults results = runTestNgSuites("suites/gh-42.xml");
 
@@ -789,7 +847,8 @@ public void shouldAddFlakyToFailedTests() {
     }
 
     @AllureFeatures.History
-    @Test(description = "Should use parameters for history id")
+    @Test
+    @DisplayName("Should use parameters for history id")
     public void shouldUseParametersForHistoryIdGeneration() {
         final AllureResults results = runTestNgSuites("suites/history-id-parameters.xml");
 
@@ -800,7 +859,8 @@ public void shouldUseParametersForHistoryIdGeneration() {
     }
 
     @AllureFeatures.History
-    @Test(description = "Should generate the same history id for the same tests")
+    @Test
+    @DisplayName("Should generate the same history id for the same tests")
     public void shouldGenerateSameHistoryIdForTheSameTests() {
         final AllureResults results = runTestNgSuites("suites/history-id-the-same.xml");
 
@@ -814,7 +874,8 @@ public void shouldGenerateSameHistoryIdForTheSameTests() {
     @SuppressWarnings("unchecked")
     @AllureFeatures.Fixtures
     @Issue("67")
-    @Test(description = "Should set correct status for fixtures")
+    @Test
+    @DisplayName("Should set correct status for fixtures")
     public void shouldSetCorrectStatusesForFixtures() {
         final AllureResults results = runTestNgSuites(
                 "suites/per-suite-fixtures-combination.xml",
@@ -860,7 +921,8 @@ public void shouldSetCorrectStatusesForFixtures() {
     @SuppressWarnings("unchecked")
     @AllureFeatures.Fixtures
     @Issue("67")
-    @Test(description = "Should set correct status for failed before fixtures")
+    @Test
+    @DisplayName("Should set correct status for failed before fixtures")
     public void shouldSetCorrectStatusForFailedBeforeFixtures() {
         final AllureResults results = runTestNgSuites(
                 "suites/failed-before-suite-fixture.xml",
@@ -882,7 +944,8 @@ public void shouldSetCorrectStatusForFailedBeforeFixtures() {
     @SuppressWarnings("unchecked")
     @AllureFeatures.Fixtures
     @Issue("67")
-    @Test(description = "Should set correct status for failed after fixtures")
+    @Test
+    @DisplayName("Should set correct status for failed after fixtures")
     public void shouldSetCorrectStatusForFailedAfterFixtures() {
         final Consumer<TestNG> configurer = parallel(XmlSuite.ParallelMode.METHODS, 5);
 
@@ -906,7 +969,8 @@ public void shouldSetCorrectStatusForFailedAfterFixtures() {
 
     @AllureFeatures.Parameters
     @Issue("97")
-    @Test(description = "Should process varargs test parameters")
+    @Test
+    @DisplayName("Should process varargs test parameters")
     public void shouldProcessVarargsParameters() {
         final AllureResults results = runTestNgSuites("suites/gh-97.xml");
 
@@ -921,7 +985,8 @@ public void shouldProcessVarargsParameters() {
 
     @AllureFeatures.Fixtures
     @Issue("99")
-    @Test(description = "Should attach class fixtures correctly")
+    @Test
+    @DisplayName("Should attach class fixtures correctly")
     public void shouldAttachClassFixturesCorrectly() {
         final Consumer<TestNG> configurer = parallel(XmlSuite.ParallelMode.METHODS, 5);
 
@@ -943,7 +1008,6 @@ public void shouldAttachClassFixturesCorrectly() {
                         "io.qameta.allure.testng.samples.ClassFixturesInParent"
                 );
 
-
         final TestResult classFixtures1 = findTestResultByName(results, "classFixtures1");
         final TestResultContainer c1 = findTestContainerByName(results, "io.qameta.allure.testng.samples.ClassFixtures1");
 
@@ -969,12 +1033,12 @@ public void shouldAttachClassFixturesCorrectly() {
         assertThat(c4.getChildren())
                 .containsExactlyInAnyOrder(classFixturesInParent.getUuid());
 
-
     }
 
     @AllureFeatures.History
     @Issue("102")
-    @Test(description = "Should generate different history id for inherited tests")
+    @Test
+    @DisplayName("Should generate different history id for inherited tests")
     public void shouldGenerateDifferentHistoryIdForInheritedTests() {
         final AllureResults results = runTestNgSuites("suites/gh-102.xml");
 
@@ -985,7 +1049,8 @@ public void shouldGenerateDifferentHistoryIdForInheritedTests() {
 
     @AllureFeatures.Fixtures
     @Issue("101")
-    @Test(description = "Should use fixture description")
+    @Test
+    @DisplayName("Should use fixture description")
     public void shouldUseFixtureDescriptions() {
         final AllureResults results = runTestNgSuites("suites/gh-101.xml");
 
@@ -1009,12 +1074,11 @@ public void shouldProcessCyrillicDescriptions() {
     @AllureFeatures.Fixtures
     @AllureFeatures.Parallel
     @Issue("219")
-    @Test(
-            description = "Should not mix up fixtures during parallel run",
-            dataProvider = "parallelConfiguration"
-    )
+    @ParameterizedTest
+    @MethodSource("parallelConfiguration")
+    @DisplayName("Should not mix up fixtures during parallel run")
     public void shouldAddCorrectBeforeMethodFixturesInCaseOfParallelRun(
-            final XmlSuite.ParallelMode mode, final int threadCount) {
+                                                                        final XmlSuite.ParallelMode mode, final int threadCount) {
         final AllureResults results = runTestNgSuites(
                 parallel(mode, threadCount),
                 "suites/gh-219.xml"
@@ -1045,7 +1109,6 @@ public void shouldAddCorrectBeforeMethodFixturesInCaseOfParallelRun(
                             "beforeMethod2"
                     );
 
-
             assertThat(firstAfter)
                     .extracting(FixtureResult::getName)
                     .contains(
@@ -1149,7 +1212,8 @@ public void shouldProcessArrayParameters() {
     @SuppressWarnings("unchecked")
     @AllureFeatures.Fixtures
     @Issue("304")
-    @Test(dataProvider = "parallelConfiguration")
+    @ParameterizedTest
+    @MethodSource("parallelConfiguration")
     public void shouldProcessFailedSetUps(final XmlSuite.ParallelMode mode, final int threadCount) {
         final AllureResults results = runTestNgSuites(parallel(mode, threadCount), "suites/gh-304.xml");
 
@@ -1204,16 +1268,17 @@ public void shouldSupportFactoryOnConstructor() {
                 );
     }
 
-    @DataProvider(name = "failedFixtures")
-    public Object[][] failedFixtures() {
-        return new Object[][]{
-                {"suites/failed-before-test-fixture.xml", "beforeTest"},
-                {"suites/failed-before-class-fixture.xml", "beforeClass"},
-                {"suites/failed-before-suite-fixture.xml", "beforeSuite"}
-        };
+    @SuppressWarnings("unused")
+    private static Stream<Arguments> failedFixtures() {
+        return Stream.of(
+                arguments("suites/failed-before-test-fixture.xml", "beforeTest"),
+                arguments("suites/failed-before-class-fixture.xml", "beforeClass"),
+                arguments("suites/failed-before-suite-fixture.xml", "beforeSuite")
+        );
     }
 
-    @Test(dataProvider = "failedFixtures")
+    @ParameterizedTest
+    @MethodSource("failedFixtures")
     @AllureFeatures.Fixtures
     public void shouldAddBeforeFixtureToFakeTestResult(final String suite, final String fixture) {
         final AllureResults results = runTestNgSuites(suite);
@@ -1275,9 +1340,11 @@ private AllureResults runTestNgSuites(final Consumer<TestNG> configurer,
                 .hasSameSizeAs(suiteFiles);
 
         return RunUtils.runTests(lifecycle -> {
-            final AllureTestNg adapter = new AllureTestNg(lifecycle,
+            final AllureTestNg adapter = new AllureTestNg(
+                    lifecycle,
                     new AllureTestNgTestFilter(),
-                    config);
+                    config
+            );
             final TestNG testNg = new TestNG(false);
             testNg.addListener(adapter);
             testNg.setTestSuites(suiteFiles);
@@ -1319,13 +1386,13 @@ private Predicate<TestResult> hasLinks() {
     @Step("Find flaky")
     private Predicate<TestResult> flakyPredicate() {
         return testResult -> Objects.nonNull(testResult.getStatusDetails())
-                             && testResult.getStatusDetails().isFlaky();
+                && testResult.getStatusDetails().isFlaky();
     }
 
     @Step("Find muted")
     private Predicate<TestResult> mutedPredicate() {
         return testResult -> Objects.nonNull(testResult.getStatusDetails())
-                             && testResult.getStatusDetails().isMuted();
+                && testResult.getStatusDetails().isMuted();
     }
 
     @Step("Get uuids by container name")
@@ -1346,9 +1413,10 @@ private static void assertContainersChildren(String name, List<TestResultContain
     @Step("Check containers per method")
     private static void assertContainersPerMethod(String name, List<TestResultContainer> containersList,
                                                   List<String> uids) {
-        final Condition<List<? extends TestResultContainer>> singlyMapped = new Condition<>(containers ->
-                containers.stream().allMatch(c -> c.getChildren().size() == 1),
-                format("All containers for per-method fixture %s should be linked to only one testng result", name));
+        final Condition<List<? extends TestResultContainer>> singlyMapped = new Condition<>(
+                containers -> containers.stream().allMatch(c -> c.getChildren().size() == 1),
+                format("All containers for per-method fixture %s should be linked to only one testng result", name)
+        );
 
         assertThat(containersList)
                 .filteredOn("name", name)
@@ -1432,7 +1500,6 @@ private static void checkTestJavadocDescriptions(List<TestResult> results, Strin
             .setId("6")
             .setSelector("allure.junit4.samples.TestsWithIdForFilter.test3");
 
-
     @Test
     @AllureFeatures.Filtration
     public void simpleFiltration() {
@@ -1522,7 +1589,8 @@ public AllureResults runTestPlan(final TestPlan plan, final Class<?>... testClas
     }
 
     @AllureFeatures.Fixtures
-    @Test(description = "Should process data provider in setup")
+    @Test
+    @DisplayName("Should process data provider in setup")
     public void shouldProcessDataProviderInSetup() {
         final AllureResults results = runTestNgSuites("suites/data-provider-with-attachment.xml");
 
@@ -1541,7 +1609,8 @@ public void shouldProcessDataProviderInSetup() {
     }
 
     @AllureFeatures.Fixtures
-    @Test(description = "Should process failed data provider in setup")
+    @Test
+    @DisplayName("Should process failed data provider in setup")
     public void shouldProcessFailedDataProviderInSetup() {
         final AllureResults results = runTestNgSuites("suites/failed-data-provider.xml");
 
@@ -1552,7 +1621,8 @@ public void shouldProcessFailedDataProviderInSetup() {
     }
 
     @AllureFeatures.Fixtures
-    @Test(description = "Should process flaky data provider in setup")
+    @Test
+    @DisplayName("Should process flaky data provider in setup")
     public void shouldProcessFlakyDataProvider() {
         final AllureResults results = runTestNgSuites("suites/flaky-data-provider.xml");
 
@@ -1566,7 +1636,8 @@ public void shouldProcessFlakyDataProvider() {
     }
 
     @AllureFeatures.Fixtures
-    @Test(description = "Should properly link data provider container to test result")
+    @Test
+    @DisplayName("Should properly link data provider container to test result")
     public void shouldProperlyLinkDataProviderContainerToTestResult() {
         final AllureResults results = runTestNgSuites("suites/data-provider-with-attachment.xml");
 
@@ -1581,7 +1652,8 @@ public void shouldProperlyLinkDataProviderContainerToTestResult() {
     }
 
     @AllureFeatures.Fixtures
-    @Test(description = "Should link multiple tests to data provider container")
+    @Test
+    @DisplayName("Should link multiple tests to data provider container")
     public void shouldLinkMultipleTestsToDataProviderContainer() {
         final AllureResults results = runTestNgSuites("suites/data-provider-multiple-tests.xml");
 
@@ -1605,7 +1677,8 @@ public void shouldLinkMultipleTestsToDataProviderContainer() {
     }
 
     @AllureFeatures.Fixtures
-    @Test(description = "Should link inherited data provider")
+    @Test
+    @DisplayName("Should link inherited data provider")
     public void shouldLinkInheritedDataProvider() {
         final AllureResults results = runTestNgSuites("suites/data-provider-inheritance.xml");
 
@@ -1620,7 +1693,8 @@ public void shouldLinkInheritedDataProvider() {
     }
 
     @AllureFeatures.Fixtures
-    @Test(description = "Should link correct data provider in multiple classes")
+    @Test
+    @DisplayName("Should link correct data provider in multiple classes")
     public void shouldLinkCorrectDataProviderInMultipleClasses() {
         final AllureResults results = runTestNgSuites("suites/data-provider-multiple-classes.xml");
 
@@ -1639,7 +1713,8 @@ public void shouldLinkCorrectDataProviderInMultipleClasses() {
     }
 
     @AllureFeatures.Fixtures
-    @Test(description = "Should process parallel data provider")
+    @Test
+    @DisplayName("Should process parallel data provider")
     public void shouldProcessParallelDataProvider() {
         final AllureResults results = runTestNgSuites("suites/data-provider-parallel.xml");
 
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/AfterFixturesCombination.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/AfterFixturesCombination.java
index e91a9f75..35f791a8 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/AfterFixturesCombination.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/AfterFixturesCombination.java
@@ -20,12 +20,8 @@
 import org.testng.annotations.AfterSuite;
 import org.testng.annotations.AfterTest;
 import org.testng.annotations.Test;
-
-/**
- * @author Egor Borisov ehborisov@gmail.com
- */
 public class AfterFixturesCombination {
-    
+
     @AfterSuite
     public void afterSuiteTwo() {
         afterSuiteTwoStep();
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/AllFeatures.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/AllFeatures.java
index aca5ade9..ac7d26ef 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/AllFeatures.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/AllFeatures.java
@@ -33,10 +33,6 @@
 import java.io.IOException;
 import java.nio.file.Files;
 import java.util.Arrays;
-
-/**
- * @author ehborisov
- */
 public class AllFeatures {
 
     @BeforeSuite
@@ -176,7 +172,10 @@ public byte[] addImgAttachment() throws IOException {
         return Files.readAllBytes(img.toPath());
     }
 
-    @Attachment(value = "String attachment", type = "text/plain")
+    @Attachment(
+            value = "String attachment",
+            type = "text/plain"
+    )
     public String addStringAttachment() {
         return Arrays.toString(new Throwable().getStackTrace());
     }
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/AttachmentsTest.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/AttachmentsTest.java
index c5ba6144..c41c9da4 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/AttachmentsTest.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/AttachmentsTest.java
@@ -18,10 +18,6 @@
 import io.qameta.allure.Allure;
 import org.testng.Assert;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class AttachmentsTest {
 
     @Test
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/BaseTest.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/BaseTest.java
index 6077f864..9d0934cd 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/BaseTest.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/BaseTest.java
@@ -16,10 +16,6 @@
 package io.qameta.allure.testng.samples;
 
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public abstract class BaseTest {
 
     @Test
@@ -27,7 +23,6 @@ public void baseTest() throws Exception {
         check();
     }
 
-
     abstract void check();
 
 }
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/BaseTestA.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/BaseTestA.java
index a4473eb2..c897a34c 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/BaseTestA.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/BaseTestA.java
@@ -14,10 +14,6 @@
  *  limitations under the License.
  */
 package io.qameta.allure.testng.samples;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class BaseTestA extends BaseTest {
 
     @Override
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/BaseTestB.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/BaseTestB.java
index 5860f987..10470082 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/BaseTestB.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/BaseTestB.java
@@ -14,10 +14,6 @@
  *  limitations under the License.
  */
 package io.qameta.allure.testng.samples;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class BaseTestB extends BaseTest {
 
     @Override
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/BddAnnotationsTests.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/BddAnnotationsTests.java
index 2a735c01..4a9340d7 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/BddAnnotationsTests.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/BddAnnotationsTests.java
@@ -19,10 +19,6 @@
 import io.qameta.allure.Feature;
 import io.qameta.allure.Story;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @Epic("class-epic1")
 @Epic("class-epic2")
 @Feature("class-feature1")
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/BddAnnotationsTestsInherited.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/BddAnnotationsTestsInherited.java
index 018ea651..85700e7c 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/BddAnnotationsTestsInherited.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/BddAnnotationsTestsInherited.java
@@ -18,10 +18,6 @@
 import io.qameta.allure.Epic;
 import io.qameta.allure.Story;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @Story("story-inherited")
 public class BddAnnotationsTestsInherited extends BddAnnotationsTests {
 
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/BeforeFixturesCombination.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/BeforeFixturesCombination.java
index 6c401adf..ad84489d 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/BeforeFixturesCombination.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/BeforeFixturesCombination.java
@@ -20,10 +20,6 @@
 import org.testng.annotations.BeforeSuite;
 import org.testng.annotations.BeforeTest;
 import org.testng.annotations.Test;
-
-/**
- * @author Egor Borisov ehborisov@gmail.com
- */
 public class BeforeFixturesCombination {
 
     @BeforeSuite
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/BeforeMethods.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/BeforeMethods.java
index c21281fb..6c0cc15c 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/BeforeMethods.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/BeforeMethods.java
@@ -23,10 +23,6 @@
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.BeforeTest;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class BeforeMethods {
 
     @BeforeTest
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/ClassFixtures1.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/ClassFixtures1.java
index c81c1a8c..1de39c7a 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/ClassFixtures1.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/ClassFixtures1.java
@@ -18,10 +18,6 @@
 import org.testng.annotations.AfterClass;
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class ClassFixtures1 {
 
     @BeforeClass
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/ClassFixtures2.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/ClassFixtures2.java
index 64814ad5..49573b73 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/ClassFixtures2.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/ClassFixtures2.java
@@ -18,10 +18,6 @@
 import org.testng.annotations.AfterClass;
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class ClassFixtures2 {
 
     @BeforeClass
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/ClassFixtures3.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/ClassFixtures3.java
index f35a2f7a..7d1a3e2a 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/ClassFixtures3.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/ClassFixtures3.java
@@ -18,10 +18,6 @@
 import org.testng.annotations.AfterClass;
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class ClassFixtures3 {
 
     @BeforeClass
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/ClassFixturesInParent.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/ClassFixturesInParent.java
index 796f6aef..89cf6e36 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/ClassFixturesInParent.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/ClassFixturesInParent.java
@@ -16,10 +16,6 @@
 package io.qameta.allure.testng.samples;
 
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class ClassFixturesInParent extends ClassFixturesInherited {
 
     @Test
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/ClassFixturesInherited.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/ClassFixturesInherited.java
index 4169ee45..5f6b58ab 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/ClassFixturesInherited.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/ClassFixturesInherited.java
@@ -16,10 +16,6 @@
 package io.qameta.allure.testng.samples;
 
 import org.testng.annotations.BeforeClass;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class ClassFixturesInherited {
 
     @BeforeClass
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/ConfigurationFailure.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/ConfigurationFailure.java
index 09c23068..84084d78 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/ConfigurationFailure.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/ConfigurationFailure.java
@@ -17,10 +17,6 @@
 
 import org.testng.annotations.BeforeTest;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class ConfigurationFailure {
 
     @BeforeTest(description = "failed configuration")
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/CyrillicDescriptions.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/CyrillicDescriptions.java
index c9963b52..c2ffcb2a 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/CyrillicDescriptions.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/CyrillicDescriptions.java
@@ -16,10 +16,6 @@
 package io.qameta.allure.testng.samples;
 
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class CyrillicDescriptions {
 
     @Test(description = "Тест с описанием на русском языке")
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/DataProviderWithArray.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/DataProviderWithArray.java
index ec7d93c5..bc504892 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/DataProviderWithArray.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/DataProviderWithArray.java
@@ -17,10 +17,6 @@
 
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class DataProviderWithArray {
 
     @DataProvider(name = "someProvider")
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/DataProviderWithAttachment.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/DataProviderWithAttachment.java
index 20b5a7f6..a7ed8b72 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/DataProviderWithAttachment.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/DataProviderWithAttachment.java
@@ -25,7 +25,7 @@ public class DataProviderWithAttachment {
     public Object[][] dataProvider() {
         Allure.addAttachment("attachment", "attachment content");
         return new Object[][]{
-            {"a"}
+                {"a"}
         };
     }
 
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/DescriptionsAnotherTest.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/DescriptionsAnotherTest.java
index 9e94688e..7ca7e7f6 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/DescriptionsAnotherTest.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/DescriptionsAnotherTest.java
@@ -20,10 +20,6 @@
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
-
-/**
- * @author Sergey Potanin sspotanin@gmail.com
- */
 public class DescriptionsAnotherTest {
 
     /**
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/DescriptionsTest.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/DescriptionsTest.java
index b128d90e..f7aef642 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/DescriptionsTest.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/DescriptionsTest.java
@@ -20,10 +20,6 @@
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
-
-/**
- * @author Egor Borisov ehborisov@gmail.com
- */
 public class DescriptionsTest {
 
     /**
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/DisabledTest.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/DisabledTest.java
index 82e4c9d7..648ef155 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/DisabledTest.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/DisabledTest.java
@@ -16,10 +16,6 @@
 package io.qameta.allure.testng.samples;
 
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class DisabledTest {
 
     @Test(enabled = false)
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FactoryOnConstructorTests.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FactoryOnConstructorTests.java
index 351ac595..4cd2bd45 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FactoryOnConstructorTests.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FactoryOnConstructorTests.java
@@ -19,10 +19,6 @@
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Factory;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class FactoryOnConstructorTests {
 
     @TestInstanceParameter
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedAfterMethod.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedAfterMethod.java
index fd5d8be6..13bc30a0 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedAfterMethod.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedAfterMethod.java
@@ -17,10 +17,6 @@
 
 import org.testng.annotations.AfterMethod;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class FailedAfterMethod {
 
     @AfterMethod
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedAfterSuite.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedAfterSuite.java
index 9af5a2f8..9b44b566 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedAfterSuite.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedAfterSuite.java
@@ -17,10 +17,6 @@
 
 import org.testng.annotations.AfterSuite;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class FailedAfterSuite {
 
     @AfterSuite
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedAfterTest.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedAfterTest.java
index 4685a119..39bd9b75 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedAfterTest.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedAfterTest.java
@@ -17,10 +17,6 @@
 
 import org.testng.annotations.AfterTest;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class FailedAfterTest {
 
     @AfterTest
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedBeforeClass.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedBeforeClass.java
index b3a8fcb3..cc29dabe 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedBeforeClass.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedBeforeClass.java
@@ -19,10 +19,6 @@
 import org.testng.annotations.Test;
 
 import static io.qameta.allure.Allure.step;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class FailedBeforeClass {
 
     @BeforeClass
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedBeforeMethod.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedBeforeMethod.java
index c87c920b..f83ebf02 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedBeforeMethod.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedBeforeMethod.java
@@ -19,10 +19,6 @@
 import org.testng.annotations.Test;
 
 import static io.qameta.allure.Allure.step;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class FailedBeforeMethod {
 
     @BeforeMethod
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedBeforeSuite.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedBeforeSuite.java
index feeece1f..dffd1f67 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedBeforeSuite.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedBeforeSuite.java
@@ -19,10 +19,6 @@
 import org.testng.annotations.Test;
 
 import static io.qameta.allure.Allure.step;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class FailedBeforeSuite {
 
     @BeforeSuite
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedBeforeTest.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedBeforeTest.java
index 0283bab6..31c1ef7f 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedBeforeTest.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedBeforeTest.java
@@ -19,10 +19,6 @@
 import org.testng.annotations.Test;
 
 import static io.qameta.allure.Allure.step;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class FailedBeforeTest {
 
     @BeforeTest
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedFlakyTest.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedFlakyTest.java
index 78873fee..d2181f5c 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedFlakyTest.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedFlakyTest.java
@@ -19,10 +19,6 @@
 import org.testng.annotations.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class FailedFlakyTest {
 
     @Test
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedSetUp.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedSetUp.java
index be6efc8d..910353f0 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedSetUp.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedSetUp.java
@@ -20,10 +20,6 @@
 import org.testng.annotations.Test;
 
 import static io.qameta.allure.Allure.step;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class FailedSetUp {
 
     @BeforeMethod
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedTestPassedBeforeFixture.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedTestPassedBeforeFixture.java
index f839d9c7..d6dca680 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedTestPassedBeforeFixture.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FailedTestPassedBeforeFixture.java
@@ -17,10 +17,6 @@
 
 import org.testng.annotations.BeforeTest;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class FailedTestPassedBeforeFixture {
 
     @BeforeTest
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FixtureWithDescription.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FixtureWithDescription.java
index 8be7f6d7..d9d65715 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FixtureWithDescription.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FixtureWithDescription.java
@@ -17,10 +17,6 @@
 
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class FixtureWithDescription {
 
     @BeforeMethod(description = "Set up method with description")
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FlakyMethods.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FlakyMethods.java
index 25b9cafa..84faaaf0 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FlakyMethods.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FlakyMethods.java
@@ -17,10 +17,6 @@
 
 import io.qameta.allure.Flaky;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class FlakyMethods {
 
     @Test
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FlakyMethodsInherited.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FlakyMethodsInherited.java
index 96d09bb5..855b5637 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FlakyMethodsInherited.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FlakyMethodsInherited.java
@@ -14,10 +14,6 @@
  *  limitations under the License.
  */
 package io.qameta.allure.testng.samples;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class FlakyMethodsInherited extends FlakyMethods {
 
     @Override
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FlakyTestClass.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FlakyTestClass.java
index a952d709..21d53c98 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FlakyTestClass.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FlakyTestClass.java
@@ -17,10 +17,6 @@
 
 import io.qameta.allure.Flaky;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @Flaky
 public class FlakyTestClass {
 
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FlakyTestClassInherited.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FlakyTestClassInherited.java
index 3dd8fc66..3392f6e6 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/FlakyTestClassInherited.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/FlakyTestClassInherited.java
@@ -16,10 +16,6 @@
 package io.qameta.allure.testng.samples;
 
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class FlakyTestClassInherited extends FlakyTestClass {
 
     @Override
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/HistoryIdForTestWithDataProvider.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/HistoryIdForTestWithDataProvider.java
index 539ef6c0..19d79206 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/HistoryIdForTestWithDataProvider.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/HistoryIdForTestWithDataProvider.java
@@ -17,10 +17,6 @@
 
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class HistoryIdForTestWithDataProvider {
 
     @DataProvider(name = "getData")
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/JustTest.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/JustTest.java
index e9c93fe8..4bd85c84 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/JustTest.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/JustTest.java
@@ -16,10 +16,6 @@
 package io.qameta.allure.testng.samples;
 
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class JustTest {
 
     @Test
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/LinksOnTests.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/LinksOnTests.java
index fdaf6a4c..b9049ea4 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/LinksOnTests.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/LinksOnTests.java
@@ -22,10 +22,6 @@
 import io.qameta.allure.TmsLink;
 import io.qameta.allure.TmsLinks;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @Link("testClass")
 @Issue("testClassIssue")
 @TmsLink("testClassTmsLink")
@@ -40,21 +36,27 @@ public void shouldHasLinks() throws Exception {
     }
 
     @Test
-    @Links({
-            @Link("nested1"),
-            @Link("nested2"),
-    })
+    @Links(
+        {
+                @Link("nested1"),
+                @Link("nested2"),
+        }
+    )
     @Link("nested3")
     @Issue("issue1")
-    @Issues({
-            @Issue("issue2"),
-            @Issue("issue3")
-    })
+    @Issues(
+        {
+                @Issue("issue2"),
+                @Issue("issue3")
+        }
+    )
     @TmsLink("tms1")
-    @TmsLinks({
-            @TmsLink("tms2"),
-            @TmsLink("tms3")
-    })
+    @TmsLinks(
+        {
+                @TmsLink("tms2"),
+                @TmsLink("tms3")
+        }
+    )
     public void shouldHasLinksAsWell() throws Exception {
 
     }
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/LinksOnTestsInherited.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/LinksOnTestsInherited.java
index cc178f59..2acef182 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/LinksOnTestsInherited.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/LinksOnTestsInherited.java
@@ -19,10 +19,6 @@
 import io.qameta.allure.Link;
 import io.qameta.allure.TmsLink;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class LinksOnTestsInherited extends LinksOnTests {
 
     @Override
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/MutedMethods.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/MutedMethods.java
index 186258ca..0e4b0a1d 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/MutedMethods.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/MutedMethods.java
@@ -17,10 +17,6 @@
 
 import io.qameta.allure.Muted;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class MutedMethods {
 
     @Test
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/MutedMethodsInherited.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/MutedMethodsInherited.java
index 13a75d7e..d40a3555 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/MutedMethodsInherited.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/MutedMethodsInherited.java
@@ -14,10 +14,6 @@
  *  limitations under the License.
  */
 package io.qameta.allure.testng.samples;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class MutedMethodsInherited extends MutedMethods {
 
     @Override
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/MutedTestClass.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/MutedTestClass.java
index 3c346d1c..5c963d5c 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/MutedTestClass.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/MutedTestClass.java
@@ -17,10 +17,6 @@
 
 import io.qameta.allure.Muted;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @Muted
 public class MutedTestClass {
 
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/MutedTestClassInherited.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/MutedTestClassInherited.java
index bbfcd4f5..cd101aed 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/MutedTestClassInherited.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/MutedTestClassInherited.java
@@ -16,10 +16,6 @@
 package io.qameta.allure.testng.samples;
 
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class MutedTestClassInherited extends MutedTestClass {
 
     @Override
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/NestedSteps.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/NestedSteps.java
index ad5c9b91..0a2f9b36 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/NestedSteps.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/NestedSteps.java
@@ -20,10 +20,6 @@
 import org.testng.annotations.Test;
 
 import static io.qameta.allure.Allure.step;
-
-/**
- * @author Egor Borisov ehborisov@gmail.com
- */
 public class NestedSteps {
 
     @BeforeSuite
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/NullParamTest.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/NullParamTest.java
index 8ac309d8..4335b46c 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/NullParamTest.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/NullParamTest.java
@@ -17,10 +17,6 @@
 
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class NullParamTest {
 
     @DataProvider(name = "someProvider")
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/OwnerClassTest.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/OwnerClassTest.java
index c0931922..3c5cce42 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/OwnerClassTest.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/OwnerClassTest.java
@@ -17,10 +17,6 @@
 
 import io.qameta.allure.Owner;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @Owner("eroshenkoam")
 public class OwnerClassTest {
 
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/OwnerClassTestInherited.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/OwnerClassTestInherited.java
index fddffe74..778760dd 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/OwnerClassTestInherited.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/OwnerClassTestInherited.java
@@ -14,10 +14,6 @@
  *  limitations under the License.
  */
 package io.qameta.allure.testng.samples;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class OwnerClassTestInherited extends OwnerClassTest {
 
     @Override
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/OwnerMethodTest.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/OwnerMethodTest.java
index 5858262f..3366c1c6 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/OwnerMethodTest.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/OwnerMethodTest.java
@@ -17,10 +17,6 @@
 
 import io.qameta.allure.Owner;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class OwnerMethodTest {
 
     @Test
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/OwnerMethodTestInherited.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/OwnerMethodTestInherited.java
index f8d940b4..81d2167f 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/OwnerMethodTestInherited.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/OwnerMethodTestInherited.java
@@ -14,10 +14,6 @@
  *  limitations under the License.
  */
 package io.qameta.allure.testng.samples;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class OwnerMethodTestInherited extends OwnerMethodTest {
 
     @Override
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/ParallelDataProviderSample.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/ParallelDataProviderSample.java
index 30b5dd41..bd9a6465 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/ParallelDataProviderSample.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/ParallelDataProviderSample.java
@@ -28,17 +28,21 @@
  */
 public class ParallelDataProviderSample {
 
-  @DataProvider(parallel = true)
-  Iterator<Integer[]> provide() {
-    List<Integer[]> ret = new ArrayList<>();
-    for (int i = 0; i < 1000; i++) {
-      ret.add(new Integer[]{i});
+    @DataProvider(parallel = true)
+    Iterator<Integer[]> provide() {
+        List<Integer[]> ret = new ArrayList<>();
+        for (int i = 0; i < 1000; i++) {
+            ret.add(new Integer[]{i});
+        }
+        return ret.iterator();
     }
-    return ret.iterator();
-  }
 
-  @Test(dataProvider = "provide", invocationCount = 2, threadPoolSize = 2)
-  public void checkCME(Integer i) {
-    Assert.assertNotNull(i);
-  }
+    @Test(
+            dataProvider = "provide",
+            invocationCount = 2,
+            threadPoolSize = 2
+    )
+    public void checkCME(Integer i) {
+        Assert.assertNotNull(i);
+    }
 }
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/ParallelMethods.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/ParallelMethods.java
index 82180ccb..282d2dab 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/ParallelMethods.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/ParallelMethods.java
@@ -27,13 +27,8 @@
 
 import java.io.IOException;
 import java.util.stream.IntStream;
-
-/**
- * @author ehborisov
- */
 public class ParallelMethods {
 
-
     @BeforeSuite
     public void beforeSuite() {
         stepOne();
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/ParameterizedTest.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/ParameterizedTest.java
index 4f2da5bf..500a5999 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/ParameterizedTest.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/ParameterizedTest.java
@@ -19,10 +19,6 @@
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
-
-/**
- * @author Egor Borisov ehborisov@gmail.com
- */
 public class ParameterizedTest {
 
     @BeforeMethod
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/PerMethodFixtures.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/PerMethodFixtures.java
index 85920905..c42e4b77 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/PerMethodFixtures.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/PerMethodFixtures.java
@@ -19,10 +19,6 @@
 import org.testng.annotations.AfterMethod;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
-
-/**
- * @author Egor Borisov ehborisov@gmail.com
- */
 public class PerMethodFixtures {
 
     @BeforeMethod
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/PerSuiteFixtures.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/PerSuiteFixtures.java
index 050655a4..7695e9a5 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/PerSuiteFixtures.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/PerSuiteFixtures.java
@@ -19,10 +19,6 @@
 import org.testng.annotations.AfterSuite;
 import org.testng.annotations.BeforeSuite;
 import org.testng.annotations.Test;
-
-/**
- * @author Egor Borisov ehborisov@gmail.com
- */
 public class PerSuiteFixtures {
 
     @BeforeSuite
@@ -51,7 +47,7 @@ public void afterSuite2() {
     }
 
     @Step
-    public void step(){
+    public void step() {
 
     }
 }
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/PerTestFixtures.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/PerTestFixtures.java
index 44ace6ce..f5808ecd 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/PerTestFixtures.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/PerTestFixtures.java
@@ -19,10 +19,6 @@
 import org.testng.annotations.AfterTest;
 import org.testng.annotations.BeforeTest;
 import org.testng.annotations.Test;
-
-/**
- * @author Egor Borisov ehborisov@gmail.com
- */
 public class PerTestFixtures {
 
     @BeforeTest
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/PriorityTests.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/PriorityTests.java
index cc6e6d87..8e4cbc65 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/PriorityTests.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/PriorityTests.java
@@ -36,7 +36,10 @@ public static Object[][] someProvider() {
         };
     }
 
-    @Test(dataProvider = "someProvider", priority = 4)
+    @Test(
+            dataProvider = "someProvider",
+            priority = 4
+    )
     public void vTest(int parameter) {
         parameter(ORDER_PARAMETER, cnt.incrementAndGet());
     }
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/RetryTest.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/RetryTest.java
index 49fb59ab..ea3d5773 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/RetryTest.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/RetryTest.java
@@ -18,10 +18,6 @@
 import org.testng.ITestResult;
 import org.testng.annotations.Test;
 import org.testng.util.RetryAnalyzerCount;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class RetryTest {
 
     @Test(retryAnalyzer = Retry.class)
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/SeverityClassTest.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/SeverityClassTest.java
index fb778713..0cda6a14 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/SeverityClassTest.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/SeverityClassTest.java
@@ -18,10 +18,6 @@
 import io.qameta.allure.Severity;
 import io.qameta.allure.SeverityLevel;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 @Severity(SeverityLevel.MINOR)
 public class SeverityClassTest {
 
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/SeverityClassTestInherited.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/SeverityClassTestInherited.java
index 8a7d0bce..ec1102ba 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/SeverityClassTestInherited.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/SeverityClassTestInherited.java
@@ -17,10 +17,6 @@
 
 import io.qameta.allure.Severity;
 import io.qameta.allure.SeverityLevel;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class SeverityClassTestInherited extends SeverityClassTest {
 
     @Override
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/SeverityMethodTest.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/SeverityMethodTest.java
index 56aab448..2ccb5937 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/SeverityMethodTest.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/SeverityMethodTest.java
@@ -18,10 +18,6 @@
 import io.qameta.allure.Severity;
 import io.qameta.allure.SeverityLevel;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class SeverityMethodTest {
 
     @Test
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/SeverityMethodTestInherited.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/SeverityMethodTestInherited.java
index d3710b2c..481f9214 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/SeverityMethodTestInherited.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/SeverityMethodTestInherited.java
@@ -14,10 +14,6 @@
  *  limitations under the License.
  */
 package io.qameta.allure.testng.samples;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class SeverityMethodTestInherited extends SeverityMethodTest {
 
     @Override
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/SkippedSuite.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/SkippedSuite.java
index 1532c3b9..48264aee 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/SkippedSuite.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/SkippedSuite.java
@@ -20,10 +20,6 @@
 import org.testng.annotations.Test;
 
 import static io.qameta.allure.Allure.step;
-
-/**
- * @author Egor Borisov ehborisov@gmail.com
- */
 public class SkippedSuite {
 
     @BeforeSuite
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/SuiteParameterTest.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/SuiteParameterTest.java
index bcc6c72c..e7c113e0 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/SuiteParameterTest.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/SuiteParameterTest.java
@@ -15,9 +15,6 @@
  */
 package io.qameta.allure.testng.samples;
 
-/*
-  @author Andrejs Kalnacs akalnacs@evolutiongaming.com
- */
 import org.testng.ITestContext;
 import org.testng.annotations.BeforeSuite;
 import org.testng.annotations.Parameters;
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/TagClassTest.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/TagClassTest.java
index bc7ff60b..85eccf23 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/TagClassTest.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/TagClassTest.java
@@ -18,10 +18,6 @@
 import io.qameta.allure.testng.Tag;
 import io.qameta.allure.testng.Tags;
 import org.testng.annotations.Test;
-
-/**
- * @author neparij (Nikolay Laptev).
- */
 @Tag("class-tag")
 public class TagClassTest {
 
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/TagMethodTest.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/TagMethodTest.java
index 50428951..861b8473 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/TagMethodTest.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/TagMethodTest.java
@@ -18,10 +18,6 @@
 import io.qameta.allure.testng.Tag;
 import io.qameta.allure.testng.Tags;
 import org.testng.annotations.Test;
-
-/**
- * @author neparij (Nikolay Laptev).
- */
 public class TagMethodTest {
 
     @Test
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/TestTagFixtures.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/TestTagFixtures.java
index ab8f49b1..62fab6d8 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/TestTagFixtures.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/TestTagFixtures.java
@@ -19,10 +19,6 @@
 import org.testng.annotations.AfterTest;
 import org.testng.annotations.BeforeTest;
 import org.testng.annotations.Test;
-
-/**
- * @author Egor Borisov ehborisov@gmail.com
- */
 public class TestTagFixtures {
 
     @BeforeTest
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/TestWithParameters.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/TestWithParameters.java
index 5c633114..95ec24ef 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/TestWithParameters.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/TestWithParameters.java
@@ -20,10 +20,6 @@
 import org.testng.annotations.Test;
 
 import java.lang.reflect.Method;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class TestWithParameters {
 
     @Parameters({"first", "second"})
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/TestsWithIdForFilter.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/TestsWithIdForFilter.java
index 76426778..ee4c2598 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/TestsWithIdForFilter.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/TestsWithIdForFilter.java
@@ -16,9 +16,10 @@
 package io.qameta.allure.testng.samples;
 
 import io.qameta.allure.AllureId;
-import static org.assertj.core.api.Assertions.assertThat;
 import org.testng.annotations.Test;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 public class TestsWithIdForFilter {
 
     @Test
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/TestsWithSteps.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/TestsWithSteps.java
index 9f0b1a80..f1d325f8 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/TestsWithSteps.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/TestsWithSteps.java
@@ -20,10 +20,6 @@
 
 import static io.qameta.allure.Allure.step;
 import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * @author Egor Borisov ehborisov@gmail.com
- */
 public class TestsWithSteps {
 
     @Test
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/VarargsParameters.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/VarargsParameters.java
index 8a4ede2a..5ce35013 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/samples/VarargsParameters.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/VarargsParameters.java
@@ -17,10 +17,6 @@
 
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
-
-/**
- * @author charlie (Dmitry Baev).
- */
 public class VarargsParameters {
 
     @DataProvider
diff --git a/allure-testng/src/test/resources/allure.properties b/allure-testng/src/test/resources/allure.properties
index e4f1d9fc..69cd85a7 100644
--- a/allure-testng/src/test/resources/allure.properties
+++ b/allure-testng/src/test/resources/allure.properties
@@ -1,3 +1,4 @@
 allure.results.directory=build/allure-results
 allure.link.issue.pattern=https://github.com/allure-framework/allure-java/issues/{}
 allure.label.epic=#project.description#
+allure.label.module=allure-testng
diff --git a/allurerc.mjs b/allurerc.mjs
new file mode 100644
index 00000000..cb900270
--- /dev/null
+++ b/allurerc.mjs
@@ -0,0 +1,21 @@
+const { ALLURE_SERVICE_TOKEN } = process.env;
+
+const allureService = ALLURE_SERVICE_TOKEN
+    ? {
+        accessToken: ALLURE_SERVICE_TOKEN,
+    }
+    : undefined;
+
+export default {
+    name: "Allure Java",
+    output: "./build/allure-report",
+    plugins: {
+        awesome: {
+            options: {
+                groupBy: ["module", "parentSuite", "suite", "subSuite"],
+                publish: true,
+            },
+        },
+    },
+    ...(allureService ? { allureService } : {}),
+};
diff --git a/build.gradle.kts b/build.gradle.kts
index b3a82e14..89433e24 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -5,9 +5,10 @@ val qualityConfigsDir by extra("$gradleScriptDir/quality-configs")
 val spotlessDtr by extra("$qualityConfigsDir/spotless")
 
 val libs = subprojects.filterNot { it.name in "allure-bom" }
+val standardJavaLibs = libs.filterNot { it.name == "allure-scalatest" }
 
 tasks.withType(Wrapper::class) {
-    gradleVersion = "8.5"
+    gradleVersion = "8.11"
 }
 
 plugins {
@@ -20,8 +21,7 @@ plugins {
     id("com.github.spotbugs")
     id("com.diffplug.spotless")
     id("io.github.gradle-nexus.publish-plugin")
-    id("io.qameta.allure-adapter") apply false
-    id("io.qameta.allure-report")
+    id("io.qameta.allure")
     id("io.spring.dependency-management")
 }
 
@@ -60,6 +60,12 @@ configure(subprojects) {
     publishing {
         publications {
             withType<MavenPublication>().configureEach {
+                suppressAllPomMetadataWarnings()
+                versionMapping {
+                    allVariants {
+                        fromResolutionResult()
+                    }
+                }
                 pom {
                     name.set(project.name)
                     description.set("Module ${project.name} of Allure Framework.")
@@ -103,19 +109,12 @@ configure(subprojects) {
                     }
                 }
             }
-            create<MavenPublication>("maven") {
-                suppressAllPomMetadataWarnings()
-                versionMapping {
-                    allVariants {
-                        fromResolutionResult()
-                    }
-                }
-            }
+            create<MavenPublication>("maven")
         }
     }
 
     signing {
-        sign(publishing.publications["maven"])
+        sign(publishing.publications)
     }
 
     tasks.withType<Sign>().configureEach {
@@ -138,8 +137,7 @@ configure(libs) {
     apply(plugin = "pmd")
     apply(plugin = "com.github.spotbugs")
     apply(plugin = "com.diffplug.spotless")
-    apply(plugin = "io.qameta.allure-report")
-    apply(plugin = "io.qameta.allure-adapter")
+    apply(plugin = "io.qameta.allure")
     apply(plugin = "io.spring.dependency-management")
     apply(plugin = "java")
     apply(plugin = "java-library")
@@ -258,21 +256,32 @@ configure(libs) {
 
     allure {
         adapter {
+            // Many modules carry third-party test frameworks on the classpath as integration fixtures,
+            // so never let the Gradle plugin auto-detect adapters from dependencies alone.
             autoconfigure.set(false)
             aspectjWeaver.set(true)
             aspectjVersion.set(dependencyManagement.managedVersions["org.aspectj:aspectjweaver"])
 
-            // in order to disable dependencySubstitution (spi-off classifier)
-            autoconfigureListeners.set(true)
-
-            afterEvaluate {
-                frameworks.forEach { adapter -> adapter.enabled.set(false) }
+            // Every Gradle test task in this build runs on JUnit Platform now.
+            // Avoid mentioning unused adapters here because allure-gradle adds mentioned
+            // adapters to the test classpath even when we do not execute that framework.
+            frameworks {
+                junitPlatform {
+                    enabled.set(true)
+                    autoconfigureListeners.set(true)
+                }
             }
         }
     }
 
     val enableQuality = true
-    fun excludeGeneratedSources(source: FileTree): FileTree = (source - fileTree("build/generated-sources")).asFileTree
+    fun mainJavaSources(): FileTree = fileTree("src/main/java") {
+        include("**/*.java")
+    }
+
+    fun checkstyleMainJavaSources(): FileTree = mainJavaSources().matching {
+        exclude("cucumber/runtime/formatter/**")
+    }
 
     checkstyle {
         toolVersion = dependencyManagement.managedVersions["com.puppycrawl.tools:checkstyle"]!!
@@ -300,17 +309,21 @@ configure(libs) {
         }
     }
 
-    tasks.withType(Checkstyle::class) {
-        source = excludeGeneratedSources(source)
+    tasks.checkstyleMain {
+        source = checkstyleMainJavaSources()
+        classpath = files()
         enabled = enableQuality
     }
 
-    tasks.withType(Pmd::class) {
-        source = excludeGeneratedSources(source)
+    tasks.pmdMain {
+        source = mainJavaSources()
+        classpath = files()
         enabled = enableQuality
     }
 
-    tasks.withType(SpotBugsTask::class) {
+    tasks.withType<SpotBugsTask>().configureEach {
+        auxClassPaths.from(configurations.named("runtimeClasspath"))
+        dependsOn(tasks.named("jar"))
         enabled = enableQuality
     }
 
@@ -330,7 +343,9 @@ configure(libs) {
         java {
             target("src/**/*.java")
             removeUnusedImports()
+            importOrder("", "jakarta", "javax", "java", "\\#")
             licenseHeaderFile("$spotlessDtr/header.java", "(package|import|open|module|//startfile)")
+            eclipse().configFile("$spotlessDtr/eclipse-jdt.prefs")
             endWithNewline()
             replaceRegex("one blank line after package line", "(package .+;)\n+import", "$1\n\nimport")
             replaceRegex("one blank line after import lists", "(import .+;\n\n)\n+", "$1")
@@ -338,6 +353,7 @@ configure(libs) {
         scala {
             target("src/**/*.scala")
             licenseHeaderFile("$spotlessDtr/header.java", "(package|//startfile)")
+            scalafmt("3.7.3").scalaMajorVersion("2.13").configFile("$spotlessDtr/scalafmt.conf")
             endWithNewline()
             replaceRegex("one blank line after package line", "(package .+;)\n+import", "$1\n\nimport")
             replaceRegex("one blank line after import lists", "(import .+;\n\n)\n+", "$1")
@@ -345,6 +361,7 @@ configure(libs) {
         groovy {
             target("src/**/*.groovy")
             licenseHeaderFile("$spotlessDtr/header.java", "(package|//startfile) ")
+            greclipse("4.29").configFile("$spotlessDtr/eclipse-jdt.prefs")
             endWithNewline()
             replaceRegex("one blank line after package line", "(package .+;)\n+import", "$1\n\nimport")
             replaceRegex("one blank line after import lists", "(import .+;\n\n)\n+", "$1")
@@ -375,17 +392,121 @@ configure(libs) {
         }
     }
 
+    val allDepsInsight by tasks.creating(DependencyInsightReportTask::class) {
+        showingAllVariants.set(true)
+    }
+}
+
+configure(standardJavaLibs) {
     publishing.publications.named<MavenPublication>("maven") {
-        pom {
-            from(components["java"])
-        }
+        from(components["java"])
     }
+}
 
-    val allDepsInsight by tasks.creating(DependencyInsightReportTask::class) {
-        showingAllVariants.set(true)
+val verifyJupiterCompatibilityBridge by tasks.registering {
+    dependsOn(
+        ":allure-bom:generatePomFileForMavenPublication",
+        ":allure-jupiter:generatePomFileForMavenPublication",
+        ":allure-jupiter:generatePomFileForLegacyJunit5Publication",
+        ":allure-jupiter-assert:generatePomFileForMavenPublication",
+        ":allure-jupiter-assert:generatePomFileForLegacyJunit5AssertPublication"
+    )
+
+    doLast {
+        fun publicationArtifactIds(projectPath: String): Set<String> =
+            project(projectPath)
+                .extensions
+                .getByType(org.gradle.api.publish.PublishingExtension::class.java)
+                .publications
+                .withType(MavenPublication::class.java)
+                .mapTo(linkedSetOf()) { it.artifactId }
+
+        val jupiterArtifactIds = publicationArtifactIds(":allure-jupiter")
+        check("allure-jupiter" in jupiterArtifactIds) {
+            "Expected :allure-jupiter to publish the primary allure-jupiter coordinate."
+        }
+        check("allure-junit5" in jupiterArtifactIds) {
+            "Expected :allure-jupiter to publish the legacy allure-junit5 relocation."
+        }
+
+        val jupiterAssertArtifactIds = publicationArtifactIds(":allure-jupiter-assert")
+        check("allure-jupiter-assert" in jupiterAssertArtifactIds) {
+            "Expected :allure-jupiter-assert to publish the primary allure-jupiter-assert coordinate."
+        }
+        check("allure-junit5-assert" in jupiterAssertArtifactIds) {
+            "Expected :allure-jupiter-assert to publish the legacy allure-junit5-assert relocation."
+        }
+
+        val bomPom = project(":allure-bom")
+            .layout
+            .buildDirectory
+            .file("publications/maven/pom-default.xml")
+            .get()
+            .asFile
+            .readText()
+
+        fun publicationPom(projectPath: String, publicationName: String): String =
+            project(projectPath)
+                .layout
+                .buildDirectory
+                .file("publications/$publicationName/pom-default.xml")
+                .get()
+                .asFile
+                .readText()
+
+        check("<artifactId>allure-jupiter</artifactId>" in bomPom) {
+            "Expected allure-bom to manage allure-jupiter."
+        }
+        check("<artifactId>allure-junit5</artifactId>" in bomPom) {
+            "Expected allure-bom to manage the legacy allure-junit5 relocation."
+        }
+        check("<artifactId>allure-jupiter-assert</artifactId>" in bomPom) {
+            "Expected allure-bom to manage allure-jupiter-assert."
+        }
+        check("<artifactId>allure-junit5-assert</artifactId>" in bomPom) {
+            "Expected allure-bom to manage the legacy allure-junit5-assert relocation."
+        }
+
+        val legacyJunit5Pom = publicationPom(":allure-jupiter", "legacyJunit5")
+        check("<artifactId>allure-junit5</artifactId>" in legacyJunit5Pom) {
+            "Expected the legacy allure-junit5 publication to keep the old artifact id."
+        }
+        check("<relocation>" in legacyJunit5Pom) {
+            "Expected the legacy allure-junit5 publication to be a relocation POM."
+        }
+        check("<packaging>pom</packaging>" in legacyJunit5Pom) {
+            "Expected the legacy allure-junit5 relocation to use pom packaging."
+        }
+        check("<dependencies>" !in legacyJunit5Pom) {
+            "Expected the legacy allure-junit5 relocation POM to avoid publishing dependencies."
+        }
+        check("<artifactId>allure-jupiter</artifactId>" in legacyJunit5Pom) {
+            "Expected the legacy allure-junit5 publication to relocate to allure-jupiter."
+        }
+
+        val legacyJunit5AssertPom = publicationPom(":allure-jupiter-assert", "legacyJunit5Assert")
+        check("<artifactId>allure-junit5-assert</artifactId>" in legacyJunit5AssertPom) {
+            "Expected the legacy allure-junit5-assert publication to keep the old artifact id."
+        }
+        check("<relocation>" in legacyJunit5AssertPom) {
+            "Expected the legacy allure-junit5-assert publication to be a relocation POM."
+        }
+        check("<packaging>pom</packaging>" in legacyJunit5AssertPom) {
+            "Expected the legacy allure-junit5-assert relocation to use pom packaging."
+        }
+        check("<dependencies>" !in legacyJunit5AssertPom) {
+            "Expected the legacy allure-junit5-assert relocation POM to avoid publishing dependencies."
+        }
+        check("<artifactId>allure-jupiter-assert</artifactId>" in legacyJunit5AssertPom) {
+            "Expected the legacy allure-junit5-assert publication to relocate to allure-jupiter-assert."
+        }
     }
 }
 
+tasks.check {
+    dependsOn(verifyJupiterCompatibilityBridge)
+}
+
 allure {
     version.set("2.19.0")
 }
diff --git a/docs/allure-agent-mode.md b/docs/allure-agent-mode.md
new file mode 100644
index 00000000..f9948201
--- /dev/null
+++ b/docs/allure-agent-mode.md
@@ -0,0 +1,161 @@
+# Allure Agent Mode
+
+Use Allure agent-mode to design, review, validate, debug, and enrich tests in this repository.
+
+## Project Context
+
+- This repository is a Gradle multi-project build. Use `./gradlew` for repo-local test commands.
+- Prefer the narrowest relevant scope first, usually a module task such as `:allure-jupiter:test` or a single test via `--tests`.
+- CI's broad verification entry point is `./gradlew --no-build-cache cleanTest test`.
+- Many modules already emit framework results to `<module>/build/allure-results`; agent mode adds a separate per-run review artifact layer and does not replace those module outputs.
+- If `allure run` is unavailable in the local agent environment, fix that first before treating console-only runs as authoritative.
+
+## Review Principle
+
+Runtime first, source second.
+
+- If a command executes tests and its result will be used for smoke checking, reasoning, review, coverage analysis, debugging, or any user-facing conclusion, run it through `allure run`. It preserves the original console logs and adds agent-mode artifacts when you need them.
+- If the agent-mode output is missing or incomplete, debug that first and treat console-only conclusions as provisional.
+
+## Verification Standard
+
+- Use `allure run` for smoke checks too, even when the change is small or mechanical.
+- Only skip agent mode when it is impossible or when you are debugging agent mode itself.
+
+## Core Loops
+
+### Test Review Loop
+
+1. Identify the exact review scope.
+2. Create a fresh expectations file for this run in a temp directory.
+3. Run only that scope with `allure run`.
+4. Read `index.md`, `manifest/run.json`, `manifest/tests.jsonl`, and `manifest/findings.jsonl`.
+5. Read per-test markdown only for tests that failed, drifted, or have findings.
+6. Only after runtime review, inspect source code for root cause or coverage gaps.
+7. If evidence is weak or partial, enrich the tests and rerun.
+
+### Feature Delivery Loop
+
+1. Understand the feature or issue.
+2. Create a fresh expectations file for this run in a temp directory.
+3. Write or update the tests.
+4. Run the target Gradle scope with `allure run`.
+5. Review `index.md`, manifests, and per-test markdown.
+6. Enrich tests when evidence is weak.
+7. Rerun until scope and evidence are acceptable.
+
+### Metadata Enrichment Loop
+
+Use this when the run is functionally correct but too weak to review:
+
+1. Identify missing or low-signal findings.
+2. Add real steps, attachments, or minimal metadata.
+3. Rerun the same intended scope.
+4. Reject noop-style or placeholder evidence.
+
+### Small Test Change Workflow
+
+1. Create a fresh expectations file and temp output directory for the touched scope.
+2. Run the touched scope with `allure run`, even if the goal is only a smoke check after a mechanical change such as typing cleanup, mock refactors, or helper extraction.
+3. Review `index.md`, `manifest/run.json`, `manifest/tests.jsonl`, and `manifest/findings.jsonl`.
+4. Only then make a final statement about regression safety or test correctness.
+
+### Coverage Review Workflow
+
+1. Split command, package, or module audits into scoped groups.
+2. Give each group its own expectations file and temp output directory.
+3. Run each group with `allure run`.
+4. Review runtime artifacts first, then inspect source code only after the run explains what actually executed.
+5. Mark the review incomplete until each scoped group either matched expectations or was explicitly documented as a broad package-health audit.
+
+## Per-Run Artifacts
+
+- `ALLURE_AGENT_OUTPUT` must use a unique temp directory per run.
+- `ALLURE_AGENT_EXPECTATIONS` must use a unique temp file per run.
+- Do not reuse those paths across parallel runs.
+- Keep agent-mode artifacts in temp locations, not in committed repo paths or module `build/allure-results` directories.
+
+YAML is preferred for expectations in v1.
+
+Review-oriented expectations example:
+
+```yaml
+goal: Review a module-scoped Gradle test run
+task_id: module-review
+notes:
+  - Start with the smallest relevant Gradle test scope.
+  - Review runtime evidence before source inspection.
+```
+
+Targeted module-run pattern:
+
+```bash
+TMP_DIR="$(mktemp -d)"
+EXPECTATIONS="$TMP_DIR/expectations.yaml"
+
+cat > "$EXPECTATIONS" <<'YAML'
+goal: Review a module-scoped Gradle test run
+task_id: module-review
+notes:
+  - Start with the smallest relevant Gradle test scope.
+  - Review runtime evidence before source inspection.
+YAML
+
+ALLURE_AGENT_OUTPUT="$TMP_DIR/agent-output" \
+ALLURE_AGENT_EXPECTATIONS="$EXPECTATIONS" \
+allure run -- ./gradlew :allure-jupiter:test \
+  --tests io.qameta.allure.junit5.AllureJunit5Junit6CompatibilityTest
+```
+
+Broad repo-smoke pattern:
+
+```bash
+TMP_DIR="$(mktemp -d)"
+
+ALLURE_AGENT_OUTPUT="$TMP_DIR/agent-output" \
+allure run -- ./gradlew --no-build-cache cleanTest test
+```
+
+Broad package-health or repo-health audits may omit expectations, but the resulting scope review is weaker and should be called out explicitly.
+
+## Evidence Rules
+
+- Steps must wrap real setup, actions, state transitions, or assertions.
+- Attachments must contain real runtime evidence from that execution.
+- Metadata should stay minimal and purposeful.
+- Prefer helper-boundary instrumentation over repetitive caller wrapping.
+
+Good example:
+
+- instrument a shared assertion helper once instead of wrapping every caller
+
+Rejected examples:
+
+- empty wrapper steps
+- static `test passed` attachments
+- labels that no review or policy step uses
+
+## When Console Errors Are Not Represented As Test Results
+
+- Suite-load, import, or setup failures may appear only in `artifacts/global/stderr.txt` or global errors.
+- If `manifest/tests.jsonl` does not account for all visible failures from the test runner, inspect global stderr before concluding the run is fully modeled.
+- Treat that state as a partial runtime review, not as a clean or complete result set.
+- If runner-visible failures are present outside logical test files, final conclusions must stay provisional until the missing modeling is understood.
+
+## Acceptance Rules
+
+Accept a run only when:
+
+- scope matches expectations
+- evidence is strong enough to explain what happened
+- no high-confidence noop or placeholder findings remain
+
+### Review Completeness
+
+A test review is not complete unless:
+
+- the relevant scope was run with agent mode, unless that is impossible
+- expectations were created for the intended scope, unless this is a broad package-health audit
+- agent artifacts were reviewed before final conclusions
+- missing or partial runtime modeling was called out explicitly
+- console-only conclusions are treated as provisional when agent output is absent or incomplete
diff --git a/gradle.properties b/gradle.properties
index b41179d6..5c3b0908 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,4 +1,4 @@
-version=2.34.0
+version=2.35.2
 
 org.gradle.daemon=true
 org.gradle.parallel=true
diff --git a/gradle/quality-configs/checkstyle/checkstyle.xml b/gradle/quality-configs/checkstyle/checkstyle.xml
index 8e3f80a2..d431282a 100644
--- a/gradle/quality-configs/checkstyle/checkstyle.xml
+++ b/gradle/quality-configs/checkstyle/checkstyle.xml
@@ -1,247 +1,81 @@
-<?xml version="1.0" ?>
-<!DOCTYPE module PUBLIC
-        "-//Puppy Crawl//DTD Check Configuration 1.2//EN"
-        "http://www.puppycrawl.com/dtds/configuration_1_2.dtd">
-<module name="Checker">
-    <!-- Properties (http://checkstyle.sourceforge.net/config.html#Properties#Checker) -->
-    <property name="fileExtensions" value="java, properties, xml"/>
-
-    <!-- Filters (http://checkstyle.sourceforge.net/config_filters.html) -->
-    <module name="SuppressWarningsFilter"/>
-
-    <module name="NewlineAtEndOfFile">
-        <property name="lineSeparator" value="lf"/>
-    </module>
-    <!-- disabled in favour of PMD ExcessiveClassLength check, which correctly checks class length not file length -->
-    <!--<module name="FileLength">-->
-    <!--<property name="max" value="500"/>-->
-    <!--</module>-->
-    <module name="FileTabCharacter"/>
-    <module name="Translation"/>
-    <module name="UniqueProperties"/>
-
-    <module name="LineLength">
-        <property name="max" value="120"/>
-    </module>
-
-    <module name="TreeWalker">
-        <!-- http://checkstyle.sourceforge.net/config_filters.html#SuppressionCommentFilter -->
-        <module name="SuppressionCommentFilter"/>
-
-        <!-- Annotations (http://checkstyle.sourceforge.net/config_annotation.html) -->
-        <!--<module name="AnnotationLocation"/>-->
-        <!--<module name="AnnotationOnSameLine">-->
-        <!--<module name="AnnotationUseStyle"/>-->
-        <module name="MissingDeprecated"/>
-        <module name="MissingOverride"/>
-        <module name="PackageAnnotation"/>
-        <module name="SuppressWarningsHolder"/>
-        <module name="SuppressWarnings"/>
-
-
-        <!-- Block Checks (http://checkstyle.sourceforge.net/config_blocks.html) -->
-        <module name="AvoidNestedBlocks"/>
-        <module name="EmptyBlock"/>
-        <module name="EmptyCatchBlock"/>
-        <module name="LeftCurly"/>
-        <!--        <module name="NeedBraces"/>-->
-        <module name="RightCurly"/>
-
-
-        <!-- Class Design (http://checkstyle.sourceforge.net/config_design.html) -->
-        <!--<module name="DesignForExtension">-->
-        <module name="FinalClass"/>
-        <module name="HideUtilityClassConstructor"/>
-        <module name="InnerTypeLast"/>
-        <module name="InterfaceIsType"/>
-        <module name="MutableException"/>
-        <module name="OneTopLevelClass"/>
-        <module name="ThrowsCount"/>
-        <module name="VisibilityModifier">
-            <property name="protectedAllowed" value="true"/>
-        </module>
-
-
-        <!-- Coding (http://checkstyle.sourceforge.net/config_coding.html) -->
-        <module name="ArrayTrailingComma"/>
-        <!--<module name="AvoidInlineConditionals"/>-->
-        <module name="CovariantEquals"/>
-        <!--<module name="DeclarationOrder"/>-->
-        <module name="DefaultComesLast"/>
-        <module name="EmptyStatement"/>
-        <module name="EqualsAvoidNull"/>
-        <module name="EqualsHashCode"/>
-        <module name="ExplicitInitialization"/>
-        <module name="FallThrough"/>
-        <module name="FinalLocalVariable"/>
-        <!--<module name="HiddenField"/>-->
-        <!--<module name="IllegalCatch"/>-->
-        <module name="IllegalInstantiation"/>
-        <!--<module name="IllegalThrows"/>-->
-        <!--<module name="IllegalToken"/>-->
-        <module name="IllegalTokenText"/>
-        <!--<module name="IllegalType"/>-->
-        <module name="InnerAssignment"/>
-        <!--<module name="MagicNumber"/>-->
-        <!--<module name="MissingCtor"/>-->
-        <module name="MissingSwitchDefault"/>
-        <module name="ModifiedControlVariable"/>
-        <module name="MultipleStringLiterals">
-            <property name="ignoreStringsRegexp" value='^(("")|(", ")|("\\n")|("\\t")|(" "))$'/>
-        </module>
-        <module name="MultipleVariableDeclarations"/>
-        <module name="NestedForDepth">
-            <property name="max" value="2"/>
-        </module>
-        <module name="NestedIfDepth">
-            <property name="max" value="3"/>
-        </module>
-        <module name="NestedTryDepth">
-            <property name="max" value="2"/>
-        </module>
-        <module name="NoClone"/>
-        <module name="NoFinalizer"/>
-        <module name="OneStatementPerLine"/>
-        <module name="OverloadMethodsDeclarationOrder"/>
-        <module name="PackageDeclaration"/>
-        <module name="ParameterAssignment"/>  <!-- more strict version is FinalParameters -->
-        <!--<module name="RequireThis"/>-->
-        <module name="ReturnCount">
-            <property name="max" value="5"/>
-            <property name="maxForVoid" value="3"/>
-        </module>
-        <module name="SimplifyBooleanExpression"/>
-        <module name="SimplifyBooleanReturn"/>
-        <module name="StringLiteralEquality"/>
-        <!--<module name="SuperClone"/>-->
-        <!--<module name="SuperFinalize"/>-->
-        <module name="UnnecessaryParentheses"/>
-        <module name="VariableDeclarationUsageDistance">
-            <property name="allowedDistance" value="5"/>
-        </module>
-
-
-        <!-- Headers (http://checkstyle.sourceforge.net/config_header.html) -->
-        <!--<module name="Header"/>-->
-        <!--<module name="RegexpHeader"/>-->
-
-
-        <!-- Imports (http://checkstyle.sourceforge.net/config_imports.html) -->
-        <module name="AvoidStarImport"/>
-        <!--<module name="AvoidStaticImport"/>-->
-        <!--<module name="CustomImportOrder"/>-->
-        <module name="IllegalImport"/>
-        <!--<module name="ImportControl"/>-->
-        <!--<module name="ImportOrder"/>-->
-        <module name="RedundantImport"/>
-        <module name="UnusedImports"/>
-
-
-        <!-- Javadoc Comments (http://checkstyle.sourceforge.net/config_javadoc.html) -->
-        <!--<module name="AtclauseOrder"/>-->
-        <!--<module name="JavadocMethod"/>-->
-        <!--<module name="JavadocPackage"/>-->
-        <!--<module name="JavadocParagraph"/>-->
-        <module name="JavadocStyle"/>
-        <!--<module name="JavadocTagContinuationIndentation"/>-->
-        <module name="JavadocType"/>
-        <!--<module name="JavadocVariable"/>-->
-        <module name="NonEmptyAtclauseDescription"/>
-        <!--<module name="SingleLineJavadoc"/>-->
-        <!--<module name="SummaryJavadoc"/>-->
-        <!--<module name="WriteTag"/>-->
-
-
-        <!-- Metrics (http://checkstyle.sourceforge.net/config_metrics.html) -->
-        <module name="BooleanExpressionComplexity"/>
-        <!--        <module name="ClassDataAbstractionCoupling"/>-->
-        <!--        <module name="ClassFanOutComplexity"/>-->
-        <module name="CyclomaticComplexity"/>
-        <!--        <module name="JavaNCSS"/>-->
-        <module name="NPathComplexity"/>
-
-
-        <!--  Miscellaneous (http://checkstyle.sourceforge.net/config_misc.html) -->
-        <module name="ArrayTypeStyle"/>
-        <!--<module name="AvoidEscapedUnicodeCharacters"/>-->
-        <!--<module name="CommentsIndentation"/>-->
-        <module name="DescendantToken"/>
-        <!--<module name="FinalParameters"/>-->  <!-- DISABLED in favor of less restricted ParameterAssignment -->
-        <!--<module name="Indentation"/>-->
-        <module name="OuterTypeFilename"/>
-        <!--<module name="TodoComment"/>-->
-        <!--<module name="TrailingComment"/>-->
-        <!--<module name="UncommentedMain"/>-->
-        <module name="UpperEll"/>
-
-
-        <!-- Modifiers (http://checkstyle.sourceforge.net/config_modifier.html) -->
-        <module name="ModifierOrder"/>
-        <module name="RedundantModifier"/>
-
-
-        <!-- Naming Conventions (http://checkstyle.sourceforge.net/config_naming.html) -->
-        <module name="AbbreviationAsWordInName"/>
-        <!--<module name="AbstractClassName"/>-->
-        <!--<module name="CatchParameterName"/>-->
-        <module name="ClassTypeParameterName">
-            <property name="format" value="^[A-Z]*$"/>
-        </module>
-        <module name="ConstantName"/>
-        <module name="InterfaceTypeParameterName">
-            <property name="format" value="^[A-Z]*$"/>
-        </module>
-        <module name="LocalFinalVariableName"/>
-        <module name="LocalVariableName"/>
-        <module name="MemberName"/>
-        <module name="MethodName"/>
-        <module name="MethodTypeParameterName">
-            <property name="format" value="^[A-Z]*$"/>
-        </module>
-        <module name="PackageName"/>
-        <module name="ParameterName"/>
-        <module name="StaticVariableName"/>
-        <module name="TypeName"/>
-
-
-        <!-- Regexp (http://checkstyle.sourceforge.net/config_regexp.html) -->
-        <!--<module name="Regexp"/>-->
-        <!--<module name="RegexpMultiline"/>-->
-        <!--<module name="RegexpSingleline"/>-->
-        <!--<module name="RegexpSinglelineJava"/>-->
-
-
-        <!-- Size Violations (http://checkstyle.sourceforge.net/config_sizes.html) -->
-        <module name="AnonInnerLength"/>
-        <!--        <module name="ExecutableStatementCount"/>-->
-        <module name="MethodCount"/>
-        <module name="MethodLength"/>
-        <module name="OuterTypeNumber"/>
-        <module name="ParameterNumber"/>
-
-
-        <!-- Whitespace (http://checkstyle.sourceforge.net/config_whitespace.html) -->
-        <module name="EmptyForInitializerPad"/>
-        <module name="EmptyForIteratorPad"/>
-        <!--<module name="EmptyLineSeparator"/>-->
-        <module name="GenericWhitespace"/>
-        <module name="MethodParamPad"/>
-        <module name="NoLineWrap"/>
-        <module name="NoWhitespaceAfter"/>
-        <module name="NoWhitespaceBefore"/>
-        <module name="OperatorWrap"/>
-        <module name="ParenPad"/>
-        <module name="SeparatorWrap">
-            <property name="tokens" value="COMMA"/>
-            <property name="option" value="eol"/>
-        </module>
-        <module name="SeparatorWrap">
-            <property name="tokens" value="DOT"/>
-            <property name="option" value="nl"/>
-        </module>
-        <module name="SingleSpaceSeparator"/>
-        <module name="TypecastParenPad"/>
-        <module name="WhitespaceAfter"/>
-        <module name="WhitespaceAround"/>
-    </module>
-</module>
+<?xml version="1.0" ?>
+<!DOCTYPE module PUBLIC
+        "-//Puppy Crawl//DTD Check Configuration 1.2//EN"
+        "http://www.puppycrawl.com/dtds/configuration_1_2.dtd">
+<module name="Checker">
+    <property name="fileExtensions" value="java"/>
+
+    <module name="SuppressWarningsFilter"/>
+
+    <module name="TreeWalker">
+        <module name="SuppressWarningsHolder"/>
+
+        <!-- Imports -->
+        <module name="AvoidStarImport"/>
+        <module name="ImportControl">
+            <property name="file" value="${config_loc}/import-control.xml"/>
+        </module>
+
+        <!-- Annotations -->
+        <module name="MissingDeprecated"/>
+        <module name="MissingOverride"/>
+
+        <!-- Blocks -->
+        <module name="EmptyBlock"/>
+        <module name="EmptyCatchBlock"/>
+        <module name="NeedBraces"/>
+
+        <!-- Class design -->
+        <module name="HideUtilityClassConstructor"/>
+        <module name="VisibilityModifier">
+            <property name="protectedAllowed" value="true"/>
+        </module>
+
+        <!-- Coding -->
+        <module name="CovariantEquals"/>
+        <module name="DefaultComesLast"/>
+        <module name="EqualsAvoidNull"/>
+        <module name="EqualsHashCode"/>
+        <module name="FallThrough"/>
+        <module name="IllegalInstantiation"/>
+        <module name="IllegalTokenText"/>
+        <module name="InnerAssignment"/>
+        <module name="MissingSwitchDefault"/>
+        <module name="ModifiedControlVariable"/>
+        <module name="MultipleStringLiterals"/>
+        <module name="NoClone"/>
+        <module name="NoFinalizer"/>
+        <module name="OverloadMethodsDeclarationOrder"/>
+        <module name="ParameterAssignment"/>
+        <module name="SimplifyBooleanExpression"/>
+        <module name="SimplifyBooleanReturn"/>
+        <module name="StringLiteralEquality"/>
+        <module name="UnnecessaryParentheses"/>
+
+        <!-- Naming -->
+        <module name="ClassTypeParameterName">
+            <property name="format" value="^[A-Z]*$"/>
+        </module>
+        <module name="ConstantName"/>
+        <module name="InterfaceTypeParameterName">
+            <property name="format" value="^[A-Z]*$"/>
+        </module>
+        <module name="LocalFinalVariableName"/>
+        <module name="LocalVariableName"/>
+        <module name="MemberName"/>
+        <module name="MethodName"/>
+        <module name="MethodTypeParameterName">
+            <property name="format" value="^[A-Z]*$"/>
+        </module>
+        <module name="PackageName"/>
+        <module name="ParameterName"/>
+        <module name="StaticVariableName"/>
+        <module name="TypeName"/>
+
+        <!-- Modifiers and source structure -->
+        <module name="ModifierOrder"/>
+        <module name="RedundantModifier"/>
+        <module name="OuterTypeFilename"/>
+        <module name="UpperEll"/>
+    </module>
+</module>
diff --git a/gradle/quality-configs/checkstyle/import-control.xml b/gradle/quality-configs/checkstyle/import-control.xml
new file mode 100644
index 00000000..70e35d10
--- /dev/null
+++ b/gradle/quality-configs/checkstyle/import-control.xml
@@ -0,0 +1,15 @@
+<!DOCTYPE import-control PUBLIC
+        "-//Checkstyle//DTD ImportControl Configuration 1.4//EN"
+        "https://checkstyle.org/dtds/import_control_1_4.dtd">
+<import-control pkg="io.qameta.allure" strategyOnMismatch="allowed">
+    <disallow pkg="sun"/>
+    <disallow pkg="org.codehaus.jackson"/>
+    <disallow pkg="org.apache.commons.collections"/>
+    <disallow pkg="org.springframework.util"/>
+    <disallow pkg="org.springframework.data.util"/>
+
+    <subpackage name="springweb">
+        <allow pkg="org.springframework.util"/>
+    </subpackage>
+
+</import-control>
diff --git a/gradle/quality-configs/pmd/pmd.xml b/gradle/quality-configs/pmd/pmd.xml
index a3c7ca8b..8ca8ea30 100644
--- a/gradle/quality-configs/pmd/pmd.xml
+++ b/gradle/quality-configs/pmd/pmd.xml
@@ -1,128 +1,131 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ruleset name="Base ruleset" xmlns="http://pmd.sourceforge.net/ruleset/2.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://pmd.sourceforge.net/ruleset/2.0.0 http://pmd.sourceforge.net/ruleset_2_0_0.xsd">
-
-    <description>
-        General Java quality rules.
-    </description>
-
-    <!-- Best practices (https://pmd.github.io/pmd-6.0.1/pmd_rules_java_bestpractices.html) -->
-    <rule ref="category/java/bestpractices.xml">
-        <exclude name="AbstractClassWithoutAbstractMethod"/>
-        <!-- disabled as it's important for android and doesn't matter for general java (also fixes will
-             conflict with checkstyle's VisibilityModifier check -->
-        <exclude name="AccessorMethodGeneration"/>
-        <exclude name="ArrayIsStoredDirectly"/>
-        <exclude name="GuardLogStatement"/>
-        <!--  Doesn't work with Java 8 switch clause  -->
-        <exclude name="ExhaustiveSwitchHasDefault"/>
-    </rule>
-
-
-    <!-- Code style (https://pmd.github.io/pmd-6.0.1/pmd_rules_java_codestyle.html) -->
-    <rule ref="category/java/codestyle.xml">
-        <exclude name="AtLeastOneConstructor"/>
-        <exclude name="CallSuperInConstructor"/>
-        <exclude name="CommentDefaultAccessModifier"/>
-        <exclude name="ConfusingTernary"/>
-        <exclude name="GenericsNaming"/>
-        <exclude name="LinguisticNaming"/>
-        <exclude name="LocalHomeNamingConvention"/> <!-- earlier j2ee group-->
-        <exclude name="LocalInterfaceSessionNamingConvention"/> <!-- earlier j2ee group-->
-        <exclude name="LocalVariableCouldBeFinal"/>
-        <exclude name="LongVariable"/>
-        <exclude name="MDBAndSessionBeanNamingConvention"/> <!-- earlier j2ee group-->
-        <exclude name="OnlyOneReturn"/> <!-- disabled in favour of checkstyle ReturnCount check -->
-        <exclude name="RemoteInterfaceNamingConvention"/> <!-- earlier j2ee group-->
-        <exclude name="RemoteSessionInterfaceNamingConvention"/> <!-- earlier j2ee group-->
-        <exclude name="ShortClassName"/>
-        <exclude name="ShortMethodName"/>
-        <exclude name="ShortVariable"/>
-        <exclude name="TooManyStaticImports"/>
-        <exclude name="UnnecessaryAnnotationValueElement"/>
-        <exclude name="UseDiamondOperator"/>
-        <exclude name="UselessParentheses"/>
-        <exclude name="BooleanGetMethodName"/>
-        <exclude name="ClassNamingConventions"/>
-    </rule>
-
-    <!-- Design (https://pmd.github.io/pmd-6.0.1/pmd_rules_java_design.html) -->
-    <rule ref="category/java/design.xml">
-        <exclude name="AvoidCatchingGenericException"/>
-        <exclude name="CouplingBetweenObjects"/>
-        <exclude name="DataClass"/>
-        <exclude name="ExcessiveImports"/>
-        <exclude name="LawOfDemeter"/>
-        <exclude name="CyclomaticComplexity"/> <!-- disabled in favour of checkstyle's CyclomaticComplexity check -->
-        <exclude name="LoosePackageCoupling"/>
-        <exclude name="SignatureDeclareThrowsException"/>
-        <exclude name="TooManyFields"/>
-        <exclude name="GodClass"/>
-        <exclude name="CognitiveComplexity"/>
-        <exclude name="NcssCount"/>
-        <exclude name="ExcessivePublicCount"/>
-        <exclude name="TooManyMethods"/>
-        <exclude name="ClassWithOnlyPrivateConstructorsShouldBeFinal"/>
-    </rule>
-    <rule ref="category/java/design.xml/AvoidDeeplyNestedIfStmts">
-        <properties>
-            <property name="problemDepth" value="4"/>
-        </properties>
-    </rule>
-    <rule ref="category/java/design.xml/NPathComplexity">
-        <properties>
-            <property name="reportLevel" value="201"/>
-        </properties>
-    </rule>
-
-    <!-- Documentation (https://pmd.github.io/pmd-6.0.1/pmd_rules_java_documentation.html) -->
-    <rule ref="category/java/documentation.xml">
-        <exclude name="CommentRequired"/>
-        <exclude name="CommentSize"/>
-    </rule>
-
-
-    <!-- Error prone (https://pmd.github.io/pmd-6.0.1/pmd_rules_java_errorprone.html) -->
-    <rule ref="category/java/errorprone.xml">
-        <exclude name="AvoidCatchingThrowable"/>
-        <exclude name="AvoidFieldNameMatchingMethodName"/>
-        <exclude name="AssignmentInOperand"/>  <!-- duplicate of checkstyle check AssignmentInOperand -->
-        <exclude name="AvoidLiteralsInIfCondition"/>
-        <exclude name="EmptyFinalizer"/>
-        <exclude name="FinalizeDoesNotCallSuperFinalize"/>
-        <exclude name="FinalizeOnlyCallsSuperFinalize"/>
-        <exclude name="JUnitSpelling"/>
-        <exclude name="JUnitStaticSuite"/>
-        <exclude name="MissingSerialVersionUID"/>
-        <exclude
-                name="NullAssignment"/> <!-- disabled due to false positive for initialization with ternary operator -->
-        <exclude name="StaticEJBFieldShouldBeFinal"/> <!-- earlier j2ee group-->
-        <exclude name="TestClassWithoutTestCases"/>
-        <exclude name="UseCorrectExceptionLogging"/>
-        <exclude name="UseLocaleWithCaseConversions"/>
-        <exclude name="UseProperClassLoader"/> <!-- earlier j2ee group-->
-    </rule>
-    <rule ref="category/java/errorprone.xml/AvoidDuplicateLiterals">
-        <properties>
-            <property name="skipAnnotations" value="true"/>
-        </properties>
-    </rule>
-
-
-    <!-- Error prone (https://pmd.github.io/pmd-6.0.1/pmd_rules_java_multithreading.html) -->
-    <rule ref="category/java/multithreading.xml">
-        <exclude name="DoNotUseThreads"/> <!-- earlier j2ee group-->
-        <exclude name="UseConcurrentHashMap"/>
-    </rule>
-
-
-    <!-- Performance (https://pmd.github.io/pmd-6.0.1/pmd_rules_java_performance.html) -->
-    <rule ref="category/java/performance.xml">
-        <exclude name="AvoidInstantiatingObjectsInLoops"/>
-    </rule>
-
-    <!-- Security (no rules) -->
-    <rule ref="category/java/security.xml"/>
-
-</ruleset>
+<?xml version="1.0" encoding="UTF-8"?>
+<ruleset name="Base ruleset" xmlns="http://pmd.sourceforge.net/ruleset/2.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://pmd.sourceforge.net/ruleset/2.0.0 http://pmd.sourceforge.net/ruleset_2_0_0.xsd">
+
+  <description>
+    General Java quality rules.
+  </description>
+
+  <!-- Best practices -->
+  <rule ref="category/java/bestpractices.xml">
+    <exclude name="AbstractClassWithoutAbstractMethod"/>
+    <!-- disabled as it's important for android and doesn't matter for general java (also fixes will
+         conflict with checkstyle's VisibilityModifier check -->
+    <exclude name="AccessorMethodGeneration"/>
+    <exclude name="ArrayIsStoredDirectly"/>
+    <!--  Doesn't work with Java 8 switch clause  -->
+    <exclude name="ExhaustiveSwitchHasDefault"/>
+    <exclude name="GuardLogStatement"/>
+    <exclude name="ImplicitFunctionalInterface"/>
+    <exclude name="UnnecessaryVarargsArrayCreation"/>
+    <exclude name="UseTryWithResources"/>
+    <exclude name="UseVarargs"/>
+  </rule>
+
+
+  <!-- Code style -->
+  <rule ref="category/java/codestyle.xml">
+    <exclude name="AtLeastOneConstructor"/>
+    <exclude name="BooleanGetMethodName"/>
+    <exclude name="CallSuperInConstructor"/>
+    <exclude name="CommentDefaultAccessModifier"/>
+    <exclude name="ConfusingTernary"/>
+    <exclude name="GenericsNaming"/>
+    <exclude name="LinguisticNaming"/>
+    <exclude name="LocalHomeNamingConvention"/> <!-- earlier j2ee group-->
+    <exclude name="LocalInterfaceSessionNamingConvention"/> <!-- earlier j2ee group-->
+    <exclude name="LocalVariableCouldBeFinal"/>
+    <exclude name="LongVariable"/>
+    <exclude name="MDBAndSessionBeanNamingConvention"/> <!-- earlier j2ee group-->
+    <exclude name="OnlyOneReturn"/> <!-- single-return preference is too noisy for this codebase -->
+    <exclude name="RemoteInterfaceNamingConvention"/> <!-- earlier j2ee group-->
+    <exclude name="RemoteSessionInterfaceNamingConvention"/> <!-- earlier j2ee group-->
+    <exclude name="ShortClassName"/>
+    <exclude name="ShortMethodName"/>
+    <exclude name="ShortVariable"/>
+    <exclude name="TooManyStaticImports"/>
+    <exclude name="UnnecessaryAnnotationValueElement"/>
+    <exclude name="UseDiamondOperator"/>
+    <exclude name="UseShortArrayInitializer"/>
+    <exclude name="UselessParentheses"/>
+  </rule>
+
+  <rule ref="category/java/codestyle.xml/ClassNamingConventions">
+    <properties>
+      <property name="utilityClassPattern" value="[A-Z][a-zA-Z0-9]+"/>
+    </properties>
+  </rule>
+
+  <!-- Design -->
+  <rule ref="category/java/design.xml">
+    <exclude name="AvoidCatchingGenericException"/>
+    <exclude name="CouplingBetweenObjects"/>
+    <exclude name="DataClass"/>
+    <exclude name="CyclomaticComplexity"/>
+    <exclude name="ExcessiveImports"/>
+    <exclude name="ExcessivePublicCount"/>
+    <exclude name="LawOfDemeter"/>
+    <exclude name="LoosePackageCoupling"/>
+    <exclude name="NcssCount"/>
+    <exclude name="NPathComplexity"/>
+    <exclude name="SignatureDeclareThrowsException"/>
+    <exclude name="TooManyFields"/>
+  </rule>
+  <rule ref="category/java/design.xml/AvoidDeeplyNestedIfStmts">
+    <properties>
+      <property name="problemDepth" value="4"/>
+    </properties>
+  </rule>
+  <rule ref="category/java/design.xml/TooManyMethods" message="Avoid classes longer than 20 methods">
+    <properties>
+      <property name="maxmethods" value="20"/>
+    </properties>
+  </rule>
+
+
+  <!-- Documentation -->
+  <rule ref="category/java/documentation.xml">
+    <exclude name="CommentRequired"/>
+    <exclude name="CommentSize"/>
+  </rule>
+
+
+  <!-- Error prone -->
+  <rule ref="category/java/errorprone.xml">
+    <exclude name="AvoidCatchingThrowable"/>
+    <exclude name="AvoidDuplicateLiterals"/>  <!-- duplicate of checkstyle check MultipleStringLiterals -->
+    <exclude name="AvoidFieldNameMatchingMethodName"/>
+    <exclude name="AssignmentInOperand"/>  <!-- duplicate of checkstyle check InnerAssignment -->
+    <exclude name="AvoidLiteralsInIfCondition"/>
+    <exclude name="EmptyFinalizer"/>
+    <exclude name="FinalizeDoesNotCallSuperFinalize"/>
+    <exclude name="FinalizeOnlyCallsSuperFinalize"/>
+    <exclude name="InvalidLogMessageFormat"/>
+    <exclude name="JUnitSpelling"/>
+    <exclude name="JUnitStaticSuite"/>
+    <exclude name="MissingStaticMethodInNonInstantiatableClass"/>
+    <exclude name="MissingSerialVersionUID"/>
+    <exclude name="NullAssignment"/> <!-- disabled due to false positive for initialization with ternary operator -->
+    <exclude name="StaticEJBFieldShouldBeFinal"/> <!-- earlier j2ee group-->
+    <exclude name="TestClassWithoutTestCases"/>
+    <exclude name="UseCorrectExceptionLogging"/>
+    <exclude name="UseLocaleWithCaseConversions"/>
+    <exclude name="UseProperClassLoader"/> <!-- earlier j2ee group-->
+  </rule>
+
+  <!-- Multithreading -->
+  <rule ref="category/java/multithreading.xml">
+    <exclude name="DoNotUseThreads"/> <!-- earlier j2ee group-->
+    <exclude name="UseConcurrentHashMap"/>
+  </rule>
+
+
+  <!-- Performance -->
+  <rule ref="category/java/performance.xml"/>
+
+
+  <!-- Security (no rules) -->
+  <rule ref="category/java/security.xml"/>
+
+</ruleset>
diff --git a/gradle/quality-configs/spotbugs/exclude.xml b/gradle/quality-configs/spotbugs/exclude.xml
index f942c310..58ec6c46 100644
--- a/gradle/quality-configs/spotbugs/exclude.xml
+++ b/gradle/quality-configs/spotbugs/exclude.xml
@@ -9,6 +9,12 @@
     <Match>
         <Source name="~.*\.scala"/>
     </Match>
+    <Match>
+        <Source name="~.*[/\\]generated-sources[/\\].*"/>
+    </Match>
+    <Match>
+        <Source name="~.*[/\\]generated[/\\].*"/>
+    </Match>
 
     <!-- Disable check -->
     <Match>
diff --git a/gradle/quality-configs/spotless/eclipse-jdt.prefs b/gradle/quality-configs/spotless/eclipse-jdt.prefs
new file mode 100644
index 00000000..02f0d057
--- /dev/null
+++ b/gradle/quality-configs/spotless/eclipse-jdt.prefs
@@ -0,0 +1,19 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.javaFormatter=org.eclipse.jdt.core.defaultJavaFormatter
+org.eclipse.jdt.core.formatter.alignment_for_enum_constants=49
+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=18
+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=18
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=49
+org.eclipse.jdt.core.formatter.comment.format_block_comments=false
+org.eclipse.jdt.core.formatter.comment.format_header=false
+org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=false
+org.eclipse.jdt.core.formatter.comment.format_line_comments=false
+org.eclipse.jdt.core.formatter.indentation.size=4
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert
+org.eclipse.jdt.core.formatter.join_wrapped_lines=false
+org.eclipse.jdt.core.formatter.lineSplit=180
+org.eclipse.jdt.core.formatter.parentheses_positions_in_annotation=separate_lines_if_wrapped
+org.eclipse.jdt.core.formatter.parentheses_positions_in_method_invocation=separate_lines_if_wrapped
+org.eclipse.jdt.core.formatter.tabulation.char=space
+org.eclipse.jdt.core.formatter.tabulation.size=4
diff --git a/gradle/quality-configs/spotless/scalafmt.conf b/gradle/quality-configs/spotless/scalafmt.conf
new file mode 100644
index 00000000..e5465adc
--- /dev/null
+++ b/gradle/quality-configs/spotless/scalafmt.conf
@@ -0,0 +1,7 @@
+version = "3.7.3"
+runner.dialect = scala213
+maxColumn = 180
+docstrings.style = SpaceAsterisk
+docstrings.oneline = unfold
+docstrings.blankFirstLine = yes
+docstrings.wrap = no
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index a5952066..e48eca57 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.11-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/settings.gradle.kts b/settings.gradle.kts
index bf49b841..b8a4309a 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -24,15 +24,17 @@ include("allure-jsonunit")
 include("allure-junit-platform")
 include("allure-junit4")
 include("allure-junit4-aspect")
-include("allure-junit5")
-include("allure-junit5-assert")
+include("allure-jupiter")
+include("allure-jupiter-assert")
 include("allure-karate")
 include("allure-model")
 include("allure-okhttp")
 include("allure-okhttp3")
+include("allure-playwright")
 include("allure-reader")
 include("allure-rest-assured")
 include("allure-scalatest")
+include("allure-selenium-bidi")
 include("allure-selenide")
 include("allure-servlet-api")
 include("allure-spock")
@@ -49,10 +51,7 @@ pluginManagement {
         id("com.diffplug.spotless") version "6.25.0"
         id("io.github.goooler.shadow") version "8.1.8"
         id("io.github.gradle-nexus.publish-plugin") version "2.0.0"
-        id("io.qameta.allure-adapter") version "3.0.1"
-        id("io.qameta.allure-aggregate-report") version "3.0.1"
-        id("io.qameta.allure-download") version "3.0.1"
-        id("io.qameta.allure-report") version "3.0.1"
+        id("io.qameta.allure") version "4.0.0"
         id("io.spring.dependency-management") version "1.1.7"
         id("com.google.protobuf") version "0.9.6"
         id("com.github.spotbugs") version "6.4.7"