@sweny-ai/core 0.1.170 → 0.1.172

package/dist/cli/run-output.js

@@ -6,10 +6,11 @@
  * model prose: only counts, durations, token totals, and cost.
  */
 import fs from "node:fs";
-import chalk from "chalk";
 import { consoleLogger } from "../types.js";
 import { summarizeDecisions } from "../decider.js";
 import { toMermaidBlock } from "../mermaid.js";
+import { createPaint } from "./style.js";
+import { colorEnabled, glyphs } from "./terminal.js";
 /** The short key of a `degraded` entry: the text before its first colon. */
 export function degradedKey(entry) {
     const i = entry.indexOf(":");
@@ -90,12 +91,12 @@ function decisionCounts(trace) {
     return { compared: d.compared, agreed: d.agreed, fellThrough: d.fell_through };
 }
 /**
- * `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.
+ * 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 function formatPolicySegment(p) {
+export function policyParts(p) {
     if (!p)
-        return undefined;
+        return [];
     const parts = [];
     if (p.envScope !== undefined)
         parts.push(p.envScope ? "env scoped" : "env unscoped");
@@ -113,6 +114,14 @@ export function formatPolicySegment(p) {
         if (p.outputs.applied > 0)
             parts.push(`${n(p.outputs.applied)} applied`);
     }
+    return parts;
+}
+/**
+ * `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.
+ */
+export function formatPolicySegment(p) {
+    const parts = policyParts(p);
     return parts.length > 0 ? `policy: ${parts.join(", ")}` : undefined;
 }
 export function formatReceiptDuration(ms) {
@@ -137,11 +146,19 @@ export function formatCost(usd) {
         return "<$0.01";
     return `$${usd.toFixed(2)}`;
 }
-/** `budget exceeded: tokens 52k of 50k (run, at node gather)`. */
-export function formatBudgetOverrun(b) {
+/** `tokens 52k of 50k`: the overrun, in the budget's unit. */
+export function formatBudgetAmount(b) {
     const amount = (n) => b.unit === "cost_usd" ? (n < 0.01 ? `$${n.toFixed(4)}` : formatCost(n)) : formatTokenCount(n);
     const unit = b.unit === "cost_usd" ? "cost" : "tokens";
-    return `budget exceeded: ${unit} ${amount(b.spent)} of ${amount(b.limit)} (${b.scope}, at node ${b.node})`;
+    return `${unit} ${amount(b.spent)} of ${amount(b.limit)}`;
+}
+/** `budget exceeded: tokens 52k of 50k (run, at node gather)`. */
+export function formatBudgetOverrun(b) {
+    return `budget exceeded: ${formatBudgetAmount(b)} (${b.scope}, at node ${b.node})`;
+}
+/** `agreed 4/5`, or `fell through 2/2` when no decision passed the gates. */
+export function formatDeciderCounts(d) {
+    return d.compared > 0 ? `agreed ${d.agreed}/${d.compared}` : `fell through ${d.fellThrough}/${d.fellThrough}`;
 }
 /**
  * One plain line: `✓ 3/3 nodes · 41 tool calls · 2m10s · 12k tokens · $0.18`.
@@ -162,28 +179,19 @@ export function formatReceipt(s) {
         ...(s.degraded && s.degraded.length > 0 ? [`degraded: ${s.degraded.join(", ")}`] : []),
         ...(formatPolicySegment(s.policy) ? [formatPolicySegment(s.policy)] : []),
         ...(s.budget ? [formatBudgetOverrun(s.budget)] : []),
-        ...(s.decider
-            ? [
-                s.decider.compared > 0
-                    ? `decider agreed ${s.decider.agreed}/${s.decider.compared}`
-                    : `decider fell through ${s.decider.fellThrough}/${s.decider.fellThrough}`,
-            ]
-            : []),
+        ...(s.decider ? [`decider ${formatDeciderCounts(s.decider)}`] : []),
     ];
     return parts.join(" · ");
 }
-/** 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 function renderReceiptLine(s, color) {
     const line = formatReceipt(s);
     if (!color)
         return line;
-    return s.ok ? chalk.green(line) : chalk.red(line);
+    const paint = createPaint(true);
+    return s.ok ? paint.success(line) : paint.error(line);
 }
 // ── Step summary ────────────────────────────────────────────────
-/** Brand blue (blue-600 / blue-700), not indigo. Applied to successful nodes. */
-export const STEP_SUMMARY_CLASS_DEFS = {
-    success: "fill:#2563eb,stroke:#1d4ed8,color:#fff,stroke-width:2px",
-};
 /** Per-node Mermaid status from run results. */
 export function nodeStates(results) {
     const state = {};
@@ -192,7 +200,7 @@ export function nodeStates(results) {
     }
     return state;
 }
-/** Markdown for `$GITHUB_STEP_SUMMARY`: receipt + status-colored Mermaid DAG. */
+/** Markdown for `$GITHUB_STEP_SUMMARY`: receipt + Mermaid DAG in the brand classDefs. */
 export function formatStepSummary(workflow, results, summary, trace) {
     const state = nodeStates(results);
     return [
@@ -200,7 +208,7 @@ export function formatStepSummary(workflow, results, summary, trace) {
         "",
         `\`${formatReceipt(summary)}\``,
         "",
-        toMermaidBlock(workflow, { state, trace, classDefs: STEP_SUMMARY_CLASS_DEFS }),
+        toMermaidBlock(workflow, { state, trace }),
         "",
         "",
     ].join("\n");
@@ -219,7 +227,7 @@ export function writeStepSummary(workflow, results, summary, trace, env = proces
         return true;
     }
     catch (err) {
-        process.stderr.write(`  ⚠ could not write GITHUB_STEP_SUMMARY: ${err instanceof Error ? err.message : err}\n`);
+        process.stderr.write(`  ${glyphs().warning} could not write GITHUB_STEP_SUMMARY: ${err instanceof Error ? err.message : err}\n`);
         return false;
     }
 }
@@ -234,6 +242,8 @@ export function createRunLogger(opts) {
     const write = opts.write ?? ((s) => void process.stderr.write(s));
     if (opts.verbose)
         return { ...consoleLogger, flush() { } };
+    const paint = createPaint(opts.color ?? (opts.tty && colorEnabled(process.stderr)));
+    const g = glyphs();
     const held = [];
     const emit = (line) => {
         if (opts.tty)
@@ -245,8 +255,8 @@ export function createRunLogger(opts) {
     return {
         info: noop,
         debug: noop,
-        warn: (msg) => emit(`  ${chalk.yellow("⚠")} ${msg.trim()}\n`),
-        error: (msg) => emit(`  ${chalk.red("✗")} ${msg.trim()}\n`),
+        warn: (msg) => emit(`  ${paint.warning(g.warning)} ${msg.trim()}\n`),
+        error: (msg) => emit(`  ${paint.error(g.failure)} ${msg.trim()}\n`),
         flush() {
             while (held.length)
                 write(held.shift());

package/dist/cli/runs.js

@@ -2,9 +2,11 @@
  * `sweny runs` and `sweny runs diff`: read-only views over `.sweny/runs/`.
  * Metadata only. Color only when `color` is true (TTY).
  */
-import chalk from "chalk";
 import { findRun, listRuns } from "./run-history.js";
 import { formatCost, formatReceiptDuration, formatTokenCount } from "./run-output.js";
+import { createPaint } from "./style.js";
+import { colorEnabled } from "./terminal.js";
+import { GLYPHS } from "../theme.js";
 // ── Small formatters ────────────────────────────────────────────
 export function formatAge(startedAt, nowMs = Date.now()) {
     const s = Math.max(0, Math.round((nowMs - Date.parse(startedAt)) / 1000));
@@ -18,15 +20,18 @@ export function formatAge(startedAt, nowMs = Date.now()) {
         return `${h}h ago`;
     return `${Math.floor(h / 24)}d ago`;
 }
-const ICON = { success: "✓", failed: "✗", crashed: "✗", skipped: "−" };
+const G = GLYPHS.unicode;
+const ICON = { success: G.success, failed: G.failure, crashed: G.failure, skipped: G.skipped };
+/** Status text in its role color: success, error, or muted for skipped. */
 function paint(text, status, color) {
     if (!color)
         return text;
+    const p = createPaint(true);
     if (status === "success")
-        return chalk.green(text);
+        return p.success(text);
     if (status === "skipped")
-        return chalk.dim(text);
-    return chalk.red(text);
+        return p.muted(text);
+    return p.error(text);
 }
 const tokensText = (n) => (n === null ? "-" : formatTokenCount(n));
 const costText = (n) => (n === null ? "-" : formatCost(n));
@@ -63,7 +68,8 @@ export function formatRunsTable(runs, color, nowMs = Date.now()) {
             .join("  ")
             .trimEnd();
     const headLine = line(head);
-    return [color ? chalk.dim(headLine) : headLine, ...rows.map((r) => line(r.cells, r.status))].join("\n") + "\n";
+    return ([color ? createPaint(true).muted(headLine) : headLine, ...rows.map((r) => line(r.cells, r.status))].join("\n") +
+        "\n");
 }
 // ── sweny runs diff ─────────────────────────────────────────────
 const sign = (n) => (n > 0 ? "+" : n < 0 ? "-" : "");
@@ -94,7 +100,7 @@ function nodeChanges(a, b) {
 }
 const routeKey = (r) => `${r.from} → ${r.to}`;
 export function formatRunDiff(a, b, color) {
-    const dim = (s) => (color ? chalk.dim(s) : s);
+    const dim = createPaint(color).muted;
     const out = [];
     const hdr = (tag, r) => `  ${tag}  ${r.run_id}  ${r.workflow_id}  ${paint(`${ICON[r.status] ?? "?"} ${r.status}`, r.status, color)}  ${formatReceiptDuration(r.duration_ms)}`;
     out.push(hdr("a", a), hdr("b", b), "");
@@ -183,7 +189,7 @@ export function registerRunsCommand(program) {
         .action((opts) => {
         const limit = Number(opts.limit ?? "20");
         if (!Number.isInteger(limit) || limit < 1) {
-            console.error(chalk.red("  --limit must be a positive integer"));
+            console.error(createPaint(colorEnabled(process.stderr)).error("  --limit must be a positive integer"));
             process.exitCode = 1;
             return;
         }
@@ -195,7 +201,7 @@ export function registerRunsCommand(program) {
             process.stdout.write(JSON.stringify(runs, null, 2) + "\n");
             return;
         }
-        process.stdout.write("\n" + formatRunsTable(runs, process.stdout.isTTY ?? false) + "\n");
+        process.stdout.write("\n" + formatRunsTable(runs, colorEnabled(process.stdout)) + "\n");
     });
     runsCmd
         .command("diff [a] [b]")
@@ -206,11 +212,11 @@ export function registerRunsCommand(program) {
         const runs = listRuns();
         const picked = pickRunsForDiff(runs, refs, opts.workflow);
         if ("error" in picked) {
-            console.error(chalk.red(`  ${picked.error}`));
+            console.error(createPaint(colorEnabled(process.stderr)).error(`  ${picked.error}`));
             process.exitCode = 1;
             return;
         }
-        process.stdout.write("\n" + formatRunDiff(picked.a, picked.b, process.stdout.isTTY ?? false) + "\n");
+        process.stdout.write("\n" + formatRunDiff(picked.a, picked.b, colorEnabled(process.stdout)) + "\n");
     });
     return runsCmd;
 }

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/style.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Terminal painters built from the theme tokens. The only place the CLI
+ * turns a color role into ANSI.
+ *
+ * `createPaint(false)` returns identity painters, so a formatter takes one
+ * `Paint` and renders the same text with or without color.
+ */
+export type Painter = (text: string) => string;
+export interface Paint {
+    brand: Painter;
+    success: Painter;
+    warning: Painter;
+    error: Painter;
+    info: Painter;
+    muted: Painter;
+    /** Emphasis without a color: bold. */
+    strong: Painter;
+    link: Painter;
+}
+/** Painters for one output. `enabled: false` paints nothing. */
+export declare function createPaint(enabled: boolean): Paint;
+/**
+ * Honor `NO_COLOR` for every chalk call in the process, including the ones
+ * that do not go through `createPaint`. Call once at CLI startup.
+ */
+export declare function applyNoColor(env?: Record<string, string | undefined>): void;

package/dist/cli/style.js

@@ -0,0 +1,48 @@
+/**
+ * Terminal painters built from the theme tokens. The only place the CLI
+ * turns a color role into ANSI.
+ *
+ * `createPaint(false)` returns identity painters, so a formatter takes one
+ * `Paint` and renders the same text with or without color.
+ */
+import chalk, { Chalk, chalkStderr } from "chalk";
+import { ROLE_COLORS } from "../theme.js";
+const identity = (s) => s;
+/** Painters for one output. `enabled: false` paints nothing. */
+export function createPaint(enabled) {
+    if (!enabled) {
+        return {
+            brand: identity,
+            success: identity,
+            warning: identity,
+            error: identity,
+            info: identity,
+            muted: identity,
+            strong: identity,
+            link: identity,
+        };
+    }
+    // Force a level so a caller that decided "color on" gets color even when
+    // chalk's own detection looked at a different stream.
+    const k = new Chalk({ level: Math.max(chalk.level, chalkStderr.level, 1) });
+    return {
+        brand: (s) => k.hex(ROLE_COLORS.brand)(s),
+        success: (s) => k.hex(ROLE_COLORS.success)(s),
+        warning: (s) => k.hex(ROLE_COLORS.warning)(s),
+        error: (s) => k.hex(ROLE_COLORS.error)(s),
+        info: (s) => k.hex(ROLE_COLORS.info)(s),
+        muted: (s) => k.hex(ROLE_COLORS.muted)(s),
+        strong: (s) => k.bold(s),
+        link: (s) => k.hex(ROLE_COLORS.info).underline(s),
+    };
+}
+/**
+ * Honor `NO_COLOR` for every chalk call in the process, including the ones
+ * that do not go through `createPaint`. Call once at CLI startup.
+ */
+export function applyNoColor(env = process.env) {
+    if (env.NO_COLOR) {
+        chalk.level = 0;
+        chalkStderr.level = 0;
+    }
+}

package/dist/cli/terminal.d.ts

@@ -0,0 +1,47 @@
+/**
+ * What the terminal can show: color, Unicode, width, live redraws.
+ *
+ * Every check reads the env and stream passed in, so specs can pin each
+ * case. Defaults read the real process.
+ */
+import { type GlyphSet, type TicketBox } from "../theme.js";
+type Env = Record<string, string | undefined>;
+/** The narrowest layout SWEny designs for. Narrower terminals still work, they just wrap. */
+export declare const MIN_COLUMNS = 40;
+/**
+ * True when the terminal can draw box-drawing characters and the glyph set.
+ *
+ * `SWENY_ASCII=1` forces ASCII; `SWENY_UNICODE=1` forces Unicode. Otherwise a
+ * locale that names a charset decides (`LC_ALL`, then `LC_CTYPE`, then
+ * `LANG`): UTF-8 is Unicode, `C`/`POSIX`/anything else is ASCII. The Linux
+ * console (`TERM=linux`) is ASCII. With no locale set, POSIX terminals are
+ * assumed Unicode; Windows is Unicode only in terminals known to support it.
+ */
+export declare function supportsUnicode(env?: Env, platform?: string): boolean;
+/**
+ * True when output to `stream` should carry ANSI color. `NO_COLOR` (any
+ * non-empty value) always wins; then `FORCE_COLOR` (anything but `0`); then a
+ * TTY that is not `TERM=dumb`.
+ */
+export declare function colorEnabled(stream: {
+    isTTY?: boolean;
+} | undefined, env?: Env): boolean;
+/**
+ * True when `stream` gets the rich view (the ticket, redraws, a spinner):
+ * a TTY, not CI, not dumb. Everything else gets plain lines.
+ */
+export declare function richOutput(stream: {
+    isTTY?: boolean;
+} | undefined, env?: Env): boolean;
+/** Usable width of `stream`: its column count, else `COLUMNS`, else 80. */
+export declare function terminalColumns(stream: {
+    columns?: number;
+} | undefined, env?: Env): number;
+export declare function glyphsFor(unicode: boolean): GlyphSet;
+export declare function ticketBoxFor(unicode: boolean): TicketBox;
+export declare function spinnerFramesFor(unicode: boolean): readonly string[];
+/** The glyphs for the current process. */
+export declare function glyphs(env?: Env): GlyphSet;
+/** Replace single-column Unicode drawing characters with their ASCII stand-ins. */
+export declare function toAsciiDrawing(text: string): string;
+export {};

package/dist/cli/terminal.js

@@ -0,0 +1,123 @@
+/**
+ * What the terminal can show: color, Unicode, width, live redraws.
+ *
+ * Every check reads the env and stream passed in, so specs can pin each
+ * case. Defaults read the real process.
+ */
+import { GLYPHS, SPINNER_FRAMES, TICKET_BOX } from "../theme.js";
+/** The narrowest layout SWEny designs for. Narrower terminals still work, they just wrap. */
+export const MIN_COLUMNS = 40;
+/**
+ * True when the terminal can draw box-drawing characters and the glyph set.
+ *
+ * `SWENY_ASCII=1` forces ASCII; `SWENY_UNICODE=1` forces Unicode. Otherwise a
+ * locale that names a charset decides (`LC_ALL`, then `LC_CTYPE`, then
+ * `LANG`): UTF-8 is Unicode, `C`/`POSIX`/anything else is ASCII. The Linux
+ * console (`TERM=linux`) is ASCII. With no locale set, POSIX terminals are
+ * assumed Unicode; Windows is Unicode only in terminals known to support it.
+ */
+export function supportsUnicode(env = process.env, platform = process.platform) {
+    if (truthy(env.SWENY_ASCII))
+        return false;
+    if (truthy(env.SWENY_UNICODE))
+        return true;
+    if (env.TERM === "linux")
+        return false;
+    const locale = env.LC_ALL || env.LC_CTYPE || env.LANG;
+    if (locale)
+        return /utf-?8/i.test(locale);
+    if (platform !== "win32")
+        return true;
+    return Boolean(env.WT_SESSION ||
+        env.TERMINUS_SUBLIME ||
+        env.ConEmuTask === "{cmd::Cmder}" ||
+        env.TERM_PROGRAM === "vscode" ||
+        env.TERM === "xterm-256color" ||
+        env.TERM === "alacritty" ||
+        env.TERMINAL_EMULATOR === "JetBrains-JediTerm");
+}
+/**
+ * True when output to `stream` should carry ANSI color. `NO_COLOR` (any
+ * non-empty value) always wins; then `FORCE_COLOR` (anything but `0`); then a
+ * TTY that is not `TERM=dumb`.
+ */
+export function colorEnabled(stream, env = process.env) {
+    if (env.NO_COLOR)
+        return false;
+    if (env.FORCE_COLOR !== undefined && env.FORCE_COLOR !== "")
+        return env.FORCE_COLOR !== "0";
+    if (env.TERM === "dumb")
+        return false;
+    return Boolean(stream?.isTTY);
+}
+/**
+ * True when `stream` gets the rich view (the ticket, redraws, a spinner):
+ * a TTY, not CI, not dumb. Everything else gets plain lines.
+ */
+export function richOutput(stream, env = process.env) {
+    return Boolean(stream?.isTTY) && !truthy(env.CI) && env.TERM !== "dumb";
+}
+/** Usable width of `stream`: its column count, else `COLUMNS`, else 80. */
+export function terminalColumns(stream, env = process.env) {
+    const fromStream = stream?.columns;
+    if (typeof fromStream === "number" && fromStream > 0)
+        return fromStream;
+    const fromEnv = Number(env.COLUMNS);
+    if (Number.isInteger(fromEnv) && fromEnv > 0)
+        return fromEnv;
+    return 80;
+}
+export function glyphsFor(unicode) {
+    return unicode ? GLYPHS.unicode : GLYPHS.ascii;
+}
+export function ticketBoxFor(unicode) {
+    return unicode ? TICKET_BOX.unicode : TICKET_BOX.ascii;
+}
+export function spinnerFramesFor(unicode) {
+    return unicode ? SPINNER_FRAMES.unicode : SPINNER_FRAMES.ascii;
+}
+/** The glyphs for the current process. */
+export function glyphs(env = process.env) {
+    return glyphsFor(supportsUnicode(env));
+}
+function truthy(v) {
+    return v !== undefined && v !== "" && v !== "0" && v.toLowerCase() !== "false";
+}
+/**
+ * Box-drawing and glyph fallbacks for text drawn with Unicode (the DAG
+ * renderer). Each maps to a single ASCII column so alignment holds.
+ */
+const ASCII_FALLBACK = {
+    "┌": "+",
+    "┐": "+",
+    "└": "+",
+    "┘": "+",
+    "├": "+",
+    "┤": "+",
+    "┬": "+",
+    "┴": "+",
+    "┼": "+",
+    "╭": "+",
+    "╮": "+",
+    "╰": "+",
+    "╯": "+",
+    "─": "-",
+    "┄": "-",
+    "╌": "-",
+    "│": "|",
+    "┆": ":",
+    "▼": "v",
+    "▶": ">",
+    [GLYPHS.unicode.success]: GLYPHS.ascii.success,
+    [GLYPHS.unicode.failure]: GLYPHS.ascii.failure,
+    [GLYPHS.unicode.skipped]: GLYPHS.ascii.skipped,
+    [GLYPHS.unicode.pending]: GLYPHS.ascii.pending,
+    [GLYPHS.unicode.running]: GLYPHS.ascii.running,
+    [GLYPHS.unicode.brand]: GLYPHS.ascii.brand,
+    [GLYPHS.unicode.sep]: GLYPHS.ascii.sep,
+};
+const ASCII_FALLBACK_RE = new RegExp(`[${Object.keys(ASCII_FALLBACK).join("")}]`, "g");
+/** Replace single-column Unicode drawing characters with their ASCII stand-ins. */
+export function toAsciiDrawing(text) {
+    return text.replace(ASCII_FALLBACK_RE, (ch) => ASCII_FALLBACK[ch] ?? ch);
+}

package/dist/cli/ticket.d.ts

@@ -0,0 +1,89 @@
+/**
+ * The receipt ticket: the run receipt as a small perforated card with a tear
+ * line and a policy stamp. Shown at the end of a run on a TTY, and at the top
+ * of the PR comment. CI logs, pipes and `--json` keep the plain receipt line.
+ *
+ * METADATA ONLY, like the receipt line: counts, durations, tokens, cost,
+ * policy facts. Never prompts, node outputs, tool inputs, or model prose.
+ */
+import type { RunSummary } from "./run-output.js";
+import { type Paint } from "./style.js";
+/** Widest ticket, in columns, frame included. */
+export declare const TICKET_MAX_WIDTH = 48;
+/** Narrowest ticket. Below this the fields stop being readable. */
+export declare const TICKET_MIN_WIDTH = 32;
+/** Left indent the CLI prints the ticket at. */
+export declare const TICKET_INDENT = 2;
+/** How long the stub sits empty before the stamp lands (the one animation frame). */
+export declare const STAMP_DELAY_MS = 140;
+export interface TicketData {
+    summary: RunSummary;
+    /** Workflow id, shown under the status. */
+    workflow: string;
+    /** Full run id; the ticket shows its short hash. */
+    runId?: string;
+    /** The run crashed before finishing (not a node failure). */
+    crashed?: boolean;
+}
+export interface TicketRenderOptions {
+    /** Columns available, indent included. Default 80. The ticket fits in `columns - 2`. */
+    columns?: number;
+    /** Box drawing and glyphs in Unicode (default) or ASCII. */
+    unicode?: boolean;
+    /** Painters. Default: no color. */
+    paint?: Paint;
+    /** Draw the policy stamp. False leaves the stub empty: the frame before the stamp lands. Default true. */
+    stamp?: boolean;
+}
+export interface RenderedTicket {
+    /** The ticket, one string per row, no indent. */
+    lines: string[];
+    /** Index of the stamp row in `lines`, or -1 when the run reported no policy facts. */
+    stampRow: number;
+}
+/** `20260930-110000-3f9a2c` shows as `3f9a2c`; any other id as its first 8 characters. */
+export declare function shortRunId(runId: string): string;
+/** The ticket's status word. */
+export declare function ticketStatus(data: TicketData): "passed" | "failed" | "budget stop" | "crashed";
+/**
+ * The policy stamp words, from what the run reported: `ENV SCOPED`,
+ * `SANDBOXED`. Empty when no node reported env scope or sandbox facts.
+ * `strong` is false when any fact is weaker than the default (an unscoped
+ * env, no sandbox), which the stamp shows in the warning color.
+ */
+export declare function stampWords(summary: RunSummary): {
+    words: string[];
+    strong: boolean;
+};
+/** Ticket width for a terminal of `columns`: fits beside the indent, within the min and max. */
+export declare function ticketWidth(columns: number): number;
+/**
+ * Render the ticket. Pure: same input, same rows. Every row is exactly the
+ * ticket width in visible columns.
+ */
+export declare function renderTicket(data: TicketData, opts?: TicketRenderOptions): RenderedTicket;
+/** The ticket as plain text (no color, Unicode): what the PR comment carries. */
+export declare function formatTicketText(data: TicketData, columns?: number): string;
+export interface ReceiptStream {
+    write(s: string): unknown;
+    isTTY?: boolean;
+    columns?: number;
+}
+export interface WriteReceiptOptions extends Omit<TicketData, "summary"> {
+    stream: ReceiptStream;
+    env?: Record<string, string | undefined>;
+    /** Land the stamp one frame after the ticket. Default true on a rich stream. */
+    animate?: boolean;
+    /** Override the rich (ticket) or plain (one line) choice. Default: `richOutput(stream, env)`. */
+    rich?: boolean;
+    /** Override color. Default: `colorEnabled(stream, env)`. */
+    color?: boolean;
+    /** Override Unicode. Default: `supportsUnicode(env)`. */
+    unicode?: boolean;
+}
+/**
+ * Print the receipt. A TTY (not CI) gets the ticket, its stamp landing one
+ * frame after the card; anything else gets the plain line. Both end with a
+ * blank line.
+ */
+export declare function writeReceipt(summary: RunSummary, opts: WriteReceiptOptions): Promise<void>;