donobu 5.60.1 → 5.60.3

package/dist/lib/page/extendPage.js

@@ -1,7 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extendPage = extendPage;
 const crypto_1 = require("crypto");
+const path_1 = __importDefault(require("path"));
 const v4_1 = require("zod/v4");
 const GptClient_1 = require("../../clients/GptClient");
 const VercelAiGptClient_1 = require("../../clients/VercelAiGptClient");
@@ -60,6 +64,25 @@ function resolveBaseUrl(page, url) {
 // Donobu page extension helpers: decorate Playwright pages with Donobu behaviors and keep one
 // coherent flow (and persistence record) per browser context so new tabs share state safely.
 const PLACEHOLDER_FLOW_URL = 'https://example.com';
+/**
+ * Whether Page.AI cache entries should be bypassed and invalidated for this
+ * context. Two knobs:
+ * - `DONOBU_PAGE_AI_CLEAR_CACHE` — run-wide, set by `--clear-ai-cache`.
+ * - `DONOBU_PAGE_AI_CLEAR_CACHE_FILES` — JSON array of spec paths, set by the
+ *   auto-heal rerun so only heal-target spec files regenerate selectors while
+ *   other re-running tests (serial prerequisites) keep their cache replay.
+ */
+function shouldClearPageAiCache(specFilePath) {
+    if (MiscUtils_1.MiscUtils.yn(envVars_1.env.data.DONOBU_PAGE_AI_CLEAR_CACHE)) {
+        return true;
+    }
+    const files = envVars_1.env.data.DONOBU_PAGE_AI_CLEAR_CACHE_FILES;
+    if (!files?.length || !specFilePath) {
+        return false;
+    }
+    const resolved = path_1.default.resolve(specFilePath);
+    return files.some((file) => path_1.default.resolve(file) === resolved);
+}
 // Cache the shared Donobu state per browser context so every tab in that context reuses the same
 // flow metadata, persistence, GPT client, and visualizer. WeakMap ensures cleanup when contexts die.
 const contextSharedState = new WeakMap();
@@ -137,7 +160,7 @@ async function extendPage(page, options) {
             gptClient: resolvedGptClient,
             controlPanelFactory: options?.controlPanelFactory,
             runtimeDirectives: {
-                clearPageAiCache: MiscUtils_1.MiscUtils.yn(envVars_1.env.data.DONOBU_PAGE_AI_CLEAR_CACHE),
+                clearPageAiCache: shouldClearPageAiCache(options?.specFilePath),
             },
             tbdSessions: [],
             aiInvocations: [],

package/dist/lib/test/healRerunGate.d.ts

@@ -0,0 +1,102 @@
+/**
+ * @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.
+ */
+import type { TestInfo } from '@playwright/test';
+/** Shape of the plan file the auto-heal orchestrator writes before the rerun. */
+export interface HealRerunPlan {
+    targets: Array<{
+        /** Spec file path; absolute, or relative to the rerun's CWD. */
+        file: string;
+        title: string;
+        projectName?: string;
+    }>;
+    /**
+     * Projects the gate applies to. Tests in any other project — declared
+     * dependency projects (auth/setup), teardown projects — run untouched,
+     * exactly as Playwright schedules them. Computed by the orchestrator via
+     * `computeGatedProjects`; when absent, the gate falls back to the targets'
+     * own project names.
+     */
+    gatedProjects?: string[];
+}
+/** Targets indexed by absolute spec path for O(1) per-test decisions. */
+export type HealRerunPlanIndex = Map<string, Set<string>>;
+export declare function buildPlanIndex(plan: HealRerunPlan): HealRerunPlanIndex;
+/**
+ * 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.
+ */
+export declare function computeGatedProjects(targetProjects: Array<string | undefined>, projectDependencies: Record<string, string[]> | undefined): string[];
+/**
+ * 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.
+ */
+export declare function shouldRunDuringHealRerun(params: {
+    index: HealRerunPlanIndex;
+    file: string;
+    title: string;
+}): boolean;
+/**
+ * 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.
+ */
+export declare function expandTargetsWithSerialCompanions(targets: HealRerunPlan['targets'], initialReport: {
+    suites?: unknown;
+} | null): HealRerunPlan['targets'];
+/** Test-only: reset the memoized plan so each test can load its own. */
+export declare function resetHealRerunPlanCacheForTesting(): void;
+/**
+ * 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.
+ */
+export declare function maybeSkipForHealRerun(testInfo: TestInfo, options?: {
+    planPath?: string;
+}): void;
+//# sourceMappingURL=healRerunGate.d.ts.map

package/dist/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/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/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/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/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/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. */