diff --git a/packages/e2e/test/allure-awesome/tree.test.ts b/packages/e2e/test/allure-awesome/tree/commons.test.ts
similarity index 56%
rename from packages/e2e/test/allure-awesome/tree.test.ts
rename to packages/e2e/test/allure-awesome/tree/commons.test.ts
index e59ad853..2cadc924 100644
--- a/packages/e2e/test/allure-awesome/tree.test.ts
+++ b/packages/e2e/test/allure-awesome/tree/commons.test.ts
@@ -1,17 +1,20 @@
 import { expect, test } from "@playwright/test";
 import { layer } from "allure-js-commons";
 import { Stage, Status } from "allure-js-commons";
-import { type ReportBootstrap, boostrapReport } from "../utils/index.js";
+import { type ReportBootstrap, boostrapReport } from "../../utils/index.js";
 
 let bootstrap: ReportBootstrap;
 
 test.beforeEach(async ({ page }) => {
   await layer("e2e");
-  await page.goto(bootstrap.url);
+
+  if (bootstrap) {
+    await page.goto(bootstrap.url);
+  }
 });
 
 test.afterAll(async () => {
-  await bootstrap.shutdown();
+  await bootstrap?.shutdown?.();
 });
 
 test.describe("commons", () => {
@@ -77,19 +80,19 @@ test.describe("commons", () => {
     await expect(treeLeaves).toHaveCount(5);
     await expect(treeLeaves.nth(0).getByTestId("tree-leaf-title")).toHaveText("0 sample passed test");
     await expect(treeLeaves.nth(0).getByTestId("tree-leaf-status-passed")).toBeVisible();
-    await expect(treeLeaves.nth(0).getByTestId("tree-leaf-order")).toHaveText("#1");
+    await expect(treeLeaves.nth(0).getByTestId("tree-leaf-order")).toHaveText("1");
     await expect(treeLeaves.nth(1).getByTestId("tree-leaf-title")).toHaveText("1 sample failed test");
     await expect(treeLeaves.nth(1).getByTestId("tree-leaf-status-failed")).toBeVisible();
-    await expect(treeLeaves.nth(1).getByTestId("tree-leaf-order")).toHaveText("#2");
+    await expect(treeLeaves.nth(1).getByTestId("tree-leaf-order")).toHaveText("2");
     await expect(treeLeaves.nth(2).getByTestId("tree-leaf-title")).toHaveText("2 sample broken test");
     await expect(treeLeaves.nth(2).getByTestId("tree-leaf-status-broken")).toBeVisible();
-    await expect(treeLeaves.nth(2).getByTestId("tree-leaf-order")).toHaveText("#3");
+    await expect(treeLeaves.nth(2).getByTestId("tree-leaf-order")).toHaveText("3");
     await expect(treeLeaves.nth(3).getByTestId("tree-leaf-title")).toHaveText("3 sample skipped test");
     await expect(treeLeaves.nth(3).getByTestId("tree-leaf-status-skipped")).toBeVisible();
-    await expect(treeLeaves.nth(3).getByTestId("tree-leaf-order")).toHaveText("#4");
+    await expect(treeLeaves.nth(3).getByTestId("tree-leaf-order")).toHaveText("4");
     await expect(treeLeaves.nth(4).getByTestId("tree-leaf-title")).toHaveText("4 sample unknown test");
     await expect(treeLeaves.nth(4).getByTestId("tree-leaf-status-unknown")).toBeVisible();
-    await expect(treeLeaves.nth(4).getByTestId("tree-leaf-order")).toHaveText("#5");
+    await expect(treeLeaves.nth(4).getByTestId("tree-leaf-order")).toHaveText("5");
   });
 
   test("statistics in metadata renders information about the tests", async ({ page }) => {
@@ -226,181 +229,3 @@ test.describe("filters", () => {
     });
   });
 });
