@sweny-ai/core 0.1.45 → 0.1.47

package/dist/__tests__/version-consistency.test.js

@@ -196,4 +196,91 @@ describe("docs action code blocks", () => {
                 allIssues.map((i) => `  ${i}`).join("\n"));
         }
     });
+    it("every swenyai/sweny@v5 code block has a workflow: input", () => {
+        const issues = [];
+        for (const f of ACTION_DOC_FILES) {
+            const filePath = resolve(ROOT, f);
+            if (!existsSync(filePath))
+                continue;
+            const content = readFileSync(filePath, "utf-8");
+            const blocks = content.match(/```ya?ml[\s\S]*?```/g) || [];
+            for (const block of blocks) {
+                if (!block.includes(`swenyai/sweny@${CURRENT_ACTION_VERSION}`))
+                    continue;
+                if (!block.includes("workflow:")) {
+                    issues.push(`${relative(ROOT, filePath)}: code block uses swenyai/sweny@${CURRENT_ACTION_VERSION} without workflow: input`);
+                }
+            }
+        }
+        if (issues.length > 0) {
+            expect.fail(`The generic runner requires a workflow: input.\n` + issues.map((i) => `  ${i}`).join("\n"));
+        }
+    });
+});
+// ─── 5. Internal doc links resolve ──────────────────────────────────
+describe("docs internal links", () => {
+    const DOCS_ROOT = resolve(ROOT, "packages/web/src/content/docs");
+    /**
+     * Extract markdown links like [text](/path/) and verify the target exists.
+     * Only checks internal absolute links (starting with /).
+     */
+    function findBrokenLinks(filePath) {
+        if (!existsSync(filePath))
+            return [];
+        const content = readFileSync(filePath, "utf-8");
+        const broken = [];
+        // Match [text](/path/) and [text](/path/#anchor) but skip external URLs
+        const linkPattern = /\[([^\]]*)\]\(\/([^)#]*?)\/?\)/g;
+        let match;
+        while ((match = linkPattern.exec(content)) !== null) {
+            const linkPath = match[2];
+            // Map /action/ → action/index.md, /action/inputs/ → action/inputs.md
+            const candidates = [
+                resolve(DOCS_ROOT, linkPath, "index.md"),
+                resolve(DOCS_ROOT, linkPath, "index.mdx"),
+                resolve(DOCS_ROOT, `${linkPath}.md`),
+                resolve(DOCS_ROOT, `${linkPath}.mdx`),
+            ];
+            if (!candidates.some((c) => existsSync(c))) {
+                broken.push(`${relative(ROOT, filePath)}: broken link [${match[1]}](/${linkPath}/)`);
+            }
+        }
+        return broken;
+    }
+    const KEY_DOCS = [
+        "packages/web/src/content/docs/action/index.md",
+        "packages/web/src/content/docs/action/inputs.md",
+        "packages/web/src/content/docs/action/examples.md",
+        "packages/web/src/content/docs/action/scheduling.md",
+        "packages/web/src/content/docs/action/service-map.md",
+        "packages/web/src/content/docs/index.mdx",
+        "packages/web/src/content/docs/getting-started/quick-start.md",
+    ];
+    it("key action docs have no broken internal links", () => {
+        const allBroken = KEY_DOCS.flatMap((f) => findBrokenLinks(resolve(ROOT, f)));
+        if (allBroken.length > 0) {
+            expect.fail(`Found ${allBroken.length} broken link(s):\n` + allBroken.map((b) => `  ${b}`).join("\n"));
+        }
+    });
+});
+// ─── 6. Three-action architecture documented ────────────────────────
+describe("three-action architecture", () => {
+    it("action/index.md documents all three actions", () => {
+        const content = readFileSync(resolve(ROOT, "packages/web/src/content/docs/action/index.md"), "utf-8");
+        expect(content).toContain("swenyai/triage@v1");
+        expect(content).toContain("swenyai/e2e@v1");
+        expect(content).toContain(`swenyai/sweny@${CURRENT_ACTION_VERSION}`);
+    });
+    it("action/inputs.md has sections for all three actions", () => {
+        const content = readFileSync(resolve(ROOT, "packages/web/src/content/docs/action/inputs.md"), "utf-8");
+        expect(content).toMatch(/## Generic runner inputs/);
+        expect(content).toMatch(/## Triage action inputs/);
+        expect(content).toMatch(/## E2E action inputs/);
+    });
+    it("README Actions table lists all three actions", () => {
+        const readme = readFileSync(resolve(ROOT, "README.md"), "utf-8");
+        expect(readme).toContain("swenyai/triage@v1");
+        expect(readme).toContain("swenyai/e2e@v1");
+        expect(readme).toContain(`swenyai/sweny@${CURRENT_ACTION_VERSION}`);
+    });
 });

package/dist/cli/main.js

@@ -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,
@@ -353,7 +353,10 @@ triageCmd.action(async (options) => {
         // GitHub Actions step summary
         if (config.notificationProvider === "github-summary" && process.env.GITHUB_STEP_SUMMARY) {
             try {
-                const md = formatDagResultMarkdown(results, durationMs, config);
+                const md = formatDagResultMarkdown(results, durationMs, config, {
+                    workflow: triageWorkflow,
+                    trace,
+                });
                 fs.appendFileSync(process.env.GITHUB_STEP_SUMMARY, md);
             }
             catch (err) {

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;
@@ -27,10 +27,23 @@ export declare function formatResultJson(results: Map<string, NodeResult>): stri
 /**
  * Format triage results as GitHub-flavored markdown for `$GITHUB_STEP_SUMMARY`.
  *
- * Designed to render nicely in the GitHub Actions job summary panel:
- *   - Status line with an emoji for quick visual scanning
- *   - Links to any created issues or PRs
- *   - Findings table (for dry runs or no-action results)
- *   - Error detail when a node failed
+ * 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 declare function formatDagResultMarkdown(results: Map<string, NodeResult>, durationMs: number, config?: CliConfig): string;
+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,19 +405,10 @@ export function formatCheckResults(results) {
 export function formatResultJson(results) {
     return JSON.stringify(Object.fromEntries(results), null, 2);
 }
-// ── Markdown output (for GitHub Actions step summary) ───────────
-/**
- * Format triage results as GitHub-flavored markdown for `$GITHUB_STEP_SUMMARY`.
- *
- * Designed to render nicely in the GitHub Actions job summary panel:
- *   - Status line with an emoji for quick visual scanning
- *   - Links to any created issues or PRs
- *   - Findings table (for dry runs or no-action results)
- *   - Error detail when a node failed
- */
-export function formatDagResultMarkdown(results, durationMs, config) {
+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;
@@ -427,33 +419,24 @@ export function formatDagResultMarkdown(results, durationMs, config) {
             break;
         }
     }
-    if (failedResult) {
-        lines.push(`## ❌ SWEny Triage Failed`);
-        lines.push("");
-        lines.push(`**Failed at:** \`${failedNodeId}\`  `);
-        lines.push(`**Duration:** ${duration}`);
-        if (failedResult.data?.error) {
-            lines.push("");
-            lines.push("```");
-            lines.push(String(failedResult.data.error));
-            lines.push("```");
-        }
-        return lines.join("\n") + "\n";
-    }
     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;
-    // Header — pick the most informative title
-    if (prData?.prUrl) {
+    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 (config?.dryRun) {
+    else if (isDryRun) {
         lines.push(`## 🔍 SWEny Triage — Dry run complete`);
     }
     else if (novelCount === 0) {
@@ -463,67 +446,167 @@ export function formatDagResultMarkdown(results, durationMs, config) {
         lines.push(`## ℹ️ SWEny Triage — No action taken`);
     }
     lines.push("");
-    lines.push(`**Duration:** ${duration}  `);
-    if (config?.serviceFilter && config.serviceFilter !== "*") {
-        lines.push(`**Service filter:** \`${config.serviceFilter}\`  `);
-    }
-    if (config?.timeRange) {
-        lines.push(`**Time range:** ${config.timeRange}  `);
-    }
-    if (highestSeverity) {
-        lines.push(`**Highest severity:** ${highestSeverity}  `);
-    }
-    lines.push(`**Novel findings:** ${novelCount}`);
-    // Issue and PR links
-    if (issueData?.issueIdentifier || issueData?.issueUrl) {
-        lines.push("");
-        lines.push("### 📋 Issue");
-        const id = issueData.issueIdentifier ? `**${String(issueData.issueIdentifier)}** — ` : "";
-        const title = issueData.issueTitle ? String(issueData.issueTitle) : "";
-        const url = issueData.issueUrl ? String(issueData.issueUrl) : "";
-        if (url) {
-            lines.push(`${id}[${title || url}](${url})`);
-        }
-        else {
-            lines.push(`${id}${title}`);
+    // ── 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("");
     }
-    if (prData?.prUrl) {
+    // ── 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("");
-        lines.push("### 🔧 Pull request");
-        const num = prData.prNumber ? `#${String(prData.prNumber)}` : "";
-        lines.push(`[${num || String(prData.prUrl)}](${String(prData.prUrl)})`);
     }
-    // Findings table — mostly useful for dry runs and no-action results
-    if (findings && findings.length > 0 && !prData?.prUrl) {
+    // ── 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 | Status |");
-        lines.push("| --- | --- | --- |");
-        for (const f of findings.slice(0, 10)) {
+        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 status = f.is_duplicate ? "duplicate" : "novel";
-            lines.push(`| ${sev} | ${title} | ${status} |`);
+            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} |`);
         }
-        if (findings.length > 10) {
-            lines.push("");
-            lines.push(`_…and ${findings.length - 10} more_`);
+        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
+    // ── Recommendation / next step ────────────────────────────────
     const rec = investigateData?.recommendation;
     if (rec) {
-        lines.push("");
         lines.push(`**Next:** ${String(rec)}`);
-    }
-    if (config?.dryRun) {
         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.js

@@ -1,5 +1,6 @@
 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: [] };
 }
@@ -10,10 +11,41 @@ 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([
@@ -33,13 +65,15 @@ describe("formatDagResultMarkdown", () => {
         ]);
         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("| 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([
@@ -52,13 +86,13 @@ describe("formatDagResultMarkdown", () => {
         const md = formatDagResultMarkdown(results, 5_000, minimalConfig());
         expect(md).toContain("## ✅ SWEny Triage — Issue created");
         expect(md).toContain("OFF-5");
-        expect(md).not.toContain("Pull request");
+        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");
+        expect(md).toContain("| Novel findings | 0 |");
     });
     it("renders a findings table in dry-run mode", () => {
         const results = new Map([
@@ -68,18 +102,19 @@ describe("formatDagResultMarkdown", () => {
                     novel_count: 2,
                     highest_severity: "high",
                     findings: [
-                        { severity: "high", title: "OOM in worker", is_duplicate: false },
-                        { severity: "low", title: "Stale metric", is_duplicate: true },
+                        { 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 | Status |");
-        expect(md).toContain("| high | OOM in worker | novel |");
-        expect(md).toContain("| low | Stale metric | duplicate |");
+        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([
@@ -104,4 +139,41 @@ describe("formatDagResultMarkdown", () => {
         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.45",
+  "version": "0.1.47",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"