@claudinho/cli 0.10.0 → 0.10.1

package/dist/index.js

@@ -274,6 +274,8 @@ var EN = {
   "bracket.slot.tbd": "TBD",
   "live.data": "Live data: {source}",
   "standings.unavailable": "Live standings unavailable.",
+  "standings.partial": "Partial table \u2014 {n} rows could not be read.",
+  "competition.unsupported": "Not available for this competition yet.",
   "share.tryIt": "Try it: {line}",
   "stage.group": "Group {group}",
   "stage.groupStage": "Group stage",
@@ -304,6 +306,8 @@ var ES = {
   "bracket.slot.tbd": "Por definir",
   "live.data": "Datos en vivo: {source}",
   "standings.unavailable": "Tabla en vivo no disponible.",
+  "standings.partial": "Tabla parcial \u2014 no se pudieron leer {n} filas.",
+  "competition.unsupported": "A\xFAn no disponible para esta competici\xF3n.",
   "share.tryIt": "Pru\xE9balo: {line}",
   "stage.group": "Grupo {group}",
   "stage.groupStage": "Fase de grupos",
@@ -334,6 +338,8 @@ var PT = {
   "bracket.slot.tbd": "A definir",
   "live.data": "Dados ao vivo: {source}",
   "standings.unavailable": "Classifica\xE7\xE3o ao vivo indispon\xEDvel.",
+  "standings.partial": "Tabela parcial \u2014 {n} linhas n\xE3o puderam ser lidas.",
+  "competition.unsupported": "Ainda n\xE3o dispon\xEDvel para esta competi\xE7\xE3o.",
   "share.tryIt": "Experimente: {line}",
   "stage.group": "Grupo {group}",
   "stage.groupStage": "Fase de grupos",
@@ -364,6 +370,8 @@ var FR = {
   "bracket.slot.tbd": "\xC0 d\xE9finir",
   "live.data": "Donn\xE9es en direct : {source}",
   "standings.unavailable": "Classement en direct indisponible.",
+  "standings.partial": "Classement partiel \u2014 {n} lignes n'ont pas pu \xEAtre lues.",
+  "competition.unsupported": "Pas encore disponible pour cette comp\xE9tition.",
   "share.tryIt": "Essayez : {line}",
   "stage.group": "Groupe {group}",
   "stage.groupStage": "Phase de groupes",
@@ -2848,11 +2856,13 @@ function fixturesByGroup(group, fixtures = SCHEDULE) {
   const g = group.toUpperCase();
   return fixtures.filter((m) => (m.group ?? "").toUpperCase() === g).sort(byKickoff);
 }
+function isUpcoming(m, now = /* @__PURE__ */ new Date()) {
+  if (m.status === "CANCELLED" || m.status === "POSTPONED") return false;
+  return Date.parse(m.kickoff) >= now.getTime();
+}
 function nextFixtureForTeam(code, opts = {}) {
   const from = opts.from ?? /* @__PURE__ */ new Date();
-  return fixturesByTeam(code, opts.fixtures ?? SCHEDULE).find(
-    (m) => new Date(m.kickoff).getTime() >= from.getTime()
-  );
+  return fixturesByTeam(code, opts.fixtures ?? SCHEDULE).find((m) => isUpcoming(m, from));
 }
 var LIVE_WINDOW_MS = 140 * 6e4;
 var KNOCKOUT_EXTRA_TIME_MS = 60 * 6e4;
@@ -2980,8 +2990,8 @@ function humanLabel(value, maxColumns = MAX_LABEL_COLUMNS) {
   const capped = value.length > MAX_LABEL_INPUT_UNITS ? value.slice(0, MAX_LABEL_INPUT_UNITS) : value;
   return visible(runToFixedPoint(capped, maxColumns));
 }
-function visible(label) {
-  return label !== "" && displayWidth(label) === 0 ? "" : label;
+function visible(label2) {
+  return label2 !== "" && displayWidth(label2) === 0 ? "" : label2;
 }
 function runToFixedPoint(capped, maxColumns) {
   const first = sealLabelOnce(capped, maxColumns);
@@ -3209,7 +3219,7 @@ function toParticipant(raw) {
   const providerId = opaqueId(raw.team?.id, ESPN_ID);
   const known = productFlag(name) !== nationToFlag("");
   return valid(
-    providerId && known ? { kind: "team", providerId, team } : { kind: "slot", team }
+    providerId && known ? { kind: "team", providerId, team } : { kind: "slot", ...providerId ? { providerId } : {}, team }
   );
 }
 function mapStatus(st) {
@@ -3278,7 +3288,7 @@ function parseEspnEvent(raw, ctx = {}) {
   if (awayP.kind !== "valid") return awayP;
   const h = homeP.value;
   const a = awayP.value;
-  if (h.kind === "team" && a.kind === "team" && h.providerId === a.providerId) {
+  if (h.providerId !== void 0 && h.providerId === a.providerId) {
     return definitiveNone("both competitors are the same team");
   }
   const home = homeP.value.team;
@@ -3430,9 +3440,13 @@ function parseEspnStandings(raw) {
   const seenGroups = /* @__PURE__ */ new Set();
   const seenProviderIds = /* @__PURE__ */ new Set();
   for (const child of children) {
-    const label = humanLabel(child?.name ?? child?.abbreviation);
-    const letter = label.match(/Group\s+([A-L])/i)?.[1]?.toUpperCase();
-    if (!letter) continue;
+    const label2 = humanLabel(child?.name ?? child?.abbreviation);
+    const letter = label2.match(/Group\s+([A-L])(?![A-Za-z0-9])/i)?.[1]?.toUpperCase();
+    if (!letter) {
+      const rows = child?.standings?.entries;
+      if (Array.isArray(rows) && rows.length > 0) complete = false;
+      continue;
+    }
     if (seenGroups.has(letter)) {
       complete = false;
       continue;
@@ -3443,9 +3457,11 @@ function parseEspnStandings(raw) {
       complete = false;
       continue;
     }
+    let omitted = 0;
     if (rawEntries.length > MAX_GROUP_ROWS) {
       rowsTruncated = true;
       complete = false;
+      omitted += rawEntries.length - MAX_GROUP_ROWS;
     }
     const entries = takeBounded(rawEntries, MAX_GROUP_ROWS);
     const seenCodes = /* @__PURE__ */ new Map();
@@ -3455,6 +3471,7 @@ function parseEspnStandings(raw) {
       const r = entryToRow(e);
       if (r.kind !== "valid") {
         if (r.kind !== "definitive-none") complete = false;
+        omitted += 1;
         continue;
       }
       const { providerId, providerRank } = r.value;
@@ -3463,13 +3480,14 @@ function parseEspnStandings(raw) {
       const codeCollision = priorHadId !== void 0 && (providerId === void 0 || priorHadId === false);
       if (codeCollision || seenRanks.has(providerRank) || providerId !== void 0 && seenProviderIds.has(providerId)) {
         complete = false;
+        omitted += 1;
         continue;
       }
       seenCodes.set(code, providerId !== void 0);
       seenRanks.add(providerRank);
       if (providerId !== void 0) seenProviderIds.add(providerId);
       const { providerId: _dropId, providerRank: rank, ...row } = r.value;
-      ranked.push({ row, rank });
+      ranked.push({ row: { ...row, rank }, rank });
     }
     ranked.sort((a, b) => {
       if (a.rank && b.rank && a.rank !== b.rank) return a.rank - b.rank;
@@ -3481,7 +3499,11 @@ function parseEspnStandings(raw) {
       complete = false;
       continue;
     }
-    out2.push({ group: letter, rows: ranked.map((x) => x.row) });
+    out2.push({
+      group: letter,
+      rows: ranked.map((x) => x.row),
+      ...omitted > 0 ? { partial: { omitted } } : {}
+    });
   }
   return {
     items: out2,
@@ -3492,11 +3514,72 @@ function parseEspnStandings(raw) {
     complete: complete && !rowsTruncated
   };
 }
+var ResponseTooLargeError = class extends Error {
+  constructor(bytes, limit) {
+    super(`response body exceeds ${limit} bytes (${bytes} seen)`);
+    this.bytes = bytes;
+    this.limit = limit;
+    this.name = "ResponseTooLargeError";
+  }
+  bytes;
+  limit;
+};
+function isStream(v) {
+  return typeof v?.getReader === "function";
+}
+async function readJsonBounded(res, maxBytes) {
+  const r = res;
+  const declared = Number(r.headers?.get?.("content-length"));
+  if (Number.isFinite(declared) && declared > maxBytes) {
+    if (isStream(r.body)) await r.body.cancel().catch(() => {
+    });
+    throw new ResponseTooLargeError(declared, maxBytes);
+  }
+  if (isStream(r.body)) {
+    const reader = r.body.getReader();
+    const chunks = [];
+    let total = 0;
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        await reader.cancel().catch(() => {
+        });
+        throw new ResponseTooLargeError(total, maxBytes);
+      }
+      chunks.push(value);
+    }
+    return JSON.parse(new TextDecoder().decode(Buffer.concat(chunks)));
+  }
+  if (typeof r.text === "function") {
+    const text = await r.text();
+    const size = Buffer.byteLength(text);
+    if (size > maxBytes) throw new ResponseTooLargeError(size, maxBytes);
+    return JSON.parse(text);
+  }
+  if (typeof r.json === "function") return r.json();
+  throw new TypeError("response has no readable body");
+}
 var ESPN_SOCCER = "https://site.api.espn.com/apis/site/v2/sports/soccer";
 var DEFAULT_COMPETITION = "fifa.world";
 var DEFAULT_BASE = `${ESPN_SOCCER}/${DEFAULT_COMPETITION}`;
-var USER_AGENT = `claudinho/${"0.10.0"} (+https://github.com/arturogarrido/claudinho)`;
+var USER_AGENT = `claudinho/${"0.10.1"} (+https://github.com/arturogarrido/claudinho)`;
 var MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
+var DEFAULT_COOLDOWN_MS = 5 * 6e4;
+var MAX_COOLDOWN_MS = 15 * 6e4;
+function retryAfterMs(header2, nowMs) {
+  if (typeof header2 !== "string" || header2.trim() === "") return DEFAULT_COOLDOWN_MS;
+  const h = header2.trim();
+  let ms;
+  if (/^\d+$/.test(h)) ms = Number(h) * 1e3;
+  else {
+    const at = Date.parse(h);
+    if (Number.isFinite(at)) ms = at - nowMs;
+  }
+  if (ms === void 0 || !Number.isFinite(ms)) return DEFAULT_COOLDOWN_MS;
+  return Math.min(Math.max(ms, 0), MAX_COOLDOWN_MS);
+}
 function competitionBase(slug) {
   return `${ESPN_SOCCER}/${slug}`;
 }
@@ -3505,6 +3588,8 @@ var STANDINGS_SHARE_MS = 3e4;
 var ProviderError = class extends Error {
   kind;
   status;
+  /** For a throttle: how long the adapter will refuse to fetch (bounded). */
+  retryAfterMs;
   constructor(message, kind, status) {
     super(message);
     this.name = "ProviderError";
@@ -3528,6 +3613,7 @@ function usableProviderItems(kind, parsed, hasUsableRecord = parsed.items.length
 var EspnAdapter = class {
   constructor(opts = {}) {
     this.opts = opts;
+    this.clock = opts.now ?? (() => Date.now());
     const expected = opts.expectedStandingsGroups ?? (opts.baseUrl === void 0 ? groups() : void 0);
     this.expectedStandingsGroups = expected ? [...expected] : void 0;
     this.standingsFallbackGroups = opts.baseUrl === void 0 && expected ? [...expected] : void 0;
@@ -3553,6 +3639,53 @@ var EspnAdapter = class {
    * throttle (persist a backoff) from an ordinary blip.
    */
   lastError;
+  /**
+   * A retained throttle (audit A12): after a 429/403 every call inside the
+   * window throws the provider's last answer WITHOUT a request. A server-
+   * lifetime MCP adapter is covered by this alone; the CLI pre-arms each
+   * process from its persisted cache via `armCooldown`.
+   */
+  cooldownUntilMs;
+  cooldownError;
+  cooldownListeners = /* @__PURE__ */ new Set();
+  clock;
+  /** Epoch ms until which requests are refused, when a cooldown is armed. */
+  get cooldownUntil() {
+    return this.cooldownUntilMs;
+  }
+  /**
+   * Arm the cooldown from outside — a fresh CLI process reading the backoff
+   * its refresher persisted. The retained error reads as a throttle so every
+   * caller's `degraded` path and the refresher's persistence treat it as one.
+   */
+  armCooldown(untilMs, reason) {
+    const nowMs = this.clock();
+    const error = reason ?? new ProviderError("ESPN request skipped: provider cooldown in effect", "http", 429);
+    error.retryAfterMs = Math.max(0, untilMs - nowMs);
+    this.arm(untilMs, error);
+  }
+  /**
+   * Be told whenever the cooldown window is armed or EXTENDED — the way a
+   * caller persists a throttle that arrives from a still-running request after
+   * its own call already returned (review P2 on #128). Returns unsubscribe.
+   */
+  onCooldown(listener) {
+    this.cooldownListeners.add(listener);
+    return () => {
+      this.cooldownListeners.delete(listener);
+    };
+  }
+  /**
+   * The ONE place a window is set. Concurrent requests can each carry a
+   * Retry-After; the LATEST expiry wins — a shorter one arriving second must
+   * never shorten a longer active window (review P2 on #128).
+   */
+  arm(untilMs, error) {
+    if (this.cooldownUntilMs !== void 0 && untilMs <= this.cooldownUntilMs) return;
+    this.cooldownUntilMs = untilMs;
+    this.cooldownError = error;
+    for (const listener of this.cooldownListeners) listener(untilMs);
+  }
   async fetchByDate(dateISO) {
     return this.fetchScoreboard(toEspnDate(dateISO));
   }
@@ -3640,6 +3773,11 @@ var EspnAdapter = class {
     return usableProviderItems("scoreboard", parsed);
   }
   async get(url) {
+    const nowMs = this.clock();
+    if (this.cooldownError && this.cooldownUntilMs !== void 0 && nowMs < this.cooldownUntilMs) {
+      this.lastError = this.cooldownError;
+      throw this.cooldownError;
+    }
     const doFetch = this.opts.fetchImpl ?? fetch;
     const controller = new AbortController();
     const timer = setTimeout(
@@ -3661,19 +3799,24 @@ var EspnAdapter = class {
         throw e?.name === "AbortError" ? new ProviderError(`ESPN request timed out: ${url}`, "timeout") : new ProviderError(`ESPN request failed: ${e?.message ?? e}`, "http");
       }
       if (!res.ok) {
-        throw new ProviderError(
+        const pe = new ProviderError(
           `ESPN request failed: ${res.status} ${res.statusText}`,
           "http",
           res.status
         );
-      }
-      const length = Number(res.headers?.get?.("content-length"));
-      if (Number.isFinite(length) && length > MAX_RESPONSE_BYTES) {
-        throw new ProviderError(`ESPN response too large: ${length} bytes`, "parse");
+        if (pe.throttled) {
+          const receiptMs = this.clock();
+          pe.retryAfterMs = retryAfterMs(res.headers?.get?.("retry-after"), receiptMs);
+          this.arm(receiptMs + pe.retryAfterMs, pe);
+        }
+        throw pe;
       }
       try {
-        return await res.json();
+        return await readJsonBounded(res, MAX_RESPONSE_BYTES);
       } catch (e) {
+        if (e instanceof ResponseTooLargeError) {
+          throw new ProviderError(`ESPN response too large: ${e.bytes} bytes`, "parse");
+        }
         throw new ProviderError(
           `ESPN response unparseable: ${e?.message ?? e}`,
           "parse"
@@ -3716,14 +3859,30 @@ function hasGroupStarted(group, tables) {
 function matchesPerTeamInGroup(teamCount) {
   return Math.max(0, teamCount - 1);
 }
-function isGroupStandingsComplete(table) {
-  const n = table?.rows.length ?? 0;
+function isGroupStandingsComplete(table, expectedTeams) {
+  if (!table || table.partial) return false;
+  const n = table.rows.length;
   if (n < 2) return false;
-  const required = matchesPerTeamInGroup(n);
+  if (expectedTeams !== void 0 && n < expectedTeams) return false;
+  const required = matchesPerTeamInGroup(Math.max(n, expectedTeams ?? n));
   return table.rows.every((r) => r.played >= required);
 }
+function bundledGroupSize(group) {
+  const codes = /* @__PURE__ */ new Set();
+  for (const m of fixturesByGroup(group)) {
+    codes.add(m.home.code);
+    codes.add(m.away.code);
+  }
+  return codes.size > 0 ? codes.size : void 0;
+}
 function isGroupComplete(group, tables) {
-  return isGroupStandingsComplete(tables.find((t2) => t2.group === group));
+  return isGroupStandingsComplete(
+    tables.find((t2) => t2.group === group),
+    bundledGroupSize(group)
+  );
+}
+function isGroupPartial(group, tables) {
+  return tables.find((t2) => t2.group === group)?.partial !== void 0;
 }
 function resolveWinner(match) {
   if (!isFinished(match.status)) return void 0;
@@ -3757,8 +3916,8 @@ function resolveLoser(match) {
 function participant(team, status) {
   return { label: team.name, flag: team.flag, code: team.code, status };
 }
-function tbd(label) {
-  return { label, flag: "\u{1F3F3}\uFE0F", status: "tbd" };
+function tbd(label2) {
+  return { label: label2, flag: "\u{1F3F3}\uFE0F", status: "tbd" };
 }
 function confirmedLiveParticipant(team) {
   if (!team || team.flag === "\u{1F3F3}\uFE0F") return void 0;
@@ -3778,15 +3937,15 @@ function resolveSlot(ref, ctx, liveTeam, fixtureInMergedSet = false) {
       return tbd(ref.label);
     case "group": {
       if (liveParticipant) return liveParticipant;
-      if (!ctx.standingsDegraded && hasGroupStarted(ref.group, ctx.tables)) {
+      if (!ctx.standingsDegraded && !isGroupPartial(ref.group, ctx.tables) && hasGroupStarted(ref.group, ctx.tables)) {
         const team = teamFromStandings(ref.group, ref.position, ctx.tables);
         if (team) {
           const status = isGroupComplete(ref.group, ctx.tables) ? "confirmed" : "projected";
           return participant(team, status);
         }
       }
-      const label = ref.position === 1 ? t(ctx.lang, "bracket.slot.groupWinner", { group: ref.group }) : t(ctx.lang, "bracket.slot.groupSecond", { group: ref.group });
-      return tbd(label);
+      const label2 = ref.position === 1 ? t(ctx.lang, "bracket.slot.groupWinner", { group: ref.group }) : t(ctx.lang, "bracket.slot.groupSecond", { group: ref.group });
+      return tbd(label2);
     }
     case "third":
       if (liveParticipant) return liveParticipant;
@@ -4412,13 +4571,17 @@ function resolveCompetition(explicit) {
   }
   return DEFAULT_COMPETITION;
 }
+var BUNDLE_COMPETITION = DEFAULT_COMPETITION;
+function bundleApplies(competition = resolveCompetition()) {
+  return competition === BUNDLE_COMPETITION;
+}
 var KNOWN_SOURCES = ["espn"];
 function makeAdapter(source = "espn", opts = {}) {
   switch (source) {
     case "espn": {
       const competition = resolveCompetition();
       const baseUrl = competition === DEFAULT_COMPETITION ? void 0 : competitionBase(competition);
-      return new EspnAdapter({ baseUrl, enrichGroups: opts.enrichGroups });
+      return new EspnAdapter({ baseUrl, enrichGroups: opts.enrichGroups, now: opts.now });
     }
     default:
       throw new Error(
@@ -4436,7 +4599,7 @@ function liveSourceLabel(source) {
   return known[source] ?? source.charAt(0).toUpperCase() + source.slice(1);
 }
 async function getMatchesForDate(adapter, dateISO) {
-  const base = allFixtures();
+  const base = bundleApplies() ? allFixtures() : [];
   const day = dateISO.slice(0, 10);
   try {
     const live = adapter.fetchWindow ? await adapter.fetchWindow(shiftUtcDate(day, -1), shiftUtcDate(day, 1)) : await adapter.fetchByDate(day);
@@ -4481,21 +4644,27 @@ function knockoutWindow() {
   return knockoutWindowMemo;
 }
 async function getBracket(adapter, opts = {}) {
+  if (!bundleApplies()) {
+    const view2 = { stages: [], degraded: false, standingsDegraded: false, unsupported: true };
+    return { view: view2, degraded: false, standingsDegraded: false, unsupported: true };
+  }
   const topology = loadBracketTopology();
   const base = allFixtures().filter((m) => m.stage !== "GROUP" && m.stage !== "FRIENDLY");
   let matches = base;
   let liveDegraded = true;
   let source;
-  try {
-    const win = knockoutWindow();
-    const live = adapter.fetchWindow && win ? await adapter.fetchWindow(win.start, win.end) : [];
-    matches = mergeLive(base, live);
-    liveDegraded = false;
-    source = adapter.name;
-  } catch {
+  const win = knockoutWindow();
+  if (adapter.fetchWindow && win) {
+    try {
+      const live = await adapter.fetchWindow(win.start, win.end);
+      matches = mergeLive(base, live);
+      liveDegraded = false;
+      source = adapter.name;
+    } catch {
+    }
   }
   const standings = await getStandings(adapter);
-  if (!source && !standings.degraded && standings.source) {
+  if (!source && !standings.degraded && standings.source && standings.tables.length > 0) {
     source = standings.source;
   }
   const view = buildBracketView(
@@ -4517,18 +4686,18 @@ async function getBracket(adapter, opts = {}) {
 }
 var EXTRA_TIME_SLACK_MS = 60 * 6e4;
 async function marketFixtureForTeam(adapter, code, now = /* @__PURE__ */ new Date()) {
+  if (!bundleApplies()) return { match: void 0, degraded: false, unsupported: true };
   const nowMs = now.getTime();
   let fixtures = allFixtures();
   let overlayFailed = false;
-  try {
-    const win = knockoutWindow();
-    if (adapter.fetchWindow && win) {
-      fixtures = mergeLive(
-        fixtures,
-        await adapter.fetchWindow(win.start, win.end)
-      );
+  const win = knockoutWindow();
+  if (adapter.fetchWindow && win) {
+    try {
+      fixtures = mergeLive(fixtures, await adapter.fetchWindow(win.start, win.end));
+    } catch {
+      overlayFailed = true;
     }
-  } catch {
+  } else {
     overlayFailed = true;
   }
   const candidate = fixturesByTeam(code, fixtures).find((m) => {
@@ -4544,23 +4713,27 @@ async function marketFixtureForTeam(adapter, code, now = /* @__PURE__ */ new Dat
   return { match: next, degraded: overlayFailed };
 }
 async function getNextFixtureForTeam(adapter, code, now = /* @__PURE__ */ new Date()) {
+  if (!bundleApplies()) return { fixture: void 0, degraded: false, unsupported: true };
   const base = allFixtures();
   let matches = base;
   let degraded = true;
   let liveById;
-  try {
-    const win = knockoutWindow();
-    const live = adapter.fetchWindow && win ? await adapter.fetchWindow(win.start, win.end) : [];
-    matches = mergeLive(base, live);
-    degraded = false;
-    liveById = new Set(live.map((m) => m.id));
-  } catch {
+  const win = knockoutWindow();
+  if (adapter.fetchWindow && win) {
+    try {
+      const live = await adapter.fetchWindow(win.start, win.end);
+      matches = mergeLive(base, live);
+      degraded = false;
+      liveById = new Set(live.map((m) => m.id));
+    } catch {
+    }
   }
   const fixture = nextFixtureForTeam(code, { from: now, fixtures: matches });
   const source = fixture && liveById?.has(fixture.id) ? adapter.name : void 0;
   return { fixture, degraded, source };
 }
 async function getKnockoutFixtures(adapter, now = /* @__PURE__ */ new Date()) {
+  if (!bundleApplies()) return { fixtures: [], degraded: true, unsupported: true };
   const win = knockoutWindow();
   if (!adapter.fetchWindow || !win) return { fixtures: [], degraded: true };
   let live;
@@ -4569,13 +4742,13 @@ async function getKnockoutFixtures(adapter, now = /* @__PURE__ */ new Date()) {
   } catch {
     return { fixtures: [], degraded: true };
   }
-  const nowMs = now.getTime();
   const fixtures = live.filter(
-    (m) => m.stage !== "GROUP" && m.stage !== "FRIENDLY" && Date.parse(m.kickoff) >= nowMs && isResolvedNation(m.home) && isResolvedNation(m.away)
+    (m) => m.stage !== "GROUP" && m.stage !== "FRIENDLY" && isUpcoming(m, now) && isResolvedNation(m.home) && isResolvedNation(m.away)
   ).sort(byKickoff);
   return { fixtures, degraded: false };
 }
 async function getMatchById(adapter, id) {
+  if (!bundleApplies()) return { match: void 0, degraded: false, unsupported: true };
   const base = allFixtures().find((m) => m.id === id);
   if (!base) return { match: void 0, degraded: false };
   const day = base.kickoff.slice(0, 10);
@@ -5016,11 +5189,15 @@ var PolymarketProvider = class {
     if (!res.ok) {
       throw new Error(`Polymarket request failed: ${res.status} ${res.statusText}`);
     }
-    const length = Number(res.headers?.get?.("content-length"));
-    if (Number.isFinite(length) && length > MAX_RESPONSE_BYTES) {
-      throw new Error(`Polymarket response too large: ${length} bytes`);
+    let data;
+    try {
+      data = await readJsonBounded(res, MAX_RESPONSE_BYTES);
+    } catch (e) {
+      if (e instanceof ResponseTooLargeError) {
+        throw new Error(`Polymarket response too large: ${e.bytes} bytes`);
+      }
+      throw e;
     }
-    const data = await res.json();
     if (Array.isArray(data) && data.length > 1) {
       return ambiguous("slug returned more than one event");
     }
@@ -5100,7 +5277,7 @@ var PolymarketProvider = class {
     const outcomes = [];
     let asOf = canonicalTimestamp(event.updatedAt);
     let liquidity;
-    for (const [kind, market, teamCode2, label] of legs) {
+    for (const [kind, market, teamCode2, label2] of legs) {
       if (!market) continue;
       if (typeof market.closed !== "boolean" || typeof market.active !== "boolean") {
         return malformed("market active/closed is not a boolean");
@@ -5113,7 +5290,7 @@ var PolymarketProvider = class {
       }
       const yes = yesPrice(market);
       if (yes == null) return malformed("market is not a readable Yes/No binary");
-      outcomes.push({ kind, teamCode: teamCode2, label, probability: yes });
+      outcomes.push({ kind, teamCode: teamCode2, label: label2, probability: yes });
       const marketAsOf = canonicalTimestamp(market.updatedAt);
       if (!marketAsOf) {
         return malformed("market updatedAt missing or unparseable");
@@ -5427,10 +5604,13 @@ function formatShareTable(input, options = {}) {
       input.emptyNote ?? (input.degraded ? "Live standings unavailable." : "No standings available.")
     );
   } else {
-    for (const { group, rows } of input.tables) {
-      blocks.push(
-        [`Group ${group} \xB7 standings`, "", ...rows.map((r, i) => tableRow(r, i + 1))].join("\n")
-      );
+    for (const { group, rows, partial } of input.tables) {
+      const lines = [`Group ${group} \xB7 standings`, "", ...rows.map((r, i) => tableRow(r, r.rank ?? i + 1))];
+      if (partial) {
+        const n = partial.omitted;
+        lines.push("", `(partial table \u2014 ${n} row${n === 1 ? "" : "s"} unreadable; positions are the provider's ranks)`);
+      }
+      blocks.push(lines.join("\n"));
     }
     if (input.degraded) {
       blocks.push("(Live standings unavailable \u2014 group roster, not live results.)");
@@ -5614,11 +5794,56 @@ function resolveConfig(opts) {
 
 // src/cursorPayload.ts
 import { readFileSync } from "fs";
+var MAX_CURSOR_PAYLOAD_BYTES = 64 * 1024;
+var MAX_CURSOR_LABEL_COLUMNS = 40;
+function label(v) {
+  const s = humanLabel(v, MAX_CURSOR_LABEL_COLUMNS);
+  return s === "" ? void 0 : s;
+}
+function finite(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+function record(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v) ? v : void 0;
+}
+function validateCursorPayload(parsed) {
+  const p = record(parsed);
+  if (!p) return void 0;
+  const out2 = {};
+  const model = record(p.model);
+  if (model) {
+    const display_name = label(model.display_name);
+    const param_summary = label(model.param_summary);
+    if (display_name || param_summary) {
+      out2.model = {
+        ...display_name ? { display_name } : {},
+        ...param_summary ? { param_summary } : {}
+      };
+    }
+  }
+  const cw = record(p.context_window);
+  if (cw) {
+    if (cw.used_percentage === null) out2.context_window = { used_percentage: null };
+    else {
+      const pct2 = finite(cw.used_percentage);
+      if (pct2 !== void 0) out2.context_window = { used_percentage: pct2 };
+    }
+  }
+  const wt = record(p.worktree);
+  const name = wt ? label(wt.name) : void 0;
+  if (name) out2.worktree = { name };
+  const vim = record(p.vim);
+  const mode = vim ? label(vim.mode) : void 0;
+  if (mode) out2.vim = { mode };
+  const width = finite(p.render_width_chars);
+  if (width !== void 0 && width > 0) out2.render_width_chars = Math.floor(width);
+  return out2;
+}
 function parseCursorPayload(raw) {
   try {
     const trimmed = raw.trim();
     if (!trimmed) return void 0;
-    return JSON.parse(trimmed);
+    return validateCursorPayload(JSON.parse(trimmed));
   } catch {
     return void 0;
   }
@@ -5631,19 +5856,27 @@ function readCursorPayload() {
     return void 0;
   }
 }
-function readCursorPayloadBounded(timeoutMs = 100, stdin = process.stdin) {
+function readCursorPayloadBounded(timeoutMs = 100, stdin = process.stdin, maxBytes = MAX_CURSOR_PAYLOAD_BYTES) {
   if (stdin.isTTY) return Promise.resolve(void 0);
   return new Promise((resolve) => {
     const chunks = [];
+    let total = 0;
+    let overflow = false;
     const done = () => {
       clearTimeout(timer);
       stdin.off("data", onData);
       stdin.off("end", done);
       stdin.off("error", done);
       stdin.pause();
-      resolve(parseCursorPayload(Buffer.concat(chunks).toString("utf8")));
+      resolve(overflow ? void 0 : parseCursorPayload(Buffer.concat(chunks).toString("utf8")));
     };
     const onData = (c) => {
+      total += c.length;
+      if (total > maxBytes) {
+        overflow = true;
+        done();
+        return;
+      }
       chunks.push(c);
     };
     const timer = setTimeout(done, timeoutMs);
@@ -5666,18 +5899,19 @@ function cursorMetaEnabled(payload) {
 }
 function renderCursorMetaLine(payload) {
   const parts = [];
-  const model = payload.model?.display_name;
+  const model = label(payload.model?.display_name);
   if (model) {
-    let label = model;
-    if (payload.model?.param_summary) label += ` ${payload.model.param_summary}`;
-    parts.push(label);
+    const summary = label(payload.model?.param_summary);
+    parts.push(summary ? `${model} ${summary}` : model);
   }
   const pct2 = payload.context_window?.used_percentage;
   if (typeof pct2 === "number" && Number.isFinite(pct2)) {
     parts.push(`ctx ${Math.floor(pct2)}%`);
   }
-  if (payload.worktree?.name) parts.push(`wt ${payload.worktree.name}`);
-  if (payload.vim?.mode) parts.push(payload.vim.mode);
+  const wt = label(payload.worktree?.name);
+  if (wt) parts.push(`wt ${wt}`);
+  const vim = label(payload.vim?.mode);
+  if (vim) parts.push(vim);
   if (parts.length === 0) return void 0;
   return `\x1B[90m${parts.join("  ")}\x1B[0m`;
 }
@@ -5711,6 +5945,8 @@ var EN2 = {
   "table.degraded": "Live standings unavailable \u2014 showing the group roster.",
   "table.unavailable": "Live standings unavailable.",
   "table.empty": "No standings available.",
+  "table.partial": "Partial table \u2014 {n} rows could not be read.",
+  "competition.unsupported": "Not available for this competition yet.",
   "match.none": "No match found with id {id}.",
   "status.live": "LIVE",
   "status.ht": "HT",
@@ -5752,6 +5988,8 @@ var ES2 = {
   "table.degraded": "Tabla en vivo no disponible \u2014 mostrando la lista del grupo.",
   "table.unavailable": "Tabla en vivo no disponible.",
   "table.empty": "No hay clasificaci\xF3n disponible.",
+  "table.partial": "Tabla parcial \u2014 no se pudieron leer {n} filas.",
+  "competition.unsupported": "A\xFAn no disponible para esta competici\xF3n.",
   "match.none": "No se encontr\xF3 partido con id {id}.",
   "status.live": "EN VIVO",
   "status.ht": "DESC",
@@ -5793,6 +6031,8 @@ var PT2 = {
   "table.degraded": "Classifica\xE7\xE3o ao vivo indispon\xEDvel \u2014 mostrando os times do grupo.",
   "table.unavailable": "Classifica\xE7\xE3o ao vivo indispon\xEDvel.",
   "table.empty": "Classifica\xE7\xE3o indispon\xEDvel.",
+  "table.partial": "Tabela parcial \u2014 {n} linhas n\xE3o puderam ser lidas.",
+  "competition.unsupported": "Ainda n\xE3o dispon\xEDvel para esta competi\xE7\xE3o.",
   "match.none": "Nenhum jogo encontrado com id {id}.",
   "status.live": "AO VIVO",
   "status.ht": "INT",
@@ -5834,6 +6074,8 @@ var FR2 = {
   "table.degraded": "Classement en direct indisponible \u2014 affichage de la composition du groupe.",
   "table.unavailable": "Classement en direct indisponible.",
   "table.empty": "Aucun classement disponible.",
+  "table.partial": "Classement partiel \u2014 {n} lignes n'ont pas pu \xEAtre lues.",
+  "competition.unsupported": "Pas encore disponible pour cette comp\xE9tition.",
   "match.none": "Aucun match trouv\xE9 avec id {id}.",
   "status.live": "DIRECT",
   "status.ht": "MT",
@@ -5943,7 +6185,7 @@ function dataSource(source, lang, c) {
 }
 
 // src/marketCache.ts
-import { readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import { readFileSync as readFileSync3, statSync as statSync3 } from "fs";
 import { join as join3 } from "path";
 
 // src/cache.ts
@@ -5952,30 +6194,68 @@ import {
   mkdirSync as mkdirSync2,
   openSync as openSync2,
   readFileSync as readFileSync2,
-  rmSync,
-  statSync,
+  rmSync as rmSync2,
+  statSync as statSync2,
   writeSync as writeSync2
 } from "fs";
 import { join as join2 } from "path";
+import { randomBytes as randomBytes2 } from "crypto";
 
 // src/paths.ts
-import { closeSync, mkdirSync, openSync, renameSync, writeSync } from "fs";
+import { randomBytes } from "crypto";
+import {
+  closeSync,
+  fchmodSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeSync
+} from "fs";
 import { homedir } from "os";
 import { dirname, join } from "path";
 function cacheDir() {
   const base = process.env.XDG_CACHE_HOME || join(homedir(), ".cache");
   return join(base, "claudinho");
 }
-function writeFileAtomic(path, data) {
+function writeFileAtomic(path, data, opts = {}) {
   mkdirSync(dirname(path), { recursive: true });
-  const tmp = `${path}.${process.pid}.tmp`;
-  const fd = openSync(tmp, "w");
+  let target = path;
+  let existingMode;
+  let entry;
+  try {
+    entry = lstatSync(path);
+  } catch {
+    entry = void 0;
+  }
+  if (entry?.isSymbolicLink()) {
+    if (opts.followSymlinks) {
+      target = realpathSync(path);
+      existingMode = statSync(target).mode & 511;
+    }
+  } else if (entry) {
+    existingMode = entry.mode & 511;
+  }
+  const tmp = `${target}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+  const fd = openSync(tmp, "wx", existingMode ?? opts.mode ?? 438);
   try {
+    if (existingMode !== void 0) fchmodSync(fd, existingMode);
     writeSync(fd, data);
-  } finally {
+  } catch (e) {
     closeSync(fd);
+    rmSync(tmp, { force: true });
+    throw e;
+  }
+  closeSync(fd);
+  try {
+    renameSync(tmp, target);
+  } catch (e) {
+    rmSync(tmp, { force: true });
+    throw e;
   }
-  renameSync(tmp, path);
 }
 
 // src/cache.ts
@@ -6029,7 +6309,7 @@ function isCacheState(value) {
 function readState(source = "espn", competition = DEFAULT_COMPETITION) {
   try {
     const path = cachePath(source, competition);
-    const info = statSync(path);
+    const info = statSync2(path);
     if (!info.isFile() || info.size > MAX_STATE_BYTES) return void 0;
     const bytes = readFileSync2(path);
     if (bytes.byteLength > MAX_STATE_BYTES) return void 0;
@@ -6083,7 +6363,7 @@ function lockAgeMs(now = Date.now()) {
     return Infinity;
   }
   try {
-    return stampAgeMs(new Date(statSync(lp).mtimeMs).toISOString(), now);
+    return stampAgeMs(new Date(statSync2(lp).mtimeMs).toISOString(), now);
   } catch {
     return Infinity;
   }
@@ -6091,44 +6371,62 @@ function lockAgeMs(now = Date.now()) {
 function isLockFresh(now = Date.now()) {
   return lockAgeMs(now) < LOCK_STALE_MS;
 }
-function acquireLock(now = Date.now()) {
-  mkdirSync2(cacheDir(), { recursive: true });
-  const lp = lockPath();
+var heldToken;
+function readLockToken() {
+  try {
+    return readFileSync2(lockPath(), "utf8").trim();
+  } catch {
+    return void 0;
+  }
+}
+function writeExclusive(lp, token) {
   try {
     const fd = openSync2(lp, "wx");
     try {
-      writeSync2(fd, `${process.pid} ${now}`);
+      writeSync2(fd, token);
     } finally {
       closeSync2(fd);
     }
     return true;
   } catch {
-    if (lockAgeMs(now) > LOCK_STALE_MS) {
-      try {
-        rmSync(lp, { force: true });
-      } catch {
-        return false;
-      }
-      try {
-        const fd = openSync2(lp, "wx");
-        try {
-          writeSync2(fd, `${process.pid} ${now}`);
-        } finally {
-          closeSync2(fd);
-        }
-        return true;
-      } catch {
-        return false;
-      }
-    }
     return false;
   }
 }
-function releaseLock() {
+function claimLock(now = Date.now()) {
+  mkdirSync2(cacheDir(), { recursive: true });
+  const lp = lockPath();
+  const token = `${process.pid} ${now} ${randomBytes2(6).toString("hex")}`;
+  if (writeExclusive(lp, token)) return token;
+  if (lockAgeMs(now) > LOCK_STALE_MS) {
+    try {
+      rmSync2(lp, { force: true });
+    } catch {
+      return void 0;
+    }
+    return writeExclusive(lp, token) ? token : void 0;
+  }
+  return void 0;
+}
+function holdsLock(token = heldToken) {
+  return token !== void 0 && readLockToken() === token;
+}
+function acquireLock(now = Date.now()) {
+  const token = claimLock(now);
+  if (token) heldToken = token;
+  return token !== void 0;
+}
+function releaseLock(token = heldToken) {
+  if (!holdsLock(token)) return;
   try {
-    rmSync(lockPath(), { force: true });
+    rmSync2(lockPath(), { force: true });
   } catch {
   }
+  if (token === heldToken) heldToken = void 0;
+}
+function publishState(state, token = heldToken) {
+  if (!holdsLock(token)) return false;
+  writeState(state);
+  return true;
 }
 
 // src/marketCache.ts
@@ -6142,7 +6440,7 @@ function cachePath2() {
 function readFile() {
   try {
     const path = cachePath2();
-    const info = statSync2(path);
+    const info = statSync3(path);
     if (!info.isFile() || info.size > MAX_MARKET_CACHE_BYTES) return void 0;
     const bytes = readFileSync3(path);
     if (bytes.byteLength > MAX_MARKET_CACHE_BYTES) return void 0;
@@ -6316,7 +6614,7 @@ function isMatchShaped(m) {
   return !!x && typeof x === "object" && typeof x.id === "string" && typeof x.kickoff === "string" && !!x.home?.code && !!x.away?.code;
 }
 function nextOverall(now, fixtures = allFixtures()) {
-  return [...fixtures].sort(byKickoff).find((m) => Date.parse(m.kickoff) >= now && isResolvedFixture(m));
+  return [...fixtures].sort(byKickoff).find((m) => isUpcoming(m, new Date(now)) && isResolvedFixture(m));
 }
 function teamTok(t2, flags) {
   return flags ? t2.flag : t2.code;
@@ -6420,7 +6718,8 @@ function renderPromptLine(state, opts = {}) {
   const live = liveList.items;
   const cachedFixtureList = sealFixtures(state?.fixtures);
   const cachedFixtures = [...cachedFixtureList.items];
-  const schedule = cachedFixtures.length ? mergeLive(allFixtures(), cachedFixtures) : void 0;
+  const bundle = defaultCompetition ? allFixtures() : [];
+  const schedule = cachedFixtures.length ? mergeLive(bundle, cachedFixtures) : defaultCompetition ? void 0 : [];
   if (team) {
     const mine = live.find((m) => m.home?.code === team || m.away?.code === team);
     if (mine) return `\u26BD ${matchSegment(mine, compact, flags)}`;
@@ -6514,7 +6813,7 @@ function fixturesStale(state, now) {
   return fixturesAttemptAgeMs(state, now) > FIXTURES_EMPTY_TTL_MS;
 }
 function nextStaticUpcoming(nowMs) {
-  return [...allFixtures()].sort(byKickoff).find((m) => Date.parse(m.kickoff) >= nowMs);
+  return [...allFixtures()].sort(byKickoff).find((m) => isUpcoming(m, new Date(nowMs)));
 }
 function inKnockoutPhase(nowMs) {
   if (resolveCompetition() !== DEFAULT_COMPETITION) return false;
@@ -6525,8 +6824,8 @@ function liveWindowActive(nowMs) {
   if (resolveCompetition() !== DEFAULT_COMPETITION) return true;
   return inLiveWindow(nowMs);
 }
-function liveAdapter(source) {
-  return makeAdapter(source, { enrichGroups: false });
+function liveAdapter(source, now) {
+  return makeAdapter(source, { enrichGroups: false, now });
 }
 async function runRefresh(opts = {}) {
   const now = opts.now ?? /* @__PURE__ */ new Date();
@@ -6572,7 +6871,8 @@ async function runRefresh(opts = {}) {
     }
     return;
   }
-  if (!acquireLock()) return;
+  const token = claimLock();
+  if (!token) return;
   try {
     let live = base?.live ?? [];
     let degraded = base?.degraded ?? false;
@@ -6581,7 +6881,9 @@ async function runRefresh(opts = {}) {
     let fixturesUpdatedAt = base?.fixturesUpdatedAt;
     let fixturesAttemptedAt = base?.fixturesAttemptedAt;
     let backoffUntil = base?.backoffUntil;
-    const adapter = liveAdapter(source);
+    const realStart = Date.now();
+    const clock = () => nowMs + (Date.now() - realStart);
+    const adapter = liveAdapter(source, clock);
     if (needLive) {
       try {
         const r = await getLiveMatches(adapter, now);
@@ -6603,26 +6905,32 @@ async function runRefresh(opts = {}) {
       } catch {
       }
     }
-    if (adapter.lastError?.throttled) {
-      backoffUntil = new Date(
-        nowMs + BACKOFF_MS + Math.floor(Math.random() * BACKOFF_JITTER_MS)
-      ).toISOString();
+    const armed = adapter.cooldownUntil;
+    if (armed !== void 0 && armed > clock()) {
+      const jitter = opts.jitterMs ?? Math.floor(Math.random() * BACKOFF_JITTER_MS);
+      backoffUntil = new Date(Math.max(armed, nowMs + BACKOFF_MS) + jitter).toISOString();
     } else if (backoffUntil && Date.parse(backoffUntil) <= nowMs) {
       backoffUntil = void 0;
     }
-    writeState({
-      updatedAt,
-      live,
-      degraded,
-      source,
-      competition,
-      ...fixtures ? { fixtures } : {},
-      ...fixturesUpdatedAt ? { fixturesUpdatedAt } : {},
-      ...fixturesAttemptedAt ? { fixturesAttemptedAt } : {},
-      ...backoffUntil ? { backoffUntil } : {}
-    });
+    const published = publishState(
+      {
+        updatedAt,
+        live,
+        degraded,
+        source,
+        competition,
+        ...fixtures ? { fixtures } : {},
+        ...fixturesUpdatedAt ? { fixturesUpdatedAt } : {},
+        ...fixturesAttemptedAt ? { fixturesAttemptedAt } : {},
+        ...backoffUntil ? { backoffUntil } : {}
+      },
+      token
+    );
+    if (!published && process.env.CLAUDINHO_DEBUG) {
+      process.stderr.write("claudinho: refresh lease lost to a successor; snapshot not published\n");
+    }
   } finally {
-    releaseLock();
+    releaseLock(token);
   }
 }
 function shouldRefresh(now = Date.now(), state = readState("espn", resolveCompetition())) {
@@ -6654,7 +6962,7 @@ function spawnRefresh(source) {
 }
 
 // src/install.ts
-import { copyFileSync, existsSync, readFileSync as readFileSync5 } from "fs";
+import { copyFileSync, existsSync, lstatSync as lstatSync2, readFileSync as readFileSync5 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join5 } from "path";
 function claudeSettingsPath() {
@@ -6689,21 +6997,41 @@ function defaultStatusLineConfig(target, command) {
 function restartMessage(target) {
   return target === "cursor" ? "Restart Cursor CLI (or start a new session) to see it." : "Restart Claude Code to see it.";
 }
+function isSettingsObject(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function manual(path, snippet, why) {
+  return { action: "manual", path, message: `${why} ${path}. Add this manually:
+${snippet}` };
+}
 function readSettings(path, snippet) {
-  if (!existsSync(path)) return {};
+  let entry;
   try {
-    return JSON.parse(readFileSync5(path, "utf8"));
+    entry = lstatSync2(path);
   } catch {
-    return {
-      action: "manual",
-      path,
-      message: `Could not parse ${path}. Add this manually:
-${snippet}`
-    };
+    return {};
+  }
+  if (entry.isSymbolicLink() && !existsSync(path)) {
+    return manual(path, snippet, "Settings path is a symlink to a missing file:");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync5(path, "utf8"));
+  } catch {
+    return manual(path, snippet, "Could not parse");
   }
+  if (!isSettingsObject(parsed)) return manual(path, snippet, "Not a JSON settings object:");
+  return parsed;
 }
 function isInitResult(v) {
-  return "action" in v && typeof v.action === "string";
+  return typeof v.action === "string" && typeof v.path === "string" && typeof v.message === "string";
+}
+var SETTINGS_FILE_MODE = 384;
+var SETTINGS_WRITE = { mode: SETTINGS_FILE_MODE, followSymlinks: true };
+function validHookMatchers(slot) {
+  return slot.every(
+    (m) => isSettingsObject(m) && (m.hooks === void 0 || Array.isArray(m.hooks) && m.hooks.every(isSettingsObject))
+  );
 }
 function initStatuslineFor(target, opts = {}) {
   const path = configPathFor(target, opts.path);
@@ -6718,12 +7046,12 @@ function initStatuslineFor(target, opts = {}) {
   const settings = parsed;
   const existing = settings.statusLine;
   if (isSameCommand(existing?.command, command)) {
-    const label = target === "cursor" ? "Cursor CLI statusline" : "Statusline";
-    return { action: "already", path, message: `${label} already configured (${path}).` };
+    const label2 = target === "cursor" ? "Cursor CLI statusline" : "Statusline";
+    return { action: "already", path, message: `${label2} already configured (${path}).` };
   }
   backupOnce(path);
   settings.statusLine = sl;
-  writeFileAtomic(path, JSON.stringify(settings, null, 2) + "\n");
+  writeFileAtomic(path, JSON.stringify(settings, null, 2) + "\n", SETTINGS_WRITE);
   const surface = target === "cursor" ? "Cursor CLI statusline" : "Statusline";
   return {
     action: "written",
@@ -6757,6 +7085,13 @@ function initHook(opts = {}) {
   const parsed = readSettings(path, snippet);
   if (isInitResult(parsed)) return parsed;
   const settings = parsed;
+  if (settings.hooks !== void 0 && !isSettingsObject(settings.hooks)) {
+    return manual(path, snippet, 'Unexpected "hooks" shape in');
+  }
+  const eventSlot = settings.hooks?.[CLAUDE_HOOK_EVENT];
+  if (eventSlot !== void 0 && (!Array.isArray(eventSlot) || !validHookMatchers(eventSlot))) {
+    return manual(path, snippet, `Unexpected "hooks.${CLAUDE_HOOK_EVENT}" shape in`);
+  }
   if (claudeHookCommands(settings).some((c) => isSameCommand(c, command))) {
     return {
       action: "already",
@@ -6769,7 +7104,7 @@ function initHook(opts = {}) {
   const hooks = settings.hooks;
   hooks[CLAUDE_HOOK_EVENT] ??= [];
   hooks[CLAUDE_HOOK_EVENT].push({ hooks: [{ type: "command", command }] });
-  writeFileAtomic(path, JSON.stringify(settings, null, 2) + "\n");
+  writeFileAtomic(path, JSON.stringify(settings, null, 2) + "\n", SETTINGS_WRITE);
   return {
     action: "written",
     path,
@@ -6777,9 +7112,61 @@ function initHook(opts = {}) {
   };
 }
 
+// src/providerBackoff.ts
+function persistBackoff(source, competition, until, nowMs) {
+  const token = claimLock(nowMs);
+  if (!token) return false;
+  try {
+    const prior = readState(source, competition);
+    const base = prior && prior.source === source && prior.competition === competition ? prior : {
+      updatedAt: new Date(nowMs).toISOString(),
+      live: [],
+      degraded: true,
+      // the provider refused us — never claim otherwise
+      source,
+      competition
+    };
+    return publishState({ ...base, backoffUntil: new Date(until).toISOString() }, token);
+  } finally {
+    releaseLock(token);
+  }
+}
+function withPersistedBackoff(adapter, source, now = /* @__PURE__ */ new Date()) {
+  const competition = resolveCompetition();
+  const nowMs = now.getTime();
+  const state = readCurrentState(source, competition);
+  const accepted = state?.backoffUntil && backoffActive(state, nowMs) ? Date.parse(state.backoffUntil) : void 0;
+  if (accepted !== void 0) adapter.armCooldown?.(accepted);
+  let persisted = accepted;
+  const persistIfNewer = (until) => {
+    if (!(until > nowMs) || persisted !== void 0 && until <= persisted) return;
+    if (persistBackoff(source, competition, until, nowMs)) persisted = until;
+  };
+  adapter.onCooldown?.(persistIfNewer);
+  const afterCall = () => {
+    const until = adapter.cooldownUntil;
+    if (until !== void 0) persistIfNewer(until);
+  };
+  return new Proxy(adapter, {
+    get(target, prop) {
+      const value = Reflect.get(target, prop, target);
+      if (typeof value === "function" && typeof prop === "string" && prop.startsWith("fetch")) {
+        return async (...args) => {
+          try {
+            return await value.apply(target, args);
+          } finally {
+            afterCall();
+          }
+        };
+      }
+      return value;
+    }
+  });
+}
+
 // src/commands.ts
-function adapterFor({ cfg, adapter }) {
-  return adapter ?? makeAdapter(cfg.source);
+function adapterFor({ cfg, adapter, now }) {
+  return withPersistedBackoff(adapter ?? makeAdapter(cfg.source), cfg.source, now);
 }
 var DEFAULT_ON_MARKET_OPTS = { deadlineMs: 2e3, timeoutMs: 2500 };
 var MARKETS_CMD_OPTS = { deadlineMs: 12e3, timeoutMs: 6e3 };
@@ -6958,20 +7345,30 @@ async function cmdNext(team, ctx) {
   const { cfg, t: t2, now } = ctx;
   precheck(cfg, t2);
   const code = resolveTeamArg(team, "Usage: claudinho next <team> (or set CLAUDINHO_TEAM)", t2);
-  const { fixture, degraded, source } = await getNextFixtureForTeam(
+  const { fixture, degraded, source, unsupported } = await getNextFixtureForTeam(
     adapterFor(ctx),
     code,
     now ?? /* @__PURE__ */ new Date()
   );
   if (cfg.json) {
-    emitJson({ team: code, fixture: fixture ?? null, degraded, source: source ?? null });
+    emitJson({
+      team: code,
+      fixture: fixture ?? null,
+      degraded,
+      source: source ?? null,
+      ...unsupported ? { unsupported: true } : {}
+    });
     return;
   }
   const c = painterFor(cfg);
   const flags = flagsEnabled();
   out();
   if (!fixture) {
-    out(c.dim("  " + (degraded ? t2("live.degraded") : t2("next.none", { team: code }))));
+    out(
+      c.dim(
+        "  " + (unsupported ? t2("competition.unsupported") : degraded ? t2("live.degraded") : t2("next.none", { team: code }))
+      )
+    );
     out();
     out(disclaimer(t2, c));
     endScoreCommand(ctx);
@@ -7003,7 +7400,7 @@ function cmdTeam(query, ctx) {
   }
   const c = painterFor(cfg);
   const flags = flagsEnabled();
-  const label = (tm) => {
+  const label2 = (tm) => {
     const flag2 = flags ? `${tm.flag} ` : "";
     const grp = tm.group ? ` \xB7 ${t2("team.group", { group: tm.group })}` : "";
     return `  ${flag2}${c.bold(tm.name)}  ${c.dim(tm.code + grp)}`;
@@ -7012,10 +7409,10 @@ function cmdTeam(query, ctx) {
   if (!q) {
     out("  " + c.dim(t2("team.usage")));
   } else if (team) {
-    out(label(team));
+    out(label2(team));
   } else if (matches.length > 0) {
     out("  " + c.dim(t2("team.ambiguous", { query: q })));
-    for (const m of matches) out(label(m));
+    for (const m of matches) out(label2(m));
   } else {
     out("  " + c.dim(t2("team.none", { query: q })));
   }
@@ -7028,7 +7425,11 @@ async function cmdTable(group, ctx) {
   precheck(cfg, t2);
   const { tables, degraded, source } = await getStandings(adapterFor(ctx), group);
   if (cfg.json) {
-    const json = tables.map((tb) => ({ group: tb.group, standings: tb.rows }));
+    const json = tables.map((tb) => ({
+      group: tb.group,
+      standings: tb.rows,
+      ...tb.partial ? { partial: tb.partial } : {}
+    }));
     emitJson({
       degraded,
       source: source ?? null,
@@ -7051,7 +7452,7 @@ async function cmdTable(group, ctx) {
     out(disclaimer(t2, c));
     return;
   }
-  for (const { group: g, rows } of tables) {
+  for (const { group: g, rows, partial } of tables) {
     out();
     out(header(t2("table.title", { group: g }), c));
     const table = new Table({
@@ -7079,6 +7480,7 @@ async function cmdTable(group, ctx) {
       ]);
     }
     out(table.toString());
+    if (partial) out(c.dim("  " + t2("table.partial", { n: String(partial.omitted) })));
   }
   out();
   if (degraded) out(c.dim("  " + t2("table.degraded")));
@@ -7095,10 +7497,22 @@ async function cmdBracket(stage, opts, ctx) {
   if (filter && !BRACKET_STAGES.has(filter)) {
     throw new InputError(t(cfg.lang, "bracket.invalidStage"));
   }
-  const { view, degraded, standingsDegraded, source } = await getBracket(
+  const { view, degraded, standingsDegraded, source, unsupported } = await getBracket(
     adapterFor(ctx),
     filter ? { stage: filter, lang: cfg.lang } : { lang: cfg.lang }
   );
+  if (unsupported) {
+    if (cfg.json) {
+      emitJson({ degraded, standingsDegraded, source: null, view, unsupported: true });
+      return;
+    }
+    const c2 = painterFor(cfg);
+    out();
+    out(c2.dim(`  ${t(cfg.lang, "competition.unsupported")}`));
+    out();
+    out(disclaimer(t2, c2));
+    return;
+  }
   if (cfg.json) {
     emitJson({
       degraded,
@@ -7263,7 +7677,7 @@ function cmdInitClaude(opts, { cfg }) {
 async function cmdMatch(id, ctx) {
   const { cfg, t: t2 } = ctx;
   precheck(cfg, t2);
-  const { match, degraded, source: liveSource } = await getMatchById(adapterFor(ctx), id);
+  const { match, degraded, source: liveSource, unsupported } = await getMatchById(adapterFor(ctx), id);
   const market = match ? await reliableMarketSignalFor(ctx, match) : { signal: void 0, complete: true };
   if (cfg.json) {
     emitJson({
@@ -7271,14 +7685,15 @@ async function cmdMatch(id, ctx) {
       match: match ?? null,
       source: liveSource ?? null,
       marketComplete: market.complete,
-      marketSignal: market.signal ?? null
+      marketSignal: market.signal ?? null,
+      ...unsupported ? { unsupported: true } : {}
     });
     return;
   }
   const c = painterFor(cfg);
   out();
   if (!match) {
-    out(c.dim("  " + t2("match.none", { id })));
+    out(c.dim("  " + (unsupported ? t2("competition.unsupported") : t2("match.none", { id }))));
     out();
     out(disclaimer(t2, c));
     return;
@@ -7337,7 +7752,7 @@ async function cmdMarkets(target, team, ctx) {
     precheck(cfg, t2);
     const code = resolveTeamArg(team, "Usage: claudinho markets next <team> (or set CLAUDINHO_TEAM)", t2);
     const now2 = ctx.now ?? /* @__PURE__ */ new Date();
-    const { match: fixture, degraded } = await marketFixtureForTeam(adapterFor(ctx), code, now2);
+    const { match: fixture, degraded, unsupported } = await marketFixtureForTeam(adapterFor(ctx), code, now2);
     const market = fixture && marketRelevant(fixture, now2) ? await marketSignalsFor(ctx, [fixture], MARKETS_CMD_OPTS) : { 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;
@@ -7348,14 +7763,21 @@ async function cmdMarkets(target, team, ctx) {
         degraded,
         informationalOnly: true,
         complete: market.complete,
-        signal: shown ?? null
+        signal: shown ?? null,
+        // Review P2 on #129: a JSON consumer must tell "not available for this
+        // competition" from a successful empty result; the text branch already did.
+        ...unsupported ? { unsupported: true } : {}
       });
       return;
     }
     const c2 = painterFor(cfg);
     out();
     if (!fixture) {
-      out(c2.dim("  " + (degraded ? t2("live.degraded") : t2("next.none", { team: code }))));
+      out(
+        c2.dim(
+          "  " + (unsupported ? t2("competition.unsupported") : degraded ? t2("live.degraded") : t2("next.none", { team: code }))
+        )
+      );
     } else {
       out(header(marketHeaderLine(fixture, cfg), c2));
       out();
@@ -7372,7 +7794,7 @@ async function cmdMarkets(target, team, ctx) {
   if (target && target !== "today" && !isValidDate(target)) {
     precheck(cfg, t2);
     const now2 = ctx.now ?? /* @__PURE__ */ new Date();
-    const { match } = await getMatchById(adapterFor(ctx), target);
+    const { match, unsupported } = await getMatchById(adapterFor(ctx), target);
     const market = match && marketRelevant(match, now2) ? await marketSignalsFor(ctx, [match], MARKETS_CMD_OPTS) : { 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;
@@ -7381,14 +7803,15 @@ async function cmdMarkets(target, team, ctx) {
         matchId: target,
         informationalOnly: true,
         complete: market.complete,
-        signal: shown ?? null
+        signal: shown ?? null,
+        ...unsupported ? { unsupported: true } : {}
       });
       return;
     }
     const c2 = painterFor(cfg);
     out();
     if (!match) {
-      out(c2.dim("  " + t2("match.none", { id: target })));
+      out(c2.dim("  " + (unsupported ? t2("competition.unsupported") : t2("match.none", { id: target }))));
     } else {
       out(header(marketHeaderLine(match, cfg), c2));
       out();
@@ -7469,7 +7892,9 @@ function emitShare(ctx, e, copy) {
       snippet,
       matches: e.input.matches,
       marketComplete: e.input.marketComplete ?? true,
-      marketSignals: Object.fromEntries(e.input.marketSignals ?? /* @__PURE__ */ new Map())
+      marketSignals: Object.fromEntries(e.input.marketSignals ?? /* @__PURE__ */ new Map()),
+      // The structured card keeps the verdict the snippet's note carries.
+      ...e.unsupported ? { unsupported: true } : {}
     });
   } else {
     out(snippet);
@@ -7501,7 +7926,12 @@ function emitShareTable(ctx, e, copy) {
       degraded: e.degraded,
       informationalOnly: true,
       snippet,
-      tables: e.tables.map((tb) => ({ group: tb.group, standings: tb.rows }))
+      // The structured card keeps the verdict the snippet warns about (A01).
+      tables: e.tables.map((tb) => ({
+        group: tb.group,
+        standings: tb.rows,
+        ...tb.partial ? { partial: tb.partial } : {}
+      }))
     });
   } else {
     out(snippet);
@@ -7532,7 +7962,8 @@ function emitShareBracket(ctx, e, copy) {
       degraded: e.degraded,
       informationalOnly: true,
       snippet,
-      view: e.view
+      view: e.view,
+      ...e.unsupported ? { unsupported: true } : {}
     });
   } else {
     out(snippet);
@@ -7606,7 +8037,7 @@ async function cmdShare(target, team, opts, ctx) {
     if (stageFilter && !BRACKET_STAGES.has(stageFilter)) {
       throw new InputError(t(cfg.lang, "bracket.invalidStage"));
     }
-    const { view, degraded: degraded2, source: source2 } = await getBracket(
+    const { view, degraded: degraded2, source: source2, unsupported } = await getBracket(
       adapterFor(ctx),
       stageFilter ? { stage: stageFilter, lang: cfg.lang } : { lang: cfg.lang }
     );
@@ -7618,7 +8049,8 @@ async function cmdShare(target, team, opts, ctx) {
         source: degraded2 ? void 0 : source2,
         degraded: degraded2,
         installLine: stageFilter ? `npx @claudinho/cli bracket ${stageFilter}` : "npx @claudinho/cli bracket",
-        emptyNote: t(cfg.lang, "bracket.empty"),
+        emptyNote: unsupported ? t(cfg.lang, "competition.unsupported") : t(cfg.lang, "bracket.empty"),
+        unsupported,
         options: {
           includeHashtag: baseOptions.includeHashtag,
           includeInstallLine: baseOptions.includeInstallLine,
@@ -7634,7 +8066,7 @@ async function cmdShare(target, team, opts, ctx) {
   if (target === "next") {
     precheck(cfg, t2);
     const code = resolveTeamArg(team, "Usage: claudinho share next <team> (or set CLAUDINHO_TEAM)", t2);
-    const { fixture, degraded: degraded2, source: source2 } = await getNextFixtureForTeam(
+    const { fixture, degraded: degraded2, source: source2, unsupported } = await getNextFixtureForTeam(
       adapterFor(ctx),
       code,
       ctx.now ?? /* @__PURE__ */ new Date()
@@ -7658,12 +8090,13 @@ async function cmdShare(target, team, opts, ctx) {
           source: source2,
           degraded: degraded2,
           // Fail-closed: an outage must never paste as "no fixture" (eliminated).
-          emptyNote: degraded2 ? `Couldn't reach the data provider \u2014 no upcoming fixture confirmed for ${code}.` : `No upcoming fixture found for ${code}.`,
+          emptyNote: unsupported ? t(cfg.lang, "competition.unsupported") : degraded2 ? `Couldn't reach the data provider \u2014 no upcoming fixture confirmed for ${code}.` : `No upcoming fixture found for ${code}.`,
           installLine: `npx @claudinho/cli next ${code}`,
           tz: cfg.tz,
           locale: cfg.lang
         },
-        options: baseOptions
+        options: baseOptions,
+        unsupported
       },
       copy
     );
@@ -7671,7 +8104,7 @@ async function cmdShare(target, team, opts, ctx) {
   }
   if (target && target !== "today" && !isValidDate(target)) {
     precheck(cfg, t2);
-    const { match, degraded: degraded2, source: source2 } = await getMatchById(adapterFor(ctx), target);
+    const { match, degraded: degraded2, source: source2, unsupported } = await getMatchById(adapterFor(ctx), target);
     const matches = match ? [match] : [];
     const market2 = await reliableShareSignals(ctx, matches);
     emitShare(
@@ -7686,12 +8119,13 @@ async function cmdShare(target, team, opts, ctx) {
           marketComplete: market2.complete,
           source: source2,
           degraded: degraded2,
-          emptyNote: `No match found with id ${target}.`,
+          emptyNote: unsupported ? t(cfg.lang, "competition.unsupported") : `No match found with id ${target}.`,
           installLine: `npx @claudinho/cli match ${target}`,
           tz: cfg.tz,
           locale: cfg.lang
         },
-        options: baseOptions
+        options: baseOptions,
+        unsupported
       },
       copy
     );
@@ -7843,7 +8277,7 @@ function handlePipeError(stream) {
 }
 handlePipeError(process.stdout);
 handlePipeError(process.stderr);
-var VERSION = "0.10.0";
+var VERSION = "0.10.1";
 var DISCLAIMER = "Claudinho is an independent fan project. Not affiliated with or endorsed by FIFA or Anthropic.";
 function ctxFrom(cmd) {
   let root = cmd;