-
-test.describe("suites", () => {
-  test.beforeAll(async () => {
-    bootstrap = await boostrapReport({
-      reportConfig: {
-        name: "Sample allure report",
-        appendHistory: false,
-        history: undefined,
-        historyPath: undefined,
-        knownIssuesPath: undefined,
-      },
-      testResults: [
-        {
-          name: "0 sample passed test",
-          fullName: "sample.js#0 sample passed test",
-          status: Status.PASSED,
-          stage: Stage.FINISHED,
-          start: 1000,
-          labels: [
-            { name: "parentSuite", value: "foo" },
-            {
-              name: "suite",
-              value: "bar",
-            },
-            { name: "subSuite", value: "baz" },
-          ],
-        },
-        {
-          name: "1 sample failed test",
-          fullName: "sample.js#1 sample failed test",
-          status: Status.FAILED,
-          stage: Stage.FINISHED,
-          start: 5000,
-          statusDetails: {
-            message: "Assertion error: Expected 1 to be 2",
-            trace: "failed test trace",
-          },
-        },
-      ],
-    });
-  });
-
-  test("suites groups are displayed", async ({ page }) => {
-    const treeLeaves = page.getByTestId("tree-leaf");
-    const parentGroupHeader = page.getByTestId("tree-header");
-
-    await expect(treeLeaves).toHaveCount(1);
-    await expect(parentGroupHeader.getByTestId("tree-header-title")).toHaveText("foo");
-    await parentGroupHeader.getByTestId("tree-arrow").click();
-
-    await expect(parentGroupHeader).toHaveCount(2);
-    await expect(parentGroupHeader.nth(0).getByTestId("tree-header-title")).toHaveText("foo");
-    await expect(parentGroupHeader.nth(1).getByTestId("tree-header-title")).toHaveText("bar");
-    await parentGroupHeader.nth(1).getByTestId("tree-arrow").click();
-
-    await expect(parentGroupHeader).toHaveCount(3);
-    await expect(parentGroupHeader.nth(0).getByTestId("tree-header-title")).toHaveText("foo");
-    await expect(parentGroupHeader.nth(1).getByTestId("tree-header-title")).toHaveText("bar");
-    await expect(parentGroupHeader.nth(2).getByTestId("tree-header-title")).toHaveText("baz");
-    await parentGroupHeader.nth(2).getByTestId("tree-arrow").click();
-
-    await expect(treeLeaves).toHaveCount(2);
-    await expect(treeLeaves.nth(0).getByTestId("tree-leaf-title")).toHaveText("0 sample passed test");
-    await expect(treeLeaves.nth(0).getByTestId("tree-leaf-order")).toHaveText("#1");
-    await expect(treeLeaves.nth(1).getByTestId("tree-leaf-title")).toHaveText("1 sample failed test");
-    await expect(treeLeaves.nth(1).getByTestId("tree-leaf-order")).toHaveText("#1");
-  });
-});
-
-test.describe("features", () => {
-  test.beforeAll(async () => {
-    bootstrap = await boostrapReport({
-      reportConfig: {
-        name: "Sample allure report",
-        appendHistory: false,
-        history: undefined,
-        historyPath: undefined,
-        knownIssuesPath: undefined,
-      },
-      pluginConfig: {
-        groupBy: ["feature"],
-      },
-      testResults: [
-        {
-          name: "0 sample passed test",
-          fullName: "sample.js#0 sample passed test",
-          status: Status.PASSED,
-          stage: Stage.FINISHED,
-          start: 1000,
-          labels: [{ name: "feature", value: "foo" }],
-        },
-        {
-          name: "1 sample failed test",
-          fullName: "sample.js#1 sample failed test",
-          status: Status.FAILED,
-          stage: Stage.FINISHED,
-          start: 5000,
-          statusDetails: {
-            message: "Assertion error: Expected 1 to be 2",
-            trace: "failed test trace",
-          },
-        },
-      ],
-    });
-  });
-
-  test("features groups are displayed", async ({ page }) => {
-    const treeLeaves = page.getByTestId("tree-leaf");
-    const parentGroupHeader = page.getByTestId("tree-header");
-
-    await expect(treeLeaves).toHaveCount(1);
-    await expect(parentGroupHeader.getByTestId("tree-header-title")).toHaveText("foo");
-    await parentGroupHeader.getByTestId("tree-arrow").click();
-
-    await page.pause();
-
-    await expect(treeLeaves).toHaveCount(2);
-    await expect(treeLeaves.nth(0).getByTestId("tree-leaf-title")).toHaveText("0 sample passed test");
-    await expect(treeLeaves.nth(0).getByTestId("tree-leaf-order")).toHaveText("#1");
-    await expect(treeLeaves.nth(1).getByTestId("tree-leaf-title")).toHaveText("1 sample failed test");
-    await expect(treeLeaves.nth(1).getByTestId("tree-leaf-order")).toHaveText("#1");
-  });
-});
-
-test.describe("stories", () => {
-  test.beforeAll(async () => {
-    bootstrap = await boostrapReport({
-      reportConfig: {
-        name: "Sample allure report",
-        appendHistory: false,
-        history: undefined,
-        historyPath: undefined,
-        knownIssuesPath: undefined,
-      },
-      pluginConfig: {
-        groupBy: ["story"],
-      },
-      testResults: [
-        {
-          name: "0 sample passed test",
-          fullName: "sample.js#0 sample passed test",
-          status: Status.PASSED,
-          stage: Stage.FINISHED,
-          start: 1000,
-          labels: [{ name: "story", value: "foo" }],
-        },
-        {
-          name: "1 sample failed test",
-          fullName: "sample.js#1 sample failed test",
-          status: Status.FAILED,
-          stage: Stage.FINISHED,
-          start: 5000,
-          statusDetails: {
-            message: "Assertion error: Expected 1 to be 2",
-            trace: "failed test trace",
-          },
-        },
-      ],
-    });
-  });
-
-  test("stories groups are displayed", async ({ page }) => {
-    const treeLeaves = page.getByTestId("tree-leaf");
-    const parentGroupHeader = page.getByTestId("tree-header");
-
-    await expect(treeLeaves).toHaveCount(1);
-    await expect(parentGroupHeader.getByTestId("tree-header-title")).toHaveText("foo");
-    await parentGroupHeader.getByTestId("tree-arrow").click();
-
-    await page.pause();
-
-    await expect(treeLeaves).toHaveCount(2);
-    await expect(treeLeaves.nth(0).getByTestId("tree-leaf-title")).toHaveText("0 sample passed test");
-    await expect(treeLeaves.nth(0).getByTestId("tree-leaf-order")).toHaveText("#1");
-    await expect(treeLeaves.nth(1).getByTestId("tree-leaf-title")).toHaveText("1 sample failed test");
-    await expect(treeLeaves.nth(1).getByTestId("tree-leaf-order")).toHaveText("#1");
-  });
-});
diff --git a/packages/e2e/test/allure-awesome/tree/features.test.ts b/packages/e2e/test/allure-awesome/tree/features.test.ts
new file mode 100644
index 00000000..7099a839
--- /dev/null
+++ b/packages/e2e/test/allure-awesome/tree/features.test.ts
@@ -0,0 +1,68 @@
+import { expect, test } from "@playwright/test";
+import { Stage, Status } from "allure-js-commons";
+import { layer } from "allure-js-commons";
+import { type ReportBootstrap, boostrapReport } from "../../utils/index.js";
+
+let bootstrap: ReportBootstrap;
+
+test.describe("stories", () => {
+  test.beforeAll(async () => {
+    bootstrap = await boostrapReport({
+      reportConfig: {
+        name: "Sample allure report",
+        appendHistory: false,
+        history: undefined,
+        historyPath: undefined,
+        knownIssuesPath: undefined,
+      },
+      pluginConfig: {
+        groupBy: ["feature"],
+      },
+      testResults: [
+        {
+          name: "0 sample passed test",
+          fullName: "sample.js#0 sample passed test",
+          status: Status.PASSED,
+          stage: Stage.FINISHED,
+          start: 1000,
+          labels: [{ name: "feature", value: "foo" }],
+        },
+        {
+          name: "1 sample failed test",
+          fullName: "sample.js#1 sample failed test",
+          status: Status.FAILED,
+          stage: Stage.FINISHED,
+          start: 5000,
+          statusDetails: {
+            message: "Assertion error: Expected 1 to be 2",
+            trace: "failed test trace",
+          },
+        },
+      ],
+    });
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await layer("e2e");
+    await page.goto(bootstrap.url);
+  });
+
+  test.afterAll(async () => {
+    await bootstrap?.shutdown?.();
+  });
+
+  test("features groups are displayed", async ({ page }) => {
+    const treeLeaves = page.getByTestId("tree-leaf");
+    const parentGroupHeader = page.getByTestId("tree-header");
+
+    await expect(treeLeaves).toHaveCount(1);
+    await expect(parentGroupHeader.getByTestId("tree-header-title")).toHaveText("foo");
+    await parentGroupHeader.getByTestId("tree-arrow").click();
+
+    await expect(treeLeaves).toHaveCount(2);
+    await expect(treeLeaves.nth(0).getByTestId("tree-leaf-title")).toHaveText("0 sample passed test");
+    await expect(treeLeaves.nth(0).getByTestId("tree-leaf-order")).toHaveText("1");
+    await expect(treeLeaves.nth(1).getByTestId("tree-leaf-title")).toHaveText("1 sample failed test");
+    await expect(treeLeaves.nth(1).getByTestId("tree-leaf-order")).toHaveText("1");
+  });
+});
diff --git a/packages/e2e/test/allure-awesome/tree/stories.test.ts b/packages/e2e/test/allure-awesome/tree/stories.test.ts
new file mode 100644
index 00000000..6f973e4f
--- /dev/null
+++ b/packages/e2e/test/allure-awesome/tree/stories.test.ts
@@ -0,0 +1,68 @@
+import { expect, test } from "@playwright/test";
+import { Stage, Status } from "allure-js-commons";
+import { layer } from "allure-js-commons";
+import { type ReportBootstrap, boostrapReport } from "../../utils/index.js";
+
+let bootstrap: ReportBootstrap;
+
+test.describe("stories", () => {
+  test.beforeAll(async () => {
+    bootstrap = await boostrapReport({
+      reportConfig: {
+        name: "Sample allure report",
+        appendHistory: false,
+        history: undefined,
+        historyPath: undefined,
+        knownIssuesPath: undefined,
+      },
+      pluginConfig: {
+        groupBy: ["story"],
+      },
+      testResults: [
+        {
+          name: "0 sample passed test",
+          fullName: "sample.js#0 sample passed test",
+          status: Status.PASSED,
+          stage: Stage.FINISHED,
+          start: 1000,
+          labels: [{ name: "story", value: "foo" }],
+        },
+        {
+          name: "1 sample failed test",
+          fullName: "sample.js#1 sample failed test",
+          status: Status.FAILED,
+          stage: Stage.FINISHED,
+          start: 5000,
+          statusDetails: {
+            message: "Assertion error: Expected 1 to be 2",
+            trace: "failed test trace",
+          },
+        },
+      ],
+    });
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await layer("e2e");
+    await page.goto(bootstrap.url);
+  });
+
+  test.afterAll(async () => {
+    await bootstrap?.shutdown?.();
+  });
+
+  test("stories groups are displayed", async ({ page }) => {
+    const treeLeaves = page.getByTestId("tree-leaf");
+    const parentGroupHeader = page.getByTestId("tree-header");
+
+    await expect(treeLeaves).toHaveCount(1);
+    await expect(parentGroupHeader.getByTestId("tree-header-title")).toHaveText("foo");
+    await parentGroupHeader.getByTestId("tree-arrow").click();
+
+    await expect(treeLeaves).toHaveCount(2);
+    await expect(treeLeaves.nth(0).getByTestId("tree-leaf-title")).toHaveText("0 sample passed test");
+    await expect(treeLeaves.nth(0).getByTestId("tree-leaf-order")).toHaveText("1");
+    await expect(treeLeaves.nth(1).getByTestId("tree-leaf-title")).toHaveText("1 sample failed test");
+    await expect(treeLeaves.nth(1).getByTestId("tree-leaf-order")).toHaveText("1");
+  });
+});
diff --git a/packages/e2e/test/allure-awesome/tree/suites.test.ts b/packages/e2e/test/allure-awesome/tree/suites.test.ts
new file mode 100644
index 00000000..34ad60af
--- /dev/null
+++ b/packages/e2e/test/allure-awesome/tree/suites.test.ts
@@ -0,0 +1,140 @@
+import { expect, test } from "@playwright/test";
+import { Stage, Status } from "allure-js-commons";
+import { layer } from "allure-js-commons";
+import { type ReportBootstrap, boostrapReport } from "../../utils/index.js";
+
+let bootstrap: ReportBootstrap;
+
+test.describe("suites", () => {
+  test.afterEach(async () => {
+    await bootstrap?.shutdown?.();
+  });
+
+  test("should display tree groups with a correct suites hierarchy", async ({ page }) => {
+    bootstrap = await boostrapReport({
+      reportConfig: {
+        name: "Sample allure report",
+        appendHistory: false,
+        history: undefined,
+        historyPath: undefined,
+        knownIssuesPath: undefined,
+      },
+      pluginConfig: {
+        groupBy: ["parentSuite", "suite", "subSuite"],
+      },
+      testResults: [
+        {
+          name: "0 sample passed test",
+          fullName: "sample.js#0 sample passed test",
+          status: Status.PASSED,
+          stage: Stage.FINISHED,
+          start: 1000,
+          labels: [
+            { name: "parentSuite", value: "foo" },
+            {
+              name: "suite",
+              value: "bar",
+            },
+            { name: "subSuite", value: "baz" },
+          ],
+        },
+        {
+          name: "1 sample failed test",
+          fullName: "sample.js#1 sample failed test",
+          status: Status.FAILED,
+          stage: Stage.FINISHED,
+          start: 5000,
+          statusDetails: {
+            message: "Assertion error: Expected 1 to be 2",
+            trace: "failed test trace",
+          },
+        },
+      ],
+    });
+
+    await layer("e2e");
+    await page.goto(bootstrap.url);
+
+    const treeLeaves = page.getByTestId("tree-leaf");
+    const parentGroupHeader = page.getByTestId("tree-header");
+
+    await expect(treeLeaves).toHaveCount(1);
+    await expect(parentGroupHeader.getByTestId("tree-header-title")).toHaveText("foo");
+    await parentGroupHeader.getByTestId("tree-arrow").click();
+
+    await expect(parentGroupHeader).toHaveCount(2);
+    await expect(parentGroupHeader.nth(0).getByTestId("tree-header-title")).toHaveText("foo");
+    await expect(parentGroupHeader.nth(1).getByTestId("tree-header-title")).toHaveText("bar");
+    await parentGroupHeader.nth(1).getByTestId("tree-arrow").click();
+
+    await expect(parentGroupHeader).toHaveCount(3);
+    await expect(parentGroupHeader.nth(0).getByTestId("tree-header-title")).toHaveText("foo");
+    await expect(parentGroupHeader.nth(1).getByTestId("tree-header-title")).toHaveText("bar");
+    await expect(parentGroupHeader.nth(2).getByTestId("tree-header-title")).toHaveText("baz");
+    await parentGroupHeader.nth(2).getByTestId("tree-arrow").click();
+
+    await expect(treeLeaves).toHaveCount(2);
+    await expect(treeLeaves.nth(0).getByTestId("tree-leaf-title")).toHaveText("0 sample passed test");
+    await expect(treeLeaves.nth(0).getByTestId("tree-leaf-order")).toHaveText("1");
+    await expect(treeLeaves.nth(1).getByTestId("tree-leaf-title")).toHaveText("1 sample failed test");
+    await expect(treeLeaves.nth(1).getByTestId("tree-leaf-order")).toHaveText("1");
+  });
+
+  test("should not display groups when test results don't have related label", async ({ page }) => {
+    bootstrap = await boostrapReport({
+      reportConfig: {
+        name: "Sample allure report",
+        appendHistory: false,
+        history: undefined,
+        historyPath: undefined,
+        knownIssuesPath: undefined,
+      },
+      testResults: [
+        {
+          name: "0 sample passed test",
+          fullName: "sample.js#0 sample passed test",
+          status: Status.PASSED,
+          stage: Stage.FINISHED,
+          start: 1000,
+          labels: [
+            {
+              name: "suite",
+              value: "foo",
+            },
+            { name: "subSuite", value: "bar" },
+          ],
+        },
+        {
+          name: "1 sample failed test",
+          fullName: "sample.js#1 sample failed test",
+          status: Status.FAILED,
+          stage: Stage.FINISHED,
+          start: 5000,
+          statusDetails: {
+            message: "Assertion error: Expected 1 to be 2",
+            trace: "failed test trace",
+          },
+        },
+      ],
+    });
+
+    await layer("e2e");
+    await page.goto(bootstrap.url);
+
+    const treeLeaves = page.getByTestId("tree-leaf");
+    const parentGroupHeader = page.getByTestId("tree-header");
+
+    await expect(treeLeaves).toHaveCount(1);
+    await expect(parentGroupHeader.getByTestId("tree-header-title")).toHaveText("foo");
+    await parentGroupHeader.getByTestId("tree-arrow").click();
+
+    await expect(parentGroupHeader).toHaveCount(2);
+    await expect(parentGroupHeader.nth(0).getByTestId("tree-header-title")).toHaveText("foo");
+    await expect(parentGroupHeader.nth(1).getByTestId("tree-header-title")).toHaveText("bar");
+    await parentGroupHeader.nth(1).getByTestId("tree-arrow").click();
+
+    await expect(treeLeaves).toHaveCount(2);
+    await expect(treeLeaves.nth(0).getByTestId("tree-leaf-title")).toHaveText("0 sample passed test");
+    await expect(treeLeaves.nth(1).getByTestId("tree-leaf-title")).toHaveText("1 sample failed test");
+  });
+});
diff --git a/packages/plugin-api/src/utils/tree.ts b/packages/plugin-api/src/utils/tree.ts
index add9a817..a592e5d8 100644
--- a/packages/plugin-api/src/utils/tree.ts
+++ b/packages/plugin-api/src/utils/tree.ts
@@ -145,6 +145,36 @@ export const createTreeByLabels = <T = TestResult, L = DefaultTreeLeaf, G = Defa
   );
 };
 
