claudial 0.3.0 → 0.5.0

package/README.md

@@ -2,12 +2,12 @@
 
 # ⚽ claudial
 
-### Live World Cup 2026 in your terminal — goal, red-card and VAR takeovers included
+### Live World Cup 2026 in your terminal — goal and red-card takeovers included
 
 One line. Zero install. Every score, while you work.
 
 ```
-npx claudial
+npx claudial && claudial setup
 ```
 
 <br/>
@@ -24,103 +24,66 @@ npx claudial
 
 ---
 
-Live matches with scores, minutes and scorers on top. Upcoming fixtures in
-your local time below. Auto-refreshing while you work.
+Live World Cup scores right inside Claude Code's status bar — under the input
+box, always visible while you work, lighting up the moment anyone scores:
 
-```
- ▐▛███▜▌   WORLD CUP 2026 · LIVE
- ▝▜█████▛▘  ───────────────────────
-
- ⏺ LIVE 67'
-   Argentina  2 — 1  Mexico
-   ⚽ 23' Messi · 51' Álvarez | 44' Lozano
+<div align="center">
 
- ⏺ LIVE 12'
-   France  0 — 0  Senegal
+![claudial — live World Cup 2026 scores in Claude Code's status bar](demo.gif)
 
- ○ UPCOMING
-   18:00  Brazil — Croatia
-   21:00  Spain — Morocco
+</div>
 
- r refresh · q quit
-```
+## Claude Code, World Cup edition
 
-And when a goal goes in — anywhere in the tournament — the whole screen
-takes over:
+The whole point: your Claude Code, score-aware. One command and the live score
+sits right in Claude Code's status bar — under the input box, always visible
+while Claude works, with nothing to wire up by hand.
 
+```bash
+npm install -g claudial
+claudial setup
 ```
 
+The wizard drops a live-score statusline into your Claude Code settings:
 
-      █▀▀█  █▀▀█  █▀▀█  █
-      █ ▄▄  █  █  █▀▀█  █
-      ▀▀▀▀  ▀▀▀▀  ▀  ▀  ▀▀▀▀
-
-         LIONEL MESSI · 23'
-
-      ARGENTINA  2 — 1  MEXICO
-
-
+```
+⚽ QAT 🇶🇦 0—1 🇨🇭 SUI 67' · main          ← during a match
+○ QAT 🇶🇦 — 🇨🇭 SUI 10:00 PM · main        ← between matches (next kickoff, or last result)
+⚽ G O O O L  ·  ARG 🇦🇷 1—0 🇲🇽 MEX        ← for 15s whenever anyone scores
+🟥 R E D  ·  OTAMENDI  ·  ARG 🇦🇷 — 🇲🇽 MEX  ← for 15s on a red card
 ```
 
-Four seconds of glory, then back to the board.
+It refreshes every few seconds and is pure Node, so it runs on macOS and
+Windows too, in any shell. Restart Claude Code after setup to see it.
+Scriptable, no prompts: `claudial setup --statusline --global --yes`.
 
-## Claude Code, World Cup edition
+**Already run a custom status line?** `claudial setup` keeps it — it wraps your
+existing one and appends the score, so nothing you had is lost.
 
-The whole point. Two commands and your Claude Code becomes a World Cup
-workstation — Claude working on top, every live score ticking in a strip
-below, forever.
+## The full dashboard
 
-Needs [tmux](https://github.com/tmux/tmux) (`sudo pacman -S tmux` /
-`sudo apt install tmux` / `brew install tmux`), then:
+Prefer the full board beside Claude? `claudial` opens a live dashboard — every
+match with scores, minutes and scorers, upcoming fixtures in your local time,
+all auto-refreshing while you work. And when a goal goes in — anywhere in the
+tournament — the whole screen takes over:
 
-```bash
-npm install -g claudial
-cat >> ~/.zshrc <<'EOF'
-alias claude-mundial="tmux new-session 'claude' \; split-window -v -l 5 'claudial --ticker' \; select-pane -U"
-EOF
 ```
 
-Open a new shell, type `claude-mundial`, and:
 
-```
-┌──────────────────────────────────────┐
-│ > implement the parser               │
-│                                      │
-│ ⏺ Working…                           │
-│                                      │
-├──────────────────────────────────────┤
-│ ⏺ 67' QAT 0—1 SUI                    │
-│ ○ BRA—MOR Sun 01:00                  │
-└──────────────────────────────────────┘
-```
+      █▀▀█  █▀▀█  █▀▀█  █
+      █ ▄▄  █  █  █▀▀█  █
+      ▀▀▀▀  ▀▀▀▀  ▀  ▀  ▀▀▀▀
 
-When a goal goes in, the strip lights up while Claude keeps working.
-(`bash` users: append to `~/.bashrc` instead. Prefer the full board beside
-Claude rather than a strip below? Use
-`split-window -h -l 44 'claudial'` in the alias.)
+         LIONEL MESSI · 23'
 
-Don't want to hand-edit your shell config? `claudial setup --tmux` appends the
-right alias for you — zsh, bash or fish — idempotently.
+      ARG 🇦🇷  2 — 1  🇲🇽 MEX
 
-Want the score *inside* Claude Code itself — in its status bar, no tmux at
-all? Install everything in one step:
 
-```bash
-npm install -g claudial
-claudial setup
 ```
 
-The wizard adds a live-score statusline (`⚽ QAT 0—1 SUI 67' · main`, refreshed
-every few seconds) to your Claude Code settings, and can also wire up the tmux
-ticker alias below. It works on zsh, bash and fish, and the statusline itself
-is pure Node — no `jq`/`flock`/`curl`, so it runs on macOS and Windows too.
-Non-interactive: `claudial setup --statusline --global --tmux --shell zsh --yes`.
-
-## Why a TUI
-
-The World Cup happens during work hours somewhere. This sits in a terminal
-split, costs nothing to glance at, and celebrates louder than a push
-notification — without you ever opening a browser tab.
+Four seconds of glory, then back to the board. It costs nothing to glance at,
+and celebrates louder than a push notification — without you ever opening a
+browser tab.
 
 ## Usage
 
@@ -144,9 +107,9 @@ Requires Node ≥ 18. No account, no API key, no config.
 | `r` | refresh now |
 | `q` | quit        |
 
-Beyond goals, every live match carries its incident feed: yellow cards,
-substitutions, injury time — and a `⚖ VAR` badge the moment a review starts.
-Red cards and VAR decisions get the full-screen treatment, same as goals.
+Beyond goals, every live match carries its incident feed — yellow cards,
+substitutions, injury time — and red cards get the full-screen treatment, same
+as goals.
 
 ## Status
 
