claudial 0.6.4 → 0.7.1

package/README.md

@@ -2,10 +2,10 @@
 
 # ⚽ claudial
 
-### Live World Cup 2026 in your terminal — goal and red-card takeovers included
+### Live football inside Claude Code
 
-One command. Every World Cup score, in your terminal and right inside Claude
-Code, while you work.
+Your teams' scores sit under your prompt while you code.
+When one of them scores, your terminal celebrates.
 
 ```
 npm install -g claudial && claudial setup
@@ -16,121 +16,129 @@ npm install -g claudial && claudial setup
 [![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)
+![backend](https://img.shields.io/badge/backend-Rust-DEA584?style=flat-square&logo=rust&logoColor=white)
+[![license](https://img.shields.io/npm/l/claudial?style=flat-square&color=blue)](LICENSE)
 [![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)
+
+<br/>
+
+![claudial: Liverpool 6–0 Manchester United live, then a full-screen GOAL for Firmino's 88th-minute seventh](dashboard.gif)
+
+**Premier League · La Liga · Serie A · Bundesliga · Ligue 1 · Champions League ·
+Europa League · Conference League · Super League Greece · World Cup**
 
 </div>
 
 ---
 
-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:
+## Get started
 
-<div align="center">
+| You are… | Run |
+|---|---|
+| **New to claudial** | `npm install -g claudial`<br>`claudial setup` |
+| **Back from the World Cup** (you have 0.6.x) | `npm install -g claudial@latest`<br>`claudial --version` (should print 0.7.0 or newer)<br>`claudial follow` |
 
-![claudial — live World Cup 2026 scores in Claude Code's status bar](demo.gif)
+Then restart Claude Code. World Cup users keep their status line as it is; `claudial follow`
+picks your leagues and teams, because the new version starts following nothing.
 
-</div>
+Still seeing "WORLD CUP 2026" after updating? An old copy comes first on your PATH.
+`which -a claudial` lists every copy; remove the old one with
+`npm uninstall -g --prefix <its folder> claudial` (e.g. `--prefix ~/.npm-global`).
 
-## Claude Code, World Cup edition
+## The score, right under your prompt
 
-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.
+One command puts a live score line into Claude Code's status bar. It stays out
+of the way while Claude works, and lights up the moment anyone scores:
 
-```bash
-npm install -g claudial
-claudial setup
-```
+<div align="center">
+
+![claudial: Liverpool 7–0 Manchester United flashing GOOOL in Claude Code's status bar](demo.gif)
 
-The wizard drops a live-score statusline into your Claude Code settings:
+</div>
 
 ```
-⚽ 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
+⚽ Liverpool 6—0 Manchester United 87' · main                      ← every match you follow
+⚽ G O O O L  ·  Liverpool 7—0 Manchester United · main            ← for 15 s after a goal
+🟥 R E D  ·  CASEMIRO  ·  Manchester United — Southampton · main   ← for 15 s after a red card
+○ Liverpool — Arsenal Sat 05:30 PM · main                          ← between matches: next kickoff
 ```
 
-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`.
+Your git branch stays at the end. **Already run a custom status line?** Setup
+keeps it and appends the score, so nothing you had is lost. Pure Node, so it
+works on macOS, Linux and Windows. Restart Claude Code after setup to see it.
 
-**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.
+## Pick your teams in five seconds
 
-## 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:
+Setup ends by asking what you follow. Type a name, tick it with space, press
+esc to save:
 
 ```
+ claudial · what do you follow?
 
+ search › liver▏
 
-      █▀▀█  █▀▀█  █▀▀█  █
-      █ ▄▄  █  █  █▀▀█  █
-      ▀▀▀▀  ▀▀▀▀  ▀  ▀  ▀▀▀▀
+ › ◉ Liverpool  LIV · Premier League
 
-         LIONEL MESSI · 23'
+ Following Liverpool
+ ↑↓ move · space follow · type to search · esc clear search · ctrl+c cancel
+```
 
-      ARG 🇦🇷  2 — 1  🇲🇽 MEX
+Follow a whole league or just your club. Change your mind any time: press `f`
+in the dashboard, or run `claudial follow`.
 
+## A goal takes over the whole screen
 
