@sentinelqa/playwright-reporter 0.1.54 → 0.1.57

package/dist/quickDiagnosis.js

@@ -290,33 +290,6 @@ const extractLocator = (message) => {
     const callLine = message.match(/(getByTestId|getByRole|getByText|getByLabel|getByPlaceholder|getByTitle|locator)\([^)]+\)/);
     return callLine?.[0] || null;
 };
-const normalizedUrlPath = (value) => {
-    if (!value)
-        return null;
-    try {
-        const parsed = new URL(value);
-        return parsed.pathname || null;
-    }
-    catch {
-        return value.replace(/^https?:\/\/[^/]+/i, "").split("?")[0] || value;
-    }
-};
-const canonicalLocatorForFailure = (failure) => failure.domCapture?.normalizedLocator ||
-    failure.locator ||
-    failure.codeContext?.locator ||
-    null;
-const pageErrorFingerprint = (failure) => normalizeMessageFingerprint(failure.domCapture?.recentPageErrors?.[0] ||
-    failure.domCapture?.recentConsoleErrors?.[0]?.text ||
-    "");
-const requestFingerprint = (failure) => {
-    const request = failedRequestFromDomCapture(failure.domCapture);
-    if (!request)
-        return null;
-    const method = request.method || "REQUEST";
-    const url = normalizedUrlPath(request.url) || request.url || "unknown-request";
-    const status = typeof request.status === "number" ? String(request.status) : request.failure || "failed";
-    return `${method} ${url} ${status}`;
-};
 const extractExpected = (message) => {
     const match = message.match(/Expected substring:\s*"([^"]+)"/i) ||
         message.match(/Expected string:\s*"([^"]+)"/i) ||
@@ -627,26 +600,6 @@ const blockedActionSubtype = (failure, verdict) => {
         return "disabled";
     return "generic";
 };
