claudial 0.4.0 → 0.6.0

package/README.md

@@ -2,12 +2,13 @@
 
 # ⚽ 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.
+One command. Every World Cup score, in your terminal and right inside Claude
+Code, while you work.
 
 ```
-npx claudial
+npm install -g claudial && claudial setup
 ```
 
 <br/>
@@ -24,45 +25,14 @@ npx claudial
 
 ---
 
-Live matches with scores, minutes and scorers on top. Upcoming fixtures in
-your local time below. Auto-refreshing while you work.
-
-```
- ▐▛███▜▌   WORLD CUP 2026 · LIVE
- ▝▜█████▛▘  ───────────────────────
-
- ⏺ LIVE 67'
-   ARG 🇦🇷  2 — 1  🇲🇽 MEX
-   ⚽ 23' Messi · 51' Álvarez | 44' Lozano
-
- ⏺ LIVE 12'
-   FRA 🇫🇷  0 — 0  🇸🇳 SEN
-
- ○ UPCOMING
-   18:00  BRA 🇧🇷 — 🇭🇷 CRO
-   21:00  ESP 🇪🇸 — 🇲🇦 MAR
-
- r refresh · q quit
-```
-
-And when a goal goes in — anywhere in the tournament — the whole screen
-takes over:
-
-```
-
-
-      █▀▀█  █▀▀█  █▀▀█  █
-      █ ▄▄  █  █  █▀▀█  █
-      ▀▀▀▀  ▀▀▀▀  ▀  ▀  ▀▀▀▀
-
-         LIONEL MESSI · 23'
-
-      ARG 🇦🇷  2 — 1  🇲🇽 MEX
+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:
 
+<div align="center">
 
-```
+![claudial — live World Cup 2026 scores in Claude Code's status bar](demo.gif)
 
-Four seconds of glory, then back to the board.
+</div>
 
 ## Claude Code, World Cup edition
 
@@ -81,17 +51,40 @@ The wizard drops a live-score statusline into your Claude Code settings:
 ⚽ 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
 ```
 
 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`.
 
-## Why a TUI
+**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 full dashboard
+
+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:
+
+```
+
+
+      █▀▀█  █▀▀█  █▀▀█  █
+      █ ▄▄  █  █  █▀▀█  █
+      ▀▀▀▀  ▀▀▀▀  ▀  ▀  ▀▀▀▀
+
+         LIONEL MESSI · 23'
+
+      ARG 🇦🇷  2 — 1  🇲🇽 MEX
+
+
+```
 
-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
 
@@ -115,9 +108,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
 
@@ -125,6 +118,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/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

@@ -8,9 +8,14 @@ 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  ·  ${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 });
     const cacheFile = join(dir, 'line');
@@ -18,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);
@@ -95,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;
@@ -103,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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudial",
-  "version": "0.4.0",
+  "version": "0.6.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"