@sentinelqa/playwright-reporter 0.1.50 → 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.d.ts

@@ -1,5 +1,5 @@
 type DiagnosisSignal = "timeout" | "assertion_mismatch" | "locator_not_found" | "actionability" | "network" | "runtime" | "infra" | "unknown";
-type QuickDiagnosis = {
+export type QuickDiagnosis = {
     lines: string[];
     footer?: string[];
 };

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,31 +1125,29 @@ const buildQuickDiagnosis = (playwrightJsonPath) => {
         const failed = failures[0];
         const suspects = commitWindow.trusted ? rankCommitsForFailure(failed, commitWindow) : [];
         const top = suspects[0];
-        const alt = suspects[1];
-        const lines = [`${formatTitle(failed.title)} failed.`, `What broke: ${(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";
         if (primaryLocation)
             lines.push(`Where: ${withoutPrefix(withoutPrefix(primaryLocation, "Error location:"), "Likely file:")}`);
-        if (failed.firstErrorLine)
-            lines.push(`Error: ${failed.firstErrorLine}`);
-        for (const evidence of buildSecondaryEvidenceLines(failed))
-            lines.push(evidence);
-        if (top) {
-            lines.push(compactCommitLine(top));
-            lines.push(`Why Sentinel picked it: ${compactWhyLine(top)}.`);
-            if (top.touchedFiles.length) {
-                lines.push(`Touched files: ${top.touchedFiles.map((file) => basename(file)).join(", ")}`);
+        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(`What changed: "${top.commit.message}"`);
+            if (top.reasons.length) {
+                lines.push(`Reason: ${compactWhyLine(top)}.`);
             }
-            if (alt)
-                lines.push(alternateCommitLine(alt));
         }
-        lines.push(`Check first: ${checkFirst(failed)}.`);
+        lines.push(`Confidence: ${confidence}`);
+        lines.push("Next:");
+        lines.push(`- ${checkFirst(failed)}`);
         return {
             lines,
-            footer: [
-                ...(top ? [`Confidence: ${confidenceLabel(top.score)}`] : []),
-                ...(commitWindow.trusted ? [`Commits analyzed: ${commitWindow.commits.length}`] : [`Commit blame skipped: ${commitWindow.reason}`])
-            ]
+            footer: []
         };
     }
     const clusterMap = new Map();
@@ -900,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];
@@ -916,29 +1182,36 @@ const buildQuickDiagnosis = (playwrightJsonPath) => {
         const locationValue = clusterLocation
             ? withoutPrefix(clusterLocation, clusterLocation.startsWith("Error locations:") ? "Error locations:" : "Error location:")
             : null;
-        const rootCause = compactRootCauseSummary(cluster);
-        const errorLine = compactErrorLine(cluster.sample);
-        lines.push(`[${index + 1}] ${rootCauseLabel(cluster.sample)} (${cluster.count} tests)`);
-        lines.push(`    Root cause: ${rootCause}`);
-        if (errorLine) {
-            lines.push(`    Error: ${errorLine}`);
-        }
+        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}`);
+            lines.push(`  Where: ${locationValue}`);
+        }
+        for (const evidenceLine of buildClusterEvidenceLines(cluster)) {
+            lines.push(`  ${evidenceLine}`);
         }
-        if (top && top.touchedFiles.length) {
-            lines.push(`    Changed files: ${top.touchedFiles.map((file) => basename(file)).join(", ")}`);
+        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(`  What changed: "${top.commit.message}"`);
+            if (top.reasons.length) {
+                lines.push(`  Reason: ${compactWhyLine(top)}.`);
+            }
         }
-        lines.push(`    Check first: ${clusterCheckFirst(cluster)}.`);
+        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,
-        footer: topCluster
-            ? [
-                ...(topCluster.suspects[0] ? [`Top confidence: ${confidenceLabel(topCluster.suspects[0].score)}`] : []),
-                ...(commitWindow.trusted ? [`Commits analyzed: ${commitWindow.commits.length}`] : [`Commit blame skipped: ${commitWindow.reason}`])
-            ]
-            : []
+        footer: topCluster?.suspects[0] ? [`Confidence: ${confidenceLabel(topCluster.suspects[0].score).toLowerCase()}`] : []
     };
 };
 exports.buildQuickDiagnosis = buildQuickDiagnosis;