@@ -154,6 +117,10 @@ v1 is being built live during the group stage. Follow the commits.
 
 ## Notes
 
+- Seeing letter codes instead of country flags (`🇦🇷` showing as `AR`)? Your
+  terminal isn't rendering flag emoji. Install [Konsole](https://konsole.kde.org/)
+  — it shows them out of the box. (macOS terminals already do; Windows
+  Terminal does not.)
 - Match data comes from [ESPN's public soccer scoreboard](https://site.api.espn.com/apis/site/v2/sports/soccer/fifa.world/scoreboard)
   — facts only (scores, scorers, cards), no logos or branding. See
   [DATA.md](DATA.md) for why this source. Not affiliated with or endorsed by

package/dist/api/espn.js

@@ -46,15 +46,47 @@ export function pastRange(daysBack, now = Date.now()) {
     const start = new Date(now - daysBack * 86_400_000);
     return `${yyyymmdd(start)}-${yyyymmdd(end)}`;
 }
+// ── Mock mode for demos (CLAUDIAL_MOCK) ──────────────────────────────────────
+// A fake live Argentina–England match. The first live fetch is 1–1; from the
+// second fetch on, Harry Kane has scored to make it 1–2 — so the next poll (or
+// pressing `r`) fires the goal takeover with his name. Inert unless the env var
+// is set. Run: `CLAUDIAL_MOCK=1 claudial`, then press `r`.
+const MOCK = !!process.env.CLAUDIAL_MOCK;
+let mockLiveCalls = 0;
+function mockEvent() {
+    const scored = mockLiveCalls >= 2; // Kane's goal lands on the 2nd live fetch
+    return {
+        id: '9001',
+        date: new Date(Date.now() - 78 * 60_000).toISOString(),
+        status: { type: { state: 'in', name: 'STATUS_SECOND_HALF', shortDetail: scored ? "78'" : "76'" }, displayClock: scored ? "78'" : "76'" },
+        competitions: [{
+                competitors: [
+                    { homeAway: 'home', team: { id: '202', abbreviation: 'ARG', displayName: 'Argentina' }, score: '1' },
+                    { homeAway: 'away', team: { id: '448', abbreviation: 'ENG', displayName: 'England' }, score: scored ? '2' : '1' },
+                ],
+                details: [
+                    { type: { id: '137' }, clock: { value: 600, displayValue: "10'" }, scoringPlay: true, team: { id: '202' }, athletesInvolved: [{ id: '1', displayName: 'Lionel Messi', shortName: 'L. Messi' }] },
+                    { type: { id: '137' }, clock: { value: 2400, displayValue: "40'" }, scoringPlay: true, team: { id: '448' }, athletesInvolved: [{ id: '2', displayName: 'Jude Bellingham', shortName: 'J. Bellingham' }] },
+                    ...(scored ? [{ type: { id: '137' }, clock: { value: 4680, displayValue: "78'" }, scoringPlay: true, team: { id: '448' }, athletesInvolved: [{ id: '3', displayName: 'Harry Kane', shortName: 'H. Kane' }] }] : []),
+                ],
+            }],
+    };
+}
 // Kept for call-site compatibility; ESPN needs no season id to query.
 export async function resolveSeasonId() {
     return 2026;
 }
 export async function fetchLive() {
+    if (MOCK) {
+        mockLiveCalls++;
+        return [parseEvent(mockEvent())];
+    }
     const events = await scoreboard(todayRange(0));
     return events.map(parseEvent).filter((m) => m.status === 'live' || m.status === 'halftime');
 }
 export async function fetchUpcoming(_seasonId) {
+    if (MOCK)
+        return [];
     const events = await scoreboard(todayRange(10));
     return events
         .map(parseEvent)
@@ -62,6 +94,8 @@ export async function fetchUpcoming(_seasonId) {
         .sort((a, b) => a.startTimestamp - b.startTimestamp);
 }
 export async function fetchRecent(_seasonId) {
+    if (MOCK)
+        return [];
     const events = await scoreboard(pastRange(1));
     return events
         .map(parseEvent)
@@ -69,7 +103,28 @@ export async function fetchRecent(_seasonId) {
         .sort((a, b) => a.startTimestamp - b.startTimestamp);
 }
 export async function fetchIncidents(eventId) {
+    if (MOCK)
+        return parseIncidents(mockEvent());
     const events = await scoreboard(todayRange(0));
     const event = events.find((e) => Number(e.id) === eventId);
     return event ? parseIncidents(event) : [];
 }
+// Red cards in currently-live matches, drawn from the same scoreboard response
+// fetchLive uses (its details carry cards inline) — so no extra network call.
+export async function fetchLiveRedCards() {
+    if (MOCK)
+        return [];
+    const events = await scoreboard(todayRange(0));
+    const out = [];
+    for (const e of events) {
+        const m = parseEvent(e);
+        if (m.status !== 'live' && m.status !== 'halftime')
+            continue;
+        for (const inc of parseIncidents(e)) {
+            if (inc.kind === 'redCard') {
+                out.push({ id: inc.id, homeCode: m.home.code, awayCode: m.away.code, player: inc.playerShort ?? inc.player ?? '?', minute: inc.minute });
+            }
+        }
+    }
+    return out;
+}

package/dist/index.js

@@ -29,11 +29,52 @@ async function main() {
         await runSetup(args.slice(1));
         process.exit(0);
     }
+    if (args.includes('--mock-goal')) {
+        // Demo trigger for recording: show ARG 1—1 ENG live in the status bar for
+        // ~2s, then Harry Kane scores → 1—2 and a GOOOL celebration for 15s. Writes
+        // to the shared statusline cache, so the bar (which Claude Code repaints on
+        // its timer) plays the sequence. Run e.g. `!claudial --mock-goal` while
+        // recording.
+        const { makeCache } = await import('./statusline/cache.js');
+        const { liveLine } = await import('./statusline/line.js');
+        const cache = makeCache();
+        const base = {
+            id: 9001, group: null,
+            home: { name: 'Argentina', code: 'ARG' }, away: { name: 'England', code: 'ENG' },
+            status: 'live', statusText: '', minute: 78, startTimestamp: 0, varInProgress: false,
+        };
+        cache.write(liveLine({ ...base, homeScore: 1, awayScore: 1 }));
+        process.stdout.write('⚽ mock: ARG 1—1 ENG live… (Kane scores in 2s)\n');
+        await new Promise((r) => setTimeout(r, 2000));
+        const scored = { ...base, homeScore: 1, awayScore: 2 };
+        cache.write(liveLine(scored));
+        cache.armGoal(scored);
+        process.stdout.write('⚽ GOOOL! ARG 1—2 ENG — the status bar celebrates for 15s.\n');
+        process.exit(0);
+    }
+    if (args.includes('--mock-redcard')) {
+        const { makeCache } = await import('./statusline/cache.js');
+        makeCache().armRedCard({ player: 'Otamendi', homeCode: 'ARG', awayCode: 'ENG' });
+        process.stdout.write('🟥 RED armed — the Claude Code status bar flashes a red card (ARG—ENG) for 15s.\n');
+        process.exit(0);
+    }
     if (args.includes('--statusline')) {
         const input = await readStdin();
         const { runStatusline, defaultDeps } = await import('./statusline/run.js');
-        const line = await runStatusline(input, defaultDeps());
-        process.stdout.write(line);
+        let out = await runStatusline(input, defaultDeps());
+        // --wrap '<cmd>': run the user's existing statusline with the same stdin and
+        // prepend its output, so claudial co-exists with their bar instead of replacing it.
+        const w = args.indexOf('--wrap');
+        if (w >= 0 && args[w + 1]) {
+            try {
+                const { execSync } = await import('node:child_process');
+                const theirs = execSync(args[w + 1], { input, encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'], timeout: 2000 }).replace(/\n+$/, '');
+                if (theirs)
+                    out = `${theirs}  ${out}`;
+            }
+            catch { /* their command failed — just show ours */ }
+        }
+        process.stdout.write(out);
         process.exit(0);
     }
     let seasonId;

package/dist/setup/Wizard.js

@@ -1,71 +1,21 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState } from 'react';
 import { Box, Text, useInput, useApp } from 'ink';
 import { ACCENT } from '../ui/Header.js';
-export function Wizard({ defaultShell, allowTmux, onDone }) {
+/**
+ * A single confirmation: install the live-score statusline globally into Claude
+ * Code. No scope or tmux prompts — global is the one supported path.
+ */
+export function Wizard({ defaultShell, onDone }) {
     const { exit } = useApp();
-    const [step, setStep] = useState('statusline');
-    const [statusline, setStatusline] = useState(true);
-    const [scope, setScope] = useState('global');
-    const [tmux, setTmux] = useState(false);
-    const [shell, setShell] = useState(defaultShell);
-    const finish = () => {
-        onDone({ statusline, scope, tmux, shell, yes: true, interactive: false });
-        exit();
-    };
     useInput((input, key) => {
-        const yes = input.toLowerCase() === 'y';
-        const no = input.toLowerCase() === 'n';
-        if (input === 'q') {
+        if (input === 'q' || input.toLowerCase() === 'n') {
             exit();
             return;
         }
-        if (step === 'statusline') {
-            if (yes || key.return) {
-                setStatusline(true);
-                setStep('scope');
-            }
-            else if (no) {
-                setStatusline(false);
-                setStep(allowTmux ? 'tmux' : 'confirm');
-            }
-        }
-        else if (step === 'scope') {
-            if (input === 'g' || key.return) {
-                setScope('global');
-                setStep(allowTmux ? 'tmux' : 'confirm');
-            }
-            else if (input === 'p') {
-                setScope('project');
-                setStep(allowTmux ? 'tmux' : 'confirm');
-            }
-        }
-        else if (step === 'tmux') {
-            if (yes) {
-                setTmux(true);
-                setStep('shell');
-            }
-            else if (no || key.return) {
-                setTmux(false);
-                setStep('confirm');
-            }
-        }
-        else if (step === 'shell') {
-            if (input === 'z')
-                setShell('zsh');
-            else if (input === 'b')
-                setShell('bash');
-            else if (input === 'f')
-                setShell('fish');
-            if (key.return || 'zbf'.includes(input))
-                setStep('confirm');
-        }
-        else if (step === 'confirm') {
-            if (yes || key.return)
-                finish();
-            else if (no)
-                exit();
+        if (key.return || input.toLowerCase() === 'y') {
+            onDone({ statusline: true, scope: 'global', tmux: false, shell: defaultShell, yes: true, interactive: false });
+            exit();
         }
     });
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: _jsx(Text, { bold: true, color: ACCENT, children: "claudial setup" }) }), step === 'statusline' && _jsx(Text, { children: "Add the live-score statusline inside Claude Code? (Y/n)" }), step === 'scope' && _jsx(Text, { children: "Scope \u2014 [g]lobal (~/.claude) or [p]roject (.claude)? (G/p)" }), step === 'tmux' && _jsx(Text, { children: "Also add the tmux ticker alias (claude-mundial)? (y/N)" }), step === 'shell' && _jsxs(Text, { children: ["Shell for the alias \u2014 [z]sh [b]ash [f]ish? (default ", shell, ")"] }), step === 'confirm' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "About to apply:" }), statusline && _jsxs(Text, { dimColor: true, children: ["  \u2022 statusline \u2192 ", scope] }), tmux && _jsxs(Text, { dimColor: true, children: ["  \u2022 tmux alias \u2192 ", shell] }), !statusline && !tmux && _jsx(Text, { dimColor: true, children: "  \u2022 nothing selected" }), _jsx(Text, { children: "Proceed? (Y/n)" })] })), _jsx(Text, { dimColor: true, children: "q to quit" })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: _jsx(Text, { bold: true, color: ACCENT, children: "claudial setup" }) }), _jsx(Text, { children: "Install the live-score statusline into Claude Code? (Y/n)" }), _jsx(Text, { dimColor: true, children: "  \u2022 statusline \u2192 global (~/.claude/settings.json)" }), _jsx(Text, { dimColor: true, children: "q to quit" })] }));
 }

