@sweny-ai/core 0.1.170 → 0.1.172

package/dist/cli/record.d.ts

@@ -0,0 +1,66 @@
+/**
+ * `sweny try --record <file.svg>`: the demo as an animated terminal SVG.
+ *
+ * Runs the real `sweny try` replay (instant, no TTY) with color forced on,
+ * captures the ANSI text, and lays it out as a slate terminal window whose
+ * lines appear on a CSS keyframe timeline: the command, a spinner per node
+ * until it settles, the answer, the receipt ticket with its stamp
+ * landing last. Then it loops.
+ *
+ * Self-contained by construction: inline CSS only, a monospace font stack, no
+ * external fonts, images, links or scripts. Deterministic: no clock, no ids,
+ * no randomness; the same fixture and theme always yield the same bytes, so
+ * CI can regenerate the file and fail when the committed copy is stale.
+ * `prefers-reduced-motion` shows the finished frame with no animation.
+ */
+import { type TryFixture } from "./try.js";
+/** Terminal width the demo is rendered at (the ticket and DAG are designed for 80). */
+export declare const RECORD_COLUMNS = 80;
+/** Lines longer than this wrap in the window, like a terminal would. */
+export declare const RECORD_WRAP = 96;
+/** Width of one terminal column in the window, in px. Every segment is placed at column * CELL_W. */
+export declare const CELL_W = 7.85;
+/** Left edge of column 0. */
+export declare const TEXT_X = 24;
+export interface Style {
+    fg?: string;
+    bold?: boolean;
+    dim?: boolean;
+    underline?: boolean;
+}
+export interface Cell {
+    ch: string;
+    style: Style;
+}
+/** One line of ANSI text as styled cells. Cursor and erase sequences are dropped. */
+export declare function parseAnsiLine(line: string): Cell[];
+/** Soft-wrap a row of cells at `max` columns, on spaces, continuation indented two past the first. */
+export declare function wrapCells(cells: Cell[], max: number): Cell[][];
+export interface Row {
+    cells: Cell[];
+    /** Vertical slot. A spinner shares the slot of the line that replaces it. */
+    slot: number;
+    /** Seconds at which the row appears. */
+    from: number;
+    /** Seconds at which it disappears again (spinners). Absent: stays until the loop restarts. */
+    to?: number;
+    spinner?: boolean;
+}
+/** Lay captured output lines on the timeline. Pure. */
+export declare function buildTimeline(lines: string[], fixture: TryFixture): {
+    rows: Row[];
+    slots: number;
+    total: number;
+};
+/** Render the timeline as a self-contained animated SVG. Pure and deterministic. */
+export declare function renderRecordingSvg(lines: string[], fixture: TryFixture): string;
+/**
+ * The PR-comment preview (heading plus DAG) sits between the answer and the
+ * ticket. The recording drops it to stay a README-sized hero: tagline, nodes,
+ * answer, ticket.
+ */
+export declare function dropCommentPreview(lines: string[]): string[];
+/** Run the demo and return the SVG text. */
+export declare function recordTrySvg(fixture?: TryFixture): Promise<string>;
+/** Record to `file`, creating its directory. Returns the byte size written. */
+export declare function recordTrySvgToFile(file: string, fixture?: TryFixture): Promise<number>;

package/dist/cli/record.js

