@sweny-ai/core 0.1.170 → 0.1.172

package/dist/harness/sandbox-wrapper.js

@@ -19,7 +19,8 @@
  *   host network except through that proxy.
  * - filesystem: the workspace (cwd) and a scratch HOME are writable; the rest
  *   of the filesystem is read-only; the operator's credential files are
- *   unreadable. Sibling homes under the same configured scratch root are
+ *   unreadable, and so is a git credential the checkout persisted when the
+ *   node is read-only or staged (#473, `denyRead`). Sibling homes under the same configured scratch root are
  *   hidden; only this run's HOME is exposed. Dry runs (`readOnly`) leave the
  *   workspace read-only too. All concurrent credential-bearing adapters must
  *   use the same scratch root; different roots are not mutually isolated.
@@ -126,10 +127,14 @@ export function buildSrtSettings(req, opts) {
     // must stay hidden too. srt allowRead carves out only our own HOME.
     if (opts.isolationRoot)
         denyRead.push(opts.isolationRoot);
+    // #473: persisted git credentials. Also unwritable, so a writable workspace
+    // cannot rename one out from under its read deny.
+    const masked = [...new Set((req.denyRead ?? []).map(real))].filter((p) => exists(p));
+    denyRead.push(...masked.filter((p) => !denyRead.includes(p)));
     const allowWrite = req.readOnly ? [opts.home] : [real(req.cwd), opts.home];
     return {
         network: { allowedDomains, deniedDomains: [], strictAllowlist: true, allowLocalBinding: false },
-        filesystem: { denyRead, allowRead: opts.isolationRoot ? [opts.home] : [], allowWrite, denyWrite: [] },
+        filesystem: { denyRead, allowRead: opts.isolationRoot ? [opts.home] : [], allowWrite, denyWrite: masked },
     };
 }
 /** Env for the wrapped process: the adapter's env with HOME, XDG and temp dirs moved into the scratch HOME. */
@@ -149,7 +154,7 @@ export function scratchEnv(env, home) {
 export class SrtSandboxWrapper {
     opts;
     backend = "srt";
-    provides = { sandbox: true, egress: true, readOnlyMount: true };
+    provides = { sandbox: true, egress: true, readOnlyMount: true, readDeny: true };
     constructor(opts) {
         this.opts = opts;
     }
@@ -335,7 +340,12 @@ export async function prepareAgentSpawn(opts) {
         ...parseList(env.SWENY_SANDBOX_ALLOWED_DOMAINS),
         ...(opts.harnessEgress ?? []),
     ];
-    const wrapped = await wrapper.wrap({ ...opts.spawn, egress, readOnly: policy.readOnly });
+    const wrapped = await wrapper.wrap({
+        ...opts.spawn,
+        egress,
+        readOnly: policy.readOnly,
+        ...(policy.gitCredentials && policy.gitCredentials.length > 0 ? { denyRead: policy.gitCredentials } : {}),
+    });
     const { home, cleanup, ...spawn } = wrapped;
     return { degraded: gate.degraded, spawn, wrappedBy: wrapper.backend, home, cleanup };
 }

package/dist/harness/types.d.ts

@@ -97,6 +97,14 @@ export interface NodePolicy {
      * adapters, which know whether the run is sandboxed.
      */
     stagedWrite?: boolean;
+    /**
+     * Files holding a persisted git credential (#473: the token
+     * `actions/checkout` writes by default) that this node's agent must not
+     * read. Set by adapters for a read-only node or a staged write node when
+     * the checkout has one (see git-credentials.ts). The process wrapper denies
+     * reads of them; without it, reported, and refused under `strict`.
+     */
+    gitCredentials?: string[];
 }
 /** Process-level wrappers the host provides (OS sandbox, egress proxy, read-only mount). */
 export interface PolicyWrappers {
@@ -104,6 +112,8 @@ export interface PolicyWrappers {
     sandbox?: boolean;
     egress?: boolean;
     readOnlyMount?: boolean;
+    /** The wrapper can make named files unreadable to the agent (srt `denyRead`). */
+    readDeny?: boolean;
 }
 export interface PolicyGateResult {
     /** Every opinion this run could not honor natively. Empty for Claude Code. */

package/dist/index.d.ts

@@ -61,5 +61,7 @@ export { resolveTemplates, loadAdditionalContext, loadTemplate } from "./templat
 export type { Templates } from "./templates.js";
 export { toMermaid, toMermaidBlock } from "./mermaid.js";
 export type { MermaidOptions, NodeStatus } from "./mermaid.js";
+export { SWENY_TAGLINE, PALETTE, ROLE_COLORS, SURFACE_COLORS, GLYPHS, SPINNER_FRAMES, SPINNER_INTERVAL_MS, TICKET_BOX, MERMAID_CLASS_DEFS, MERMAID_EDGE_STYLES, } from "./theme.js";
+export type { ColorRole, GlyphKey, GlyphSet, TicketBox, DiagramNodeStatus } from "./theme.js";
 export { loadConfigFile } from "./cli/config-file.js";
 export type { FileConfig } from "./cli/config-file.js";

package/dist/index.js

@@ -62,5 +62,7 @@ export { buildWorkflow, refineWorkflow } from "./workflow-builder.js";
 export { resolveTemplates, loadAdditionalContext, loadTemplate } from "./templates.js";
 // Mermaid export
 export { toMermaid, toMermaidBlock } from "./mermaid.js";
+// Visual tokens (#479): palette, color roles, glyphs, diagram classDefs. Browser-safe.
+export { SWENY_TAGLINE, PALETTE, ROLE_COLORS, SURFACE_COLORS, GLYPHS, SPINNER_FRAMES, SPINNER_INTERVAL_MS, TICKET_BOX, MERMAID_CLASS_DEFS, MERMAID_EDGE_STYLES, } from "./theme.js";
 // Config file
 export { loadConfigFile } from "./cli/config-file.js";

package/dist/mermaid.d.ts

@@ -10,11 +10,16 @@
  * to highlight which edges were taken and show loop iterations.
  */
 import type { Workflow, ExecutionTrace } from "./types.js";
-export type NodeStatus = "current" | "success" | "failed" | "skipped";
+import { type DiagramNodeStatus } from "./theme.js";
+/**
+ * A node's state in a diagram. `pending` is applied automatically to every
+ * node missing from a non-empty `state` map (the run never reached it).
+ */
+export type NodeStatus = DiagramNodeStatus;
 export interface MermaidOptions {
-    /** Execution state — nodes not in this map render as default (pending) */
+    /** Execution state. With a non-empty map, nodes missing from it render as `pending`. */
     state?: Record<string, NodeStatus>;
-    /** Execution trace — highlights taken/not-taken edges and loop counts */
+    /** Execution trace: highlights taken and not-taken edges and loop counts */
     trace?: ExecutionTrace;
     /** Graph direction: TB (top-bottom) or LR (left-right). Default: TB */
     direction?: "TB" | "LR";
@@ -22,8 +27,8 @@ export interface MermaidOptions {
     title?: string;
     /**
      * Override the `classDef` style body (the part after the class name) for
-     * specific statuses, e.g. `{ success: "fill:#2563eb,stroke:#1d4ed8,color:#fff" }`.
-     * Unset statuses keep the defaults.
+     * specific statuses. Unset statuses keep the brand defaults
+     * (`MERMAID_CLASS_DEFS` in theme.ts). SWEny's own surfaces pass none.
      */
     classDefs?: Partial<Record<NodeStatus, string>>;
 }

package/dist/mermaid.js

@@ -10,6 +10,7 @@
  * to highlight which edges were taken and show loop iterations.
  */
 import { whenLabel } from "./when.js";
+import { MERMAID_CLASS_DEFS, MERMAID_EDGE_STYLES } from "./theme.js";
 /**
  * Convert a Workflow to a Mermaid flowchart diagram string.
  *
@@ -91,7 +92,7 @@ export function toMermaid(workflow, options = {}) {
             edgeTakenCounts.set(key, (edgeTakenCounts.get(key) ?? 0) + 1);
         }
     }
-    // Edges — track index for linkStyle directives
+    // Edges: track index for linkStyle directives
     const takenIndices = [];
     const notTakenIndices = [];
     let edgeIndex = 0;
@@ -129,32 +130,29 @@ export function toMermaid(workflow, options = {}) {
         }
         edgeIndex++;
     }
-    // Node status styling
+    // Node status styling (brand classDefs from theme.ts)
     const statusNodes = groupByStatus(state);
     if (statusNodes.size > 0) {
+        const unreached = Object.keys(workflow.nodes).filter((id) => !(id in state));
+        if (unreached.length > 0)
+            statusNodes.set("pending", [...(statusNodes.get("pending") ?? []), ...unreached]);
         lines.push("");
-        const defaults = {
-            current: "fill:#3b82f6,stroke:#2563eb,color:#fff,stroke-width:2px",
-            success: "fill:#22c55e,stroke:#16a34a,color:#fff,stroke-width:2px",
-            failed: "fill:#ef4444,stroke:#dc2626,color:#fff,stroke-width:2px",
-            skipped: "fill:#6b7280,stroke:#4b5563,color:#fff,stroke-dasharray:5 5",
-        };
-        for (const status of ["current", "success", "failed", "skipped"]) {
-            lines.push(`    classDef ${status} ${classDefs[status] ?? defaults[status]}`);
+        for (const status of ["current", "success", "failed", "skipped", "pending"]) {
+            lines.push(`    classDef ${status} ${classDefs[status] ?? MERMAID_CLASS_DEFS[status]}`);
         }
         for (const [status, ids] of statusNodes) {
             const sanitized = ids.map(aliasFor).join(",");
             lines.push(`    class ${sanitized} ${status}`);
         }
     }
-    // Edge styling — taken edges bold green, not-taken edges dashed gray
+    // Edge styling: taken edges bold brand blue, not-taken edges dashed slate
     if (trace) {
         lines.push("");
         if (takenIndices.length > 0) {
-            lines.push(`    linkStyle ${takenIndices.join(",")} stroke:#22c55e,stroke-width:3px`);
+            lines.push(`    linkStyle ${takenIndices.join(",")} ${MERMAID_EDGE_STYLES.taken}`);
         }
         if (notTakenIndices.length > 0) {
-            lines.push(`    linkStyle ${notTakenIndices.join(",")} stroke:#6b7280,stroke-width:1px,stroke-dasharray:5 5`);
+            lines.push(`    linkStyle ${notTakenIndices.join(",")} ${MERMAID_EDGE_STYLES.notTaken}`);
         }
     }
     return lines.join("\n");

package/dist/safe-outputs.js

@@ -428,6 +428,11 @@ export async function applySafeOutputs(o) {
                 refuse("close needs a pinned issue", at);
                 continue;
             }
+            // ...and the repository (or Linear team) must come from the declaration or the run, never from the agent's intent.
+            if (asked === "close" && !pinned) {
+                refuse("close needs a pinned repository", at);
+                continue;
+            }
             state = asked;
         }
         if (via === "github" && issueRef !== undefined && !/^[1-9][0-9]*$/.test(issueRef)) {

package/dist/skills/git-push.d.ts

@@ -0,0 +1,62 @@
+/**
+ * sweny-side branch push for `github_create_pr` (#473).
+ *
+ * With `actions/checkout`'s recommended `persist-credentials: false` the
+ * checkout holds no token, so the agent's own `git push` in the create_pr node
+ * has nothing to push with. sweny pushes the PR's head branch itself, from
+ * the sweny process, with the github skill's token (`GITHUB_TOKEN`), right
+ * before it opens the PR. The agent never holds the token.
+ *
+ * Guard rails: only a local branch that exists, only to `origin` when it is
+ * the PR's own repo, never force, never the base branch or the remote's
+ * default branch. The token goes to git through command-scope config in the
+ * child env (`GIT_CONFIG_*`), never argv, as an `http.<server>/.extraheader`
+ * that first resets any persisted one (so the job token is never sent twice).
+ * A push that fails is logged and the PR is still requested: the agent may
+ * already have pushed (persisted credentials, an `agent_env` grant).
+ */
+export interface GitRunResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+export type GitRunner = (args: string[], opts: {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+}) => Promise<GitRunResult>;
+export interface PushHeadOptions {
+    /** `owner/repo` the PR is for. */
+    repo: string;
+    /** The PR's head branch. */
+    head: string;
+    /** The PR's base branch. */
+    base: string;
+    /** The github skill's token. Without it, git uses whatever credential the checkout has. */
+    token?: string;
+    /** The checkout. Default: `process.cwd()`. */
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    /** Test seam. */
+    git?: GitRunner;
+}
+export interface PushHeadResult {
+    pushed: boolean;
+    /** A push ran (and `pushed` says whether it worked); false when a guard skipped it. */
+    attempted: boolean;
+    /** Why nothing was pushed, or why the push failed. Never carries the token. */
+    reason?: string;
+}
+/** `owner/repo` from a GitHub remote URL (https, ssh or scp form), lowercased, or undefined. */
+export declare function repoFromRemote(url: string): {
+    host: string;
+    repo: string;
+    https: boolean;
+} | undefined;
+/** A branch name sweny will pass to git: plain ref characters, no option or traversal forms. */
+export declare function isSafeBranch(name: string): boolean;
+/** The command-scope git config that authenticates one push to `server` with `token`. */
+export declare function pushAuthConfig(server: string, token: string, env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+/**
+ * Push the PR's head branch to `origin` from the sweny process. Never throws.
+ */
+export declare function pushHeadBranch(opts: PushHeadOptions): Promise<PushHeadResult>;

package/dist/skills/git-push.js

@@ -0,0 +1,132 @@
+/**
+ * sweny-side branch push for `github_create_pr` (#473).
+ *
+ * With `actions/checkout`'s recommended `persist-credentials: false` the
+ * checkout holds no token, so the agent's own `git push` in the create_pr node
+ * has nothing to push with. sweny pushes the PR's head branch itself, from
+ * the sweny process, with the github skill's token (`GITHUB_TOKEN`), right
+ * before it opens the PR. The agent never holds the token.
+ *
+ * Guard rails: only a local branch that exists, only to `origin` when it is
+ * the PR's own repo, never force, never the base branch or the remote's
+ * default branch. The token goes to git through command-scope config in the
+ * child env (`GIT_CONFIG_*`), never argv, as an `http.<server>/.extraheader`
+ * that first resets any persisted one (so the job token is never sent twice).
+ * A push that fails is logged and the PR is still requested: the agent may
+ * already have pushed (persisted credentials, an `agent_env` grant).
+ */
+import { execFile } from "node:child_process";
+import { setBranchPusher } from "./github.js";
+const defaultGit = (args, opts) => new Promise((resolve) => {
+    execFile("git", args, { cwd: opts.cwd, env: opts.env, timeout: 120_000 }, (err, stdout, stderr) => {
+        const code = err
+            ? typeof err.code === "number"
+                ? err.code
+                : 1
+            : 0;
+        resolve({ code, stdout: String(stdout ?? ""), stderr: String(stderr ?? "") });
+    });
+});
+/** `owner/repo` from a GitHub remote URL (https, ssh or scp form), lowercased, or undefined. */
+export function repoFromRemote(url) {
+    const u = url.trim();
+    const https = /^https?:\/\/(?:[^@/]*@)?([^/:]+)(?::\d+)?\/(.+?)(?:\.git)?\/?$/i.exec(u);
+    if (https)
+        return { host: https[1].toLowerCase(), repo: https[2].toLowerCase(), https: true };
+    const ssh = /^ssh:\/\/(?:[^@/]*@)?([^/:]+)(?::\d+)?\/(.+?)(?:\.git)?\/?$/i.exec(u);
+    if (ssh)
+        return { host: ssh[1].toLowerCase(), repo: ssh[2].toLowerCase(), https: false };
+    const scp = /^(?:[^@/]+@)?([^/:]+):(.+?)(?:\.git)?\/?$/.exec(u);
+    if (scp)
+        return { host: scp[1].toLowerCase(), repo: scp[2].toLowerCase(), https: false };
+    return undefined;
+}
+/** A branch name sweny will pass to git: plain ref characters, no option or traversal forms. */
+export function isSafeBranch(name) {
+    return (/^[A-Za-z0-9._/-]+$/.test(name) &&
+        !name.startsWith("-") &&
+        !name.startsWith("/") &&
+        !name.endsWith("/") &&
+        !name.endsWith(".lock") &&
+        !name.includes("..") &&
+        !name.includes("//"));
+}
+/** The command-scope git config that authenticates one push to `server` with `token`. */
+export function pushAuthConfig(server, token, env) {
+    const out = { ...env };
+    const base = Number.parseInt(out.GIT_CONFIG_COUNT ?? "0", 10);
+    let n = Number.isFinite(base) && base > 0 ? base : 0;
+    const key = `http.${server.replace(/\/+$/, "")}/.extraheader`;
+    const basic = Buffer.from(`x-access-token:${token}`).toString("base64");
+    // An empty value resets the list, so a header the checkout persisted is not sent too.
+    for (const value of ["", `AUTHORIZATION: basic ${basic}`]) {
+        out[`GIT_CONFIG_KEY_${n}`] = key;
+        out[`GIT_CONFIG_VALUE_${n}`] = value;
+        n++;
+    }
+    out.GIT_CONFIG_COUNT = String(n);
+    return out;
+}
+/**
+ * Push the PR's head branch to `origin` from the sweny process. Never throws.
+ */
+export async function pushHeadBranch(opts) {
+    const git = opts.git ?? defaultGit;
+    const cwd = opts.cwd ?? process.cwd();
+    const env = { ...(opts.env ?? process.env), GIT_TERMINAL_PROMPT: "0" };
+    const { head, base } = opts;
+    if (!isSafeBranch(head))
+        return { pushed: false, attempted: false, reason: `head "${head}" is not a plain branch name` };
+    if (head === base)
+        return { pushed: false, attempted: false, reason: "head is the base branch" };
+    try {
+        const local = await git(["rev-parse", "--verify", "--quiet", `refs/heads/${head}^{commit}`], { cwd, env });
+        if (local.code !== 0)
+            return { pushed: false, attempted: false, reason: `no local branch ${head}` };
+        const remote = await git(["remote", "get-url", "origin"], { cwd, env });
+        if (remote.code !== 0)
+            return { pushed: false, attempted: false, reason: "no origin remote" };
+        const parsed = repoFromRemote(remote.stdout);
+        if (!parsed || parsed.repo !== opts.repo.toLowerCase()) {
+            return { pushed: false, attempted: false, reason: `origin is not ${opts.repo}` };
+        }
+        const originHead = await git(["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"], { cwd, env });
+        const defaultBranch = originHead.code === 0 ? originHead.stdout.trim().replace(/^origin\//, "") : undefined;
+        if (head === defaultBranch || head === "main" || head === "master") {
+            return { pushed: false, attempted: false, reason: `head ${head} is the default branch` };
+        }
+        const server = (env.GITHUB_SERVER_URL || "https://github.com").replace(/\/+$/, "");
+        let serverHost;
+        try {
+            serverHost = new URL(server).host.toLowerCase();
+        }
+        catch {
+            serverHost = "github.com";
+        }
+        const pushEnv = opts.token && parsed.https && parsed.host === serverHost ? pushAuthConfig(server, opts.token, env) : env;
+        const r = await git(["push", "--porcelain", "origin", `refs/heads/${head}:refs/heads/${head}`], {
+            cwd,
+            env: pushEnv,
+        });
+        if (r.code !== 0) {
+            const why = (r.stderr || r.stdout).trim().split("\n").at(-1) ?? "";
+            return { pushed: false, attempted: true, reason: `git push failed: ${redact(why, opts.token)}` };
+        }
+        return { pushed: true, attempted: true };
+    }
+    catch (err) {
+        return {
+            pushed: false,
+            attempted: false,
+            reason: redact(err instanceof Error ? err.message : String(err), opts.token),
+        };
+    }
+}
+function redact(text, token) {
+    if (!token)
+        return text;
+    const basic = Buffer.from(`x-access-token:${token}`).toString("base64");
+    return text.split(token).join("***").split(basic).join("***");
+}
+// The Node entry imports this module (executor.ts), which arms the push in `github_create_pr`.
+setBranchPusher(pushHeadBranch);

package/dist/skills/github.d.ts

@@ -5,6 +5,23 @@
  * ~800 lines → ~120 lines
  */
 import type { Skill } from "../types.js";
+/**
+ * Pushes a PR's head branch from the sweny process (#473). The Node entry
+ * registers it (skills/git-push.ts, imported by the executor); this module
+ * stays browser-safe, and without a pusher `github_create_pr` only calls the API.
+ */
+export type BranchPusher = (opts: {
+    repo: string;
+    head: string;
+    base: string;
+    token?: string;
+}) => Promise<{
+    pushed: boolean;
+    attempted: boolean;
+    reason?: string;
+}>;
+/** Register (or clear, with `undefined`) the sweny-side branch pusher. */
+export declare function setBranchPusher(fn: BranchPusher | undefined): void;
 /**
  * Encode an LLM-chosen repo file path for safe interpolation into a
  * GitHub API request path.

package/dist/skills/github.js

@@ -4,6 +4,11 @@
  * Replaces: source-control/github.ts + issue-tracking/github-issues.ts
  * ~800 lines → ~120 lines
  */
+let branchPusher;
+/** Register (or clear, with `undefined`) the sweny-side branch pusher. */
+export function setBranchPusher(fn) {
+    branchPusher = fn;
+}
 class GitHubApiError extends Error {
     status;
     body;
@@ -178,6 +183,24 @@ export const github = {
             handler: async (input, ctx) => {
                 let pr;
                 let reused = false;
+                // #473: push the head branch from sweny with this skill's token, so the
+                // recommended `persist-credentials: false` checkout still ships the
+                // branch and the agent never holds a write token. Skipped unless the
+                // branch exists locally and origin is this repo; never forced.
+                if (branchPusher) {
+                    const push = await branchPusher({
+                        repo: input.repo,
+                        head: input.head,
+                        base: input.base ?? "main",
+                        token: ctx.config.GITHUB_TOKEN,
+                    });
+                    if (push.pushed)
+                        ctx.logger?.info?.(`  github_create_pr: pushed ${input.head} to origin`);
+                    else if (push.attempted)
+                        ctx.logger?.warn?.(`  github_create_pr: ${push.reason}; requesting the PR anyway`);
+                    else
+                        ctx.logger?.debug?.(`  github_create_pr: no sweny-side push (${push.reason})`);
+                }
                 try {
                     pr = (await gh(`/repos/${input.repo}/pulls`, ctx, {
                         method: "POST",

package/dist/theme.d.ts

@@ -0,0 +1,185 @@
+/**
+ * SWEny visual tokens: one palette, one glyph set, one meaning per color.
+ *
+ * The single source for the CLI, the PR comment, the Mermaid diagrams, and
+ * Studio. Values come from docs/brand-guide.md. Browser-safe on purpose: no
+ * imports, no `process`, no chalk. Terminal painters live in `cli/style.ts`
+ * and are built from these tokens.
+ *
+ * Import from `@sweny-ai/core`, `@sweny-ai/core/browser`, or
+ * `@sweny-ai/core/theme`.
+ */
+/** The product line, as on the README and docs. */
+export declare const SWENY_TAGLINE = "Workflows for coding agents. One set of rules, a receipt for every run.";
+/** Raw brand palette (Tailwind names in comments). Prefer `ROLE_COLORS` in UI code. */
+export declare const PALETTE: {
+    readonly blue300: "#93c5fd";
+    readonly blue400: "#60a5fa";
+    readonly blue500: "#3b82f6";
+    readonly blue600: "#2563eb";
+    readonly blue700: "#1d4ed8";
+    readonly blue900: "#1e3a5f";
+    readonly green400: "#4ade80";
+    readonly green600: "#16a34a";
+    readonly yellow400: "#facc15";
+    readonly yellow600: "#ca8a04";
+    readonly red400: "#f87171";
+    readonly red600: "#dc2626";
+    readonly red800: "#991b1b";
+    readonly slate50: "#f8fafc";
+    readonly slate100: "#f1f5f9";
+    readonly slate200: "#e2e8f0";
+    readonly slate400: "#94a3b8";
+    readonly slate500: "#64748b";
+    readonly slate600: "#475569";
+    readonly slate700: "#334155";
+    readonly slate800: "#1e293b";
+    readonly slate900: "#0f172a";
+    readonly surface: "#162032";
+    readonly white: "#ffffff";
+};
+/**
+ * One color per meaning. Every surface (terminal, PR comment, diagram,
+ * Studio) maps a meaning to the same token:
+ *
+ * - `brand`   the SWEny mark, the policy stamp, the running spinner, current work
+ * - `success` a passed node or run
+ * - `warning` something ran weaker than asked (unscoped env, no sandbox, degraded)
+ * - `error`   a failed node or run, a budget stop
+ * - `info`    links and neutral highlights
+ * - `muted`   labels, frames, pending and skipped work
+ */
+export declare const ROLE_COLORS: {
+    readonly brand: "#3b82f6";
+    readonly brandStrong: "#2563eb";
+    readonly brandDeep: "#1d4ed8";
+    readonly success: "#4ade80";
+    readonly warning: "#facc15";
+    readonly error: "#f87171";
+    readonly info: "#60a5fa";
+    readonly muted: "#64748b";
+};
+export type ColorRole = keyof typeof ROLE_COLORS;
+/** Surface colors for dark and light UIs (Studio, docs). */
+export declare const SURFACE_COLORS: {
+    readonly dark: {
+        readonly background: "#1e293b";
+        readonly surface: "#162032";
+        readonly border: "#334155";
+        readonly primary: "#3b82f6";
+        readonly text: "#f1f5f9";
+        readonly textSecondary: "#94a3b8";
+        readonly textMuted: "#64748b";
+    };
+    readonly light: {
+        readonly background: "#f8fafc";
+        readonly surface: "#ffffff";
+        readonly border: "#e2e8f0";
+        readonly primary: "#2563eb";
+        readonly text: "#0f172a";
+        readonly textSecondary: "#64748b";
+        readonly textMuted: "#94a3b8";
+    };
+};
+/**
+ * The glyph set. One glyph per meaning, everywhere:
+ *
+ * | key      | unicode | ascii | meaning                              |
+ * |----------|---------|-------|--------------------------------------|
+ * | success  | ✓       | +     | node or run passed                   |
+ * | failure  | ✗       | x     | node or run failed                   |
+ * | skipped  | −       | -     | node skipped                         |
+ * | pending  | ○       | o     | node not reached yet                 |
+ * | running  | ●       | *     | node running (static views)          |
+ * | warning  | ⚠       | !     | a warning line                       |
+ * | brand    | ▲       | ^     | the SWEny mark                       |
+ * | detail   | ↳       | >     | a detail line under a node           |
+ * | sep      | ·       | |     | separator between inline facts       |
+ * | ellipsis | …       | ...   | work in progress, truncated text     |
+ * | arrow    | →       | ->    | a route taken, a change from a to b  |
+ *
+ * Every unicode glyph above is a single terminal column.
+ */
+export declare const GLYPHS: {
+    readonly unicode: {
+        readonly success: "✓";
+        readonly failure: "✗";
+        readonly skipped: "−";
+        readonly pending: "○";
+        readonly running: "●";
+        readonly warning: "⚠";
+        readonly brand: "▲";
+        readonly detail: "↳";
+        readonly sep: "·";
+        readonly ellipsis: "…";
+        readonly arrow: "→";
+    };
+    readonly ascii: {
+        readonly success: "+";
+        readonly failure: "x";
+        readonly skipped: "-";
+        readonly pending: "o";
+        readonly running: "*";
+        readonly warning: "!";
+        readonly brand: "^";
+        readonly detail: ">";
+        readonly sep: "|";
+        readonly ellipsis: "...";
+        readonly arrow: "->";
+    };
+};
+export type GlyphKey = keyof typeof GLYPHS.unicode;
+export type GlyphSet = {
+    readonly [K in GlyphKey]: string;
+};
+/** Spinner frames for live work: braille dots, or a plain ASCII bar. */
+export declare const SPINNER_FRAMES: {
+    readonly unicode: readonly ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    readonly ascii: readonly ["|", "/", "-", "\\"];
+};
+/** Spinner frame interval in ms. */
+export declare const SPINNER_INTERVAL_MS = 80;
+/**
+ * Box drawing for the receipt ticket. The frame is perforated (dashed
+ * edges); the tear line separates the stub that carries the policy stamp.
+ */
+export declare const TICKET_BOX: {
+    readonly unicode: {
+        readonly topLeft: "╭";
+        readonly topRight: "╮";
+        readonly bottomLeft: "╰";
+        readonly bottomRight: "╯";
+        readonly horizontal: "┄";
+        readonly vertical: "┆";
+        readonly tearLeft: "├";
+        readonly tearRight: "┤";
+        readonly tear: "╌";
+    };
+    readonly ascii: {
+        readonly topLeft: "+";
+        readonly topRight: "+";
+        readonly bottomLeft: "+";
+        readonly bottomRight: "+";
+        readonly horizontal: "-";
+        readonly vertical: ":";
+        readonly tearLeft: "+";
+        readonly tearRight: "+";
+        readonly tear: "- ";
+    };
+};
+export type TicketBox = {
+    readonly [K in keyof typeof TICKET_BOX.unicode]: string;
+};
+/** Node states a diagram can show. `pending` is any node the run never reached. */
+export type DiagramNodeStatus = "current" | "success" | "failed" | "skipped" | "pending";
+/**
+ * Mermaid `classDef` bodies by node status. Readable on GitHub light and dark:
+ * filled nodes carry white text, pending is an outline in slate-500 (legible
+ * on both backgrounds).
+ */
+export declare const MERMAID_CLASS_DEFS: Readonly<Record<DiagramNodeStatus, string>>;
+/** Mermaid `linkStyle` bodies for edges a traced run took and did not take. */
+export declare const MERMAID_EDGE_STYLES: {
+    readonly taken: "stroke:#2563eb,stroke-width:3px";
+    readonly notTaken: "stroke:#64748b,stroke-width:1px,stroke-dasharray:5 5";
+};