claudial 0.2.1 → 0.4.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Wim Iliano
+Copyright (c) 2026 lefProg
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,11 +1,29 @@
-# claudial
+<div align="center">
 
-Live World Cup 2026 fixtures in your terminal. One line, zero install:
+# ⚽ claudial
+
+### Live World Cup 2026 in your terminal — goal, red-card and VAR takeovers included
+
+One line. Zero install. Every score, while you work.
 
 ```
 npx claudial
 ```
 
+<br/>
+
+[![npm version](https://img.shields.io/npm/v/claudial?style=flat-square&color=CB3837&logo=npm)](https://www.npmjs.com/package/claudial)
+[![npm downloads](https://img.shields.io/npm/dm/claudial?style=flat-square&color=CB3837&logo=npm)](https://www.npmjs.com/package/claudial)
+[![node](https://img.shields.io/node/v/claudial?style=flat-square&color=339933&logo=node.js&logoColor=white)](https://nodejs.org)
+[![license](https://img.shields.io/npm/l/claudial?style=flat-square&color=blue)](LICENSE)
+[![TypeScript](https://img.shields.io/badge/TypeScript-strict-3178C6?style=flat-square&logo=typescript&logoColor=white)](tsconfig.json)
+[![GitHub stars](https://img.shields.io/github/stars/lefProg/claudial?style=flat-square&color=f5c518&logo=github)](https://github.com/lefProg/claudial/stargazers)
+[![PRs welcome](https://img.shields.io/badge/PRs-welcome-brightgreen?style=flat-square)](https://github.com/lefProg/claudial/issues)
+
+</div>
+
+---
+
 Live matches with scores, minutes and scorers on top. Upcoming fixtures in
 your local time below. Auto-refreshing while you work.
 
@@ -14,15 +32,15 @@ your local time below. Auto-refreshing while you work.
  ▝▜█████▛▘  ───────────────────────
 
  ⏺ LIVE 67'
-   Argentina  2 — 1  Mexico
+   ARG 🇦🇷  2 — 1  🇲🇽 MEX
    ⚽ 23' Messi · 51' Álvarez | 44' Lozano
 
  ⏺ LIVE 12'
-   France  0 — 0  Senegal
+   FRA 🇫🇷  0 — 0  🇸🇳 SEN
 
  ○ UPCOMING
-   18:00  Brazil — Croatia
-   21:00  Spain — Morocco
+   18:00  BRA 🇧🇷 — 🇭🇷 CRO
+   21:00  ESP 🇪🇸 — 🇲🇦 MAR
 
  r refresh · q quit
 ```
@@ -39,7 +57,7 @@ takes over:
 
          LIONEL MESSI · 23'
 
-      ARGENTINA  2 — 1  MEXICO
+      ARG 🇦🇷  2 — 1  🇲🇽 MEX
 
 
 ```
@@ -48,42 +66,26 @@ Four seconds of glory, then back to the board.
 
 ## Claude Code, World Cup edition
 
-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.
-
-Needs [tmux](https://github.com/tmux/tmux) (`sudo pacman -S tmux` /
-`sudo apt install tmux` / `brew install tmux`), then:
+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
-cat >> ~/.zshrc <<'EOF'
-alias claude-mundial="tmux new-session 'claude' \; split-window -v -l 5 'claudial --ticker' \; select-pane -U"
-EOF
+claudial setup
 ```
 
-Open a new shell, type `claude-mundial`, and:
+The wizard drops a live-score statusline into your Claude Code settings:
 
 ```
-┌──────────────────────────────────────┐
-│ > implement the parser               │
-│                                      │
-│ ⏺ Working…                           │
-│                                      │
-├──────────────────────────────────────┤
-│ ⏺ 67' QAT 0—1 SUI                    │
-│ ○ BRA—MOR Sun 01:00                  │
-└──────────────────────────────────────┘
+⚽ 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
 ```
 
-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.)
-
-Want the score *inside* Claude Code itself — in its status bar, no tmux at
-all? There's a [statusline integration](extras/statusline/) for that:
-`⚽ QAT 0—1 SUI 67' · main`, refreshed every 15 s.
+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
 
@@ -108,10 +110,10 @@ claudial
 
 Requires Node ≥ 18. No account, no API key, no config.
 
-| Key | Action  |
-|-----|---------|
+| Key | Action      |
+|-----|-------------|
 | `r` | refresh now |
-| `q` | quit    |
+| `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.
@@ -139,6 +141,31 @@ v1 is being built live during the group stage. Follow the commits.
 // up in a smoke test before any UI existed to celebrate it. Legendary.
 ```
 
+## Contributing
+
+Issues and PRs welcome — bug reports, new incident types, terminal quirks,
+all of it. Keep the polling gentle and the spirit playful.
+
+```bash
+git clone https://github.com/lefProg/claudial.git
+cd claudial
+npm install
+npm run dev     # live TUI from source
+npm test        # vitest
+```
+
 ## License
 
-MIT
+[MIT](LICENSE) © lefProg
+
+<div align="center">
+
+<br/>
+
+**If this made a goal feel a little louder, drop a ⭐ — it helps others find it.**
+
+[Report a bug](https://github.com/lefProg/claudial/issues) ·
+[Request a feature](https://github.com/lefProg/claudial/issues) ·
+[npm](https://www.npmjs.com/package/claudial)
+
+</div>

package/dist/api/espn.js

@@ -40,6 +40,12 @@ function todayRange(daysAhead) {
     const end = new Date(now.getTime() + daysAhead * 86_400_000);
     return `${start}-${yyyymmdd(end)}`;
 }
+// Past date range "YYYYMMDD-YYYYMMDD" from (today - daysBack) through today (UTC).
+export function pastRange(daysBack, now = Date.now()) {
+    const end = new Date(now);
+    const start = new Date(now - daysBack * 86_400_000);
+    return `${yyyymmdd(start)}-${yyyymmdd(end)}`;
+}
 // Kept for call-site compatibility; ESPN needs no season id to query.
 export async function resolveSeasonId() {
     return 2026;
@@ -56,8 +62,11 @@ export async function fetchUpcoming(_seasonId) {
         .sort((a, b) => a.startTimestamp - b.startTimestamp);
 }
 export async function fetchRecent(_seasonId) {
-    const events = await scoreboard(todayRange(0));
-    return events.map(parseEvent).filter((m) => m.status === 'finished');
+    const events = await scoreboard(pastRange(1));
+    return events
+        .map(parseEvent)
+        .filter((m) => m.status === 'finished')
+        .sort((a, b) => a.startTimestamp - b.startTimestamp);
 }
 export async function fetchIncidents(eventId) {
     const events = await scoreboard(todayRange(0));

package/dist/index.js

@@ -9,7 +9,33 @@ process.stdout.on('error', (err) => {
         process.exit(0);
     throw err;
 });
+function readStdin() {
+    return new Promise((resolve) => {
+        if (process.stdin.isTTY) {
+            resolve('');
+            return;
+        }
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (c) => { data += c; });
+        process.stdin.on('end', () => resolve(data));
+        process.stdin.on('error', () => resolve(data));
+    });
+}
 async function main() {
+    const args = process.argv.slice(2);
+    if (args[0] === 'setup') {
+        const { runSetup } = await import('./setup/index.js');
+        await runSetup(args.slice(1));
+        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);
+        process.exit(0);
+    }
     let seasonId;
     try {
         seasonId = await resolveSeasonId();

package/dist/setup/Wizard.js

@@ -0,0 +1,71 @@
+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 }) {
+    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') {
+            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();
+        }
+    });
+    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" })] }));
+}

package/dist/setup/apply.js

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

package/dist/setup/detect.js

@@ -0,0 +1,34 @@
+import { execFileSync } from 'node:child_process';
+import { join } from 'node:path';
+export function detectShell(env = process.env) {
+    const s = env.SHELL ?? '';
+    if (s.includes('zsh'))
+        return 'zsh';
+    if (s.includes('fish'))
+        return 'fish';
+    return 'bash';
+}
+export function rcPathFor(shell, home) {
+    if (shell === 'zsh')
+        return join(home, '.zshrc');
+    if (shell === 'fish')
+        return join(home, '.config', 'fish', 'config.fish');
+    return join(home, '.bashrc');
+}
+export function isWindows(platform = process.platform) {
+    return platform === 'win32';
+}
+/** True if `bin` resolves on PATH (so settings can use the bare command). */
+export function isOnPath(bin) {
+    const probe = process.platform === 'win32' ? 'where' : 'which';
+    try {
+        execFileSync(probe, [bin], { stdio: ['ignore', 'ignore', 'ignore'] });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function hasTmux() {
+    return isOnPath('tmux');
+}

package/dist/setup/flags.js

@@ -0,0 +1,18 @@
+const SHELLS = ['zsh', 'bash', 'fish'];
+export function parseFlags(args) {
+    const has = (f) => args.includes(f);
+    const shellArg = args[args.indexOf('--shell') + 1];
+    const shell = SHELLS.includes(shellArg) ? shellArg : null;
+    const statusline = has('--statusline');
+    const tmux = has('--tmux');
+    // any actionable flag (or --yes) means run without prompting
+    const interactive = !(statusline || tmux || has('--yes'));
+    return {
+        statusline,
+        scope: has('--project') ? 'project' : 'global',
+        tmux,
+        shell,
+        yes: has('--yes'),
+        interactive,
+    };
+}

package/dist/setup/index.js

@@ -0,0 +1,63 @@
+import { homedir } from 'node:os';
+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 { applySetup } from './apply.js';
+import { Wizard } from './Wizard.js';
+function commandFor() {
+    return isOnPath('claudial') ? 'claudial --statusline' : 'npx claudial --statusline';
+}
+function contextFor(opts) {
+    const shell = opts.shell ?? detectShell();
+    const settingsPath = opts.scope === 'project'
+        ? join(process.cwd(), '.claude', 'settings.json')
+        : join(homedir(), '.claude', 'settings.json');
+    return {
+        settingsPath,
+        rcPath: rcPathFor(shell, homedir()),
+        shell,
+        command: commandFor(),
+        conflict: 'overwrite',
+    };
+}
+function printReport(opts, ctx, report) {
+    if (report.statuslineWritten) {
+        console.log(`✓ statusline installed → ${ctx.settingsPath}`);
+        if (report.statuslineBackedUp)
+            console.log(`  (previous settings backed up to ${ctx.settingsPath}.bak)`);
+        console.log('  Restart Claude Code to see the score bar.');
+    }
+    else if (opts.statusline) {
+        console.log('• statusline unchanged (an existing statusLine was kept).');
+    }
+    if (report.aliasAppended) {
+        console.log(`✓ tmux alias added → ${ctx.rcPath}`);
+        console.log(`  Open a new shell, then run: claude-mundial`);
+    }
+    else if (opts.tmux) {
+        console.log('• tmux alias already present — left as-is.');
+    }
+    if (!opts.statusline && !opts.tmux)
+        console.log('Nothing selected. Run `claudial setup` again to choose options.');
+}
+export async function runSetup(args) {
+    const opts = parseFlags(args);
+    const run = (final) => {
+        const ctx = contextFor(final);
+        printReport(final, ctx, applySetup(final, ctx));
+    };
+    if (!opts.interactive) {
+        run(opts);
+        return;
+    }
+    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

@@ -0,0 +1,37 @@
+import { mkdirSync, readFileSync, writeFileSync, copyFileSync, existsSync } from 'node:fs';
+import { dirname } from 'node:path';
+export function statusLineBlock(command) {
+    return { type: 'command', command, refreshInterval: 3 };
+}
+/** Pure merge. Returns the new settings object and whether it changed. */
+export function mergeSettings(existing, block, conflict) {
+    const hasExisting = existing?.statusLine != null;
+    if (hasExisting && conflict !== 'overwrite') {
+        return { settings: existing, changed: false };
+    }
+    return { settings: { ...existing, statusLine: block }, changed: true };
+}
+/** Read → merge → (backup) → write. Creates parent dirs and a .bak. */
+export function installStatusline(settingsPath, command, conflict) {
+    let existing = {};
+    const fileExists = existsSync(settingsPath);
+    if (fileExists) {
+        try {
+            existing = JSON.parse(readFileSync(settingsPath, 'utf8'));
+        }
+        catch {
+            existing = {};
+        }
+    }
+    const { settings, changed } = mergeSettings(existing, statusLineBlock(command), conflict);
+    if (!changed)
+        return { written: false, backedUp: false };
+    let backedUp = false;
+    if (fileExists) {
+        copyFileSync(settingsPath, `${settingsPath}.bak`);
+        backedUp = true;
+    }
+    mkdirSync(dirname(settingsPath), { recursive: true });
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+    return { written: true, backedUp };
+}

package/dist/setup/shellrc.js

@@ -0,0 +1,24 @@
+import { mkdirSync, readFileSync, appendFileSync, existsSync } from 'node:fs';
+import { dirname } from 'node:path';
+const MARKER = '# claudial — World Cup ticker beside Claude Code';
+/** The `claude-mundial` alias, escaped for the target shell. */
+export function aliasLine(shell) {
+    if (shell === 'fish') {
+        return `${MARKER}\nalias claude-mundial "tmux new-session 'claude' ; split-window -v -l 5 'claudial --ticker' ; select-pane -U"\n`;
+    }
+    // zsh + bash share POSIX syntax; tmux command separators escaped as \;
+    return `${MARKER}\nalias claude-mundial="tmux new-session 'claude' \\; split-window -v -l 5 'claudial --ticker' \\; select-pane -U"\n`;
+}
+export function hasAlias(content) {
+    return content.includes('claude-mundial');
+}
+/** Append the alias unless one is already present. Creates the file/dir. */
+export function appendAlias(rcPath, shell) {
+    const current = existsSync(rcPath) ? readFileSync(rcPath, 'utf8') : '';
+    if (hasAlias(current))
+        return { appended: false };
+    mkdirSync(dirname(rcPath), { recursive: true });
+    const prefix = current && !current.endsWith('\n') ? '\n' : '';
+    appendFileSync(rcPath, `${prefix}\n${aliasLine(shell)}`);
+    return { appended: true };
+}

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/cache.js

@@ -0,0 +1,107 @@
+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';
+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}`;
+}
+export function makeCache(dir = join(tmpdir(), 'claudial-statusline')) {
+    mkdirSync(dir, { recursive: true });
+    const cacheFile = join(dir, 'line');
+    const lockFile = join(dir, 'lock');
+    const stateFile = join(dir, 'goals.json');
+    const goalFile = join(dir, 'goal');
+    const goalTsFile = join(dir, 'goalts');
+    const atomicWrite = (path, data) => {
+        const tmp = `${path}.tmp`;
+        writeFileSync(tmp, data);
+        renameSync(tmp, path);
+    };
+    const readJson = (path) => {
+        try {
+            return JSON.parse(readFileSync(path, 'utf8'));
+        }
+        catch {
+            return {};
+        }
+    };
+    const totals = (live) => {
+        const out = {};
+        for (const m of live)
+            out[String(m.id)] = (m.homeScore ?? 0) + (m.awayScore ?? 0);
+        return out;
+    };
+    return {
+        read(now = Date.now()) {
+            if (!existsSync(cacheFile))
+                return null;
+            const line = readFileSync(cacheFile, 'utf8');
+            const ageMs = now - statSync(cacheFile).mtimeMs;
+            return { line, ageMs };
+        },
+        write(line, now = Date.now()) {
+            atomicWrite(cacheFile, line);
+            const t = now / 1000;
+            try {
+                utimesSync(cacheFile, t, t);
+            }
+            catch { /* best effort */ }
+        },
+        tryLock(now = Date.now()) {
+            if (existsSync(lockFile)) {
+                const age = now - statSync(lockFile).mtimeMs;
+                if (age > LOCK_STALE_MS) {
+                    try {
+                        unlinkSync(lockFile);
+                    }
+                    catch { /* race */ }
+                }
+            }
+            try {
+                const fd = openSync(lockFile, 'wx');
+                const t = now / 1000;
+                try {
+                    futimesSync(fd, t, t);
+                }
+                catch { /* best effort */ }
+                closeSync(fd);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        unlock() { try {
+            unlinkSync(lockFile);
+        }
+        catch { /* already gone */ } },
+        updateGoalState(live, now = Date.now()) {
+            const prev = readJson(stateFile);
+            const cur = totals(live);
+            for (const m of live) {
+                const id = String(m.id);
+                const was = prev[id] ?? cur[id]; // first sighting never fires
+                if (cur[id] > was) {
+                    atomicWrite(goalFile, goalText(m));
+                    atomicWrite(goalTsFile, String(now));
+                    break;
+                }
+            }
+            atomicWrite(stateFile, JSON.stringify(cur));
+        },
+        activeGoalLine(now = Date.now()) {
+            if (!existsSync(goalTsFile) || !existsSync(goalFile))
+                return null;
+            const ts = Number(readFileSync(goalTsFile, 'utf8'));
+            if (!Number.isFinite(ts) || now - ts > GOAL_WINDOW_MS)
+                return null;
+            return readFileSync(goalFile, 'utf8');
+        },
+    };
+}

package/dist/statusline/line.js

@@ -0,0 +1,45 @@
+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'" (mirrored code+flag). */
+export function liveLine(match) {
+    const clock = match.status === 'halftime' ? ' HT'
+        : match.minute != null ? ` ${match.minute}'`
+            : '';
+    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". */
+export function finishedLine(match) {
+    return `⚽ ${homeTag(match.home.code)} ${match.homeScore ?? 0}—${match.awayScore ?? 0} ${awayTag(match.away.code)} FT`;
+}
+/** The next kickoff: "○ BRA 🇧🇷 — 🇲🇦 MAR Sun 01:00". */
+function upcomingLine(match, 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
+ * to `now`: the latest finished result (end ≈ kickoff + MATCH_MS) or the next
+ * kickoff. Only one present → that one; neither → "".
+ */
+export function scoreLine(live, recent, upcoming, now = Date.now()) {
+    if (live.length > 0)
+        return live.map(liveLine).join('  ');
+    const lastFinished = recent.length
+        ? recent.reduce((a, b) => (b.startTimestamp > a.startTimestamp ? b : a))
+        : null;
+    const next = upcoming[0] ?? null;
+    if (lastFinished && next) {
+        const finishMs = lastFinished.startTimestamp * 1000 + MATCH_MS;
+        const startMs = next.startTimestamp * 1000;
+        return Math.abs(now - finishMs) <= Math.abs(startMs - now)
+            ? finishedLine(lastFinished)
+            : upcomingLine(next, now);
+    }
+    if (lastFinished)
+        return finishedLine(lastFinished);
+    if (next)
+        return upcomingLine(next, now);
+    return '';
+}

package/dist/statusline/run.js

@@ -0,0 +1,68 @@
+import { execFileSync } from 'node:child_process';
+import { fetchLive as realFetchLive, fetchRecent as realFetchRecent, fetchUpcoming as realFetchUpcoming } from '../api/espn.js';
+import { scoreLine } from './line.js';
+import { makeCache, TTL_MS } from './cache.js';
+const PLACEHOLDER = '⚽ claudial · warming up';
+function withTimeout(p, ms) {
+    let id;
+    const timer = new Promise((_, reject) => {
+        id = setTimeout(() => reject(new Error('timeout')), ms);
+    });
+    return Promise.race([p, timer]).finally(() => clearTimeout(id));
+}
+export async function runStatusline(input, deps, now = Date.now()) {
+    const { cache } = deps;
+    const cached = cache.read(now);
+    let line = cached?.line ?? null;
+    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 next = scoreLine(liveM, recentM, upcomingM, now);
+            cache.updateGoalState(liveM, now);
+            if (next) {
+                cache.write(next, now);
+                line = next;
+            }
+        }
+        catch {
+            // keep last good cache (line already set)
+        }
+        finally {
+            cache.unlock();
+        }
+    }
+    const score = cache.activeGoalLine(now) ?? line ?? PLACEHOLDER;
+    const branch = deps.branchOf(input);
+    return branch ? `${score} · ${branch}` : score;
+}
+/** Resolve the git branch of the workspace dir named in Claude Code's stdin JSON. */
+export function defaultBranchOf(input) {
+    let dir = '';
+    try {
+        const j = JSON.parse(input || '{}');
+        dir = j?.workspace?.current_dir || j?.cwd || '';
+    }
+    catch { /* no/!json stdin */ }
+    if (!dir)
+        return null;
+    try {
+        const out = execFileSync('git', ['-C', dir, 'branch', '--show-current'], {
+            encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        return out || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function defaultDeps() {
+    return {
+        fetchLive: realFetchLive,
+        fetchRecent: () => realFetchRecent(2026),
+        fetchUpcoming: realFetchUpcoming,
+        cache: makeCache(),
+        branchOf: defaultBranchOf,
+        timeoutMs: 3000,
+    };
+}

package/dist/ui/App.js

@@ -5,11 +5,22 @@ import { initialState, reducer } from '../state.js';
 import { startPoller } from '../engine/poller.js';
 import { fetchIncidents, fetchLive, fetchRecent, fetchUpcoming } from '../api/espn.js';
 import { Header } from './Header.js';
-import { LiveSection } from './LiveSection.js';
+import { DaySection } from './DaySection.js';
+import { partitionByDay } from './fixtures.js';
 import { UpcomingSection } from './UpcomingSection.js';
 import { Footer } from './Footer.js';
 import { TakeoverView } from './TakeoverView.js';
 import { Ticker } from './Ticker.js';
+function dedupeById(matches) {
+    const seen = new Set();
+    const out = [];
+    for (const m of matches)
+        if (!seen.has(m.id)) {
+            seen.add(m.id);
+            out.push(m);
+        }
+    return out;
+}
 export function App({ seasonId, mode = 'board' }) {
     const [state, dispatch] = useReducer(reducer, initialState);
     const { exit } = useApp();
@@ -46,5 +57,7 @@ export function App({ seasonId, mode = 'board' }) {
     if (mode === 'ticker') {
         return _jsx(Ticker, { live: state.live, upcoming: state.upcoming, takeover: playing });
     }
-    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(Header, { stale: state.stale, lastUpdated: state.lastUpdated }), _jsx(LiveSection, { matches: state.live, recent: state.recent, incidents: state.incidents, compact: compact }), _jsx(UpcomingSection, { matches: state.upcoming, compact: compact }), _jsx(Footer, {})] }));
+    const all = dedupeById([...state.live, ...state.recent, ...state.upcoming]);
+    const { yesterday, today, future } = partitionByDay(all, Date.now());
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(Header, { stale: state.stale, lastUpdated: state.lastUpdated }), _jsx(DaySection, { label: "TODAY", matches: today, incidents: state.incidents, compact: compact }), _jsx(DaySection, { label: "YESTERDAY", matches: yesterday, incidents: state.incidents, compact: compact }), _jsx(UpcomingSection, { matches: future, compact: compact }), _jsx(Footer, {})] }));
 }

package/dist/ui/DaySection.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { MatchRow } from './MatchRow.js';
+/** A labelled group of match rows (e.g. TODAY / YESTERDAY). Hidden when empty. */
+export function DaySection({ label, matches, incidents, compact }) {
+    if (matches.length === 0)
+        return null;
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { dimColor: true, children: label }), matches.map((m) => (_jsx(MatchRow, { m: m, incidents: incidents[m.id] ?? [], compact: compact }, m.id)))] }));
+}

package/dist/ui/MatchRow.js

@@ -0,0 +1,44 @@
+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)
+        return null;
+    const fmt = (g) => `${g.minute ?? '?'}' ${g.playerShort ?? '?'}`;
+    const home = goals.filter((g) => g.isHome).map(fmt).join(' · ');
+    const away = goals.filter((g) => !g.isHome).map(fmt).join(' · ');
+    return _jsxs(Text, { dimColor: true, children: ['   ', "\u26BD ", [home, away].filter(Boolean).join(' | ')] });
+}
+export function FeedLine({ incidents }) {
+    const feed = incidents.filter((i) => i.kind === 'yellowCard' || i.kind === 'substitution');
+    if (feed.length === 0)
+        return null;
+    const fmt = (i) => i.kind === 'yellowCard'
+        ? `${i.minute ?? '?'}' 🟨 ${i.playerShort ?? '?'}`
+        : `${i.minute ?? '?'}' ⇄ ${i.playerShort ?? '?'}`;
+    // last 4 only — the feed is a pulse, not a log
+    return _jsxs(Text, { dimColor: true, children: ['   ', "\u25AA ", feed.slice(-4).map(fmt).join(' · ')] });
+}
+function statusLabel(m) {
+    if (m.status === 'halftime')
+        return 'HT';
+    if (m.status === 'finished')
+        return 'FT';
+    return m.minute != null ? `LIVE ${m.minute}'` : 'LIVE';
+}
+/** One match row. Upcoming → kickoff line; live/halftime/finished → score + feed. */
+export function MatchRow({ m, incidents, compact }) {
+    if (m.status === 'upcoming') {
+        if (compact) {
+            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)] }), 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), " "] }), 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: ['   ', 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/fixtures.js

@@ -0,0 +1,32 @@
+const DAY_MS = 86_400_000;
+/** Local-midnight epoch (ms) for the instant `ms`. */
+function dayKey(ms) {
+    const d = new Date(ms);
+    return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+}
+/**
+ * Partition matches by local calendar day relative to `now`:
+ * today (diff 0), yesterday (diff -1), future (diff ≥ 1). Anything older than
+ * yesterday — or with no usable timestamp — is dropped. Each bucket is sorted
+ * ascending by kickoff. `Match.startTimestamp` is unix seconds.
+ */
+export function partitionByDay(matches, now = Date.now()) {
+    const todayKey = dayKey(now);
+    const out = { yesterday: [], today: [], future: [] };
+    for (const m of matches) {
+        if (!m.startTimestamp)
+            continue;
+        const diffDays = Math.round((dayKey(m.startTimestamp * 1000) - todayKey) / DAY_MS);
+        if (diffDays === 0)
+            out.today.push(m);
+        else if (diffDays === -1)
+            out.yesterday.push(m);
+        else if (diffDays >= 1)
+            out.future.push(m);
+    }
+    const byStart = (a, b) => a.startTimestamp - b.startTimestamp;
+    out.yesterday.sort(byStart);
+    out.today.sort(byStart);
+    out.future.sort(byStart);
+    return out;
+}

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.2.1",
+  "version": "0.4.0",
   "description": "Live World Cup 2026 fixtures in your terminal — goal, red-card and VAR takeovers included",
   "type": "module",
   "bin": {
@@ -46,5 +46,5 @@
   },
   "homepage": "https://github.com/lefProg/claudial#readme",
   "bugs": "https://github.com/lefProg/claudial/issues",
-  "author": "Wim Iliano"
+  "author": "lefProg"
 }

