@sentinelqa/playwright-reporter 0.1.51 → 0.1.53

package/README.md

@@ -40,6 +40,46 @@ Debugging Playwright failures usually means downloading traces, screenshots, and
 
 Reporter uploads those artifacts into a single hosted Sentinel run page so you can open one link, inspect failures fast, and share that link with the rest of the team.
 
+## CLI diagnosis
+
+Sentinel is not just a report link.
+
+On failed runs, it prints a compact terminal diagnosis that answers:
+
+1. what broke
+2. why it broke
+3. where to look
+4. what changed
+5. what to do next
+
+The goal is simple:
+
+you should not need to open logs first.
+
+Typical CLI output:
+
+```text
+Sentinel diagnosis
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+NEW FAILURE after 8 passing runs
+
+What broke: 10 tests failed
+Why: collapsed into 2 real issues
+
+Issue 1: UI assertion mismatch (6 tests)
+  Why: getByTestId('metric-pass-rate') showed "82%" instead of "88%"
+  Where: app.spec.ts:43, app.spec.ts:69
+  Expected: 88%
+  Received: 82%
+  What changed: "update analytics cards"
+  Next: verify getByTestId('metric-pass-rate')
+  Impact: 6 tests failing with same root cause
+  Clears: fixing this likely clears 6 of 10 failures
+```
+
+On passed runs, Sentinel stays short and only prints a warning if there is a strong risk signal worth caring about.
+
 ## Why teams use the free version
 
 - Drop one wrapper into `playwright.config.ts` and keep running `npx playwright test`

package/dist/quickDiagnosis.js

@@ -162,6 +162,23 @@ const extractFocusLineFromSnippet = (snippet) => {
         .replace(/^\s*\d+\s*\|\s*/, "")
         .trim() || null;
 };