+/**
+ * Omits labels that don't exist in the given test results
+ * If label is present at least in one test result, it will be included
+ * @param labelNames
+ * @param trs
+ * @param labelNamesAccessor
+ */
+export const preciseTreeLabels = <T = TestResult>(
+  labelNames: string[],
+  trs: T[],
+  labelNamesAccessor: (tr: T) => string[] = (tr: T) => (tr as TestResult).labels.map(({ name }) => name),
+) => {
+  const result = new Set<string>();
+
+  for (const tr of trs) {
+    // break the loop if all the labels are found
+    if (labelNames.every((label) => result.has(label))) {
+      break;
+    }
+
+    labelNamesAccessor(tr).forEach((label) => {
+      if (labelNames.includes(label)) {
+        result.add(label);
+      }
+    });
+  }
+
+  return Array.from(result);
+};
+
 /**
  * Mutates the given tree by filtering leaves in each group.
  * Returns the link to the same tree.
diff --git a/packages/plugin-api/test/tree.test.ts b/packages/plugin-api/test/tree.test.ts
index 170649ed..33242926 100644
--- a/packages/plugin-api/test/tree.test.ts
+++ b/packages/plugin-api/test/tree.test.ts
@@ -1,7 +1,14 @@
 import { type TestResult, type TreeData, compareBy, nullsLast, ordinal } from "@allurereport/core-api";
 import { randomUUID } from "node:crypto";
 import { describe, expect, it } from "vitest";
-import { createTreeByLabels, filterTree, filterTreeLabels, sortTree, transformTree } from "../src/index.js";
+import {
+  createTreeByLabels,
+  filterTree,
+  filterTreeLabels,
+  preciseTreeLabels,
+  sortTree,
+  transformTree,
+} from "../src/index.js";
 
 const itResult = (args: Partial<TestResult>): TestResult => ({
   id: randomUUID(),
@@ -352,3 +359,78 @@ describe("filterTreeLabels", () => {
     ).toEqual(["subSuite"]);
   });
 });
+
+describe("preciseTreeLabels", () => {
+  it("should return labels that only exist in the given test results", () => {
+    const tr1 = itResult({
+      name: "tr1",
+      labels: [
+        { name: "parentSuite", value: "A" },
+        { name: "suite", value: "B" },
+        { name: "subSuite", value: "C" },
+      ],
+    });
+    const tr2 = itResult({
+      name: "tr2",
+      labels: [
+        { name: "suite", value: "B" },
+        { name: "subSuite", value: "C" },
+      ],
+    });
+    const tr3 = itResult({
+      name: "tr3",
+      labels: [{ name: "subSuite", value: "C" }],
+    });
+
+    expect(preciseTreeLabels(["parentSuite", "suite", "subSuite"], [tr1, tr2, tr3])).toEqual([
+      "parentSuite",
+      "suite",
+      "subSuite",
+    ]);
+  });
+
+  it("should omit labels that don't exist in the given test results", () => {
+    const tr1 = itResult({
+      name: "tr1",
+      labels: [
+        { name: "suite", value: "B" },
+        { name: "subSuite", value: "C" },
+      ],
+    });
+    const tr2 = itResult({
+      name: "tr2",
+      labels: [
+        { name: "suite", value: "B" },
+        { name: "subSuite", value: "C" },
+      ],
+    });
+    const tr3 = itResult({
+      name: "tr3",
+      labels: [{ name: "subSuite", value: "C" }],
+    });
+
+    expect(preciseTreeLabels(["parentSuite", "suite", "subSuite"], [tr1, tr2, tr3])).toEqual(["suite", "subSuite"]);
+  });
+
+  it("should allow to extract labels from custom data structures via accessor function", () => {
+    const tr1 = {
+      l: [
+        { name: "suite", value: "B" },
+        { name: "subSuite", value: "C" },
+      ],
+    };
+    const tr2 = {
+      l: [
+        { name: "suite", value: "B" },
+        { name: "subSuite", value: "C" },
+      ],
+    };
+    const tr3 = {
+      l: [{ name: "subSuite", value: "C" }],
+    };
+
+    expect(
+      preciseTreeLabels(["parentSuite", "suite", "subSuite"], [tr1, tr2, tr3], ({ l }) => l.map(({ name }) => name)),
+    ).toEqual(["suite", "subSuite"]);
+  });
+});
diff --git a/packages/plugin-awesome/src/plugin.ts b/packages/plugin-awesome/src/plugin.ts
index abaff0a1..aac37ade 100644
--- a/packages/plugin-awesome/src/plugin.ts
+++ b/packages/plugin-awesome/src/plugin.ts
@@ -1,5 +1,6 @@
 import { type EnvironmentItem } from "@allurereport/core-api";
 import type { AllureStore, Plugin, PluginContext } from "@allurereport/plugin-api";
+import { preciseTreeLabels } from "@allurereport/plugin-api";
 import {
   generateAttachmentsFiles,
   generateEnvironmentJson,
@@ -28,13 +29,13 @@ export class AllureAwesomePlugin implements Plugin {
     await generatePieChart(this.#writer!, statistic);
 
     const convertedTrs = await generateTestResults(this.#writer!, store);
-
-    await generateTree(
-      this.#writer!,
-      "tree",
-      groupBy?.length ? groupBy : ["parentSuite", "suite", "subSuite"],
+    const treeLabels = preciseTreeLabels(
+      !groupBy?.length ? ["parentSuite", "suite", "subSuite"] : groupBy,
       convertedTrs,
+      ({ labels }) => labels.map(({ name }) => name),
     );
+
+    await generateTree(this.#writer!, "tree", treeLabels, convertedTrs);
     await generateHistoryDataPoints(this.#writer!, store);
 
     if (environmentItems?.length) {
diff --git a/packages/plugin-classic/src/plugin.ts b/packages/plugin-classic/src/plugin.ts
index fc02de1b..fab59e2f 100644
--- a/packages/plugin-classic/src/plugin.ts
+++ b/packages/plugin-classic/src/plugin.ts
@@ -1,5 +1,5 @@
 import type { EnvironmentItem } from "@allurereport/core-api";
-import type { AllureStore, Plugin, PluginContext } from "@allurereport/plugin-api";
+import { type AllureStore, type Plugin, type PluginContext, preciseTreeLabels } from "@allurereport/plugin-api";
 import { convertTestResult } from "./converters.js";
 import {
   generateAttachmentsData,
@@ -55,9 +55,17 @@ export class Allure2Plugin implements Plugin {
     await generateTestResults(writer, allTr);
 
     const displayedTr = allTr.filter((atr) => !atr.hidden);
+    const treeLabelNamesFactory = (labelNames: string[]) =>
+      preciseTreeLabels(labelNames, displayedTr, (tr) => {
+        if (tr.labels) {
+          return tr.labels.map(({ name }) => name!);
+        }
 
-    await generateTree(writer, "suites", ["parentSuite", "suite", "subSuite"], displayedTr);
-    await generateTree(writer, "behaviors", ["epic", "feature", "story"], displayedTr);
+        return [] as string[];
+      });
+
+    await generateTree(writer, "suites", treeLabelNamesFactory(["parentSuite", "suite", "subSuite"]), displayedTr);
+    await generateTree(writer, "behaviors", treeLabelNamesFactory(["epic", "feature", "story"]), displayedTr);
     await generatePackagesData(writer, displayedTr);
     await generateCategoriesData(writer, displayedTr);
     await generateTimelineData(writer, allTr);