@sentinelqa/playwright-reporter 0.1.51 → 0.1.54

package/dist/reporter.js

@@ -1,5 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 const node_1 = require("@sentinelqa/uploader/node");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
 const env_1 = require("./env");
 const quickDiagnosis_1 = require("./quickDiagnosis");
 const terminalSummary_1 = require("./terminalSummary");
@@ -11,10 +16,107 @@ const colorize = (value, code) => {
         return value;
     return `\u001b[${code}m${value}\u001b[0m`;
 };
-const green = (value) => colorize(value, "32");
-const yellow = (value) => colorize(value, "33");
-const dim = (value) => colorize(value, "2");
+const styleCritical = (value) => colorize(value, "1;31");
+const styleWarning = (value) => colorize(value, "1;33");
+const styleAction = (value) => colorize(value, "1;36");
+const stylePrimary = (value) => colorize(value, "1;97");
+const styleImportant = (value) => colorize(value, "97");
+const styleSecondary = (value) => colorize(value, "2");
 const divider = () => "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━";
+const LABEL_WIDTH = 19;
+const renderRow = (label, value, valueStyle, indent = "") => {
+    const paddedLabel = `${label}:`.padEnd(LABEL_WIDTH);
+    const styledValue = valueStyle ? valueStyle(value) : value;
+    return `${indent}${stylePrimary(paddedLabel)} ${styledValue}`;
+};
+const highlightCounts = (value) => value
+    .replace(/\b(\d+\s+tests?\s+failed)\b/gi, (_, match) => styleCritical(match))
+    .replace(/\b(\d+\s+real\s+issues?)\b/gi, (_, match) => styleWarning(match))
+    .replace(/\b(\d+\s+tests?)\b/gi, (_, match) => styleWarning(match))
+    .replace(/\b(\d+\s+previous\s+runs?)\b/gi, (_, match) => styleSecondary(match))
+    .replace(/\b(\d+\s+passing\s+runs?)\b/gi, (_, match) => styleSecondary(match))
+    .replace(/\b(\d+\s+newly\s+failing)\b/gi, (_, match) => styleWarning(match))
+    .replace(/\b(\d+\s+tests?\s+still\s+failing)\b/gi, (_, match) => styleWarning(match));
+const styleIssueTitle = (value) => stylePrimary(value.replace(/\((\d+\s+tests?)\)/i, (_, match) => `(${styleWarning(match)})`));
+const styleWhereValue = (value) => value.replace(/\b([A-Za-z0-9_.-]+\.[cm]?[jt]sx?:\d+(?::\d+)?)\b/g, (_, match) => styleImportant(match));
+const formatCliLine = (line) => {
+    if (!line.trim())
+        return line;
+    if (line === divider())
+        return styleSecondary(line);
+    if (/^NEW FAILURE/.test(line))
+        return styleCritical(line);
+    if (/^RECURRING FAILURE/.test(line)) {
+        return line.replace(/RECURRING FAILURE/, styleWarning("RECURRING FAILURE")).replace(/\(([^)]+)\)/, (_, inner) => `(${styleSecondary(inner)})`);
+    }
+    if (/^All tests passed$/.test(line))
+        return stylePrimary(line);
+    if (/^❌\s+\d+\s+failures?/.test(line))
+        return styleCritical(line);
+    if (/^\d+\s+tests?\s+failed$/.test(line))
+        return styleCritical(line);
+    if (/^Collapsed into \d+\s+real issue/.test(line))
+        return highlightCounts(line);
+    if (/^\d+\s+tests?\s+in\s+/.test(line))
+        return line;
+    if (/^Issue(?:(?: \d+)?):/.test(line)) {
+        const [head, rest] = line.split(": ", 2);
+        return `${stylePrimary(head)}: ${styleIssueTitle(rest || "")}`;
+    }
+    const rowMatch = line.match(/^(\s*)(What broke|Why|Cause|Where|What changed|Changes since last run|Next|Likely fix|Expected|Received|Confidence|Impact|At risk|Why this matters|Recommendation|Last failure|Status|Artifacts ready|Failing step|Selector|Target state|Report|Blocker):\s*(.*)$/);
+    if (!rowMatch)
+        return line;
+    const [, indent, label, rawValue] = rowMatch;
+    const value = highlightCounts(rawValue);
+    switch (label) {
+        case "What broke":
+            return renderRow(label, value, undefined, indent);
+        case "Why":
+            return renderRow(label, value, undefined, indent);
+        case "Cause":
+            return renderRow(label, rawValue, undefined, indent);
+        case "Where":
+            return renderRow(label, rawValue, styleWhereValue, indent);
+        case "What changed":
+        case "Changes since last run":
+            return renderRow(label, rawValue, styleWarning, indent);
+        case "Next":
+        case "Likely fix":
+            return renderRow(label, rawValue, styleAction, indent);
+        case "Report":
+            return renderRow(label, rawValue, styleAction, indent);
+        case "Expected":
+            return renderRow(label, rawValue, styleImportant, indent);
+        case "Received":
+            return renderRow(label, rawValue, styleCritical, indent);
+        case "Confidence":
+            return renderRow(label, rawValue, /high/i.test(rawValue) ? styleAction : /medium/i.test(rawValue) ? styleWarning : styleSecondary, indent);
+        case "Impact":
+            return renderRow(label, highlightCounts(rawValue), undefined, indent);
+        case "At risk":
+            return renderRow(label, rawValue, styleWarning, indent);
+        case "Why this matters":
+            return renderRow(label, rawValue, undefined, indent);
+        case "Recommendation":
+            return renderRow(label, rawValue, styleAction, indent);
+        case "Last failure":
+            return renderRow(label, rawValue, styleSecondary, indent);
+        case "Status":
+            return renderRow(label, rawValue, styleSecondary, indent);
+        case "Artifacts ready":
+            return renderRow(label, rawValue, styleSecondary, indent);
+        case "Failing step":
+            return renderRow(label, rawValue, styleImportant, indent);
+        case "Selector":
+            return renderRow(label, rawValue, styleImportant, indent);
+        case "Blocker":
+            return renderRow(label, rawValue, styleCritical, indent);
+        case "Target state":
+            return renderRow(label, rawValue, styleWarning, indent);
+        default:
+            return line;
+    }
+};
 const readFinalFailedCount = (playwrightJsonPath) => {
     try {
         const parsed = JSON.parse(require("node:fs").readFileSync(playwrightJsonPath, "utf8"));
@@ -83,22 +185,26 @@ class SentinelReporter {
             !hasCiEnv &&
             !localUploadEnabled;
         const quickDiagnosis = (0, quickDiagnosis_1.buildQuickDiagnosis)(this.options.playwrightJsonPath);
+        const quickDiagnosisStructured = (0, quickDiagnosis_1.buildQuickDiagnosisStructured)(this.options.playwrightJsonPath);
+        const isSetupFailureDiagnosis = Boolean(quickDiagnosis?.lines.some((line) => /^Issue(?:(?: \d+)?): Playwright setup error/.test(line)));
         const finalFailedCount = readFinalFailedCount(this.options.playwrightJsonPath);
         const effectiveFailedCount = typeof finalFailedCount === "number" ? finalFailedCount : this.failedCount;
         const passingSummary = effectiveFailedCount === 0
             ? (0, terminalSummary_1.buildPassingRunSummary)(this.options.playwrightJsonPath, { observedRunDurationMs: Date.now() - this.startedAt })
             : null;
-        const failedRunHistory = effectiveFailedCount > 0 ? (0, runHistory_1.buildFailedRunHistorySummary)(this.options.playwrightJsonPath) : null;
+        const failedRunHistory = effectiveFailedCount > 0 && !isSetupFailureDiagnosis
+            ? (0, runHistory_1.buildFailedRunHistorySummary)(this.options.playwrightJsonPath)
+            : null;
         if (effectiveFailedCount > 0) {
             (0, terminalSummary_1.recordReporterHistorySnapshot)(this.options.playwrightJsonPath);
         }
         console.log("");
         if (passingSummary) {
-            console.log(green("Sentinel run summary"));
-            console.log(divider());
+            console.log(stylePrimary("Sentinel run summary"));
+            console.log(styleSecondary(divider()));
             console.log("");
             for (const line of passingSummary.lines) {
-                console.log(line);
+                console.log(formatCliLine(line));
             }
             console.log("");
             console.log(divider());
@@ -117,34 +223,56 @@ class SentinelReporter {
             return;
         }
         if (quickDiagnosis?.lines.length) {
-            console.log(yellow("Sentinel diagnosis"));
-            console.log(divider());
+            console.log(stylePrimary("Sentinel diagnosis"));
+            console.log(styleSecondary(divider()));
             console.log("");
-            if (failedRunHistory?.passStreakBeforeFailure && failedRunHistory.passStreakBeforeFailure > 0) {
-                console.log(`NEW FAILURE after ${failedRunHistory.passStreakBeforeFailure} passing runs`);
+            if (!isSetupFailureDiagnosis && failedRunHistory?.passStreakBeforeFailure && failedRunHistory.passStreakBeforeFailure > 0) {
+                console.log(formatCliLine(`NEW FAILURE after ${failedRunHistory.passStreakBeforeFailure} passing runs`));
                 console.log("");
             }
-            else if ((failedRunHistory?.recurringCount || 0) > 0) {
-                console.log(`RECURRING FAILURE (${failedRunHistory?.recurringCount} previous runs)`);
+            else if (!isSetupFailureDiagnosis && (failedRunHistory?.recurringCount || 0) > 0) {
+                console.log(formatCliLine(`RECURRING FAILURE (${failedRunHistory?.recurringCount} previous runs)`));
+                if (failedRunHistory?.isDominantRecurringIssue && failedRunHistory?.dominantRecurringIssueTitle) {
+                    console.log(formatCliLine(`Impact: ${failedRunHistory.dominantRecurringIssueTitle} is the most common recent failure in local history`));
+                }
                 console.log("");
             }
             for (const line of quickDiagnosis.lines) {
-                console.log(line);
+                console.log(formatCliLine(line));
             }
             console.log("");
-            console.log(divider());
-            console.log("");
-            if (failedRunHistory?.newFailures && failedRunHistory.newFailures > 0) {
-                console.log(`Impact: ${failedRunHistory.newFailures} newly failing in this run`);
-                console.log("");
-            }
-            else if (failedRunHistory?.stillFailing && failedRunHistory.stillFailing > 0) {
-                console.log(`Impact: ${failedRunHistory.stillFailing} tests still failing`);
+            if (!isSetupFailureDiagnosis) {
+                console.log(styleSecondary(divider()));
                 console.log("");
+                if (failedRunHistory?.newFailures && failedRunHistory.newFailures > 0) {
+                    console.log(formatCliLine(`Impact: ${failedRunHistory.newFailures} newly failing in this run`));
+                    console.log("");
+                }
+                else if (failedRunHistory?.stillFailing && failedRunHistory.stillFailing > 0) {
+                    console.log(formatCliLine(`Impact: ${failedRunHistory.stillFailing} tests still failing`));
+                    if (failedRunHistory?.isDominantRecurringIssue && failedRunHistory?.dominantRecurringIssueCount > 0) {
+                        console.log(formatCliLine(`Impact: Seen in ${failedRunHistory.dominantRecurringIssueCount} recorded failed runs`));
+                    }
+                    console.log("");
+                }
             }
         }
-        console.log("Uploading debug report...");
+        if (isSetupFailureDiagnosis) {
+            return;
+        }
+        console.log(styleSecondary("Uploading debug report..."));
         console.log("");
+        let structuredDiagnosisPath = null;
+        if (quickDiagnosisStructured) {
+            try {
+                structuredDiagnosisPath = node_path_1.default.join(this.options.testResultsDir, "sentinel-structured-diagnosis.json");
+                node_fs_1.default.mkdirSync(this.options.testResultsDir, { recursive: true });
+                node_fs_1.default.writeFileSync(structuredDiagnosisPath, JSON.stringify(quickDiagnosisStructured, null, 2));
+            }
+            catch {
+                structuredDiagnosisPath = null;
+            }
+        }
         const upload = (await (0, node_1.runSentinelUpload)({
             playwrightJsonPath: this.options.playwrightJsonPath,
             playwrightReportDir: this.options.playwrightReportDir,
@@ -154,27 +282,28 @@ class SentinelReporter {
             env: {
                 SENTINEL_REPORTER_PROJECT: this.options.project || undefined,
                 SENTINEL_REPORTER_SILENT: "1",
+                SENTINEL_STRUCTURED_DIAGNOSIS_PATH: structuredDiagnosisPath || undefined,
                 SENTINEL_UPLOAD_LOCAL: usingImplicitLocalPublicMode ? "1" : process.env.SENTINEL_UPLOAD_LOCAL
             }
         }));
         if (upload.exitCode !== 0) {
-            throw new Error(`Sentinel upload failed with exit code ${upload.exitCode}`);
+            return;
         }
         if (!quickDiagnosis?.lines.length && upload.diagnosis?.lines.length) {
-            console.log(yellow("Sentinel diagnosis"));
-            console.log(divider());
+            console.log(stylePrimary("Sentinel diagnosis"));
+            console.log(styleSecondary(divider()));
             console.log("");
             for (const line of upload.diagnosis.lines) {
-                console.log(line);
+                console.log(formatCliLine(line));
             }
             console.log("");
-            console.log(divider());
+            console.log(styleSecondary(divider()));
         }
         console.log("");
-        console.log("Debug report ready");
-        console.log(`  ${upload.shareRunUrl || upload.internalRunUrl}`);
+        console.log(styleAction("Debug report ready"));
+        console.log(formatCliLine(`Next: ${upload.shareRunUrl || upload.internalRunUrl}`));
         if (upload.shareLabel) {
-            console.log(`  ${dim(upload.shareLabel)}`);
+            console.log(`  ${styleSecondary(upload.shareLabel)}`);
         }
     }
 }

package/dist/runHistory.d.ts

@@ -12,6 +12,9 @@ export type FailedRunHistorySummary = {
     stillFailing: number;
     recurringCount: number;
     recurringTitle: string | null;
+    dominantRecurringIssueTitle: string | null;
+    dominantRecurringIssueCount: number;
+    isDominantRecurringIssue: boolean;
 };
 export declare const buildRunDiffSummary: (playwrightJsonPath: string) => RunDiffSummary | null;
 export declare const buildFailedRunHistorySummary: (playwrightJsonPath: string) => FailedRunHistorySummary | null;

package/dist/runHistory.js

@@ -204,6 +204,10 @@ const buildFailedRunHistorySummary = (playwrightJsonPath) => {
     }))
         .sort((a, b) => b.occurrences - a.occurrences);
     const topRecurring = recurringFailures.find((item) => item.occurrences > 0) || null;
+    const topRecurringTotal = topRecurring ? topRecurring.occurrences + 1 : 0;
+    const isDominantRecurringIssue = Boolean(topRecurring &&
+        topRecurringTotal >= 3 &&
+        topRecurringTotal >= Math.ceil(Math.max(failingReporterRuns.length, 1) / 2));
     writeSnapshot(snapshot);
     const lines = [];
     if (passStreakBeforeFailure > 0) {
@@ -220,6 +224,9 @@ const buildFailedRunHistorySummary = (playwrightJsonPath) => {
     }
     if (topRecurring) {
         lines.push(`- Recurring across ${topRecurring.occurrences + 1} recorded failed runs in local history (${topRecurring.failure.title})`);
+        if (isDominantRecurringIssue) {
+            lines.push(`- This is the most common recent failure in local history`);
+        }
     }
     return lines.length
         ? {
@@ -230,7 +237,10 @@ const buildFailedRunHistorySummary = (playwrightJsonPath) => {
             fixedTests,
             stillFailing,
             recurringCount: topRecurring ? topRecurring.occurrences : 0,
-            recurringTitle: topRecurring?.failure.title || null
+            recurringTitle: topRecurring?.failure.title || null,
+            dominantRecurringIssueTitle: topRecurring?.failure.title || null,
+            dominantRecurringIssueCount: topRecurringTotal,
+            isDominantRecurringIssue
         }
         : null;
 };

package/dist/terminalSummary.js

@@ -73,6 +73,56 @@ const medianAbsoluteDeviation = (values) => {
         return null;
     return median(values.map((value) => Math.abs(value - med)));
 };
+const getPrimaryRiskKind = (candidate) => {
+    if (candidate.primaryReason.startsWith("failed in "))
+        return "historical_failures";
+    if (candidate.primaryReason.startsWith("passed after "))
+        return "retry";
+    if (candidate.primaryReason.startsWith("needed retries in "))
+        return "historical_retries";
+    if (candidate.primaryReason.startsWith("took "))
+        return "slowdown";
+    if (candidate.primaryReason.startsWith("has been unusually slow in "))
+        return "repeated_slow";
+    if (candidate.primaryReason.startsWith("used "))
+        return "timeout_pressure";
+    if (candidate.primaryReason.startsWith("is trending slower"))
+        return "trend";
+    if (candidate.retries > 0)
+        return "retry";
+    if (candidate.historicalRetries >= 2)
+        return "historical_retries";
+    if (candidate.ratio !== null && candidate.ratio >= 1.8)
+        return "slowdown";
+    if (candidate.repeatedSlowPasses >= 3)
+        return "repeated_slow";
+    if (candidate.recentTrendRatio !== null && candidate.recentTrendRatio >= 1.5)
+        return "trend";
+    if (candidate.timeoutUtilization !== null && candidate.timeoutUtilization >= 0.85)
+        return "timeout_pressure";
+    if (candidate.historicalFailures >= 5)
+        return "historical_failures";
+    return "generic";
+};
+const isStrongPassRisk = (candidate, lastFailureRunsAgo) => {
+    if (candidate.retries > 0)
+        return true;
+    if (candidate.ratio !== null && candidate.ratio >= 2.0)
+        return true;
+    if (candidate.repeatedSlowPasses >= 3)
+        return true;
+    if (candidate.timeoutUtilization !== null && candidate.timeoutUtilization >= 0.9)
+        return true;
+    if (candidate.historicalRetries >= 2)
+        return true;
+    if (candidate.historicalFailures >= 6 &&
+        lastFailureRunsAgo !== null &&
+        lastFailureRunsAgo <= 2 &&
+        (candidate.ratio !== null || candidate.historicalRetries > 0 || candidate.repeatedSlowPasses > 0)) {
+        return true;
+    }
+    return false;
+};
 const cleanTitlePath = (parts) => {
     const normalized = parts.map((part) => part.trim()).filter(Boolean);
     const withoutUnnamed = normalized.filter((part) => part !== "Unnamed test");
@@ -297,17 +347,33 @@ const buildPassingRunSummary = (playwrightJsonPath, options) => {
             ? `passed after ${test.retries} retr${test.retries === 1 ? 'y' : 'ies'} in this run`
             : historicalRetries >= 2
                 ? `needed retries in ${historicalRetries} of the last 10 passing runs`
-                : recentFailurePressure
-                    ? `failed in ${historicalFailures} of the last 10 runs`
-                    : ratio && ratio >= 1.8
-                        ? `took ${formatShortDuration(test.durationMs)} vs ${formatShortDuration(med)} recent median (${ratio.toFixed(1)}x)`
-                        : repeatedSlowPasses >= 2
-                            ? `has been unusually slow in ${repeatedSlowPasses} of the last 10 passing runs`
-                            : timeoutUtilization && timeoutUtilization >= 0.85
-                                ? `used ${(timeoutUtilization * 100).toFixed(0)}% of its timeout budget`
-                                : recentTrendRatio && recentTrendRatio >= 1.5
-                                    ? `is trending slower over recent runs`
+                : ratio && ratio >= 1.8
+                    ? `took ${formatShortDuration(test.durationMs)} vs ${formatShortDuration(med)} recent median (${ratio.toFixed(1)}x)`
+                    : repeatedSlowPasses >= 2
+                        ? `has been unusually slow in ${repeatedSlowPasses} of the last 10 passing runs`
+                        : timeoutUtilization && timeoutUtilization >= 0.85
+                            ? `used ${(timeoutUtilization * 100).toFixed(0)}% of its timeout budget`
+                            : recentTrendRatio && recentTrendRatio >= 1.5
+                                ? `is trending slower over recent runs`
+                                : recentFailurePressure
+                                    ? `failed in ${historicalFailures} of the last 10 runs`
                                     : `has weak instability signals`;
+        const riskKind = getPrimaryRiskKind({
+            title: test.title,
+            ratio,
+            recentTrendRatio,
+            retries: test.retries,
+            historicalRetries,
+            historicalFailures,
+            repeatedSlowPasses,
+            timeoutUtilization,
+            medianDurationMs: med,
+            currentDurationMs: test.durationMs,
+            score,
+            strongSignal,
+            currentRunSignal,
+            primaryReason
+        });
         if (score > 0) {
             nearFailureCandidates.push({
                 title: test.title,
@@ -323,7 +389,8 @@ const buildPassingRunSummary = (playwrightJsonPath, options) => {
                 score,
                 strongSignal,
                 currentRunSignal,
-                primaryReason
+                primaryReason,
+                riskKind
             });
         }
     }
@@ -333,27 +400,48 @@ const buildPassingRunSummary = (playwrightJsonPath, options) => {
         (right.timeoutUtilization || 0) - (left.timeoutUtilization || 0) ||
         (right.ratio || 0) - (left.ratio || 0));
     const strongNearFailures = nearFailureCandidates.filter((candidate) => candidate.strongSignal &&
-        (candidate.currentRunSignal ||
-            candidate.historicalRetries >= 2 ||
-            candidate.repeatedSlowPasses >= 3 ||
-            (candidate.recentTrendRatio !== null && candidate.recentTrendRatio >= 1.5)) &&
-        candidate.score >= 3);
-    const topNearFailures = strongNearFailures.slice(0, 2);
-    const flakyLookingCount = strongNearFailures.length;
-    const hasActiveRisk = flakyLookingCount > 0;
+        candidate.score >= 3 &&
+        isStrongPassRisk(candidate, lastFailureRunsAgo));
+    const topRisk = strongNearFailures[0] || null;
+    const hasActiveRisk = Boolean(topRisk);
     const totalDurationMs = snapshot.tests.reduce((sum, test) => sum + test.durationMs, 0);
     const displayedRunDurationMs = options?.observedRunDurationMs || snapshot.wallDurationMs || totalDurationMs;
     const lines = ["All tests passed", `${snapshot.passedCount} tests in ${formatDuration(displayedRunDurationMs)}`];
-    if (hasActiveRisk && topNearFailures[0]) {
-        lines.push(`At risk: ${topNearFailures[0].title} ${topNearFailures[0].primaryReason}`);
-        lines.push(topNearFailures[0].retries > 0 || topNearFailures[0].historicalRetries >= 2
-            ? "Why this matters: Similar timing and retry patterns often turn into flaky failures"
-            : "Why this matters: Performance regressions often lead to flaky failures");
+    if (hasActiveRisk && topRisk) {
+        const riskKind = topRisk.riskKind;
+        lines.push(`At risk: ${topRisk.title} ${topRisk.primaryReason}`);
+        if (riskKind === "retry" || riskKind === "historical_retries") {
+            lines.push("Why this matters: Similar retry patterns often turn into flaky failures");
+        }
+        else if (riskKind === "slowdown" || riskKind === "repeated_slow" || riskKind === "trend") {
+            lines.push("Why this matters: Performance regressions often lead to flaky failures");
+        }
+        else if (riskKind === "historical_failures") {
+            lines.push("Why this matters: This test has been failing repeatedly and is likely to regress again");
+        }
+        else if (riskKind === "timeout_pressure") {
+            lines.push("Why this matters: Tests that run close to their timeout budget often become flaky");
+        }
+        else {
+            lines.push("Why this matters: This instability pattern often turns into a future failure");
+        }
         if (lastFailureRunsAgo !== null)
             lines.push(`Last failure: ${lastFailureRunsAgo} runs ago`);
-        lines.push(topNearFailures[0].retries > 0
-            ? "Recommendation: inspect retry behavior or timing around this test"
-            : "Recommendation: monitor the next runs or investigate the slowdown");
+        if (riskKind === "retry" || riskKind === "historical_retries") {
+            lines.push("Recommendation: inspect retry behavior or timing around this test");
+        }
+        else if (riskKind === "slowdown" || riskKind === "repeated_slow" || riskKind === "trend") {
+            lines.push("Recommendation: monitor the next runs or investigate the slowdown");
+        }
+        else if (riskKind === "historical_failures") {
+            lines.push("Recommendation: rerun this test locally and inspect the last failing behavior");
+        }
+        else if (riskKind === "timeout_pressure") {
+            lines.push("Recommendation: inspect timeout pressure or waiting logic in this test");
+        }
+        else {
+            lines.push("Recommendation: monitor the next runs and inspect this test if the pattern repeats");
+        }
     }
     else {
         lines.push("No anomalies detected");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentinelqa/playwright-reporter",
-  "version": "0.1.51",
+  "version": "0.1.54",
   "private": false,
   "description": "Playwright reporter for CI debugging with optional Sentinel cloud dashboards",
   "license": "MIT",
@@ -39,7 +39,7 @@
     "@playwright/test": ">=1.40.0"
   },
   "dependencies": {
-    "@sentinelqa/uploader": "^0.1.35"
+    "@sentinelqa/uploader": "^0.1.38"
   },
   "devDependencies": {
     "@types/node": "^20.19.32",