@claudinho/cli 0.11.2 → 0.12.0

package/dist/index.js

@@ -335,6 +335,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",
@@ -343,6 +350,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
@@ -354,6 +378,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}.",
@@ -431,6 +456,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",
@@ -438,6 +469,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.",
@@ -446,6 +488,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:',
@@ -520,6 +563,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",
@@ -527,6 +576,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.",
@@ -535,6 +595,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:',
@@ -609,6 +670,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",
@@ -616,6 +683,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.",
@@ -624,6 +702,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 :',
@@ -657,6 +736,20 @@ function t(lang, key, vars) {
     (whole, name) => Object.hasOwn(vars, name) ? vars[name] : whole
   );
 }
+function momentWords(lang) {
+  return {
+    goal: t(lang, "moment.goal"),
+    ownGoal: t(lang, "moment.ownGoal"),
+    ownGoalDetail: t(lang, "moment.ownGoalDetail"),
+    goalFor: t(lang, "moment.goalFor"),
+    goals: t(lang, "moment.goals"),
+    scoreUpdated: t(lang, "moment.scoreUpdated"),
+    penalties: t(lang, "moment.penalties"),
+    fullTime: t(lang, "moment.fullTime"),
+    win: t(lang, "moment.win"),
+    draw: t(lang, "moment.draw")
+  };
+}
 var STAGE_KEYS = Object.freeze({
   GROUP: "stage.groupStage",
   R32: "stage.r32",
@@ -838,6 +931,65 @@ 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" }];
+  });
+}
+var SCORING = /* @__PURE__ */ new Set(["GOAL", "OWN_GOAL", "PEN"]);
+function provenLastGoal(match) {
+  const score = match.score;
+  if (!score) return null;
+  let home = 0;
+  let away = 0;
+  let last = null;
+  const identities = /* @__PURE__ */ new Set();
+  for (const e of match.events ?? []) {
+    if (!SCORING.has(e.type)) continue;
+    const identity = JSON.stringify([e.type, e.minute, e.added ?? 0, e.side, e.player ?? null]);
+    if (identities.has(identity)) return null;
+    identities.add(identity);
+    if (e.side === "home") home++;
+    else if (e.side === "away") away++;
+    else continue;
+    last = e;
+  }
+  return last !== null && home === score.home && away === score.away ? last : null;
+}
 function outcomeFromScore(home, away) {
   if (home > away) return "H";
   if (home < away) return "A";
@@ -1109,18 +1261,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 out2 = { 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 out2 = { type, minute };
+  if (added !== void 0) out2.added = added;
+  out2.side = side;
+  out2.teamCode = humanLabel(e.teamCode, TEAM_CODE_COLUMNS);
   const player = humanLabel(e.player);
   if (player) out2.player = player;
   return out2;
 }
+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);
@@ -1165,7 +1332,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 out2 = { id, stage };
   if (stageLabel2) out2.stageLabel = stageLabel2;
   if (group) out2.group = group;
@@ -4307,6 +4475,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 plain2 = DETAIL_MINUTE.exec(dv);
+  if (plain2) return { minute: Number(plain2[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 out2 = [];
+  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;
+    out2.push(event);
+  }
+  return out2;
+}
+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({
@@ -4428,7 +4665,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 }
@@ -4745,7 +4989,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.2"} (+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;
@@ -6647,10 +6891,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();
@@ -6658,6 +6911,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,
@@ -6669,10 +6923,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) {
@@ -6908,22 +7164,29 @@ function sealMarketSignal(raw, options = {}) {
   if (sourceMarketId) out2.sourceMarketId = sourceMarketId;
   out2.asOf = canonicalTimestamp(s.asOf) ?? "";
   out2.fetchedAt = canonicalTimestamp(s.fetchedAt) ?? "";
+  const judgedAt = options.now ?? /* @__PURE__ */ new Date();
+  const fetchedMs = Date.parse(out2.fetchedAt);
+  if (out2.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");
+  }
   out2.outcomes = outcomes;
   const isAmbiguous = s.ambiguous !== false;
   const favorite = isAmbiguous ? void 0 : deriveFavorite(outcomes);
   if (favorite) out2.favorite = favorite;
   if (liquidity !== void 0) out2.liquidity = liquidity;
   if (volume24h !== void 0) out2.volume24h = volume24h;
-  out2.stale = s.stale !== false;
+  out2.stale = isStaleSignal(out2, { now: judgedAt, maxAgeMs: options.maxAgeMs });
   out2.ambiguous = isAmbiguous || out2.source === "";
-  out2.stale = out2.stale || isStaleSignal(out2, { now: options.now, maxAgeMs: options.maxAgeMs });
   return valid(out2);
 }
 function parseCachedMarketSignal(raw, options = {}) {
   return sealMarketSignal(raw, options);
 }
 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);
@@ -7012,12 +7275,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,
@@ -7025,8 +7289,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 };
   }
