donobu 5.26.0 → 5.27.0

package/dist/cli/donobu-cli.js

@@ -63,8 +63,13 @@ const v4_1 = require("zod/v4");
 const gptClients_1 = require("../lib/test/fixtures/gptClients");
 const donobuTestStack_1 = require("../lib/test/utils/donobuTestStack");
 const triageTestFailure_1 = require("../lib/test/utils/triageTestFailure");
+const merge_1 = require("../reporter/merge");
+const model_1 = require("../reporter/model");
+const render_1 = require("../reporter/render");
+const renderMarkdown_1 = require("../reporter/renderMarkdown");
+const renderSlack_1 = require("../reporter/renderSlack");
+const slack_1 = require("../reporter/slack");
 const Logger_1 = require("../utils/Logger");
-const playwright_json_to_html_1 = require("./playwright-json-to-html");
 const FAILURE_EVIDENCE_PREFIX = 'failure-evidence-';
 const TREATMENT_PLAN_PREFIX = 'treatment-plan-';
 const PLAYWRIGHT_JSON_REPORT_FILENAME = 'report.json';
@@ -1287,17 +1292,21 @@ async function attemptAutoHealRun(params) {
         else {
             Logger_1.appLogger.warn(`Auto-heal attempt exited with code ${healExitCode}. Keeping failing status.`);
         }
-        if (params.initialReport || healReportCopy) {
+        // Prefer the heal reporter's state file; fall back to Playwright's JSON
+        // reporter output for configs that don't wire up the Donobu reporter.
+        const healReport = await loadDonobuReportForMerge(staging.playwrightOutputDir, healReportCopy?.destinationPath ?? undefined);
+        if (params.initialReport || healReport) {
             // Write the merged report directly to the primary report target when
             // available, avoiding a redundant intermediate file.
             const primaryTarget = params.reportTargets[0];
             const mergedReportPath = primaryTarget
                 ? primaryTarget
                 : path.join(params.playwrightOutputDir, `donobu-merged-report-${Date.now()}.json`);
-            await mergePlaywrightJsonReports({
-                initialReport: params.initialReport,
+            const mergedReport = await mergePlaywrightJsonReports({
+                initialReport: params.initialReport ?? null,
                 initialReportSourcePath: params.initialReportSourcePath,
-                healReportPath: healReportCopy?.destinationPath ?? undefined,
+                healReport,
+                healReportSourcePath: healReportCopy?.destinationPath ?? undefined,
                 mergedReportPath,
                 healedTests: evaluation.eligiblePlans.map((record) => ({
                     plan: record.plan,
@@ -1309,10 +1318,12 @@ async function attemptAutoHealRun(params) {
             });
             // Copy to any remaining report targets (skip the primary — already
             // written there).
-            if (params.reportTargets.length > 1) {
+            if (mergedReport && params.reportTargets.length > 1) {
                 await overwriteReportTargets(mergedReportPath, params.reportTargets.slice(1));
             }
-            await regenerateDonobuHtmlReport(mergedReportPath, params.playwrightOutputDir);
+            if (mergedReport) {
+                await regenerateDonobuReports(mergedReport);
+            }
         }
     }
     finally {
@@ -1373,32 +1384,37 @@ async function relocateTemporaryAttachments(report, outputDir) {
  * outcome. Reads the output path from the sidecar written by the reporter
  * during the initial run; does nothing if the reporter wasn't configured.
  */
-async function regenerateDonobuHtmlReport(mergedReportPath, playwrightOutputDir) {
-    const sidecarPath = path.join(playwrightOutputDir, '.donobu-html-reporter.json');
-    let outputFile;
-    try {
-        const sidecar = JSON.parse(await fs_1.promises.readFile(sidecarPath, 'utf-8'));
-        outputFile = sidecar.outputFile;
-        if (!outputFile) {
-            return;
-        }
+async function regenerateDonobuReports(mergedReport) {
+    const outputs = mergedReport.metadata?.donobuOutputs;
+    if (!outputs) {
+        return;
     }
-    catch {
-        return; // Sidecar absent — reporter not configured, nothing to do.
+    if (outputs.html?.outputFile) {
+        await regenerateHtmlOutput(mergedReport, outputs.html.outputFile);
     }
+    if (outputs.markdown?.outputFile) {
+        await regenerateMarkdownOutput(mergedReport, outputs.markdown.outputFile);
+    }
+    if (outputs.slack?.outputFile) {
+        await regenerateSlackOutput(mergedReport, outputs.slack.outputFile);
+    }
+}
+async function regenerateHtmlOutput(mergedReport, outputFile) {
     try {
-        const mergedJson = JSON.parse(await fs_1.promises.readFile(mergedReportPath, 'utf-8'));
-        let triage = { plans: [], evidence: [] };
-        if (mergedJson.metadata?.triageRunDir) {
+        let triage = {
+            plans: [],
+            evidence: [],
+        };
+        if (mergedReport.metadata?.triageRunDir) {
             try {
-                triage = (0, playwright_json_to_html_1.loadTriageData)(mergedJson.metadata.triageRunDir);
+                triage = (0, render_1.loadTriageData)(mergedReport.metadata.triageRunDir);
             }
             catch {
                 // Triage dir may not exist in all environments; report without it.
             }
         }
         const outputDir = path.dirname(outputFile);
-        const html = (0, playwright_json_to_html_1.generateHtml)(mergedJson, triage, outputDir);
+        const html = (0, render_1.renderHtml)(mergedReport, triage, outputDir);
         await fs_1.promises.mkdir(outputDir, { recursive: true });
         await fs_1.promises.writeFile(outputFile, html, 'utf8');
         Logger_1.appLogger.info(`Donobu HTML report regenerated from merged data: ${outputFile}`);
@@ -1407,234 +1423,110 @@ async function regenerateDonobuHtmlReport(mergedReportPath, playwrightOutputDir)
         Logger_1.appLogger.warn('Failed to regenerate Donobu HTML report from merged data.', error);
     }
 }
+async function regenerateMarkdownOutput(mergedReport, outputFile) {
+    try {
+        const markdown = (0, renderMarkdown_1.renderMarkdown)(mergedReport);
+        await fs_1.promises.mkdir(path.dirname(outputFile), { recursive: true });
+        await fs_1.promises.writeFile(outputFile, markdown, 'utf8');
+        Logger_1.appLogger.info(`Donobu Markdown report regenerated from merged data: ${outputFile}`);
+    }
+    catch (error) {
+        Logger_1.appLogger.warn('Failed to regenerate Donobu Markdown report from merged data.', error);
+    }
+}
+async function regenerateSlackOutput(mergedReport, outputFile) {
+    try {
+        // `DONOBU_REPORT_URL` is read here (not threaded via state) for symmetry
+        // with the reporter — both the reporter and the orchestrator pull Slack
+        // configuration from the environment.
+        const payload = (0, renderSlack_1.renderSlack)(mergedReport, {
+            reportUrl: process.env.DONOBU_REPORT_URL,
+        });
+        await fs_1.promises.mkdir(path.dirname(outputFile), { recursive: true });
+        await fs_1.promises.writeFile(outputFile, JSON.stringify(payload, null, 2), 'utf8');
+        Logger_1.appLogger.info(`Donobu Slack payload regenerated from merged data: ${outputFile}`);
+        // Post to Slack from the orchestrator — at this point the payload reflects
+        // the final (merged, possibly healed) outcome. The reporter itself
+        // deferred posting when `DONOBU_AUTO_HEAL_ORCHESTRATED=1` was set on the
+        // initial run, so this is the single authoritative post for the whole run.
+        const webhookUrl = process.env.DONOBU_SLACK_WEBHOOK_URL;
+        if (webhookUrl) {
+            await (0, slack_1.postSlackPayload)(webhookUrl, payload);
+            Logger_1.appLogger.info('Donobu Slack payload posted to webhook.');
+        }
+    }
+    catch (error) {
+        Logger_1.appLogger.warn('Failed to regenerate Donobu Slack payload from merged data.', error);
+    }
+}
 /**
- * Combine the JSON reports from the original failed run and any auto-heal rerun.
- * The merged output is useful for dashboards that expect a single report file.
+ * Try to load a run's `DonobuReport` from the reporter state file, falling
+ * back to a Playwright JSON report at `fallbackPath`. The DonobuReport shape
+ * is a superset of Playwright JSON so either works as input to `mergeReports`.
+ *
+ * Returns null when neither source exists (e.g. a config that uses neither
+ * reporter) — the orchestrator treats this as "nothing to merge".
+ */
+async function loadDonobuReportForMerge(outputDir, fallbackPath) {
+    if (outputDir) {
+        const stateFile = path.join(outputDir, model_1.DONOBU_REPORT_STATE_FILENAME);
+        const state = await readJsonIfExists(stateFile);
+        if (state) {
+            return state;
+        }
+    }
+    if (fallbackPath) {
+        return await readJsonIfExists(fallbackPath);
+    }
+    return null;
+}
+/**
+ * Combine the reports from the original failed run and any auto-heal rerun,
+ * relocate any heal-run attachments to persistent storage, and write the
+ * merged JSON to `mergedReportPath` for downstream dashboards. Returns the
+ * in-memory merged report so the caller can drive HTML regeneration without
+ * re-reading from disk.
+ *
+ * Also forwards `metadata.donobuOutputs` from whichever input recorded it
+ * (typically the initial run's state file), so regeneration lands every
+ * format at the same paths the reporters originally chose.
  */
 async function mergePlaywrightJsonReports(params) {
-    const initialReport = params.initialReport ?? null;
-    const healReport = await readJsonIfExists(params.healReportPath);
-    if (!initialReport && !healReport) {
-        return;
+    const merged = (0, merge_1.mergeReports)({
+        initialReport: params.initialReport,
+        healReport: params.healReport,
+        healedTests: params.healedTests,
+        healSucceeded: params.healSucceeded,
+        triageRunDir: params.triageRunDir,
+        initialReportSourcePath: params.initialReportSourcePath,
+        healReportSourcePath: params.healReportSourcePath,
+    });
+    if (!merged) {
+        return null;
     }
-    // Clone the reports so we never mutate the on-disk originals.
-    const combined = initialReport
-        ? JSON.parse(JSON.stringify(initialReport))
-        : JSON.parse(JSON.stringify(healReport));
-    const initialIndex = indexReport(initialReport);
-    const combinedIndex = indexReport(combined);
-    const healIndex = indexReport(healReport);
-    const healedKeys = new Set();
-    if (healReport) {
-        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)
-                : undefined) ??
-                combinedIndex.byKey.get(key) ??
-                null;
-            if (!combinedEntry) {
-                combinedEntry = insertTestIntoReport(combined, healEntry);
-                if (healEntry.test.testId) {
-                    combinedIndex.byId.set(healEntry.test.testId, combinedEntry);
-                }
-                combinedIndex.byKey.set(key, combinedEntry);
-            }
-            const originalEntry = (healEntry.test.testId
-                ? initialIndex.byId.get(healEntry.test.testId)
-                : undefined) ??
-                initialIndex.byKey.get(key) ??
-                null;
-            const combinedTest = combinedEntry.test;
-            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
-                ? getFinalResultStatus(originalEntry.test)
-                : undefined;
-            const healStatus = getFinalResultStatus(healEntry.test);
-            if (healStatus === 'passed' &&
-                originalStatus &&
-                originalStatus !== 'passed') {
-                combinedTest.annotations = combinedTest.annotations ?? [];
-                if (!combinedTest.annotations.some((annotation) => annotation.type === 'self-healed')) {
-                    combinedTest.annotations.push({
-                        type: 'self-healed',
-                        description: 'Automatically healed by Donobu auto-heal rerun after applying treatment plan.',
-                    });
-                }
-                combinedTest.donobuStatus = 'healed';
-                healedKeys.add(key);
-            }
-        };
-        const iterateEntries = (entries) => {
-            for (const [, healEntry] of entries) {
-                if (processedHealEntries.has(healEntry)) {
-                    continue;
-                }
-                processedHealEntries.add(healEntry);
-                processHealEntry(healEntry);
-            }
+    // Carry forward each format's output path recorded by the reporters so the
+    // orchestrator can regenerate every output at the same place. Prefer the
+    // initial run's value — the heal-run lands in a temp staging directory the
+    // user never sees.
+    const donobuOutputs = {
+        ...(params.healReport?.metadata?.donobuOutputs ?? {}),
+        ...(params.initialReport?.metadata?.donobuOutputs ?? {}),
+    };
+    if (Object.keys(donobuOutputs).length > 0) {
+        merged.metadata = {
+            ...(merged.metadata ?? {}),
+            donobuOutputs,
         };
-        iterateEntries(healIndex.byId);
-        iterateEntries(healIndex.byKey);
-    }
-    if (params.healSucceeded && healedKeys.size === 0) {
-        params.healedTests.forEach((descriptor) => {
-            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 ?? [];
-                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);
-    combined.metadata = {
-        ...(combined.metadata ?? {}),
-        donobuMergedReport: true,
-        mergedAtIso: new Date().toISOString(),
-        sources: {
-            initial: params.initialReportSourcePath ?? null,
-            autoHeal: params.healReportPath ?? null,
-        },
-        ...(params.triageRunDir
-            ? { triageRunDir: params.triageRunDir }
-            : undefined),
-        donobuHealedTests: Array.from(healedKeys.values()),
-    };
     // Relocate heal-run attachments from temporary staging directory to the
     // persistent output directory so they survive after staging cleanup.
     if (params.outputDir) {
-        await relocateTemporaryAttachments(combined, params.outputDir);
+        await relocateTemporaryAttachments(merged, params.outputDir);
     }
     await ensureDirectory(path.dirname(params.mergedReportPath));
-    await fs_1.promises.writeFile(params.mergedReportPath, JSON.stringify(combined, null, 2), 'utf8');
+    await fs_1.promises.writeFile(params.mergedReportPath, JSON.stringify(merged, null, 2), 'utf8');
     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) {
-    return [file ?? 'unknown-file', projectName ?? 'default', 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
- * differences between initial runs and reruns.
- */
-function indexReport(report) {
-    const byId = new Map();
-    const byKey = new Map();
-    if (!report?.suites) {
-        return { byId, byKey };
-    }
-    report.suites.forEach((suite) => {
-        suite.specs?.forEach((spec) => {
-            spec.tests?.forEach((test) => {
-                const entry = { suite, spec, test };
-                if (test.testId) {
-                    byId.set(test.testId, entry);
-                }
-                const key = buildTestKey(suite.file, test.projectName, test.title);
-                byKey.set(key, entry);
-            });
-        });
-    });
-    return { byId, byKey };
-}
-function insertTestIntoReport(report, entry) {
-    // Look for an existing suite/spec structure to attach the test clone to.
-    let suite = report.suites?.find((candidate) => candidate.file === entry.suite.file);
-    if (!suite) {
-        suite = JSON.parse(JSON.stringify(entry.suite));
-        suite.specs = [];
-        report.suites = report.suites ?? [];
-        report.suites.push(suite);
-    }
-    let spec = suite.specs.find((candidate) => candidate.title === entry.spec.title);
-    if (!spec) {
-        spec = JSON.parse(JSON.stringify(entry.spec));
-        spec.tests = [];
-        suite.specs.push(spec);
-    }
-    const testClone = JSON.parse(JSON.stringify(entry.test));
-    spec.tests.push(testClone);
-    return { suite, spec, test: testClone };
-}
-function computeReportStats(report) {
-    let expected = 0;
-    let unexpected = 0;
-    let skipped = 0;
-    let flaky = 0;
-    let total = 0;
-    let duration = 0;
-    // Some reports come from external tools and might not include suites/tests.
-    // Fall back to the existing stats block if we cannot recompute metrics.
-    if (!report?.suites) {
-        return report?.stats ?? {};
-    }
-    report.suites.forEach((suite) => {
-        suite.specs?.forEach((spec) => {
-            spec.tests?.forEach((test) => {
-                total += 1;
-                const finalResult = test.results?.at(-1);
-                if (finalResult?.duration) {
-                    duration += finalResult.duration;
-                }
-                const status = finalResult?.status ?? test.status;
-                switch (status) {
-                    case 'passed':
-                        expected += 1;
-                        break;
-                    case 'skipped':
-                        skipped += 1;
-                        break;
-                    case 'flaky':
-                        flaky += 1;
-                        break;
-                    case 'failed':
-                    case 'timedOut':
-                    case 'interrupted':
-                        unexpected += 1;
-                        break;
-                    default:
-                        unexpected += 1;
-                }
-            });
-        });
-    });
-    return {
-        expected,
-        unexpected,
-        flaky,
-        skipped,
-        duration,
-        total,
-    };
+    return merged;
 }
 async function readJsonIfExists(filePath) {
     if (!filePath) {
@@ -1737,6 +1629,13 @@ async function runTestCommand(cliArgs) {
         triageContext,
     });
     applyJsonReportEnv(envOverrides, playwrightOutputDir);
+    // When auto-heal is enabled, any Slack reporter defers its POST to us —
+    // whether auto-heal actually triggers or not, we want exactly one Slack
+    // message per run reflecting the final outcome, so the orchestrator owns
+    // the HTTP call.
+    if (effectiveOptions.autoHeal) {
+        envOverrides.DONOBU_AUTO_HEAL_ORCHESTRATED = '1';
+    }
     const reporterSetup = await ensureJsonReporter(playwrightArgs);
     const runArgs = reporterSetup.args;
     Logger_1.appLogger.debug(`Initial Playwright args: ${JSON.stringify(runArgs)} with env overrides ${JSON.stringify(envOverrides)}`);
@@ -1763,25 +1662,38 @@ async function runTestCommand(cliArgs) {
         reportTargets.add(discoveredReport);
     }
     if (exitCode === 0 || !effectiveOptions.autoHeal) {
+        // Auto-heal wasn't attempted (either tests passed or the user disabled
+        // it). If a Slack reporter deferred its POST waiting for us, deliver the
+        // initial run's payload now — nothing further will be re-rendered.
+        if (effectiveOptions.autoHeal) {
+            await postDeferredSlackFromInitialRun(playwrightOutputDir);
+        }
         return exitCode;
     }
     // Tests failed and auto-heal is enabled — load the initial report into
     // memory so we can merge it with the heal-run report later without writing
     // a redundant copy to disk.
-    let initialReport = null;
+    let loadedPlaywrightJson = null;
+    let initialDonobuReport = null;
     if (triageEnabled) {
-        initialReport = await loadJsonReport(playwrightOutputDir, {
+        loadedPlaywrightJson = await loadJsonReport(playwrightOutputDir, {
             envOverrides,
             additionalCandidates: [
                 path.join(playwrightOutputDir, PLAYWRIGHT_JSON_REPORT_FILENAME),
             ],
         });
-        if (initialReport) {
-            reportTargets.add(initialReport.sourcePath);
+        if (loadedPlaywrightJson) {
+            reportTargets.add(loadedPlaywrightJson.sourcePath);
         }
+        // Prefer the Donobu reporter's state file (carries the HTML output path
+        // and any Donobu-specific metadata); fall back to the Playwright JSON for
+        // configs that don't wire up the Donobu reporter.
+        const stateReport = await readJsonIfExists(path.join(playwrightOutputDir, model_1.DONOBU_REPORT_STATE_FILENAME));
+        initialDonobuReport =
+            stateReport ?? loadedPlaywrightJson?.data ?? null;
     }
     if (triageEnabled && triageContext) {
-        generatedPlans = await postProcessTriageRun(triageContext, playwrightArgs, initialReport?.sourcePath);
+        generatedPlans = await postProcessTriageRun(triageContext, playwrightArgs, loadedPlaywrightJson?.sourcePath);
     }
     const autoHealOutcome = await attemptAutoHealRun({
         options: effectiveOptions,
@@ -1789,13 +1701,47 @@ async function runTestCommand(cliArgs) {
         playwrightOutputDir,
         generatedPlans,
         currentExitCode: exitCode,
-        initialReport: initialReport?.data,
-        initialReportSourcePath: initialReport?.sourcePath,
+        initialReport: initialDonobuReport,
+        initialReportSourcePath: loadedPlaywrightJson?.sourcePath,
         triageRunDir: triageContext?.runDir,
         reportTargets: Array.from(reportTargets),
     });
+    // When auto-heal was eligible-checked but didn't actually run a rerun (no
+    // actionable directives), nothing downstream re-renders the Slack payload —
+    // deliver the pre-heal payload now so we honor the "one post per run"
+    // guarantee the reporter was deferring for.
+    if (!autoHealOutcome.attempted) {
+        await postDeferredSlackFromInitialRun(playwrightOutputDir);
+    }
     return autoHealOutcome.exitCode;
 }
+/**
+ * When auto-heal was enabled but no rerun happened (tests passed, or no
+ * treatment plan had actionable directives), the Slack reporter deferred its
+ * POST to the orchestrator. Fire the deferred POST from the initial run's
+ * state file so the user gets exactly one Slack notification per run.
+ */
+async function postDeferredSlackFromInitialRun(playwrightOutputDir) {
+    const webhookUrl = process.env.DONOBU_SLACK_WEBHOOK_URL;
+    if (!webhookUrl) {
+        return;
+    }
+    const state = await readJsonIfExists(path.join(playwrightOutputDir, model_1.DONOBU_REPORT_STATE_FILENAME));
+    const slack = state?.metadata?.donobuOutputs?.slack;
+    if (!state || !slack) {
+        return;
+    }
+    try {
+        const payload = (0, renderSlack_1.renderSlack)(state, {
+            reportUrl: process.env.DONOBU_REPORT_URL,
+        });
+        await (0, slack_1.postSlackPayload)(webhookUrl, payload);
+        Logger_1.appLogger.info('Donobu Slack payload posted to webhook.');
+    }
+    catch (error) {
+        Logger_1.appLogger.warn('Failed to POST deferred Donobu Slack payload.', error);
+    }
+}
 /**
  * Apply a previously generated treatment plan manually. Engineers use this
  * entrypoint to re-run a specific plan locally or in CI without waiting for
@@ -1884,17 +1830,21 @@ async function runHealCommand(cliArgs) {
     if (triageEnabled && triageContext && exitCode !== 0) {
         await postProcessTriageRun(triageContext, healArgsWithDirectives, healReportCopy?.destinationPath ?? undefined);
     }
-    const persistedInitialReport = await readJsonIfExists(persisted.reportPath);
-    if (persistedInitialReport || healReportCopy) {
+    // Prefer a Donobu reporter state file written alongside the persisted
+    // Playwright JSON; fall back to the raw Playwright JSON for older runs.
+    const persistedInitialReport = await loadDonobuReportForMerge(persisted.reportPath ? path.dirname(persisted.reportPath) : undefined, persisted.reportPath);
+    const healReport = await loadDonobuReportForMerge(playwrightOutputDir, healReportCopy?.destinationPath ?? undefined);
+    if (persistedInitialReport || healReport) {
         // Write merged report directly to the original report location when
         // available, otherwise fall back to a standalone file.
         const mergedReportPath = persisted.reportPath
             ? persisted.reportPath
             : path.join(path.dirname(parsed.planPath), 'donobu-heal-merged-report.json');
-        await mergePlaywrightJsonReports({
+        const mergedReport = await mergePlaywrightJsonReports({
             initialReport: persistedInitialReport,
             initialReportSourcePath: persisted.reportPath,
-            healReportPath: healReportCopy?.destinationPath ?? undefined,
+            healReport,
+            healReportSourcePath: healReportCopy?.destinationPath ?? undefined,
             mergedReportPath,
             healedTests: [
                 {
@@ -1905,7 +1855,9 @@ async function runHealCommand(cliArgs) {
             healSucceeded: exitCode === 0,
             outputDir: path.dirname(mergedReportPath),
         });
-        await regenerateDonobuHtmlReport(mergedReportPath, playwrightOutputDir);
+        if (mergedReport) {
+            await regenerateDonobuReports(mergedReport);
+        }
     }
     return exitCode;
 }

package/dist/codegen/CodeGenerator.js

@@ -402,6 +402,9 @@ async function generateGitHubActionsWorkflow(flowsWithToolCalls, gptConfig, opti
         envVarsList.push('DONOBU_API_KEY: ${{ secrets.DONOBU_API_KEY }}');
     }
     envVarsList.push(...allUniqueEnvVars.map((envVarName) => `${envVarName}: \${{ secrets.${envVarName} }}`));
+    // Let the Donobu Slack reporter POST directly when a webhook secret is
+    // present, and link each message back to the workflow run.
+    envVarsList.push('DONOBU_SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}', 'DONOBU_REPORT_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}');
     const envVarsSection = envVarsList.length > 0
         ? `\n        env:\n          ${envVarsList.join('\n          ')}`
         : '';
@@ -459,10 +462,12 @@ ${xvfbStep}
         continue-on-error: true${envVarsSection}
         run: ${testCommand}
 
-      - name: Generate GitHub Workflow Summary
+      - name: Append Markdown report to GitHub Actions summary
         if: always()
         run: |
-          npm exec playwright-json-to-markdown test-results/playwright-report.json >> $GITHUB_STEP_SUMMARY
+          if [ -f test-results/report.md ]; then
+            cat test-results/report.md >> $GITHUB_STEP_SUMMARY
+          fi
 
       - name: Save Test Reports as Artifacts
         uses: actions/upload-artifact@v6
@@ -471,19 +476,6 @@ ${xvfbStep}
           name: test-results
           path: test-results/
           retention-days: 3
-
-      - name: Post to Slack
-        if: always()
-        env:
-          SLACK_WEBHOOK_URL: \${{ secrets.SLACK_WEBHOOK_URL }}
-        run: |
-          if [ -n "$SLACK_WEBHOOK_URL" ]; then
-            WORKFLOW_URL="\${GITHUB_SERVER_URL}/\${GITHUB_REPOSITORY}/actions/runs/\${GITHUB_RUN_ID}"
-            SLACK_PAYLOAD=$(npm exec playwright-json-to-slack-json -- --report-url "$WORKFLOW_URL" < "test-results/playwright-report.json")
-            curl --header 'Content-type: application/json' --data "$SLACK_PAYLOAD" "$SLACK_WEBHOOK_URL"
-          else
-            echo "SLACK_WEBHOOK_URL secret not present, skipping Slack notification."
-          fi
 ${pullRequestCreationSection}`;
 }
 async function buildCacheContents(flowsWithToolCalls, toolRegistry) {
@@ -769,8 +761,12 @@ export default defineConfig({
   projects: [ ${projects.join(',')} ],
   use: ${JSON.stringify(useConfig, null, 2)},
   reporter: [
-    ['json', { outputFile: 'test-results/playwright-report.json' }],
     ['donobu/reporter/html'],
+    ['donobu/reporter/markdown'],
+    // A Slack message will be sent to destination specified by the
+    // DONOBU_SLACK_WEBHOOK_URL (if it exists) and optionally contain a link
+    // specified by DONOBU_REPORT_URL.
+    ['donobu/reporter/slack'],
   ],
   ${metadata}
 });`;