@claudinho/cli 0.2.0 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # @claudinho/cli ⚽
 
-**The 2026 men's football tournament, right in your terminal.** Live scores, fixtures, and group tables — TZ-aware, localized, scriptable.
+**The 2026 men's football tournament, right in your terminal.** Live scores, fixtures, group tables, and market odds — TZ-aware, localized, scriptable.
 
 > ⚠️ **Not affiliated with, endorsed by, or connected to FIFA or Anthropic.**
 > Claudinho is an independent, open-source fan project. It shows factual match
@@ -23,6 +23,7 @@ claudinho live              # matches in play right now
 claudinho next <TEAM>       # a team's next fixture + countdown   (e.g. next MEX)
 claudinho table [GROUP]     # group standings (default: all groups)
 claudinho match <id>        # a single match's detail
+claudinho markets [target]  # prediction-market odds: today | <date> | <id> | next <TEAM>
 claudinho prompt            # one compact status line (for statusline/tmux/Starship)
 claudinho init-statusline   # wire it into the Claude Code statusline
 claudinho hook              # live-score context for a Claude Code hook (silent off-match)
@@ -50,6 +51,7 @@ claudinho today --flavor off               # just the facts, no commentary
 | `--no-color` | disable ANSI color (also honors `NO_COLOR`; auto-off when piped) |
 | `--source <name>` | live data provider (advanced; sensible default) |
 | `--flavor <level>` | commentary flair: `off`, `subtle`, `full` (default: `full`; also `CLAUDINHO_FLAVOR`) |
+| `--no-markets` | hide prediction-market signals in `today`/`match` (also `CLAUDINHO_MARKETS=off`) |
 
 Team codes are 3-letter (FIFA/IOC-style): `MEX`, `BRA`, `USA`, `ENG`, …
 
@@ -64,6 +66,35 @@ localized per `--lang`, and they never affect `--json` output.
 - `--flavor subtle` — only goals and full-time
 - `--flavor off` — just the facts
 
