@sweny-ai/core 0.1.171 → 0.1.173

package/dist/cli/new.js

@@ -328,7 +328,7 @@ export function inferObservability(skills) {
  */
 export function buildSwenyYml(sourceControl, observability, issueTracker) {
     const lines = [];
-    lines.push("# .sweny.yml — SWEny project configuration");
+    lines.push("# .sweny.yml - SWEny project configuration");
     lines.push("# Secrets (API keys, tokens) go in .env (gitignored).");
     lines.push("# Docs: https://docs.sweny.ai/cli");
     lines.push("");
@@ -345,7 +345,7 @@ export function buildSwenyYml(sourceControl, observability, issueTracker) {
  */
 export function buildEnvTemplate(credentials) {
     const lines = [];
-    lines.push("# .env — SWEny credentials (DO NOT COMMIT)");
+    lines.push("# .env - SWEny credentials (DO NOT COMMIT)");
     lines.push("# Fill in each value, then run: sweny check");
     lines.push("");
     for (const cred of credentials) {
@@ -746,7 +746,7 @@ export async function runNew(options) {
         summaryLines.push("");
     }
     if (hasExistingConfig) {
-        summaryLines.push(chalk.dim("(.sweny.yml already exists — keeping your existing config)"));
+        summaryLines.push(chalk.dim("(.sweny.yml already exists - keeping your existing config)"));
         summaryLines.push("");
     }
     summaryLines.push(chalk.bold(hasExistingConfig ? "Workflow uses:" : "Inferred from workflow:"));
@@ -773,7 +773,7 @@ export async function runNew(options) {
         p.log.success("Created .sweny.yml");
     }
     else {
-        p.log.info(".sweny.yml already exists — keeping existing config");
+        p.log.info(".sweny.yml already exists - keeping existing config");
     }
     // 2. Append missing .env keys
     const envExistedBefore = fs.existsSync(path.join(cwd, ".env"));
@@ -786,7 +786,7 @@ export async function runNew(options) {
         p.log.success(`Appended ${addedCount} new key(s) to .env`);
     }
     else {
-        p.log.info(".env already contains all required keys — skipped");
+        p.log.info(".env already contains all required keys - skipped");
     }
     // The pack's Actions trigger (#474): never overwritten, skipped with --no-ci.
     const installTrigger = () => {
@@ -815,7 +815,7 @@ export async function runNew(options) {
             if (p.isCancel(overwrite))
                 cancel();
             if (!overwrite) {
-                p.log.info("Workflow file preserved — no changes");
+                p.log.info("Workflow file preserved - no changes");
                 p.outro("Done.");
                 return;
             }
@@ -903,8 +903,8 @@ async function runCustomWorkflowBuilder(skills) {
         const action = await p.select({
             message: "Looks good?",
             options: [
-                { value: "accept", label: "Yes — use this workflow" },
-                { value: "refine", label: "Refine — describe what to change" },
+                { value: "accept", label: "Yes - use this workflow" },
+                { value: "refine", label: "Refine - describe what to change" },
                 { value: "cancel", label: "Cancel" },
             ],
         });

package/dist/cli/publish.js

@@ -216,7 +216,7 @@ async function publishWorkflow() {
         p.log.error(`Validation failed:\n${validation.errors.map((e) => `  - ${e}`).join("\n")}`);
         return null;
     }
-    p.log.success(`Validated: ${chalk.cyan(validation.name)} — ${validation.nodeCount} nodes, ${validation.edgeCount} edges`);
+    p.log.success(`Validated: ${chalk.cyan(validation.name)} - ${validation.nodeCount} nodes, ${validation.edgeCount} edges`);
     if (validation.warnings.length > 0) {
         for (const warn of validation.warnings) {
             p.log.warn(warn);
@@ -312,7 +312,7 @@ async function selectOutputMode(type, id, sourcePath, meta) {
     const hasGh = ghAvailable();
     const options = [
         ...(hasGh
-            ? [{ value: "pr", label: "Open GitHub PR", hint: "recommended — forks marketplace repo and opens a PR" }]
+            ? [{ value: "pr", label: "Open GitHub PR", hint: "recommended - forks marketplace repo and opens a PR" }]
             : []),
         { value: "save", label: "Save submission file", hint: "saves to ./sweny-publish/" },
     ];

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/resume.js

@@ -7,7 +7,7 @@
  */
 import path from "node:path";
 import { validateRuntimeInput } from "../inputs.js";
-import { JOURNAL_DIR, JOURNAL_FILE, JournalLockedError, JournalVersionError, RunJournal, buildResumePlan, canonicalHash, findJournalRun, journalDir, mayRepeatWrites, readJournal, workflowHashOf, } from "../journal.js";
+import { JOURNAL_DIR, JOURNAL_FILE, JournalKeyError, JournalLockedError, JournalVersionError, RunJournal, buildResumePlan, canonicalHash, checkJournalAgainstWorkflow, findJournalRun, journalDir, mayRepeatWrites, readJournal, workflowHashOf, } from "../journal.js";
 import { parseInputFlag } from "./workflow-input.js";
 /** Resume-only flags; the rest are shared with `workflow run`. */
 export const WORKFLOW_RESUME_OPTIONS = [
@@ -83,10 +83,14 @@ export function prepareResume(ref, opts, deps) {
         read = readJournal(file, { repair: !opts.plan });
     }
     catch (err) {
-        if (err instanceof JournalVersionError)
+        if (err instanceof JournalVersionError || err instanceof JournalKeyError)
             return fail(err.message);
         return fail(`cannot read ${file}: ${err instanceof Error ? err.message : String(err)}`);
     }
+    if (read.forgedAtLine !== undefined) {
+        return fail(`run journal ${file} line ${read.forgedAtLine} fails authentication: it was edited or written by something ` +
+            `other than this run. Refusing to resume. Start a new run.`);
+    }
     if (read.corruptAtLine !== undefined) {
         return fail(`run journal ${file} is damaged at line ${read.corruptAtLine}, with valid records after it. ` +
             `That is not a torn last write, so it cannot be repaired safely. Start a new run.`);
@@ -122,6 +126,10 @@ export function prepareResume(ref, opts, deps) {
         }
         lines.push(`warning: --force: workflow ${workflowFile} changed since the run started`);
     }
+    // Replayed control flow must exist in the workflow (not overridable by --force).
+    const flaw = checkJournalAgainstWorkflow(read.records, workflow);
+    if (flaw)
+        return fail(`cannot resume run ${runId}: ${flaw}. Start a new run.`);
     let input;
     if (opts.input !== undefined) {
         const parsed = parseInputFlag(opts.input);

package/dist/cli/setup.js

@@ -12,17 +12,17 @@ const SIGNAL_LABELS = [
     {
         name: "agent-needs-input",
         color: "CA8A04",
-        description: "Agent hit a decision point — needs human clarification before it can proceed",
+        description: "Agent hit a decision point - needs human clarification before it can proceed",
     },
     {
         name: "agent-error",
         color: "B91C1C",
-        description: "Unexpected technical failure during agent execution — needs human investigation",
+        description: "Unexpected technical failure during agent execution - needs human investigation",
     },
     {
         name: "human-only",
         color: "6B7280",
-        description: "Guard rail — automation must not touch this issue or PR",
+        description: "Guard rail - automation must not touch this issue or PR",
     },
     {
         name: "needs-review",
@@ -52,7 +52,7 @@ const WORK_TYPE_LABELS = [
     {
         name: "research",
         color: "D97706",
-        description: "Spike, investigation, or report by the agent — exploratory work without a direct code change",
+        description: "Spike, investigation, or report by the agent - exploratory work without a direct code change",
         isWorkType: true,
     },
     {
@@ -64,7 +64,7 @@ const WORK_TYPE_LABELS = [
     {
         name: "spec",
         color: "BE185D",
-        description: "Spec generation — agent converted non-technical input into a structured spec",
+        description: "Spec generation - agent converted non-technical input into a structured spec",
         isWorkType: true,
     },
     {
@@ -77,7 +77,7 @@ const WORK_TYPE_LABELS = [
 const AGENT_PARENT = {
     name: "agent",
     color: "7C3AED",
-    description: "Parent group — marks all autonomous agent work",
+    description: "Parent group - marks all autonomous agent work",
 };
 const BUG_LABEL = {
     name: "bug",
@@ -254,7 +254,7 @@ ${chalk.cyan(`  source-control-provider: github
   pr-labels: agent,triage,needs-review
   issue-labels: agent`)}
 
-${chalk.dim("  GitHub labels are referenced by name — no UUIDs needed.")}
+${chalk.dim("  GitHub labels are referenced by name - no UUIDs needed.")}
 `);
 }
 // ── Command registration ───────────────────────────────────────────────────

package/dist/cli/try.d.ts

@@ -86,6 +86,10 @@ export interface TryOptions {
     tty?: boolean;
     /** Draw with Unicode. Default: what the terminal supports. */
     unicode?: boolean;
+    /** Force ANSI color on or off. Default: on for a TTY that allows color. */
+    color?: boolean;
+    /** Force the receipt ticket (true) or the plain receipt line (false). Default: `tty`. */
+    rich?: boolean;
     /** Terminal width. Default: stdout's. */
     columns?: number;
     fixture?: TryFixture;

package/dist/cli/try.js

@@ -189,7 +189,7 @@ export async function runTry(opts = {}) {
     }
     const env = process.env;
     const unicode = opts.unicode ?? supportsUnicode(env);
-    const color = tty && colorEnabled({ isTTY: true }, env);
+    const color = opts.color ?? (tty && colorEnabled({ isTTY: true }, env));
     const paint = createPaint(color);
     const g = glyphsFor(unicode);
     const columns = opts.columns ?? terminalColumns(process.stdout, env);
@@ -263,7 +263,7 @@ export async function runTry(opts = {}) {
         runId: "demo",
         stream: { write, isTTY: tty, columns },
         env,
-        rich: tty,
+        rich: opts.rich ?? tty,
         color,
         unicode,
         animate: !opts.fast,
@@ -287,8 +287,21 @@ export function registerTryCommand(program) {
         .option("--fast", "Replay instantly instead of pacing the progress")
         .option("--pace <ms>", `Milliseconds each node takes to replay (default ${DEFAULT_TRY_PACE_MS})`)
         .option("--comment-file <path>", "Also write the PR-comment markdown to <path>")
+        .option("--record <file.svg>", "Write the demo as an animated, self-contained SVG terminal recording to <file.svg>")
         .addHelpText("after", `\n${TRY_HELP_NOTE}\n`)
         .action(async (options) => {
+        if (options.record) {
+            try {
+                const { recordTrySvgToFile } = await import("./record.js");
+                const bytes = await recordTrySvgToFile(options.record);
+                process.stdout.write(`  wrote ${options.record} (${bytes} bytes)\n`);
+            }
+            catch (err) {
+                console.error(`\n  could not record the demo: ${err instanceof Error ? err.message : err}\n`);
+                process.exitCode = 1;
+            }
+            return;
+        }
         let paceMs;
         if (options.pace !== undefined) {
             paceMs = Number(options.pace);

package/dist/cli/upgrade.js

@@ -154,7 +154,7 @@ export async function runUpgrade(options, deps) {
         latest = await deps.fetchLatestVersion(tag);
     }
     catch (err) {
-        stderr.write(chalk.red(`  Error: couldn't reach the npm registry — ${err instanceof Error ? err.message : String(err)}`) +
+        stderr.write(chalk.red(`  Error: couldn't reach the npm registry - ${err instanceof Error ? err.message : String(err)}`) +
             "\n");
         stderr.write(chalk.dim("  Check your network connection and try again.") + "\n");
         exit(1);