+const extractFocusLineFromMessage = (message) => {
+    if (!message)
+        return null;
+    const lines = stripAnsi(message).split(/\r?\n/);
+    const marked = lines.find((line) => /^\s*>\s*\d+\s*\|/.test(line));
+    if (marked) {
+        return marked
+            .replace(/^\s*>\s*/, "")
+            .replace(/^\s*\d+\s*\|\s*/, "")
+            .trim() || null;
+    }
+    const expectLine = lines.find((line) => /\b(await\s+)?expect\(/.test(line));
+    if (expectLine)
+        return expectLine.trim();
+    const stepLine = lines.find((line) => /\b(getBy|locator\(|page\.)/.test(line));
+    return stepLine?.trim() || null;
+};
 const parseCommitLine = (line) => {
     const [sha, author, message] = line.split("\u001f");
     if (!sha)
@@ -208,12 +225,28 @@ const normalizeStatus = (status) => {
         return "passed";
     return "skipped";
 };
+const errorRichness = (error) => {
+    if (!error)
+        return -1;
+    const message = String(error.message || error.stack || error.value || "");
+    let score = message.length;
+    if (error.location?.file)
+        score += 200;
+    if (/locator\.|Call log:|intercepts pointer events|waiting for|getBy|at .*:\d+:\d+/i.test(message))
+        score += 400;
+    if (/Test timeout of \d+ms exceeded\.$/i.test(stripAnsi(message).trim()))
+        score -= 300;
+    return score;
+};
+const selectBestError = (result) => {
+    const candidates = [result.error, ...(result.errors || [])].filter(Boolean);
+    if (!candidates.length)
+        return null;
+    return candidates.sort((a, b) => errorRichness(b) - errorRichness(a))[0] || null;
+};
 const toMessage = (result) => {
-    const direct = result.error?.message || result.error?.stack || result.error?.value || null;
-    if (direct)
-        return stripAnsi(String(direct));
-    const first = result.errors?.find(Boolean);
-    return first ? stripAnsi(String(first.message || first.stack || first.value || "")) : "";
+    const best = selectBestError(result);
+    return best ? stripAnsi(String(best.message || best.stack || best.value || "")) : "";
 };
 const classifySignal = (message) => {
     const lower = message.toLowerCase();
@@ -339,6 +372,56 @@ const describeDomState = (failure) => {
     }
     return null;
 };
+const dominantValue = (values) => {
+    const counts = new Map();
+    for (const value of values) {
+        const normalized = (value || "").trim();
+        if (!normalized)
+            continue;
+        counts.set(normalized, (counts.get(normalized) || 0) + 1);
+    }
+    const sorted = Array.from(counts.entries()).sort((a, b) => b[1] - a[1]);
+    if (!sorted.length)
+        return null;
+    return sorted[0][0];
+};
+const dominantFocusLine = (failures) => dominantValue(failures.map((failure) => failure.codeContext?.focusLine || null));
+const timeoutState = (failure) => {
+    const dom = failure.domCapture;
+    if (!dom)
+        return "unknown";
+    if (dom.targetFound === false || dom.matchedCount === 0)
+        return "missing";
+    if (dom.visible === false)
+        return "hidden";
+    if (dom.enabled === false)
+        return "disabled";
+    if (dom.targetFound === true && dom.visible === true)
+        return "present";
+    return "unknown";
+};
+const sharedTimeoutEvidence = (failures) => {
+    const timeoutFailures = failures.filter((failure) => failure.signal === "timeout");
+    return {
+        action: dominantValue(timeoutFailures.map((failure) => failure.codeContext?.action || null)),
+        locator: dominantValue(timeoutFailures.map((failure) => failure.locator || null)),
+        state: dominantValue(timeoutFailures.map((failure) => timeoutState(failure))) || "unknown"
+    };
+};
+const timeoutStateLabel = (state) => {
+    switch (state) {
+        case "missing":
+            return "locator never appeared";
+        case "hidden":
+            return "found but hidden";
+        case "disabled":
+            return "found but disabled";
+        case "present":
+            return "found and visible before timeout";
+        default:
+            return null;
+    }
+};
 const buildTouchedFileReason = (label, files) => `${label}: ${files.slice(0, 2).map((file) => basename(file)).join(", ")}`;
 const commitTouchedFailure = (commit, failure) => {
     const reasons = [];
@@ -455,8 +538,12 @@ const flattenFailedCases = (node, titlePath = []) => {
             timeoutBudgetMs: typeof test.timeout === "number" ? test.timeout : null,
             codeContext: loadCodeContext(finalResult),
             domCapture: loadDomCapture(finalResult),
-            errorLocation: finalResult.error?.location || finalResult.errors?.find(Boolean)?.location || null,
-            errorSnippet: finalResult.error?.snippet || null
+            errorLocation: selectBestError(finalResult)?.location ||
+                finalResult.error?.location ||
+                finalResult.errors?.find((item) => item?.location)?.location ||
+                test.location ||
+                null,
+            errorSnippet: selectBestError(finalResult)?.snippet || finalResult.error?.snippet || null
         }));
     }
     return failures;
@@ -546,13 +633,13 @@ const rootCauseLabel = (failure) => {
 };
 const describeFailure = (failure) => {
     if (failure.signal === "assertion_mismatch" && failure.locator && failure.expected && failure.received) {
-        return `${failure.locator} showed "${failure.received}" instead of "${failure.expected}".`;
+        return `${compactLocator(failure.locator)} showed "${truncateValue(failure.received, 72)}" instead of "${truncateValue(failure.expected, 40)}".`;
     }
     if (failure.signal === "locator_not_found" && failure.locator) {
-        return `${failure.locator} was not found when the test expected it to be available.`;
+        return `${compactLocator(failure.locator)} was not found when the test expected it to be available.`;
     }
     if (failure.signal === "actionability" && failure.locator) {
-        return `${failure.locator} was found but was not actionable when the interaction ran.`;
+        return `${compactLocator(failure.locator)} was found but was not actionable when the interaction ran.`;
     }
     if (failure.signal === "network") {
         return failure.apiHint
@@ -593,7 +680,25 @@ const describeCluster = (cluster) => {
         return `${cluster.count} tests failed behind the same network or API signal.`;
     }
     if (cluster.count > 1 && failure.signal === "timeout") {
-        return `${cluster.count} tests timed out behind the same blocked state transition.`;
+        const evidence = sharedTimeoutEvidence(cluster.failures);
+        const action = evidence.action ? evidence.action.trim() : "the expected interaction";
+        const locator = evidence.locator ? compactLocator(evidence.locator) : "the target element";
+        if (evidence.state === "missing") {
+            return `${cluster.count} tests timed out because ${locator} never appeared before ${action}.`;
+        }
+        if (evidence.state === "hidden") {
+            return `${cluster.count} tests timed out because ${locator} stayed hidden and blocked ${action}.`;
+        }
+        if (evidence.state === "disabled") {
+            return `${cluster.count} tests timed out because ${locator} stayed disabled and blocked ${action}.`;
+        }
+        if (evidence.state === "present" && evidence.action) {
+            return `${cluster.count} tests timed out because ${action} on ${locator} never completed even though the target was present.`;
+        }
+        if (evidence.action && evidence.locator) {
+            return `${cluster.count} tests timed out on the same ${action} step for ${locator}.`;
+        }
+        return `${cluster.count} tests timed out while waiting for the same UI state change to complete.`;
     }
     if (cluster.count > 1 && failure.signal === "infra") {
         return `${cluster.count} tests failed behind the same browser or CI instability signal.`;
@@ -610,8 +715,57 @@ const clusterCheckFirst = (cluster) => {
         }
         return "inspect the shared retry/flaky helper or intentional throw in these tests before opening the trace";
     }
+    if (failure.signal === "timeout") {
+        const evidence = sharedTimeoutEvidence(cluster.failures);
+        const locator = evidence.locator ? compactLocator(evidence.locator) : "the target element";
+        if (evidence.state === "missing") {
+            return `make ${locator} render before the blocked step`;
+        }
+        if (evidence.state === "hidden") {
+            return `remove the condition keeping ${locator} hidden before the action`;
+        }
+        if (evidence.state === "disabled") {
+            return `enable ${locator} before the action runs`;
+        }
+        if (evidence.state === "present" && evidence.action && evidence.locator) {
+            return `fix what blocks ${evidence.action} on ${compactLocator(evidence.locator)} (overlay or pointer interception is likely)`;
+        }
+        if (failure.codeContext?.focusLine) {
+            return `inspect the waiting assertion or step: ${failure.codeContext.focusLine.trim()}`;
+        }
+        if (failure.likelyFile) {
+            return `inspect the waiting assertion or blocked state transition in ${basename(failure.likelyFile)}`;
+        }
+    }
     return checkFirst(failure);
 };
+const buildClusterEvidenceLines = (cluster) => {
+    const failure = cluster.sample;
+    const lines = [];
+    if (failure.signal === "timeout") {
+        const evidence = sharedTimeoutEvidence(cluster.failures);
+        const focusLine = dominantFocusLine(cluster.failures);
+        if (focusLine)
+            lines.push(`Failing code: ${focusLine.trim()}`);
+        if (evidence.action)
+            lines.push(`Failing step: ${evidence.action}`);
+        if (evidence.locator)
+            lines.push(`Selector: ${compactLocator(evidence.locator)}`);
+        const stateLabel = timeoutStateLabel(evidence.state);
+        if (stateLabel)
+            lines.push(`Target state: ${stateLabel}`);
+        return lines.slice(0, 4);
+    }
+    const focusLine = dominantFocusLine(cluster.failures);
+    if (focusLine)
+        lines.push(`Failing code: ${focusLine.trim()}`);
+    for (const line of buildSecondaryEvidenceLines(failure)) {
+        if (lines.includes(line))
+            continue;
+        lines.push(line);
+    }
+    return lines.slice(0, 4);
+};
 const formatAffectedTests = (titles) => {
     const unique = Array.from(new Set(titles.map((title) => shortenTitle(title)))).slice(0, 3);
     if (!unique.length)
@@ -674,6 +828,18 @@ const buildEvidenceLines = (failure) => {
     return lines.slice(0, 4);
 };
 const withoutPrefix = (value, prefix) => value.startsWith(prefix) ? value.slice(prefix.length).trim() : value;
+const truncateValue = (value, max = 96) => {
+    if (!value)
+        return null;
+    const compact = value.replace(/\s+/g, " ").trim();
+    if (compact.length <= max)
+        return compact;
+    return `${compact.slice(0, max - 1)}…`;
+};
+const compactLocator = (value) => {
+    const compact = truncateValue(value, 40);
+    return compact || "target element";
+};
 const buildSecondaryEvidenceLines = (failure) => buildEvidenceLines(failure)
     .filter((line) => !line.startsWith("Error location:") && !line.startsWith("Likely file:"))
     .slice(0, 3);
@@ -704,6 +870,65 @@ const compactRootCauseSummary = (cluster) => {
     }
     return describeCluster(cluster);
 };
+const compactIssueTitle = (cluster) => {
+    const failure = cluster.sample;
+    const locator = compactLocator(failure.locator);
+    switch (failure.signal) {
+        case "assertion_mismatch":
+            return failure.locator ? `Assertion mismatch (${locator})` : "Assertion mismatch";
+        case "locator_not_found":
+            return failure.locator ? `Missing locator (${locator})` : "Missing locator";
+        case "actionability":
+            return failure.locator ? `Blocked interaction (${locator})` : "Blocked interaction";
+        case "network":
+            return failure.apiHint ? `Network/API failure (${truncateValue(failure.apiHint, 28)})` : "Network/API failure";
+        case "timeout":
+            return failure.locator ? `Timeout waiting on ${locator}` : "Timeout waiting for state change";
+        case "runtime":
+            return /retry|flaky/i.test(failure.message) ? "Test-side throw" : "Runtime error";
+        case "infra":
+            return "Browser/CI instability";
+        default:
+            return rootCauseLabel(failure);
+    }
+};
+const clusterCauseLine = (cluster) => {
+    const failure = cluster.sample;
+    if (failure.signal === "assertion_mismatch") {
+        return failure.locator
+            ? `Same assertion mismatch on ${compactLocator(failure.locator)}`
+            : "Same assertion mismatch across these tests";
+    }
+    if (failure.signal === "locator_not_found") {
+        return failure.locator
+            ? `${compactLocator(failure.locator)} is missing or changed in each failure`
+            : "Same missing or changed locator across these tests";
+    }
+    if (failure.signal === "actionability") {
+        return failure.locator
+            ? `${compactLocator(failure.locator)} is present but blocked in each failure`
+            : "Same actionability problem across these tests";
+    }
+    return compactRootCauseSummary(cluster);
+};
+const strongerClusterNext = (cluster) => {
+    const failure = cluster.sample;
+    if (failure.signal === "assertion_mismatch") {
+        if (failure.locator && failure.apiHint) {
+            return `check ${compactLocator(failure.locator)} or the data returned by ${truncateValue(failure.apiHint, 36)}`;
+        }
+        if (failure.locator) {
+            return `check ${compactLocator(failure.locator)} or the data source behind it`;
+        }
+    }
+    if (failure.signal === "locator_not_found" && failure.locator) {
+        return `check whether ${compactLocator(failure.locator)} changed or no longer renders`;
+    }
+    if (failure.signal === "actionability" && failure.locator) {
+        return `check what blocks ${compactLocator(failure.locator)} from becoming actionable`;
+    }
+    return clusterCheckFirst(cluster);
+};
 const compactErrorLine = (failure) => {
     if (!failure.firstErrorLine)
         return null;
@@ -736,10 +961,29 @@ const parseFailureFacts = (title, titlePath, message, status, file = null, optio
             file: options.codeContext.file || fallbackCodeContext?.file || null,
             line: options.codeContext.line ?? fallbackCodeContext?.line ?? null,
             column: options.codeContext.column ?? fallbackCodeContext?.column ?? null,
-            focusLine: options.codeContext.focusLine || fallbackCodeContext?.focusLine || null,
+            focusLine: options.codeContext.focusLine || fallbackCodeContext?.focusLine || extractFocusLineFromMessage(message) || null,
             found: options.codeContext.found ?? fallbackCodeContext?.found ?? false
         }
-        : fallbackCodeContext || null;
+        : fallbackCodeContext
+            ? {
+                ...fallbackCodeContext,
+                focusLine: fallbackCodeContext.focusLine || extractFocusLineFromMessage(message) || null
+            }
+            : {
+                file: fallbackLocation?.file || file || null,
+                line: typeof fallbackLocation?.line === "number" ? fallbackLocation.line : null,
+                column: typeof fallbackLocation?.column === "number" ? fallbackLocation.column : null,
+                action: null,
+                locator: null,
+                expectedText: null,
+                timeoutMs: null,
+                apiCall: null,
+                assertion: null,
+                methodName: null,
+                focusLine: extractFocusLineFromMessage(message),
+                previousActionLine: null,
+                found: Boolean(fallbackLocation?.file || extractFocusLineFromMessage(message))
+            };
     const domCapture = options?.domCapture || null;
     const locator = extractLocator(message) || codeContext?.locator || domCapture?.locator || null;
     const expected = extractExpected(message) || codeContext?.expectedText || domCapture?.expectedText || null;
@@ -805,6 +1049,27 @@ const buildSimilarityKey = (failure) => {
             locationKey
         ].join('|');
     }
+    if (failure.signal === "assertion_mismatch") {
+        return [
+            failure.signal,
+            failure.locator || failure.likelyModule || basename(failure.likelyFile) || "unknown-target",
+            basename(failure.likelyFile) || "unknown-file"
+        ].join("|");
+    }
+    if (failure.signal === "timeout" || failure.signal === "actionability" || failure.signal === "locator_not_found") {
+        return [
+            failure.signal,
+            failure.locator || failure.codeContext?.action || failure.likelyModule || "unknown-target",
+            basename(failure.likelyFile) || "unknown-file"
+        ].join("|");
+    }
+    if (failure.signal === "network") {
+        return [
+            failure.signal,
+            failure.apiHint || failure.likelyModule || "unknown-api",
+            basename(failure.likelyFile) || "unknown-file"
+        ].join("|");
+    }
     if (failure.locator || failure.expected || failure.received || failure.apiHint) {
         return [
             failure.signal,
@@ -860,22 +1125,26 @@ const buildQuickDiagnosis = (playwrightJsonPath) => {
         const failed = failures[0];
         const suspects = commitWindow.trusted ? rankCommitsForFailure(failed, commitWindow) : [];
         const top = suspects[0];
-        const lines = [`Test: ${shortenTitle(failed.title)}`, `Likely cause: ${(0, exports.describeFailure)(failed)}`];
+        const lines = [`What broke: ${shortenTitle(failed.title)}`, `Why: ${(0, exports.describeFailure)(failed)}`];
         const primaryLocation = buildLocationLine(failed);
         const confidence = top ? confidenceLabel(top.score).toLowerCase() : "medium";
-        lines.push(`Confidence: ${confidence}`);
+        if (primaryLocation)
+            lines.push(`Where: ${withoutPrefix(withoutPrefix(primaryLocation, "Error location:"), "Likely file:")}`);
+        if (failed.codeContext?.action)
+            lines.push(`Failing step: ${failed.codeContext.action}`);
+        if (failed.expected)
+            lines.push(`Expected: ${truncateValue(failed.expected)}`);
+        if (failed.received)
+            lines.push(`Received: ${truncateValue(failed.received)}`);
         if (top && top.score >= 0.62) {
-            lines.push(`Likely introduced in: "${top.commit.message}"`);
+            lines.push(`What changed: "${top.commit.message}"`);
             if (top.reasons.length) {
                 lines.push(`Reason: ${compactWhyLine(top)}.`);
             }
         }
-        lines.push("Check first:");
+        lines.push(`Confidence: ${confidence}`);
+        lines.push("Next:");
         lines.push(`- ${checkFirst(failed)}`);
-        if (primaryLocation)
-            lines.push(`Where: ${withoutPrefix(withoutPrefix(primaryLocation, "Error location:"), "Likely file:")}`);
-        if (failed.codeContext?.action)
-            lines.push(`Failing step: ${failed.codeContext.action}`);
         return {
             lines,
             footer: []
@@ -894,14 +1163,17 @@ const buildQuickDiagnosis = (playwrightJsonPath) => {
         count: clusterFailures.length,
         sample: clusterFailures[0],
         titles: clusterFailures.map((item) => item.title),
-        suspects: commitWindow.trusted ? buildClusterSuspects(clusterFailures, commitWindow) : []
+        suspects: commitWindow.trusted ? buildClusterSuspects(clusterFailures, commitWindow) : [],
+        failures: clusterFailures
     }))
-        .sort((a, b) => b.count - a.count)
+        .sort((a, b) => b.count - a.count ||
+        ((b.suspects[0]?.score || 0) - (a.suspects[0]?.score || 0)) ||
+        (b.sample.signal === "assertion_mismatch" ? 1 : 0) - (a.sample.signal === "assertion_mismatch" ? 1 : 0))
         .slice(0, 2);
     const topCluster = clusters[0];
     const lines = [
-        `${failures.length} tests failed.`,
-        `Collapsed into ${clusters.length} likely root cause${clusters.length === 1 ? "" : "s"}:`
+        `${failures.length} tests failed`,
+        `Collapsed into ${clusters.length} real issue${clusters.length === 1 ? "" : "s"}`
     ];
     for (const [index, cluster] of clusters.entries()) {
         const clusterFailures = clusterMap.get(cluster.key) || [cluster.sample];
@@ -910,20 +1182,32 @@ const buildQuickDiagnosis = (playwrightJsonPath) => {
         const locationValue = clusterLocation
             ? withoutPrefix(clusterLocation, clusterLocation.startsWith("Error locations:") ? "Error locations:" : "Error location:")
             : null;
-        const rootCause = cluster.count === 1 ? (0, exports.describeFailure)(cluster.sample) : compactRootCauseSummary(cluster);
-        lines.push(`[${index + 1}] ${rootCauseLabel(cluster.sample)} (${cluster.count} tests)`);
-        lines.push(`    Likely cause: ${rootCause}`);
+        const rootCause = cluster.count === 1 ? (0, exports.describeFailure)(cluster.sample) : clusterCauseLine(cluster);
+        lines.push(`Issue ${index + 1}: ${compactIssueTitle(cluster)} (${cluster.count} test${cluster.count === 1 ? "" : "s"})`);
+        lines.push(`  Cause: ${rootCause}`);
+        if (locationValue) {
+            lines.push(`  Where: ${locationValue}`);
+        }
+        for (const evidenceLine of buildClusterEvidenceLines(cluster)) {
+            lines.push(`  ${evidenceLine}`);
+        }
+        if (cluster.sample.expected) {
+            lines.push(`  Expected: ${truncateValue(cluster.sample.expected)}`);
+        }
+        if (cluster.sample.received) {
+            lines.push(`  Received: ${truncateValue(cluster.sample.received)}`);
+        }
         if (top && top.score >= 0.62) {
-            lines.push(`    Likely introduced in: "${top.commit.message}"`);
+            lines.push(`  What changed: "${top.commit.message}"`);
             if (top.reasons.length) {
-                lines.push(`    Reason: ${compactWhyLine(top)}.`);
+                lines.push(`  Reason: ${compactWhyLine(top)}.`);
             }
         }
-        lines.push(`    Check first: ${clusterCheckFirst(cluster)}.`);
-        if (locationValue) {
-            lines.push(`    Where: ${locationValue}`);
-        }
-        lines.push(`    Shared impact: ${cluster.count} test${cluster.count === 1 ? "" : "s"} failing with ${cluster.count === 1 ? "this" : "same"} root cause`);
+        lines.push(`  Next: ${strongerClusterNext(cluster)}.`);
+        lines.push(`  Impact: ${cluster.count} test${cluster.count === 1 ? "" : "s"} failing with ${cluster.count === 1 ? "this" : "same"} root cause`);
+        lines.push(`  Clears: fixing this likely clears ${cluster.count} of ${failures.length} failures`);
+        if (index < clusters.length - 1)
+            lines.push("");
     }
     return {
         lines,

package/dist/reporter.js

@@ -11,10 +11,104 @@ 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 styleSecondary = (value) => colorize(value, "2");
 const divider = () => "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━";
+const LABEL_WIDTH = 10;
+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) => 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) => stylePrimary(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 (/^\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|Next|Expected|Received|Confidence|Impact|At risk|Why this matters|Recommendation|Last failure|Status|Artifacts ready|Failing step|Failing code|Selector|Target state|Clears|Report):\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, value, undefined, indent);
+        case "Where":
+            return renderRow(label, rawValue, styleWhereValue, indent);
+        case "What changed":
+            return renderRow(label, rawValue, styleWarning, indent);
+        case "Next":
+            return renderRow(label, rawValue, styleAction, indent);
+        case "Report":
+            return renderRow(label, rawValue, styleAction, indent);
+        case "Expected":
+            return renderRow(label, rawValue, stylePrimary, 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, stylePrimary, indent);
+        case "Failing code":
+            return renderRow(label, rawValue, stylePrimary, indent);
+        case "Selector":
+            return renderRow(label, rawValue, stylePrimary, indent);
+        case "Target state":
+            return renderRow(label, rawValue, styleWarning, indent);
+        case "Clears":
+            return renderRow(label, highlightCounts(rawValue), styleWarning, indent);
+        default:
+            return line;
+    }
+};
 const readFinalFailedCount = (playwrightJsonPath) => {
     try {
         const parsed = JSON.parse(require("node:fs").readFileSync(playwrightJsonPath, "utf8"));
@@ -94,11 +188,11 @@ class SentinelReporter {
         }
         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,33 +211,33 @@ 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`);
+                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)`);
+                console.log(formatCliLine(`RECURRING FAILURE (${failedRunHistory?.recurringCount} previous runs)`));
                 console.log("");
             }
             for (const line of quickDiagnosis.lines) {
-                console.log(line);
+                console.log(formatCliLine(line));
             }
             console.log("");
-            console.log(divider());
+            console.log(styleSecondary(divider()));
             console.log("");
             if (failedRunHistory?.newFailures && failedRunHistory.newFailures > 0) {
-                console.log(`Impact: ${failedRunHistory.newFailures} newly failing in this run`);
+                console.log(formatCliLine(`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`);
+                console.log(formatCliLine(`Impact: ${failedRunHistory.stillFailing} tests still failing`));
                 console.log("");
             }
         }
-        console.log("Uploading debug report...");
+        console.log(styleSecondary("Uploading debug report..."));
         console.log("");
         const upload = (await (0, node_1.runSentinelUpload)({
             playwrightJsonPath: this.options.playwrightJsonPath,
@@ -161,20 +255,20 @@ class SentinelReporter {
             throw new Error(`Sentinel upload failed with exit code ${upload.exitCode}`);
         }
         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/terminalSummary.js

@@ -73,6 +73,37 @@ 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 cleanTitlePath = (parts) => {
     const normalized = parts.map((part) => part.trim()).filter(Boolean);
     const withoutUnnamed = normalized.filter((part) => part !== "Unnamed test");
@@ -297,16 +328,16 @@ 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`;
         if (score > 0) {
             nearFailureCandidates.push({
@@ -345,15 +376,40 @@ const buildPassingRunSummary = (playwrightJsonPath, options) => {
     const displayedRunDurationMs = options?.observedRunDurationMs || snapshot.wallDurationMs || totalDurationMs;
     const lines = ["All tests passed", `${snapshot.passedCount} tests in ${formatDuration(displayedRunDurationMs)}`];
     if (hasActiveRisk && topNearFailures[0]) {
+        const riskKind = getPrimaryRiskKind(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 (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.53",
   "private": false,
   "description": "Playwright reporter for CI debugging with optional Sentinel cloud dashboards",
   "license": "MIT",