+## Prediction-market signals
+
+`claudinho markets` shows **read-only** prediction-market odds — "who's favored" as
+market-implied percentages — for a date, a match, or a team's next fixture:
+
+```bash
+claudinho markets                 # today's signals
+claudinho markets 2026-06-11      # a specific date
+claudinho markets 760415          # one match by id
+claudinho markets next MEX        # a team's next fixture
+claudinho markets today --json    # structured sidecar output
+```
+
+A short market line is also added under `claudinho today` and `claudinho match`
+when a reliable market is available. It's **informational only — not betting
+advice:** market-implied percentages with attribution, no trading, no links. Data
+comes from Polymarket public market data and is shown
+only when the market maps cleanly to the result and is fresh.
+
+Opt out with `--no-markets` (per command) or `CLAUDINHO_MARKETS=off` (global). The
+statusline and hook **never** show market data — it stays off the hot path.
+
+> **How matches are matched:** event slugs are derived automatically from each
+> fixture (`fifwc-{home}-{away}-{date}`), so real odds appear for any match with a
+> live Polymarket market — no mapping needed (`mapping.2026.json` is for slug
+> *overrides* only). Matching fails closed, so an unmatched fixture simply shows
+> nothing. For an offline preview, set `CLAUDINHO_MARKETS_SOURCE=fake` to render
+> clearly-labeled synthetic **"demo data"** odds.
+
 ## Statusline (Claude Code)
 
 ```bash
@@ -111,8 +142,9 @@ statusline/hook cache is keyed to the active competition, so switching with
 
 The full fixture list (104 matches, groups, venues, host cities, kickoffs) ships **bundled**
 in the package, so the common path is offline and instant. Only live match
-state hits the network. Scores come from a swappable data provider; provider
-attribution and rate limits are respected.
+state hits the network. Live scores come from **ESPN's** public scoreboard (a
+swappable provider, attributed in output as `Live data: ESPN`) and market odds
+from Polymarket; provider attribution and rate limits are respected.
 
 ## License
 

package/dist/index.js

@@ -2830,12 +2830,16 @@ function mergeLive(base, live) {
   for (const m of live) byId.set(m.id, m);
   return [...byId.values()];
 }
+function liveSourceLabel(source) {
+  const known = { espn: "ESPN" };
+  return known[source] ?? source.charAt(0).toUpperCase() + source.slice(1);
+}
 async function getMatchesForDate(adapter, dateISO) {
   const base = 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);
-    return { matches: mergeLive(base, live), degraded: false };
+    return { matches: mergeLive(base, live), degraded: false, source: adapter.name };
   } catch {
     return { matches: base, degraded: true };
   }
@@ -2846,11 +2850,425 @@ function shiftUtcDate(dateISO, days) {
 }
 async function getLiveMatches(adapter) {
   try {
-    return { matches: await adapter.fetchLive(), degraded: false };
+    return { matches: await adapter.fetchLive(), degraded: false, source: adapter.name };
   } catch {
     return { matches: [], degraded: true };
   }
 }
+var DEFAULT_MAX_AGE_MS = 15 * 6e4;
+function normalizeOutcomes(outcomes) {
+  const sum = outcomes.reduce(
+    (s, o) => s + (Number.isFinite(o.probability) && o.probability > 0 ? o.probability : 0),
+    0
+  );
+  if (sum <= 0) return outcomes.map((o) => ({ ...o, probability: 0 }));
+  return outcomes.map((o) => ({
+    ...o,
+    probability: Number.isFinite(o.probability) && o.probability > 0 ? o.probability / sum : 0
+  }));
+}
+function favoriteStrength(probability) {
+  if (probability >= 0.65) return "clear";
+  if (probability >= 0.52) return "slight";
+  return "close";
+}
+function deriveFavorite(outcomes) {
+  let top;
+  for (const o of outcomes) {
+    if (o.kind === "other") continue;
+    if (!top || o.probability > top.probability) top = o;
+  }
+  if (!top || top.probability <= 0 || top.kind === "other") return void 0;
+  return {
+    kind: top.kind,
+    teamCode: top.teamCode,
+    probability: top.probability,
+    strength: favoriteStrength(top.probability)
+  };
+}
+function mapsCleanly(match, outcomes) {
+  if (outcomes.some((o) => o.kind === "other")) return false;
+  const home = outcomes.find((o) => o.kind === "home");
+  const away = outcomes.find((o) => o.kind === "away");
+  const draw = outcomes.find((o) => o.kind === "draw");
+  if (!home || !away) return false;
+  if (home.teamCode && home.teamCode.toUpperCase() !== match.home.code.toUpperCase()) {
+    return false;
+  }
+  if (away.teamCode && away.teamCode.toUpperCase() !== match.away.code.toUpperCase()) {
+    return false;
+  }
+  if (match.stage === "GROUP" && !draw) return false;
+  return true;
+}
+function hasSaneDistribution(outcomes) {
+  const priced = outcomes.filter((o) => Number.isFinite(o.probability) && o.probability > 0);
+  if (priced.length < 2) return false;
+  const sum = priced.reduce((s, o) => s + o.probability, 0);
+  return sum > 0.97 && sum < 1.03;
+}
+function isStaleSignal(signal, options = {}) {
+  const maxAge = options.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
+  const asOf = Date.parse(signal.asOf);
+  if (!Number.isFinite(asOf)) return true;
+  const now = (options.now ?? /* @__PURE__ */ new Date()).getTime();
+  return now - asOf > maxAge;
+}
+function isReliableMarketSignal(signal, options = {}) {
+  if (options.includeUnreliable) return true;
+  if (signal.ambiguous) return false;
+  if (!signal.favorite) return false;
+  if (!hasSaneDistribution(signal.outcomes)) return false;
+  if (signal.stale || isStaleSignal(signal, options)) return false;
+  if (options.minLiquidity != null) {
+    if (signal.liquidity == null || signal.liquidity < options.minLiquidity) return false;
+  }
+  return true;
+}
+function buildMarketSignal(input) {
+  const outcomes = normalizeOutcomes(input.outcomes);
+  const ambiguous = input.ambiguous === true || !mapsCleanly(input.match, outcomes);
+  const favorite = ambiguous ? void 0 : deriveFavorite(outcomes);
+  const signal = {
+    matchId: input.match.id,
+    source: input.source,
+    sourceMarketId: input.sourceMarketId,
+    asOf: input.asOf,
+    fetchedAt: input.fetchedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    outcomes,
+    favorite,
+    liquidity: input.liquidity,
+    volume24h: input.volume24h,
+    stale: false,
+    ambiguous
+  };
+  signal.stale = isStaleSignal(signal, { now: input.now, maxAgeMs: input.maxAgeMs });
+  return signal;
+}
+function pct(p) {
+  return Math.round(p * 100);
+}
+function marketSourceLabel(source) {
+  if (source === "polymarket") return "Polymarket";
+  if (source === "fake") return "demo data";
+  return source.charAt(0).toUpperCase() + source.slice(1);
+}
+function outcomeLabel(o, match) {
+  if (o.kind === "home") return match.home.name;
+  if (o.kind === "away") return match.away.name;
+  if (o.kind === "draw") return "Draw";
+  return o.label;
+}
+function utcHhmm(iso) {
+  const t = Date.parse(iso);
+  if (!Number.isFinite(t)) return "";
+  return `${new Date(t).toISOString().slice(11, 16)} UTC`;
+}
+function marketFavoriteText(signal, match) {
+  const fav = signal.favorite;
+  if (!fav || fav.strength === "close") return "Prediction markets see this match as close.";
+  if (fav.kind === "draw") return "Prediction markets see a draw as the top outcome.";
+  const name = fav.kind === "home" ? match.home.name : match.away.name;
+  return fav.strength === "clear" ? `Prediction markets favor ${name}.` : `Prediction markets slightly favor ${name}.`;
+}
+function marketProbabilityText(signal, match) {
+  const order = ["home", "draw", "away"];
+  const parts = [];
+  for (const kind of order) {
+    const o = signal.outcomes.find((x) => x.kind === kind);
+    if (o) parts.push(`${outcomeLabel(o, match)} ${pct(o.probability)}%`);
+  }
+  for (const o of signal.outcomes) {
+    if (o.kind === "other") parts.push(`${outcomeLabel(o, match)} ${pct(o.probability)}%`);
+  }
+  return parts.join(" \xB7 ");
+}
+function marketAttributionText(signal) {
+  const time = utcHhmm(signal.asOf);
+  const src = `Source: ${marketSourceLabel(signal.source)}`;
+  return time ? `${src} \xB7 updated ${time}` : src;
+}
+function marketLine(signal, match) {
+  return `Market: ${marketProbabilityText(signal, match)} \xB7 ${marketSourceLabel(
+    signal.source
+  )} \xB7 informational only`;
+}
+function marketBlock(signal, match) {
+  const lines = [];
+  if (signal.stale) lines.push("Market signal is stale; the reading may be out of date.");
+  lines.push(marketFavoriteText(signal, match));
+  lines.push(marketProbabilityText(signal, match));
+  lines.push(`${marketAttributionText(signal)} \xB7 informational only`);
+  return lines;
+}
+var FakeMarketProvider = class {
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  opts;
+  name = "fake";
+  async findSignal(match, options) {
+    const preset = this.opts.signals?.[match.id];
+    if (preset) return preset;
+    if (this.opts.synthesize) return this.synthesize(match, options);
+    return void 0;
+  }
+  async findSignals(matches, options) {
+    const signals = /* @__PURE__ */ new Map();
+    const checked = /* @__PURE__ */ new Set();
+    for (const m of matches) {
+      checked.add(m.id);
+      const s = await this.findSignal(m, options);
+      if (s) signals.set(m.id, s);
+    }
+    return { signals, checked };
+  }
+  synthesize(match, options) {
+    const seed = hash(`${match.home.code}-${match.away.code}`);
+    const home = 0.3 + seed % 33 / 100;
+    const away = 0.18 + (seed >> 3) % 23 / 100;
+    const draw = Math.max(0.05, 1 - home - away);
+    const outcomes = [
+      { kind: "home", teamCode: match.home.code, label: match.home.name, probability: home },
+      { kind: "draw", label: "Draw", probability: draw },
+      { kind: "away", teamCode: match.away.code, label: match.away.name, probability: away }
+    ];
+    const now = this.opts.now ?? options?.now ?? /* @__PURE__ */ new Date();
+    const asOf = new Date(now.getTime() - 6e4).toISOString();
+    return buildMarketSignal({
+      match,
+      source: "fake",
+      sourceMarketId: `fake-${match.id}`,
+      asOf,
+      fetchedAt: now.toISOString(),
+      outcomes,
+      liquidity: 5e4,
+      now,
+      maxAgeMs: options?.maxAgeMs
+    });
+  }
+};
+function hash(s) {
+  let h = 0;
+  for (let i = 0; i < s.length; i++) h = h * 31 + s.charCodeAt(i) >>> 0;
+  return h % 1e5;
+}
+var mapping_2026_default = {
+  version: 1,
+  note: "Optional matchId -> Polymarket EVENT-slug OVERRIDES. By default the slug is DERIVED from each fixture (fifwc-{home}-{away}-{UTC-date}, e.g. fifwc-mex-rsa-2026-06-11), so most matches need NO entry here. Add an entry only for a fixture whose real Polymarket slug differs (e.g. a team abbreviation that isn't the FIFA code, or a tz-shifted date). The event payload carries the three moneyline binary markets; each outcome's probability is its 'Yes' price; validation fails closed. Entry: { eventSlug, eventId? }.",
+  markets: {}
+};
+var DEFAULT_BASE2 = "https://gamma-api.polymarket.com";
+var ALLOWED_HOSTS = /* @__PURE__ */ new Set(["gamma-api.polymarket.com"]);
+var USER_AGENT2 = "claudinho/0.0 (+https://github.com/arturogarrido/claudinho)";
+var DEFAULT_TIMEOUT_MS = 8e3;
+var WC_SERIES_SLUG = "soccer-fifwc";
+var WC_SPORT = "fifwc";
+var KICKOFF_TOLERANCE_MS = 6 * 60 * 6e4;
+var NON_REGULAR_TIME = /extra time|penalt|to advance|to qualif|win the (group|tournament|cup|title)/i;
+var BUNDLED_MAPPING = mapping_2026_default.markets;
+var PolymarketProvider = class {
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  opts;
+  name = "polymarket";
+  async findSignal(match, options) {
+    return (await this.resolveOne(match, options)).signal;
+  }
+  async findSignals(matches, options) {
+    const signals = /* @__PURE__ */ new Map();
+    const checked = /* @__PURE__ */ new Set();
+    const deadline = options?.deadlineMs != null ? Date.now() + options.deadlineMs : Number.POSITIVE_INFINITY;
+    for (const m of matches) {
+      if (Date.now() >= deadline) break;
+      const r = await this.resolveOne(m, options);
+      if (r.checked) checked.add(m.id);
+      if (r.signal) signals.set(m.id, r.signal);
+    }
+    return { signals, checked };
+  }
+  /**
+   * Resolve one match. `checked` distinguishes a DEFINITIVE result (reached the
+   * source and found no usable market, or the fixture is unmappable) from a
+   * provider/network error — so transient failures are retried, not
+   * negative-cached.
+   */
+  async resolveOne(match, options) {
+    const entry = (this.opts.mapping ?? BUNDLED_MAPPING)[match.id];
+    const eventSlug = entry?.eventSlug ?? deriveEventSlug(match);
+    if (!eventSlug) return { checked: true };
+    try {
+      const event = await this.fetchEvent(eventSlug, options?.timeoutMs);
+      const signal = event ? this.toSignal(match, eventSlug, event, options) : void 0;
+      return { signal, checked: true };
+    } catch {
+      return { checked: false };
+    }
+  }
+  async fetchEvent(slug, timeoutMs) {
+    const base = this.opts.baseUrl ?? DEFAULT_BASE2;
+    assertAllowedHost(base);
+    const url = `${base}/events?slug=${encodeURIComponent(slug)}`;
+    const doFetch = this.opts.fetchImpl ?? fetch;
+    const res = await doFetch(url, {
+      signal: AbortSignal.timeout(timeoutMs ?? this.opts.timeoutMs ?? DEFAULT_TIMEOUT_MS),
+      headers: { Accept: "application/json", "User-Agent": USER_AGENT2 }
+    });
+    if (res.status === 404) return void 0;
+    if (!res.ok) {
+      throw new Error(`Polymarket request failed: ${res.status} ${res.statusText}`);
+    }
+    const data = await res.json();
+    const event = Array.isArray(data) ? data[0] : data;
+    return event && typeof event === "object" ? event : void 0;
+  }
+  toSignal(match, eventSlug, event, options) {
+    if (event.active === false || event.closed === true) return void 0;
+    if (event.seriesSlug != null && event.seriesSlug !== WC_SERIES_SLUG && event.sport?.sport !== WC_SPORT) {
+      return void 0;
+    }
+    if (event.slug != null && event.slug !== eventSlug) return void 0;
+    const start = event.startTime ? Date.parse(event.startTime) : Number.NaN;
+    const kick = Date.parse(match.kickoff);
+    if (Number.isFinite(start) && Number.isFinite(kick) && Math.abs(start - kick) > KICKOFF_TOLERANCE_MS) {
+      return void 0;
+    }
+    const moneyline = (event.markets ?? []).filter(
+      (m) => (m.sportsMarketType ?? "moneyline") === "moneyline"
+    );
+    const homeMarket = pickMarket(moneyline, match.home.code, match.home.name);
+    const awayMarket = pickMarket(moneyline, match.away.code, match.away.name);
+    const drawMarket = pickDraw(moneyline);
+    if (!homeMarket || !awayMarket) return void 0;
+    const legIds = [homeMarket, awayMarket, drawMarket].filter((m) => m != null).map((m) => m.id ?? m.slug ?? "");
+    if (new Set(legIds).size !== legIds.length) return void 0;
+    const legs = [
+      ["home", homeMarket, match.home.code, match.home.name],
+      ["draw", drawMarket, void 0, "Draw"],
+      ["away", awayMarket, match.away.code, match.away.name]
+    ];
+    const outcomes = [];
+    let asOf = event.updatedAt;
+    let liquidity;
+    for (const [kind, market, teamCode, label] of legs) {
+      if (!market) continue;
+      if (market.closed === true || market.active === false) return void 0;
+      if (market.description && NON_REGULAR_TIME.test(market.description)) return void 0;
+      const yes = yesPrice(market);
+      if (yes == null) return void 0;
+      outcomes.push({ kind, teamCode, label, probability: yes });
+      if (market.updatedAt && (!asOf || market.updatedAt < asOf)) asOf = market.updatedAt;
+      const liq = numberish(market.liquidityNum ?? market.liquidity);
+      if (liq != null) liquidity = liquidity == null ? liq : Math.min(liquidity, liq);
+    }
+    const rawSum = outcomes.reduce((s, o) => s + o.probability, 0);
+    if (rawSum < 0.9 || rawSum > 1.15) return void 0;
+    const signal = buildMarketSignal({
+      match,
+      source: "polymarket",
+      sourceMarketId: event.id ?? eventSlug,
+      asOf: asOf ?? (/* @__PURE__ */ new Date()).toISOString(),
+      outcomes,
+      liquidity,
+      now: options?.now ?? this.opts.now,
+      maxAgeMs: options?.maxAgeMs ?? this.opts.maxAgeMs
+    });
+    return signal.ambiguous ? void 0 : signal;
+  }
+};
+function deriveEventSlug(match) {
+  const home = match.home.code.toLowerCase();
+  const away = match.away.code.toLowerCase();
+  if (home === away || home === "tbd" || away === "tbd") return void 0;
+  if (!/^[a-z]{3}$/.test(home) || !/^[a-z]{3}$/.test(away)) return void 0;
+  const date = match.kickoff.slice(0, 10);
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) return void 0;
+  return `fifwc-${home}-${away}-${date}`;
+}
+function slugToken(m) {
+  return (m.slug ?? "").toLowerCase().split("-").pop() ?? "";
+}
+function isDrawMarket(m) {
+  return slugToken(m) === "draw" || (m.groupItemTitle ?? "").trim().toLowerCase().startsWith("draw");
+}
+function pickMarket(markets, teamCode, teamName) {
+  const code = teamCode.toLowerCase();
+  const name = teamName.trim().toLowerCase();
+  const teamMarkets = markets.filter((m) => !isDrawMarket(m));
+  const bySlug = teamMarkets.find((m) => slugToken(m) === code);
+  if (bySlug) return bySlug;
+  return teamMarkets.find((m) => (m.groupItemTitle ?? "").trim().toLowerCase() === name);
+}
+function pickDraw(markets) {
+  return markets.find(isDrawMarket);
+}
+function assertAllowedHost(base) {
+  let host;
+  try {
+    host = new URL(base).host;
+  } catch {
+    throw new Error(`Invalid Polymarket base URL: ${base}`);
+  }
+  if (!ALLOWED_HOSTS.has(host)) {
+    throw new Error(`Polymarket host not allow-listed: ${host}`);
+  }
+}
+function yesPrice(market) {
+  const labels = parseJsonArray(market.outcomes);
+  const prices = parseJsonArray(market.outcomePrices).map((p2) => Number(p2));
+  if (labels.length === 0 || labels.length !== prices.length) return void 0;
+  const i = labels.findIndex((l) => l.trim().toLowerCase() === "yes");
+  if (i < 0) return void 0;
+  const p = prices[i];
+  return typeof p === "number" && Number.isFinite(p) && p > 0 && p <= 1 ? p : void 0;
+}
+function parseJsonArray(v) {
+  if (Array.isArray(v)) return v.map((x) => String(x));
+  if (typeof v === "string") {
+    try {
+      const parsed = JSON.parse(v);
+      return Array.isArray(parsed) ? parsed.map((x) => String(x)) : [];
+    } catch {
+      return [];
+    }
+  }
+  return [];
+}
+function numberish(v) {
+  if (typeof v === "number") return Number.isFinite(v) ? v : void 0;
+  if (typeof v === "string") {
+    const n = Number(v);
+    return Number.isFinite(n) ? n : void 0;
+  }
+  return void 0;
+}
+function resolveMarketSource(explicit) {
+  if (explicit) return explicit;
+  if (typeof process !== "undefined" && process.env?.CLAUDINHO_MARKETS_SOURCE) {
+    return process.env.CLAUDINHO_MARKETS_SOURCE;
+  }
+  return "polymarket";
+}
+function makeMarketProvider(source) {
+  switch (resolveMarketSource(source)) {
+    case "fake":
+      return new FakeMarketProvider({ synthesize: true });
+    case "none":
+    case "off":
+      return new FakeMarketProvider();
+    // no synth → yields no signals, no network
+    default:
+      return new PolymarketProvider();
+  }
+}
+async function getMarketSignals(provider, matches, options) {
+  try {
+    return await provider.findSignals(matches, options);
+  } catch {
+    return { signals: /* @__PURE__ */ new Map(), checked: /* @__PURE__ */ new Set() };
+  }
+}
 
 // src/config.ts
 var SUPPORTED_LANGS = ["en", "es", "pt", "fr"];
@@ -2876,6 +3294,11 @@ function pickColor(explicit) {
 function isSupportedLang(s) {
   return SUPPORTED_LANGS.includes(s);
 }
+function pickMarkets(explicit) {
+  if (explicit === false) return false;
+  if ((process.env.CLAUDINHO_MARKETS ?? "").toLowerCase() === "off") return false;
+  return true;
+}
 function resolveConfig(opts) {
   const langRequestedUnsupported = opts.lang && !isSupportedLang(opts.lang) ? opts.lang : void 0;
   return {
@@ -2885,6 +3308,7 @@ function resolveConfig(opts) {
     color: pickColor(opts.color),
     source: opts.source ?? process.env.CLAUDINHO_SOURCE ?? "espn",
     flavor: asFlavorLevel(opts.flavor ?? process.env.CLAUDINHO_FLAVOR),
+    markets: pickMarkets(opts.markets),
     langRequestedUnsupported
   };
 }
@@ -3090,34 +3514,91 @@ function header(text, c) {
 function disclaimer(t, c) {
   return c.dim(t("disclaimer"));
 }
+function dataSource(source, c) {
+  return source ? c.dim(`Live data: ${liveSourceLabel(source)}`) : "";
+}
+
+// src/marketCache.ts
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var POSITIVE_TTL_MS = 10 * 6e4;
+var NEGATIVE_TTL_MS = 3 * 6e4;
+function cacheDir() {
+  const base = process.env.XDG_CACHE_HOME || join(homedir(), ".cache");
+  return join(base, "claudinho");
+}
+function cachePath() {
+  return join(cacheDir(), "market-signals.json");
+}
+function readFile() {
+  try {
+    return JSON.parse(readFileSync(cachePath(), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function readMarketCache(source, competition, now = Date.now()) {
+  const signals = /* @__PURE__ */ new Map();
+  const checked = /* @__PURE__ */ new Set();
+  const file = readFile();
+  if (!file || file.source !== source || file.competition !== competition) {
+    return { signals, checked };
+  }
+  for (const [id, entry] of Object.entries(file.entries ?? {})) {
+    const t = Date.parse(entry.fetchedAt);
+    if (!Number.isFinite(t)) continue;
+    const ttl = entry.signal ? POSITIVE_TTL_MS : NEGATIVE_TTL_MS;
+    if (now - t > ttl) continue;
+    checked.add(id);
+    if (entry.signal) signals.set(id, entry.signal);
+  }
+  return { signals, checked };
+}
+function writeMarketCache(source, competition, attempted, fetched, now = Date.now()) {
+  if (attempted.length === 0) return;
+  try {
+    const existing = readFile();
+    const base = existing && existing.source === source && existing.competition === competition ? existing : { source, competition, entries: {} };
+    const fetchedAt = new Date(now).toISOString();
+    for (const id of attempted) {
+      base.entries[id] = { fetchedAt, signal: fetched.get(id) ?? null };
+    }
+    mkdirSync(cacheDir(), { recursive: true });
+    const tmp = join(cacheDir(), `market-signals.${process.pid}.tmp`);
+    writeFileSync(tmp, JSON.stringify(base));
+    renameSync(tmp, cachePath());
+  } catch {
+  }
+}
 
 // src/cache.ts
 import {
   closeSync,
-  mkdirSync,
+  mkdirSync as mkdirSync2,
   openSync,
-  readFileSync,
-  renameSync,
+  readFileSync as readFileSync2,
+  renameSync as renameSync2,
   rmSync,
   statSync,
   writeSync
 } from "fs";
-import { homedir } from "os";
-import { join } from "path";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
 var LOCK_STALE_MS = 6e4;
-function cacheDir() {
-  const base = process.env.XDG_CACHE_HOME || join(homedir(), ".cache");
-  return join(base, "claudinho");
+function cacheDir2() {
+  const base = process.env.XDG_CACHE_HOME || join2(homedir2(), ".cache");
+  return join2(base, "claudinho");
 }
-function cachePath() {
-  return join(cacheDir(), "state.json");
+function cachePath2() {
+  return join2(cacheDir2(), "state.json");
 }
 function lockPath() {
-  return join(cacheDir(), "refresh.lock");
+  return join2(cacheDir2(), "refresh.lock");
 }
 function readState() {
   try {
-    return JSON.parse(readFileSync(cachePath(), "utf8"));
+    return JSON.parse(readFileSync2(cachePath2(), "utf8"));
   } catch {
     return void 0;
   }
@@ -3127,11 +3608,11 @@ function readCurrentState(source, competition) {
   return s && s.source === source && s.competition === competition ? s : void 0;
 }
 function writeState(state) {
-  const dir = cacheDir();
-  mkdirSync(dir, { recursive: true });
-  const tmp = join(dir, `state.${process.pid}.tmp`);
+  const dir = cacheDir2();
+  mkdirSync2(dir, { recursive: true });
+  const tmp = join2(dir, `state.${process.pid}.tmp`);
   writeFileSync_(tmp, JSON.stringify(state));
-  renameSync(tmp, cachePath());
+  renameSync2(tmp, cachePath2());
 }
 function writeFileSync_(path, data) {
   const fd = openSync(path, "w");
@@ -3149,7 +3630,7 @@ function ageMs(state, now = Date.now()) {
 function lockAgeMs(now = Date.now()) {
   const lp = lockPath();
   try {
-    const contents = readFileSync(lp, "utf8");
+    const contents = readFileSync2(lp, "utf8");
     const written = Number.parseInt(contents.split(/\s+/)[1] ?? "", 10);
     if (Number.isFinite(written)) return now - written;
   } catch {
@@ -3165,7 +3646,7 @@ function isLockFresh(now = Date.now()) {
   return lockAgeMs(now) < LOCK_STALE_MS;
 }
 function acquireLock(now = Date.now()) {
-  mkdirSync(cacheDir(), { recursive: true });
+  mkdirSync2(cacheDir2(), { recursive: true });
   const lp = lockPath();
   try {
     const fd = openSync(lp, "wx");
@@ -3337,14 +3818,14 @@ function spawnRefresh(source) {
 import {
   copyFileSync,
   existsSync,
-  mkdirSync as mkdirSync2,
-  readFileSync as readFileSync2,
-  writeFileSync
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync2
 } from "fs";
-import { homedir as homedir2 } from "os";
-import { dirname, join as join2 } from "path";
+import { homedir as homedir3 } from "os";
+import { dirname, join as join3 } from "path";
 function claudeSettingsPath() {
-  return join2(homedir2(), ".claude", "settings.json");
+  return join3(homedir3(), ".claude", "settings.json");
 }
 function backupOnce(path) {
   const bak = `${path}.claudinho.bak`;
@@ -3360,7 +3841,7 @@ function initStatusline(opts = {}) {
   let settings = {};
   if (existsSync(path)) {
     try {
-      settings = JSON.parse(readFileSync2(path, "utf8"));
+      settings = JSON.parse(readFileSync3(path, "utf8"));
     } catch {
       return {
         action: "manual",
@@ -3376,8 +3857,8 @@ ${snippet}`
   }
   backupOnce(path);
   settings.statusLine = sl;
