@sweny-ai/core 0.1.44 → 0.1.46

package/dist/cli/config.js

@@ -11,7 +11,7 @@ export function registerTriageCommand(program) {
         .option("--observability-provider <provider>", "Observability provider (default: datadog)")
         .option("--issue-tracker-provider <provider>", "Issue tracker provider (default: github-issues)")
         .option("--source-control-provider <provider>", "Source control provider (default: github)")
-        .option("--notification-provider <provider>", "Notification provider (default: console)")
+        .option("--notification-provider <provider>", "Notification provider: console, github-summary, slack, teams, discord, webhook, email, file (default: console)")
         .option("--time-range <range>", "Time range to analyze (default: 24h)")
         .option("--severity-focus <focus>", "Severity level focus (default: errors)")
         .option("--service-filter <filter>", "Service filter pattern (default: *)")
@@ -355,7 +355,10 @@ export function validateInputs(config) {
     // Notification credentials by provider
     switch (config.notificationProvider) {
         case "console":
-            // No credentials needed
+        case "github-summary":
+            // No credentials needed. github-summary writes a markdown summary to the
+            // file at $GITHUB_STEP_SUMMARY when running inside GitHub Actions; outside
+            // Actions it behaves like console.
             break;
         case "slack":
         case "teams":
@@ -376,7 +379,7 @@ export function validateInputs(config) {
             // No external credentials needed
             break;
         default:
-            errors.push(`Unknown --notification-provider "${config.notificationProvider}". Valid values: console, slack, teams, discord, webhook, email, file`);
+            errors.push(`Unknown --notification-provider "${config.notificationProvider}". Valid values: console, github-summary, slack, teams, discord, webhook, email, file`);
     }
     // Workspace tools: reject unknown names early
     for (const tool of config.workspaceTools) {

package/dist/cli/config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/config.test.js

@@ -0,0 +1,111 @@
+import { describe, it, expect } from "vitest";
+import { validateInputs } from "./config.js";
+/**
+ * Focused tests for validateInputs() — specifically the notification-provider
+ * switch. Regressions here break every `swenyai/triage` action run because
+ * that action passes --notification-provider github-summary by default.
+ */
+function baseConfig(overrides = {}) {
+    return {
+        codingAgentProvider: "claude",
+        anthropicApiKey: "sk-ant-test",
+        claudeOauthToken: "",
+        openaiApiKey: "",
+        geminiApiKey: "",
+        observabilityProvider: "file",
+        observabilityCredentials: {},
+        issueTrackerProvider: "file",
+        linearApiKey: "",
+        linearTeamId: "",
+        linearBugLabelId: "",
+        linearTriageLabelId: "",
+        linearStateBacklog: "",
+        linearStateInProgress: "",
+        linearStatePeerReview: "",
+        timeRange: "24h",
+        severityFocus: "errors",
+        serviceFilter: "*",
+        investigationDepth: "standard",
+        maxInvestigateTurns: 50,
+        maxImplementTurns: 30,
+        baseBranch: "main",
+        prLabels: ["agent"],
+        issueLabels: [],
+        dryRun: false,
+        reviewMode: "review",
+        noveltyMode: true,
+        issueOverride: "",
+        additionalInstructions: "",
+        serviceMapPath: ".github/service-map.yml",
+        githubToken: "ghp_test",
+        botToken: "",
+        sourceControlProvider: "github",
+        jiraBaseUrl: "",
+        jiraEmail: "",
+        jiraApiToken: "",
+        gitlabToken: "",
+        gitlabProjectId: "",
+        gitlabBaseUrl: "https://gitlab.com",
+        notificationProvider: "console",
+        notificationWebhookUrl: "",
+        sendgridApiKey: "",
+        emailFrom: "",
+        emailTo: "",
+        webhookSigningSecret: "",
+        repository: "acme/app",
+        repositoryOwner: "",
+        json: false,
+        stream: false,
+        bell: false,
+        cacheDir: ".sweny/cache",
+        cacheTtl: 86400,
+        noCache: false,
+        outputDir: ".sweny/output",
+        mcpServers: {},
+        workspaceTools: [],
+        rules: [],
+        context: [],
+        ...overrides,
+    };
+}
+describe("validateInputs — notification provider", () => {
+    it("accepts console (no credentials required)", () => {
+        const errors = validateInputs(baseConfig({ notificationProvider: "console" }));
+        expect(errors.filter((e) => e.includes("notification-provider"))).toEqual([]);
+    });
+    it("accepts github-summary (no credentials required)", () => {
+        // Regression guard: the `swenyai/triage` composite action passes this as
+        // its default. If the validator stops accepting it every scheduled run
+        // across every consumer immediately breaks.
+        const errors = validateInputs(baseConfig({ notificationProvider: "github-summary" }));
+        expect(errors.filter((e) => e.includes("notification-provider"))).toEqual([]);
+    });
+    it("accepts file (no credentials required)", () => {
+        const errors = validateInputs(baseConfig({ notificationProvider: "file" }));
+        expect(errors.filter((e) => e.includes("notification-provider"))).toEqual([]);
+    });
+    it("requires NOTIFICATION_WEBHOOK_URL for slack", () => {
+        const errors = validateInputs(baseConfig({ notificationProvider: "slack", notificationWebhookUrl: "" }));
+        expect(errors.some((e) => e.includes("NOTIFICATION_WEBHOOK_URL"))).toBe(true);
+    });
+    it("accepts slack when NOTIFICATION_WEBHOOK_URL is set", () => {
+        const errors = validateInputs(baseConfig({
+            notificationProvider: "slack",
+            notificationWebhookUrl: "https://hooks.slack.com/services/T/B/X",
+        }));
+        expect(errors.filter((e) => e.includes("notification"))).toEqual([]);
+    });
+    it("requires sendgrid credentials for email", () => {
+        const errors = validateInputs(baseConfig({ notificationProvider: "email" }));
+        expect(errors.some((e) => e.includes("SENDGRID_API_KEY"))).toBe(true);
+        expect(errors.some((e) => e.includes("EMAIL_FROM"))).toBe(true);
+        expect(errors.some((e) => e.includes("EMAIL_TO"))).toBe(true);
+    });
+    it("rejects unknown providers and lists github-summary in the error", () => {
+        const errors = validateInputs(baseConfig({ notificationProvider: "bogus" }));
+        const err = errors.find((e) => e.includes("Unknown --notification-provider"));
+        expect(err).toBeDefined();
+        expect(err).toContain("github-summary");
+        expect(err).toContain("console");
+    });
+});

package/dist/cli/main.js

@@ -25,7 +25,7 @@ import { buildCredentialMap } from "./credentials.js";
 import { runInit } from "./init.js";
 import { runE2eInit, runE2eRun } from "./e2e.js";
 import { registerTriageCommand, registerImplementCommand, parseCliInputs, validateInputs, validateWarnings, } from "./config.js";
-import { c, formatBanner, getStepDetails, formatStepLine, formatDagResultHuman, formatResultJson, formatValidationErrors, formatCrashError, formatCheckResults, } from "./output.js";
+import { c, formatBanner, getStepDetails, formatStepLine, formatDagResultHuman, formatDagResultMarkdown, formatResultJson, formatValidationErrors, formatCrashError, formatCheckResults, } from "./output.js";
 import { checkProviderConnectivity } from "./check.js";
 import { registerSetupCommand } from "./setup.js";
 // ── Stream observer (NDJSON) ────────────────────────────────────────
@@ -336,7 +336,7 @@ triageCmd.action(async (options) => {
         contextUrls,
     };
     try {
-        const { results } = await execute(triageWorkflow, workflowInput, {
+        const { results, trace } = await execute(triageWorkflow, workflowInput, {
             skills,
             claude,
             observer,
@@ -350,6 +350,20 @@ triageCmd.action(async (options) => {
         else {
             console.log(formatDagResultHuman(results, durationMs, config));
         }
+        // GitHub Actions step summary
+        if (config.notificationProvider === "github-summary" && process.env.GITHUB_STEP_SUMMARY) {
+            try {
+                const md = formatDagResultMarkdown(results, durationMs, config, {
+                    workflow: triageWorkflow,
+                    trace,
+                });
+                fs.appendFileSync(process.env.GITHUB_STEP_SUMMARY, md);
+            }
+            catch (err) {
+                // Don't fail the run if the summary file can't be written
+                console.error(c.subtle(`  ⚠ could not write GITHUB_STEP_SUMMARY: ${err instanceof Error ? err.message : err}`));
+            }
+        }
         // Terminal bell
         if (config.bell)
             process.stderr.write("\x07");
@@ -364,6 +378,16 @@ triageCmd.action(async (options) => {
         else {
             console.error(formatCrashError(error));
         }
+        // Best-effort GitHub Actions step summary on crash
+        if (config.notificationProvider === "github-summary" && process.env.GITHUB_STEP_SUMMARY) {
+            try {
+                const msg = error instanceof Error ? error.message : "Unknown error";
+                fs.appendFileSync(process.env.GITHUB_STEP_SUMMARY, `## ❌ SWEny Triage Crashed\n\n\`\`\`\n${msg}\n\`\`\`\n`);
+            }
+            catch {
+                // ignore
+            }
+        }
         // Terminal bell even on crash
         if (config.bell)
             process.stderr.write("\x07");

package/dist/cli/output.d.ts

@@ -1,6 +1,6 @@
 import type { CliConfig } from "./config.js";
 import type { CheckResult } from "./check.js";
-import type { NodeResult } from "../types.js";
+import type { NodeResult, ExecutionTrace, Workflow } from "../types.js";
 export declare const c: {
     brand: import("chalk").ChalkInstance;
     brandDim: import("chalk").ChalkInstance;
@@ -24,3 +24,26 @@ export declare function extractCredentialHint(err: unknown): string | null;
 export declare function formatCrashError(error: unknown): string;
 export declare function formatCheckResults(results: CheckResult[]): string;
 export declare function formatResultJson(results: Map<string, NodeResult>): string;
+/**
+ * Format triage results as GitHub-flavored markdown for `$GITHUB_STEP_SUMMARY`.
+ *
+ * Designed to render richly in the GitHub Actions job summary panel:
+ *   - Status header with an emoji
+ *   - Mermaid workflow diagram colored by node execution state (when a
+ *     workflow + trace are supplied; this is the headline feature of the
+ *     job summary view)
+ *   - Config table (repository, providers, time range, mode)
+ *   - Workflow path showing actual execution sequence including loop iterations
+ *   - Routing decisions (collapsible) when the DAG had conditional edges
+ *   - Findings table
+ *   - Actions taken (issue/PR links)
+ *   - Recommendation / next step
+ *   - Node execution details (collapsible) with tool-call summaries
+ */
+export interface FormatMarkdownOptions {
+    /** Workflow definition — required for the Mermaid diagram. */
+    workflow?: Workflow;
+    /** Execution trace from `execute()` — colors the diagram and drives the path/routing sections. */
+    trace?: ExecutionTrace;
+}
+export declare function formatDagResultMarkdown(results: Map<string, NodeResult>, durationMs: number, config?: CliConfig, options?: FormatMarkdownOptions): string;

package/dist/cli/output.js

@@ -1,4 +1,5 @@
 import chalk from "chalk";
+import { toMermaidBlock } from "../mermaid.js";
 // ── Color palette ───────────────────────────────────────────────
 export const c = {
     brand: chalk.hex("#FF6B2B"),
@@ -404,6 +405,208 @@ export function formatCheckResults(results) {
 export function formatResultJson(results) {
     return JSON.stringify(Object.fromEntries(results), null, 2);
 }
+export function formatDagResultMarkdown(results, durationMs, config, options = {}) {
+    const duration = formatDuration(durationMs);
+    const lines = [];
+    const { workflow, trace } = options;
+    // Detect failure anywhere in the DAG
+    let failedNodeId;
+    let failedResult;
+    for (const [nodeId, result] of results) {
+        if (result.status === "failed") {
+            failedNodeId = nodeId;
+            failedResult = result;
+            break;
+        }
+    }
+    const investigateData = results.get("investigate")?.data;
+    const issueData = results.get("create_issue")?.data;
+    const prData = results.get("create_pr")?.data;
+    const novelCount = investigateData?.novel_count ?? 0;
+    const highestSeverity = investigateData?.highest_severity;
+    const findings = investigateData?.findings;
+    const isDryRun = Boolean(config?.dryRun);
+    // ── Header ────────────────────────────────────────────────────
+    if (failedResult) {
+        lines.push(`## ❌ SWEny Triage Failed`);
+    }
+    else if (prData?.prUrl) {
+        lines.push(`## ✅ SWEny Triage — PR opened`);
+    }
+    else if (issueData?.issueIdentifier || issueData?.issueUrl) {
+        lines.push(`## ✅ SWEny Triage — Issue created`);
+    }
+    else if (isDryRun) {
+        lines.push(`## 🔍 SWEny Triage — Dry run complete`);
+    }
+    else if (novelCount === 0) {
+        lines.push(`## ✅ SWEny Triage — No new incidents`);
+    }
+    else {
+        lines.push(`## ℹ️ SWEny Triage — No action taken`);
+    }
+    lines.push("");
+    // ── Workflow diagram (Mermaid) ────────────────────────────────
+    // Requires a workflow definition; trace is optional but makes it much more useful.
+    if (workflow) {
+        const state = {};
+        for (const [nodeId, result] of results) {
+            state[nodeId] = result.status === "success" ? "success" : result.status === "failed" ? "failed" : "skipped";
+        }
+        lines.push(toMermaidBlock(workflow, { state, trace, title: workflow.name }));
+        lines.push("");
+    }
+    // ── Config / run metadata table ───────────────────────────────
+    const rows = [];
+    if (config?.repository)
+        rows.push(["Repository", `\`${config.repository}\``]);
+    if (config?.observabilityProvider)
+        rows.push(["Observability", config.observabilityProvider]);
+    if (config?.issueTrackerProvider)
+        rows.push(["Issue tracker", config.issueTrackerProvider]);
+    if (config?.timeRange)
+        rows.push(["Time range", config.timeRange]);
+    if (config?.serviceFilter && config.serviceFilter !== "*") {
+        rows.push(["Service filter", `\`${config.serviceFilter}\``]);
+    }
+    if (highestSeverity)
+        rows.push(["Highest severity", highestSeverity]);
+    rows.push(["Novel findings", String(novelCount)]);
+    rows.push(["Duration", duration]);
+    rows.push(["Mode", isDryRun ? "dry run" : "live"]);
+    lines.push("| Setting | Value |");
+    lines.push("| --- | --- |");
+    for (const [k, v] of rows)
+        lines.push(`| ${k} | ${v} |`);
+    lines.push("");
+    // ── Workflow path (actual execution sequence including loops) ─
+    if (trace && trace.steps.length > 0) {
+        const pathSteps = trace.steps.map((s) => {
+            const tag = s.iteration > 1 ? ` ×${s.iteration}` : "";
+            return `\`${s.node}${tag}\``;
+        });
+        lines.push(`**Workflow path:** ${pathSteps.join(" → ")}`);
+        const routingLines = trace.edges
+            .filter((e) => e.reason !== "only path")
+            .map((e) => `- \`${e.from}\` → \`${e.to}\` *(${e.reason})*`);
+        if (routingLines.length > 0) {
+            lines.push("");
+            lines.push("<details><summary>Routing decisions</summary>");
+            lines.push("");
+            lines.push(...routingLines);
+            lines.push("");
+            lines.push("</details>");
+        }
+        lines.push("");
+    }
+    // ── Failure detail (short-circuit) ────────────────────────────
+    if (failedResult) {
+        lines.push(`**Failed at:** \`${failedNodeId}\``);
+        if (failedResult.data?.error) {
+            lines.push("");
+            lines.push("```");
+            lines.push(String(failedResult.data.error));
+            lines.push("```");
+        }
+        // Still render node details below so debugging is easy
+        lines.push("");
+        appendNodeDetails(lines, results);
+        return lines.join("\n") + "\n";
+    }
+    // ── Findings table ────────────────────────────────────────────
+    if (findings && findings.length > 0) {
+        lines.push("### 🔎 Findings");
+        lines.push("");
+        lines.push("| # | Severity | Title | Complexity | Status |");
+        lines.push("| --- | --- | --- | --- | --- |");
+        for (let i = 0; i < findings.length; i++) {
+            const f = findings[i];
+            const sev = String(f.severity ?? "—");
+            const title = String(f.title ?? "—").replace(/\|/g, "\\|");
+            const complexity = String(f.fix_complexity ?? "—");
+            const status = f.is_duplicate ? `dup of ${f.duplicate_of ?? "existing"}` : "novel";
+            lines.push(`| ${i + 1} | ${sev} | ${title} | ${complexity} | ${status} |`);
+        }
+        lines.push("");
+    }
+    // ── Actions taken ─────────────────────────────────────────────
+    if (issueData?.issueIdentifier || issueData?.issueUrl || prData?.prUrl) {
+        lines.push("### Actions taken");
+        lines.push("");
+        if (issueData?.issueIdentifier || issueData?.issueUrl) {
+            const id = issueData.issueIdentifier ? String(issueData.issueIdentifier) : "";
+            const title = issueData.issueTitle ? String(issueData.issueTitle) : "";
+            const url = issueData.issueUrl ? String(issueData.issueUrl) : "";
+            const link = url ? `[${id || url}](${url})` : id;
+            lines.push(`- **Issue created:** ${link}${title ? ` — ${title}` : ""}`);
+        }
+        if (prData?.prUrl) {
+            const num = prData.prNumber ? `#${String(prData.prNumber)}` : "";
+            const link = `[${num || String(prData.prUrl)}](${String(prData.prUrl)})`;
+            lines.push(`- **PR opened:** ${link}`);
+        }
+        lines.push("");
+    }
+    // ── Recommendation / next step ────────────────────────────────
+    const rec = investigateData?.recommendation;
+    if (rec) {
+        lines.push(`**Next:** ${String(rec)}`);
+        lines.push("");
+    }
+    if (isDryRun) {
+        lines.push("_Dry run mode — no side effects were taken._");
+        lines.push("");
+    }
+    // ── Node execution details (collapsible) ──────────────────────
+    appendNodeDetails(lines, results);
+    return lines.join("\n") + "\n";
+}
+function appendNodeDetails(lines, results) {
+    if (results.size === 0)
+        return;
+    lines.push("<details><summary>Node execution details</summary>");
+    lines.push("");
+    for (const [nodeId, result] of results) {
+        const icon = result.status === "success" ? "✓" : result.status === "failed" ? "✗" : "—";
+        const toolCount = result.toolCalls?.length ?? 0;
+        lines.push(`#### ${icon} \`${nodeId}\` — ${toolCount} tool call${toolCount === 1 ? "" : "s"}`);
+        lines.push("");
+        if (toolCount > 0 && result.toolCalls) {
+            lines.push("| Tool | Input (truncated) |");
+            lines.push("| --- | --- |");
+            for (const tc of result.toolCalls.slice(0, 20)) {
+                const name = tc.tool ?? "—";
+                const input = summarizeToolInput(tc.input).replace(/\|/g, "\\|");
+                lines.push(`| \`${name}\` | ${input || "—"} |`);
+            }
+            if (toolCount > 20) {
+                lines.push(`| … | _${toolCount - 20} more tool calls_ |`);
+            }
+            lines.push("");
+        }
+    }
+    lines.push("</details>");
+    lines.push("");
+}
+function summarizeToolInput(input) {
+    if (input === undefined || input === null)
+        return "";
+    if (typeof input === "string")
+        return truncate(input, 100);
+    if (typeof input !== "object")
+        return truncate(String(input), 100);
+    const parts = [];
+    for (const [k, v] of Object.entries(input)) {
+        if (typeof v === "string")
+            parts.push(`${k}=${truncate(v, 40)}`);
+        else if (typeof v === "number" || typeof v === "boolean")
+            parts.push(`${k}=${v}`);
+    }
+    return truncate(parts.join(", "), 100);
+}
+function truncate(s, n) {
+    return s.length > n ? s.slice(0, n - 1) + "…" : s;
+}
 // ── Helpers ─────────────────────────────────────────────────────
 function formatDuration(ms) {
     const s = Math.round(ms / 1000);

package/dist/cli/output.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/output.test.js

@@ -0,0 +1,179 @@
+import { describe, it, expect } from "vitest";
+import { formatDagResultMarkdown } from "./output.js";
+import { triageWorkflow } from "../workflows/index.js";
+function success(data = {}) {
+    return { status: "success", data, toolCalls: [] };
+}
+function failed(data = {}) {
+    return { status: "failed", data, toolCalls: [] };
+}
+function minimalConfig(overrides = {}) {
+    return {
+        timeRange: "6h",
+        serviceFilter: "permit-service",
+        repository: "acme/app",
+        observabilityProvider: "betterstack",
+        issueTrackerProvider: "linear",
+        dryRun: false,
+        ...overrides,
+    };
+}
+/** Build a minimal fake workflow for tests that don't need the full triage graph. */
+function fakeWorkflow() {
+    return {
+        id: "test",
+        name: "Test Workflow",
+        description: "Minimal fixture for output.test.ts — not a real DAG.",
+        entry: "investigate",
+        nodes: {
+            investigate: { name: "Investigate", instruction: "noop", skills: [] },
+            create_issue: { name: "Create Issue", instruction: "noop", skills: [] },
+            create_pr: { name: "Open PR", instruction: "noop", skills: [] },
+        },
+        edges: [
+            { from: "investigate", to: "create_issue" },
+            { from: "create_issue", to: "create_pr" },
+        ],
+    };
+}
+function fakeTrace(steps) {
+    return {
+        steps: steps.map((s) => ({
+            node: s.node,
+            status: "success",
+            iteration: s.iteration ?? 1,
+        })),
+        edges: [],
+    };
+}
+describe("formatDagResultMarkdown", () => {
+    it("renders a success header with issue + PR when both exist", () => {
+        const results = new Map([
+            [
+                "investigate",
+                success({ novel_count: 1, highest_severity: "high", findings: [{ severity: "high", title: "500 on /parse" }] }),
+            ],
+            [
+                "create_issue",
+                success({
+                    issueIdentifier: "OFF-1234",
+                    issueTitle: "Parse failure",
+                    issueUrl: "https://linear.app/acme/issue/OFF-1234",
+                }),
+            ],
+            ["create_pr", success({ prNumber: 42, prUrl: "https://github.com/acme/app/pull/42" })],
+        ]);
+        const md = formatDagResultMarkdown(results, 15_000, minimalConfig());
+        expect(md).toContain("## ✅ SWEny Triage — PR opened");
+        expect(md).toContain("| Duration | 15s |");
+        expect(md).toContain("| Service filter | `permit-service` |");
+        expect(md).toContain("| Highest severity | high |");
+        expect(md).toContain("OFF-1234");
+        expect(md).toContain("https://linear.app/acme/issue/OFF-1234");
+        expect(md).toContain("#42");
+        expect(md).toContain("https://github.com/acme/app/pull/42");
+        expect(md).toContain("**Issue created:**");
+        expect(md).toContain("**PR opened:**");
+    });
+    it("renders an issue-only result when no PR was opened", () => {
+        const results = new Map([
+            ["investigate", success({ novel_count: 1, highest_severity: "medium" })],
+            [
+                "create_issue",
+                success({ issueIdentifier: "OFF-5", issueTitle: "Investigate warning", issueUrl: "https://linear.app/x/5" }),
+            ],
+        ]);
+        const md = formatDagResultMarkdown(results, 5_000, minimalConfig());
+        expect(md).toContain("## ✅ SWEny Triage — Issue created");
+        expect(md).toContain("OFF-5");
+        expect(md).not.toContain("**PR opened:**");
+    });
+    it("renders a clean no-incident result when novel_count is 0", () => {
+        const results = new Map([["investigate", success({ novel_count: 0 })]]);
+        const md = formatDagResultMarkdown(results, 3_000, minimalConfig());
+        expect(md).toContain("## ✅ SWEny Triage — No new incidents");
+        expect(md).toContain("| Novel findings | 0 |");
+    });
+    it("renders a findings table in dry-run mode", () => {
+        const results = new Map([
+            [
+                "investigate",
+                success({
+                    novel_count: 2,
+                    highest_severity: "high",
+                    findings: [
+                        { severity: "high", title: "OOM in worker", is_duplicate: false, fix_complexity: "medium" },
+                        { severity: "low", title: "Stale metric", is_duplicate: true, duplicate_of: "OFF-99" },
+                    ],
+                }),
+            ],
+        ]);
+        const md = formatDagResultMarkdown(results, 9_000, minimalConfig({ dryRun: true }));
+        expect(md).toContain("## 🔍 SWEny Triage — Dry run complete");
+        expect(md).toContain("| # | Severity | Title | Complexity | Status |");
+        expect(md).toContain("| 1 | high | OOM in worker | medium | novel |");
+        expect(md).toContain("| 2 | low | Stale metric | — | dup of OFF-99 |");
+        expect(md).toContain("_Dry run mode — no side effects were taken._");
+        expect(md).toContain("| Mode | dry run |");
+    });
+    it("renders a failure summary when a node failed", () => {
+        const results = new Map([
+            ["gather", success()],
+            ["investigate", failed({ error: "Rate limited by Anthropic API" })],
+        ]);
+        const md = formatDagResultMarkdown(results, 2_000, minimalConfig());
+        expect(md).toContain("## ❌ SWEny Triage Failed");
+        expect(md).toContain("**Failed at:** `investigate`");
+        expect(md).toContain("Rate limited by Anthropic API");
+    });
+    it("escapes pipe characters in finding titles so the table stays valid", () => {
+        const results = new Map([
+            [
+                "investigate",
+                success({
+                    novel_count: 1,
+                    findings: [{ severity: "high", title: "broken | pipe | title" }],
+                }),
+            ],
+        ]);
+        const md = formatDagResultMarkdown(results, 1_000, minimalConfig({ dryRun: true }));
+        expect(md).toContain("broken \\| pipe \\| title");
+    });
+    it("embeds a mermaid workflow diagram when workflow is supplied", () => {
+        const results = new Map([
+            ["investigate", success({ novel_count: 0 })],
+            ["create_issue", success({ issueIdentifier: "OFF-7", issueUrl: "https://linear.app/x/7" })],
+        ]);
+        const workflow = fakeWorkflow();
+        const md = formatDagResultMarkdown(results, 4_000, minimalConfig(), { workflow });
+        expect(md).toContain("```mermaid");
+        expect(md).toContain("graph TB");
+        expect(md).toContain("title: Test Workflow");
+        // Status classes should be applied for nodes that ran successfully
+        expect(md).toContain("class investigate,create_issue success");
+    });
+    it("renders the workflow path and iteration counts from the execution trace", () => {
+        const results = new Map([
+            ["investigate", success({ novel_count: 1 })],
+            ["create_issue", success({ issueIdentifier: "OFF-8" })],
+        ]);
+        const workflow = fakeWorkflow();
+        const trace = fakeTrace([
+            { node: "investigate" },
+            { node: "create_issue" },
+            { node: "create_issue", iteration: 2 },
+        ]);
+        const md = formatDagResultMarkdown(results, 8_000, minimalConfig(), { workflow, trace });
+        expect(md).toContain("**Workflow path:** `investigate` → `create_issue` → `create_issue ×2`");
+    });
+    it("accepts the real triageWorkflow without throwing", () => {
+        // Regression guard: the real workflow must serialise cleanly through toMermaidBlock
+        // so we do not ship a broken diagram to every downstream consumer.
+        const results = new Map([["investigate", success({ novel_count: 0 })]]);
+        const md = formatDagResultMarkdown(results, 1_000, minimalConfig(), {
+            workflow: triageWorkflow,
+        });
+        expect(md).toContain("```mermaid");
+        expect(md).toContain(`title: ${triageWorkflow.name}`);
+    });
+});

package/dist/mermaid.js

@@ -43,7 +43,7 @@ export function toMermaid(workflow, options = {}) {
     for (const [id, node] of Object.entries(workflow.nodes)) {
         let label = escapeLabel(node.name);
         const isEntry = id === workflow.entry;
-        const entryTag = isEntry ? " \\u25B6" : "";
+        const entryTag = isEntry ? " \u25B6" : "";
         // Show iteration count for nodes that ran multiple times
         const iterations = nodeIterations.get(id);
         const iterTag = iterations && iterations > 1 ? ` ×${iterations}` : "";

package/dist/mermaid.test.js

@@ -55,7 +55,7 @@ describe("toMermaid", () => {
         const result = toMermaid(simple);
         expect(result).toContain("graph TB");
         // Entry node gets stadium shape
-        expect(result).toContain("a([Triage \\u25B6])");
+        expect(result).toContain("a([Triage \u25B6])");
         // Non-entry nodes get default shape
         expect(result).toContain("b[Investigate]");
         expect(result).toContain("c[Report]");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.44",
+  "version": "0.1.46",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"