-```
+Want the full board beside Claude? `claudial` opens a live dashboard: every
+match you follow with scores, minutes, scorers and cards, plus the next three
+weeks of fixtures in your local time.
 
-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.
+When a goal goes in, the server pushes it within a second, and the whole
+screen becomes the goal: the scorer, the minute, the new score. Four seconds
+of glory, then back to the board. Red cards get the same treatment.
 
 ## Usage
 
 ```
-npx claudial            # the dashboard
-npx claudial --ticker   # 4-line strip for slim split panes
-npx claudial | cat      # non-interactive snapshot (pipes, scripts, CI)
-```
-
-Or install it for good:
-
-```
-npm install -g claudial
-claudial
+claudial              # the live dashboard
+claudial --ticker     # a 4-line strip for slim split panes
+claudial | cat        # plain snapshot for pipes and scripts
+claudial follow       # pick leagues and teams
 ```
 
-Requires Node ≥ 18. No account, no API key, no config.
-
-| Key | Action      |
-|-----|-------------|
+| Key | Action |
+|-----|--------|
+| `f` | pick what you follow |
 | `r` | refresh now |
-| `q` | quit        |
+| `q` | quit |
+
+Requires Node ≥ 18. No account, no sign-up, no API key.
 
-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.
+Scripting it? `claudial setup --statusline --yes` installs without
+prompts, and `claudial leagues`, `claudial teams <league>`,
+`claudial follow <id>...`, `claudial unfollow <id>...` and `claudial following`
+work without the UI. `claudial forget` deletes your device from the server.
 
 ## Status
 
-v1 is being built live during the group stage. Follow the commits.
+claudial started as a World Cup 2026 side project. It now follows ten leagues
+through its own server, written in Rust: one set of polls for everyone, goals
+pushed to every terminal over server-sent events.
 
 ## 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
-  ESPN or FIFA.
-- Not affiliated with Anthropic. The aesthetic is a love letter to
-  [Claude Code](https://claude.com/claude-code), whose terminal UI this
-  proudly imitates.
-- Polling is deliberately gentle (15 s live, 5 min fixtures), and a single
-  scoreboard call serves all live matches at once. Please keep it that way.
+- Privacy: the server stores a random device id, what you follow, and when it
+  last saw you. No accounts, emails, names or analytics, and your IP is never
+  written down. Inactive devices are deleted after 400 days; `claudial forget`
+  deletes yours right away.
+- Match facts (scores, scorers, cards) come from ESPN's public site API, through
+  the claudial server. No logos or branding. Not affiliated with or endorsed by
+  ESPN, FIFA, UEFA or any league.
+- Seeing `AR` instead of `🇦🇷` for national teams? Your terminal doesn't render
+  flag emoji. macOS terminals and [Konsole](https://konsole.kde.org/) do;
+  Windows Terminal doesn't.
+- Not affiliated with Anthropic. The look is a love letter to
+  [Claude Code](https://claude.com/claude-code).
 
 ```js
 // Canada — Bosnia & Herzegovina, 12 June 2026, was on while this was built.
@@ -140,8 +148,8 @@ v1 is being built live during the group stage. Follow the commits.
 
 ## Contributing
 
