@claudinho/mcp 0.11.1 → 0.12.0

package/README.md

@@ -1,149 +1,154 @@
 # @claudinho/mcp ⚽
 
-**An MCP server with live football scores, fixtures, standings and paste-ready match cards for
-the competition you follow: the World Cup, the Premier League, LALIGA, the Champions League and
-12 more.** Ask your agent in Claude Code, Cursor, Codex, Claude Desktop, Windsurf, Zed, VS Code,
-or any MCP client (stdio). No API key, no signup. The World Cup's 104 fixtures ship bundled; the
-other competitions' schedules are read from the feed, and live scores (and the optional,
-read-only Polymarket signals for the World Cup) hit the network. It ran the 2026 World Cup from
-the opener to the final.
+**An MCP server that lets your coding agent answer football questions: live scores, fixtures,
+standings and paste-ready match cards for the competition you follow: the World Cup, the Premier
+League, LALIGA, the Champions League and 12 more.** It works in Claude Code, Cursor, Codex, Claude
+Desktop, Windsurf, Zed, VS Code and any MCP client that runs a local (stdio) server. No API key, no
+signup, no account.
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/arturogarrido/claudinho/main/.github/assets/mcp-aha.gif" alt="An AI coding agent mid-task during the 2026 World Cup: asked 'did Germany get through?', it calls the Claudinho MCP server and answers with the result: 🇩🇪 Germany 1(3)–1(4) Paraguay 🇵🇾, FT (Paraguay won the shootout)" width="760">
+  <img src="https://raw.githubusercontent.com/arturogarrido/claudinho/main/.github/assets/mcp-aha.gif" alt="Cursor CLI asked mid-task how Manchester City are doing against Paris Saint-Germain; it calls the Claudinho MCP server and answers with the live score from the 24th minute" width="760">
 </p>
 
-> ⭐ Added via `npx` or your MCP config? **[Star the repo](https://github.com/arturogarrido/claudinho)**: a fan project runs on stars.
-
 ## Install
 
+The server runs with `npx`, so it needs Node.js 20 or later.
+
 **Claude Code**
 ```bash
 claude mcp add claudinho -- npx -y @claudinho/mcp
 ```
 
-**Cursor**: add to `~/.cursor/mcp.json` (global) or a project `.cursor/mcp.json`:
+**Codex CLI**
+```bash
+codex mcp add claudinho -- npx -y @claudinho/mcp
+```
+
+**Cursor, Claude Desktop, Windsurf, Zed, VS Code**: add this to the client's MCP config (for
+Cursor, `~/.cursor/mcp.json` or a project's `.cursor/mcp.json`; for Claude Desktop, Settings →
+Developer → Edit Config, then restart). Some clients (VS Code, Zed) put the same `command` and
+`args` under a key of their own: see your client's MCP docs.
 ```json
 { "mcpServers": { "claudinho": { "command": "npx", "args": ["-y", "@claudinho/mcp"] } } }
 ```
-> Bonus: `claudinho init-cursor-statusline` (from `@claudinho/cli`) also puts the live score
-> in your Cursor CLI statusline, or run `claudinho init cursor` to do both at once.
 
-**Codex CLI**
+Using Cursor CLI too? `claudinho init cursor` (from `@claudinho/cli`) puts the live score in its
+statusline and prints this config for you to paste.
+
+## Ask your first question
+
+The server answers for one competition at a time. Either name it in your question:
+
+> "What Champions League matches are on today?" · "Show me the Premier League table" ·
+> "When does Arsenal play next in the Champions League?"
+
+or choose it once with the CLI, and then just ask:
+
 ```bash
-codex mcp add claudinho -- npx -y @claudinho/mcp
+npx @claudinho/cli follow champions-league --team Arsenal
 ```
 
-**Claude Desktop / Windsurf / Zed / VS Code**: standard stdio config (same JSON as Cursor):
-Claude Desktop: Settings → Developer → Edit Config, then restart. Codex config file:
-`~/.codex/config.toml` (`[mcp_servers.claudinho]`, `command = "npx"`, `args = ["-y", "@claudinho/mcp"]`).
-
-Then just ask your agent naturally; it picks the right tool and answers with live data:
+> "What matches are on today?" · "Show me the live scores" · "When's our next game?" ·
+> "Make me a shareable card for today"
 
-> "What matches are on today?" · "Show me the live scores" · "What's Arsenal's next game?"
-> "Show the Premier League table" · "Show the World Cup bracket" · "Make me a shareable card for today"
+Without a competition, the tools that answer for one say how to choose it.
 
 ## Tools
 
+Every tool is read-only, and two of them never touch the network.
+
 | Tool | What it does |
 |---|---|