package/dist/ui/LiveSection.js

@@ -1,39 +0,0 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { Box, Text } from 'ink';
-import { ACCENT } from './Header.js';
-function ScorerLine({ incidents }) {
-    const goals = incidents.filter((i) => i.kind === 'goal');
-    if (goals.length === 0)
-        return null;
-    const fmt = (g) => `${g.minute ?? '?'}' ${g.playerShort ?? '?'}`;
-    const home = goals.filter((g) => g.isHome).map(fmt).join(' · ');
-    const away = goals.filter((g) => !g.isHome).map(fmt).join(' · ');
-    return _jsxs(Text, { dimColor: true, children: ['   ', "\u26BD ", [home, away].filter(Boolean).join(' | ')] });
-}
-function FeedLine({ incidents }) {
-    const feed = incidents.filter((i) => i.kind === 'yellowCard' || i.kind === 'substitution');
-    if (feed.length === 0)
-        return null;
-    const fmt = (i) => i.kind === 'yellowCard'
-        ? `${i.minute ?? '?'}' 🟨 ${i.playerShort ?? '?'}`
-        : `${i.minute ?? '?'}' ⇄ ${i.playerShort ?? '?'}`;
-    // last 4 only — the feed is a pulse, not a log
-    return _jsxs(Text, { dimColor: true, children: ['   ', "\u25AA ", feed.slice(-4).map(fmt).join(' · ')] });
-}
-function statusLabel(m) {
-    if (m.status === 'halftime')
-        return 'HT';
-    if (m.status === 'finished')
-        return 'FT';
-    return m.minute != null ? `LIVE ${m.minute}'` : 'LIVE';
-}
-export function LiveSection({ matches, recent, incidents, compact }) {
-    const liveIds = new Set(matches.map((m) => m.id));
-    const rows = [...matches, ...recent.filter((r) => !liveIds.has(r.id))];
-    if (rows.length === 0)
-        return null;
-    if (compact) {
-        return (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: rows.map((m) => (_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] }, m.id))) }));
-    }
-    return (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: rows.map((m) => (_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[m.id] ?? [] }), _jsx(FeedLine, { incidents: incidents[m.id] ?? [] })] }, m.id))) }));
-}