package/dist/reporter.js

@@ -11,9 +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"));
@@ -93,22 +188,15 @@ class SentinelReporter {
         }
         console.log("");
         if (passingSummary) {
-            console.log(green("Sentinel run summary"));
+            console.log(stylePrimary("Sentinel run summary"));
+            console.log(styleSecondary(divider()));
+            console.log("");
             for (const line of passingSummary.lines) {
-                console.log(`  ${line}`);
-            }
-            if (passingSummary.risks.length > 0) {
-                console.log("");
-                console.log(yellow("Potential risks"));
-                for (const line of passingSummary.risks) {
-                    console.log(`  ${line}`);
-                }
-            }
-            if (!hasWorkspaceToken) {
-                console.log("");
-                console.log("Activate a free workspace at sentinelqa.com/register");
+                console.log(formatCliLine(line));
             }
             console.log("");
+            console.log(divider());
+            console.log("");
         }
         if (effectiveFailedCount > 0) {
             (0, telemetry_1.emitFailedRunTelemetry)();
@@ -118,31 +206,38 @@ class SentinelReporter {
             return;
         }
         if (hasWorkspaceToken && !hasCiEnv && !localUploadEnabled) {
-            console.log([
-                "Sentinel: Upload skipped.",
-                "Reason: Local workspace uploads require SENTINEL_UPLOAD_LOCAL=1.",
-                "",
-                "Next step:",
-                "- Set SENTINEL_UPLOAD_LOCAL=1 to allow a local workspace upload.",
-                "- Or remove SENTINEL_TOKEN to generate a free public hosted report instead."
-            ].join("\n"));
+            console.log("Uploading debug report skipped");
+            console.log("Set SENTINEL_UPLOAD_LOCAL=1 for local workspace uploads.");
             return;
         }
-        if (hasWorkspaceToken) {
+        if (quickDiagnosis?.lines.length) {
+            console.log(stylePrimary("Sentinel diagnosis"));
+            console.log(styleSecondary(divider()));
             console.log("");
-            console.log(green("✔ Artifacts collected"));
-        }
-        console.log("");
-        if (hasWorkspaceToken) {
-            console.log("Uploading hosted debugging report to Sentinel...");
-        }
-        else if (usingImplicitLocalPublicMode) {
-            console.log("Creating free hosted debug report with Sentinel...");
-            console.log(dim("No API key detected. Using the free public report flow for this local run."));
-        }
-        else {
-            console.log("Creating free hosted debug report with Sentinel...");
+            if (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(formatCliLine(`RECURRING FAILURE (${failedRunHistory?.recurringCount} previous runs)`));
+                console.log("");
+            }
+            for (const line of quickDiagnosis.lines) {
+                console.log(formatCliLine(line));
+            }
+            console.log("");
+            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`));
+                console.log("");
+            }
         }
+        console.log(styleSecondary("Uploading debug report..."));
         console.log("");
         const upload = (await (0, node_1.runSentinelUpload)({
             playwrightJsonPath: this.options.playwrightJsonPath,
@@ -159,42 +254,21 @@ class SentinelReporter {
         if (upload.exitCode !== 0) {
             throw new Error(`Sentinel upload failed with exit code ${upload.exitCode}`);
         }
-        const backendReady = upload.diagnosis?.status === "ready" && Boolean(upload.diagnosis?.lines?.length);
-        const diagnosis = backendReady ? upload.diagnosis : quickDiagnosis;
-        if (diagnosis?.lines.length) {
+        if (!quickDiagnosis?.lines.length && upload.diagnosis?.lines.length) {
+            console.log(stylePrimary("Sentinel diagnosis"));
+            console.log(styleSecondary(divider()));
             console.log("");
-            console.log(yellow("Sentinel diagnosis"));
-            for (const line of diagnosis.lines) {
-                console.log(`  ${dim(line)}`);
-            }
-            if (diagnosis.footer?.length) {
-                console.log("");
-                for (const line of diagnosis.footer) {
-                    console.log(`  ${dim(line)}`);
-                }
+            for (const line of upload.diagnosis.lines) {
+                console.log(formatCliLine(line));
             }
-        }
-        const historyLines = failedRunHistory?.lines || [];
-        const normalizedHistory = backendReady
-            ? historyLines.filter((line) => !line.includes("Seen before:"))
-            : historyLines;
-        if (normalizedHistory.length) {
             console.log("");
-            console.log(yellow("Run context"));
-            for (const line of normalizedHistory) {
-                console.log(`  ${dim(line)}`);
-            }
+            console.log(styleSecondary(divider()));
         }
         console.log("");
-        console.log("View full debug report");
-        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)}`);
-        }
-        if (!hasWorkspaceToken) {
-            console.log("");
-            console.log("Create a free workspace to keep reports private, compare runs, and unlock deeper AI debugging");
-            console.log(`  ${dim("https://sentinelqa.com/register")}`);
+            console.log(`  ${styleSecondary(upload.shareLabel)}`);
         }
     }
 }