package/dist/setup/apply.js

@@ -1,11 +1,12 @@
 import { installStatusline } from './settings.js';
 import { appendAlias } from './shellrc.js';
 export function applySetup(opts, ctx) {
-    const report = { statuslineWritten: false, statuslineBackedUp: false, aliasAppended: false };
+    const report = { statuslineWritten: false, statuslineBackedUp: false, statuslineWrapped: false, aliasAppended: false };
     if (opts.statusline) {
         const r = installStatusline(ctx.settingsPath, ctx.command, ctx.conflict);
         report.statuslineWritten = r.written;
         report.statuslineBackedUp = r.backedUp;
+        report.statuslineWrapped = r.wrapped;
     }
     if (opts.tmux) {
         report.aliasAppended = appendAlias(ctx.rcPath, ctx.shell).appended;

package/dist/setup/index.js

@@ -3,7 +3,7 @@ import { join } from 'node:path';
 import React from 'react';
 import { render } from 'ink';
 import { parseFlags } from './flags.js';
-import { detectShell, rcPathFor, isOnPath, hasTmux, isWindows } from './detect.js';
+import { detectShell, rcPathFor, isOnPath } from './detect.js';
 import { applySetup } from './apply.js';
 import { Wizard } from './Wizard.js';
 function commandFor() {
@@ -11,9 +11,8 @@ function commandFor() {
 }
 function contextFor(opts) {
     const shell = opts.shell ?? detectShell();
-    const settingsPath = opts.scope === 'project'
-        ? join(process.cwd(), '.claude', 'settings.json')
-        : join(homedir(), '.claude', 'settings.json');
+    // Always global — setup installs the statusline into ~/.claude/settings.json.
+    const settingsPath = join(homedir(), '.claude', 'settings.json');
     return {
         settingsPath,
         rcPath: rcPathFor(shell, homedir()),
@@ -25,6 +24,8 @@ function contextFor(opts) {
 function printReport(opts, ctx, report) {
     if (report.statuslineWritten) {
         console.log(`✓ statusline installed → ${ctx.settingsPath}`);
+        if (report.statuslineWrapped)
+            console.log('  (kept your existing status line and appended the score)');
         if (report.statuslineBackedUp)
             console.log(`  (previous settings backed up to ${ctx.settingsPath}.bak)`);
         console.log('  Restart Claude Code to see the score bar.');
@@ -55,7 +56,6 @@ export async function runSetup(args) {
     await new Promise((resolve) => {
         const { waitUntilExit } = render(React.createElement(Wizard, {
             defaultShell: detectShell(),
-            allowTmux: !isWindows() && hasTmux(),
             onDone: (final) => run(final),
         }));
         waitUntilExit().then(() => resolve());

package/dist/setup/settings.js

@@ -1,7 +1,7 @@
 import { mkdirSync, readFileSync, writeFileSync, copyFileSync, existsSync } from 'node:fs';
 import { dirname } from 'node:path';
 export function statusLineBlock(command) {
-    return { type: 'command', command, refreshInterval: 3 };
+    return { type: 'command', command, refreshInterval: 1 };
 }
 /** Pure merge. Returns the new settings object and whether it changed. */
 export function mergeSettings(existing, block, conflict) {
@@ -11,7 +11,7 @@ export function mergeSettings(existing, block, conflict) {
     }
     return { settings: { ...existing, statusLine: block }, changed: true };
 }
-/** Read → merge → (backup) → write. Creates parent dirs and a .bak. */
+/** Read → (wrap existing) → merge → (backup) → write. Creates parent dirs and a .bak. */
 export function installStatusline(settingsPath, command, conflict) {
     let existing = {};
     const fileExists = existsSync(settingsPath);
@@ -23,9 +23,30 @@ export function installStatusline(settingsPath, command, conflict) {
             existing = {};
         }
     }
-    const { settings, changed } = mergeSettings(existing, statusLineBlock(command), conflict);
+    // Co-exist with a user's existing statusLine: wrap a foreign command so both
+    // show (claudial runs theirs via --wrap and appends the score). If ours is
+    // already there, preserve any --wrap suffix and just refresh the rest.
+    const existingCmd = typeof existing?.statusLine?.command === 'string' ? existing.statusLine.command : '';
+    let finalCommand = command;
+    let wrapped = false;
+    if (existingCmd.includes('claudial --statusline')) {
+        const w = existingCmd.indexOf(' --wrap ');
+        if (w >= 0) {
+            finalCommand = command + existingCmd.slice(w);
+            wrapped = true;
+        }
+    }
+    else if (existingCmd) {
+        finalCommand = `${command} --wrap '${existingCmd.replace(/'/g, `'\\''`)}'`;
+        wrapped = true;
+    }
+    const block = statusLineBlock(finalCommand);
+    if (existing.statusLine && JSON.stringify(existing.statusLine) === JSON.stringify(block)) {
+        return { written: false, backedUp: false, wrapped };
+    }
+    const { settings, changed } = mergeSettings(existing, block, conflict);
     if (!changed)
-        return { written: false, backedUp: false };
+        return { written: false, backedUp: false, wrapped };
     let backedUp = false;
     if (fileExists) {
         copyFileSync(settingsPath, `${settingsPath}.bak`);
@@ -33,5 +54,5 @@ export function installStatusline(settingsPath, command, conflict) {
     }
     mkdirSync(dirname(settingsPath), { recursive: true });
     writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
-    return { written: true, backedUp };
+    return { written: true, backedUp, wrapped };
 }

package/dist/snapshot.js

@@ -1,10 +1,11 @@
 import { fetchLive, fetchRecent, fetchUpcoming } from './api/espn.js';
 import { formatKickoff } from './ui/UpcomingSection.js';
+import { homeTag, awayTag } from './ui/flags.js';
 function line(m) {
     if (m.status === 'upcoming')
-        return `o ${formatKickoff(m.startTimestamp).padEnd(13)} ${m.home.name} - ${m.away.name}`;
+        return `o ${formatKickoff(m.startTimestamp).padEnd(13)} ${homeTag(m.home.code)} - ${awayTag(m.away.code)}`;
     const label = m.status === 'finished' ? 'FT' : m.status === 'halftime' ? 'HT' : `${m.minute ?? '?'}'`;
-    return `* ${label.padEnd(4)} ${m.home.name} ${m.homeScore ?? '-'} - ${m.awayScore ?? '-'} ${m.away.name}`;
+    return `* ${label.padEnd(4)} ${homeTag(m.home.code)} ${m.homeScore ?? '-'} - ${m.awayScore ?? '-'} ${awayTag(m.away.code)}`;
 }
 export async function printSnapshot(seasonId) {
     const [live, upcoming, recent] = await Promise.all([

package/dist/statusline/anim.js

@@ -0,0 +1,18 @@
+// A gentle "goal kick → net" animation for the idle (between-matches) status
+// line. Claude Code repaints the status line on a timer, so one frame shows per
+// repaint — the frame is chosen from wall-clock time so it advances at a steady
+// rate regardless of how often the command happens to be invoked.
+export const FRAME_MS = 1000;
+const FRAMES = [
+    '⚽·····🥅',
+    '·⚽····🥅',
+    '··⚽···🥅',
+    '···⚽··🥅',
+    '····⚽·🥅',
+    '·····⚽🥅',
+    '· G O A L! ·',
+];
+/** The goal-kick animation frame for time `now` (ms); loops continuously. */
+export function goalKickFrame(now = Date.now()) {
+    return FRAMES[Math.floor(now / FRAME_MS) % FRAMES.length];
+}

package/dist/statusline/cache.js

@@ -1,14 +1,20 @@
 import { mkdirSync, openSync, closeSync, writeFileSync, readFileSync, renameSync, statSync, existsSync, unlinkSync, utimesSync, futimesSync, } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { homeTag, awayTag } from '../ui/flags.js';
 export const TTL_MS = 10_000;
 export const GOAL_WINDOW_MS = 15_000;
 const LOCK_STALE_MS = 30_000;
 // ACCENT #D97757 → truecolor; bold. Matches the old bash celebration styling.
 const GOAL_OPEN = '\x1b[1;38;2;217;119;87m';
 const GOAL_CLOSE = '\x1b[0m';
+// RED #E5484D — the red-card flash.
+const RED_OPEN = '\x1b[1;38;2;229;72;77m';
 function goalText(m) {
-    return `${GOAL_OPEN}⚽ G O O O L  ·  ${m.home.code} ${m.homeScore ?? 0}—${m.awayScore ?? 0} ${m.away.code}${GOAL_CLOSE}`;
+    return `${GOAL_OPEN}⚽ G O O O L  ·  ${homeTag(m.home.code)} ${m.homeScore ?? 0}—${m.awayScore ?? 0} ${awayTag(m.away.code)}${GOAL_CLOSE}`;
+}
+function redCardText(rc) {
+    return `${RED_OPEN}🟥 R E D  ·  ${rc.player.toUpperCase()}  ·  ${homeTag(rc.homeCode)} — ${awayTag(rc.awayCode)}${GOAL_CLOSE}`;
 }
 export function makeCache(dir = join(tmpdir(), 'claudial-statusline')) {
     mkdirSync(dir, { recursive: true });
@@ -17,6 +23,9 @@ export function makeCache(dir = join(tmpdir(), 'claudial-statusline')) {
     const stateFile = join(dir, 'goals.json');
     const goalFile = join(dir, 'goal');
     const goalTsFile = join(dir, 'goalts');
+    const redSeenFile = join(dir, 'redseen.json');
+    const redFile = join(dir, 'red');
+    const redTsFile = join(dir, 'redts');
     const atomicWrite = (path, data) => {
         const tmp = `${path}.tmp`;
         writeFileSync(tmp, data);
@@ -94,6 +103,11 @@ export function makeCache(dir = join(tmpdir(), 'claudial-statusline')) {
             }
             atomicWrite(stateFile, JSON.stringify(cur));
         },
+        armGoal(match, now = Date.now()) {
+            // Directly fire a celebration (used by `claudial --mock-goal` for demos).
+            atomicWrite(goalFile, goalText(match));
+            atomicWrite(goalTsFile, String(now));
+        },
         activeGoalLine(now = Date.now()) {
             if (!existsSync(goalTsFile) || !existsSync(goalFile))
                 return null;
@@ -102,5 +116,41 @@ export function makeCache(dir = join(tmpdir(), 'claudial-statusline')) {
                 return null;
             return readFileSync(goalFile, 'utf8');
         },
+        updateRedCards(reds, now = Date.now()) {
+            const firstRun = !existsSync(redSeenFile);
+            const seen = new Set(firstRun ? [] : (() => {
+                try {
+                    return JSON.parse(readFileSync(redSeenFile, 'utf8'));
+                }
+                catch {
+                    return [];
+                }
+            })());
+            let armed = false;
+            for (const rc of reds) {
+                if (seen.has(rc.id))
+                    continue;
+                // First run never fires (don't replay pre-existing reds when first seen mid-match).
+                if (!firstRun && !armed) {
+                    atomicWrite(redFile, redCardText(rc));
+                    atomicWrite(redTsFile, String(now));
+                    armed = true;
+                }
+                seen.add(rc.id);
+            }
+            atomicWrite(redSeenFile, JSON.stringify([...seen]));
+        },
+        armRedCard(rc, now = Date.now()) {
+            atomicWrite(redFile, redCardText(rc));
+            atomicWrite(redTsFile, String(now));
+        },
+        activeRedCardLine(now = Date.now()) {
+            if (!existsSync(redTsFile) || !existsSync(redFile))
+                return null;
+            const ts = Number(readFileSync(redTsFile, 'utf8'));
+            if (!Number.isFinite(ts) || now - ts > GOAL_WINDOW_MS)
+                return null;
+            return readFileSync(redFile, 'utf8');
+        },
     };
 }

package/dist/statusline/line.js

@@ -1,21 +1,22 @@
 import { formatKickoff } from '../ui/UpcomingSection.js';
+import { homeTag, awayTag } from '../ui/flags.js';
 // Assumed wall-clock length of a match (kickoff → ~full time). ESPN exposes no
 // end-time, so a finished match is anchored at kickoff + this for proximity math.
 const MATCH_MS = 2 * 60 * 60 * 1000;
-/** A live/halftime match: "⚽ QAT 0—1 SUI 67'" (em-dash U+2014 between scores). */
+/** A live/halftime match: "⚽ QAT 🇶🇦 0—1 🇨🇭 SUI 67'" (mirrored code+flag). */
 export function liveLine(match) {
     const clock = match.status === 'halftime' ? ' HT'
         : match.minute != null ? ` ${match.minute}'`
             : '';
-    return `⚽ ${match.home.code} ${match.homeScore ?? 0}—${match.awayScore ?? 0} ${match.away.code}${clock}`;
+    return `⚽ ${homeTag(match.home.code)} ${match.homeScore ?? 0}—${match.awayScore ?? 0} ${awayTag(match.away.code)}${clock}`;
 }
-/** A finished match with its result: "⚽ QAT 2—1 SUI FT". */
+/** A finished match with its result: "⚽ QAT 🇶🇦 2—1 🇨🇭 SUI FT". */
 export function finishedLine(match) {
-    return `⚽ ${match.home.code} ${match.homeScore ?? 0}—${match.awayScore ?? 0} ${match.away.code} FT`;
+    return `⚽ ${homeTag(match.home.code)} ${match.homeScore ?? 0}—${match.awayScore ?? 0} ${awayTag(match.away.code)} FT`;
 }
-/** The next kickoff: "○ BRA—MOR Sun 01:00". */
+/** The next kickoff: "○ BRA 🇧🇷 — 🇲🇦 MAR Sun 01:00". */
 function upcomingLine(match, now) {
-    return `○ ${match.home.code}—${match.away.code} ${formatKickoff(match.startTimestamp, now)}`;
+    return `○ ${homeTag(match.home.code)} — ${awayTag(match.away.code)} ${formatKickoff(match.startTimestamp, now)}`;
 }
 /**
  * Live matches joined by two spaces. Otherwise show whichever moment is closer

package/dist/statusline/run.js

@@ -1,7 +1,8 @@
 import { execFileSync } from 'node:child_process';
-import { fetchLive as realFetchLive, fetchRecent as realFetchRecent, fetchUpcoming as realFetchUpcoming } from '../api/espn.js';
+import { fetchLive as realFetchLive, fetchRecent as realFetchRecent, fetchUpcoming as realFetchUpcoming, fetchLiveRedCards as realFetchLiveRedCards } from '../api/espn.js';
 import { scoreLine } from './line.js';
 import { makeCache, TTL_MS } from './cache.js';
+import { goalKickFrame } from './anim.js';
 const PLACEHOLDER = '⚽ claudial · warming up';
 function withTimeout(p, ms) {
     let id;
@@ -17,9 +18,10 @@ export async function runStatusline(input, deps, now = Date.now()) {
     const fresh = cached != null && cached.ageMs <= TTL_MS;
     if (!fresh && cache.tryLock(now)) {
         try {
-            const [liveM, recentM, upcomingM] = await withTimeout(Promise.all([deps.fetchLive(), deps.fetchRecent(), deps.fetchUpcoming(2026)]), deps.timeoutMs);
+            const [liveM, recentM, upcomingM, redsM] = await withTimeout(Promise.all([deps.fetchLive(), deps.fetchRecent(), deps.fetchUpcoming(2026), deps.fetchRedCards()]), deps.timeoutMs);
             const next = scoreLine(liveM, recentM, upcomingM, now);
             cache.updateGoalState(liveM, now);
+            cache.updateRedCards(redsM, now);
             if (next) {
                 cache.write(next, now);
                 line = next;
@@ -32,7 +34,10 @@ export async function runStatusline(input, deps, now = Date.now()) {
             cache.unlock();
         }
     }
-    const score = cache.activeGoalLine(now) ?? line ?? PLACEHOLDER;
+    const goal = cache.activeGoalLine(now);
+    const red = cache.activeRedCardLine(now);
+    // Goal → animated kick; red card → static flash; otherwise the idle/live line.
+    const score = goal ? `${goalKickFrame(now)}  ${goal}` : (red ?? line ?? PLACEHOLDER);
     const branch = deps.branchOf(input);
     return branch ? `${score} · ${branch}` : score;
 }
@@ -61,6 +66,7 @@ export function defaultDeps() {
         fetchLive: realFetchLive,
         fetchRecent: () => realFetchRecent(2026),
         fetchUpcoming: realFetchUpcoming,
+        fetchRedCards: realFetchLiveRedCards,
         cache: makeCache(),
         branchOf: defaultBranchOf,
         timeoutMs: 3000,

package/dist/ui/MatchRow.js

@@ -2,6 +2,7 @@ import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { ACCENT } from './Header.js';
 import { formatKickoff } from './UpcomingSection.js';
+import { homeTag, awayTag } from './flags.js';
 export function ScorerLine({ incidents }) {
     const goals = incidents.filter((i) => i.kind === 'goal');
     if (goals.length === 0)
@@ -32,12 +33,12 @@ function statusLabel(m) {
 export function MatchRow({ m, incidents, compact }) {
     if (m.status === 'upcoming') {
         if (compact) {
-            return _jsxs(Text, { dimColor: true, children: ["\u25CB ", m.home.code, "\u2014", m.away.code, " ", formatKickoff(m.startTimestamp)] });
+            return _jsxs(Text, { dimColor: true, children: ["\u25CB ", homeTag(m.home.code), " \u2014 ", awayTag(m.away.code), " ", formatKickoff(m.startTimestamp)] });
         }
-        return (_jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: ["\u25CB ", formatKickoff(m.startTimestamp).padEnd(13)] }), m.home.name, " \u2014 ", m.away.name, m.group ? _jsxs(Text, { dimColor: true, children: ["  \u00B7  ", m.group] }) : null] }));
+        return (_jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: ["\u25CB ", formatKickoff(m.startTimestamp).padEnd(13)] }), homeTag(m.home.code), " \u2014 ", awayTag(m.away.code), m.group ? _jsxs(Text, { dimColor: true, children: ["  \u00B7  ", m.group] }) : null] }));
     }
     if (compact) {
-        return (_jsxs(Text, { children: [_jsx(Text, { color: m.status === 'finished' ? undefined : ACCENT, children: "\u23FA" }), _jsxs(Text, { dimColor: true, children: [" ", statusLabel(m), " "] }), m.home.code, " ", _jsxs(Text, { bold: true, color: ACCENT, children: [m.homeScore ?? '–', "\u2014", m.awayScore ?? '–'] }), " ", m.away.code, m.varInProgress ? _jsx(Text, { dimColor: true, children: " \u2696" }) : null] }));
+        return (_jsxs(Text, { children: [_jsx(Text, { color: m.status === 'finished' ? undefined : ACCENT, children: "\u23FA" }), _jsxs(Text, { dimColor: true, children: [" ", statusLabel(m), " "] }), homeTag(m.home.code), " ", _jsxs(Text, { bold: true, color: ACCENT, children: [m.homeScore ?? '–', "\u2014", m.awayScore ?? '–'] }), " ", awayTag(m.away.code), m.varInProgress ? _jsx(Text, { dimColor: true, children: " \u2696" }) : null] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { children: [_jsx(Text, { color: m.status === 'finished' ? undefined : ACCENT, children: "\u23FA" }), _jsxs(Text, { bold: m.status !== 'finished', dimColor: m.status === 'finished', children: [" ", statusLabel(m)] }), m.group ? _jsxs(Text, { dimColor: true, children: ["  \u00B7  ", m.group] }) : null, m.varInProgress ? _jsx(Text, { dimColor: true, children: "  \u00B7  \u2696 VAR" }) : null] }), _jsxs(Text, { children: ['   ', m.home.name, "  ", _jsxs(Text, { bold: true, color: ACCENT, children: [m.homeScore ?? '–', " \u2014 ", m.awayScore ?? '–'] }), "  ", m.away.name] }), _jsx(ScorerLine, { incidents: incidents }), _jsx(FeedLine, { incidents: incidents })] }));
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { children: [_jsx(Text, { color: m.status === 'finished' ? undefined : ACCENT, children: "\u23FA" }), _jsxs(Text, { bold: m.status !== 'finished', dimColor: m.status === 'finished', children: [" ", statusLabel(m)] }), m.group ? _jsxs(Text, { dimColor: true, children: ["  \u00B7  ", m.group] }) : null, m.varInProgress ? _jsx(Text, { dimColor: true, children: "  \u00B7  \u2696 VAR" }) : null] }), _jsxs(Text, { children: ['   ', homeTag(m.home.code), "  ", _jsxs(Text, { bold: true, color: ACCENT, children: [m.homeScore ?? '–', " \u2014 ", m.awayScore ?? '–'] }), "  ", awayTag(m.away.code)] }), _jsx(ScorerLine, { incidents: incidents }), _jsx(FeedLine, { incidents: incidents })] }));
 }

package/dist/ui/TakeoverView.js

@@ -2,6 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { GOAL_ART, VAR_ART, RED_CARD_ART, spacedCaps } from '../banner.js';
 import { ACCENT, RED } from './Header.js';
+import { homeTag, awayTag } from './flags.js';
 const ART = {
     goal: { art: GOAL_ART, color: ACCENT, caption: null },
     redcard: { art: RED_CARD_ART, color: RED, caption: 'R E D   C A R D' },
@@ -16,7 +17,7 @@ export function TakeoverView({ takeover }) {
     const rows = process.stdout.rows ?? 24;
     if (rows < 14) {
         const label = kind === 'goal' ? 'G O A L' : kind === 'redcard' ? 'R E D   C A R D' : 'V A R';
-        return (_jsxs(Box, { flexDirection: "column", alignItems: "center", justifyContent: "center", height: rows - 1, children: [_jsx(Text, { bold: true, color: color, wrap: "truncate", children: label }), _jsxs(Text, { bold: true, wrap: "truncate", children: [spacedCaps(fallback), takeover.minute != null ? _jsxs(Text, { dimColor: true, children: ["  \u00B7  ", takeover.minute, "'"] }) : null] }), takeover.detail ? _jsx(Text, { dimColor: true, wrap: "truncate", children: takeover.detail }) : null, _jsxs(Text, { wrap: "truncate", children: [_jsxs(Text, { dimColor: true, children: [match.home.name.toUpperCase(), "  "] }), _jsxs(Text, { bold: true, color: ACCENT, children: [takeover.homeScore, " \u2014 ", takeover.awayScore] }), _jsxs(Text, { dimColor: true, children: ["  ", match.away.name.toUpperCase()] })] })] }));
+        return (_jsxs(Box, { flexDirection: "column", alignItems: "center", justifyContent: "center", height: rows - 1, children: [_jsx(Text, { bold: true, color: color, wrap: "truncate", children: label }), _jsxs(Text, { bold: true, wrap: "truncate", children: [spacedCaps(fallback), takeover.minute != null ? _jsxs(Text, { dimColor: true, children: ["  \u00B7  ", takeover.minute, "'"] }) : null] }), takeover.detail ? _jsx(Text, { dimColor: true, wrap: "truncate", children: takeover.detail }) : null, _jsxs(Text, { wrap: "truncate", children: [_jsxs(Text, { dimColor: true, children: [homeTag(match.home.code), "  "] }), _jsxs(Text, { bold: true, color: ACCENT, children: [takeover.homeScore, " \u2014 ", takeover.awayScore] }), _jsxs(Text, { dimColor: true, children: ["  ", awayTag(match.away.code)] })] })] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", alignItems: "center", justifyContent: "center", height: rows - 1, children: [art.map((line, i) => (_jsx(Text, { bold: true, color: color, wrap: "truncate", children: line }, i))), caption ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { bold: true, color: color, wrap: "truncate", children: caption }) })) : null, _jsx(Box, { marginTop: 1, children: _jsxs(Text, { bold: true, children: [spacedCaps(fallback), takeover.minute != null ? _jsxs(Text, { dimColor: true, children: ["  \u00B7  ", takeover.minute, "'"] }) : null] }) }), takeover.detail ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: takeover.detail }) })) : null, _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { dimColor: true, children: [match.home.name.toUpperCase(), "  "] }), _jsxs(Text, { bold: true, color: ACCENT, children: [takeover.homeScore, " \u2014 ", takeover.awayScore] }), _jsxs(Text, { dimColor: true, children: ["  ", match.away.name.toUpperCase()] })] })] }));
+    return (_jsxs(Box, { flexDirection: "column", alignItems: "center", justifyContent: "center", height: rows - 1, children: [art.map((line, i) => (_jsx(Text, { bold: true, color: color, wrap: "truncate", children: line }, i))), caption ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { bold: true, color: color, wrap: "truncate", children: caption }) })) : null, _jsx(Box, { marginTop: 1, children: _jsxs(Text, { bold: true, children: [spacedCaps(fallback), takeover.minute != null ? _jsxs(Text, { dimColor: true, children: ["  \u00B7  ", takeover.minute, "'"] }) : null] }) }), takeover.detail ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: takeover.detail }) })) : null, _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { dimColor: true, children: [homeTag(match.home.code), "  "] }), _jsxs(Text, { bold: true, color: ACCENT, children: [takeover.homeScore, " \u2014 ", takeover.awayScore] }), _jsxs(Text, { dimColor: true, children: ["  ", awayTag(match.away.code)] })] })] }));
 }

package/dist/ui/Ticker.js

@@ -3,13 +3,14 @@ import { Box, Text } from 'ink';
 import { formatKickoff } from './UpcomingSection.js';
 import { ACCENT, RED } from './Header.js';
 import { spacedCaps } from '../banner.js';
+import { homeTag, awayTag } from './flags.js';
 function TickerTakeover({ t }) {
     const color = t.kind === 'redcard' ? RED : ACCENT;
     const label = t.kind === 'goal' ? 'G O A L' : t.kind === 'redcard' ? 'R E D' : 'V A R';
-    return (_jsxs(Text, { bold: true, color: color, wrap: "truncate", children: [label, " \u00B7 ", t.who ? spacedCaps(t.who) : t.detail ?? '', " \u00B7 ", t.match.home.code, " ", t.homeScore, "\u2014", t.awayScore, " ", t.match.away.code] }));
+    return (_jsxs(Text, { bold: true, color: color, wrap: "truncate", children: [label, " \u00B7 ", t.who ? spacedCaps(t.who) : t.detail ?? '', " \u00B7 ", homeTag(t.match.home.code), " ", t.homeScore, "\u2014", t.awayScore, " ", awayTag(t.match.away.code)] }));
 }
 export function Ticker({ live, upcoming, takeover }) {
     if (takeover)
         return _jsx(TickerTakeover, { t: takeover });
-    return (_jsxs(Box, { flexDirection: "column", children: [live.slice(0, 3).map((m) => (_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: ACCENT, children: "\u23FA" }), _jsxs(Text, { dimColor: true, children: [" ", m.minute != null ? `${m.minute}'` : m.status === 'halftime' ? 'HT' : m.status === 'finished' ? 'FT' : '', " "] }), m.home.code, " ", _jsxs(Text, { bold: true, color: ACCENT, children: [m.homeScore ?? '–', "\u2014", m.awayScore ?? '–'] }), " ", m.away.code, m.varInProgress ? _jsx(Text, { dimColor: true, children: " \u2696" }) : null] }, m.id))), upcoming[0] ? (_jsxs(Text, { dimColor: true, wrap: "truncate", children: ["\u25CB ", upcoming[0].home.code, "\u2014", upcoming[0].away.code, " ", formatKickoff(upcoming[0].startTimestamp)] })) : null] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [live.slice(0, 3).map((m) => (_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: ACCENT, children: "\u23FA" }), _jsxs(Text, { dimColor: true, children: [" ", m.minute != null ? `${m.minute}'` : m.status === 'halftime' ? 'HT' : m.status === 'finished' ? 'FT' : '', " "] }), homeTag(m.home.code), " ", _jsxs(Text, { bold: true, color: ACCENT, children: [m.homeScore ?? '–', "\u2014", m.awayScore ?? '–'] }), " ", awayTag(m.away.code), m.varInProgress ? _jsx(Text, { dimColor: true, children: " \u2696" }) : null] }, m.id))), upcoming[0] ? (_jsxs(Text, { dimColor: true, wrap: "truncate", children: ["\u25CB ", homeTag(upcoming[0].home.code), " \u2014 ", awayTag(upcoming[0].away.code), " ", formatKickoff(upcoming[0].startTimestamp)] })) : null] }));
 }

package/dist/ui/UpcomingSection.js

@@ -1,5 +1,6 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
+import { homeTag, awayTag } from './flags.js';
 export function formatKickoff(ts, now = Date.now()) {
     const d = new Date(ts * 1000);
     const time = d.toLocaleTimeString(undefined, { hour: '2-digit', minute: '2-digit' });
@@ -15,7 +16,7 @@ export function UpcomingSection({ matches, compact }) {
         return null;
     if (compact) {
         const m = shown[0];
-        return (_jsxs(Text, { dimColor: true, children: ["\u25CB ", m.home.code, "\u2014", m.away.code, " ", formatKickoff(m.startTimestamp)] }));
+        return (_jsxs(Text, { dimColor: true, children: ["\u25CB ", homeTag(m.home.code), " \u2014 ", awayTag(m.away.code), " ", formatKickoff(m.startTimestamp)] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { dimColor: true, children: "UPCOMING" }), shown.map((m) => (_jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: ["\u25CB ", formatKickoff(m.startTimestamp).padEnd(13)] }), m.home.name, " \u2014 ", m.away.name, m.group ? _jsxs(Text, { dimColor: true, children: ["  \u00B7  ", m.group] }) : null] }, m.id)))] }));
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { dimColor: true, children: "UPCOMING" }), shown.map((m) => (_jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: ["\u25CB ", formatKickoff(m.startTimestamp).padEnd(13)] }), homeTag(m.home.code), " \u2014 ", awayTag(m.away.code), m.group ? _jsxs(Text, { dimColor: true, children: ["  \u00B7  ", m.group] }) : null] }, m.id)))] }));
 }

package/dist/ui/flags.js

@@ -0,0 +1,43 @@
+// Country flag emoji for a team, keyed on ESPN's 3-letter abbreviation
+// (verified against the live FIFA World Cup feed — note ESPN uses MAR for
+// Morocco). Bracket placeholders (1A, QFW1, RD16 W1, …) have no flag.
+// ESPN abbreviation → ISO 3166-1 alpha-2.
+const ISO2 = {
+    ALG: 'DZ', ARG: 'AR', AUS: 'AU', AUT: 'AT', BEL: 'BE', BIH: 'BA', BRA: 'BR',
+    CAN: 'CA', CIV: 'CI', COD: 'CD', COL: 'CO', CPV: 'CV', CRO: 'HR', CUW: 'CW',
+    CZE: 'CZ', ECU: 'EC', EGY: 'EG', ESP: 'ES', FRA: 'FR', GER: 'DE', GHA: 'GH',
+    HAI: 'HT', IRN: 'IR', IRQ: 'IQ', JOR: 'JO', JPN: 'JP', KOR: 'KR', KSA: 'SA',
+    MAR: 'MA', MEX: 'MX', NED: 'NL', NOR: 'NO', NZL: 'NZ', PAN: 'PA', PAR: 'PY',
+    POR: 'PT', QAT: 'QA', RSA: 'ZA', SEN: 'SN', SUI: 'CH', SWE: 'SE', TUN: 'TN',
+    TUR: 'TR', URU: 'UY', USA: 'US', UZB: 'UZ',
+};
+// Home nations have no ISO2 flag — use the subdivision tag sequence.
+const SUBDIVISION = {
+    ENG: 'gbeng', SCO: 'gbsct', WAL: 'gbwls',
+};
+function regionalIndicator(iso2) {
+    return String.fromCodePoint(...[...iso2].map((c) => 0x1f1e6 + (c.charCodeAt(0) - 65)));
+}
+function subdivisionFlag(sub) {
+    return String.fromCodePoint(0x1f3f4, ...[...sub].map((c) => 0xe0000 + c.charCodeAt(0)), 0xe007f);
+}
+/** Flag emoji for a team code, or '' if unknown (e.g. bracket placeholders). */
+export function flagFor(code) {
+    const iso2 = ISO2[code];
+    if (iso2)
+        return regionalIndicator(iso2);
+    const sub = SUBDIVISION[code];
+    if (sub)
+        return subdivisionFlag(sub);
+    return '';
+}
+/** Home side: "QAT 🇶🇦" (flag trails the code), or just the code if unmapped. */
+export function homeTag(code) {
+    const f = flagFor(code);
+    return f ? `${code} ${f}` : code;
+}
+/** Away side: "🇨🇭 SUI" (flag leads the code), or just the code if unmapped. */
+export function awayTag(code) {
+    const f = flagFor(code);
+    return f ? `${f} ${code}` : code;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudial",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Live World Cup 2026 fixtures in your terminal — goal, red-card and VAR takeovers included",
   "type": "module",
   "bin": {
@@ -13,7 +13,7 @@
     "node": ">=18.18"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc",
+    "build": "rm -rf dist && tsc && chmod +x dist/index.js",
     "dev": "tsx src/index.tsx",
     "test": "vitest run",
     "prepublishOnly": "npm run build"