-| `get_today` | fixtures for a date (default: today), grouped in the caller's `tz`, live scores overlaid |
-| `get_live` | matches in play right now |
-| `get_match` | a single match by id; in a club competition, looked for from yesterday to 14 days ahead (`window` names the days searched when it is not there) |
-| `get_standings` | live cumulative standings: every table, or one by its key (a group letter, or `A1`, `A-B`, `LEAGUE`) |
-| `get_bracket` | knockout bracket from the Round of 32 through the final, with an optional `stage` filter (`R32`, `R16`, `QF`, `SF`, `3P`, `F`); the Premier League and LALIGA, league seasons with no knockout tie of their own, answer `inapplicable`; the other competitions off the World Cup answer `unsupported` (not offered yet) |
-| `get_next_fixture` | a team's next match, by name or code. A nation (`Mexico`, `MEX`): live-resolves a confirmed knockout tie from the feed, group fixtures offline, fails back to the bundled schedule if the feed is down; a club (`Arsenal`, `ARS`): its next match within 14 days, `candidates` when several teams match, `horizon` when it has none in that span. With no `team`: the server's `CLAUDINHO_TEAM`, else the team the user pinned (`claudinho follow <alias> --team <name>`) when the request is for its competition |
-| `get_market_signal` | read-only prediction-market signal for a match, a team's current-or-next fixture (in-play preferred while live), or a date; informational only |
-| `get_share_snippet` | a copy-pasteable plain-text card for a match, a team's next fixture, a group's standings table (`group`), the knockout bracket (`bracket: true`, optional `knockoutStage`), a date, or live; hand the returned snippet to the user as-is |
-| `get_team` | the World Cup roster: resolve a nation name or code to its FIFA 3-letter code, flag, and group; fuzzy (`Mexico`, `mex`, `DR Congo`, `Türkiye`); handy for the code `get_market_signal` needs. It knows no clubs. Offline (no network) |
-| `list_competitions` | the supported competitions: each one's alias (what `competition` takes), name, teams (nations or clubs), kind, and what it offers (scores, next, standings, bracket, markets: `offered`, `not-offered-yet`, `not-applicable`), plus `current`, the competition the request is for. Offline (no network) |
-
-Most tools are **read-only** (`readOnlyHint`) and accept optional `tz`, `lang`
-(`en`/`es`/`pt`/`fr`), `flavor` (`off`/`subtle`/`full`), and `competition`: an alias
-such as `premier-league` (from `list_competitions`) or an ESPN slug such as `eng.1`
-(without it: the server's `CLAUDINHO_COMPETITION`, else the user's saved choice, the one
-`claudinho follow <alias>` saves; an unknown value is a tool error listing the aliases).
-With none of the three, every competition-answering tool answers, before it reads
-anything, `noCompetition: true` and `competition: null` beside its empty shape, and a
-sentence saying what to do (pass `competition`, or the user runs `claudinho follow
-<alias>`); `list_competitions` answers `current: null`, and `get_team` answers as ever. Every competition-answering tool's text
-starts with the competition it is for (`Premier League · from the request`; a share
-card says it in its title instead) and its structured content carries it as
-`competition`. `get_team` (the World Cup's roster, whatever the competition) and
-`list_competitions` are read-only **and** offline. Every response carries
-human-readable text **and** structured content, validated against each tool's
-declared `outputSchema`. When the provider's knockout answer was not whole,
-`get_next_fixture`, `get_bracket` and the next/bracket share cards say so before
-what was read and carry `partial` (`omitted`: the count of provider records left
-out, when known); no fixture is then not "eliminated". `get_today`, `get_live`,
-`get_match`, `get_market_signal` and their share cards carry `partial` for their own
-reads too: an empty answer then means nothing was read, not that nothing exists, and a
-World Cup day counts the fixtures shown from the bundled schedule without their live
-state. In a club competition whose
-edition has ended (and the next has not started), `get_today`, `get_live`,
-`get_next_fixture` and `get_match` say so and carry `betweenEditions`. A club has no
-`flag` (a nation's is generated from its name), and nothing is printed in its place; a
-match's `stage` is the written one (`REGULAR` for a league's season, `LEAGUE` for a cup's
-league phase, `PO` for play-offs), or `OTHER` with the provider's own words in `stageLabel`.
-
-Resources: `standings://{group}` (its text starts with the competition it is for, like a tool's), `fixtures://{date}` (the bundled World Cup schedule, named first, whatever the competition). Prompts: `tournament_today`,
-and `my_team` (the competition you follow: give it a club's or a nation's code or name, or
-none for your team (the server's `CLAUDINHO_TEAM`, else the one pinned with `claudinho follow --team`);
-it asks for the next fixture with its date and state and the team's standing, and on the World Cup
-for the prediction-market read of that fixture).
-
-## Market signals
-
-Market signals are pre-match and in-play reads: finished matches never show one.
-`get_today` / `get_match` include a short market line when a reliable market exists
-(slugs are auto-derived per fixture; matching fails closed). Their structured output
-includes `marketComplete`; the dedicated market tool uses `complete`. A false verdict
-means the optional read was unavailable or incomplete and is never described as "no signal."
-Share cards carry the same verdict and warning. **Read-only and
-informational only, not betting advice:** market-implied percentages with Polymarket
-attribution, never links or trade calls. Disable with `CLAUDINHO_MARKETS=off`; set
-`CLAUDINHO_MARKETS_SOURCE=fake` in the server `env` for a network-free, clearly
-labeled synthetic preview.
-
-## Commentary flair
-
-Match lines in the text end with a short, localized exclamation for the match's
-moment (`— ¡GOOOOL!`): a few hundred lines in four languages, no real person named
-or impersonated, none repeated within one list while the bank lasts, never in the
-structured JSON. A team's own rally cry takes its place when one side has one
-(Mexico's `¿Y si sí?`, Pumas' `¡Goya!`, Arsenal's `COYG!`): when both do, the team
-saved with `claudinho follow --team` for that competition, else the home side's
-(the server's `CLAUDINHO_TEAM` is the team-taking tools' default query, not the
-cry's tiebreak). A row with a cry takes no line from the bank, a postponed or
-cancelled match prints neither, and the `fixtures://` resource prints a phrase,
-never a cry (it states no team kind). Control with `CLAUDINHO_FLAVOR`
-(`off`|`subtle`|`full`, default `full`; `subtle` is goals, full time, draws and
-the cries) in the server `env`, or per call via the `flavor` argument.
+| `get_today` | the fixtures for a date (default: today) in the caller's timezone, with live scores |
+| `get_live` | the matches in play right now |
+| `get_match` | one match by id, with the goals and cards the provider sent for a match in play or finished |
+| `get_next_fixture` | a team's next match, by name or code (`Arsenal`, `ARS`, `Mexico`, `MEX`); with no `team`, the server's `CLAUDINHO_TEAM`, else the team the user pinned (`claudinho follow <alias> --team <name>`) when the request is for its competition |
+| `get_standings` | the standings: every table, or one by its key (a group letter, or `A1`, `A-B`, `LEAGUE`) |
+| `get_bracket` | the knockout bracket, World Cup only, from the Round of 32 to the final; an optional `stage` (`R32`, `R16`, `QF`, `SF`, `3P`, `F`) keeps one round |
+| `get_share_snippet` | a plain-text card for a match, a team's next match, a table, the bracket (`bracket: true`, with an optional `knockoutStage`), a date or live; hand it to the user as it is |
+| `get_market_signal` | World Cup prediction-market odds for a match (`matchId`), a team's current or next match (`team`, a 3-letter code such as `MEX`), or a date; informational only |
+| `get_team` | a World Cup nation's name or code to its FIFA code, flag and group (offline) |
+| `list_competitions` | the supported competitions, the alias each takes and what each offers, and the one in effect (offline) |
+
+Every tool but `get_team` takes an optional `competition` (an alias such as `champions-league`), and
+most take `tz`, `lang` (`en`, `es`, `pt`, `fr`) and `flavor` (`off`, `subtle`, `full`).
+
+Resources: `standings://{group}`, and `fixtures://{date}` (the bundled World Cup schedule).
+Prompts: `my_team` (your team's next match and its standing, in the competition you follow) and
+`tournament_today`.
+
+## Prediction-market odds (World Cup)
+
+For World Cup matches, `get_today`, `get_match` and a `get_share_snippet` card for a match, a
+team's next match or a date add a short "who's favored" line when a reliable Polymarket market
+exists, and `get_market_signal` reads one on its own. **Informational only, not betting advice:**
+market-implied percentages with Polymarket's attribution, never links or trade calls. Finished
+matches never show one. `CLAUDINHO_MARKETS=off` in the server's `env` turns the short line off;
+`get_market_signal` still answers.
+
+## Commentary
+
+A match line in a tool's text ends with a short line of commentary in the reader's language
+(`— ¡GOOOOL!`), or a team's own rally cry when it has one (Mexico's `¿Y si sí?`, Pumas' `¡Goya!`,
+Arsenal's `COYG!`). A postponed or cancelled match gets neither. The commentary never appears in
+the structured data. Turn it down with `CLAUDINHO_FLAVOR=subtle` or `off` in the server's `env`, or
+per call with `flavor`.
+
+## Details for agent builders
+
+**Choosing the competition.** A request's competition is its `competition` argument, else the
+server's `CLAUDINHO_COMPETITION`, else the choice `claudinho follow <alias>` saved. An unknown value
+is a tool error that lists the aliases. With none of the three, every competition-answering tool
+answers `noCompetition: true` and `competition: null` beside its empty shape, with a sentence saying
+what to do; `list_competitions` answers `current: null`.
+
+**What every answer carries.** Human-readable text and structured content, validated against each
+tool's declared `outputSchema`. The text starts with the competition it is for (a share card says it
+in its title), and the structured content carries it as `competition`. Two tools differ:
+`get_team` reads the World Cup's nations whatever the competition and carries no `competition`, and
+`list_competitions` names the one in effect last in its text and as `current` in its data.
+
+**Answers that are not whole.** When the provider sent records that could not be read,
+`get_today`, `get_live`, `get_match`, `get_next_fixture`, `get_bracket`, `get_market_signal` and
+`get_share_snippet` say so before what they show and carry `partial` (with `omitted`, the count of
+records left out, when it is known). An empty answer then means nothing was read, not that nothing
+exists. In particular, a missing next match does not mean a team is out.
+
+**Club competitions.** `get_next_fixture` and `get_match` search from yesterday to 14 days ahead:
+an empty answer carrying `horizon` or `window` is about that span. Several teams matching one name
+come back as `candidates`. Between two seasons, `get_today`, `get_live`, `get_next_fixture` and
+`get_match` carry `betweenEditions`. `get_bracket` answers `inapplicable` for a league season with no
+knockout tie (the Premier League, LALIGA), and `unsupported` for every other competition but the
+World Cup. A club has no `flag`. A match's `stage` is `REGULAR` for a league's season, `LEAGUE` for
+a cup's league phase, `PO` for play-offs, or `OTHER` with the provider's own words in `stageLabel`.
+
+**Markets.** `get_today`, `get_match` and a `get_share_snippet` card for a match, a team's next
+match, a date or live matches carry `marketComplete` (a table or bracket card does not), and
+`get_market_signal` carries `complete`. `false` means the
+optional market read did not finish, which is not the same as "no signal"; the text, and a share
+card, say so too. `CLAUDINHO_MARKETS_SOURCE=fake` gives a clearly labelled, network-free preview.
+
+**The process.** Stdout carries only the MCP protocol; diagnostics go to stderr.
+`CLAUDINHO_DEBUG=1` in the server's `env` prints the data provider's failures there.
 
 ## How it works
 
-The World Cup's 104 fixtures ship bundled in the package; the other competitions'
-schedules are read from the feed, and live state always hits the network: live scores
-from **ESPN's** public scoreboard (swappable provider, attributed in output), market
-signals from Polymarket. Stdout carries only the MCP protocol;
-diagnostics go to stderr.
+The World Cup's 104 fixtures ship with the package. Every other competition's schedule, and every
+live score, comes from ESPN's public scoreboard (an answer from it names ESPN). World Cup market odds
+come from Polymarket's public data. The server keeps its cache in memory only.
 
-## Privacy Policy
+## Privacy
 
-No personal data collected: no accounts, no telemetry, no analytics, no tracking, and no
-Claudinho server. To show live scores, Claudinho makes read-only requests to public services
-(ESPN; Polymarket for informational-only market signals) with no account or personal data
-attached, though those services still receive standard request metadata (such as your IP
-address) like any HTTP call. The MCP server keeps its cache **in memory only** and writes
-nothing to disk. Full policy: [PRIVACY.md](https://github.com/arturogarrido/claudinho/blob/main/PRIVACY.md).
+No accounts, no telemetry, no analytics, no tracking, and no Claudinho server. The server asks ESPN
+(and Polymarket, for World Cup odds) for public data with nothing about you attached; those services
+still see standard request metadata, such as your IP address, like any web request. It writes
+nothing to disk. Full policy:
+[PRIVACY.md](https://github.com/arturogarrido/claudinho/blob/main/PRIVACY.md).
 
 ## License
 
-MIT © 2026 Arturo Garrido · [source & issues](https://github.com/arturogarrido/claudinho)
-
-> **Not affiliated with FIFA, any confederation, league or club, or Anthropic. Nor endorsed by or connected to any of them.** An independent,
-> open-source fan project showing factual match data with emoji flags only: no logos, crests,
-> kits, broadcast footage, or player likenesses.
+MIT © 2026 Arturo Garrido · [source and issues](https://github.com/arturogarrido/claudinho)
 
----
+Independent fan project. Not affiliated with FIFA, any confederation, league or club, or Anthropic.
 
 _Built while watching the games._ **#VibingLaVidaLoca** ⚽

package/dist/index.js

@@ -342,6 +342,13 @@ var EN = {
   "status.fullTime": "full-time",
   "status.postponed": "postponed",
   "status.cancelled": "cancelled",
+  // A timeline row's kind word (core `timelineRows`).
+  "event.goal": "Goal",
+  "event.ownGoal": "Own goal",
+  "event.penalty": "Penalty",
+  "event.yellow": "Yellow card",
+  "event.red": "Red card",
+  "event.sub": "Substitution",
   "live.title": "Live now",
   "today.title": "Today's matches",
   "today.on": "Matches",
@@ -350,6 +357,23 @@ var EN = {
   "next.in": "in {countdown}",
   // A kickoff that has passed, where the countdown would say "in" (core `countdownPhrase`).
   "countdown.now": "now",
+  // The ambient line's syncing phrase (`claudinho ambient --json` alone; the
+  // statusline's own `prompt` stays English).
+  "ambient.syncing": "live \xB7 syncing\u2026",
+  // The plugin's moment words, sent by `claudinho ambient --json` as `words`
+  // (`{team}` a template the plugin fills with the record's own names). Each
+  // at most 40 characters; `{team}` once in `moment.goalFor` and `moment.win`
+  // and nowhere else, or the plugin falls back to its English words.
+  "moment.goal": "GOAL!",
+  "moment.ownGoal": "Own goal",
+  "moment.ownGoalDetail": "own goal",
+  "moment.goalFor": "Goal for {team}",
+  "moment.goals": "Goals",
+  "moment.scoreUpdated": "Score updated",
+  "moment.penalties": "Penalties",
+  "moment.fullTime": "Full time",
+  "moment.win": "{team} win",
+  "moment.draw": "Draw",
   // A title that introduces the lines below it (the MCP text).
   heading: "{title}:",
   // A list's empty state and the outage lines: the CLI's sentences, the MCP
@@ -361,6 +385,7 @@ var EN = {
   "feed.earlierRecord": "Live state could not be refreshed \u2014 showing the provider's earlier record.",
   "next.none": "No upcoming fixture found for {team}.",
   "match.none": "No match found with id {id}.",
+  "match.kickoff": "Kickoff",
   // The MCP text's own sentences for these states (the CLI says `live.degraded`
   // there): they keep the team or the id the answer is about.
   "next.unreachable": "Couldn't reach the data provider \u2014 no upcoming fixture confirmed for {team}.",
@@ -438,6 +463,12 @@ var ES = {
   "status.fullTime": "finalizado",
   "status.postponed": "aplazado",
   "status.cancelled": "cancelado",
+  "event.goal": "Gol",
+  "event.ownGoal": "Gol en contra",
+  "event.penalty": "Penal",
+  "event.yellow": "Tarjeta amarilla",
+  "event.red": "Tarjeta roja",
+  "event.sub": "Cambio",
   "live.title": "En vivo",
   "today.title": "Partidos de hoy",
   "today.on": "Partidos",
@@ -445,6 +476,17 @@ var ES = {
   "next.label": "Pr\xF3ximo partido de {team}",
   "next.in": "en {countdown}",
   "countdown.now": "ahora",
+  "ambient.syncing": "en vivo \xB7 sincronizando\u2026",
+  "moment.goal": "\xA1GOL!",
+  "moment.ownGoal": "Gol en contra",
+  "moment.ownGoalDetail": "gol en contra",
+  "moment.goalFor": "Gol de {team}",
+  "moment.goals": "Goles",
+  "moment.scoreUpdated": "Marcador corregido",
+  "moment.penalties": "Penales",
+  "moment.fullTime": "Final",
+  "moment.win": "Gana {team}",
+  "moment.draw": "Empate",
   heading: "{title}:",
   "today.none": "No hay partidos para esta fecha.",
   "live.none": "No hay partidos en juego ahora mismo.",
@@ -453,6 +495,7 @@ var ES = {
   "feed.earlierRecord": "No se pudo actualizar el estado en vivo \u2014 se muestra el registro anterior del proveedor.",
   "next.none": "No se encontr\xF3 pr\xF3ximo partido para {team}.",
   "match.none": "No se encontr\xF3 partido con id {id}.",
+  "match.kickoff": "Inicio",
   "next.unreachable": "No se pudo contactar al proveedor de datos \u2014 ning\xFAn pr\xF3ximo partido confirmado para {team}.",
   "match.unreachable": "No se pudo contactar al proveedor de datos \u2014 no se pudo consultar el partido {id}.",
   "team.ambiguous": '"{query}" es ambiguo. \xBFQuisiste decir:',
@@ -527,6 +570,12 @@ var PT = {
   "status.fullTime": "encerrado",
   "status.postponed": "adiado",
   "status.cancelled": "cancelado",
+  "event.goal": "Gol",
+  "event.ownGoal": "Gol contra",
+  "event.penalty": "P\xEAnalti",
+  "event.yellow": "Cart\xE3o amarelo",
+  "event.red": "Cart\xE3o vermelho",
+  "event.sub": "Substitui\xE7\xE3o",
   "live.title": "Ao vivo",
   "today.title": "Jogos de hoje",
   "today.on": "Jogos",
@@ -534,6 +583,17 @@ var PT = {
   "next.label": "Pr\xF3ximo jogo de {team}",
   "next.in": "em {countdown}",
   "countdown.now": "agora",
+  "ambient.syncing": "ao vivo \xB7 sincronizando\u2026",
+  "moment.goal": "GOL!",
+  "moment.ownGoal": "Gol contra",
+  "moment.ownGoalDetail": "gol contra",
+  "moment.goalFor": "Gol \xB7 {team}",
+  "moment.goals": "Gols",
+  "moment.scoreUpdated": "Placar corrigido",
+  "moment.penalties": "P\xEAnaltis",
+  "moment.fullTime": "Fim de jogo",
+  "moment.win": "{team} vence",
+  "moment.draw": "Empate",
   heading: "{title}:",
   "today.none": "Nenhum jogo para esta data.",
   "live.none": "Nenhum jogo em andamento agora.",
@@ -542,6 +602,7 @@ var PT = {
   "feed.earlierRecord": "N\xE3o foi poss\xEDvel atualizar o estado ao vivo \u2014 mostrando o registro anterior do provedor.",
   "next.none": "Nenhum pr\xF3ximo jogo encontrado para {team}.",
   "match.none": "Nenhum jogo encontrado com id {id}.",
+  "match.kickoff": "In\xEDcio",
   "next.unreachable": "N\xE3o foi poss\xEDvel contatar o provedor de dados \u2014 nenhum pr\xF3ximo jogo confirmado para {team}.",
   "match.unreachable": "N\xE3o foi poss\xEDvel contatar o provedor de dados \u2014 o jogo {id} n\xE3o p\xF4de ser consultado.",
   "team.ambiguous": '"{query}" \xE9 amb\xEDguo. Voc\xEA quis dizer:',
@@ -616,6 +677,12 @@ var FR = {
   "status.fullTime": "termin\xE9",
   "status.postponed": "report\xE9",
   "status.cancelled": "annul\xE9",
+  "event.goal": "But",
+  "event.ownGoal": "But contre son camp",
+  "event.penalty": "Penalty",
+  "event.yellow": "Carton jaune",
+  "event.red": "Carton rouge",
+  "event.sub": "Remplacement",
   "live.title": "En direct",
   "today.title": "Matchs d'aujourd'hui",
   "today.on": "Matchs",
@@ -623,6 +690,17 @@ var FR = {
   "next.label": "Prochain match de {team}",
   "next.in": "dans {countdown}",
   "countdown.now": "maintenant",
+  "ambient.syncing": "en direct \xB7 synchronisation\u2026",
+  "moment.goal": "BUT !",
+  "moment.ownGoal": "But contre son camp",
+  "moment.ownGoalDetail": "contre son camp",
+  "moment.goalFor": "But pour {team}",
+  "moment.goals": "Buts",
+  "moment.scoreUpdated": "Score corrig\xE9",
+  "moment.penalties": "Tirs au but",
+  "moment.fullTime": "Fin du match",
+  "moment.win": "{team} gagne",
+  "moment.draw": "Match nul",
   heading: "{title} :",
   "today.none": "Aucun match pr\xE9vu pour cette date.",
   "live.none": "Aucun match en cours pour l'instant.",
@@ -631,6 +709,7 @@ var FR = {
   "feed.earlierRecord": "L\u2019\xE9tat en direct n\u2019a pas pu \xEAtre actualis\xE9 \u2014 affichage de l\u2019enregistrement pr\xE9c\xE9dent du fournisseur.",
   "next.none": "Aucun prochain match trouv\xE9 pour {team}.",
   "match.none": "Aucun match trouv\xE9 avec id {id}.",
+  "match.kickoff": "Coup d\u2019envoi",
   "next.unreachable": "Impossible de joindre le fournisseur de donn\xE9es \u2014 aucun prochain match confirm\xE9 pour {team}.",
   "match.unreachable": "Impossible de joindre le fournisseur de donn\xE9es \u2014 le match {id} n\u2019a pas pu \xEAtre consult\xE9.",
   "team.ambiguous": '"{query}" est ambigu. Vouliez-vous dire :',
@@ -769,7 +848,7 @@ function formatTime(iso, opts = {}) {
   }).format(when);
 }
 var COUNTDOWN_NOW = "now";
-function countdown(iso, from = /* @__PURE__ */ new Date()) {
+function countdown(iso, from) {
   const when = parsedDate(iso);
   if (!when) return UNKNOWN_TIME;
   const ms = when.getTime() - from.getTime();
@@ -782,7 +861,7 @@ function countdown(iso, from = /* @__PURE__ */ new Date()) {
   if (hours > 0) return `${hours}h${mins}m`;
   return `${mins}m`;
 }
-function countdownPhrase(lang, iso, from = /* @__PURE__ */ new Date()) {
+function countdownPhrase(lang, iso, from) {
   const left = countdown(iso, from);
   return left === COUNTDOWN_NOW ? t(lang, "countdown.now") : t(lang, "next.in", { countdown: left });
 }
@@ -832,6 +911,48 @@ function withFlag(text, flag2, side) {
   if (typeof flag2 !== "string" || flag2 === "") return text;
   return side === "home" ? `${flag2} ${text}` : `${text} ${flag2}`;
 }
+var KIND_KEYS = Object.freeze({
+  GOAL: "event.goal",
+  OWN_GOAL: "event.ownGoal",
+  PEN: "event.penalty",
+  YELLOW: "event.yellow",
+  RED: "event.red",
+  SUB: "event.sub"
+});
+var KIND_MARKS = Object.freeze({
+  GOAL: "\u26BD",
+  OWN_GOAL: "\u26BD",
+  PEN: "\u26BD",
+  YELLOW: "\u{1F7E8}",
+  RED: "\u{1F7E5}",
+  SUB: "\u{1F504}"
+});
+function timelineParts(match, opts) {
+  const events = match.events ?? [];
+  if (events.length === 0) return [];
+  const cells = events.map((e) => {
+    const team = e.side === "home" ? match.home : match.away;
+    return {
+      minute: e.added !== void 0 ? `${e.minute}+${e.added}'` : `${e.minute}'`,
+      mark: KIND_MARKS[e.type],
+      kind: t(opts.lang, KIND_KEYS[e.type]),
+      label: withFlag(team.code, opts.flags ? team.flag : void 0, e.side),
+      player: e.player
+    };
+  });
+  const widest = (pick2) => Math.max(...cells.map((c) => displayWidth(pick2(c))));
+  const minuteW = widest((c) => c.minute);
+  const kindW = widest((c) => c.kind);
+  const labelW = widest((c) => c.label);
+  return cells.map((c) => {
+    const columns = `  ${padVisible(c.minute, minuteW)}  ${c.mark} ${padVisible(c.kind, kindW)}  ${padVisible(c.label, labelW)}`;
+    if (!c.player) return [{ text: columns.trimEnd() }];
+    return [{ text: `${columns}  ` }, { text: c.player, style: "strong" }];
+  });
+}
+function timelineRows(match, opts) {
+  return timelineParts(match, opts).map((row) => row.map((p) => p.text).join(""));
+}
 function outcomeFromScore(home, away) {
   if (home > away) return "H";
   if (home < away) return "A";
@@ -1113,18 +1234,33 @@ function sealScorePair(raw) {
   const away = count(v.away, MAX_GOALS);
   return home !== void 0 && away !== void 0 ? { home, away } : void 0;
 }
+var MAX_ADDED_MINUTES = 30;
+var SIDES = /* @__PURE__ */ new Set(["home", "away"]);
 function sealEvent(raw) {
-  if (!raw || typeof raw !== "object") return void 0;
+  if (!raw || typeof raw !== "object") return null;
   const e = raw;
   const type = member(e.type, EVENT_TYPES);
-  if (!type) return void 0;
+  if (!type) return null;
   const minute = count(e.minute, MAX_MINUTE);
-  if (minute === void 0) return void 0;
-  const out = { type, minute, teamCode: humanLabel(e.teamCode, TEAM_CODE_COLUMNS) };
+  if (minute === void 0) return null;
+  let added;
+  if (e.added !== void 0) {
+    added = count(e.added, MAX_ADDED_MINUTES);
+    if (added === void 0 || added < 1) return null;
+  }
+  const side = member(e.side, SIDES);
+  if (!side) return null;
+  const out = { type, minute };
+  if (added !== void 0) out.added = added;
+  out.side = side;
+  out.teamCode = humanLabel(e.teamCode, TEAM_CODE_COLUMNS);
   const player = humanLabel(e.player);
   if (player) out.player = player;
   return out;
 }
+function byClock(a, b) {
+  return a.minute - b.minute || (a.added ?? 0) - (b.added ?? 0);
+}
 function sealMatch(parts, opts = {}) {
   if (!parts || typeof parts !== "object") return malformed("match is not an object");
   const id = opaqueId(parts.id, ESPN_ID);
@@ -1169,7 +1305,8 @@ function sealMatch(parts, opts = {}) {
       winnerCode = claimedWinner;
     }
   }
-  const events = opts.events === false ? [] : takeBounded(parts.events, MAX_MATCH_EVENTS).map(sealEvent).filter((e) => !!e);
+  const timelined = status === "LIVE" || status === "HT" || status === "FT";
+  const events = opts.events === false || !timelined ? [] : takeBounded(parts.events, MAX_MATCH_EVENTS).map(sealEvent).filter((e) => !!e).sort(byClock);
   const out = { id, stage };
   if (stageLabel2) out.stageLabel = stageLabel2;
   if (group) out.group = group;
@@ -4290,6 +4427,75 @@ function parseMinute(st) {
   }
   return void 0;
 }
+var DETAIL_FLAGS = ["scoringPlay", "yellowCard", "redCard", "penaltyKick", "ownGoal", "shootout"];
+var DETAIL_MINUTE = /^(\d{1,3})'$/;
+var DETAIL_MINUTE_ADDED = /^(\d{1,3})'\+(\d{1,2})'$/;
+function detailKind(d) {
+  const f = {};
+  for (const name of DETAIL_FLAGS) {
+    const v = flag(d[name]);
+    if (v === void 0) return void 0;
+    f[name] = v;
+  }
+  if (f.shootout) return void 0;
+  const { scoringPlay: s, yellowCard: y, redCard: r, penaltyKick: p, ownGoal: o } = f;
+  if (s && !y && !r) {
+    if (!p && !o) return "GOAL";
+    if (o && !p) return "OWN_GOAL";
+    if (p && !o) return "PEN";
+    return void 0;
+  }
+  if (p || o || s) return void 0;
+  if (y && !r) return "YELLOW";
+  if (r && !y) return "RED";
+  return void 0;
+}
+function detailMinute(clock) {
+  if (!clock || typeof clock !== "object") return void 0;
+  const dv = clock.displayValue;
+  if (typeof dv !== "string") return void 0;
+  const plain = DETAIL_MINUTE.exec(dv);
+  if (plain) return { minute: Number(plain[1]) };
+  const extra = DETAIL_MINUTE_ADDED.exec(dv);
+  if (!extra) return void 0;
+  return { minute: Number(extra[1]), added: Number(extra[2]) };
+}
+function rawTeamId(holder) {
+  if (!holder || typeof holder !== "object") return void 0;
+  const team = holder.team;
+  if (!team || typeof team !== "object") return void 0;
+  return opaqueId(team.id, ESPN_ID);
+}
+function detailEvents(details, sides) {
+  const out = [];
+  for (const raw of takeBounded(details, MAX_MATCH_EVENTS)) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+    const d = raw;
+    const type = detailKind(d);
+    if (!type) continue;
+    const when = detailMinute(d.clock);
+    if (!when) continue;
+    const teamId = rawTeamId(d);
+    const side = teamId === void 0 ? void 0 : teamId === sides.homeId ? "home" : teamId === sides.awayId ? "away" : void 0;
+    if (!side) continue;
+    const event = { type, minute: when.minute };
+    if (when.added !== void 0) event.added = when.added;
+    event.side = side;
+    event.teamCode = side === "home" ? sides.homeCode : sides.awayCode;
+    const player = detailPlayer(d.athletesInvolved, type === "OWN_GOAL" ? side === "home" ? sides.awayId : sides.homeId : teamId);
+    if (player) event.player = player;
+    out.push(event);
+  }
+  return out;
+}
+function detailPlayer(athletes, expectedTeamId) {
+  if (!Array.isArray(athletes) || athletes.length !== 1 || expectedTeamId === void 0) return void 0;
+  const a = athletes[0];
+  if (rawTeamId(a) !== expectedTeamId) return void 0;
+  const name = a.displayName;
+  if (!isHumanLabel(name)) return void 0;
+  return humanLabel(name) || void 0;
+}
 var MAX_SLUG_UNITS2 = 64;
 var SLUG = /^[a-z0-9-]+$/;
 var EXACT_STAGE = Object.freeze({
@@ -4411,7 +4617,14 @@ function parseEspnEvent(raw, ctx = {}) {
       status,
       winnerCode,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      events: ev.events
+      // The goals and cards: ESPN's `details`, read by the detail grammar; the
+      // seal keeps them only on a status that holds a score.
+      events: detailEvents(comp?.details, {
+        homeId: rawTeamId(homeRaw),
+        awayId: rawTeamId(awayRaw),
+        homeCode: home.code,
+        awayCode: away.code
+      })
     },
     // The final reseal states the same kind the competitors were built with.
     { teamKind: kind }
@@ -4728,7 +4941,7 @@ function fetchMeta(result) {
 }
 var ESPN_SOCCER = "https://site.api.espn.com/apis/site/v2/sports/soccer";
 var DEFAULT_COMPETITION = BUNDLED_SLUG;
-var USER_AGENT = `claudinho/${"0.11.1"} (+https://github.com/arturogarrido/claudinho)`;
+var USER_AGENT = `claudinho/${"0.12.0"} (+https://github.com/arturogarrido/claudinho)`;
 var MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
 var DEFAULT_COOLDOWN_MS = 5 * 6e4;
 var MAX_COOLDOWN_MS = 15 * 6e4;
@@ -6217,6 +6430,9 @@ function mergeLive(base, live) {
 function clockOf(adapter) {
   return new Date(adapter.now?.() ?? Date.now());
 }
+function requestClock(adapter, given) {
+  return given ?? clockOf(adapter);
+}
 function providerDayOf(adapter, instant) {
   if (Number.isNaN(instant.getTime())) return "";
   return adapter.bucketDay?.(instant) || instant.toISOString().slice(0, 10);
@@ -6391,7 +6607,7 @@ async function marketFixtureForTeam(adapter, code, now = /* @__PURE__ */ new Dat
   });
   let refreshRead = {};
   if (candidate) {
-    const { partial, served: _served, ...r } = await getMatchById(adapter, candidate.id);
+    const { partial, served: _served, ...r } = await getMatchById(adapter, candidate.id, now);
     refreshRead = partial ? { partial } : {};
     const m = r.degraded ? candidate : r.match ?? candidate;
     if (!isFinished(m.status)) return { ...r, match: m, ...bothReads(windowRead, refreshRead) };
@@ -6600,10 +6816,19 @@ async function getScheduleAhead(adapter, now = /* @__PURE__ */ new Date()) {
   };
 }
 async function getLiveMatches(adapter, now = /* @__PURE__ */ new Date()) {
-  const { complete: _complete, ...result } = await getLiveRead(adapter, now);
+  const { complete: _complete, finished: _finished, finishedTruncated: _truncated, ...result } = await getLiveRead(adapter, now);
   return result;
 }
-async function getLiveRead(adapter, now = /* @__PURE__ */ new Date()) {
+var MAX_LIVE_FINISHED = 64;
+function finishedOf(records, seen) {
+  const wanted = new Set(takeBounded(seen, MAX_LIVE_FINISHED));
+  const done = records.filter((m) => m.status === "FT" && m.score !== void 0);
+  const first = done.filter((m) => wanted.has(m.id));
+  const rest = done.filter((m) => !wanted.has(m.id));
+  const all = [...first, ...rest];
+  return { finished: all.slice(0, MAX_LIVE_FINISHED), truncated: all.length > MAX_LIVE_FINISHED };
+}
+async function getLiveRead(adapter, now = /* @__PURE__ */ new Date(), seen = []) {
   try {
     const day = now.toISOString().slice(0, 10);
     const fetched = adapter.fetchWindow ? await adapter.fetchWindow(shiftUtcDate(day, -1), shiftUtcDate(day, 1), { acrossSeasons: true }) : await adapter.fetchLive();
@@ -6611,6 +6836,7 @@ async function getLiveRead(adapter, now = /* @__PURE__ */ new Date()) {
     const season = meta?.season;
     const matches = fetched.filter((m) => isLive(m.status));
     const between = betweenEditionsOf(adapter, meta, fetched, providerDayOf(adapter, now));
+    const done = finishedOf(fetched, seen);
     return {
       matches,
       degraded: false,
@@ -6622,10 +6848,12 @@ async function getLiveRead(adapter, now = /* @__PURE__ */ new Date()) {
       // boolean below is the refresher's, unchanged: false for that, for an
       // adapter that said nothing, and for a failed read alike.
       ...partialOfRead(meta),
-      complete: meta?.complete === true
+      complete: meta?.complete === true,
+      finished: done.finished,
+      finishedTruncated: done.truncated
     };
   } catch {
-    return { matches: [], degraded: true, complete: false };
+    return { matches: [], degraded: true, complete: false, finished: [], finishedTruncated: false };
   }
 }
 function norm2(s) {
@@ -6869,19 +7097,26 @@ function sealMarketSignal(raw, options = {}) {
   if (sourceMarketId) out.sourceMarketId = sourceMarketId;
   out.asOf = canonicalTimestamp(s.asOf) ?? "";
   out.fetchedAt = canonicalTimestamp(s.fetchedAt) ?? "";
+  const judgedAt = options.now ?? /* @__PURE__ */ new Date();
+  const fetchedMs = Date.parse(out.fetchedAt);
+  if (out.fetchedAt === "" || !Number.isFinite(fetchedMs)) {
+    return malformed("signal carries no readable fetch time");
+  }
+  if (fetchedMs > judgedAt.getTime()) {
+    return unresolved("signal was fetched after the clock it is judged by");
+  }
   out.outcomes = outcomes;
   const isAmbiguous = s.ambiguous !== false;
   const favorite = isAmbiguous ? void 0 : deriveFavorite(outcomes);
   if (favorite) out.favorite = favorite;
   if (liquidity !== void 0) out.liquidity = liquidity;
   if (volume24h !== void 0) out.volume24h = volume24h;
-  out.stale = s.stale !== false;
+  out.stale = isStaleSignal(out, { now: judgedAt, maxAgeMs: options.maxAgeMs });
   out.ambiguous = isAmbiguous || out.source === "";
-  out.stale = out.stale || isStaleSignal(out, { now: options.now, maxAgeMs: options.maxAgeMs });
   return valid(out);
 }
 var DEFAULT_MAX_AGE_MS = 15 * 6e4;
-function marketRelevant(match, now = /* @__PURE__ */ new Date()) {
+function marketRelevant(match, now) {
   if (isLive(match.status)) return true;
   if (isFinished(match.status)) return false;
   const k = Date.parse(match.kickoff);
@@ -6970,12 +7205,13 @@ function buildMarketSignal(input) {
   const outcomes = normalizeOutcomes(input.outcomes);
   const ambiguous2 = input.ambiguous === true || !mapsCleanly(input.match, outcomes);
   const favorite = ambiguous2 ? void 0 : deriveFavorite(outcomes);
+  const clock = input.now ?? /* @__PURE__ */ new Date();
   const signal = {
     matchId: input.match.id,
     source: input.source,
     sourceMarketId: input.sourceMarketId,
     asOf: input.asOf,
-    fetchedAt: input.fetchedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    fetchedAt: input.fetchedAt ?? clock.toISOString(),
     outcomes,
     favorite,
     liquidity: input.liquidity,
@@ -6983,8 +7219,8 @@ function buildMarketSignal(input) {
     stale: false,
     ambiguous: ambiguous2
   };
-  signal.stale = isStaleSignal(signal, { now: input.now, maxAgeMs: input.maxAgeMs });
-  const sealed = sealMarketSignal(signal, { now: input.now, maxAgeMs: input.maxAgeMs });
+  signal.stale = isStaleSignal(signal, { now: clock, maxAgeMs: input.maxAgeMs });
+  const sealed = sealMarketSignal(signal, { now: clock, maxAgeMs: input.maxAgeMs });
   if (sealed.kind !== "valid") {
     return { ...signal, outcomes: [], favorite: void 0, stale: true, ambiguous: true };
   }
@@ -8079,13 +8315,13 @@ var STATUS_KEY = {
 function flairOptsOf(opts) {
   return { level: opts.flavor, locale: opts.locale, kind: opts.teamKind, pin: opts.pin };
 }
-function matchLine(m, opts = {}, flair = matchFlair(m, flairOptsOf(opts))) {
+function matchLine(m, opts, flair = matchFlair(m, flairOptsOf(opts))) {
   const head = `${withFlag(m.home.name, m.home.flag, "home")} ${scoreline(m)} ${withFlag(m.away.name, m.away.flag, "away")}`;
   const lang = opts.locale;
   const stage = stageLabelI18n(lang, m);
   let tail;
   if (m.status === "SCHEDULED") {
-    tail = `${formatKickoff(m.kickoff, opts)} (${countdownPhrase(lang, m.kickoff)})`;
+    tail = `${formatKickoff(m.kickoff, opts)} (${countdownPhrase(lang, m.kickoff, opts.now)})`;
   } else if (m.status === "LIVE") {
     tail = m.minute ? `${t(lang, "status.live")} ${m.minute}'` : t(lang, "status.live");
   } else {
@@ -8104,7 +8340,7 @@ function truncationNote(list) {
 function headingLine(lang, title) {
   return t(lang, "heading", { title });
 }
-function matchRows(matches, empty, opts = {}) {
+function matchRows(matches, empty, opts) {
   if (matches.length === 0) return empty;
   const shown = matches.slice(0, MAX_LIST_MATCHES);
   const flairs = matchFlairs(shown, flairOptsOf(opts));
@@ -8114,7 +8350,7 @@ function listTruncation(matches) {
   const overflow = matches.length - MAX_LIST_MATCHES;
   return overflow > 0 ? `(list truncated \u2014 ${overflow} more not shown)` : void 0;
 }
-function matchList(matches, empty, opts = {}) {
+function matchList(matches, empty, opts) {
   const rows = matchRows(matches, empty, opts);
   const truncated = listTruncation(matches);
   return truncated ? `${rows}
@@ -8326,56 +8562,60 @@ var MARKETS_TOOL_OPTS = { deadlineMs: 12e3, timeoutMs: 6e3 };
 function memKey(competition, id) {
   return `polymarket:${competition}:${id}`;
 }
-async function cachedMarketSignals(args, matches, providerFactory = makeMarketProvider) {
+async function cachedMarketSignals(args, matches, now, providerFactory = makeMarketProvider) {
+  const clock = { now };
   if (args.marketProvider) {
-    const batch = await getMarketSignals(args.marketProvider, matches);
+    const batch = await getMarketSignals(args.marketProvider, matches, clock);
     return { signals: resolvedValues(batch), complete: batch.complete };
   }
   const source = resolveMarketSource();
   const competition = competitionOf(args);
   if (source !== "polymarket") {
-    const batch = await getMarketSignals(
-      providerFactory(source, competition),
-      matches,
-      DEFAULT_ON_MARKET_OPTS
-    );
+    const batch = await getMarketSignals(providerFactory(source, competition), matches, {
+      ...DEFAULT_ON_MARKET_OPTS,
+      ...clock
+    });
     return { signals: resolvedValues(batch), complete: batch.complete };
   }
-  const now = Date.now();
+  const memNow = Date.now();
   const result = /* @__PURE__ */ new Map();
   const miss = [];
   for (const m of matches) {
     const e = marketMem.get(memKey(competition, m.id));
     const ttl = e?.signal ? MEM_POSITIVE_TTL : MEM_NEGATIVE_TTL;
-    const fresh = e && now - e.at <= ttl;
-    if (fresh && (!e.signal || marketSignalRendersFor(m, e.signal))) {
-      if (e.signal) result.set(m.id, e.signal);
+    const fresh = e && memNow - e.at <= ttl;
+    if (!fresh) {
+      miss.push(m);
+      continue;
+    }
+    if (!e.signal) continue;
+    const resealed = sealMarketSignal(e.signal, { now });
+    if (resealed.kind === "valid" && marketSignalRendersFor(m, resealed.value)) {
+      result.set(m.id, resealed.value);
     } else {
       miss.push(m);
     }
   }
   let complete = true;
   if (miss.length > 0) {
-    const batch = await getMarketSignals(
-      providerFactory("polymarket", competition),
-      miss,
-      DEFAULT_ON_MARKET_OPTS
-    );
+    const batch = await getMarketSignals(providerFactory("polymarket", competition), miss, {
+      ...DEFAULT_ON_MARKET_OPTS,
+      ...clock
+    });
     const fetched = resolvedValues(batch);
     complete = batch.complete;
     for (const id of cacheableKeys(batch)) {
-      marketMem.set(memKey(competition, id), { at: now, signal: fetched.get(id) ?? null });
+      marketMem.set(memKey(competition, id), { at: memNow, signal: fetched.get(id) ?? null });
     }
     for (const [id, s] of fetched) result.set(id, s);
   }
   return { signals: result, complete };
 }
-async function reliableMarketData(args, matches) {
+async function reliableMarketData(args, matches, now) {
   if (!marketsEnabled()) return { data: void 0, complete: true };
-  const now = args.now ?? /* @__PURE__ */ new Date();
   const relevant = matches.filter((m) => marketRelevant(m, now));
   if (relevant.length === 0) return { data: void 0, complete: true };
-  const result = await cachedMarketSignals(args, relevant);
+  const result = await cachedMarketSignals(args, relevant, now);
   const out = {};
   for (const m of relevant) {
     const s = result.signals.get(m.id);
@@ -8388,9 +8628,11 @@ async function reliableMarketData(args, matches) {
     complete: result.complete
   };
 }
-function fmtOpts(args, competition) {
+function fmtOpts(args, competition, now) {
   const pin = choiceOf(args).pin;
   return {
+    // The tool's clock, read once where the tool reads it: a line's countdown is relative to it.
+    now,
     tz: args.tz,
     locale: args.lang,
     flavor: asFlavorLevel(args.flavor ?? process.env.CLAUDINHO_FLAVOR),
@@ -8431,17 +8673,18 @@ function toolGetToday(args) {
 }
 async function todayAnswer(args) {
   const adapter = resolveAdapter(args);
-  const date = args.date ?? localDate((args.now ?? /* @__PURE__ */ new Date()).toISOString(), args.tz);
+  const now = requestClock(adapter, args.now);
+  const date = args.date ?? localDate(now.toISOString(), args.tz);
   const day = await getMatchesForDate(adapter, date, resolveTz(args.tz));
   const { matches, degraded, source } = day;
   const todays = fixturesByDate(date, matches, args.tz);
   const shownToday = boundedRecords(todays);
-  const opts = fmtOpts(args, adapter.competition);
+  const opts = fmtOpts(args, adapter.competition, now);
   const empty = verdictNotice(day, args.lang) ?? dateUnreached(day, date, args.lang) ?? dateNoneRead(day, date, args.lang) ?? t(args.lang, "today.none");
   const text = `${headingLine(args.lang, t(args.lang, "today.onDate", { date }))}
 ${matchRows(todays, empty, opts)}`;
   const degradedLine = degraded ? `(${t(args.lang, day.skeleton ? "feed.degraded" : "live.degraded")})` : void 0;
-  const market = await reliableMarketData(args, todays);
+  const market = await reliableMarketData(args, todays, now);
   const marketLine2 = market.complete ? void 0 : "(Market data unavailable or incomplete \u2014 not all fixtures were checked.)";
   const attribution = dayAttribution(day, shownToday.items, args.lang);
   return {
@@ -8479,9 +8722,10 @@ function toolGetLive(args = {}) {
 }
 async function liveAnswer(args) {
   const adapter = resolveAdapter(args);
-  const live = await getLiveMatches(adapter, args.now ?? /* @__PURE__ */ new Date());
+  const now = requestClock(adapter, args.now);
+  const live = await getLiveMatches(adapter, now);
   const { matches, degraded, source } = live;
-  const opts = fmtOpts(args, adapter.competition);
+  const opts = fmtOpts(args, adapter.competition, now);
   const text = degraded ? t(args.lang, "live.degraded") : `${headingLine(args.lang, t(args.lang, "live.title"))}
 ${matchRows(matches, verdictNotice(live, args.lang) ?? liveNoneRead(live, args.lang) ?? t(args.lang, "live.none"), opts)}`;
   const shownLive = boundedRecords(matches);
@@ -8504,7 +8748,8 @@ function toolGetMatch(args) {
 }
 async function matchAnswer(args) {
   const adapter = resolveAdapter(args);
-  const found = await getMatchById(adapter, args.id, args.now);
+  const now = requestClock(adapter, args.now);
+  const found = await getMatchById(adapter, args.id, now);
   const { match, degraded, source: liveSource } = found;
   if (!match) {
     const msg = verdictNotice(found, args.lang) ?? matchWindowSentence(found, args.id, args.lang) ?? matchNoneReadSentence(found, args.id, args.lang) ?? t(args.lang, degraded ? "match.unreachable" : "match.none", { id: args.id });
@@ -8520,20 +8765,21 @@ async function matchAnswer(args) {
       }
     };
   }
-  const opts = fmtOpts(args, adapter.competition);
-  const now = args.now ?? /* @__PURE__ */ new Date();
+  const opts = fmtOpts(args, adapter.competition, now);
   let marketSignal;
   let marketComplete = true;
   if (marketsEnabled() && marketRelevant(match, now)) {
-    const market = await cachedMarketSignals(args, [match]);
+    const market = await cachedMarketSignals(args, [match], now);
     marketComplete = market.complete;
     const s = market.signals.get(match.id);
     if (s && isReliableMarketSignal(s, { now }) && marketSignalRendersFor(match, s)) marketSignal = s;
   }
   const attribution = dayAttribution(found, [match], args.lang);
-  const base = matchLine(match, opts);
-  const text = marketSignal ? `${base}
-${marketBlock(marketSignal, match).join("\n")}` : base;
+  const text = [
+    matchLine(match, opts),
+    ...marketSignal ? marketBlock(marketSignal, match) : [],
+    ...timelineRows(match, { lang: args.lang, flags: true })
+  ].join("\n");
   const degradedLine = degraded ? `(${t(args.lang, found.earlierRecord ? "feed.earlierRecord" : "feed.degraded")})` : void 0;
   const marketLine2 = marketComplete ? void 0 : "(Market data unavailable or incomplete \u2014 this match was not checked.)";
   return {
@@ -8696,7 +8942,7 @@ async function nextAnswer(args) {
   if (!query) throw new Error(NO_TEAM);
   const asked = pin ? { code: query } : bundleApplies(adapter.competition) ? nationArg(query) : { code: query };
   const code = "code" in asked ? asked.code : query;
-  const now = args.now ?? /* @__PURE__ */ new Date();
+  const now = requestClock(adapter, args.now);
   const next = pin ? await nextFixtureForPin(adapter, pin, now) : "code" in asked ? await getNextFixtureForTeam(adapter, code, now) : asked.answer;
   const { fixture, degraded, source } = next;
   const label = nextTeamLabel(next, code);
@@ -8716,7 +8962,7 @@ ${msg}`, next, args.lang), void 0, args.lang),
       data: { ...about, fixture: null, degraded, source: source ?? null, ...verdictExtras(next) }
     };
   }
-  const opts = fmtOpts(args, adapter.competition);
+  const opts = fmtOpts(args, adapter.competition, now);
   return {
     // `source` in data mirrors the text's "Live data: …" attribution (parity
     // with CLI `next --json`); null for a static group fixture (no live source).
@@ -8760,7 +9006,6 @@ function toolGetMarketSignal(args) {
 }
 async function marketAnswer(args) {
   const provider = resolveMarketProvider(args);
-  const now = args.now ?? /* @__PURE__ */ new Date();
   if (args.matchId) {
     const scope = marketScopeVerdict(competitionOf(args), 0);
     const outOfScope = verdictNotice(scope, args.lang);
@@ -8776,13 +9021,15 @@ async function marketAnswer(args) {
         }
       };
     }
-    const found = await getMatchById(resolveAdapter(args), args.matchId);
+    const adapter2 = resolveAdapter(args);
+    const now2 = requestClock(adapter2, args.now);
+    const found = await getMatchById(adapter2, args.matchId, now2);
     const { match } = found;
-    const relevant = match ? marketRelevant(match, now) : false;
-    const batch2 = match && relevant ? await getMarketSignals(provider, [match], MARKETS_TOOL_OPTS) : { results: /* @__PURE__ */ new Map(), complete: true };
+    const relevant = match ? marketRelevant(match, now2) : false;
+    const batch2 = match && relevant ? await getMarketSignals(provider, [match], { ...MARKETS_TOOL_OPTS, now: now2 }) : { results: /* @__PURE__ */ new Map(), complete: true };
     const sig = match ? resolvedValues(batch2).get(match.id) : void 0;
     const shown2 = batch2.complete && match && sig && marketDisplayable(match, sig) ? sig : void 0;
-    const text2 = !match ? verdictNotice(found, args.lang) ?? `No match found with id ${args.matchId}.` : !batch2.complete ? `Market data unavailable or incomplete for ${marketHeader(match, args)} \u2014 this match could not be checked.` : shown2 ? marketText(match, shown2, args) : noSignalText(match, args, now);
+    const text2 = !match ? verdictNotice(found, args.lang) ?? `No match found with id ${args.matchId}.` : !batch2.complete ? `Market data unavailable or incomplete for ${marketHeader(match, args)} \u2014 this match could not be checked.` : shown2 ? marketText(match, shown2, args) : noSignalText(match, args, now2);
     return {
       // The fixture read was not whole: said first, apart from `complete`
       // (the market requests' own completeness).
@@ -8798,13 +9045,15 @@ async function marketAnswer(args) {
   }
   if (args.team) {
     const code = args.team.toUpperCase();
-    const picked = await marketFixtureForTeam(resolveAdapter(args), code, now);
+    const adapter2 = resolveAdapter(args);
+    const now2 = requestClock(adapter2, args.now);
+    const picked = await marketFixtureForTeam(adapter2, code, now2);
     const { match: fixture, degraded } = picked;
-    const relevant = fixture ? marketRelevant(fixture, now) : false;
-    const batch2 = fixture && relevant ? await getMarketSignals(provider, [fixture], MARKETS_TOOL_OPTS) : { results: /* @__PURE__ */ new Map(), complete: true };
+    const relevant = fixture ? marketRelevant(fixture, now2) : false;
+    const batch2 = fixture && relevant ? await getMarketSignals(provider, [fixture], { ...MARKETS_TOOL_OPTS, now: now2 }) : { results: /* @__PURE__ */ new Map(), complete: true };
     const sig = fixture ? resolvedValues(batch2).get(fixture.id) : void 0;
     const shown2 = batch2.complete && fixture && sig && marketDisplayable(fixture, sig) ? sig : void 0;
-    const text2 = !fixture ? verdictNotice(picked, args.lang) ?? (degraded ? `Live feed unavailable \u2014 can't resolve ${code}'s next fixture right now.` : `No upcoming fixture found for ${code}.`) : !batch2.complete ? `Market data unavailable or incomplete for ${marketHeader(fixture, args)} \u2014 this match could not be checked.` : shown2 ? marketText(fixture, shown2, args) : noSignalText(fixture, args, now);
+    const text2 = !fixture ? verdictNotice(picked, args.lang) ?? (degraded ? `Live feed unavailable \u2014 can't resolve ${code}'s next fixture right now.` : `No upcoming fixture found for ${code}.`) : !batch2.complete ? `Market data unavailable or incomplete for ${marketHeader(fixture, args)} \u2014 this match could not be checked.` : shown2 ? marketText(fixture, shown2, args) : noSignalText(fixture, args, now2);
     return {
       // Either read the pick was made from was not whole: said first, apart
       // from `complete` (the market requests' own completeness).
@@ -8820,11 +9069,13 @@ async function marketAnswer(args) {
       }
     };
   }
+  const adapter = resolveAdapter(args);
+  const now = requestClock(adapter, args.now);
   const date = args.date ?? localDate(now.toISOString(), args.tz);
-  const day = await getMatchesForDate(resolveAdapter(args), date, resolveTz(args.tz));
+  const day = await getMatchesForDate(adapter, date, resolveTz(args.tz));
   const fixtureRead = marketsCoverCompetition(competitionOf(args)) ? day : {};
   const todays = fixturesByDate(date, day.matches, args.tz).filter((m) => marketRelevant(m, now));
-  const batch = await getMarketSignals(provider, todays, MARKETS_TOOL_OPTS);
+  const batch = await getMarketSignals(provider, todays, { ...MARKETS_TOOL_OPTS, now });
   const signals = resolvedValues(batch);
   const all = todays.map((m) => ({ match: m, signal: signals.get(m.id) })).filter(
     (r) => !!r.signal && marketDisplayable(r.match, r.signal)
@@ -8863,12 +9114,11 @@ ${shown.items.map(({ match, signal }) => marketText(match, signal, args)).join("
     }
   };
 }
-async function reliableSignalMap(args, matches) {
+async function reliableSignalMap(args, matches, now) {
   if (!marketsEnabled()) return { signals: /* @__PURE__ */ new Map(), complete: true };
-  const now = args.now ?? /* @__PURE__ */ new Date();
   const relevant = matches.filter((m) => marketRelevant(m, now));
   if (relevant.length === 0) return { signals: /* @__PURE__ */ new Map(), complete: true };
-  const result = await cachedMarketSignals(args, relevant);
+  const result = await cachedMarketSignals(args, relevant, now);
   const out = /* @__PURE__ */ new Map();
   for (const m of relevant) {
     const s = result.signals.get(m.id);
@@ -8938,11 +9188,12 @@ function shareKindAsked(args) {
 }
 async function shareAnswer(args) {
   const options = shareOptions(args);
-  const signalsFor = (ms) => args.includeMarkets === false ? Promise.resolve({ signals: /* @__PURE__ */ new Map(), complete: true }) : reliableSignalMap(args, ms);
+  const signalsFor = (ms, now2) => args.includeMarkets === false ? Promise.resolve({ signals: /* @__PURE__ */ new Map(), complete: true }) : reliableSignalMap(args, ms, now2);
   const competition = selectedOf(args).slug;
   const where = { tz: args.tz, locale: args.lang, competition };
   if (args.live) {
-    const live = await getLiveMatches(resolveAdapter(args), args.now ?? /* @__PURE__ */ new Date());
+    const adapter2 = resolveAdapter(args);
+    const live = await getLiveMatches(adapter2, requestClock(adapter2, args.now));
     const shownLive = boundedRecords(live.matches);
     return shareResult(
       liveShareCard(live, where, {
@@ -9012,24 +9263,29 @@ async function shareAnswer(args) {
     };
   }
   if (args.matchId) {
-    const found = await getMatchById(resolveAdapter(args), args.matchId, args.now);
-    const market2 = await signalsFor(found.match ? [found.match] : []);
+    const adapter2 = resolveAdapter(args);
+    const now2 = requestClock(adapter2, args.now);
+    const found = await getMatchById(adapter2, args.matchId, now2);
+    const market2 = await signalsFor(found.match ? [found.match] : [], now2);
     return shareResult(matchShareCard(found, args.matchId, market2, where), options);
   }
   if (args.team) {
-    const adapter = resolveAdapter(args);
+    const adapter2 = resolveAdapter(args);
     const query = humanLabel(args.team, 40);
-    const asked = bundleApplies(adapter.competition) ? nationArg(query) : { code: query };
+    const asked = bundleApplies(adapter2.competition) ? nationArg(query) : { code: query };
     const code = "code" in asked ? asked.code : query;
-    const next = "code" in asked ? await getNextFixtureForTeam(adapter, code, args.now ?? /* @__PURE__ */ new Date()) : asked.answer;
-    const market2 = await signalsFor(next.fixture ? [next.fixture] : []);
+    const now2 = requestClock(adapter2, args.now);
+    const next = "code" in asked ? await getNextFixtureForTeam(adapter2, code, now2) : asked.answer;
+    const market2 = await signalsFor(next.fixture ? [next.fixture] : [], now2);
     return shareResult(nextShareCard(next, code, market2, where), options);
   }
-  const date = args.date ?? localDate((args.now ?? /* @__PURE__ */ new Date()).toISOString(), args.tz);
-  const day = await getMatchesForDate(resolveAdapter(args), date, resolveTz(args.tz));
+  const adapter = resolveAdapter(args);
+  const now = requestClock(adapter, args.now);
+  const date = args.date ?? localDate(now.toISOString(), args.tz);
+  const day = await getMatchesForDate(adapter, date, resolveTz(args.tz));
   const todays = fixturesByDate(date, day.matches, args.tz);
   const shownToday = boundedRecords(todays);
-  const market = await signalsFor(shownToday.items);
+  const market = await signalsFor(shownToday.items, now);
   return shareResult(
     dateShareCard(
       {
@@ -9055,7 +9311,7 @@ async function shareAnswer(args) {
 
 // src/server.ts
 var SERVER_NAME = "claudinho";
-var SERVER_VERSION = "0.11.1";
+var SERVER_VERSION = "0.12.0";
 var VOICE = asFlavorLevel(process.env.CLAUDINHO_FLAVOR) === "off" ? "" : `
 Voice: when relaying scores, narrate with lively, regionally-appropriate football-commentary energy in the user's language. Each match line may end with a short exclamation ("\u2014 \xA1GOOOOL!"): use it as a tone cue. Keep every fact exact; never invent details and never impersonate or name a real commentator.`;
 var INSTRUCTIONS = `Claudinho serves live scores, fixtures, and standings for one football competition per request, chosen by the tool call's competition argument (an alias such as premier-league, or an ESPN slug such as eng.1), else the server's CLAUDINHO_COMPETITION, else the user's saved choice (set with claudinho follow <alias>). With none of the three, every competition-answering tool answers noCompetition with a sentence saying what to do: pass competition, or ask the user to run claudinho follow <alias>. list_competitions lists the supported competitions, their aliases and what each offers, offline. Every tool's text but get_team's, get_share_snippet's and list_competitions' starts with the competition it is for, and its structured data carries it as competition (get_share_snippet's card names it in its title; list_competitions says it last, as Current, and in data.current; get_team is the World Cup's roster). An unknown competition is a tool error that lists the aliases.
@@ -9082,7 +9338,7 @@ var competitionArg = z.string().describe(
   "The competition: an alias such as premier-league, or an ESPN slug such as eng.1 (list_competitions lists the aliases). Without it: the server's CLAUDINHO_COMPETITION, else the user's saved choice (claudinho follow); with none, the answer is noCompetition"
 );
 var langArg = z.string().optional().describe(
-  "Locale for dates, list titles, match status and stage words, the empty and outage sentences, provider attribution, and commentary: en, es, pt, fr (the market copy, a few notes and the disclaimer stay English; other locales fall back to en)"
+  "Locale for dates, list titles, match status and stage words, a match timeline's kind words (Goal, Yellow card\u2026), the empty and outage sentences, provider attribution, and commentary: en, es, pt, fr (the market copy, a few notes and the disclaimer stay English; other locales fall back to en)"
 );
 var commonArgs = {
   competition: competitionArg.optional(),
@@ -9092,6 +9348,14 @@ var commonArgs = {
 };
 var teamRef = z.object({ code: z.string(), name: z.string(), flag: z.string(), id: z.string() }).partial().passthrough();
 var scorePair = z.object({ home: z.number(), away: z.number() }).partial().passthrough();
+var matchEventOut = z.object({
+  type: z.string(),
+  minute: z.number(),
+  added: z.number(),
+  side: z.string(),
+  teamCode: z.string(),
+  player: z.string()
+}).partial().passthrough();
 var matchOut = z.object({
   id: z.string(),
   stage: z.string().optional(),
@@ -9107,6 +9371,9 @@ var matchOut = z.object({
   shootout: scorePair.optional(),
   status: z.string().optional(),
   minute: z.number().nullable().optional(),
+  // The goals and cards that could be read, in time order; absent when none
+  // (a match with no score has none).
+  events: z.array(matchEventOut).optional(),
   winnerCode: z.string().optional()
 }).passthrough();
 var anyObj = z.object({}).passthrough();
@@ -9525,7 +9792,7 @@ function buildServer() {
     "get_match",
     {
       title: "Match detail",
-      description: `One match by its id, with live score/minute overlaid when it's in play. Off the World Cup the id is looked for from yesterday to 14 days ahead: window names the provider days searched when it was not there (not found in that span, not "no such match"), and degraded with a match means its state could not be refreshed. Optional prediction-market enrichment carries marketComplete; false means the read was incomplete, not that no signal exists. Get the id from get_today or get_live; to find a team's match without an id, use get_next_fixture. tz/lang/flavor affect formatting.`,
+      description: `One match by its id, with live score/minute overlaid when it's in play, and, for a match in play or finished, the provider's goals and cards it could read (minute, kind, side, the player when named; match.events in data), never a claim that the list is every goal. Off the World Cup the id is looked for from yesterday to 14 days ahead: window names the provider days searched when it was not there (not found in that span, not "no such match"), and degraded with a match means its state could not be refreshed. Optional prediction-market enrichment carries marketComplete; false means the read was incomplete, not that no signal exists. Get the id from get_today or get_live; to find a team's match without an id, use get_next_fixture. tz/lang/flavor affect formatting.`,
       inputSchema: { id: z.string().describe("Match id"), ...commonArgs },
       annotations: { readOnlyHint: true, openWorldHint: true },
       outputSchema: matchDetailOut
@@ -9674,8 +9941,9 @@ function buildServer() {
     },
     async (uri, variables) => {
       const date = String(variables.date ?? "");
+      const now = /* @__PURE__ */ new Date();
       const text = `${competitionLabel(BUNDLE_COMPETITION)}
-${matchList(fixturesByDate(date, void 0, "UTC"), `No matches on ${date}.`)}`;
+${matchList(fixturesByDate(date, void 0, "UTC"), `No matches on ${date}.`, { now })}`;
       return { contents: [{ uri: uri.href, mimeType: "text/plain", text }] };
     }
   );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claudinho/mcp",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "mcpName": "io.github.arturogarrido/claudinho",
   "description": "An MCP server with live football scores, fixtures, standings and paste-ready match cards for the competition you follow: the World Cup, the Premier League, LALIGA, the Champions League and 12 more. Works with Claude Code, Cursor, Codex, Claude Desktop, Windsurf, Zed and any MCP client. No API key. Independent fan project. Not affiliated with FIFA, any confederation, league or club, or Anthropic.",
   "type": "module",
@@ -64,16 +64,16 @@
     "club-world-cup"
   ],
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.31.0",
+    "@modelcontextprotocol/sdk": "^1.32.1",
     "zod": "^4.6.5"
   },
   "devDependencies": {
-    "@types/node": "^22.20.4",
+    "@types/node": "^22.20.5",
     "@vitest/coverage-v8": "^5.0.3",
     "tsup": "^8.0.0",
     "typescript": "^5.7.0",
     "vitest": "^5.0.3",
-    "@claudinho/core": "0.11.1"
+    "@claudinho/core": "0.12.0"
   },
   "scripts": {
     "build": "tsup",