package/dist/runHistory.d.ts

@@ -5,6 +5,13 @@ type RunDiffSummary = {
 };
 export type FailedRunHistorySummary = {
     lines: string[];
+    passStreakBeforeFailure: number;
+    previousWasGreen: boolean;
+    newFailures: number;
+    fixedTests: number;
+    stillFailing: number;
+    recurringCount: number;
+    recurringTitle: string | null;
 };
 export declare const buildRunDiffSummary: (playwrightJsonPath: string) => RunDiffSummary | null;
 export declare const buildFailedRunHistorySummary: (playwrightJsonPath: string) => FailedRunHistorySummary | null;

package/dist/runHistory.js

@@ -221,6 +221,17 @@ const buildFailedRunHistorySummary = (playwrightJsonPath) => {
     if (topRecurring) {
         lines.push(`- Recurring across ${topRecurring.occurrences + 1} recorded failed runs in local history (${topRecurring.failure.title})`);
     }
-    return lines.length ? { lines } : null;
+    return lines.length
+        ? {
+            lines,
+            passStreakBeforeFailure,
+            previousWasGreen: Boolean(previousRun && (previousRun.failedCount || 0) === 0),
+            newFailures,
+            fixedTests,
+            stillFailing,
+            recurringCount: topRecurring ? topRecurring.occurrences : 0,
+            recurringTitle: topRecurring?.failure.title || null
+        }
+        : null;
 };
 exports.buildFailedRunHistorySummary = buildFailedRunHistorySummary;

package/dist/terminalSummary.d.ts