-const blockerGroupingKey = (failure, verdict) => {
-    const subtype = blockedActionSubtype(failure, verdict);
-    const blocker = (verdict?.blocker || "").toLowerCase().replace(/\s+/g, " ").trim();
-    if (!blocker)
-        return null;
-    return `${subtype}|${blocker}`;
-};
-const sharedBlockedClusterSubtype = (cluster) => {
-    const subtypes = cluster.failures
-        .map((failure) => blockedActionSubtype(failure, blockedVerdictForFailure(failure)))
-        .filter(Boolean);
-    return dominantValue(subtypes) || null;
-};
-const isMultiSelectorBlockedCluster = (cluster) => {
-    const selectors = new Set(cluster.failures.map((item) => compactLocator(item.locator)).filter(Boolean));
-    if (selectors.size <= 1)
-        return false;
-    const subtype = sharedBlockedClusterSubtype(cluster);
-    return subtype === "overlay" || subtype === "strict_mode" || subtype === "detached" || subtype === "offscreen" || subtype === "focus";
-};
 const extractStackLocation = (message) => {
     const lines = stripAnsi(message).split(/\r?\n/);
     for (const line of lines) {
@@ -1553,7 +1506,6 @@ const compactIssueTitle = (cluster) => {
     const locator = compactLocator(failure.locator);
     const blockedVerdict = blockedVerdictForCluster(cluster);
     const navigation = navigationVerdictForFailure(failure);
-    const multiSelectorBlocked = isMultiSelectorBlockedCluster(cluster);
     switch (failure.signal) {
         case "setup":
             return "Playwright setup error";
@@ -1570,19 +1522,6 @@ const compactIssueTitle = (cluster) => {
         case "actionability":
             if (blockedVerdict?.locator) {
                 const subtype = blockedActionSubtype(failure, blockedVerdict);
-                if (multiSelectorBlocked) {
-                    if (subtype === "overlay")
-                        return "Overlay blocked interactions";
-                    if (subtype === "strict_mode")
-                        return "Strict-mode locator conflicts";
-                    if (subtype === "detached")
-                        return "Detached targets before interaction";
-                    if (subtype === "offscreen")
-                        return "Offscreen targets before interaction";
-                    if (subtype === "focus")
-                        return "Input targets blocked";
-                    return "Blocked interactions";
-                }
                 if (subtype === "strict_mode")
                     return `Strict-mode locator conflict (${compactLocator(blockedVerdict.locator)})`;
                 if (subtype === "detached")
@@ -1601,13 +1540,6 @@ const compactIssueTitle = (cluster) => {
                 return "Navigation timeout";
             if (navigation?.kind === "blank_page")
                 return "Blank page after navigation";
-            if (multiSelectorBlocked) {
-                const subtype = blockedActionSubtype(failure, blockedVerdict);
-                if (subtype === "overlay")
-                    return "Overlay blocked interactions";
-                if (subtype === "strict_mode")
-                    return "Strict-mode locator conflicts";
-            }
             if (blockedVerdict?.targetState === "visible_blocked" && blockedVerdict.action && blockedVerdict.locator) {
                 return `Blocked ${blockedVerdict.action} on ${compactLocator(blockedVerdict.locator)}`;
             }
@@ -1665,23 +1597,6 @@ const clusterCauseLine = (cluster) => {
     }
     if (failure.signal === "actionability") {
         const subtype = blockedActionSubtype(failure, blockedVerdict);
-        if (isMultiSelectorBlockedCluster(cluster)) {
-            if (subtype === "overlay" && blockedVerdict?.blocker) {
-                return `${blockedVerdict.blocker} blocked interactions across these tests`;
-            }
-            if (subtype === "strict_mode") {
-                return "The shared locator pattern matched multiple elements across these tests";
-            }
-            if (subtype === "detached") {
-                return "Targets detached from the DOM before the interaction completed across these tests";
-            }
-            if (subtype === "offscreen") {
-                return "Targets never became reachable in the viewport across these tests";
-            }
-            if (subtype === "focus") {
-                return "Targets could not receive focus or input when the interaction ran";
-            }
-        }
         if (subtype === "overlay" && blockedVerdict?.blocker && blockedVerdict?.locator) {
             return `${blockedVerdict.blocker} blocked ${blockedVerdict.action || "the action"} on ${compactLocator(blockedVerdict.locator)}`;
         }
@@ -1715,15 +1630,6 @@ const clusterCauseLine = (cluster) => {
         if (navigation?.kind === "blank_page") {
             return `The app ended on a blank page instead of the expected screen`;
         }
-        if (isMultiSelectorBlockedCluster(cluster)) {
-            const subtype = blockedActionSubtype(failure, blockedVerdict);
-            if (subtype === "overlay" && blockedVerdict?.blocker) {
-                return `${blockedVerdict.blocker} blocked interactions across these tests before the expected state changed`;
-            }
-            if (subtype === "strict_mode") {
-                return "The shared locator pattern matched multiple elements across these tests";
-            }
-        }
         if (blockedVerdict?.targetState === "visible_blocked" && blockedVerdict.action && blockedVerdict.locator) {
             if (blockedVerdict.blocker) {
                 return `${blockedVerdict.blocker} blocked ${blockedVerdict.action} on ${compactLocator(blockedVerdict.locator)}`;
@@ -1798,23 +1704,6 @@ const strongerClusterNext = (cluster) => {
     }
     if (failure.signal === "actionability" && failure.locator) {
         const subtype = blockedActionSubtype(failure, blockedVerdict);
-        if (isMultiSelectorBlockedCluster(cluster)) {
-            if (subtype === "overlay" && blockedVerdict?.blocker) {
-                return `remove or dismiss ${blockedVerdict.blocker} before these interactions run`;
-            }
-            if (subtype === "strict_mode") {
-                return "narrow the shared locator pattern so each interaction matches exactly one element";
-            }
-            if (subtype === "detached") {
-                return "stabilize the DOM so the targets do not detach before the interactions run";
-            }
-            if (subtype === "offscreen") {
-                return "make the targets reachable in the viewport before the interactions run";
-            }
-            if (subtype === "focus") {
-                return "make the targets focusable/editable before the interactions run";
-            }
-        }
         if (subtype === "strict_mode" && blockedVerdict?.locator) {
             return `narrow ${compactLocator(blockedVerdict.locator)} so it matches exactly one element`;
         }
@@ -1845,15 +1734,6 @@ const strongerClusterNext = (cluster) => {
         if (navigation?.kind === "blank_page") {
             return "check why the app ended on a blank route after navigation";
         }
-        if (isMultiSelectorBlockedCluster(cluster)) {
-            const subtype = blockedActionSubtype(failure, blockedVerdict);
-            if (subtype === "overlay" && blockedVerdict?.blocker) {
-                return `remove or dismiss ${blockedVerdict.blocker} before these interactions run`;
-            }
-            if (subtype === "strict_mode") {
-                return "narrow the shared locator pattern so each interaction matches exactly one element";
-            }
-        }
         if (blockedVerdict?.targetState === "visible_blocked" && blockedVerdict.action && blockedVerdict.locator) {
             return blockedVerdict.blocker
                 ? `remove or dismiss what blocks ${blockedVerdict.action} on ${compactLocator(blockedVerdict.locator)}`
@@ -1969,9 +1849,9 @@ const parseFailureFacts = (title, titlePath, message, status, file = null, optio
                 found: Boolean(fallbackLocation?.file || assertionLine || extractFocusLineFromMessage(message))
             };
     const domCapture = options?.domCapture || null;
-    const locator = domCapture?.normalizedLocator ||
-        extractLocator(message) ||
+    const locator = extractLocator(message) ||
         codeContext?.locator ||
+        domCapture?.normalizedLocator ||
         domCapture?.locator ||
         null;
     const extractedExpected = extractExpected(message);
@@ -2069,63 +1949,47 @@ const buildDebugSummary = (failure) => {
 exports.buildDebugSummary = buildDebugSummary;
 const buildSimilarityKey = (failure) => {
     const locationKey = failure.codeContext?.line ? `${basename(failure.codeContext.file)}:${failure.codeContext.line}` : basename(failure.likelyFile) || "unknown-file";
-    const canonicalLocator = canonicalLocatorForFailure(failure);
-    const requestKey = requestFingerprint(failure);
-    const pageErrorKey = pageErrorFingerprint(failure);
     if (failure.signal === 'runtime' || failure.signal === 'unknown') {
         return [
             failure.signal,
-            pageErrorKey || normalizeMessageFingerprint(failure.message),
-            canonicalLocator || locationKey
+            normalizeMessageFingerprint(failure.message),
+            locationKey
         ].join('|');
     }
     if (failure.signal === "assertion_mismatch") {
-        const assertionKind = extractAssertionKind(failure.codeContext?.assertion || failure.codeContext?.focusLine || null);
         return [
             failure.signal,
-            canonicalLocator || failure.likelyModule || basename(failure.likelyFile) || "unknown-target",
-            assertionKind,
-            failure.expected || "unknown-expected",
-            failure.received || pageErrorKey || "unknown-received"
+            failure.locator || failure.likelyModule || basename(failure.likelyFile) || "unknown-target",
+            basename(failure.likelyFile) || "unknown-file"
         ].join("|");
     }
     if (failure.signal === "setup") {
         return [failure.signal, normalizeMessageFingerprint(failure.message)].join("|");
     }
     if (failure.signal === "timeout" || failure.signal === "actionability" || failure.signal === "locator_not_found") {
-        const verdict = blockedVerdictForFailure(failure);
-        const blockerKey = blockerGroupingKey(failure, verdict);
-        const subtype = blockedActionSubtype(failure, verdict);
-        if (blockerKey && (subtype === "overlay" || subtype === "strict_mode" || subtype === "detached" || subtype === "offscreen" || subtype === "focus")) {
-            return [
-                "blocked_action_family",
-                blockerKey
-            ].join("|");
-        }
         return [
             failure.signal,
-            canonicalLocator || failure.codeContext?.action || failure.likelyModule || "unknown-target",
-            failure.codeContext?.action || "unknown-action",
-            pageErrorKey || locationKey
+            failure.locator || failure.codeContext?.action || failure.likelyModule || "unknown-target",
+            basename(failure.likelyFile) || "unknown-file"
         ].join("|");
     }
     if (failure.signal === "network") {
         return [
             failure.signal,
-            requestKey || normalizedUrlPath(failure.apiHint) || failure.likelyModule || "unknown-api",
-            pageErrorKey || basename(failure.likelyFile) || "unknown-file"
+            failure.apiHint || failure.likelyModule || "unknown-api",
+            basename(failure.likelyFile) || "unknown-file"
         ].join("|");
     }
     if (failure.locator || failure.expected || failure.received || failure.apiHint) {
         return [
             failure.signal,
-            canonicalLocator || normalizedUrlPath(failure.apiHint) || "unknown-target",
+            failure.locator || failure.apiHint || "unknown-target",
             failure.expected || "unknown-expected",
-            failure.received || requestKey || pageErrorKey || "unknown-received",
-            pageErrorKey || locationKey
+            failure.received || "unknown-received",
+            locationKey
         ].join("|");
     }
-    return `${failure.signal}|${pageErrorKey || normalizeMessageFingerprint(failure.message)}|${canonicalLocator || locationKey}`;
+    return `${failure.signal}|${normalizeMessageFingerprint(failure.message)}|${locationKey}`;
 };
 exports.buildSimilarityKey = buildSimilarityKey;
 const summarizeSignal = (signal) => {
@@ -2184,7 +2048,7 @@ const representativeClusterSelector = (cluster) => {
         .find((line) => line.startsWith("Selector:"));
     if (evidenceSelector)
         return withoutPrefix(evidenceSelector, "Selector:");
-    return representativeClusterValue(cluster.failures, (failure) => canonicalLocatorForFailure(failure));
+    return representativeClusterValue(cluster.failures, (failure) => failure.locator);
 };
 const representativeClusterBlocker = (cluster) => {
     const evidenceBlocker = buildClusterEvidenceLines(cluster)
@@ -2295,18 +2159,17 @@ const buildSingleFailureIssue = (failed, top) => ({
 const buildClusterIssue = (cluster, totalFailures) => {
     const top = cluster.suspects[0];
     const rootCause = cluster.count === 1 ? (0, exports.describeFailure)(cluster.sample) : clusterCauseLine(cluster);
-    const hideSelectorSpecificEvidence = isMultiSelectorBlockedCluster(cluster);
     return {
         title: `${compactIssueTitle(cluster)} (${cluster.count} test${cluster.count === 1 ? "" : "s"})`,
         cause: rootCause,
         affectedTitles: cluster.titles,
         where: locationValueForCluster(cluster),
-        failingCode: hideSelectorSpecificEvidence ? null : representativeClusterFailingCode(cluster)?.trim() || null,
-        failingStep: hideSelectorSpecificEvidence ? null : representativeClusterFailingStep(cluster)?.trim() || null,
-        selector: hideSelectorSpecificEvidence ? null : representativeClusterSelector(cluster)?.trim() || null,
+        failingCode: representativeClusterFailingCode(cluster)?.trim() || null,
+        failingStep: representativeClusterFailingStep(cluster)?.trim() || null,
+        selector: representativeClusterSelector(cluster)?.trim() || null,
         blocker: representativeClusterBlocker(cluster)?.trim() || null,
         targetState: representativeClusterTargetState(cluster)?.trim() || null,
-        expected: hideSelectorSpecificEvidence ? null : representativeClusterExpected(cluster) ? truncateValue(representativeClusterExpected(cluster) || null) : null,
+        expected: representativeClusterExpected(cluster) ? truncateValue(representativeClusterExpected(cluster) || null) : null,
         received: representativeClusterReceived(cluster) ? truncateValue(representativeClusterReceived(cluster) || null) : null,
         whatChanged: top && top.score >= 0.62 ? top.commit.message : null,
         reason: top && top.score >= 0.62 && top.reasons.length ? `${compactWhyLine(top)}.` : null,
@@ -2407,7 +2270,77 @@ const buildQuickDiagnosisStructured = (playwrightJsonPath) => {
         ((b.suspects[0]?.score || 0) - (a.suspects[0]?.score || 0)) ||
         (b.sample.signal === "assertion_mismatch" ? 1 : 0) - (a.sample.signal === "assertion_mismatch" ? 1 : 0));
     const topCluster = clusters[0];
-    const visibleClusters = clusters.slice(0, 3);
+    const mergeRelatedIssues = (issues) => {
+        // If multiple clusters share the same actionability blocker, treat them as one root cause.
+        // This matches the user's expectation: the blocker is the canonical evidence, not the target locator.
+        const merged = [];
+        const used = new Set();
+        const norm = (value) => (value || "").replace(/\s+/g, " ").trim().toLowerCase();
+        const isBlockedInteraction = (issue) => issue.title.toLowerCase().startsWith("blocked interaction");
+        const blockerKey = (issue) => {
+            const blocker = norm(issue.blocker);
+            if (!blocker)
+                return null;
+            const state = norm(issue.targetState);
+            return `blocked_interaction::${blocker}::${state}`;
+        };
+        const buildMergedTitle = (blocker, count) => {
+            const b = blocker.toLowerCase();
+            const prefix = b.includes("overlay") ? "Overlay blocked interactions" : "Blocked interaction";
+            return `${prefix} (${count} test${count === 1 ? "" : "s"})`;
+        };
+        for (let i = 0; i < issues.length; i += 1) {
+            if (used.has(i))
+                continue;
+            const base = issues[i];
+            const key = blockerKey(base);
+            if (!key || !isBlockedInteraction(base)) {
+                merged.push(base);
+                used.add(i);
+                continue;
+            }
+            const group = [base];
+            used.add(i);
+            for (let j = i + 1; j < issues.length; j += 1) {
+                if (used.has(j))
+                    continue;
+                const candidate = issues[j];
+                if (!isBlockedInteraction(candidate))
+                    continue;
+                if (blockerKey(candidate) !== key)
+                    continue;
+                group.push(candidate);
+                used.add(j);
+            }
+            if (group.length === 1) {
+                merged.push(base);
+                continue;
+            }
+            const allTitles = Array.from(new Set(group.flatMap((issue) => issue.affectedTitles || [])));
+            const count = allTitles.length;
+            const blocker = group.map((issue) => issue.blocker).find(Boolean) || base.blocker || "";
+            const targetState = group.map((issue) => issue.targetState).find(Boolean) || base.targetState || null;
+            const whereParts = group
+                .map((issue) => issue.where)
+                .filter(Boolean)
+                .flatMap((where) => String(where).split(";").map((p) => p.trim()).filter(Boolean));
+            const where = Array.from(new Set(whereParts)).slice(0, 12).join("; ") || null;
+            merged.push({
+                ...base,
+                title: buildMergedTitle(blocker, count),
+                // Canonical, normalized evidence: blocker + state. Avoid sample-selector specificity here.
+                cause: `${blocker} blocked interactions across these tests`,
+                affectedTitles: allTitles,
+                where,
+                selector: null,
+                targetState,
+                impact: `${count} tests failing with same root cause`,
+                clears: `fixing this likely clears ${count} of ${failures.length} failures`
+            });
+        }
+        return merged;
+    };
+    const mergedIssues = mergeRelatedIssues(clusters.map((cluster) => buildClusterIssue(cluster, failures.length)));
     return {
         mode: "failure",
         headline: null,
@@ -2415,11 +2348,9 @@ const buildQuickDiagnosisStructured = (playwrightJsonPath) => {
             ? `❌ ${failures.length} failures (grouped)`
             : `❌ ${failures.length} failures`,
         collapseLine: clusters.length < failures.length
-            ? clusters.length > visibleClusters.length
-                ? `Collapsed into ${clusters.length} real issues (showing top ${visibleClusters.length})`
-                : `Collapsed into ${clusters.length} real issue${clusters.length === 1 ? "" : "s"}`
+            ? `Collapsed into ${clusters.length} real issue${clusters.length === 1 ? "" : "s"}`
             : null,
-        issues: visibleClusters.map((cluster) => buildClusterIssue(cluster, failures.length)),
+        issues: mergedIssues,
         footer: topCluster?.suspects[0] ? [`Confidence: ${confidenceLabel(topCluster.suspects[0].score).toLowerCase()}`] : []
     };
 };

package/dist/reporter.d.ts

@@ -11,6 +11,7 @@ declare class SentinelReporter {
     private totalCount;
     private startedAt;
     private options;
+    private sentinelMode;
     constructor(options: ReporterOptions);
     onBegin(config: any, suite: any): void;
     onTestEnd(test: any, result: any): Promise<void>;

package/dist/reporter.js

@@ -3,14 +3,27 @@ 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 node_url_1 = require("node:url");
 const env_1 = require("./env");
 const quickDiagnosis_1 = require("./quickDiagnosis");
+const localReport_1 = require("./localReport");
 const terminalSummary_1 = require("./terminalSummary");
 const runHistory_1 = require("./runHistory");
 const telemetry_1 = require("./telemetry");
 const { sentinelCaptureFailureContextFromReporter } = require("@sentinelqa/uploader/playwright");
+const readSentinelMode = (env = process.env) => {
+    const raw = env.SENTINEL_MODE?.trim();
+    if (raw == null || raw === "")
+        return "hosted";
+    if (raw === "hosted" || raw === "offline")
+        return raw;
+    throw new Error([
+        "Invalid SENTINEL_MODE value: \"" + raw + "\".",
+        "Allowed values: hosted, offline.",
+        "Tip: remove SENTINEL_MODE to use the default hosted flow."
+    ].join(" "));
+};
 const colorize = (value, code) => {
     if (!process.stdout.isTTY)
         return value;
@@ -150,6 +163,7 @@ class SentinelReporter {
         this.startedAt = Date.now();
         (0, env_1.loadSentinelEnv)();
         this.options = options;
+        this.sentinelMode = readSentinelMode(process.env);
     }
     onBegin(config, suite) {
         this.startedAt = Date.now();
@@ -178,6 +192,37 @@ class SentinelReporter {
         }
     }
     async onEnd() {
+        const offlineMode = this.sentinelMode === "offline";
+        const emitLocalReport = () => {
+            console.log(styleSecondary("Writing local debug report..."));
+            console.log("");
+            try {
+                const result = (0, localReport_1.generateLocalDebugReport)({
+                    playwrightJsonPath: this.options.playwrightJsonPath,
+                    playwrightReportDir: this.options.playwrightReportDir,
+                    testResultsDir: this.options.testResultsDir,
+                    artifactDirs: this.options.artifactDirs || [],
+                    reportDir: process.env.SENTINEL_REPORT_DIR || undefined
+                });
+                const rel = node_path_1.default.relative(process.cwd(), result.htmlPath) || result.htmlPath;
+                const fileUrl = (0, node_url_1.pathToFileURL)(node_path_1.default.resolve(result.htmlPath)).toString();
+                console.log(styleAction("Local report ready"));
+                console.log(formatCliLine(`Next: ${rel}`));
+                console.log("");
+                console.log(styleAction("Shareable report:"));
+                console.log(`  ${fileUrl}`);
+            }
+            catch (err) {
+                console.error(styleCritical("Sentinel: Local report generation failed."));
+                const message = err instanceof Error ? err.message : String(err);
+                if (message && message !== "[object Object]") {
+                    console.error(styleSecondary(message));
+                }
+                if (process.env.SENTINEL_DEBUG && err instanceof Error && err.stack) {
+                    console.error(styleSecondary(err.stack));
+                }
+            }
+        };
         const hasWorkspaceToken = Boolean(process.env.SENTINEL_TOKEN);
         const hasCiEnv = (0, node_1.hasSupportedCiEnv)(process.env);
         const localUploadEnabled = (0, node_1.isLocalUploadEnabled)(process.env);
@@ -185,7 +230,6 @@ 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;
@@ -220,6 +264,8 @@ class SentinelReporter {
         if (hasWorkspaceToken && !hasCiEnv && !localUploadEnabled) {
             console.log("Uploading debug report skipped");
             console.log("Set SENTINEL_UPLOAD_LOCAL=1 for local workspace uploads.");
+            console.log("");
+            emitLocalReport();
             return;
         }
         if (quickDiagnosis?.lines.length) {
@@ -260,19 +306,12 @@ class SentinelReporter {
         if (isSetupFailureDiagnosis) {
             return;
         }
+        if (offlineMode) {
+            emitLocalReport();
+            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,
@@ -282,11 +321,14 @@ 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) {
+            console.log(styleWarning("Hosted upload failed"));
+            console.log(styleSecondary("Falling back to a local report."));
+            console.log("");
+            emitLocalReport();
             return;
         }
         if (!quickDiagnosis?.lines.length && upload.diagnosis?.lines.length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentinelqa/playwright-reporter",
-  "version": "0.1.54",
+  "version": "0.1.57",
   "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.38"
+    "@sentinelqa/uploader": "^0.1.35"
   },
   "devDependencies": {
     "@types/node": "^20.19.32",