-Issues and PRs welcome — bug reports, new incident types, terminal quirks,
-all of it. Keep the polling gentle and the spirit playful.
+Issues and PRs welcome: bug reports, new incident types, terminal quirks, all
+of it. Keep the spirit playful.
 
 ```bash
 git clone https://github.com/lefProg/claudial.git
@@ -159,10 +167,14 @@ npm test        # vitest
 
 <br/>
 
-**If this made a goal feel a little louder, drop a ⭐ — it helps others find it.**
+**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)
 
+<br/>
+
+**YNWA** 🔴
+
 </div>

package/dist/api/backend.js

@@ -0,0 +1,216 @@
+import { deviceId } from './device.js';
+// Where the server lives: the deployed VPS. Plain HTTP until it has a domain and
+// TLS; scripts/check-release.mjs blocks an npm publish until this is https://.
+// CLAUDIAL_API_URL always wins (local dev: http://localhost:8080).
+export const DEFAULT_API_URL = 'http://161.97.67.12:30083';
+export function apiUrl(env = process.env) {
+    return (env.CLAUDIAL_API_URL || DEFAULT_API_URL).replace(/\/+$/, '');
+}
+/** Thrown for any non-2xx answer, carrying the server's own error message. */
+export class ApiError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+const TIMEOUT_MS = 8_000;
+export async function api(method, path, body, fetchImpl = fetch) {
+    const res = await fetchImpl(`${apiUrl()}${path}`, {
+        method,
+        headers: {
+            Authorization: `Bearer ${deviceId()}`,
+            Accept: 'application/json',
+            ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}),
+        },
+        body: body !== undefined ? JSON.stringify(body) : undefined,
+        signal: AbortSignal.timeout(TIMEOUT_MS),
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        let message = `server answered ${res.status}`;
+        try {
+            message = JSON.parse(text).error ?? message;
+        }
+        catch { /* not JSON */ }
+        throw new ApiError(res.status, message);
+    }
+    return (text ? JSON.parse(text) : undefined);
+}
+// ── Adapting server matches to the client's Match ───────────────────────────
+export function toMatch(m) {
+    const national = m.league === 'fifa.world';
+    const status = m.status === 'postponed' ? 'finished' : m.status;
+    return {
+        id: Number(m.id),
+        group: null,
+        home: { name: m.home.name, code: m.home.code, national },
+        away: { name: m.away.name, code: m.away.code, national },
+        homeScore: m.homeScore,
+        awayScore: m.awayScore,
+        status,
+        statusText: m.status === 'postponed' ? (m.statusText || 'Postponed') : m.statusText,
+        minute: m.minute,
+        startTimestamp: m.startTimestamp,
+        varInProgress: false,
+    };
+}
+export function toIncidents(m) {
+    return m.incidents.map((i) => ({ ...i, homeScore: null, awayScore: null }));
+}
+// One /v1/state request serves every caller in a tick (dashboard or statusline):
+// the in-flight promise is shared, and the answer is reused for a few seconds.
+const CACHE_MS = 5_000;
+let cached = null;
+export function fetchState(now = Date.now()) {
+    if (MOCK)
+        return Promise.resolve(mockState());
+    if (cached && now - cached.at < CACHE_MS)
+        return cached.state;
+    const state = api('GET', '/v1/state');
+    cached = { at: now, state };
+    state.catch(() => { if (cached?.state === state)
+        cached = null; });
+    return state;
+}
+/** Forget the cached state (after the event stream says something changed). */
+export function invalidateState() { cached = null; }
+const isLive = (m) => m.status === 'live' || m.status === 'halftime';
+// Kept for call-site compatibility; the server needs no season id.
+export async function resolveSeasonId() {
+    return 2026;
+}
+export async function fetchLive() {
+    if (MOCK)
+        mockLiveCalls++;
+    return (await fetchState()).matches.map(toMatch).filter(isLive);
+}
+export async function fetchUpcoming(_seasonId) {
+    return (await fetchState()).matches
+        .map(toMatch)
+        .filter((m) => m.status === 'upcoming')
+        .sort((a, b) => a.startTimestamp - b.startTimestamp);
+}
+export async function fetchRecent(_seasonId) {
+    return (await fetchState()).matches
+        .map(toMatch)
+        .filter((m) => m.status === 'finished')
+        .sort((a, b) => a.startTimestamp - b.startTimestamp);
+}
+export async function fetchIncidents(eventId) {
+    const m = (await fetchState()).matches.find((x) => Number(x.id) === eventId);
+    return m ? toIncidents(m) : [];
+}
+// Red cards in live matches, from the same /v1/state answer.
+export async function fetchLiveRedCards() {
+    const out = [];
+    for (const sm of (await fetchState()).matches) {
+        const m = toMatch(sm);
+        if (!isLive(m))
+            continue;
+        for (const inc of sm.incidents) {
+            if (inc.kind === 'redCard') {
+                out.push({ id: inc.id, homeCode: m.home.code, awayCode: m.away.code, homeName: m.home.name, awayName: m.away.name, player: inc.playerShort ?? inc.player ?? '?', minute: inc.minute, national: m.home.national !== false });
+            }
+        }
+    }
+    return out;
+}
+// ── Subscriptions ────────────────────────────────────────────────────────────
+export const listLeagues = () => api('GET', '/v1/leagues');
+export const listTeams = (slug) => api('GET', `/v1/leagues/${encodeURIComponent(slug)}/teams`);
+export const getSettings = () => api('GET', '/v1/me/settings');
+export const putSettings = (s) => api('PUT', '/v1/me/settings', s);
+export const forgetDevice = () => api('DELETE', '/v1/me/settings');
+/**
+ * A new device follows nothing until the user picks something. True when this
+ * device follows no league and no team, so the UI can say how to start.
+ */
+export async function followsNothing() {
+    if (MOCK)
+        return false;
+    const s = await getSettings();
+    return s.leagues.length === 0 && s.teams.length === 0;
+}
+// ── Push: the server's event stream ─────────────────────────────────────────
+/** Three missed 15 s heartbeats. */
+const STALL_MS = 45_000;
+/**
+ * Hold GET /v1/events open and call `onEvent` with each event name. Reconnects
+ * with backoff after errors or when the server ends the stream. Returns a stop
+ * function. The caller refetches /v1/state on each event.
+ */
+export function subscribeEvents(onEvent, fetchImpl = fetch, stallMs = STALL_MS) {
+    let stopped = false;
+    let controller = null;
+    let failures = 0;
+    const loop = async () => {
+        while (!stopped) {
+            controller = new AbortController();
+            try {
+                const res = await fetchImpl(`${apiUrl()}/v1/events`, {
+                    headers: { Authorization: `Bearer ${deviceId()}`, Accept: 'text/event-stream' },
+                    signal: controller.signal,
+                });
+                if (!res.ok || !res.body)
+                    throw new ApiError(res.status, `events answered ${res.status}`);
+                failures = 0;
+                // The server writes a heartbeat every 15 s. Silence for longer than that
+                // means a dead connection nobody closed (a sleeping laptop, a NAT drop):
+                // abort and reconnect instead of waiting forever (final review N9).
+                const current = controller;
+                let stall = setTimeout(() => current.abort(), stallMs);
+                const decoder = new TextDecoder();
+                let buf = '';
+                for await (const chunk of res.body) {
+                    clearTimeout(stall);
+                    stall = setTimeout(() => current.abort(), stallMs);
+                    buf += decoder.decode(chunk, { stream: true });
+                    let cut;
+                    while ((cut = buf.indexOf('\n\n')) >= 0) {
+                        const frame = buf.slice(0, cut);
+                        buf = buf.slice(cut + 2);
+                        const name = frame.split('\n').find((l) => l.startsWith('event:'))?.slice(6).trim();
+                        if (name)
+                            onEvent(name);
+                    }
+                }
+                clearTimeout(stall);
+            }
+            catch {
+                failures++;
+            }
+            if (stopped)
+                return;
+            const wait = Math.min(1_000 * 2 ** Math.min(failures, 6), 60_000);
+            await new Promise((r) => setTimeout(r, wait));
+        }
+    };
+    void loop();
+    return () => { stopped = true; controller?.abort(); };
+}
+// ── 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 mockState() {
+    const scored = mockLiveCalls >= 2; // Kane's goal lands on the 2nd live fetch
+    const goal = (id, minute, player, short, isHome) => ({ id, kind: 'goal', minute, player, playerShort: short, detail: null, isHome });
+    return {
+        generatedAt: Math.floor(Date.now() / 1000),
+        matches: [{
+                id: '9001', league: 'fifa.world',
+                home: { id: '202', name: 'Argentina', code: 'ARG' }, away: { id: '448', name: 'England', code: 'ENG' },
+                homeScore: 1, awayScore: scored ? 2 : 1, status: 'live', statusText: scored ? "78'" : "76'",
+                minute: scored ? 78 : 76, startTimestamp: Math.floor(Date.now() / 1000) - 78 * 60,
+                incidents: [
+                    goal('9001-137-600-1', 10, 'Lionel Messi', 'L. Messi', true),
+                    goal('9001-137-2400-2', 40, 'Jude Bellingham', 'J. Bellingham', false),
+                    ...(scored ? [goal('9001-137-4680-3', 78, 'Harry Kane', 'H. Kane', false)] : []),
+                ],
+            }],
+    };
+}

package/dist/api/device.js

@@ -0,0 +1,28 @@
+import { randomUUID } from 'node:crypto';
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+// This device's identity for the claudial server: a random UUID made once and
+// kept in ~/.config/claudial/device-id. It is the only credential; there are no
+// accounts. Deleting the file makes the server see a brand-new device.
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function configDir(env = process.env) {
+    return join(env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'claudial');
+}
+/** Read the device id, creating it (mode 0600) on first use. */
+export function deviceId(dir = configDir()) {
+    const file = join(dir, 'device-id');
+    if (existsSync(file)) {
+        const id = readFileSync(file, 'utf8').trim();
+        if (UUID.test(id))
+            return id;
+    }
+    mkdirSync(dir, { recursive: true });
+    const id = randomUUID();
+    writeFileSync(file, `${id}\n`, { mode: 0o600 });
+    try {
+        chmodSync(file, 0o600);
+    }
+    catch { /* best effort */ }
+    return id;
+}

package/dist/cli/follow.js

@@ -0,0 +1,136 @@
+import { rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { ApiError, apiUrl, forgetDevice, getSettings, listLeagues, listTeams, putSettings, } from '../api/backend.js';
+import { configDir } from '../api/device.js';
+// `claudial leagues | teams | follow | unfollow | following | forget`:
+// what this device follows on the claudial server.
+export const FOLLOW_COMMANDS = ['leagues', 'teams', 'follow', 'unfollow', 'following', 'forget'];
+export const USAGE = `usage:
+  claudial follow                      pick your leagues and teams from a list
+  claudial leagues                     the leagues you can follow (✓ = following)
+  claudial teams <league> [search]     a league's teams and their ids, e.g. claudial teams gre.1 pana
+  claudial follow <league|team id>...  e.g. claudial follow gre.1 443
+  claudial unfollow <league|team id>...
+  claudial following                   what this device follows
+  claudial forget                      delete this device from the server`;
+/** Pure: apply follow/unfollow targets to settings. Slugs are leagues, digits are team ids. */
+export function applyTargets(s, targets, follow, known) {
+    const leagues = new Set(s.leagues);
+    const teams = new Set(s.teams);
+    for (const t of targets) {
+        if (/^\d+$/.test(t)) {
+            if (follow) {
+                teams.add(t);
+            }
+            else {
+                teams.delete(t);
+            }
+        }
+        else if (known.some((l) => l.slug === t)) {
+            if (follow) {
+                leagues.add(t);
+            }
+            else {
+                leagues.delete(t);
+            }
+        }
+        else {
+            throw new Error(`"${t}" is neither a league slug (see: claudial leagues) nor a team id (see: claudial teams <league>)`);
+        }
+    }
+    return { leagues: [...leagues], teams: [...teams] };
+}
+/** Pure: case- and accent-insensitive match on a team's name or code. */
+export function matchesSearch(t, search) {
+    const fold = (x) => x.normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
+    const q = fold(search);
+    return fold(t.name).includes(q) || fold(t.code).includes(q);
+}
+/** One line for a failed command: the server's own message, or a plain "can't reach it". */
+export function describeError(e) {
+    if (e instanceof ApiError)
+        return `server said: ${e.message}`;
+    // fetch rejects with a TypeError when the network fails, and a Timeout/AbortError on our 8 s limit.
+    const name = e instanceof Error ? e.name : '';
+    if (e instanceof TypeError || name === 'TimeoutError' || name === 'AbortError') {
+        return `can't reach the claudial server (${apiUrl()}). Check your connection and try again.`;
+    }
+    return e instanceof Error ? e.message : String(e);
+}
+export async function runFollow(args, out = console.log) {
+    const [cmd, ...rest] = args;
+    try {
+        switch (cmd) {
+            case 'leagues': {
+                const [leagues, s] = await Promise.all([listLeagues(), getSettings()]);
+                for (const l of leagues)
+                    out(`${s.leagues.includes(l.slug) ? '✓' : ' '} ${l.slug.padEnd(18)} ${l.name}`);
+                return 0;
+            }
+            case 'teams': {
+                const [league, search] = rest;
+                if (!league) {
+                    out(USAGE);
+                    return 2;
+                }
+                const [teams, s] = await Promise.all([listTeams(league), getSettings()]);
+                const shown = search ? teams.filter((t) => matchesSearch(t, search)) : teams;
+                for (const t of shown)
+                    out(`${s.teams.includes(t.id) ? '✓' : ' '} ${t.id.padStart(7)}  ${t.code.padEnd(10)} ${t.name}`);
+                if (shown.length === 0)
+                    out('no team matches');
+                return 0;
+            }
+            case 'follow':
+            case 'unfollow': {
+                if (rest.length === 0 && cmd === 'follow' && process.stdin.isTTY) {
+                    const { runPicker } = await import('../ui/picker/run.js');
+                    await runPicker();
+                    return 0;
+                }
+                if (rest.length === 0) {
+                    out(USAGE);
+                    return 2;
+                }
+                const [leagues, s] = await Promise.all([listLeagues(), getSettings()]);
+                const next = applyTargets(s, rest, cmd === 'follow', leagues);
+                const saved = await putSettings(next);
+                out(`following ${saved.leagues.length} league(s) and ${saved.teams.length} team(s)`);
+                return 0;
+            }
+            case 'following': {
+                const [leagues, s] = await Promise.all([listLeagues(), getSettings()]);
+                const name = new Map(leagues.map((l) => [l.slug, l.name]));
+                out(s.leagues.length ? `leagues: ${s.leagues.map((l) => `${l} (${name.get(l) ?? '?'})`).join(', ')}` : 'leagues: none');
+                if (s.teams.length === 0) {
+                    out('teams:   none');
+                    return 0;
+                }
+                // Settings hold team ids only; look their names up in every league's list.
+                const lists = await Promise.all(leagues.map((l) => listTeams(l.slug).catch(() => [])));
+                const team = new Map();
+                for (const t of lists.flat())
+                    if (!team.has(t.id))
+                        team.set(t.id, t);
+                out(`teams:   ${s.teams.map((id) => { const t = team.get(id); return t ? `${t.name} (${id})` : id; }).join(', ')}`);
+                return 0;
+            }
+            case 'forget': {
+                await forgetDevice();
+                // A new identity next time. `onboarded` was written by versions that auto-followed.
+                const dir = configDir();
+                rmSync(join(dir, 'device-id'), { force: true });
+                rmSync(join(dir, 'onboarded'), { force: true });
+                out('the server no longer has anything about this device');
+                return 0;
+            }
+            default:
+                out(USAGE);
+                return 2;
+        }
+    }
+    catch (e) {
+        out(`claudial: ${describeError(e)}`);
+        return 1;
+    }
+}