-  mkdirSync2(dirname(path), { recursive: true });
-  writeFileSync(path, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  mkdirSync3(dirname(path), { recursive: true });
+  writeFileSync2(path, JSON.stringify(settings, null, 2) + "\n", "utf8");
   return {
     action: "written",
     path,
@@ -3398,7 +3879,7 @@ function initHook(opts = {}) {
   let settings = {};
   if (existsSync(path)) {
     try {
-      settings = JSON.parse(readFileSync2(path, "utf8"));
+      settings = JSON.parse(readFileSync3(path, "utf8"));
     } catch {
       return {
         action: "manual",
@@ -3420,8 +3901,8 @@ ${snippet}`
   }
   backupOnce(path);
   matchers.push({ hooks: [{ type: "command", command }] });
-  mkdirSync2(dirname(path), { recursive: true });
-  writeFileSync(path, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  mkdirSync3(dirname(path), { recursive: true });
+  writeFileSync2(path, JSON.stringify(settings, null, 2) + "\n", "utf8");
   return {
     action: "written",
     path,
@@ -3433,6 +3914,45 @@ ${snippet}`
 function adapterFor({ cfg, adapter }) {
   return adapter ?? makeAdapter(cfg.source);
 }
+var DEFAULT_ON_MARKET_OPTS = { deadlineMs: 2e3, timeoutMs: 2500 };
+var MARKETS_CMD_OPTS = { deadlineMs: 12e3, timeoutMs: 6e3 };
+async function marketSignalsFor(ctx, matches, opts = {}) {
+  if (ctx.marketProvider) return (await getMarketSignals(ctx.marketProvider, matches, opts)).signals;
+  const source = resolveMarketSource();
+  if (source !== "polymarket") {
+    return (await getMarketSignals(makeMarketProvider(source), matches, opts)).signals;
+  }
+  const competition = resolveCompetition();
+  const { signals: cached, checked: cachedIds } = readMarketCache("polymarket", competition);
+  const result = /* @__PURE__ */ new Map();
+  const miss = [];
+  for (const m of matches) {
+    const hit = cached.get(m.id);
+    if (hit) result.set(m.id, hit);
+    else if (!cachedIds.has(m.id)) miss.push(m);
+  }
+  if (miss.length > 0) {
+    const { signals: fetched, checked } = await getMarketSignals(
+      makeMarketProvider("polymarket"),
+      miss,
+      opts
+    );
+    writeMarketCache("polymarket", competition, [...checked], fetched);
+    for (const [id, s] of fetched) result.set(id, s);
+  }
+  return result;
+}
+async function reliableMarketSignals(ctx, matches) {
+  if (ctx.cfg.markets === false) return /* @__PURE__ */ new Map();
+  const raw = await marketSignalsFor(ctx, matches, DEFAULT_ON_MARKET_OPTS);
+  const now = /* @__PURE__ */ new Date();
+  const out2 = /* @__PURE__ */ new Map();
+  for (const [id, s] of raw) if (isReliableMarketSignal(s, { now })) out2.set(id, s);
+  return out2;
+}
+async function reliableMarketSignalFor(ctx, match) {
+  return (await reliableMarketSignals(ctx, [match])).get(match.id);
+}
 function out(line2 = "") {
   process.stdout.write(line2 + "\n");
 }
@@ -3457,10 +3977,17 @@ async function cmdToday(date, ctx) {
   precheck(cfg, t, date);
   const adapter = adapterFor(ctx);
   const targetDate = date ?? localDate((/* @__PURE__ */ new Date()).toISOString(), cfg.tz);
-  const { matches, degraded } = await getMatchesForDate(adapter, targetDate);
+  const { matches, degraded, source } = await getMatchesForDate(adapter, targetDate);
   const todays = fixturesByDate(targetDate, matches, cfg.tz);
+  const signals = await reliableMarketSignals(ctx, todays);
   if (cfg.json) {
-    emitJson({ date: targetDate, degraded, matches: todays });
+    emitJson({
+      date: targetDate,
+      degraded,
+      source: source ?? null,
+      matches: todays,
+      marketSignals: Object.fromEntries(signals)
+    });
     return;
   }
   const c = painterFor(cfg);
@@ -3471,18 +3998,24 @@ async function cmdToday(date, ctx) {
   if (todays.length === 0) {
     out(c.dim("  " + t("today.none")));
   } else {
-    for (const m of todays) out(matchLine(m, cfg, t, c));
+    for (const m of todays) {
+      out(matchLine(m, cfg, t, c));
+      const s = signals.get(m.id);
+      if (s) out("    " + c.dim(marketLine(s, m)));
+    }
   }
   out();
+  const src = dataSource(source, c);
+  if (src) out(src);
   out(disclaimer(t, c));
 }
 async function cmdLive(ctx) {
   const { cfg, t } = ctx;
   precheck(cfg, t);
   const adapter = adapterFor(ctx);
-  const { matches, degraded } = await getLiveMatches(adapter);
+  const { matches, degraded, source } = await getLiveMatches(adapter);
   if (cfg.json) {
-    emitJson({ degraded, matches });
+    emitJson({ degraded, source: source ?? null, matches });
     return;
   }
   const c = painterFor(cfg);
@@ -3495,6 +4028,8 @@ async function cmdLive(ctx) {
     for (const m of matches) out(matchLine(m, cfg, t, c));
   }
   out();
+  const src = dataSource(source, c);
+  if (src) out(src);
   out(disclaimer(t, c));
 }
 async function cmdNext(team, { cfg, t }) {
@@ -3528,7 +4063,7 @@ async function cmdTable(group, ctx) {
   const { cfg, t } = ctx;
   precheck(cfg, t);
   const adapter = adapterFor(ctx);
-  const { matches } = await getMatchesForDate(
+  const { matches, degraded, source } = await getMatchesForDate(
     adapter,
     localDate((/* @__PURE__ */ new Date()).toISOString(), cfg.tz)
   );
@@ -3538,7 +4073,11 @@ async function cmdTable(group, ctx) {
       group: g,
       standings: computeStandings(fixturesByGroup(g, matches))
     }));
-    emitJson(group ? tables[0] ?? null : tables);
+    emitJson({
+      degraded,
+      source: source ?? null,
+      tables: group ? tables[0] ?? null : tables
+    });
     return;
   }
   const c = painterFor(cfg);
@@ -3578,6 +4117,8 @@ async function cmdTable(group, ctx) {
     out(table.toString());
   }
   out();
+  const src = dataSource(source, c);
+  if (src) out(src);
   out(disclaimer(t, c));
 }
 function cmdPrompt({ cfg }) {
@@ -3633,15 +4174,18 @@ async function cmdMatch(id, ctx) {
   precheck(cfg, t);
   const adapter = adapterFor(ctx);
   let match = allFixtures().find((m) => m.id === id);
+  let liveSource;
   try {
     if (match) {
       const live = await adapter.fetchByDate(match.kickoff.slice(0, 10));
       match = live.find((m) => m.id === id) ?? match;
+      liveSource = adapter.name;
     }
   } catch {
   }
+  const marketSignal = match ? await reliableMarketSignalFor(ctx, match) : void 0;
   if (cfg.json) {
-    emitJson({ match: match ?? null });
+    emitJson({ match: match ?? null, source: liveSource ?? null, marketSignal: marketSignal ?? null });
     return;
   }
   const c = painterFor(cfg);
@@ -3668,8 +4212,112 @@ async function cmdMatch(id, ctx) {
       out(`  ${e.minute}'  ${e.type}  ${e.teamCode}${e.player ? ` \u2014 ${e.player}` : ""}`);
     }
   }
+  if (marketSignal) {
+    out();
+    for (const mline of marketBlock(marketSignal, match)) out("  " + c.dim(mline));
+  }
+  out();
+  const src = dataSource(liveSource, c);
+  if (src) out(src);
+  out(disclaimer(t, c));
+}
+var MARKET_INFO = "Prediction-market data is informational only.";
+function marketDisplayable(sig) {
+  return !sig.ambiguous && sig.favorite != null && hasSaneDistribution(sig.outcomes);
+}
+function marketHeaderLine(m) {
+  return `${m.home.flag} ${m.home.name} vs ${m.away.name} ${m.away.flag}`;
+}
+function printMarketBlock(m, sig, c) {
+  for (const line2 of marketBlock(sig, m)) out("    " + c.dim(line2));
+}
+async function cmdMarkets(target, team, ctx) {
+  const { cfg, t } = ctx;
+  if (target === "next") {
+    precheck(cfg, t);
+    if (!team) throw new InputError("Usage: claudinho markets next <team>");
+    const code = team.toUpperCase();
+    const fixture = nextFixtureForTeam(code);
+    const sig = fixture ? (await marketSignalsFor(ctx, [fixture], MARKETS_CMD_OPTS)).get(fixture.id) : void 0;
+    const shown = sig && marketDisplayable(sig) ? sig : void 0;
+    if (cfg.json) {
+      emitJson({
+        team: code,
+        matchId: fixture?.id ?? null,
+        informationalOnly: true,
+        signal: shown ?? null
+      });
+      return;
+    }
+    const c2 = painterFor(cfg);
+    out();
+    if (!fixture) {
+      out(c2.dim("  " + t("next.none", { team: code })));
+    } else {
+      out(header(marketHeaderLine(fixture), c2));
+      out();
+      if (shown) printMarketBlock(fixture, shown, c2);
+      else out(c2.dim("    No market signal for this match."));
+    }
+    out();
+    out(disclaimer(t, c2));
+    out(c2.dim(MARKET_INFO));
+    return;
+  }
+  if (target && target !== "today" && !isValidDate(target)) {
+    precheck(cfg, t);
+    const match = allFixtures().find((m) => m.id === target);
+    const sig = match ? (await marketSignalsFor(ctx, [match], MARKETS_CMD_OPTS)).get(match.id) : void 0;
+    const shown = sig && marketDisplayable(sig) ? sig : void 0;
+    if (cfg.json) {
+      emitJson({ matchId: target, informationalOnly: true, signal: shown ?? null });
+      return;
+    }
+    const c2 = painterFor(cfg);
+    out();
+    if (!match) {
+      out(c2.dim("  " + t("match.none", { id: target })));
+    } else {
+      out(header(marketHeaderLine(match), c2));
+      out();
+      if (shown) printMarketBlock(match, shown, c2);
+      else out(c2.dim("    No market signal for this match."));
+    }
+    out();
+    out(disclaimer(t, c2));
+    out(c2.dim(MARKET_INFO));
+    return;
+  }
+  const explicitDate = target && target !== "today" ? target : void 0;
+  precheck(cfg, t, explicitDate);
+  const date = explicitDate ?? localDate((/* @__PURE__ */ new Date()).toISOString(), cfg.tz);
+  const { matches } = await getMatchesForDate(adapterFor(ctx), date);
+  const todays = fixturesByDate(date, matches, cfg.tz);
+  const signals = await marketSignalsFor(ctx, todays, MARKETS_CMD_OPTS);
+  const rows = todays.map((m) => ({ match: m, signal: signals.get(m.id) })).filter(
+    (r) => !!r.signal && marketDisplayable(r.signal)
+  );
+  if (cfg.json) {
+    const marketSignals = {};
+    for (const r of rows) marketSignals[r.match.id] = r.signal;
+    emitJson({ date, informationalOnly: true, marketSignals });
+    return;
+  }
+  const c = painterFor(cfg);
+  out();
+  out(header(`Market signals \xB7 ${date}`, c));
   out();
+  if (rows.length === 0) {
+    out(c.dim(`  No market signals available for ${date}.`));
+  } else {
+    for (const { match, signal } of rows) {
+      out("  " + c.bold(marketHeaderLine(match)));
+      printMarketBlock(match, signal, c);
+      out();
+    }
+  }
   out(disclaimer(t, c));
+  out(c.dim(MARKET_INFO));
 }
 var VIBES = [
   "Shipping code, watching goals.",
@@ -3704,7 +4352,7 @@ function handlePipeError(stream) {
 }
 handlePipeError(process.stdout);
 handlePipeError(process.stderr);
-var VERSION = "0.2.0";
+var VERSION = "0.3.0";
 var DISCLAIMER = "Claudinho is an independent fan project. Not affiliated with or endorsed by FIFA or Anthropic.";
 function ctxFrom(cmd) {
   const root = cmd.parent ?? cmd;
@@ -3719,7 +4367,7 @@ function fail(err) {
   process.exit(1);
 }
 var program = new Command();
-program.name("claudinho").description("The 2026 football tournament in your terminal.\n" + DISCLAIMER).version(VERSION, "-v, --version").option("--lang <code>", "language: en, es, pt, fr").option("--tz <zone>", "IANA timezone, e.g. America/Mexico_City").option("--json", "output JSON (for scripting)").option("--no-color", "disable ANSI colors").option("--source <name>", "live data provider (advanced)").option("--flavor <level>", "commentary flair: off, subtle, full (default: full)");
+program.name("claudinho").description("The 2026 football tournament in your terminal.\n" + DISCLAIMER).version(VERSION, "-v, --version").option("--lang <code>", "language: en, es, pt, fr").option("--tz <zone>", "IANA timezone, e.g. America/Mexico_City").option("--json", "output JSON (for scripting)").option("--no-color", "disable ANSI colors").option("--source <name>", "live data provider (advanced)").option("--flavor <level>", "commentary flair: off, subtle, full (default: full)").option("--no-markets", "hide prediction-market signals (informational odds)");
 program.addHelpText("after", "\n#VibingLaVidaLoca \u26BD");
 program.command("today").description("show a day's fixtures (default: today)").argument("[date]", "date as YYYY-MM-DD").action(async (date, _opts, cmd) => {
   try {
@@ -3756,6 +4404,13 @@ program.command("match").description("show a single match by id").argument("<id>
     fail(e);
   }
 });
+program.command("markets").description("show prediction-market signals (read-only, informational only)").argument("[target]", 'date (YYYY-MM-DD), match id, "today", or "next"').argument("[team]", 'team code when target is "next" (e.g. MEX)').action(async (target, team, _opts, cmd) => {
+  try {
+    await cmdMarkets(target, team, ctxFrom(cmd));
+  } catch (e) {
+    fail(e);
+  }
+});
 program.command("prompt").description("print a one-line status (Claude Code statusline, tmux, Starship, \u2026)").action((_opts, cmd) => {
   cmdPrompt(ctxFrom(cmd));
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@claudinho/cli",
-  "version": "0.2.0",
-  "description": "Claudinho CLI — the 2026 football tournament in your terminal. Live scores, fixtures, group tables. Not affiliated with FIFA or Anthropic.",
+  "version": "0.3.0",
+  "description": "Claudinho CLI — the 2026 men's football tournament in your terminal: live scores, fixtures, group tables, prediction-market odds. Not affiliated with FIFA or Anthropic.",
   "type": "module",
   "license": "MIT",
   "author": "Arturo Garrido",
@@ -48,7 +48,7 @@
     "tsup": "^8.0.0",
     "typescript": "^5.7.0",
     "vitest": "^4.1.0",
-    "@claudinho/core": "0.2.0"
+    "@claudinho/core": "0.3.0"
   },
   "scripts": {
     "build": "tsup",