donobu 2.47.0 → 2.48.0

package/dist/assets/generated/version

@@ -1 +1 @@
-1413
+1423

package/dist/cli/donobu-cli.js

@@ -64,13 +64,14 @@ const triageTestFailure_1 = require("../lib/utils/triageTestFailure");
 const Logger_1 = require("../utils/Logger");
 const FAILURE_EVIDENCE_PREFIX = 'failure-evidence-';
 const TREATMENT_PLAN_PREFIX = 'treatment-plan-';
+const PLAYWRIGHT_JSON_REPORT_FILENAME = 'report.json';
 /**
  * Execute `npx playwright` while wiring Donobu-specific environment controls.
  * Streams stdout/stderr to the current process so our CLI mirrors the native
  * Playwright experience, and forwards termination signals to keep CI parity.
  */
 async function runPlaywright(args, envOverrides = {}) {
-    Logger_1.appLogger.info(`Running Playwright with args: ${JSON.stringify(args)}`);
+    Logger_1.appLogger.debug(`Running Playwright with args: ${JSON.stringify(args)}`);
     if (Object.keys(envOverrides).length > 0) {
         Logger_1.appLogger.debug(`Playwright env overrides: ${JSON.stringify(envOverrides, null, 2)}`);
     }
@@ -298,20 +299,23 @@ const noopAsync = async () => { };
  * wrapper config when necessary so we can append the JSON reporter alongside
  * user-specified reporters.
  */
-async function ensureJsonReporter(originalArgs) {
+async function ensureJsonReporter(originalArgs, options = {}) {
     const args = [...originalArgs];
-    if (injectJsonReporterIntoArgs(args)) {
+    if (injectJsonReporterIntoArgs(args, options)) {
         return { args, cleanup: noopAsync };
     }
     const configPath = await resolvePlaywrightConfigPath(args);
     if (!configPath) {
         if (!hasReporterArg(args)) {
-            args.push('--reporter=json');
+            const reporterValue = options.jsonOutputFile
+                ? `json=${options.jsonOutputFile}`
+                : 'json';
+            args.push(`--reporter=${reporterValue}`);
         }
         Logger_1.appLogger.debug('No Playwright config detected; falling back to CLI --reporter=json injection.');
         return { args, cleanup: noopAsync };
     }
-    const { configPath: wrapperPath, cleanup } = await createConfigWrapperWithJsonReporter(configPath);
+    const { configPath: wrapperPath, cleanup } = await createConfigWrapperWithJsonReporter(configPath, options);
     Logger_1.appLogger.debug(`Augmenting Playwright config at ${configPath} with temporary wrapper ${wrapperPath} to ensure JSON reporter.`);
     const strippedArgs = stripConfigArgs(args);
     const finalArgs = insertConfigArg(strippedArgs, wrapperPath);
@@ -331,7 +335,7 @@ function hasReporterArg(args) {
     }
     return false;
 }
-function injectJsonReporterIntoArgs(args) {
+function injectJsonReporterIntoArgs(args, options = {}) {
     let reporterFlagFound = false;
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i];
@@ -342,7 +346,7 @@ function injectJsonReporterIntoArgs(args) {
             reporterFlagFound = true;
             const valueIndex = i + 1;
             if (valueIndex < args.length) {
-                const { value, changed } = ensureReporterValueHasJson(args[valueIndex]);
+                const { value, changed } = ensureReporterValueHasJson(args[valueIndex], options);
                 args[valueIndex] = value;
                 if (changed) {
                     reporterFlagFound = true;
@@ -354,13 +358,13 @@ function injectJsonReporterIntoArgs(args) {
         if (arg.startsWith('--reporter=') || arg.startsWith('-r=')) {
             reporterFlagFound = true;
             const [prefix, rawValue] = arg.split('=', 2);
-            const { value } = ensureReporterValueHasJson(rawValue ?? '');
+            const { value } = ensureReporterValueHasJson(rawValue ?? '', options);
             args[i] = `${prefix}=${value}`;
         }
     }
     return reporterFlagFound;
 }
-function ensureReporterValueHasJson(value) {
+function ensureReporterValueHasJson(value, options = {}) {
     const segments = value
         .split(',')
         .map((segment) => segment.trim())
@@ -369,7 +373,10 @@ function ensureReporterValueHasJson(value) {
     if (hasJson) {
         return { value, changed: false };
     }
-    segments.push('json');
+    const jsonEntry = options.jsonOutputFile
+        ? `json=${options.jsonOutputFile}`
+        : 'json';
+    segments.push(jsonEntry);
     return { value: segments.join(','), changed: true };
 }
 async function resolvePlaywrightConfigPath(args) {
@@ -447,10 +454,10 @@ function insertConfigArg(args, configPath) {
         ...args.slice(dashDashIndex),
     ];
 }
-async function createConfigWrapperWithJsonReporter(originalConfigPath) {
+async function createConfigWrapperWithJsonReporter(originalConfigPath, options = {}) {
     const stagingDir = await fs_1.promises.mkdtemp(path.join(os.tmpdir(), 'donobu-playwright-config-'));
     const wrapperPath = path.join(stagingDir, 'playwright.config.cjs');
-    const content = buildConfigWrapperContent(originalConfigPath);
+    const content = buildConfigWrapperContent(originalConfigPath, options.jsonOutputFile);
     await fs_1.promises.writeFile(wrapperPath, content, 'utf-8');
     const cleanup = async () => {
         try {
@@ -462,11 +469,17 @@ async function createConfigWrapperWithJsonReporter(originalConfigPath) {
     };
     return { configPath: wrapperPath, cleanup };
 }
-function buildConfigWrapperContent(originalConfigPath) {
+function buildConfigWrapperContent(originalConfigPath, jsonOutputFileOverride) {
     const sanitisedPath = originalConfigPath.replace(/\\/g, '\\\\');
-    return `'use strict';
+    const forcedJsonPath = jsonOutputFileOverride
+        ? jsonOutputFileOverride.replace(/\\/g, '\\\\')
+        : null;
+    const defaultJsonName = PLAYWRIGHT_JSON_REPORT_FILENAME;
+    const forcedLiteral = forcedJsonPath ? `'${forcedJsonPath}'` : 'null';
+    return `"use strict";
 
 const path = require('path');
+const forcedJsonOutputFile = ${forcedLiteral};
 
 function loadBaseConfig() {
   const imported = require('${sanitisedPath}');
@@ -544,7 +557,10 @@ if (Array.isArray(normalizedConfig.projects)) {
       if (typeof useConfig.storageState === 'string') {
         useConfig.storageState = absolutify(useConfig.storageState);
       }
-      if (typeof useConfig.baseURL === 'string' && !/^https?:/i.test(useConfig.baseURL)) {
+      if (
+        typeof useConfig.baseURL === 'string' &&
+        !/^https?:/i.test(useConfig.baseURL)
+      ) {
         useConfig.baseURL = absolutify(useConfig.baseURL);
       }
       projectConfig.use = useConfig;
@@ -580,18 +596,46 @@ const hasJsonReporter = reporters.some((entry) => {
 });
 
 if (!hasJsonReporter) {
-  const outputDir = process.env.PLAYWRIGHT_JSON_OUTPUT_DIR
-    ? path.resolve(process.cwd(), process.env.PLAYWRIGHT_JSON_OUTPUT_DIR)
-    : path.resolve(configDir, 'test-results');
-  const outputName = process.env.PLAYWRIGHT_JSON_OUTPUT_NAME || 'report.json';
-  const outputFile = path.isAbsolute(outputName)
-    ? outputName
-    : path.join(outputDir, outputName);
+  const outputFile =
+    forcedJsonOutputFile ||
+    (() => {
+      const outputDir = process.env.PLAYWRIGHT_JSON_OUTPUT_DIR
+        ? path.resolve(process.cwd(), process.env.PLAYWRIGHT_JSON_OUTPUT_DIR)
+        : path.resolve(configDir, 'test-results');
+      const outputName =
+        process.env.PLAYWRIGHT_JSON_OUTPUT_NAME || '${defaultJsonName}';
+      return path.isAbsolute(outputName)
+        ? outputName
+        : path.join(outputDir, outputName);
+    })();
   reporters.push(['json', { outputFile }]);
 }
 
 const normalisedReporters = reporters.map((entry) => {
-  if (Array.isArray(entry) && entry.length > 1 && entry[1] && typeof entry[1] === 'object') {
+  if (typeof entry === 'string') {
+    if (!forcedJsonOutputFile) {
+      return entry;
+    }
+    const segments = entry
+      .split(',')
+      .map((segment) => segment.trim())
+      .filter((segment) => segment.length > 0);
+    const rewritten = segments.map((segment) => {
+      const [name] = segment.split('=', 2);
+      if (name === 'json') {
+        return \`json=\${forcedJsonOutputFile}\`;
+      }
+      return segment;
+    });
+    return rewritten.join(',');
+  }
+
+  if (
+    Array.isArray(entry) &&
+    entry.length > 1 &&
+    entry[1] &&
+    typeof entry[1] === 'object'
+  ) {
     const options = { ...entry[1] };
     if (options.outputFile) {
       options.outputFile = absolutify(options.outputFile);
@@ -599,8 +643,19 @@ const normalisedReporters = reporters.map((entry) => {
     if (options.outputFolder) {
       options.outputFolder = absolutify(options.outputFolder);
     }
+    if (entry[0] === 'json' && forcedJsonOutputFile) {
+      options.outputFile = forcedJsonOutputFile;
+    }
     return [entry[0], options];
   }
+
+  if (Array.isArray(entry) && entry.length > 0) {
+    const name = typeof entry[0] === 'string' ? entry[0] : '';
+    if (name === 'json' && forcedJsonOutputFile) {
+      return [entry[0], { outputFile: forcedJsonOutputFile }];
+    }
+    return entry;
+  }
   return entry;
 });
 
@@ -615,23 +670,113 @@ module.exports = {
  * We keep a stable snapshot because Playwright may delete the file between
  * retries or when the `--output` folder is cleaned.
  */
-async function copyJsonReport(outputDir, destinationPath) {
-    const sourcePath = path.join(outputDir, 'report.json');
+async function copyJsonReport(outputDir, destinationPath, options = {}) {
+    const candidatePaths = new Set();
+    const envDefinedPath = resolveEnvJsonReportPath(options.envOverrides);
+    if (envDefinedPath) {
+        candidatePaths.add(envDefinedPath);
+    }
+    candidatePaths.add(path.join(outputDir, PLAYWRIGHT_JSON_REPORT_FILENAME));
+    (options.additionalCandidates ?? []).forEach((candidate) => {
+        if (candidate) {
+            candidatePaths.add(candidate);
+        }
+    });
+    for (const sourcePath of candidatePaths) {
+        const copied = await tryCopyReport(sourcePath, destinationPath);
+        if (copied) {
+            return { sourcePath, destinationPath };
+        }
+    }
+    const fallbackSource = await findJsonReportInDir(outputDir);
+    if (fallbackSource) {
+        const copied = await tryCopyReport(fallbackSource, destinationPath);
+        if (copied) {
+            return { sourcePath: fallbackSource, destinationPath };
+        }
+    }
+    return null;
+}
+function resolveEnvJsonReportPath(envOverrides) {
+    if (!envOverrides) {
+        return null;
+    }
+    const outputDir = envOverrides.PLAYWRIGHT_JSON_OUTPUT_DIR;
+    const outputName = envOverrides.PLAYWRIGHT_JSON_OUTPUT_NAME;
+    if (!outputDir || !outputName) {
+        return null;
+    }
+    const resolvedDir = path.isAbsolute(outputDir)
+        ? outputDir
+        : path.resolve(process.cwd(), outputDir);
+    return path.isAbsolute(outputName)
+        ? outputName
+        : path.join(resolvedDir, outputName);
+}
+async function tryCopyReport(sourcePath, destinationPath) {
     try {
         await fs_1.promises.access(sourcePath, fs_1.constants.F_OK);
     }
     catch {
-        return null;
+        return false;
     }
     await ensureDirectory(path.dirname(destinationPath));
     try {
         await fs_1.promises.copyFile(sourcePath, destinationPath);
-        return destinationPath;
+        return true;
     }
     catch (error) {
         Logger_1.appLogger.warn(`Failed to copy Playwright JSON report from ${sourcePath} to ${destinationPath}.`, error);
+        return false;
+    }
+}
+async function findJsonReportInDir(outputDir) {
+    let entries;
+    try {
+        entries = await fs_1.promises.readdir(outputDir);
+    }
+    catch {
         return null;
     }
+    const candidates = entries
+        .filter((entry) => entry.endsWith('.json'))
+        .sort((a, b) => {
+        const aScore = a.includes('report') ? 0 : 1;
+        const bScore = b.includes('report') ? 0 : 1;
+        if (aScore !== bScore) {
+            return aScore - bScore;
+        }
+        return a.localeCompare(b);
+    });
+    for (const fileName of candidates) {
+        const fullPath = path.join(outputDir, fileName);
+        if (await isLikelyPlaywrightReport(fullPath)) {
+            return fullPath;
+        }
+    }
+    return null;
+}
+async function isLikelyPlaywrightReport(filePath) {
+    try {
+        const raw = await fs_1.promises.readFile(filePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        return (!!parsed && typeof parsed === 'object' && Array.isArray(parsed.suites));
+    }
+    catch {
+        return false;
+    }
+}
+async function overwriteReportTargets(sourcePath, targets) {
+    const uniqueTargets = Array.from(new Set(targets)).filter((target) => target && target !== sourcePath);
+    await Promise.all(uniqueTargets.map(async (targetPath) => {
+        try {
+            await ensureDirectory(path.dirname(targetPath));
+            await fs_1.promises.copyFile(sourcePath, targetPath);
+        }
+        catch (error) {
+            Logger_1.appLogger.warn(`Failed to copy merged Playwright report to ${targetPath}.`, error);
+        }
+    }));
 }
 /**
  * Donobu always wants Playwright's JSON reporter enabled so we can build
@@ -643,7 +788,7 @@ function applyJsonReportEnv(env, outputDir) {
         env.PLAYWRIGHT_JSON_OUTPUT_DIR = outputDir;
     }
     if (!env.PLAYWRIGHT_JSON_OUTPUT_NAME) {
-        env.PLAYWRIGHT_JSON_OUTPUT_NAME = 'report.json';
+        env.PLAYWRIGHT_JSON_OUTPUT_NAME = PLAYWRIGHT_JSON_REPORT_FILENAME;
     }
 }
 /**
@@ -987,7 +1132,10 @@ async function attemptAutoHealRun(params) {
         // Flag downstream systems so they know this invocation came from auto-heal.
         envOverrides.DONOBU_AUTO_HEAL_ACTIVE = '1';
         Logger_1.appLogger.info(`Auto-heal: applying directives from ${evaluation.eligiblePlans.length} treatment plan(s) and re-running Playwright...`);
-        const reporterSetup = await ensureJsonReporter(healArgsForRun);
+        const healJsonReportPath = path.join(staging.playwrightOutputDir, PLAYWRIGHT_JSON_REPORT_FILENAME);
+        const reporterSetup = await ensureJsonReporter(healArgsForRun, {
+            jsonOutputFile: healJsonReportPath,
+        });
         try {
             healExitCode = await runPlaywright(reporterSetup.args, envOverrides);
         }
@@ -995,9 +1143,12 @@ async function attemptAutoHealRun(params) {
             await reporterSetup.cleanup();
         }
         const healReportDestination = path.join(params.playwrightOutputDir, `donobu-auto-heal-report-${Date.now()}.json`);
-        const healReportCopy = await copyJsonReport(staging.playwrightOutputDir, healReportDestination);
+        const healReportCopy = await copyJsonReport(staging.playwrightOutputDir, healReportDestination, {
+            envOverrides,
+            additionalCandidates: [healJsonReportPath],
+        });
         if (healTriageEnabled && healTriageContext && healExitCode !== 0) {
-            await postProcessTriageRun(healTriageContext, healArgsForRun, healReportCopy ?? undefined);
+            await postProcessTriageRun(healTriageContext, healArgsForRun, healReportCopy?.destinationPath ?? undefined);
             const finalTriageBaseDir = params.options.triageOutputDir
                 ? path.resolve(params.options.triageOutputDir)
                 : path.join(params.playwrightOutputDir, 'donobu-triage');
@@ -1024,7 +1175,7 @@ async function attemptAutoHealRun(params) {
             const mergedReportPath = path.join(params.playwrightOutputDir, `donobu-merged-report-${Date.now()}.json`);
             await mergePlaywrightJsonReports({
                 initialReportPath: params.initialReportPath,
-                healReportPath: healReportCopy ?? undefined,
+                healReportPath: healReportCopy?.destinationPath ?? undefined,
                 mergedReportPath,
                 healedTests: evaluation.eligiblePlans.map((record) => ({
                     plan: record.plan,
@@ -1032,6 +1183,9 @@ async function attemptAutoHealRun(params) {
                 })),
                 healSucceeded: healExitCode === 0,
             });
+            if (params.reportTargets.length > 0) {
+                await overwriteReportTargets(mergedReportPath, params.reportTargets);
+            }
         }
     }
     finally {
@@ -1058,7 +1212,8 @@ async function mergePlaywrightJsonReports(params) {
     const healIndex = indexReport(healReport);
     const healedKeys = new Set();
     if (healReport) {
-        for (const [, healEntry] of healIndex.byId) {
+        const processedHealEntries = new Set();
+        const processHealEntry = (healEntry) => {
             const key = buildTestKey(healEntry.suite.file, healEntry.test.projectName, healEntry.test.title);
             let combinedEntry = (healEntry.test.testId
                 ? combinedIndex.byId.get(healEntry.test.testId)
@@ -1078,16 +1233,23 @@ async function mergePlaywrightJsonReports(params) {
                 initialIndex.byKey.get(key) ??
                 null;
             const combinedTest = combinedEntry.test;
-            combinedTest.results = [
-                ...(combinedTest.results ?? []),
-                ...(healEntry.test.results ?? []),
-            ];
-            combinedTest.status = healEntry.test.status;
+            if (healEntry.test.results?.length) {
+                combinedTest.results = [
+                    ...(combinedTest.results ?? []),
+                    ...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?.test?.status;
-            if (healEntry.test.status === 'passed' &&
+            const originalStatus = originalEntry
+                ? getFinalResultStatus(originalEntry.test)
+                : undefined;
+            const healStatus = getFinalResultStatus(healEntry.test);
+            if (healStatus === 'passed' &&
                 originalStatus &&
                 originalStatus !== 'passed') {
                 combinedTest.annotations = combinedTest.annotations ?? [];
@@ -1100,11 +1262,22 @@ async function mergePlaywrightJsonReports(params) {
                 combinedTest.donobuStatus = 'healed';
                 healedKeys.add(key);
             }
-        }
+        };
+        const iterateEntries = (entries) => {
+            for (const [, healEntry] of entries) {
+                if (processedHealEntries.has(healEntry)) {
+                    continue;
+                }
+                processedHealEntries.add(healEntry);
+                processHealEntry(healEntry);
+            }
+        };
+        iterateEntries(healIndex.byId);
+        iterateEntries(healIndex.byKey);
     }
     if (params.healSucceeded && healedKeys.size === 0) {
         params.healedTests.forEach((descriptor) => {
-            const key = buildTestKey(descriptor.testCase.file, descriptor.testCase.projectName, descriptor.testCase.title);
+            const key = buildTestKey(normalizeSpecPath(descriptor.testCase.file), descriptor.testCase.projectName, descriptor.testCase.title);
             const entry = combinedIndex.byKey.get(key);
             if (entry) {
                 entry.test.annotations = entry.test.annotations ?? [];
@@ -1132,7 +1305,7 @@ async function mergePlaywrightJsonReports(params) {
     };
     await ensureDirectory(path.dirname(params.mergedReportPath));
     await fs_1.promises.writeFile(params.mergedReportPath, JSON.stringify(combined, null, 2), 'utf8');
-    Logger_1.appLogger.info(`Saved merged Playwright report to ${params.mergedReportPath}.`);
+    Logger_1.appLogger.debug(`Saved merged Playwright report to ${params.mergedReportPath}.`);
 }
 // Playwright does not reliably expose stable IDs across reports; fall back to a composite key.
 function buildTestKey(file, projectName, title) {
@@ -1140,6 +1313,12 @@ function buildTestKey(file, projectName, title) {
         .map((segment) => segment.toString())
         .join('::');
 }
+function getFinalResultStatus(test) {
+    if (!test) {
+        return undefined;
+    }
+    return test.results?.at?.(-1)?.status ?? test.status;
+}
 /**
  * Build lookup tables for quickly finding test entries inside a Playwright
  * report. We index by both `testId` (preferred) and the composite key to handle
@@ -1319,7 +1498,7 @@ async function runTestCommand(cliArgs) {
     if (triageEnabled) {
         try {
             triageContext = await prepareTriageContext(playwrightOutputDir, options);
-            Logger_1.appLogger.info(`[donobu triage] Collecting failure evidence in ${triageContext.runDir}.`);
+            Logger_1.appLogger.debug(`[donobu triage] Will collect test failure evidence in ${triageContext.runDir}.`);
         }
         catch (error) {
             Logger_1.appLogger.error('Failed to prepare test-failure triage directory. Continuing without triage.', error);
@@ -1348,11 +1527,27 @@ async function runTestCommand(cliArgs) {
     }
     let generatedPlans = [];
     let initialReportCopy = null;
+    const reportTargets = new Set();
     if (triageEnabled) {
         const initialReportDestination = triageContext
             ? path.join(triageContext.runDir, 'initial-playwright-report.json')
             : path.join(playwrightOutputDir, `donobu-initial-report-${Date.now()}.json`);
-        initialReportCopy = await copyJsonReport(playwrightOutputDir, initialReportDestination);
+        const initialReportResult = await copyJsonReport(playwrightOutputDir, initialReportDestination, {
+            envOverrides,
+            additionalCandidates: [
+                path.join(playwrightOutputDir, PLAYWRIGHT_JSON_REPORT_FILENAME),
+            ],
+        });
+        if (initialReportResult) {
+            initialReportCopy = initialReportResult.destinationPath;
+            reportTargets.add(initialReportResult.sourcePath);
+        }
+    }
+    if (reportTargets.size === 0) {
+        const discoveredReport = await findJsonReportInDir(playwrightOutputDir);
+        if (discoveredReport) {
+            reportTargets.add(discoveredReport);
+        }
     }
     if (triageEnabled && triageContext && exitCode !== 0) {
         generatedPlans = await postProcessTriageRun(triageContext, playwrightArgs, initialReportCopy ?? undefined);
@@ -1367,6 +1562,7 @@ async function runTestCommand(cliArgs) {
         generatedPlans,
         currentExitCode: exitCode,
         initialReportPath: initialReportCopy ?? undefined,
+        reportTargets: Array.from(reportTargets),
     });
     return autoHealOutcome.exitCode;
 }
@@ -1438,7 +1634,10 @@ async function runHealCommand(cliArgs) {
     // Downstream hooks check this flag to avoid recursive auto-heal loops.
     envOverrides.DONOBU_AUTO_HEAL_ACTIVE = '1';
     Logger_1.appLogger.info(`Re-running Playwright using treatment plan at ${parsed.planPath}...`);
-    const reporterSetup = await ensureJsonReporter(healArgsWithDirectives);
+    const healJsonReportPath = path.join(playwrightOutputDir, PLAYWRIGHT_JSON_REPORT_FILENAME);
+    const reporterSetup = await ensureJsonReporter(healArgsWithDirectives, {
+        jsonOutputFile: healJsonReportPath,
+    });
     Logger_1.appLogger.debug(`Heal command Playwright args: ${JSON.stringify(reporterSetup.args)} with env overrides ${JSON.stringify(envOverrides)}`);
     let exitCode;
     try {
@@ -1448,15 +1647,18 @@ async function runHealCommand(cliArgs) {
         await reporterSetup.cleanup();
     }
     const healReportDestination = path.join(path.dirname(parsed.planPath), `donobu-heal-report-${Date.now()}.json`);
-    const healReportCopy = await copyJsonReport(playwrightOutputDir, healReportDestination);
+    const healReportCopy = await copyJsonReport(playwrightOutputDir, healReportDestination, {
+        envOverrides,
+        additionalCandidates: [healJsonReportPath],
+    });
     if (triageEnabled && triageContext && exitCode !== 0) {
-        await postProcessTriageRun(triageContext, healArgsWithDirectives, healReportCopy ?? undefined);
+        await postProcessTriageRun(triageContext, healArgsWithDirectives, healReportCopy?.destinationPath ?? undefined);
     }
     if (persisted.reportPath || healReportCopy) {
         const mergedReportPath = path.join(path.dirname(parsed.planPath), 'donobu-heal-merged-report.json');
         await mergePlaywrightJsonReports({
             initialReportPath: persisted.reportPath,
-            healReportPath: healReportCopy ?? undefined,
+            healReportPath: healReportCopy?.destinationPath ?? undefined,
             mergedReportPath,
             healedTests: [
                 {
@@ -1466,6 +1668,9 @@ async function runHealCommand(cliArgs) {
             ],
             healSucceeded: exitCode === 0,
         });
+        if (persisted.reportPath) {
+            await overwriteReportTargets(mergedReportPath, [persisted.reportPath]);
+        }
     }
     return exitCode;
 }