donobu 5.60.0 → 5.60.2

package/dist/esm/lib/test/healRerunGate.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * @fileoverview Runtime gate for auto-heal reruns.
+ *
+ * The auto-heal rerun is launched with the same project-level arguments as the
+ * initial run so Playwright's scheduling (declared project `dependencies`,
+ * workers, ordering) behaves with full fidelity. Within the targeted projects,
+ * however, only the tests the heal actually needs should execute. This module
+ * enforces that from an auto fixture that runs before any browser fixture:
+ * when `DONOBU_AUTO_HEAL_PLAN_PATH` is set, every test not in the rerun plan
+ * skips immediately — before a context or page is created — annotated with
+ * `donobu-heal-skip-replay` so the merge step drops the entry and leaves the
+ * initial run's result untouched.
+ *
+ * What runs during a heal rerun (the "declared signals only" policy):
+ *   - Heal targets (the failed tests with actionable treatment plans).
+ *   - For a target inside a `test.describe.serial` scope (or a file marked
+ *     serial via `test.describe.configure({ mode: 'serial' })`): the other
+ *     serial-scoped tests in that file. Serial mode is Playwright's declared
+ *     intra-file ordering contract — Playwright itself re-runs whole serial
+ *     groups on retry, and we mirror that. The orchestrator expands the plan
+ *     with these companions before the rerun (see
+ *     `expandTargetsWithSerialCompanions`) using the `serialScoped` flags the
+ *     Donobu reporter recorded during the initial run — the runner process
+ *     sees the suite tree; the worker (where this gate runs) does not.
+ *   - Declared dependency projects, which Playwright always runs in full.
+ *
+ * Implicit ordering (checkpoint files between plain tests, cross-file state
+ * with `workers: 1`) is deliberately NOT honored: tests relying on it will
+ * skip themselves during the rerun and surface as honest failures with
+ * guidance to declare the dependency.
+ *
+ * The gate runs at test runtime rather than collection time so Playwright's
+ * test-location attribution stays untouched (a collection-time wrapper would
+ * become every test's reported call site, breaking the merge's file-based
+ * matching) and so the plan can be matched against `testInfo.file`/`title`
+ * exactly instead of via stack inspection.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPlanIndex = buildPlanIndex;
+exports.shouldRunDuringHealRerun = shouldRunDuringHealRerun;
+exports.expandTargetsWithSerialCompanions = expandTargetsWithSerialCompanions;
+exports.resetHealRerunPlanCacheForTesting = resetHealRerunPlanCacheForTesting;
+exports.maybeSkipForHealRerun = maybeSkipForHealRerun;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const envVars_1 = require("../../envVars");
+const model_1 = require("../../reporter/model");
+const Logger_1 = require("../../utils/Logger");
+function buildPlanIndex(plan) {
+    const index = new Map();
+    for (const target of plan.targets ?? []) {
+        if (!target?.file || !target?.title) {
+            continue;
+        }
+        const file = path_1.default.resolve(target.file);
+        if (!index.has(file)) {
+            index.set(file, new Set());
+        }
+        index.get(file).add(target.title);
+    }
+    return index;
+}
+/**
+ * Pure decision: should the test in `file` with `title` actually execute
+ * during the heal rerun? The plan is fully explicit — serial companions were
+ * already expanded into it by the orchestrator.
+ */
+function shouldRunDuringHealRerun(params) {
+    const titles = params.index.get(path_1.default.resolve(params.file));
+    return titles?.has(params.title) ?? false;
+}
+/**
+ * Expand heal targets with their `describe.serial` siblings, using the
+ * `serialScoped` flags the Donobu reporter recorded in the initial run's
+ * report. Companions live in the same file as their target by construction
+ * (serial scopes are intra-file), so they inherit the target's absolute file
+ * path; report file paths are rootDir-relative, hence the suffix match.
+ *
+ * Degrades to the unexpanded targets when the report (or the flags) are
+ * unavailable — serial chains then surface as honest not-reattempted
+ * failures instead of healing.
+ */
+function expandTargetsWithSerialCompanions(targets, initialReport) {
+    const suites = (initialReport?.suites ?? []);
+    const expanded = [...targets];
+    const seen = new Set(targets.map((t) => `${path_1.default.resolve(t.file)}::${t.projectName}::${t.title}`));
+    for (const target of targets) {
+        if (!target.file || !target.title) {
+            continue;
+        }
+        const targetFile = path_1.default.resolve(target.file);
+        for (const suite of suites) {
+            const suiteFile = String(suite.file ?? '');
+            if (!targetFile.endsWith(path_1.default.normalize(suiteFile)) ||
+                suiteFile.length === 0) {
+                continue;
+            }
+            const specs = suite.specs ?? [];
+            const targetEntry = specs
+                .find((spec) => spec.title === target.title)
+                ?.tests?.find((test) => !target.projectName || test.projectName === target.projectName);
+            if (!targetEntry?.serialScoped) {
+                continue;
+            }
+            // The target is serial-scoped: every serial-scoped test in this file
+            // (same project) joins the plan. Bounded by the file, mirroring how
+            // Playwright re-runs whole serial groups on retry.
+            for (const spec of specs) {
+                for (const test of spec.tests ?? []) {
+                    if (!test.serialScoped) {
+                        continue;
+                    }
+                    if (target.projectName && test.projectName !== target.projectName) {
+                        continue;
+                    }
+                    const key = `${targetFile}::${test.projectName}::${spec.title}`;
+                    if (seen.has(key)) {
+                        continue;
+                    }
+                    seen.add(key);
+                    expanded.push({
+                        file: target.file,
+                        title: spec.title,
+                        projectName: test.projectName,
+                    });
+                }
+            }
+        }
+    }
+    return expanded;
+}
+let cachedPlanIndex;
+function getPlanIndex(planPathOverride) {
+    if (planPathOverride === undefined && cachedPlanIndex !== undefined) {
+        return cachedPlanIndex;
+    }
+    const planPath = planPathOverride ?? envVars_1.env.data.DONOBU_AUTO_HEAL_PLAN_PATH;
+    let index = null;
+    if (planPath) {
+        try {
+            const raw = fs_1.default.readFileSync(planPath, 'utf8');
+            index = buildPlanIndex(JSON.parse(raw));
+        }
+        catch (error) {
+            Logger_1.appLogger.warn(`Auto-heal rerun plan at ${planPath} could not be read; running all collected tests.`, error);
+            index = null;
+        }
+    }
+    if (planPathOverride === undefined) {
+        cachedPlanIndex = index;
+    }
+    return index;
+}
+/** Test-only: reset the memoized plan so each test can load its own. */
+function resetHealRerunPlanCacheForTesting() {
+    cachedPlanIndex = undefined;
+}
+/**
+ * Called from the Donobu auto fixture before any browser fixture initializes.
+ * Outside heal reruns this is a no-op. During a rerun, tests outside the plan
+ * are annotated and skipped on the spot — no context, no page, no cost.
+ */
+function maybeSkipForHealRerun(testInfo, options) {
+    const index = getPlanIndex(options?.planPath);
+    if (!index) {
+        return;
+    }
+    const shouldRun = shouldRunDuringHealRerun({
+        index,
+        file: testInfo.file,
+        title: testInfo.title,
+    });
+    if (shouldRun) {
+        return;
+    }
+    testInfo.annotations.push({
+        type: model_1.HEAL_SKIP_REPLAY_ANNOTATION_TYPE,
+        description: 'Not part of the auto-heal rerun plan; the initial run result stands.',
+    });
+    testInfo.skip(true, 'Not part of the auto-heal rerun plan; the initial run result stands.');
+}
+//# sourceMappingURL=healRerunGate.js.map

