aiden-runtime 4.0.1 → 4.1.0

package/dist/cli/v4/aidenPrompt.js

@@ -0,0 +1,317 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/aidenPrompt.ts — Tier-3.1.1 (v4.1-tier3.1.1)
+ *
+ * Custom @inquirer/core prompt component that combines:
+ *   - Standard text input (inquirer.input parity)
+ *   - Ghost-text overlay for matching slash commands / history
+ *   - Slash dropdown with ↑/↓ nav, Esc dismiss, description column
+ *   - History suggestions for non-slash text
+ *   - Cooperation with pasteIntercept (ghost disabled when a paste
+ *     label is in the buffer)
+ *
+ * The prompt returns the typed text on Enter (NOT the ghost). The
+ * user must explicitly accept the ghost via Right-arrow or Tab.
+ *
+ * MCP serve mode never reaches this path — the REPL is gated on
+ * `process.stdout.isTTY` and serve mode runs over JSON-RPC stdio.
+ *
+ * `--no-ui`: the chatSession owner consults `isNoUiMode()` and
+ * falls back to the legacy inquirer prompt path when the env-var
+ * is set.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@inquirer/core");
+const ghostMatch_1 = require("./ghostMatch");
+const skinEngine_1 = require("./skinEngine");
+const DEFAULT_DROPDOWN_LIMIT = 8;
+/** Strip ANSI for width math. */
+function stripAnsi(s) {
+    return s.replace(/\x1b\[[0-9;]*[A-Za-z]/g, '');
+}
+/** Visible width — ignore ANSI escape sequences. */
+function vWidth(s) {
+    return stripAnsi(s).length;
+}
+/** Build an SGR span using the active skin. */
+function dim(s) {
+    return (0, skinEngine_1.getSkinEngine)().applyColors(s, 'muted');
+}
+/** Render a single dropdown row with right-aligned dim description. */
+function renderDropdownRow(cmd, selected, width) {
+    const sk = (0, skinEngine_1.getSkinEngine)();
+    const marker = selected ? '▸ ' : '  ';
+    const nameCell = `/${cmd.name}`;
+    const desc = cmd.description ?? '';
+    // Reserve 2 chars for marker + 2-space pad before the desc column.
+    // The desc column is right-aligned and dim-coloured.
+    const lhs = `${marker}${nameCell}`;
+    const lhsWidth = vWidth(lhs);
+    const padBetween = Math.max(2, width - lhsWidth - vWidth(desc));
+    const truncatedDesc = vWidth(desc) > width - lhsWidth - 2
+        ? desc.slice(0, Math.max(0, width - lhsWidth - 3)) + '…'
+        : desc;
+    const dimDesc = sk.applyColors(truncatedDesc, 'muted');
+    const painted = selected
+        ? sk.applyColors(lhs, 'brand')
+        : lhs;
+    return painted + ' '.repeat(padBetween) + dimDesc;
+}
+/** Default 3-tier filter — matches commandRegistry.filter shape. */
+function defaultFilter(cmds, input) {
+    const stem = input.startsWith('/') ? input.slice(1) : input;
+    const lower = stem.toLowerCase();
+    if (!lower)
+        return cmds.filter((c) => !c.hidden);
+    const visible = cmds.filter((c) => !c.hidden);
+    const prefix = visible.filter((c) => c.name.toLowerCase().startsWith(lower) ||
+        (c.aliases ?? []).some((a) => a.toLowerCase().startsWith(lower)));
+    if (prefix.length > 0)
+        return prefix;
+    const substring = visible.filter((c) => c.name.toLowerCase().includes(lower) ||
+        (c.aliases ?? []).some((a) => a.toLowerCase().includes(lower)));
+    if (substring.length > 0)
+        return substring;
+    return visible.filter((c) => (c.description ?? '').toLowerCase().includes(lower));
+}
+/**
+ * The prompt itself. Resolves with the literal user-typed text on
+ * Enter. If the dropdown is open and the user pressed Enter on a
+ * highlighted row, resolves with `/<row.name>` instead.
+ */
+exports.default = (0, core_1.createPrompt)((config, done) => {
+    const theme = (0, core_1.makeTheme)({}, config.theme);
+    const [status, setStatus] = (0, core_1.useState)('idle');
+    const [value, setValue] = (0, core_1.useState)('');
+    const [ghost, setGhost] = (0, core_1.useState)(null);
+    const [dropdownOpen, setDropdownOpen] = (0, core_1.useState)(false);
+    const [selectedIdx, setSelectedIdx] = (0, core_1.useState)(0);
+    const [historyIdx, setHistoryIdx] = (0, core_1.useState)(null);
+    // Snapshot of the typed value when the user starts navigating
+    // history — restored when they reach the bottom of the stack.
+    const historyDraftRef = (0, core_1.useRef)('');
+    // Tier-3.1c: paste-burst guard. When bracketed paste mode isn't
+    // honoured by the terminal (no CSI 200~/201~ wrap) the paste
+    // arrives as raw bytes; the first internal `\n` becomes an Enter
+    // event and submits before the user can review. We can't always
+    // suppress that at the stdin level, so as a defence-in-depth the
+    // prompt records the timestamp of the last NON-Enter keypress and
+    // refuses to submit on Enter that arrives within
+    // PASTE_BURST_GUARD_MS of it. Real user Enter comes after a
+    // pause, so this only blocks the rapid Enter-from-paste path.
+    const lastNonEnterKeyMsRef = (0, core_1.useRef)(0);
+    const prefix = (0, core_1.usePrefix)({ status, theme });
+    const dropdownLimit = config.dropdownLimit ?? DEFAULT_DROPDOWN_LIMIT;
+    const filterFn = config.filter
+        ?? ((input) => defaultFilter(config.commands, input));
+    /** Recompute ghost + dropdown for a new value. */
+    function rederive(next) {
+        setValue(next);
+        setGhost((0, ghostMatch_1.findGhost)(next, {
+            slashNames: config.commands.map((c) => c.name),
+            slashAliases: config.commands.flatMap((c) => [...(c.aliases ?? [])]),
+            history: config.history,
+        }));
+        if (next.startsWith('/')) {
+            const matches = filterFn(next);
+            const open = matches.length > 0;
+            setDropdownOpen(open);
+            if (open)
+                setSelectedIdx(Math.min(selectedIdx, matches.length - 1));
+        }
+        else {
+            setDropdownOpen(false);
+            setSelectedIdx(0);
+        }
+    }
+    (0, core_1.useEffect)((rl) => {
+        // Initial sync — empty.
+        setValue('');
+        setGhost(null);
+        setDropdownOpen(false);
+        void rl;
+    }, []);
+    (0, core_1.useKeypress)((key, rl) => {
+        if (status !== 'idle')
+            return;
+        // ── Submit ──
+        if ((0, core_1.isEnterKey)(key)) {
+            // Tier-3.1c: paste-burst guard. If a non-Enter keystroke fired
+            // within the last 50ms, this Enter is almost certainly an
+            // internal `\n` from an unbracketed paste, not a deliberate
+            // user submit. Suppress and let readline keep accumulating
+            // bytes — the user will press Enter again once the paste
+            // settles.
+            const PASTE_BURST_GUARD_MS = 50;
+            const sinceLastKey = Date.now() - lastNonEnterKeyMsRef.current;
+            if (lastNonEnterKeyMsRef.current > 0 && sinceLastKey < PASTE_BURST_GUARD_MS) {
+                // Reset so subsequent rapid Enters are also caught while
+                // the burst continues.
+                lastNonEnterKeyMsRef.current = Date.now();
+                // Resync value in case readline already cleared the line
+                // on this Enter (it does — we can't fully prevent that, but
+                // we keep the buffered fragments in `value` for context).
+                rederive(rl.line);
+                return;
+            }
+            if (dropdownOpen) {
+                const matches = filterFn(value);
+                const picked = matches[selectedIdx];
+                if (picked) {
+                    // Tier-3.1c: preserve typed args. If the user typed
+                    // `/skills list` we must submit the literal value, not
+                    // `/skills` alone — the row pick only short-circuits to
+                    // the command name when the typed value is JUST the
+                    // (partial) command without args. Detect args via a
+                    // whitespace boundary inside `value`.
+                    const hasArgs = /\s/.test(value);
+                    const out = hasArgs ? value : `/${picked.name}`;
+                    setStatus('done');
+                    setValue(out);
+                    done(out);
+                    return;
+                }
+            }
+            // Normal submit — return literal typed text (NOT ghost).
+            setStatus('done');
+            done(value);
+            return;
+        }
+        // ── Esc — dismiss dropdown ──
+        if (key.name === 'escape') {
+            if (dropdownOpen) {
+                setDropdownOpen(false);
+                return;
+            }
+            // No dropdown — let inquirer's default Esc handling run
+            // (typically a no-op for an `input`-style prompt).
+            return;
+        }
+        // ── Right / Tab — accept ghost ──
+        if ((key.name === 'right' || (0, core_1.isTabKey)(key)) && ghost) {
+            // Tab unambiguously accepts. Right-arrow only accepts when the
+            // cursor is at the END of the line (otherwise the user is mid-
+            // edit and right-arrow should move the cursor normally). Cursor
+            // position isn't in @inquirer/type's InquirerReadline shape but
+            // is on the underlying node readline — read it via cast.
+            const cursorPos = rl.cursor ?? rl.line.length;
+            const atEnd = cursorPos === rl.line.length;
+            if (atEnd || (0, core_1.isTabKey)(key)) {
+                const accepted = value + ghost;
+                rl.clearLine(0);
+                rl.write(accepted);
+                rederive(accepted);
+                return;
+            }
+        }
+        // ── ↑/↓ ──
+        if (key.name === 'up' || key.name === 'down') {
+            if (dropdownOpen) {
+                const matches = filterFn(value);
+                if (matches.length > 0) {
+                    if (key.name === 'up') {
+                        setSelectedIdx((selectedIdx - 1 + matches.length) % matches.length);
+                    }
+                    else {
+                        setSelectedIdx((selectedIdx + 1) % matches.length);
+                    }
+                    return;
+                }
+            }
+            // History nav (when dropdown closed). Up = older, Down = newer.
+            if (config.history.length > 0) {
+                if (key.name === 'up') {
+                    if (historyIdx === null) {
+                        historyDraftRef.current = value;
+                        setHistoryIdx(0);
+                        const next = config.history[0];
+                        rl.clearLine(0);
+                        rl.write(next);
+                        rederive(next);
+                    }
+                    else if (historyIdx + 1 < config.history.length) {
+                        const ni = historyIdx + 1;
+                        setHistoryIdx(ni);
+                        const next = config.history[ni];
+                        rl.clearLine(0);
+                        rl.write(next);
+                        rederive(next);
+                    }
+                }
+                else { // down
+                    if (historyIdx !== null) {
+                        if (historyIdx === 0) {
+                            setHistoryIdx(null);
+                            const draft = historyDraftRef.current;
+                            rl.clearLine(0);
+                            rl.write(draft);
+                            rederive(draft);
+                        }
+                        else {
+                            const ni = historyIdx - 1;
+                            setHistoryIdx(ni);
+                            const next = config.history[ni];
+                            rl.clearLine(0);
+                            rl.write(next);
+                            rederive(next);
+                        }
+                    }
+                }
+                return;
+            }
+            return;
+        }
+        // ── Backspace fast-path so cursor sync stays clean ──
+        if ((0, core_1.isBackspaceKey)(key)) {
+            // rl.line already updated by the readline event before this
+            // handler runs, so we just resync.
+            lastNonEnterKeyMsRef.current = Date.now();
+            setHistoryIdx(null);
+            rederive(rl.line);
+            return;
+        }
+        // ── Default — sync from rl.line, recompute derived state ──
+        // Tier-3.1c: any non-Enter keystroke updates the burst-guard
+        // timestamp; the Enter handler reads it to decide whether the
+        // submit is a real user Enter or part of a paste burst.
+        lastNonEnterKeyMsRef.current = Date.now();
+        setHistoryIdx(null);
+        rederive(rl.line);
+    });
+    // ── Render ─────────────────────────────────────────────────────
+    const message = theme.style.message(config.message, status);
+    let line;
+    if (status === 'done') {
+        line = `${message} ${theme.style.answer(value)}`;
+    }
+    else {
+        const ghostStr = ghost ? dim(ghost) : '';
+        line = `${prefix} ${message}${value}${ghostStr}`;
+    }
+    // Footer (dropdown). Returning a tuple `[line, footer]` adds the
+    // footer below the input line; inquirer takes care of cursor
+    // positioning so the cursor stays on `line`.
+    let footer;
+    if (dropdownOpen && status === 'idle') {
+        const matches = filterFn(value);
+        if (matches.length > 0) {
+            const visibleCols = process.stdout.columns ?? 100;
+            const rowWidth = Math.max(40, Math.min(visibleCols - 4, 100));
+            const window = matches.slice(0, dropdownLimit);
+            // Clamp selectedIdx into the visible window.
+            const safeIdx = Math.min(selectedIdx, window.length - 1);
+            const rows = window.map((c, i) => renderDropdownRow(c, i === safeIdx, rowWidth));
+            const more = matches.length > window.length
+                ? `  ${dim(`… ${matches.length - window.length} more`)}`
+                : '';
+            footer = [...rows, more].filter((r) => r.length > 0).join('\n');
+        }
+    }
+    return footer ? [line, footer] : line;
+});

package/dist/cli/v4/box.js

@@ -6,47 +6,68 @@
  * Aiden — local-first agent.
  */
 /**
- * cli/v4/box.ts — rounded-corner box drawing helpers (Phase 22).
+ * cli/v4/box.ts — sharp + double-line box drawing helpers.
  *
- * Shared between the REPL boot card (chatSession.ts), the
- * setup-complete summary (setupWizard.ts), the /doctor health box
- * (doctor.ts), and the approval prompt box (callbacks.ts). Per the
- * Aiden uses the rounded set (╭╮╰╯) for box framing — rounded
- * reads softer at launch-card scale than square corners.
+ * Tier-3.1 (v4.1-tier3.1) replaced the rounded set (╭╮╰╯) with
+ * sharp corners (┌┐└┘) for the default box and added a second
+ * double-line variant (╔╗╚╝═║) for emphasis surfaces (e.g. the
+ * approval/escalation banner). The default `box*` exports continue
+ * to point at the sharp variant so existing callers compile
+ * unchanged; `boxSharp*` and `boxDouble*` are explicit aliases for
+ * call sites that want to declare intent.
  *
  * Width counts the inner cell only (between the verticals). Content
  * is padded to width-1 so a single leading space gives the box a
  * visual gutter.
  *
- * ANSI awareness (Phase 22 Group C smoke-fix): Group C's per-row
- * coloured content (orange ✓ icons, soft-cyan labels) inflated
- * `string.length` from ~50 visible chars to ~120 bytes per row, so
- * the prior byte-based padding under-filled and the closing `│`
- * drifted inside the visible box top/bottom borders. The helpers
+ * ANSI awareness: per-row coloured content (orange ✓ icons, soft-
+ * cyan labels) inflates `String.length` from ~50 visible chars to
+ * ~120 bytes per row, so byte-based padding under-fills and the
+ * closing vertical drifts inside the visible borders. The helpers
  * below measure / truncate against the visible (post-strip)
  * length, so coloured content frames identically to plain content.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.boxSharpTopTitled = exports.boxSharpLine = exports.boxSharpBottom = exports.boxSharpTop = void 0;
 exports.visibleLength = visibleLength;
 exports.truncateVisible = truncateVisible;
 exports.boxTop = boxTop;
 exports.boxBottom = boxBottom;
 exports.boxLine = boxLine;
 exports.boxTopTitled = boxTopTitled;
-const TL = '╭';
-const TR = '╮';
-const BL = '╰';
-const BR = '╯';
-const H = '─';
-const V = '│';
+exports.boxDoubleTop = boxDoubleTop;
+exports.boxDoubleBottom = boxDoubleBottom;
+exports.boxDoubleLine = boxDoubleLine;
+exports.boxDoubleTopTitled = boxDoubleTopTitled;
+exports.boxDouble = boxDouble;
+exports.boxSharp = boxSharp;
+// ── Sharp (default) ──────────────────────────────────────────────
+const SHARP = {
+    TL: '┌',
+    TR: '┐',
+    BL: '└',
+    BR: '┘',
+    H: '─',
+    V: '│',
+};
+// ── Double-line (emphasis) ───────────────────────────────────────
+const DOUBLE = {
+    TL: '╔',
+    TR: '╗',
+    BL: '╚',
+    BR: '╝',
+    H: '═',
+    V: '║',
+};
 /**
  * Strip ANSI CSI escape sequences and return the visible length in
  * Unicode code units (`String.length`). Sufficient for all colour
  * codes we emit (`\x1b[38;2;r;g;bm`, `\x1b[39m`, `\x1b[0m`, etc.).
  *
  * Doesn't try to handle East Asian wide chars / emoji-with-VS16 — we
- * use only single-cell glyphs in box content (✓ ⚠ ✗ ⏵ ▶ ⊕). If the
- * skill expands in v4.1 to cover wide chars, swap to `string-width`.
+ * use only single-cell glyphs in box content (✓ ⚠ ✗ ⏵ ▶ ⊕). Wide-
+ * char-aware width is available in `cli/v4/table.ts` via
+ * `string-width`, used only by the table renderer.
  */
 const ANSI_REGEX = /\x1b\[[0-9;]*[A-Za-z]/g;
 function visibleLength(s) {
@@ -55,10 +76,8 @@ function visibleLength(s) {
 /**
  * Truncate `s` to `maxVisible` visible columns, preserving any ANSI
  * sequences encountered along the way. When the input contained ANSI
- * codes, an SGR reset is appended so the closing `│` doesn't inherit
- * the truncated content's colour. Plain-text input is unchanged
- * beyond the truncation, so callers building plain rows still see
- * exactly `maxVisible` characters back.
+ * codes, an SGR reset is appended so the closing vertical doesn't
+ * inherit the truncated content's colour.
  */
 function truncateVisible(s, maxVisible) {
     if (visibleLength(s) <= maxVisible)
@@ -84,29 +103,76 @@ function truncateVisible(s, maxVisible) {
     }
     return sawAnsi ? out + '\x1b[0m' : out;
 }
-function boxTop(width) {
-    return TL + H.repeat(width) + TR;
+// ── Generic primitives ───────────────────────────────────────────
+function renderTop(g, width) {
+    return g.TL + g.H.repeat(width) + g.TR;
 }
-function boxBottom(width) {
-    return BL + H.repeat(width) + BR;
+function renderBottom(g, width) {
+    return g.BL + g.H.repeat(width) + g.BR;
 }
-function boxLine(content, width) {
+function renderLine(g, content, width) {
     const inner = ' ' + content;
     const visible = visibleLength(inner);
     if (visible >= width) {
-        return V + truncateVisible(inner, width) + V;
+        return g.V + truncateVisible(inner, width) + g.V;
     }
-    return V + inner + ' '.repeat(width - visible) + V;
+    return g.V + inner + ' '.repeat(width - visible) + g.V;
+}
+function renderTopTitled(g, title, width) {
+    const lhs = `${g.TL}${g.H}${g.H} ${title} `;
+    const visibleLhs = 2 + 1 + visibleLength(title) + 1;
+    const remaining = Math.max(0, width - visibleLhs);
+    return `${lhs}${g.H.repeat(remaining)}${g.TR}`;
+}
+// ── Sharp variant (default) ──────────────────────────────────────
+function boxTop(width) {
+    return renderTop(SHARP, width);
+}
+function boxBottom(width) {
+    return renderBottom(SHARP, width);
+}
+function boxLine(content, width) {
+    return renderLine(SHARP, content, width);
+}
+function boxTopTitled(title, width) {
+    return renderTopTitled(SHARP, title, width);
+}
+// Explicit sharp aliases (for call sites that want to declare intent).
+exports.boxSharpTop = boxTop;
+exports.boxSharpBottom = boxBottom;
+exports.boxSharpLine = boxLine;
+exports.boxSharpTopTitled = boxTopTitled;
+// ── Double-line variant ──────────────────────────────────────────
+function boxDoubleTop(width) {
+    return renderTop(DOUBLE, width);
+}
+function boxDoubleBottom(width) {
+    return renderBottom(DOUBLE, width);
+}
+function boxDoubleLine(content, width) {
+    return renderLine(DOUBLE, content, width);
+}
+function boxDoubleTopTitled(title, width) {
+    return renderTopTitled(DOUBLE, title, width);
 }
 /**
- * Render a titled box header — top border with the title injected just
- * after the left corner, e.g. `╭─ Setup Complete ─────╮`. Used for the
- * setup-complete summary and the /doctor + approval boxes.
+ * Convenience: wrap an array of content rows with double-line
+ * borders and an optional title. Returns the full multi-line box
+ * as a single string with `\n` separators.
  */
-function boxTopTitled(title, width) {
-    // Two leading dashes, space, title, space, then fill remaining dashes.
-    const lhs = `${TL}${H}${H} ${title} `;
-    const visibleLhs = 2 + 1 + visibleLength(title) + 1; // dashes + space + title + space
-    const remaining = Math.max(0, width - visibleLhs);
-    return `${lhs}${H.repeat(remaining)}${TR}`;
+function boxDouble(rows, width, title) {
+    const top = title ? boxDoubleTopTitled(title, width) : boxDoubleTop(width);
+    const body = rows.map((r) => boxDoubleLine(r, width)).join('\n');
+    const bottom = boxDoubleBottom(width);
+    return [top, body, bottom].filter(Boolean).join('\n');
+}
+/**
+ * Convenience: wrap an array of content rows with sharp borders
+ * and an optional title.
+ */
+function boxSharp(rows, width, title) {
+    const top = title ? boxTopTitled(title, width) : boxTop(width);
+    const body = rows.map((r) => boxLine(r, width)).join('\n');
+    const bottom = boxBottom(width);
+    return [top, body, bottom].filter(Boolean).join('\n');
 }

package/dist/cli/v4/callbacks.js

@@ -33,10 +33,15 @@ async function defaultPrompts() {
         },
     };
 }
+// Tier-3-essentials: terse 4-state ladder labels per dispatch.
+// Once / Session / Always / Deny — same underlying ApprovalDecision
+// values, friendlier wording. Persistence to <aidenHome>/approvals.json
+// is wired in aidenCLI.ts via approvalEngine.callbacks.persistAllow
+// (Phase 16f); session-scope cache in approvalEngine.allowForSession.
 const DECISION_CHOICES = [
-    { name: 'Allow once', value: 'allow' },
-    { name: 'Allow this session', value: 'allow_session' },
-    { name: 'Allow always', value: 'allow_always' },
+    { name: 'Once', value: 'allow' },
+    { name: 'Session', value: 'allow_session' },
+    { name: 'Always', value: 'allow_always' },
     { name: 'Deny', value: 'deny' },
 ];
 const KNOWN_TIERS = new Set(['safe', 'caution', 'dangerous']);
@@ -184,6 +189,26 @@ Reply with ONE word: safe, caution, or dangerous.`;
                 this.display.dim(`[planner] kept ${decision.selectedTools.length} tools (${decision.reason})`);
             }
         };
+        /**
+         * Phase v4.1-skill-mining — post-turn cue when the miner has
+         * staged a candidate for `/skills review`. Single dim line, no
+         * modal. Pulls the skill name + confidence from the candidate's
+         * own SKILL.md (best-effort parse; falls back to id slice).
+         */
+        this.onSkillCandidate = (candidate) => {
+            let name = candidate.id.slice(0, 8);
+            try {
+                // Tier-3.1c sweep: do not import here — chatSession's display
+                // wraps strings, and the SKILL.md frontmatter is plain enough
+                // that a quick regex is fine for the cue line.
+                const m = /\bname\s*:\s*([^\n]+)/.exec(candidate.skillContent);
+                if (m)
+                    name = m[1].trim();
+            }
+            catch { /* fall through */ }
+            const conf = candidate.candidateConfidence.toFixed(2);
+            this.display.dim(`[skill] candidate '${name}' queued (conf ${conf}) — run /skills review`);
+        };
         /** ContextCompressor sink — always shows. */
         this.onCompression = (result) => {
             if (result.refused) {
@@ -239,14 +264,22 @@ Reply with ONE word: safe, caution, or dangerous.`;
     }
 }
 exports.CliCallbacks = CliCallbacks;
+// Tier-3.1 (v4.1-tier3.1): replaced 🟢/🟡/🔴 emoji badges with
+// text-state badges. Each badge is 7 visible chars (pad-aligned) so
+// approval-prompt rows align across tiers. Plain ANSI SGR colour to
+// keep this file dependency-free.
+const ANSI_GREEN = '\x1b[32m';
+const ANSI_YELLOW = '\x1b[33m';
+const ANSI_RED = '\x1b[31m';
+const ANSI_RESET = '\x1b[0m';
 function badgeForTier(tier) {
     switch (tier) {
         case 'safe':
-            return '🟢 safe';
+            return `${ANSI_GREEN}[ALLOW]${ANSI_RESET} safe`;
         case 'caution':
-            return '🟡 caution';
+            return `${ANSI_YELLOW}[WARN] ${ANSI_RESET} caution`;
         case 'dangerous':
-            return '🔴 dangerous';
+            return `${ANSI_RED}[DENY] ${ANSI_RESET} dangerous`;
         default:
             return '';
     }