@@ -8780,17 +9044,33 @@ function painterFor(cfg) {
   return paint(cfg.color);
 }
 function statusToken(m, t2, c) {
+  const word = statusWord(m, t2);
+  switch (m.status) {
+    case "LIVE":
+      return c.green(word);
+    case "HT":
+      return c.yellow(word);
+    case "FT":
+      return c.gray(word);
+    case "POSTPONED":
+    case "CANCELLED":
+      return c.red(word);
+    default:
+      return "";
+  }
+}
+function statusWord(m, t2) {
   switch (m.status) {
     case "LIVE":
-      return c.green(`${m.minute ? `${m.minute}'` : t2("status.live")}`);
+      return m.minute ? `${m.minute}'` : t2("status.live");
     case "HT":
-      return c.yellow(t2("status.ht"));
+      return t2("status.ht");
     case "FT":
-      return c.gray(t2("status.ft"));
+      return t2("status.ft");
     case "POSTPONED":
-      return c.red(t2("status.postponed"));
+      return t2("status.postponed");
     case "CANCELLED":
-      return c.red(t2("status.cancelled"));
+      return t2("status.cancelled");
     default:
       return "";
   }
@@ -9013,12 +9293,60 @@ function writeState(state, now = stampOrNow(state.updatedAt)) {
     const until = envelopeDeadline(replaced, now);
     if (until !== void 0 && !writeBackoffNote(state.source, state.competition, until, now)) return false;
   }
-  writeFileAtomic(
-    cachePath(state.source, state.competition),
-    JSON.stringify({ ...state, version: CACHE_VERSION })
-  );
+  writeFileAtomic(cachePath(state.source, state.competition), boundedSnapshot(withoutEvents(state)));
   return true;
 }
+function boundedSnapshot(state) {
+  const serialize = (s) => JSON.stringify({ ...s, version: CACHE_VERSION });
+  let text = serialize(state);
+  if (Buffer.byteLength(text, "utf8") <= MAX_STATE_BYTES) return text;
+  let next = state;
+  const play = state.play;
+  if (play && typeof play === "object" && !Array.isArray(play) && Array.isArray(play.finished)) {
+    next = { ...next, play: { ...play, finished: [] } };
+    text = serialize(next);
+    if (Buffer.byteLength(text, "utf8") <= MAX_STATE_BYTES) return text;
+  }
+  if (Array.isArray(next.live)) {
+    next = { ...next, live: next.live.map(dropLastGoal) };
+    text = serialize(next);
+    if (Buffer.byteLength(text, "utf8") <= MAX_STATE_BYTES) return text;
+  }
+  if ("play" in next) {
+    const { play: _play, ...withoutPlay } = next;
+    text = serialize(withoutPlay);
+  }
+  return text;
+}
+function dropLastGoal(m) {
+  if (!m || typeof m !== "object" || !("lastGoal" in m)) return m;
+  const copy = { ...m };
+  delete copy.lastGoal;
+  return copy;
+}
+function withoutEvents(state) {
+  const strip = (list) => Array.isArray(list) ? list.map(dropEvents) : list;
+  const out2 = { ...state, live: strip(state.live) };
+  if (state.fixtures !== void 0) out2.fixtures = strip(state.fixtures);
+  if (state.schedule?.fixtures !== void 0) out2.schedule = { ...state.schedule, fixtures: strip(state.schedule.fixtures) };
+  const play = state.play;
+  if (play && typeof play === "object" && !Array.isArray(play) && Array.isArray(play.finished)) {
+    const p = play;
+    out2.play = {
+      ...p,
+      finished: p.finished.map(
+        (e) => e && typeof e === "object" && !Array.isArray(e) ? { ...e, match: dropEvents(e.match) } : e
+      )
+    };
+  }
+  return out2;
+}
+function dropEvents(m) {
+  if (!m || typeof m !== "object" || !("events" in m)) return m;
+  const copy = { ...m };
+  delete copy.events;
+  return copy;
+}
 function stampOrNow(stamp) {
   return validStamp(stamp) ? Date.parse(stamp) : Date.now();
 }
@@ -9242,7 +9570,7 @@ function isUsableSignal(s) {
   if (!s.favorite) return false;
   return hasSaneDistribution(s.outcomes);
 }
-function readMarketCache(source, competition, now = Date.now()) {
+function readMarketCache(source, competition, now = Date.now(), requestNow) {
   const signals = /* @__PURE__ */ new Map();
   const checked = /* @__PURE__ */ new Set();
   const file = readFile();
@@ -9269,7 +9597,7 @@ function readMarketCache(source, competition, now = Date.now()) {
       checked.add(id);
       continue;
     }
-    const sealed = parseCachedMarketSignal(entry.signal, { now: new Date(now) });
+    const sealed = parseCachedMarketSignal(entry.signal, { now: requestNow });
     if (sealed.kind !== "valid") continue;
     const clean = sealed.value;
     if (clean.matchId !== id || clean.source !== source) continue;
@@ -9367,6 +9695,104 @@ function copyToClipboard(text, platform = process.platform) {
   return false;
 }
 
+// src/play.ts
+var FINISHED_TTL_MS = 10 * 6e4;
+var SEEN_TTL_MS = 6 * 60 * 6e4;
+var MAX_PLAY = 64;
+var NO_READ = Object.freeze({ whole: false, matches: [], finished: [], finishedTruncated: false });
+var ID = /^[A-Za-z0-9._:-]{1,64}$/;
+function believedAt(at, now, ttl) {
+  if (!validStamp(at)) return false;
+  const ms = Date.parse(at);
+  return ms <= now && now - ms < ttl;
+}
+function playRecordIds(play, now) {
+  const ids = /* @__PURE__ */ new Set();
+  if (!play || typeof play !== "object" || Array.isArray(play)) return ids;
+  const p = play;
+  for (const raw of takeBounded(p.seen, MAX_PLAY)) {
+    if (!raw || typeof raw !== "object") continue;
+    const { id, at } = raw;
+    if (typeof id === "string" && ID.test(id) && believedAt(at, now, SEEN_TTL_MS)) ids.add(id);
+  }
+  for (const raw of takeBounded(p.finished, MAX_PLAY)) {
+    if (!raw || typeof raw !== "object") continue;
+    const { match, at } = raw;
+    if (!match || typeof match !== "object" || !believedAt(at, now, FINISHED_TTL_MS)) continue;
+    const id = match.id;
+    if (typeof id === "string" && ID.test(id)) ids.add(id);
+  }
+  return ids;
+}
+function believedPlay(prev, now, kind) {
+  const out2 = { seen: [], finished: [] };
+  if (!prev || typeof prev !== "object" || Array.isArray(prev)) return out2;
+  const p = prev;
+  const ids = /* @__PURE__ */ new Set();
+  for (const raw of takeBounded(p.seen, MAX_PLAY)) {
+    if (!raw || typeof raw !== "object") continue;
+    const { id, at } = raw;
+    if (typeof id !== "string" || !ID.test(id) || ids.has(id) || !believedAt(at, now, SEEN_TTL_MS)) continue;
+    ids.add(id);
+    out2.seen.push({ id, at });
+  }
+  const done = /* @__PURE__ */ new Set();
+  for (const raw of takeBounded(p.finished, MAX_PLAY)) {
+    if (!raw || typeof raw !== "object") continue;
+    const { match, at } = raw;
+    if (!believedAt(at, now, FINISHED_TTL_MS)) continue;
+    const sealed = parsedValue(parseCachedMatch(match, { events: false, teamKind: kind }));
+    if (sealed?.status !== "FT" || !sealed.score || done.has(sealed.id)) continue;
+    done.add(sealed.id);
+    out2.finished.push({ match: sealed, at });
+  }
+  return out2;
+}
+function advancePlay(prev, read, now, kind = "club") {
+  const nowMs = now.getTime();
+  const believed = believedPlay(prev, nowMs, kind);
+  if (!read.whole) return believed;
+  const at = now.toISOString();
+  const inPlay = /* @__PURE__ */ new Set();
+  const seenNow = [];
+  for (const m of read.matches) {
+    if (typeof m?.id !== "string" || inPlay.has(m.id)) continue;
+    inPlay.add(m.id);
+    seenNow.push({ id: m.id, at });
+  }
+  const finishedRead = /* @__PURE__ */ new Map();
+  for (const m of read.finished) {
+    if (typeof m?.id === "string" && !finishedRead.has(m.id)) finishedRead.set(m.id, m);
+  }
+  const finished = [];
+  const held = /* @__PURE__ */ new Set();
+  for (const e of believed.finished) {
+    const id = e.match.id;
+    if (inPlay.has(id)) continue;
+    const again = finishedRead.get(id);
+    if (again) finished.push({ match: again, at: e.at });
+    else if (read.finishedTruncated) finished.push(e);
+    else continue;
+    held.add(id);
+  }
+  const keptSeen = [];
+  for (const e of believed.seen) {
+    if (inPlay.has(e.id) || held.has(e.id)) continue;
+    const done = finishedRead.get(e.id);
+    if (done) {
+      finished.push({ match: done, at });
+      held.add(e.id);
+    } else if (read.finishedTruncated) {
+      keptSeen.push(e);
+    }
+  }
+  const seen = [...keptSeen, ...seenNow];
+  return {
+    seen: seen.length > MAX_PLAY ? seen.slice(seen.length - MAX_PLAY) : seen,
+    finished: finished.length > MAX_PLAY ? finished.slice(finished.length - MAX_PLAY) : finished
+  };
+}
+
 // src/scheduleSlice.ts
 var SCHEDULE_DISPLAY_MAX = 64;
 var RELEVANT_BACK_MS = 6 * 60 * 6e4;
@@ -9496,8 +9922,17 @@ function isMatchShaped(m) {
   const x = m;
   return !!x && typeof x === "object" && typeof x.id === "string" && typeof x.kickoff === "string" && !!x.home?.code && !!x.away?.code;
 }
-function upcomingResolved(now, fixtures = allFixtures()) {
-  return [...fixtures].sort(byKickoff).filter((m) => isUpcoming(m, new Date(now)) && isResolvedFixture(m));
+var KICKOFF_DUE_MS = 30 * 6e4;
+function isDue(m, nowMs, played) {
+  if (m.status !== "SCHEDULED" || played.has(m.id)) return false;
+  const k = Date.parse(m.kickoff);
+  return k <= nowMs && nowMs <= k + KICKOFF_DUE_MS;
+}
+function isAhead(m, nowMs) {
+  return Date.parse(m.kickoff) > nowMs && isUpcoming(m, new Date(nowMs));
+}
+function countdownCandidates(nowMs, fixtures = allFixtures(), played) {
+  return [...fixtures].sort(byKickoff).filter((m) => isResolvedFixture(m) && (isAhead(m, nowMs) || isDue(m, nowMs, played)));
 }
 function defaultTeamKind(defaultCompetition) {
   return defaultCompetition === false ? "club" : "nation";
@@ -9505,14 +9940,38 @@ function defaultTeamKind(defaultCompetition) {
 function teamTok(t2, flags) {
   return flags && t2.flag ? t2.flag : t2.code;
 }
-function matchSegment(m, compact, flags) {
-  const minute = m.status === "HT" ? "HT" : m.minute ? `${m.minute}'` : "LIVE";
-  if (!flags) {
-    return `${m.home.code} ${scoreline(m)} ${m.away.code} ${minute}`;
+function matchSegment(m, compact, flags, lang) {
+  const ht = lang === void 0 ? "HT" : t(lang, "status.ht");
+  const live = lang === void 0 ? "LIVE" : t(lang, "status.live");
+  const minute = m.status === "HT" ? ht : m.minute ? `${m.minute}'` : live;
+  const home = !flags ? m.home.code : compact ? teamTok(m.home, true) : withFlag(m.home.code, m.home.flag, "home");
+  const away = !flags ? m.away.code : compact ? teamTok(m.away, true) : withFlag(m.away.code, m.away.flag, "away");
+  const score = scoreline(m);
+  return { text: `${home} ${score} ${away} ${minute}`, score: [home.length + 1, home.length + 1 + score.length] };
+}
+var plain = (text) => ({ text, strong: [] });
+function sharedPrefix(a, b) {
+  const n = Math.min(a.length, b.length);
+  let i = 0;
+  while (i < n && a.charCodeAt(i) === b.charCodeAt(i)) i++;
+  return i;
+}
+function keptRanges(from, to, ranges) {
+  if (from === to) return [...ranges];
+  const kept = sharedPrefix(from, to);
+  return ranges.filter(([, end]) => end <= kept);
+}
+function partsOf(line, strong) {
+  const parts = [];
+  let at = 0;
+  for (const [start, end] of strong) {
+    if (start < at || end <= start || end > line.length) return [{ text: line }];
+    if (start > at) parts.push({ text: line.slice(at, start) });
+    parts.push({ text: line.slice(start, end), style: "strong" });
+    at = end;
   }
-  const home = compact ? teamTok(m.home, true) : withFlag(m.home.code, m.home.flag, "home");
-  const away = compact ? teamTok(m.away, true) : withFlag(m.away.code, m.away.flag, "away");
-  return `${home} ${scoreline(m)} ${away} ${minute}`;
+  if (at < line.length || parts.length === 0) parts.push({ text: line.slice(at) });
+  return parts.map((p) => p.text).join("") === line ? parts : [{ text: line }];
 }
 var MAX_LIVE_CONSIDERED = 64;
 var MAX_LIVE_EXAMINED = 512;
@@ -9550,13 +10009,17 @@ function sealFixtures(raw, kind) {
   };
 }
 function liveMatchesFromCache(state, nowMs, kind) {
+  return liveRecordsFromCache(state, nowMs, kind).list;
+}
+function liveRecordsFromCache(state, nowMs, kind) {
   const fresh = state && ageMs(state, nowMs) < DISPLAY_STALE_MS;
   const rawLive = fresh ? state?.live : [];
   if (!Array.isArray(rawLive)) {
-    return { items: [], total: 0, shown: 0, truncated: false, complete: false };
+    return { list: { items: [], total: 0, shown: 0, truncated: false, complete: false }, sources: [] };
   }
   const liveArr = rawLive;
   const out2 = [];
+  const sources = [];
   let inspected = 0;
   let readable = true;
   for (let i = 0; i < liveArr.length; i++) {
@@ -9573,19 +10036,24 @@ function liveMatchesFromCache(state, nowMs, kind) {
       continue;
     }
     const sealed = parsedValue(parseCachedMatch(m, { events: false, teamKind: kind }));
-    if (sealed) out2.push(sealed);
-    else readable = false;
+    if (sealed) {
+      out2.push(sealed);
+      sources.push(raw);
+    } else readable = false;
   }
   const exhausted = inspected === liveArr.length;
   const complete = exhausted && readable;
   return {
-    items: out2,
-    total: out2.length,
-    shown: out2.length,
-    truncated: !exhausted,
-    // False when we stopped early or a record was unreadable. In either case an
-    // empty list must not render as the authoritative "nothing is on".
-    complete
+    list: {
+      items: out2,
+      total: out2.length,
+      shown: out2.length,
+      truncated: !exhausted,
+      // False when we stopped early or a record was unreadable. In either case an
+      // empty list must not render as the authoritative "nothing is on".
+      complete
+    },
+    sources
   };
 }
 var DEFAULT_MAX_SEGMENTS = 8;
@@ -9593,11 +10061,13 @@ var MAX_LINE_COLUMNS = 200;
 function renderPrompt(state, opts = {}) {
   return promptLine(state, opts).line;
 }
-function promptLine(state, opts = {}) {
-  const unfitted = renderPromptLine(state, opts);
-  return { line: truncateVisible(unfitted, lineColumns(opts)), unfitted };
+function promptLine(state, opts = {}, played) {
+  const rendered = renderPromptLine(state, opts, played);
+  const unfitted = rendered.text;
+  const line = truncateVisible(unfitted, lineColumns(opts));
+  return { line, unfitted, parts: partsOf(line, keptRanges(unfitted, line, rendered.strong)) };
 }
-function renderPromptLine(state, opts = {}) {
+function renderPromptLine(state, opts = {}, played) {
   const now = opts.now ?? /* @__PURE__ */ new Date();
   const nowMs = now.getTime();
   const defaultCompetition = opts.defaultCompetition ?? true;
@@ -9615,23 +10085,27 @@ function renderPromptLine(state, opts = {}) {
     const max = picked ? 1 : opts.max && opts.max > 0 ? Math.min(opts.max, DEFAULT_MAX_SEGMENTS) : DEFAULT_MAX_SEGMENTS;
     const shown = ordered.slice(0, max);
     const overflow = live.length - shown.length;
-    return fitLiveLine(shown.map((m) => matchSegment(m, compact, flags)), overflow, liveList.complete, width);
+    return fitLiveLine(shown.map((m) => matchSegment(m, compact, flags, opts.lang)), overflow, liveList.complete, width);
   }
   const win = syncingWindow(state, nowMs, liveWhole(liveList.complete, state), defaultCompetition, cachedFixtures, schedule, pick2);
   if (win) {
     const first = win[0];
     const matchup = first && isResolvedFixture(first) ? `${teamTok(first.home, flags)} vs ${teamTok(first.away, flags)} ` : "";
     const more = win.length - 1;
-    return fitWithMarker(`\u26BD ${matchup}live \xB7 syncing\u2026`, more > 0 ? ` +${more}` : "", width);
+    const syncing = opts.lang === void 0 ? "live \xB7 syncing\u2026" : t(opts.lang, "ambient.syncing");
+    return plain(fitWithMarker(`\u26BD ${matchup}${syncing}`, more > 0 ? ` +${more}` : "", width));
   }
-  const next = countdownFixture(nowMs, schedule, pick2);
+  const next = countdownFixture(nowMs, schedule, pick2, played ?? playRecordIds(state?.play, nowMs));
   if (next) {
-    return `${teamTok(next.home, flags)} vs ${teamTok(next.away, flags)} in ${countdown(next.kickoff, now)}`;
+    const matchup = `${teamTok(next.home, flags)} vs ${teamTok(next.away, flags)}`;
+    if (opts.lang !== void 0) return plain(`\u26BD ${matchup} ${countdownPhrase(opts.lang, next.kickoff, now)}`);
+    const left = countdown(next.kickoff, now);
+    return plain(left === COUNTDOWN_NOW ? `\u26BD ${matchup} ${COUNTDOWN_NOW}` : `\u26BD ${matchup} in ${left}`);
   }
   if (defaultCompetition && isTournamentWindowOver(nowMs, schedule)) {
-    return TOURNAMENT_COMPLETE_LINE;
+    return plain(TOURNAMENT_COMPLETE_LINE);
   }
-  return NOTHING_KNOWN_LINE;
+  return plain(NOTHING_KNOWN_LINE);
 }
 function lineColumns(opts) {
   const c = opts.columns;
@@ -9645,10 +10119,18 @@ function fitWithMarker(body, marker, width) {
 }
 function fitLiveLine(segments, overflow, complete, width) {
   const markerFor = (dropped) => !complete ? " +more" : overflow + dropped > 0 ? ` +${overflow + dropped}` : "";
-  const bodyOf = (kept2) => "\u26BD " + segments.slice(0, kept2).join(" \xB7 ");
+  const bodyOf = (kept2) => "\u26BD " + segments.slice(0, kept2).map((g) => g.text).join(" \xB7 ");
   let kept = segments.length;
   while (kept > 1 && displayWidth(bodyOf(kept)) + displayWidth(markerFor(segments.length - kept)) > width) kept--;
-  return fitWithMarker(bodyOf(kept), markerFor(segments.length - kept), width);
+  const body = bodyOf(kept);
+  const text = fitWithMarker(body, markerFor(segments.length - kept), width);
+  const ranges = [];
+  let offset = "\u26BD ".length;
+  for (const g of segments.slice(0, kept)) {
+    ranges.push([offset + g.score[0], offset + g.score[1]]);
+    offset += g.text.length + " \xB7 ".length;
+  }
+  return { text, strong: keptRanges(body, text, ranges).filter(([, end]) => end <= text.length) };
 }
 function countdownSchedule(state, defaultCompetition, kind) {
   const cachedFixtureList = sealFixtures(defaultCompetition ? state?.fixtures : state?.schedule?.fixtures, kind);
@@ -9676,8 +10158,8 @@ function syncingWindow(state, nowMs, liveComplete, defaultCompetition, cachedFix
   const win = pickAmbientMatch(fixturesInLiveWindow(nowMs, schedule), pick2);
   return win.length > 0 ? win : void 0;
 }
-function countdownFixture(nowMs, schedule, pick2) {
-  return pickAmbientMatch(upcomingResolved(nowMs, schedule), pick2)[0];
+function countdownFixture(nowMs, schedule, pick2, played) {
+  return pickAmbientMatch(countdownCandidates(nowMs, schedule, played), pick2)[0];
 }
 
 // src/hook.ts
@@ -9695,9 +10177,12 @@ function rosterPinned(t2, pin) {
   const { team } = lookupTeam(t2.code);
   return team ? { ...t2, name: team.name, flag: team.flag } : t2;
 }
+function hookNames(m, pin) {
+  return { home: rosterPinned(m.home, pin).name, away: rosterPinned(m.away, pin).name };
+}
 function hookLine(m, opts) {
   const { flags, pin } = opts;
-  const minute = m.status === "HT" ? "half-time" : m.minute ? `${m.minute}'` : "live";
+  const minute = m.status === "FT" ? "FT" : m.status === "HT" ? "half-time" : m.minute ? `${m.minute}'` : "live";
   const h = rosterPinned(m.home, pin);
   const a = rosterPinned(m.away, pin);
   const home = flags ? withFlag(h.name, h.flag, "home") : h.name;
@@ -9722,36 +10207,85 @@ ${lines}`, more);
 }
 
 // src/ambient.ts
+function pinnedSideOf(m, pin) {
+  if (pin === void 0) return null;
+  if (isPinnedSide(m.home, pin)) return "home";
+  return isPinnedSide(m.away, pin) ? "away" : null;
+}
+var SCORING2 = /* @__PURE__ */ new Set(["GOAL", "OWN_GOAL", "PEN"]);
+function lastGoalOf(m, raw) {
+  if (raw === void 0 || raw === null) return null;
+  const e = sealEvent(raw);
+  if (!e || !SCORING2.has(e.type)) return null;
+  if (e.teamCode !== (e.side === "home" ? m.home.code : m.away.code)) return null;
+  return (m.score?.[e.side] ?? 0) >= 1 ? e : null;
+}
+function finishedFromCache(state, nowMs, kind, live) {
+  if (state?.liveComplete !== true) return [];
+  const play = state.play;
+  if (!play || typeof play !== "object" || Array.isArray(play)) return [];
+  const out2 = [];
+  const ids = /* @__PURE__ */ new Set();
+  for (const raw of takeBounded(play.finished, MAX_PLAY)) {
+    if (!raw || typeof raw !== "object") continue;
+    const { match, at } = raw;
+    if (!validStamp(at)) continue;
+    const atMs = Date.parse(at);
+    if (atMs > nowMs || nowMs - atMs >= FINISHED_TTL_MS) continue;
+    const sealed = parsedValue(parseCachedMatch(match, { events: false, teamKind: kind }));
+    if (sealed?.status !== "FT" || !sealed.score || live.has(sealed.id) || ids.has(sealed.id)) continue;
+    ids.add(sealed.id);
+    out2.push(sealed);
+  }
+  return out2;
+}
 function ambientView(state, opts = {}) {
   const now = opts.now ?? /* @__PURE__ */ new Date();
   const nowMs = now.getTime();
   const defaultCompetition = opts.defaultCompetition ?? true;
   const kind = opts.teamKind ?? defaultTeamKind(opts.defaultCompetition);
   const pin = opts.pin ?? (opts.pick && "team" in opts.pick ? opts.pick.team : void 0);
-  const read = { ...opts, now };
+  const { lang, ...rest } = opts;
+  const read = { ...rest, now };
   const hookOpts = { flags: opts.flags ?? true, pin: defaultCompetition };
-  const list = liveMatchesFromCache(state, nowMs, kind);
+  const { list, sources } = liveRecordsFromCache(state, nowMs, kind);
+  const lastGoals = /* @__PURE__ */ new Map();
+  list.items.forEach((m, i) => {
+    lastGoals.set(m, lastGoalOf(m, sources[i]?.lastGoal));
+  });
   const items = pickAmbientMatch(list.items, opts.pick).map((m) => ({
     ...m,
     picked: isPicked(m, opts.pick),
     pinned: pin !== void 0 && (isPinnedSide(m.home, pin) || isPinnedSide(m.away, pin)),
-    line: hookLine(m, hookOpts)
+    pinnedSide: pinnedSideOf(m, pin),
+    names: hookNames(m, defaultCompetition),
+    line: hookLine(m, hookOpts),
+    lastGoal: lastGoals.get(m) ?? null
   }));
-  const prompt = promptLine(state, read);
+  const played = playRecordIds(state?.play, nowMs);
+  const prompt = promptLine(state, { ...read, lang }, played);
   const context = renderHook(state, read);
   const { cachedFixtures, schedule } = countdownSchedule(state, defaultCompetition, kind);
   const age = stampAgeMs(state?.updatedAt, nowMs);
   const stamp = state && Number.isFinite(age) ? Date.parse(state.updatedAt) : void 0;
   const staleAt = stamp === void 0 ? void 0 : new Date(stamp + DISPLAY_STALE_MS);
+  const finished = finishedFromCache(
+    state,
+    nowMs,
+    kind,
+    new Set(list.items.map((m) => m.id))
+  ).map((m) => ({ ...m, pinnedSide: pinnedSideOf(m, pin), names: hookNames(m, defaultCompetition), line: hookLine(m, hookOpts) }));
   const syncing = list.items.length === 0 && syncingWindow(state, nowMs, liveWhole(list.complete, state), defaultCompetition, cachedFixtures, schedule, opts.pick) !== void 0;
   return {
     line: prompt.line,
+    lineParts: prompt.parts,
     idle: prompt.unfitted === TOURNAMENT_COMPLETE_LINE,
     empty: prompt.unfitted === NOTHING_KNOWN_LINE,
     context: context === "" ? null : context,
     live: { items, total: list.total, shown: list.shown, truncated: list.truncated, complete: list.complete },
+    finished,
     current: stamp !== void 0 && age < DISPLAY_STALE_MS && state?.degraded !== true && state?.liveComplete === true && !syncing,
-    next: countdownFixture(nowMs, schedule, opts.pick) ?? null,
+    next: countdownFixture(nowMs, schedule, opts.pick, played) ?? null,
     degraded: state?.degraded === true,
     source: typeof state?.source === "string" ? state.source : null,
     updatedAt: stamp === void 0 ? null : new Date(stamp).toISOString(),
@@ -9783,6 +10317,16 @@ function inKnockoutPhase(nowMs, competition) {
   return !!next && isKnockoutStage(next.stage);
 }
 var NEVER = (/* @__PURE__ */ new Date(0)).toISOString();
+function carriedPlay(base, now, kind) {
+  return advancePlay(base?.play, NO_READ, now, kind);
+}
+function liveWithLastGoal(matches) {
+  return matches.map((m) => ({ ...m, lastGoal: provenLastGoal(m) }));
+}
+function playAfterRead(play, r, at, kind) {
+  const whole = !r.degraded && r.complete === true;
+  return advancePlay(play, { whole, matches: r.matches, finished: r.finished ?? [], finishedTruncated: r.finishedTruncated === true }, at, kind);
+}
 function liveAdapter(source, competition, now) {
   return makeAdapter(source, { competition, enrichGroups: false, now });
 }
@@ -9808,7 +10352,9 @@ async function runRefresh(opts) {
                 degraded: true,
                 // no live provider served this scope — never claim otherwise
                 source,
-                competition
+                competition,
+                play: { seen: [], finished: [] }
+                // nothing was read, and no snapshot to carry one from
               },
               idle
             );
@@ -9843,7 +10389,9 @@ async function runRefresh(opts) {
           degraded: until !== void 0,
           source,
           competition,
-          ...until !== void 0 ? { backoffUntil: new Date(until).toISOString() } : {}
+          ...until !== void 0 ? { backoffUntil: new Date(until).toISOString() } : {},
+          play: { seen: [], finished: [] }
+          // nothing was read, and no snapshot to carry one from
         },
         idle,
         nowMs
@@ -9885,6 +10433,8 @@ async function runRefresh(opts) {
     let liveComplete = base ? base.liveComplete : false;
     let degraded = base?.degraded ?? false;
     let updatedAt = base?.updatedAt ?? now.toISOString();
+    const kind = teamKind(competition);
+    let play = carriedPlay(base, now, kind);
     let fixtures = base?.fixtures;
     let fixturesUpdatedAt = base?.fixturesUpdatedAt;
     let fixturesAttemptedAt = base?.fixturesAttemptedAt;
@@ -9895,10 +10445,11 @@ async function runRefresh(opts) {
     const adapter = liveAdapter(source, competition, clock);
     if (needLive) {
       try {
-        const r = await getLiveRead(adapter, now);
-        live = r.matches;
+        const r = await getLiveRead(adapter, now, play.seen.map((e) => e.id));
+        live = liveWithLastGoal(r.matches);
         liveComplete = r.complete === true;
         degraded = r.degraded;
+        play = playAfterRead(play, r, now, kind);
         if (!r.degraded) season = r.season;
       } catch {
         liveComplete = false;
@@ -9946,7 +10497,8 @@ async function runRefresh(opts) {
           ...backoffUntil ? { backoffUntil } : {},
           ...season ? { season } : {},
           // Stored with the slice it describes, and only while that slice exists.
-          ...fixtures && fixturesSeason ? { fixturesSeason } : {}
+          ...fixtures && fixturesSeason ? { fixturesSeason } : {},
+          play
         },
         token,
         // The cycle's clock, not the carried live stamp: the throttle a
@@ -10028,6 +10580,8 @@ async function refreshOffBundle(c) {
     let liveComplete = base ? base.liveComplete : false;
     let degraded = base?.degraded ?? false;
     let updatedAt = base?.updatedAt ?? NEVER;
+    const kind = teamKind(competition);
+    let play = carriedPlay(base, now, kind);
     let season = sealSeason(base?.season);
     let index = view.index;
     let display = [...sealFixtures(base?.schedule?.fixtures, teamKind(competition)).items];
@@ -10057,7 +10611,8 @@ async function refreshOffBundle(c) {
         ...scheduleSeason ? { season: scheduleSeason } : {},
         ...inPlayUntil !== void 0 ? { inPlayUntil: new Date(inPlayUntil).toISOString() } : {},
         ...probe ? { probe: true } : {}
-      }
+      },
+      play
     });
     if (needDiscovery) {
       const before = { attemptedAt, failures };
@@ -10096,10 +10651,11 @@ async function refreshOffBundle(c) {
       if (ageMs(base, nowMs) >= MIN_REFRESH_MS) {
         const liveAt = clock();
         try {
-          const r = await getLiveRead(adapter, now);
-          live = r.matches;
+          const r = await getLiveRead(adapter, now, play.seen.map((e) => e.id));
+          live = liveWithLastGoal(r.matches);
           liveComplete = r.complete === true;
           degraded = r.degraded;
+          play = playAfterRead(play, r, new Date(liveAt), kind);
           if (!r.degraded) season = r.season;
           if (r.matches.length > 0) inPlayUntil = raiseInPlay(inPlayUntil, r.matches, nowMs);
           else if (!r.degraded && r.complete) inPlayUntil = void 0;
@@ -10484,7 +11040,8 @@ function adapterServing({ cfg, adapter, now }, competition) {
 }
 var DEFAULT_ON_MARKET_OPTS = { deadlineMs: 2e3, timeoutMs: 2500 };
 var MARKETS_CMD_OPTS = { deadlineMs: 12e3, timeoutMs: 6e3 };
-async function marketSignalsFor(ctx, matches, opts = {}, providerFactory = makeMarketProvider) {
+async function marketSignalsFor(ctx, matches, baseOpts, now, providerFactory = makeMarketProvider) {
+  const opts = { ...baseOpts, now };
   if (ctx.marketProvider) {
     const b = await getMarketSignals(ctx.marketProvider, matches, opts);
     return { signals: resolvedValues(b), complete: b.complete };
@@ -10495,7 +11052,12 @@ async function marketSignalsFor(ctx, matches, opts = {}, providerFactory = makeM
     return { signals: resolvedValues(b), complete: b.complete };
   }
   const competition = ctx.cfg.competition;
-  const { signals: cached, checked: cachedIds } = readMarketCache("polymarket", competition);
+  const { signals: cached, checked: cachedIds } = readMarketCache(
+    "polymarket",
+    competition,
+    Date.now(),
+    now
+  );
   const result = /* @__PURE__ */ new Map();
   const miss = [];
   for (const m of matches) {
@@ -10517,12 +11079,11 @@ async function marketSignalsFor(ctx, matches, opts = {}, providerFactory = makeM
   }
   return { signals: result, complete };
 }
-async function reliableMarketSignals(ctx, matches) {
+async function reliableMarketSignals(ctx, matches, now) {
   if (ctx.cfg.markets === false) return { signals: /* @__PURE__ */ new Map(), complete: true };
-  const now = ctx.now ?? /* @__PURE__ */ new Date();
   const relevant = matches.filter((m) => marketRelevant(m, now));
   if (relevant.length === 0) return { signals: /* @__PURE__ */ new Map(), complete: true };
-  const raw = await marketSignalsFor(ctx, relevant, DEFAULT_ON_MARKET_OPTS);
+  const raw = await marketSignalsFor(ctx, relevant, DEFAULT_ON_MARKET_OPTS, now);
   const out2 = /* @__PURE__ */ new Map();
   for (const [id, s] of raw.signals) {
     const m = relevant.find((x) => x.id === id);
@@ -10530,8 +11091,8 @@ async function reliableMarketSignals(ctx, matches) {
   }
   return { signals: out2, complete: raw.complete };
 }
-async function reliableMarketSignalFor(ctx, match) {
-  const result = await reliableMarketSignals(ctx, [match]);
+async function reliableMarketSignalFor(ctx, match, now) {
+  const result = await reliableMarketSignals(ctx, [match], now);
   return { signal: result.signals.get(match.id), complete: result.complete };
 }
 function out(line = "") {
@@ -10541,7 +11102,10 @@ function emitJson(data) {
   out(JSON.stringify(data, null, 2));
 }
 function modeOut(cfg, c) {
-  out(c.dim(`  ${modeLine(cfg.selection, cfg.lang)}`));
+  out(modeRow(cfg, c));
+}
+function modeRow(cfg, c) {
+  return c.dim(`  ${modeLine(cfg.selection, cfg.lang)}`);
 }
 function competitionKey(cfg) {
   return selectionExtras(cfg.selection);
@@ -10665,11 +11229,12 @@ async function cmdToday(date, ctx) {
   const { cfg, t: t2 } = ctx;
   precheck(cfg, t2, date);
   const adapter = adapterFor(ctx);
-  const targetDate = date ?? localDate((ctx.now ?? /* @__PURE__ */ new Date()).toISOString(), cfg.tz);
+  const now = requestClock(adapter, ctx.now);
+  const targetDate = date ?? localDate(now.toISOString(), cfg.tz);
   const day = await getMatchesForDate(adapter, targetDate, resolveTz(cfg.tz));
   const { matches, degraded, source } = day;
   const todays = fixturesByDate(targetDate, matches, cfg.tz);
-  const market = await reliableMarketSignals(ctx, todays);
+  const market = await reliableMarketSignals(ctx, todays, now);
   if (cfg.json) {
     emitJson({
       date: targetDate,
@@ -10721,13 +11286,14 @@ async function cmdToday(date, ctx) {
   const src = attribution.attributed ? dataSource(source, cfg.lang, c) : "";
   if (src) out(src);
   out(disclaimer(t2, c));
-  endScoreCommand(ctx);
+  endScoreCommand(ctx, now);
 }
 async function cmdLive(ctx) {
   const { cfg, t: t2 } = ctx;
   precheck(cfg, t2);
   const adapter = adapterFor(ctx);
-  const live = await getLiveMatches(adapter, ctx.now ?? /* @__PURE__ */ new Date());
+  const now = requestClock(adapter, ctx.now);
+  const live = await getLiveMatches(adapter, now);
   const { matches, degraded, source } = live;
   if (cfg.json) {
     emitJson({ degraded, source: source ?? null, matches, ...verdictExtras(live), ...competitionKey(cfg) });
@@ -10755,7 +11321,7 @@ async function cmdLive(ctx) {
   const src = dataSource(source, cfg.lang, c);
   if (src) out(src);
   out(disclaimer(t2, c));
-  endScoreCommand(ctx);
+  endScoreCommand(ctx, now);
 }
 async function cmdNext(team, ctx) {
   const { cfg, t: t2 } = ctx;
@@ -10796,7 +11362,7 @@ async function cmdNext(team, ctx) {
     }
     out();
     out(disclaimer(t2, c));
-    endScoreCommand(ctx);
+    endScoreCommand(ctx, now);
     return;
   }
   for (const q of qualifiers) out(c.dim("  " + q));
@@ -10814,7 +11380,7 @@ async function cmdNext(team, ctx) {
   const src = dataSource(source, cfg.lang, c);
   if (src) out(src);
   out(disclaimer(t2, c));
-  endScoreCommand(ctx);
+  endScoreCommand(ctx, now);
 }
 function cmdTeam(query, ctx) {
   const { cfg, t: t2 } = ctx;
@@ -11080,6 +11646,7 @@ function cmdAmbient({ cfg, now }, opts = {}) {
     }
     const { compact, max } = promptLineEnv();
     const preference = ambientPreference(cfg);
+    const lang = normalizeLang(cfg.lang);
     const state = readCurrentState(cfg.source, cfg.competition);
     const read = ambientView(state, {
       pick: preference.pick,
@@ -11091,26 +11658,37 @@ function cmdAmbient({ cfg, now }, opts = {}) {
       defaultCompetition: bundleApplies(cfg.competition),
       teamKind: teamKind(cfg.competition),
       now,
-      columns: opts.columns
+      columns: opts.columns,
+      // The line's own tokens in the CLI's resolved language (the statusline module reads no environment).
+      lang
     });
     const pick2 = preference.pick;
     const view = {
       line: read.line,
+      lineParts: read.lineParts,
       idle: read.idle,
       empty: read.empty,
       context: read.context,
       live: read.live,
+      finished: read.finished,
       current: read.current,
       next: read.next,
       pick: pick2 === void 0 ? null : "code" in pick2 ? { code: pick2.code } : pick2.team,
       ...preference.unreadable ? { pickUnreadable: true } : {},
       // A selected competition: core's key is present (see `selectionExtras`).
       ...selectionExtras(cfg.selection),
+      // The language of the line and of the plugin's moment words (core's `moment.*` keys, templates).
+      lang,
+      words: momentWords(lang),
       degraded: read.degraded,
       source: read.source,
       updatedAt: read.updatedAt,
       staleAfter: read.staleAfter,
-      disclaimer: DISCLAIMER
+      disclaimer: DISCLAIMER,
+      // The provider's sentence, English as every ambient string (never the reader's language): when the snapshot
+      // names a provider and the line is neither the sign-off (`idle`) nor nothing known (`empty`); none otherwise.
+      // `degraded` does not decide: a degraded snapshot still shows what an earlier read or discovery served.
+      attribution: read.source !== null && !read.idle && !read.empty ? t("en", "live.data", { source: liveSourceLabel(read.source) }) : null
     };
     out(JSON.stringify(view));
     printed = true;
@@ -11214,8 +11792,11 @@ async function cmdMatch(id, ctx) {
   const now = requestClock(adapter, ctx.now);
   const found = await getMatchById(adapter, id, now);
   const { match, degraded, source: liveSource } = found;
-  const market = match ? await reliableMarketSignalFor({ ...ctx, now }, match) : { signal: void 0, complete: true };
+  const market = match ? await reliableMarketSignalFor(ctx, match, now) : { signal: void 0, complete: true };
+  const answer = matchAnswerRows(found, id, market, cfg, t2);
   if (cfg.json) {
+    const rows = [...answer.rows];
+    while (rows.length && rowText(rows[rows.length - 1]) === "") rows.pop();
     emitJson({
       degraded,
       match: match ?? null,
@@ -11227,59 +11808,91 @@ async function cmdMatch(id, ctx) {
       // The span a whole read searched for an id it did not hold (a plain field).
       ...found.window ? { window: found.window } : {},
       ...verdictExtras(found),
+      lines: rows.map(rowText),
+      rows,
+      attribution: answer.attribution || null,
+      disclaimer: answer.disclaimer,
       ...competitionKey(cfg)
     });
     return;
   }
   const c = painterFor(cfg);
-  const qualifiers = verdictQualifiers(found, cfg.lang);
   out();
+  for (const row of answer.rows) out(paintRow(row, c));
+  if (answer.attribution) out(c.dim(answer.attribution));
+  out(c.dim(answer.disclaimer));
+  if (match) maybeStarNudge(ctx);
+}
+function rowText(row) {
+  return row.parts.map((p) => p.text).join("");
+}
+function paintPart(p, c) {
+  switch (p.style) {
+    case "strong":
+      return c.bold(p.text);
+    case "dim":
+    case "quote":
+      return c.dim(p.text);
+    case "accent":
+    case "flair":
+      return c.green(p.text);
+    default:
+      return p.text;
+  }
+}
+function paintRow(row, c) {
+  return row.parts.map((p) => paintPart(p, c)).join("");
+}
+function matchAnswerRows(found, id, market, cfg, t2) {
+  const { match, degraded, source: liveSource } = found;
+  const rows = [];
+  const row = (role, ...parts) => rows.push({ role, parts });
+  const blank = (role = "blank") => rows.push({ role, parts: [] });
+  const plain2 = painterFor({ ...cfg, color: false });
+  const footer = { disclaimer: disclaimer(t2, plain2) };
+  const mode = { text: modeRow(cfg, plain2), style: "dim" };
+  const qualifiers = verdictQualifiers(found, cfg.lang);
   if (!match) {
-    modeOut(cfg, c);
-    for (const q of qualifiers) out(c.dim("  " + q));
-    out(
-      c.dim(
-        "  " + (degraded ? t2("live.degraded") : verdictNotice(found, cfg.lang) ?? matchWindowSentence(found, id, cfg.lang) ?? matchNoneReadSentence(found, id, cfg.lang) ?? t2("match.none", { id }))
-      )
-    );
-    out();
-    out(disclaimer(t2, c));
-    return;
+    row("text", mode);
+    for (const q of qualifiers) row("text", { text: "  " + q, style: "dim" });
+    row("text", {
+      text: "  " + (degraded ? t2("live.degraded") : verdictNotice(found, cfg.lang) ?? matchWindowSentence(found, id, cfg.lang) ?? matchNoneReadSentence(found, id, cfg.lang) ?? t2("match.none", { id })),
+      style: "dim"
+    });
+    blank("text");
+    return { rows, attribution: "", ...footer };
   }
-  for (const q of qualifiers) out(c.dim("  " + q));
+  for (const q of qualifiers) row("qualifier", { text: "  " + q, style: "dim" });
   const attribution = dayAttribution(found, [match], cfg.lang);
-  if (attribution.unserved) out(c.dim("  " + attribution.unserved));
-  out(header(`${match.home.name} ${scoreline(match)} ${match.away.name}`, c));
-  modeOut(cfg, c);
+  if (attribution.unserved) row("qualifier", { text: "  " + attribution.unserved, style: "dim" });
+  const pin = cfg.pin;
+  const side = (team) => pin !== void 0 && isPinnedSide(team, pin) ? { text: team.name, style: "accent" } : { text: team.name };
+  row("title", side(match.home), { text: " " }, { text: scoreline(match), style: "strong" }, { text: " " }, side(match.away));
+  row("mode", mode);
   const where = joinSegments([stageLabelI18n(cfg.lang, match), matchLocation(match)]);
-  if (where) out("  " + c.dim(where));
-  out(
-    "  " + c.dim(
-      `${formatKickoff(match.kickoff, { tz: cfg.tz, locale: cfg.lang })}  ${statusToken(match, t2, c)}`.trimEnd()
-    )
-  );
+  if (where) row("meta", { text: "  " }, { text: where, style: "dim" });
+  const word = statusWord(match, t2);
+  const kickoff = { text: `${t2("match.kickoff")} ${formatKickoff(match.kickoff, { tz: cfg.tz, locale: cfg.lang })}`, style: "dim" };
+  if (word) row("status", { text: "  " }, { text: word, style: "strong" }, { text: " \xB7 ", style: "dim" }, kickoff);
+  else row("status", { text: "  " }, kickoff);
   const flair = matchFlair(match, flairOpts(cfg));
-  if (flair.text) out("  " + (flair.rally ? c.green(flair.text) : c.cyan(flair.text)));
-  if (match.events?.length) {
-    out();
-    for (const e of match.events) {
-      out(`  ${e.minute}'  ${e.type}  ${e.teamCode}${e.player ? ` \u2014 ${e.player}` : ""}`);
-    }
-  }
+  if (flair.text) row("flair", { text: "  " }, { text: flair.text, style: flair.rally ? "flair" : "quote" });
   if (market.signal) {
-    out();
-    for (const mline of marketBlock(market.signal, match)) out("  " + c.dim(mline));
+    blank();
+    for (const mline of marketBlock(market.signal, match)) row("market", { text: "  " }, { text: mline, style: "dim" });
+  }
+  const timeline = timelineParts(match, { lang: cfg.lang, flags: flagsEnabled() });
+  if (timeline.length) {
+    blank();
+    for (const parts of timeline) row("event", ...parts);
   }
   if (!market.complete) {
-    out();
-    out(c.dim("  Market data unavailable or incomplete \u2014 this match could not be checked."));
+    blank();
+    row("note", { text: "  Market data unavailable or incomplete \u2014 this match could not be checked.", style: "dim" });
   }
-  out();
-  if (degraded) out(c.dim("  " + t2(found.earlierRecord ? "feed.earlierRecord" : "feed.degraded")));
-  const src = dataSource(liveSource, cfg.lang, c);
-  if (src) out(src);
-  out(disclaimer(t2, c));
-  maybeStarNudge(ctx);
+  blank();
+  if (degraded) row("note", { text: "  " + t2(found.earlierRecord ? "feed.earlierRecord" : "feed.degraded"), style: "dim" });
+  return { rows, attribution: dataSource(liveSource, cfg.lang, plain2), ...footer };
 }
 var MARKET_INFO = "Prediction-market data is informational only.";
 function marketHeaderLine(m, cfg) {
@@ -11302,10 +11915,11 @@ async function cmdMarkets(target, team, ctx) {
     const asked = teamAsked(team, cfg);
     if (!asked) throw new InputError(usage);
     const code = "pin" in asked ? asked.pin.code : resolveTeamArg(asked.query, usage, t2, cfg.competition);
-    const now2 = ctx.now ?? /* @__PURE__ */ new Date();
-    const picked = await marketFixtureForTeam(adapterFor(ctx), code, now2);
+    const adapter2 = adapterFor(ctx);
+    const now2 = requestClock(adapter2, ctx.now);
+    const picked = await marketFixtureForTeam(adapter2, code, now2);
     const { match: fixture, degraded } = picked;
-    const market = fixture && marketRelevant(fixture, now2) ? await marketSignalsFor(ctx, [fixture], MARKETS_CMD_OPTS) : { signals: /* @__PURE__ */ new Map(), complete: true };
+    const market = fixture && marketRelevant(fixture, now2) ? await marketSignalsFor(ctx, [fixture], MARKETS_CMD_OPTS, now2) : { signals: /* @__PURE__ */ new Map(), complete: true };
     const sig = fixture ? market.signals.get(fixture.id) : void 0;
     const shown = market.complete && fixture && sig && marketDisplayable(fixture, sig) ? sig : void 0;
     if (cfg.json) {
@@ -11372,11 +11986,11 @@ async function cmdMarkets(target, team, ctx) {
       out(c3.dim(MARKET_INFO));
       return;
     }
-    const adapter = adapterFor(ctx);
-    const now2 = requestClock(adapter, ctx.now);
-    const found = await getMatchById(adapter, target, now2);
+    const adapter2 = adapterFor(ctx);
+    const now2 = requestClock(adapter2, ctx.now);
+    const found = await getMatchById(adapter2, target, now2);
     const { match } = found;
-    const market = match && marketRelevant(match, now2) ? await marketSignalsFor(ctx, [match], MARKETS_CMD_OPTS) : { signals: /* @__PURE__ */ new Map(), complete: true };
+    const market = match && marketRelevant(match, now2) ? await marketSignalsFor(ctx, [match], MARKETS_CMD_OPTS, now2) : { signals: /* @__PURE__ */ new Map(), complete: true };
     const sig = match ? market.signals.get(match.id) : void 0;
     const shown = market.complete && match && sig && marketDisplayable(match, sig) ? sig : void 0;
     if (cfg.json) {
@@ -11412,12 +12026,13 @@ async function cmdMarkets(target, team, ctx) {
   }
   const explicitDate = target && target !== "today" ? target : void 0;
   precheck(cfg, t2, explicitDate);
-  const now = ctx.now ?? /* @__PURE__ */ new Date();
+  const adapter = adapterFor(ctx);
+  const now = requestClock(adapter, ctx.now);
   const date = explicitDate ?? localDate(now.toISOString(), cfg.tz);
-  const day = await getMatchesForDate(adapterFor(ctx), date, resolveTz(cfg.tz));
+  const day = await getMatchesForDate(adapter, date, resolveTz(cfg.tz));
   const todays = fixturesByDate(date, day.matches, cfg.tz);
   const relevant = todays.filter((m) => marketRelevant(m, now));
-  const { signals, complete } = await marketSignalsFor(ctx, relevant, MARKETS_CMD_OPTS);
+  const { signals, complete } = await marketSignalsFor(ctx, relevant, MARKETS_CMD_OPTS, now);
   const rows = relevant.map((m) => ({ match: m, signal: signals.get(m.id) })).filter(
     (r) => !!r.signal && marketDisplayable(r.match, r.signal)
   );
@@ -11466,8 +12081,8 @@ async function cmdMarkets(target, team, ctx) {
 function pickShareStyle(v) {
   return v === "compact" ? "compact" : "social";
 }
-async function reliableShareSignals(ctx, matches) {
-  const raw = await reliableMarketSignals(ctx, matches);
+async function reliableShareSignals(ctx, matches, now) {
+  const raw = await reliableMarketSignals(ctx, matches, now);
   const out2 = /* @__PURE__ */ new Map();
   for (const [id, s] of raw.signals) {
     const m = matches.find((x) => x.id === id);
@@ -11568,7 +12183,8 @@ async function cmdShare(target, team, opts, ctx) {
   const where = { tz: cfg.tz, locale: cfg.lang, competition: cfg.competition };
   if (target === "live") {
     precheck(cfg, t2);
-    const live = await getLiveMatches(adapterFor(ctx), ctx.now ?? /* @__PURE__ */ new Date());
+    const adapter2 = adapterFor(ctx);
+    const live = await getLiveMatches(adapter2, requestClock(adapter2, ctx.now));
     emitMatchCard(ctx, liveShareCard(live, where), { ...baseOptions, includeMarkets: false }, copy);
     return;
   }
@@ -11609,27 +12225,29 @@ async function cmdShare(target, team, opts, ctx) {
   }
   if (target === "next") {
     precheck(cfg, t2);
-    const { code, next, now } = await nextAsked(ctx, team, teamUsage("share next", cfg));
-    const market2 = await reliableShareSignals({ ...ctx, now }, next.fixture ? [next.fixture] : []);
+    const { code, next, now: now2 } = await nextAsked(ctx, team, teamUsage("share next", cfg));
+    const market2 = await reliableShareSignals(ctx, next.fixture ? [next.fixture] : [], now2);
     emitMatchCard(ctx, nextShareCard(next, code, market2, where), baseOptions, copy);
     return;
   }
   if (target && target !== "today" && !isValidDate(target)) {
     precheck(cfg, t2);
-    const adapter = adapterFor(ctx);
-    const now = requestClock(adapter, ctx.now);
-    const found = await getMatchById(adapter, target, now);
-    const market2 = await reliableShareSignals({ ...ctx, now }, found.match ? [found.match] : []);
+    const adapter2 = adapterFor(ctx);
+    const now2 = requestClock(adapter2, ctx.now);
+    const found = await getMatchById(adapter2, target, now2);
+    const market2 = await reliableShareSignals(ctx, found.match ? [found.match] : [], now2);
     emitMatchCard(ctx, matchShareCard(found, target, market2, where), baseOptions, copy);
     return;
   }
   const explicitDate = target && target !== "today" ? target : void 0;
   precheck(cfg, t2, explicitDate);
-  const date = explicitDate ?? localDate((ctx.now ?? /* @__PURE__ */ new Date()).toISOString(), cfg.tz);
-  const day = await getMatchesForDate(adapterFor(ctx), date, resolveTz(cfg.tz));
+  const adapter = adapterFor(ctx);
+  const now = requestClock(adapter, ctx.now);
+  const date = explicitDate ?? localDate(now.toISOString(), cfg.tz);
+  const day = await getMatchesForDate(adapter, date, resolveTz(cfg.tz));
   const { matches: all, degraded, source } = day;
   const todays = fixturesByDate(date, all, cfg.tz);
-  const market = await reliableShareSignals(ctx, todays);
+  const market = await reliableShareSignals(ctx, todays, now);
   emitMatchCard(
     ctx,
     dateShareCard(
@@ -11717,7 +12335,8 @@ async function pinFor(ctx, competition, query) {
   if (!isKnownSource(cfg.source)) {
     throw new InputError(t2("err.source", { source: cfg.source, sources: KNOWN_SOURCES.join(", ") }));
   }
-  const next = await getNextFixtureForTeam(adapterServing(ctx, competition), label2, ctx.now ?? /* @__PURE__ */ new Date());
+  const adapter = adapterServing(ctx, competition);
+  const next = await getNextFixtureForTeam(adapter, label2, requestClock(adapter, ctx.now));
   if (next.team) {
     const { id, code, name } = next.team;
     return id !== void 0 ? { id, code, name } : { code, name };
@@ -11910,8 +12529,8 @@ function maybeStarNudge(ctx) {
   out();
   out(c.dim(`  \u2B50 Enjoying Claudinho? Star it \u2192 ${REPO_URL}   (claudinho star)`));
 }
-function endScoreCommand(ctx) {
-  const over = bundleApplies(ctx.cfg.competition) && isTournamentWindowOver(ctx.now?.getTime() ?? Date.now());
+function endScoreCommand(ctx, now) {
+  const over = bundleApplies(ctx.cfg.competition) && isTournamentWindowOver(now.getTime());
   if (over) printTournamentSignOff(ctx);
   else maybeStarNudge(ctx);
 }
@@ -11935,7 +12554,8 @@ function printInitStarCta(cfg) {
 function cmdVibe(ctx) {
   const { cfg } = ctx;
   const bundled = cfg.selection.kind === "selected" && bundleApplies(cfg.competition);
-  const pool = vibePool(localDate((ctx.now ?? /* @__PURE__ */ new Date()).toISOString(), cfg.tz), bundled);
+  const now = ctx.now ?? /* @__PURE__ */ new Date();
+  const pool = vibePool(localDate(now.toISOString(), cfg.tz), bundled);
   const line = pool[Math.floor(Math.random() * pool.length)];
   let liveSeg;
   try {
@@ -11943,7 +12563,7 @@ function cmdVibe(ctx) {
     const state = readCurrentState(cfg.source, cfg.competition);
     liveSeg = vibeLiveSegment(
       // Sealed with the competition's written kind, like the statusline's.
-      liveMatchesFromCache(state, (ctx.now ?? /* @__PURE__ */ new Date()).getTime(), teamKind(cfg.competition)).items,
+      liveMatchesFromCache(state, now.getTime(), teamKind(cfg.competition)).items,
       // The statusline's and the hook's pick (offline).
       ambientPick(cfg)
     );
@@ -11969,7 +12589,7 @@ function handlePipeError(stream) {
 }
 handlePipeError(process.stdout);
 handlePipeError(process.stderr);
-var VERSION = "0.11.2";
+var VERSION = "0.12.0";
 var DISCLAIMER2 = `Claudinho is an ${FAN_PROJECT.toLowerCase()}. ${DISCLAIMER}`;
 function ctxFrom(cmd) {
   let root = cmd;