package/dist/engine/poller.js

@@ -31,7 +31,12 @@ export function startPoller(deps, opts = {}) {
         try {
             const matches = await deps.fetchLive();
             const scoreChanges = diffGoals(prev, matches);
+            // A match that left the live list has finished (or was postponed): refresh
+            // the finished/upcoming lists now, or it vanishes until the next fixtures tick.
+            const ended = prev.some((p) => !matches.some((m) => m.id === p.id));
             prev = matches;
+            if (ended)
+                void refreshFixtures();
             deps.dispatch({ type: 'live', matches, at: Date.now() });
             failures = 0;
             for (const m of matches) {
@@ -98,7 +103,7 @@ export function startPoller(deps, opts = {}) {
             liveTimer = setTimeout(liveTick, delay);
         }
     }
-    async function fixturesTick() {
+    async function refreshFixtures() {
         try {
             const { upcoming, recent } = await deps.fetchFixtures();
             deps.dispatch({ type: 'fixtures', upcoming, recent });
@@ -106,6 +111,9 @@ export function startPoller(deps, opts = {}) {
         catch {
             deps.dispatch({ type: 'stale' });
         }
+    }
+    async function fixturesTick() {
+        await refreshFixtures();
         // Predictions ride the gentle fixtures cadence. fetchPredictions is
         // fail-silent (returns [] when disabled or on error), so this never
         // disturbs the board.