donobu 5.60.1 → 5.60.3

package/dist/reporter/merge.js

@@ -15,6 +15,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeReports = mergeReports;
 exports.buildTestKey = buildTestKey;
+const model_1 = require("./model");
+const reportWalk_1 = require("./reportWalk");
 function mergeReports(params) {
     const { initialReport, healReport } = params;
     if (!initialReport && !healReport) {
@@ -29,7 +31,17 @@ function mergeReports(params) {
     if (healReport) {
         const processedHealEntries = new Set();
         const processHealEntry = (healEntry) => {
-            const key = buildTestKey(healEntry.suite.file, healEntry.test.projectName, healEntry.test.title);
+            // Tests the rerun's collection gate statically skipped carry zero
+            // information — the initial run's result for them stands untouched, so
+            // their heal entries are dropped wholesale (no appended attempts, no
+            // status churn, no skip noise in the merged report).
+            if (healEntry.test.annotations?.some((annotation) => annotation.type === model_1.HEAL_SKIP_REPLAY_ANNOTATION_TYPE)) {
+                return;
+            }
+            // Titles live on the spec in both report shapes (the Donobu state file
+            // and Playwright's native JSON); `test.title` is never set. Without the
+            // spec fallback all tests in a file/project collapse to one key.
+            const key = buildTestKey(healEntry.suite.file, healEntry.test.projectName, healEntry.test.title ?? healEntry.spec.title);
             let combinedEntry = (healEntry.test.testId
                 ? combinedIndex.byId.get(healEntry.test.testId)
                 : undefined) ??
@@ -54,16 +66,47 @@ function mergeReports(params) {
                     ...healEntry.test.results,
                 ];
             }
-            if (healEntry.test.status !== undefined) {
-                combinedTest.status = healEntry.test.status;
-            }
-            if (healEntry.test.outcome !== undefined) {
-                combinedTest.outcome = healEntry.test.outcome;
-            }
             const originalStatus = originalEntry
                 ? getFinalResultStatus(originalEntry.test)
                 : undefined;
             const healStatus = getFinalResultStatus(healEntry.test);
+            const originalFailed = originalStatus !== undefined &&
+                originalStatus !== 'passed' &&
+                originalStatus !== 'skipped';
+            // The heal rerun may only improve a test's outcome:
+            // - It must not relabel a genuine failure as "skipped" (a rerun in
+            //   which the test skipped itself — e.g. a precondition guard fired —
+            //   used to turn red runs green).
+            // - It must not flip an initially-passing test red: rerun failures of
+            //   tests that tagged along (serial siblings, dependency projects) are
+            //   advisory, recorded in the attempt history and an annotation.
+            const adoptHealStatus = healStatus === 'passed' ||
+                (originalStatus !== 'passed' && healStatus !== 'skipped');
+            if (adoptHealStatus) {
+                if (healEntry.test.status !== undefined) {
+                    combinedTest.status = healEntry.test.status;
+                }
+                if (healEntry.test.outcome !== undefined) {
+                    combinedTest.outcome = healEntry.test.outcome;
+                }
+            }
+            else if (originalFailed && healStatus === 'skipped') {
+                combinedTest.annotations = combinedTest.annotations ?? [];
+                combinedTest.annotations.push({
+                    type: 'auto-heal-not-reattempted',
+                    description: 'The auto-heal rerun could not re-attempt this test: it skipped itself during the rerun because a precondition set up by another test was missing. The original failure stands. To make this test heal-eligible, declare the ordering explicitly — via Playwright project `dependencies` or `test.describe.serial` — so the rerun can execute the prerequisites.',
+                });
+            }
+            else if (originalStatus === 'passed' &&
+                healStatus !== undefined &&
+                healStatus !== 'passed' &&
+                healStatus !== 'skipped') {
+                combinedTest.annotations = combinedTest.annotations ?? [];
+                combinedTest.annotations.push({
+                    type: 'auto-heal-rerun-failed',
+                    description: 'This test passed in the initial run but failed when re-run during the auto-heal pass. The initial result stands; the failed rerun attempt is preserved in the attempt history.',
+                });
+            }
             if (healStatus === 'passed' &&
                 originalStatus &&
                 originalStatus !== 'passed') {
@@ -90,26 +133,6 @@ function mergeReports(params) {
         iterateEntries(healIndex.byId);
         iterateEntries(healIndex.byKey);
     }
-    if (params.healSucceeded && healedKeys.size === 0) {
-        params.healedTests.forEach((descriptor) => {
-            // Descriptors must arrive with `testCase.file` already normalized to the
-            // same form that suite.file has in the reports — the caller owns path
-            // normalization because it has access to the CWD the run was launched in.
-            const key = buildTestKey(descriptor.testCase.file, descriptor.testCase.projectName, descriptor.testCase.title);
-            const entry = combinedIndex.byKey.get(key);
-            if (entry) {
-                entry.test.annotations = entry.test.annotations ?? [];
-                if (!entry.test.annotations.some((annotation) => annotation.type === 'self-healed')) {
-                    entry.test.annotations.push({
-                        type: 'self-healed',
-                        description: 'Automatically healed by Donobu auto-heal rerun after applying treatment plan.',
-                    });
-                }
-                entry.test.donobuStatus = 'healed';
-                healedKeys.add(key);
-            }
-        });
-    }
     combined.stats = computeReportStats(combined);
     const mergedMetadata = {
         ...(combined.metadata ?? {}),
@@ -152,7 +175,7 @@ function indexReport(report) {
                 if (test.testId) {
                     byId.set(test.testId, entry);
                 }
-                const key = buildTestKey(suite.file, test.projectName, test.title);
+                const key = buildTestKey(suite.file, test.projectName, test.title ?? spec.title);
                 byKey.set(key, entry);
             });
         });
@@ -195,9 +218,13 @@ function computeReportStats(report) {
                 if (finalResult?.duration) {
                     duration += finalResult.duration;
                 }
-                const status = finalResult?.status ?? test.status;
-                switch (status) {
+                // Classify from the full attempt history so a heal-rerun skip can't
+                // hide an earlier genuine failure, retry recoveries count as flaky,
+                // and expected failures (`test.fail()`) count as expected.
+                switch ((0, reportWalk_1.statusOf)(test)) {
                     case 'passed':
+                    case 'expectedFailure':
+                    case 'healed':
                         expected += 1;
                         break;
                     case 'skipped':
@@ -206,11 +233,6 @@ function computeReportStats(report) {
                     case 'flaky':
                         flaky += 1;
                         break;
-                    case 'failed':
-                    case 'timedOut':
-                    case 'interrupted':
-                        unexpected += 1;
-                        break;
                     default:
                         unexpected += 1;
                 }

package/dist/reporter/model.d.ts

@@ -21,6 +21,15 @@
  * stable across Donobu versions.
  */
 export declare const DONOBU_REPORT_STATE_FILENAME = ".donobu-report-state.json";
+/**
+ * Annotation type stamped on tests the auto-heal rerun statically skipped
+ * because they were not part of the rerun plan (they passed the initial run
+ * and were not prerequisites of any heal target). The merge step drops these
+ * heal-run entries entirely: they carry no information, and the initial run's
+ * result for those tests stands untouched. Defined here (rather than in the
+ * test-side gate) so the pure reporter modules don't import test runtime code.
+ */
+export declare const HEAL_SKIP_REPLAY_ANNOTATION_TYPE = "donobu-heal-skip-replay";
 /**
  * Per-format output record written by each Donobu reporter into the shared
  * state file. The auto-heal orchestrator reads this map after merging two
@@ -48,6 +57,13 @@ export interface DonobuReportMetadata {
     /** True on reports that are the result of merging an initial + heal run. */
     donobuMergedReport?: boolean;
     mergedAtIso?: string;
+    /**
+     * Declared Playwright project dependency graph (`FullProject.dependencies`)
+     * keyed by project name, recorded by the reporter. The auto-heal
+     * orchestrator uses it to exclude declared dependencies of heal targets
+     * from the rerun gate — they must run in full.
+     */
+    projectDependencies?: Record<string, string[]>;
     sources?: {
         initial?: string | null;
         autoHeal?: string | null;

package/dist/reporter/model.js

@@ -14,7 +14,7 @@
  * retype the whole Playwright reporter surface.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DONOBU_REPORT_STATE_FILENAME = void 0;
+exports.HEAL_SKIP_REPLAY_ANNOTATION_TYPE = exports.DONOBU_REPORT_STATE_FILENAME = void 0;
 /**
  * Filename the reporter writes into each run's Playwright output directory.
  * The auto-heal orchestrator looks for this file (in both the initial run's
@@ -24,4 +24,13 @@ exports.DONOBU_REPORT_STATE_FILENAME = void 0;
  * stable across Donobu versions.
  */
 exports.DONOBU_REPORT_STATE_FILENAME = '.donobu-report-state.json';
+/**
+ * Annotation type stamped on tests the auto-heal rerun statically skipped
+ * because they were not part of the rerun plan (they passed the initial run
+ * and were not prerequisites of any heal target). The merge step drops these
+ * heal-run entries entirely: they carry no information, and the initial run's
+ * result for those tests stands untouched. Defined here (rather than in the
+ * test-side gate) so the pure reporter modules don't import test runtime code.
+ */
+exports.HEAL_SKIP_REPLAY_ANNOTATION_TYPE = 'donobu-heal-skip-replay';
 //# sourceMappingURL=model.js.map

package/dist/reporter/render.js

@@ -253,18 +253,10 @@ function extractTests(jsonData) {
             for (const test of spec.tests ?? []) {
                 const annotations = test.annotations ?? [];
                 const isSelfHealed = (0, reportWalk_1.isSelfHealed)(test);
-                let status;
-                const lastResult = test.results?.at(-1);
-                if (test.status === 'skipped' ||
-                    (!lastResult && test.status === undefined)) {
-                    status = 'skipped';
-                }
-                else if (isSelfHealed) {
-                    status = 'healed';
-                }
-                else {
-                    status = lastResult?.status ?? 'unknown';
-                }
+                // Derived from the full attempt history (see reportWalk.statusOf):
+                // surviving failures stay failed even when a heal-rerun skip is the
+                // final attempt, and retry recoveries surface as 'flaky'.
+                const status = (0, reportWalk_1.statusOf)(test);
                 const objectiveAnnotation = annotations.find((a) => a.type === 'objective');
                 const results = (test.results ?? []).map((r, i) => {
                     const attachments = r.attachments ?? [];
@@ -394,6 +386,18 @@ const STATUS_CFG = {
         bg: 'rgba(16,185,129,0.08)',
         icon: '✓',
     },
+    flaky: {
+        label: 'Flaky',
+        color: '#eab308',
+        bg: 'rgba(234,179,8,0.08)',
+        icon: '↻',
+    },
+    expectedFailure: {
+        label: 'Expected Failure',
+        color: '#14b8a6',
+        bg: 'rgba(20,184,166,0.08)',
+        icon: '☑',
+    },
     failed: {
         label: 'Failed',
         color: '#ef4444',
@@ -1524,6 +1528,8 @@ function renderHtml(report, triage, outputDir) {
     // Counts
     const counts = {
         passed: 0,
+        flaky: 0,
+        expectedFailure: 0,
         failed: 0,
         healed: 0,
         timedOut: 0,
@@ -1566,6 +1572,8 @@ function renderHtml(report, triage, outputDir) {
     // Build test bar blocks (one square per test, ordered by status, clickable)
     const statusOrder = [
         'passed',
+        'flaky',
+        'expectedFailure',
         'healed',
         'failed',
         'timedOut',
@@ -1594,6 +1602,18 @@ function renderHtml(report, triage, outputDir) {
             icon: '✓',
             iconClass: 'icon-pass',
         },
+        {
+            key: 'flaky',
+            label: 'Flaky',
+            icon: '↻',
+            iconClass: 'icon-flaky',
+        },
+        {
+            key: 'expectedFailure',
+            label: 'Expected Failures',
+            icon: '☑',
+            iconClass: 'icon-expected-failure',
+        },
         { key: 'healed', label: 'Healed', icon: '♥', iconClass: 'icon-heal' },
         { key: 'failed', label: 'Failed', icon: '⚠', iconClass: 'icon-fail' },
         {
@@ -1793,6 +1813,8 @@ body::before{content:'';position:fixed;top:-750px;left:50%;transform:translateX(
 .test-bar-block[data-tooltip]:hover::after{content:attr(data-tooltip);position:absolute;top:calc(100% + 8px);left:50%;transform:translateX(-50%);background:var(--surface);color:var(--text);border:1px solid var(--border);border-radius:var(--radius);padding:6px 10px;font-size:11px;font-family:var(--font);white-space:nowrap;z-index:10;pointer-events:none;box-shadow:0 4px 12px rgba(0,0,0,.2)}
 .test-bar-block[data-tooltip]:hover::before{content:'';position:absolute;top:calc(100% + 2px);left:50%;transform:translateX(-50%);border:5px solid transparent;border-bottom-color:var(--border);z-index:10;pointer-events:none}
 .test-bar-block.bar-passed{background:var(--bar-pass)}
+.test-bar-block.bar-flaky{background:var(--bar-warn)}
+.test-bar-block.bar-expectedfailure{background:var(--bar-pass);opacity:.55}
 .test-bar-block.bar-healed{background:var(--bar-heal)}
 .test-bar-block.bar-failed{background:var(--bar-fail)}
 .test-bar-block.bar-timedout,.test-bar-block.bar-interrupted{background:var(--bar-warn)}

package/dist/reporter/renderMarkdown.js

@@ -11,6 +11,34 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderMarkdown = renderMarkdown;
 const ansi_1 = require("../utils/ansi");
 const reportWalk_1 = require("./reportWalk");
+const STATUS_LABELS = {
+    passed: '✅ Passed',
+    flaky: '🔁 Flaky',
+    expectedFailure: '☑️ Expected Failure',
+    healed: '❤️‍🩹 Healed',
+    failed: '❌ Failed',
+    timedOut: '⏰ Timed Out',
+    skipped: '⏭️ Skipped',
+    interrupted: '⚡ Interrupted',
+    unknown: '⚠️ Unknown',
+};
+/**
+ * The attempt whose details (duration, errors) the per-test section shows.
+ * For surviving failures this is the last failing attempt — the final entry
+ * in `results` may be a heal-rerun skip that carries no error context.
+ */
+function displayResultOf(test, status) {
+    const results = test.results ?? [];
+    if (status === 'failed' ||
+        status === 'timedOut' ||
+        status === 'interrupted') {
+        const failures = results.filter((r) => ['failed', 'timedOut', 'interrupted'].includes(r?.status));
+        if (failures.length > 0) {
+            return failures.at(-1);
+        }
+    }
+    return results.at(-1);
+}
 function formatDuration(ms) {
     if (ms < 1000) {
         return `${ms}ms`;
@@ -29,69 +57,111 @@ function renderMarkdown(report) {
     if (report.metadata?.donobuMergedReport) {
         markdown += `> ⚙️ Auto-heal summary generated by Donobu (merged initial and retry runs).\n\n`;
     }
-    // Per-file summary table
+    // Per-file summary table. Counts are computed for all suites first so the
+    // rarely-used Expected Failures column can be omitted when it would be
+    // entirely empty.
     markdown += `## Summary\n\n`;
-    markdown += `| File | Passed | Self-Healed | Failed | Timed Out | Skipped | Interrupted | Duration |\n`;
-    markdown += `| - | - | - | - | - | - | - | - |\n`;
-    let totalPassed = 0;
-    let totalFailed = 0;
-    let totalTimedOut = 0;
-    let totalSkipped = 0;
-    let totalInterrupted = 0;
-    let totalSelfHealed = 0;
-    let totalDuration = 0;
-    suites.forEach((suite) => {
-        let passed = 0;
-        let failed = 0;
-        let timedOut = 0;
-        let skipped = 0;
-        let interrupted = 0;
-        let selfHealed = 0;
-        const allSpecs = (0, reportWalk_1.collectSpecs)(suite);
-        const fileDuration = allSpecs.reduce((total, spec) => total +
-            (spec.tests ?? []).reduce((testTotal, test) => {
-                const result = test.results?.at(-1);
-                const healed = (0, reportWalk_1.isSelfHealed)(test);
-                if (test.status === 'skipped' ||
-                    (!result && test.status === undefined)) {
-                    skipped++;
-                }
-                else if (result) {
-                    if (healed) {
-                        selfHealed++;
-                    }
-                    else {
-                        switch (result.status) {
-                            case 'passed':
-                                passed++;
-                                break;
-                            case 'failed':
-                                failed++;
-                                break;
-                            case 'timedOut':
-                                timedOut++;
-                                break;
-                            case 'skipped':
-                                skipped++;
-                                break;
-                            case 'interrupted':
-                                interrupted++;
-                                break;
-                        }
-                    }
+    const suiteRows = suites.map((suite) => {
+        const row = {
+            file: suite.file,
+            passed: 0,
+            flaky: 0,
+            expectedFailures: 0,
+            selfHealed: 0,
+            failed: 0,
+            timedOut: 0,
+            skipped: 0,
+            interrupted: 0,
+            duration: 0,
+        };
+        for (const spec of (0, reportWalk_1.collectSpecs)(suite)) {
+            for (const test of spec.tests ?? []) {
+                row.duration += test.results?.at(-1)?.duration || 0;
+                switch ((0, reportWalk_1.statusOf)(test)) {
+                    case 'passed':
+                        row.passed++;
+                        break;
+                    case 'flaky':
+                        row.flaky++;
+                        break;
+                    case 'expectedFailure':
+                        row.expectedFailures++;
+                        break;
+                    case 'healed':
+                        row.selfHealed++;
+                        break;
+                    case 'timedOut':
+                        row.timedOut++;
+                        break;
+                    case 'skipped':
+                        row.skipped++;
+                        break;
+                    case 'interrupted':
+                        row.interrupted++;
+                        break;
+                    default:
+                        // 'failed' and 'unknown' both belong in the Failed column —
+                        // dropping unknowns from the table would hide real problems.
+                        row.failed++;
+                        break;
                 }
-                return testTotal + (result?.duration || 0);
-            }, 0), 0);
-        totalPassed += passed;
-        totalFailed += failed;
-        totalTimedOut += timedOut;
-        totalSkipped += skipped;
-        totalInterrupted += interrupted;
-        totalSelfHealed += selfHealed;
-        totalDuration += fileDuration;
-        markdown += `| ${suite.file} | ${passed ? passed + ' ✅' : ''} | ${selfHealed ? selfHealed + ' ❤️‍🩹' : ''} | ${failed ? failed + ' ❌' : ''} | ${timedOut ? timedOut + ' ⏰' : ''} | ${skipped ? skipped + ' ⏭️' : ''} | ${interrupted ? interrupted + ' ⚡' : ''} | ${formatDuration(fileDuration)} |\n`;
+            }
+        }
+        return row;
     });
-    markdown += `| **TOTAL** | **${totalPassed + ' ✅'}** | **${totalSelfHealed + ' ❤️‍🩹'}** | **${totalFailed + ' ❌'}** | **${totalTimedOut + ' ⏰'}** | **${totalSkipped + ' ⏭️'}** | **${totalInterrupted + ' ⚡'}** | **${formatDuration(totalDuration)}** |\n`;
+    const totals = suiteRows.reduce((acc, row) => ({
+        file: '**TOTAL**',
+        passed: acc.passed + row.passed,
+        flaky: acc.flaky + row.flaky,
+        expectedFailures: acc.expectedFailures + row.expectedFailures,
+        selfHealed: acc.selfHealed + row.selfHealed,
+        failed: acc.failed + row.failed,
+        timedOut: acc.timedOut + row.timedOut,
+        skipped: acc.skipped + row.skipped,
+        interrupted: acc.interrupted + row.interrupted,
+        duration: acc.duration + row.duration,
+    }), {
+        file: '**TOTAL**',
+        passed: 0,
+        flaky: 0,
+        expectedFailures: 0,
+        selfHealed: 0,
+        failed: 0,
+        timedOut: 0,
+        skipped: 0,
+        interrupted: 0,
+        duration: 0,
+    });
+    const includeExpectedFailures = totals.expectedFailures > 0;
+    const expectedFailuresHeader = includeExpectedFailures
+        ? ` Expected Failures |`
+        : '';
+    markdown += `| File | Passed | Flaky |${expectedFailuresHeader} Self-Healed | Failed | Timed Out | Skipped | Interrupted | Duration |\n`;
+    markdown += `| - | - | - |${includeExpectedFailures ? ' - |' : ''} - | - | - | - | - | - |\n`;
+    const cell = (count, emoji, bold) => {
+        const text = bold
+            ? `**${count} ${emoji}**`
+            : count
+                ? `${count} ${emoji}`
+                : '';
+        return ` ${text} |`;
+    };
+    for (const row of [...suiteRows, totals]) {
+        const bold = row === totals;
+        markdown += `| ${row.file} |`;
+        markdown += cell(row.passed, '✅', bold);
+        markdown += cell(row.flaky, '🔁', bold);
+        if (includeExpectedFailures) {
+            markdown += cell(row.expectedFailures, '☑️', bold);
+        }
+        markdown += cell(row.selfHealed, '❤️‍🩹', bold);
+        markdown += cell(row.failed, '❌', bold);
+        markdown += cell(row.timedOut, '⏰', bold);
+        markdown += cell(row.skipped, '⏭️', bold);
+        markdown += cell(row.interrupted, '⚡', bold);
+        const duration = formatDuration(row.duration);
+        markdown += ` ${bold ? `**${duration}**` : duration} |\n`;
+    }
     markdown += `\n`;
     // Per-test details
     suites.forEach((suite) => {
@@ -100,9 +170,9 @@ function renderMarkdown(report) {
         (0, reportWalk_1.collectSpecs)(suite).forEach((spec) => {
             markdown += `### ${spec.title}\n\n`;
             (spec.tests ?? []).forEach((test) => {
-                const result = test.results?.at(-1);
-                if (test.status === 'skipped' ||
-                    (!result && test.status === undefined)) {
+                const status = (0, reportWalk_1.statusOf)(test);
+                const result = displayResultOf(test, status);
+                if (status === 'skipped') {
                     markdown += `**Status**: ⏭️ Skipped  \n`;
                     markdown += `**Duration**: N/A  \n`;
                     if (Array.isArray(test.tags) && test.tags.length > 0) {
@@ -116,47 +186,32 @@ function renderMarkdown(report) {
                     markdown += `\n---\n\n`;
                     return;
                 }
-                const healed = (0, reportWalk_1.isSelfHealed)(test);
-                let status;
-                if (healed) {
-                    status = '❤️‍🩹 Healed';
-                }
-                else {
-                    switch (result.status) {
-                        case 'passed':
-                            status = '✅ Passed';
-                            break;
-                        case 'failed':
-                            status = '❌ Failed';
-                            break;
-                        case 'timedOut':
-                            status = '⏰ Timed Out';
-                            break;
-                        case 'skipped':
-                            status = '⏭️ Skipped';
-                            break;
-                        case 'interrupted':
-                            status = '⚡ Interrupted';
-                            break;
-                        default:
-                            status = `⚠️ ${result.status || 'Unknown'}`;
-                    }
-                }
-                const duration = formatDuration(result.duration || 0);
-                markdown += `**Status**: ${status}  \n`;
+                const duration = formatDuration(result?.duration || 0);
+                markdown += `**Status**: ${STATUS_LABELS[status]}  \n`;
                 markdown += `**Duration**: ${duration}  \n`;
                 if (Array.isArray(test.tags) && test.tags.length > 0) {
                     markdown += `**Tags**: ${test.tags.join(' ')}  \n`;
                 }
-                if (healed) {
+                if (status === 'healed') {
                     markdown += `> ❤️‍🩹 This test was automatically healed by re-running with Donobu treatment plan directives.\n\n`;
                 }
+                if (status === 'flaky') {
+                    markdown += `> 🔁 This test failed and then passed on a retry.\n\n`;
+                }
+                const notReattempted = test.annotations?.find((a) => a.type === 'auto-heal-not-reattempted');
+                if (notReattempted) {
+                    markdown += `> ⚠️ ${notReattempted.description}\n\n`;
+                }
+                const rerunFailed = test.annotations?.find((a) => a.type === 'auto-heal-rerun-failed');
+                if (rerunFailed) {
+                    markdown += `> ⚠️ ${rerunFailed.description}\n\n`;
+                }
                 const objectiveAnnotation = test.annotations?.find((a) => a.type === 'objective');
                 if (objectiveAnnotation) {
                     const objective = (objectiveAnnotation.description || 'No objective provided').replace(/```/g, '\\`\\`\\`');
                     markdown += `**Objective**:\n\`\`\`\n${objective}\n\`\`\`\n`;
                 }
-                if (result.status === 'failed' && result.error) {
+                if (result?.status === 'failed' && result.error) {
                     markdown += `\n<details>\n<summary>⚠️ Error Details</summary>\n\n`;
                     markdown += `\`\`\`\n${(0, ansi_1.stripAnsi)(result.error.message || '') || 'No error message available'}\n\`\`\`\n\n`;
                     if (result.error.snippet) {

package/dist/reporter/renderSlack.js

@@ -17,6 +17,8 @@ function renderSlack(report, options = {}) {
         text: { type: 'plain_text', text: '🐵 Donobu Test Summary' },
     });
     let totalPassed = 0;
+    let totalFlaky = 0;
+    let totalExpectedFailures = 0;
     let totalFailed = 0;
     let totalTimedOut = 0;
     let totalSkipped = 0;
@@ -25,41 +27,50 @@ function renderSlack(report, options = {}) {
     suites.forEach((suite) => {
         (0, reportWalk_1.collectSpecs)(suite).forEach((spec) => {
             (spec.tests ?? []).forEach((test) => {
-                const result = test.results?.at(-1);
-                const healed = (0, reportWalk_1.isSelfHealed)(test);
-                if (test.status === 'skipped' ||
-                    (!result && test.status === undefined)) {
-                    totalSkipped++;
-                }
-                else if (result) {
-                    if (healed) {
+                switch ((0, reportWalk_1.statusOf)(test)) {
+                    case 'passed':
+                        totalPassed++;
+                        break;
+                    case 'flaky':
+                        totalFlaky++;
+                        break;
+                    case 'expectedFailure':
+                        totalExpectedFailures++;
+                        break;
+                    case 'healed':
                         totalSelfHealed++;
-                    }
-                    else {
-                        switch (result.status) {
-                            case 'passed':
-                                totalPassed++;
-                                break;
-                            case 'failed':
-                                totalFailed++;
-                                break;
-                            case 'timedOut':
-                                totalTimedOut++;
-                                break;
-                            case 'skipped':
-                                totalSkipped++;
-                                break;
-                            case 'interrupted':
-                                totalInterrupted++;
-                                break;
-                        }
-                    }
+                        break;
+                    case 'timedOut':
+                        totalTimedOut++;
+                        break;
+                    case 'skipped':
+                        totalSkipped++;
+                        break;
+                    case 'interrupted':
+                        totalInterrupted++;
+                        break;
+                    default:
+                        // 'failed' and 'unknown' both count as failures.
+                        totalFailed++;
+                        break;
                 }
             });
         });
     });
     const statusRows = [
         { name: 'Passed', emoji: '✅', count: totalPassed },
+        { name: 'Flaky', emoji: '🔁', count: totalFlaky },
+        // Expected failures are rare enough that a permanent zero row would be
+        // clutter; anyone using test.fail() will see the row when it matters.
+        ...(totalExpectedFailures > 0
+            ? [
+                {
+                    name: 'Expected Failures',
+                    emoji: '☑️',
+                    count: totalExpectedFailures,
+                },
+            ]
+            : []),
         { name: 'Self-Healed', emoji: '❤️‍🩹', count: totalSelfHealed },
         { name: 'Failed', emoji: '❌', count: totalFailed },
         { name: 'Timed Out', emoji: '⏰', count: totalTimedOut },