package/dist/esm/lib/test/testExtension.d.ts

@@ -5,6 +5,7 @@ import { FlowLogBuffer } from '../../utils/FlowLogBuffer';
 import type { DonobuExtendedPage } from '../page/DonobuExtendedPage';
 export * from '@playwright/test';
 export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & {
+    healRerunGate: void;
     flowLoggingContext: {
         flowId: string;
         logBuffer: FlowLogBuffer;

package/dist/esm/lib/test/testExtension.js

@@ -41,6 +41,7 @@ const PageLogListeners_1 = require("../../utils/PageLogListeners");
 const cacheLocator_1 = require("../ai/cache/cacheLocator");
 const extendPage_1 = require("../page/extendPage");
 const tbd_1 = require("../page/tbd");
+const healRerunGate_1 = require("./healRerunGate");
 const selfHealing_1 = require("./utils/selfHealing");
 const triageTestFailure_1 = require("./utils/triageTestFailure");
 __exportStar(require("@playwright/test"), exports);
@@ -220,6 +221,20 @@ function persistVideoIfApplicable(page, testInfo, videoOption) {
  */
 const UPLOAD_DRAIN_TIMEOUT_MS = 30_000;
 exports.test = test_1.test.extend({
+    /**
+     * Auto-heal rerun gate. First in registration order so it runs before every
+     * other test-scoped fixture: during a heal rerun, tests outside the rerun
+     * plan skip here — before a browser context or page is ever created — with
+     * the `donobu-heal-skip-replay` annotation the merge step uses to drop
+     * their entries. A no-op outside heal reruns.
+     */
+    healRerunGate: [
+        async ({}, use, testInfo) => {
+            (0, healRerunGate_1.maybeSkipForHealRerun)(testInfo);
+            await use();
+        },
+        { scope: 'test', auto: true },
+    ],
     /**
      * Establish a logging scope for the entire Playwright test *before* any other
      * fixtures run. Playwright builds the fixture dependency graph eagerly, so
@@ -400,6 +415,7 @@ exports.test = test_1.test.extend({
             flowId: flowId,
             visualCueDurationMs: visualCueDurationMs,
             cacheFilepath: (0, cacheLocator_1.buildPageAiCachePath)(testInfo.file),
+            specFilePath: testInfo.file,
             envVars: (0, DonobuFlowsManager_1.distillAllowedEnvVariableNames)(overallObjective, testInfo.annotations
                 .filter((a) => a.type === 'ENV' && a.description)
                 .map((a) => a.description)),
@@ -1051,16 +1067,10 @@ async function finalizeTest(page, testInfo, logBuffer, videoOption) {
             }
         }
     }
-    else if (testInfo.status === 'passed' &&
-        MiscUtils_1.MiscUtils.yn(envVars_1.env.data.DONOBU_AUTO_HEAL_ACTIVE)) {
-        const hasSelfHealedAnnotation = testInfo.annotations.some((annotation) => annotation.type === 'self-healed');
-        if (!hasSelfHealedAnnotation) {
-            testInfo.annotations.push({
-                type: 'self-healed',
-                description: 'Automatically healed by Donobu auto-heal rerun.',
-            });
-        }
-    }
+    // Note: passing tests in an auto-heal rerun are NOT annotated here. Whether
+    // a test was actually healed (failed initially, passed on the rerun) is
+    // decided by the merge step, which sees both runs — annotating every rerun
+    // pass would mislabel dependency tests that never failed.
     // Flush any page.tbd() sessions: replace the tbd() call sites in the
     // source files with the generated Playwright code for the recorded
     // user interactions.

package/dist/esm/reporter/buildReport.js

@@ -58,6 +58,14 @@ function buildDonobuReport(resultsByTest, rootDir) {
                     // Signal "skipped" tests to the renderers the same way the JSON
                     // reporter does.
                     status: test.expectedStatus === 'skipped' ? 'skipped' : undefined,
+                    // Consumed by `reportWalk.statusOf` to classify `test.fail()`
+                    // specs as expected failures rather than real ones; absent from
+                    // the legacy state-file shape.
+                    expectedStatus: test.expectedStatus,
+                    // Whether the test sits inside a `describe.serial` scope — declared
+                    // intra-file ordering. The auto-heal orchestrator uses this to
+                    // include a heal target's serial siblings in the rerun plan.
+                    serialScoped: isSerialScoped(test),
                     results: results.map((r) => ({
                         status: r.status,
                         duration: r.duration,
@@ -110,6 +118,30 @@ function buildDonobuReport(resultsByTest, rootDir) {
     }
     return { suites, metadata: {} };
 }
+/**
+ * Whether any enclosing suite is in serial mode (`test.describe.serial` or
+ * `test.describe.configure({ mode: 'serial' })`).
+ *
+ * Reads the runner-side suite internals (`_parallelMode`) — reporters receive
+ * the runner's own Suite instances, which carry it. Verified against
+ * @playwright/test 1.58; guarded so shape drift degrades to `false` (serial
+ * chains then lose heal eligibility, but reporting stays honest).
+ */
+function isSerialScoped(test) {
+    try {
+        let suite = test.parent;
+        while (suite) {
+            if (suite._parallelMode === 'serial') {
+                return true;
+            }
+            suite = suite.parent;
+        }
+    }
+    catch {
+        // Internal shape drifted — treat as non-serial.
+    }
+    return false;
+}
 /** Walk up the suite chain to find the enclosing project suite's title. */
 function getProjectName(test) {
     let suite = test.parent;

package/dist/esm/reporter/merge.d.ts

@@ -11,17 +11,12 @@
  * call `mergeReports`, then persist / relocate attachments / re-render as
  * needed. Keeping the merge pure makes it trivial to test and reason about.
  */
-import type { DonobuReport, HealedTestDescriptor } from './model';
+import type { DonobuReport } from './model';
 export interface MergeReportsParams {
     /** Pre-loaded initial report, or null when the initial run produced none. */
     initialReport: DonobuReport | null;
     /** Pre-loaded heal-run report, or null when the heal run produced none. */
     healReport: DonobuReport | null;
-    /** Tests the orchestrator declared healed — used when the heal report
-     *  doesn't expose them under a matching key (e.g. filter rewrites). */
-    healedTests: HealedTestDescriptor[];
-    /** Whether the heal rerun exited cleanly. */
-    healSucceeded: boolean;
     /** Recorded in the merged report metadata for triage auto-discovery. */
     triageRunDir?: string;
     /** Recorded in the merged report metadata purely for provenance. */

package/dist/esm/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/esm/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

package/dist/esm/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/esm/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)}