donobu 5.60.1 → 5.60.3

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

@@ -0,0 +1,228 @@
+"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.computeGatedProjects = computeGatedProjects;
+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;
+}
+/**
+ * The projects the rerun gate should apply to: the heal targets' own
+ * projects, minus any project that is a declared (transitive) dependency of
+ * another target project — the dependency declaration wins, and that project
+ * runs in full.
+ */
+function computeGatedProjects(targetProjects, projectDependencies) {
+    const targets = [
+        ...new Set(targetProjects.filter((name) => Boolean(name))),
+    ];
+    if (!projectDependencies) {
+        return targets;
+    }
+    // Every project reachable through any target's declared dependency chain.
+    const reachable = new Set();
+    const visit = (name) => {
+        for (const dependency of projectDependencies[name] ?? []) {
+            if (!reachable.has(dependency)) {
+                reachable.add(dependency);
+                visit(dependency);
+            }
+        }
+    };
+    targets.forEach(visit);
+    return targets.filter((name) => !reachable.has(name));
+}
+/**
+ * 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 cachedPlan;
+function loadPlan(planPathOverride) {
+    if (planPathOverride === undefined && cachedPlan !== undefined) {
+        return cachedPlan;
+    }
+    const planPath = planPathOverride ?? envVars_1.env.data.DONOBU_AUTO_HEAL_PLAN_PATH;
+    let loaded = null;
+    if (planPath) {
+        try {
+            const raw = fs_1.default.readFileSync(planPath, 'utf8');
+            const plan = JSON.parse(raw);
+            loaded = {
+                index: buildPlanIndex(plan),
+                gatedProjects: new Set(plan.gatedProjects ??
+                    // Older plans carry no project list — gate the targets' own
+                    // projects, leaving everything else (dependencies) untouched.
+                    plan.targets
+                        ?.map((target) => target.projectName)
+                        .filter((name) => Boolean(name)) ??
+                    []),
+            };
+        }
+        catch (error) {
+            Logger_1.appLogger.warn(`Auto-heal rerun plan at ${planPath} could not be read; running all collected tests.`, error);
+            loaded = null;
+        }
+    }
+    if (planPathOverride === undefined) {
+        cachedPlan = loaded;
+    }
+    return loaded;
+}
+/** Test-only: reset the memoized plan so each test can load its own. */
+function resetHealRerunPlanCacheForTesting() {
+    cachedPlan = undefined;
+}
+/**
+ * Called from the Donobu auto fixture before any browser fixture initializes.
+ * Outside heal reruns this is a no-op. During a rerun, tests in gated
+ * projects that are outside the plan are annotated and skipped on the spot —
+ * no context, no page, no cost. Tests in ungated projects (declared
+ * dependencies of the targets, teardown projects) always run.
+ */
+function maybeSkipForHealRerun(testInfo, options) {
+    const plan = loadPlan(options?.planPath);
+    if (!plan) {
+        return;
+    }
+    if (!plan.gatedProjects.has(testInfo.project.name)) {
+        return;
+    }
+    const shouldRun = shouldRunDuringHealRerun({
+        index: plan.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/managers/DonobuStack.d.ts

@@ -43,25 +43,25 @@ export type DonobuStack = {
  *       environment variables.
  */
 export declare function setupDonobuStack(donobuDeploymentEnvironment: DonobuDeploymentEnvironment, controlPanelFactory: ControlPanelFactory, envPersistenceVolatile?: EnvPersistenceVolatile, environ?: import("env-struct").Env<{
-    BASE64_GPT_CONFIG: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-    BROWSERBASE_API_KEY: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-    BROWSERBASE_PROJECT_ID: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-    DONOBU_API_BASE_URL: import("zod/v4").ZodDefault<import("zod/v4").ZodString>;
-    ANTHROPIC_API_KEY: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-    ANTHROPIC_MODEL_NAME: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-    GOOGLE_GENERATIVE_AI_API_KEY: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-    GOOGLE_GENERATIVE_AI_MODEL_NAME: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-    OLLAMA_MODEL_NAME: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-    OLLAMA_API_URL: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-    OPENAI_API_KEY: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-    OPENAI_API_MODEL_NAME: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-    PERSISTENCE_PRIORITY: import("zod/v4").ZodDefault<import("zod/v4").ZodArray<import("zod/v4").ZodString>>;
-    AWS_BEDROCK_MODEL_NAME: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-    AWS_ACCESS_KEY_ID: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-    AWS_SECRET_ACCESS_KEY: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-    DONOBU_API_KEY: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-    DONOBU_PERSISTENCE_API_KEY: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-    DONOBU_UPLOADS_OWNED_BY_PARENT: import("zod/v4").ZodOptional<import("zod/v4").ZodCodec<import("zod/v4").ZodString, import("zod/v4").ZodBoolean>>;
+    BASE64_GPT_CONFIG: import("zod").ZodOptional<import("zod").ZodString>;
+    BROWSERBASE_API_KEY: import("zod").ZodOptional<import("zod").ZodString>;
+    BROWSERBASE_PROJECT_ID: import("zod").ZodOptional<import("zod").ZodString>;
+    DONOBU_API_BASE_URL: import("zod").ZodDefault<import("zod").ZodString>;
+    ANTHROPIC_API_KEY: import("zod").ZodOptional<import("zod").ZodString>;
+    ANTHROPIC_MODEL_NAME: import("zod").ZodOptional<import("zod").ZodString>;
+    GOOGLE_GENERATIVE_AI_API_KEY: import("zod").ZodOptional<import("zod").ZodString>;
+    GOOGLE_GENERATIVE_AI_MODEL_NAME: import("zod").ZodOptional<import("zod").ZodString>;
+    OLLAMA_MODEL_NAME: import("zod").ZodOptional<import("zod").ZodString>;
+    OLLAMA_API_URL: import("zod").ZodOptional<import("zod").ZodString>;
+    OPENAI_API_KEY: import("zod").ZodOptional<import("zod").ZodString>;
+    OPENAI_API_MODEL_NAME: import("zod").ZodOptional<import("zod").ZodString>;
+    PERSISTENCE_PRIORITY: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    AWS_BEDROCK_MODEL_NAME: import("zod").ZodOptional<import("zod").ZodString>;
+    AWS_ACCESS_KEY_ID: import("zod").ZodOptional<import("zod").ZodString>;
+    AWS_SECRET_ACCESS_KEY: import("zod").ZodOptional<import("zod").ZodString>;
+    DONOBU_API_KEY: import("zod").ZodOptional<import("zod").ZodString>;
+    DONOBU_PERSISTENCE_API_KEY: import("zod").ZodOptional<import("zod").ZodString>;
+    DONOBU_UPLOADS_OWNED_BY_PARENT: import("zod").ZodOptional<import("zod").ZodCodec<import("zod").ZodString, import("zod").ZodBoolean>>;
 }, {
     BASE64_GPT_CONFIG?: string | undefined;
     BROWSERBASE_API_KEY?: string | undefined;

package/dist/esm/reporter/buildReport.js

@@ -41,6 +41,27 @@ function buildDonobuReport(resultsByTest, rootDir) {
         }
         byTitle.get(test.title).push(test);
     }
+    // Declared project dependency graph (`FullProject.dependencies`), keyed by
+    // project name. The auto-heal orchestrator uses it to keep the rerun gate
+    // away from projects that are declared dependencies of heal targets — those
+    // must run in full, exactly as Playwright schedules them.
+    const projectDependencies = {};
+    for (const test of resultsByTest.keys()) {
+        try {
+            let suite = test.parent;
+            while (suite && suite.type !== 'project') {
+                suite = suite.parent;
+            }
+            const project = suite?.project();
+            if (project?.name && !(project.name in projectDependencies)) {
+                projectDependencies[project.name] = [...(project.dependencies ?? [])];
+            }
+        }
+        catch {
+            // Reporter shape drift — omit the entry; the orchestrator degrades to
+            // gating only the heal targets' own projects.
+        }
+    }
     const suites = [];
     for (const [file, titleMap] of byFile) {
         const specs = [];
@@ -58,6 +79,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,
@@ -108,7 +137,31 @@ function buildDonobuReport(resultsByTest, rootDir) {
         }
         suites.push({ file, specs });
     }
-    return { suites, metadata: {} };
+    return { suites, metadata: { projectDependencies } };
+}
+/**
+ * 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) {

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
@@ -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/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