@@ -21,7 +21,6 @@ type HistorySnapshot = {
 };
 export type PassingRunSummary = {
     lines: string[];
-    risks: string[];
 };
 type PassingRunSummaryOptions = {
     observedRunDurationMs?: number | null;

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({
@@ -343,56 +374,50 @@ const buildPassingRunSummary = (playwrightJsonPath, options) => {
     const hasActiveRisk = flakyLookingCount > 0;
     const totalDurationMs = snapshot.tests.reduce((sum, test) => sum + test.durationMs, 0);
     const displayedRunDurationMs = options?.observedRunDurationMs || snapshot.wallDurationMs || totalDurationMs;
-    const lines = [
-        `- ${snapshot.passedCount} tests passed in ${formatDuration(displayedRunDurationMs)} of wall time`
-    ];
-    if (hasActiveRisk) {
-        if (retryPassedCount > 0)
-            lines.push(`- Retries detected: ${retryPassedCount}`);
-        lines.push(`- Flaky-looking tests: ${flakyLookingCount}`);
-        if (topNearFailures[0]) {
-            lines.push(`- Most at risk next: ${topNearFailures[0].title} (${topNearFailures[0].primaryReason})`);
+    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}`);
+        if (riskKind === "retry" || riskKind === "historical_retries") {
+            lines.push("Why this matters: Similar retry patterns often turn into flaky failures");
         }
-        if (passStreak > 1)
-            lines.push(`- Pass streak: ${passStreak} runs`);
-        if (lastFailureRunsAgo !== null)
-            lines.push(`- Last failure: ${lastFailureRunsAgo} runs ago`);
-    }
-    else {
-        lines.push(`- Pipeline health: Stable`);
-        if (passStreak > 1)
-            lines.push(`- Pass streak: ${passStreak} runs`);
-        if (lastFailureRunsAgo !== null)
-            lines.push(`- Last failure: ${lastFailureRunsAgo} runs ago`);
-    }
-    lines.push(`- Sentinel active: traces, screenshots, video enabled`);
-    const risks = [];
-    for (const candidate of topNearFailures) {
-        if (candidate.ratio && candidate.ratio >= 1.8) {
-            risks.push(`- ${candidate.title} took ${formatShortDuration(candidate.currentDurationMs)} vs ${formatShortDuration(candidate.medianDurationMs)} recent median (${candidate.ratio.toFixed(1)}x)`);
+        else if (riskKind === "slowdown" || riskKind === "repeated_slow" || riskKind === "trend") {
+            lines.push("Why this matters: Performance regressions often lead to flaky failures");
         }
-        if (candidate.retries > 0) {
-            risks.push(`- ${candidate.title} passed after ${candidate.retries} retr${candidate.retries === 1 ? 'y' : 'ies'}`);
+        else if (riskKind === "historical_failures") {
+            lines.push("Why this matters: This test has been failing repeatedly and is likely to regress again");
         }
-        if (candidate.historicalRetries >= 2) {
-            risks.push(`- ${candidate.title} has needed retries in ${candidate.historicalRetries} of the last 10 passing runs`);
+        else if (riskKind === "timeout_pressure") {
+            lines.push("Why this matters: Tests that run close to their timeout budget often become flaky");
         }
-        if (candidate.repeatedSlowPasses >= 3) {
-            risks.push(`- ${candidate.title} has been unusually slow in ${candidate.repeatedSlowPasses} of the last 10 passing runs`);
+        else {
+            lines.push("Why this matters: This instability pattern often turns into a future failure");
         }
-        if (candidate.recentTrendRatio && candidate.recentTrendRatio >= 1.5) {
-            risks.push(`- ${candidate.title} is trending slower over recent runs`);
+        if (lastFailureRunsAgo !== null)
+            lines.push(`Last failure: ${lastFailureRunsAgo} runs ago`);
+        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");
         }
-        if (candidate.timeoutUtilization && candidate.timeoutUtilization >= 0.65) {
-            risks.push(`- ${candidate.title} used ${(candidate.timeoutUtilization * 100).toFixed(0)}% of its timeout budget`);
+        else if (riskKind === "timeout_pressure") {
+            lines.push("Recommendation: inspect timeout pressure or waiting logic in this test");
         }
-        if (candidate.historicalFailures >= 5 &&
-            lastFailureRunsAgo !== null &&
-            lastFailureRunsAgo <= 3 &&
-            (candidate.currentRunSignal || candidate.historicalRetries >= 2 || candidate.repeatedSlowPasses >= 3)) {
-            risks.push(`- ${candidate.title} failed in ${candidate.historicalFailures} of the last 10 runs`);
+        else {
+            lines.push("Recommendation: monitor the next runs and inspect this test if the pattern repeats");
         }
     }
-    return { lines, risks: Array.from(new Set(risks)).slice(0, 4) };
+    else {
+        lines.push("No anomalies detected");
+        if (lastFailureRunsAgo !== null)
+            lines.push(`Last failure: ${lastFailureRunsAgo} runs ago`);
+        lines.push("Status: Stable");
+    }
+    lines.push("Artifacts ready: traces, screenshots, video");
+    return { lines };
 };
 exports.buildPassingRunSummary = buildPassingRunSummary;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentinelqa/playwright-reporter",
-  "version": "0.1.50",
+  "version": "0.1.53",
   "private": false,
   "description": "Playwright reporter for CI debugging with optional Sentinel cloud dashboards",
   "license": "MIT",