@@ -0,0 +1,344 @@
+/**
+ * `sweny try --record <file.svg>`: the demo as an animated terminal SVG.
+ *
+ * Runs the real `sweny try` replay (instant, no TTY) with color forced on,
+ * captures the ANSI text, and lays it out as a slate terminal window whose
+ * lines appear on a CSS keyframe timeline: the command, a spinner per node
+ * until it settles, the answer, the receipt ticket with its stamp
+ * landing last. Then it loops.
+ *
+ * Self-contained by construction: inline CSS only, a monospace font stack, no
+ * external fonts, images, links or scripts. Deterministic: no clock, no ids,
+ * no randomness; the same fixture and theme always yield the same bytes, so
+ * CI can regenerate the file and fail when the committed copy is stale.
+ * `prefers-reduced-motion` shows the finished frame with no animation.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import chalk from "chalk";
+import { GLYPHS, PALETTE, ROLE_COLORS, SPINNER_FRAMES, SURFACE_COLORS } from "../theme.js";
+import { loadTryFixture, runTry } from "./try.js";
+/** Terminal width the demo is rendered at (the ticket and DAG are designed for 80). */
+export const RECORD_COLUMNS = 80;
+/** Lines longer than this wrap in the window, like a terminal would. */
+export const RECORD_WRAP = 96;
+const FONT_SIZE = 13;
+/** Width of one terminal column in the window, in px. Every segment is placed at column * CELL_W. */
+export const CELL_W = 7.85;
+/** Left edge of column 0. */
+export const TEXT_X = 24;
+const NBSP = "\u00A0";
+const LINE_H = 19;
+const PAD_X = TEXT_X;
+const BAR_H = 38;
+const PAD_TOP = 18;
+const PAD_BOTTOM = 22;
+const WINDOW_W = Math.ceil(RECORD_WRAP * CELL_W + PAD_X * 2);
+const FONT_STACK = "ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas, 'Liberation Mono', monospace";
+const SECONDS_PER_LINE = 0.06;
+const SECONDS_PER_BLANK = 0.25;
+const SECONDS_STAMP_DELAY = 0.5;
+const SECONDS_HOLD = 5;
+const BASIC_COLORS = {
+    30: PALETTE.slate900,
+    31: ROLE_COLORS.error,
+    32: ROLE_COLORS.success,
+    33: ROLE_COLORS.warning,
+    34: ROLE_COLORS.brand,
+    35: PALETTE.blue300,
+    36: ROLE_COLORS.info,
+    37: SURFACE_COLORS.dark.text,
+    90: ROLE_COLORS.muted,
+    91: ROLE_COLORS.error,
+    92: ROLE_COLORS.success,
+    93: ROLE_COLORS.warning,
+    94: ROLE_COLORS.info,
+    95: PALETTE.blue300,
+    96: ROLE_COLORS.info,
+    97: PALETTE.white,
+};
+const hex = (n) => n.toString(16).padStart(2, "0");
+/** Apply one SGR parameter list to a style. */
+function applySgr(style, params) {
+    const next = { ...style };
+    for (let i = 0; i < params.length; i++) {
+        const p = params[i];
+        if (p === 0)
+            return {};
+        else if (p === 1)
+            next.bold = true;
+        else if (p === 2)
+            next.dim = true;
+        else if (p === 22) {
+            delete next.bold;
+            delete next.dim;
+        }
+        else if (p === 4)
+            next.underline = true;
+        else if (p === 24)
+            delete next.underline;
+        else if (p === 39)
+            delete next.fg;
+        else if (p === 38 && params[i + 1] === 2) {
+            next.fg = `#${hex(params[i + 2] ?? 0)}${hex(params[i + 3] ?? 0)}${hex(params[i + 4] ?? 0)}`;
+            i += 4;
+        }
+        else if (p === 38 && params[i + 1] === 5) {
+            next.fg = SURFACE_COLORS.dark.text;
+            i += 2;
+        }
+        else if (BASIC_COLORS[p])
+            next.fg = BASIC_COLORS[p];
+    }
+    return next;
+}
+/** One line of ANSI text as styled cells. Cursor and erase sequences are dropped. */
+export function parseAnsiLine(line) {
+    const cells = [];
+    let style = {};
+    const re = /\x1B\[([0-9;]*)([A-Za-z])/g;
+    let last = 0;
+    const push = (text) => {
+        for (const ch of text.replace(/\r/g, ""))
+            cells.push({ ch, style });
+    };
+    for (let m = re.exec(line); m; m = re.exec(line)) {
+        push(line.slice(last, m.index));
+        if (m[2] === "m")
+            style = applySgr(style, m[1] === "" ? [0] : m[1].split(";").map(Number));
+        last = m.index + m[0].length;
+    }
+    push(line.slice(last));
+    return cells;
+}
+const sameStyle = (a, b) => a.fg === b.fg && !!a.bold === !!b.bold && !!a.dim === !!b.dim && !!a.underline === !!b.underline;
+/** Soft-wrap a row of cells at `max` columns, on spaces, continuation indented two past the first. */
+export function wrapCells(cells, max) {
+    const rows = [];
+    const indent = cells.findIndex((c) => c.ch !== " ");
+    const pad = " ".repeat(Math.max(0, indent) + 2);
+    let rest = cells;
+    while (rest.length > max) {
+        let cut = -1;
+        for (let i = max; i > pad.length; i--) {
+            if (rest[i].ch === " ") {
+                cut = i;
+                break;
+            }
+        }
+        if (cut < 0)
+            cut = max;
+        rows.push(rest.slice(0, cut));
+        let tail = rest.slice(cut);
+        while (tail.length > 0 && tail[0].ch === " ")
+            tail = tail.slice(1);
+        rest = [...[...pad].map((ch) => ({ ch, style: {} })), ...tail];
+    }
+    rows.push(rest);
+    return rows;
+}
+const plainText = (cells) => cells.map((c) => c.ch).join("");
+function textCells(text, style = {}) {
+    return [...text].map((ch) => ({ ch, style }));
+}
+/** Lay captured output lines on the timeline. Pure. */
+export function buildTimeline(lines, fixture) {
+    const rows = [];
+    const nodeIds = Object.keys(fixture.nodes);
+    const settledPrefix = (id) => `  ${GLYPHS.unicode.success} ${id}`;
+    const spinnerGlyph = SPINNER_FRAMES.unicode[3];
+    let t = 0.5;
+    let slot = 0;
+    // The command being typed.
+    rows.push({
+        cells: [...textCells("$ ", { fg: ROLE_COLORS.muted }), ...textCells("sweny try", { bold: true })],
+        slot: slot++,
+        from: t,
+    });
+    t += 0.9;
+    for (const line of lines) {
+        const cells = parseAnsiLine(line);
+        const text = plainText(cells);
+        const id = nodeIds.find((n) => text.startsWith(settledPrefix(n)));
+        if (id) {
+            const seconds = 0.8 + Math.min(1.6, fixture.nodes[id].duration_ms / 12000);
+            rows.push({
+                cells: [...textCells("  "), ...textCells(spinnerGlyph, { fg: ROLE_COLORS.brand }), ...textCells(` ${id}`)],
+                slot,
+                from: t,
+                to: t + seconds,
+                spinner: true,
+            });
+            t += seconds;
+        }
+        else if (/\[ (ENV|SANDBOXED|UNSANDBOXED)\b/.test(text)) {
+            // The policy stamp lands a beat after the card.
+            t += SECONDS_STAMP_DELAY;
+        }
+        for (const part of wrapCells(cells, RECORD_WRAP)) {
+            rows.push({ cells: part, slot, from: t });
+            slot++;
+        }
+        t += text.trim() === "" ? SECONDS_PER_BLANK : SECONDS_PER_LINE;
+    }
+    return { rows, slots: slot, total: t + SECONDS_HOLD };
+}
+// ── SVG ─────────────────────────────────────────────────────────
+const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+const pct = (seconds, total) => ((seconds / total) * 100).toFixed(2);
+/** Render the timeline as a self-contained animated SVG. Pure and deterministic. */
+export function renderRecordingSvg(lines, fixture) {
+    const { rows, slots, total } = buildTimeline(lines, fixture);
+    const height = BAR_H + PAD_TOP + slots * LINE_H + PAD_BOTTOM;
+    const dark = SURFACE_COLORS.dark;
+    // Color classes by first use, so the CSS is small and the order is stable.
+    const colorClass = new Map();
+    const classFor = (style) => {
+        const names = [];
+        if (style.fg) {
+            let c = colorClass.get(style.fg);
+            if (!c) {
+                c = `c${colorClass.size}`;
+                colorClass.set(style.fg, c);
+            }
+            names.push(c);
+        }
+        if (style.bold)
+            names.push("b");
+        if (style.dim)
+            names.push("d");
+        if (style.underline)
+            names.push("u");
+        return names.join(" ");
+    };
+    // Keyframes by (from, to), numbered by first use.
+    const frames = new Map();
+    const frameFor = (from, to) => {
+        const key = `${pct(from, total)}:${to === undefined ? "" : pct(to, total)}`;
+        let name = frames.get(key);
+        if (!name) {
+            name = `k${frames.size}`;
+            frames.set(key, name);
+        }
+        return name;
+    };
+    const body = [];
+    for (const row of rows) {
+        const y = BAR_H + PAD_TOP + row.slot * LINE_H + FONT_SIZE;
+        const spans = [];
+        let i = 0;
+        while (i < row.cells.length) {
+            let j = i + 1;
+            while (j < row.cells.length && sameStyle(row.cells[i].style, row.cells[j].style))
+                j++;
+            const raw = row.cells
+                .slice(i, j)
+                .map((c) => c.ch)
+                .join("");
+            // Layout must not depend on whitespace handling (rsvg, proxies and some viewers collapse
+            // spaces): each segment sits at an explicit x for its column, edge spaces become offset
+            // or nothing, and inner spaces are non-breaking.
+            const lead = raw.length - raw.trimStart().length;
+            const body_ = raw.trim();
+            if (body_ !== "") {
+                const x = (TEXT_X + (i + lead) * CELL_W).toFixed(2);
+                const text = esc(body_).replace(/ /g, NBSP);
+                const cls = classFor(row.cells[i].style);
+                spans.push(`<tspan x="${x}"${cls ? ` class="${cls}"` : ""}>${text}</tspan>`);
+            }
+            i = j;
+        }
+        const cls = `r ${frameFor(row.from, row.to)}${row.spinner ? " sp" : ""}`;
+        body.push(`<text class="${cls}" x="${TEXT_X}" y="${y}" xml:space="preserve">${spans.join("")}</text>`);
+    }
+    const css = [
+        `text{font-family:${FONT_STACK};font-size:${FONT_SIZE}px;fill:${dark.text};white-space:pre}`,
+        // No-animation default is the FINAL frame: lines visible, spinner frames hidden. Keyframes drive the replay.
+        `.r{opacity:1}`,
+        `.sp{opacity:0}`,
+        `.b{font-weight:700}`,
+        `.d{fill-opacity:.65}`,
+        `.u{text-decoration:underline}`,
+        `.t{fill:${dark.textSecondary};font-size:12px}`,
+    ];
+    for (const [fg, name] of colorClass)
+        css.push(`.${name}{fill:${fg}}`);
+    for (const [key, name] of frames) {
+        const [from, to] = key.split(":");
+        const a = Number(from);
+        const keyframe = to === ""
+            ? `0%,${from}%{opacity:0}${(a + 0.01).toFixed(2)}%,98%{opacity:1}100%{opacity:0}`
+            : `0%,${from}%{opacity:0}${(a + 0.01).toFixed(2)}%,${to}%{opacity:1}${(Number(to) + 0.01).toFixed(2)}%,100%{opacity:0}`;
+        css.push(`@keyframes ${name}{${keyframe}}`);
+        css.push(`.${name}{animation:${name} ${total.toFixed(2)}s linear infinite}`);
+    }
+    css.push(`@media (prefers-reduced-motion:reduce){.r{animation:none!important}.sp{display:none}}`);
+    const label = "Recorded demo of sweny try: two nodes run, then the answer and the receipt ticket.";
+    return [
+        `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${WINDOW_W} ${height}" width="${WINDOW_W}" height="${height}" xml:space="preserve" role="img" aria-label="${esc(label)}">`,
+        `<title>sweny try</title>`,
+        `<style>${css.join("")}</style>`,
+        `<rect x="0.5" y="0.5" width="${WINDOW_W - 1}" height="${height - 1}" rx="10" fill="${dark.background}" stroke="${dark.border}"/>`,
+        `<path d="M0.5 ${BAR_H}V10.5A10 10 0 0 1 10.5 0.5H${WINDOW_W - 10.5}A10 10 0 0 1 ${WINDOW_W - 0.5} 10.5V${BAR_H}Z" fill="${PALETTE.slate900}" stroke="${dark.border}"/>`,
+        `<circle cx="20" cy="19" r="5.5" fill="${ROLE_COLORS.error}"/>`,
+        `<circle cx="40" cy="19" r="5.5" fill="${ROLE_COLORS.warning}"/>`,
+        `<circle cx="60" cy="19" r="5.5" fill="${ROLE_COLORS.success}"/>`,
+        `<text class="t" x="${WINDOW_W / 2}" y="23" text-anchor="middle">sweny try</text>`,
+        ...body,
+        `</svg>`,
+        ``,
+    ].join("\n");
+}
+// ── Entry points ────────────────────────────────────────────────
+const stripAnsi = (s) => s.replace(/\x1B\[[0-9;]*[A-Za-z]/g, "");
+/**
+ * The PR-comment preview (heading plus DAG) sits between the answer and the
+ * ticket. The recording drops it to stay a README-sized hero: tagline, nodes,
+ * answer, ticket.
+ */
+export function dropCommentPreview(lines) {
+    const from = lines.findIndex((l) => stripAnsi(l).includes("On a pull request, CI posts"));
+    const to = lines.findIndex((l, i) => i > from && stripAnsi(l).startsWith("  \u256D"));
+    if (from < 0 || to < 0)
+        return lines;
+    return [...lines.slice(0, from), ...lines.slice(to)];
+}
+/** Run the demo and return the SVG text. */
+export async function recordTrySvg(fixture = loadTryFixture()) {
+    let out = "";
+    // The DAG renderer paints through the default chalk; pin it so the capture carries color on any host.
+    const prevLevel = chalk.level;
+    chalk.level = 3;
+    try {
+        const code = await runTry({
+            fast: true,
+            tty: false,
+            color: true,
+            rich: true,
+            unicode: true,
+            columns: RECORD_COLUMNS,
+            fixture,
+            write: (s) => {
+                out += s;
+            },
+        });
+        if (code !== 0)
+            throw new Error(`the demo run exited ${code}`);
+    }
+    finally {
+        chalk.level = prevLevel;
+    }
+    const lines = out.split("\n");
+    while (lines.length > 0 && lines[0].trim() === "")
+        lines.shift();
+    while (lines.length > 0 && lines[lines.length - 1].trim() === "")
+        lines.pop();
+    return renderRecordingSvg(dropCommentPreview(lines), fixture);
+}
+/** Record to `file`, creating its directory. Returns the byte size written. */
+export async function recordTrySvgToFile(file, fixture) {
+    const svg = await recordTrySvg(fixture);
+    fs.mkdirSync(path.dirname(path.resolve(file)), { recursive: true });
+    fs.writeFileSync(file, svg);
+    return Buffer.byteLength(svg);
+}

package/dist/cli/renderer.d.ts

@@ -7,6 +7,10 @@ export interface DagRendererOptions {
     animate?: boolean;
     /** Stream to write to when animate=true or render() is called. Default: process.stderr. */
     stream?: NodeJS.WriteStream;
+    /** Show the status legend under the graph. Default: true. */
+    legend?: boolean;
+    /** Draw with Unicode box characters, else ASCII. Default: what the terminal supports. */
+    unicode?: boolean;
 }
 export declare class DagRenderer {
     private readonly workflow;

package/dist/cli/renderer.js

@@ -1,4 +1,6 @@
 import chalk from "chalk";
+import { GLYPHS, ROLE_COLORS } from "../theme.js";
+import { supportsUnicode, toAsciiDrawing } from "./terminal.js";
 // ── Helpers ──────────────────────────────────────────────────────
 /** Strip ANSI escape codes for accurate visible-width calculations. */
 export function stripAnsi(str) {
@@ -48,17 +50,18 @@ function topologicalOrder(workflow) {
     }
     return order;
 }
-// ── Status icons + colors ────────────────────────────────────────
+// ── Status icons + colors (the theme glyph set, one role color each) ─
+const G = GLYPHS.unicode;
 function statusIcon(state) {
     switch (state) {
         case "completed":
-            return chalk.green("●");
+            return chalk.hex(ROLE_COLORS.success)(G.success);
         case "running":
-            return chalk.yellow("◉");
+            return chalk.hex(ROLE_COLORS.brand)(G.running);
         case "pending":
-            return chalk.gray("○");
+            return chalk.hex(ROLE_COLORS.muted)(G.pending);
         case "failed":
-            return chalk.red("✕");
+            return chalk.hex(ROLE_COLORS.error)(G.failure);
     }
 }
 // ── Graph helpers ────────────────────────────────────────────────
@@ -143,7 +146,7 @@ function renderNodeBox(nodeName, nodeRenderState, innerWidth, indent, topConnect
     else {
         bottom = `${pad}└${"─".repeat(innerWidth)}┘`;
     }
-    // Content lines — icon on first line, wrapped name
+    // Content lines: icon on first line, wrapped name
     // Available space for text: innerWidth - 4 (1 space + icon + 1 space + text + padding + 1 space)
     // "│ ○ Name...padding │"  → icon(1) + spaces(2) + name + pad
     const iconVis = stripAnsi(icon); // 1 char
@@ -184,10 +187,10 @@ function renderNodeBox(nodeName, nodeRenderState, innerWidth, indent, topConnect
 // ── Legend ───────────────────────────────────────────────────────
 function renderLegend() {
     const items = [
-        `${chalk.green("●")} completed`,
-        `${chalk.yellow("◉")} running`,
-        `${chalk.gray("○")} pending`,
-        `${chalk.red("✕")} failed`,
+        `${statusIcon("completed")} completed`,
+        `${statusIcon("running")} running`,
+        `${statusIcon("pending")} pending`,
+        `${statusIcon("failed")} failed`,
     ];
     return `\n  ${chalk.dim(items.join("   "))}`;
 }
@@ -202,6 +205,8 @@ export class DagRenderer {
         this.workflow = workflow;
         this.options = {
             animate: options.animate ?? false,
+            legend: options.legend ?? true,
+            unicode: options.unicode ?? supportsUnicode(),
             stream: options.stream ??
                 (typeof process !== "undefined" ? process.stderr : undefined),
         };
@@ -298,7 +303,7 @@ export class DagRenderer {
                     continue;
                 const leftState = this.nodeStates.get(leftId) ?? { state: "pending", toolCallCount: 0 };
                 const rightState = this.nodeStates.get(rightId) ?? { state: "pending", toolCallCount: 0 };
-                // Determine child box widths — each child gets its own width based on its name
+                // Determine child box widths: each child gets its own width based on its name
                 const leftKids = children.get(leftId) ?? [];
                 const rightKids = children.get(rightId) ?? [];
                 // For side-by-side, compute widths that fit
@@ -391,8 +396,10 @@ export class DagRenderer {
                 }
             }
         }
-        lines.push(renderLegend());
-        return lines.join("\n");
+        if (this.options.legend)
+            lines.push(renderLegend());
+        const out = lines.join("\n");
+        return this.options.unicode ? out : toAsciiDrawing(out);
     }
     /**
      * Writes the current DAG render to the stream.

package/dist/cli/run-output.d.ts

@@ -68,6 +68,11 @@ export interface RunPolicy {
 export declare function degradedKey(entry: string): string;
 /** Sum the per-node results into one run summary. */
 export declare function summarizeRun(results: Map<string, NodeResult>, durationMs: number, crashed?: boolean, trace?: ExecutionTrace): RunSummary;
+/**
+ * The policy facts the run knew, as short phrases: `env scoped`, `sandbox on`,
+ * `1 output staged`. No phrase for a fact no node reported.
+ */
+export declare function policyParts(p: RunPolicy | undefined): string[];
 /**
  * `policy: env scoped, sandbox on, 1 output staged`. Only what the run knew:
  * no segment for a fact no node reported. Undefined when there is nothing to say.
@@ -76,8 +81,12 @@ export declare function formatPolicySegment(p: RunPolicy | undefined): string |
 export declare function formatReceiptDuration(ms: number): string;
 export declare function formatTokenCount(n: number): string;
 export declare function formatCost(usd: number): string;
+/** `tokens 52k of 50k`: the overrun, in the budget's unit. */
+export declare function formatBudgetAmount(b: NonNullable<RunSummary["budget"]>): string;
 /** `budget exceeded: tokens 52k of 50k (run, at node gather)`. */
 export declare function formatBudgetOverrun(b: NonNullable<RunSummary["budget"]>): string;
+/** `agreed 4/5`, or `fell through 2/2` when no decision passed the gates. */
+export declare function formatDeciderCounts(d: NonNullable<RunSummary["decider"]>): string;
 /**
  * One plain line: `✓ 3/3 nodes · 41 tool calls · 2m10s · 12k tokens · $0.18`.
  * Token and cost segments are omitted when the SDK reported none. A harness
@@ -86,15 +95,11 @@ export declare function formatBudgetOverrun(b: NonNullable<RunSummary["budget"]>
  * when writing to a TTY.
  */
 export declare function formatReceipt(s: RunSummary): string;
-/** Receipt for a terminal: colored only when `color` is true. */
+/** Receipt for a terminal: in the success or error color only when `color` is true. */
 export declare function renderReceiptLine(s: RunSummary, color: boolean): string;
-/** Brand blue (blue-600 / blue-700), not indigo. Applied to successful nodes. */
-export declare const STEP_SUMMARY_CLASS_DEFS: {
-    readonly success: "fill:#2563eb,stroke:#1d4ed8,color:#fff,stroke-width:2px";
-};
 /** Per-node Mermaid status from run results. */
 export declare function nodeStates(results: Map<string, NodeResult>): Record<string, NodeStatus>;
-/** Markdown for `$GITHUB_STEP_SUMMARY`: receipt + status-colored Mermaid DAG. */
+/** Markdown for `$GITHUB_STEP_SUMMARY`: receipt + Mermaid DAG in the brand classDefs. */
 export declare function formatStepSummary(workflow: Workflow, results: Map<string, NodeResult>, summary: RunSummary, trace?: ExecutionTrace): string;
 /**
  * Append the step summary to the file named by GITHUB_STEP_SUMMARY.
@@ -116,6 +121,8 @@ export interface RunLogger extends Logger {
 export declare function createRunLogger(opts: {
     verbose: boolean;
     tty: boolean;
+    /** Color the markers. Default: `tty` and color is enabled for stderr. */
+    color?: boolean;
     write?: (s: string) => void;
 }): RunLogger;
 export declare const WORKFLOW_RUN_DESCRIPTION = "Run a workflow from a YAML or JSON file. With no file, batch-runs every workflow in .sweny/e2e/ (lists and confirms first; use --yes to skip the prompt).";