@claudinho/cli 0.2.0 → 0.4.0

package/dist/index.js

@@ -311,6 +311,25 @@ function formatKickoff(iso, opts = {}) {
     timeZone: tz
   }).format(new Date(iso));
 }
+function formatDate(iso, opts = {}) {
+  const tz = resolveTz(opts.tz);
+  const locale = safeLocale(opts.locale);
+  return new Intl.DateTimeFormat(locale, {
+    month: "short",
+    day: "numeric",
+    timeZone: tz
+  }).format(new Date(iso));
+}
+function formatTime(iso, opts = {}) {
+  const tz = resolveTz(opts.tz);
+  const locale = safeLocale(opts.locale);
+  return new Intl.DateTimeFormat(locale, {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false,
+    timeZone: tz
+  }).format(new Date(iso));
+}
 function countdown(iso, from = /* @__PURE__ */ new Date()) {
   const ms = new Date(iso).getTime() - from.getTime();
   if (ms <= 0) return "now";
@@ -2830,12 +2849,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 +2869,506 @@ 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() };
+  }
+}
+var SHARE_HASHTAG = "#VibingLaVidaLoca";
+var SHARE_DISCLAIMER = "Independent fan project \xB7 not affiliated with FIFA or Anthropic.";
+function mid(m) {
+  return isLive(m.status) || m.status === "FT" ? scoreline(m) : "vs";
+}
+function statusTail(m) {
+  switch (m.status) {
+    case "LIVE":
+      return m.minute ? `${m.minute}'` : "LIVE";
+    case "HT":
+      return "HT";
+    case "FT":
+      return "FT";
+    case "POSTPONED":
+      return "postponed";
+    case "CANCELLED":
+      return "cancelled";
+    default:
+      return "";
+  }
+}
+function compactLine(m, input, single) {
+  const home = `${m.home.flag} ${m.home.code}`;
+  const away = `${m.away.code} ${m.away.flag}`;
+  const opts = { tz: input.tz, locale: input.locale };
+  let tail;
+  if (m.status === "SCHEDULED") {
+    const time = formatTime(m.kickoff, opts);
+    tail = single ? `${formatDate(m.kickoff, opts)} ${time}` : time;
+  } else {
+    tail = statusTail(m);
+  }
+  return `${home} ${mid(m)} ${away}${tail ? ` \xB7 ${tail}` : ""}`;
+}
+function socialCard(m, input) {
+  const lines = [];
+  const head = `${m.home.flag} ${m.home.name} ${mid(m)} ${m.away.name} ${m.away.flag}`;
+  if (m.status === "SCHEDULED") {
+    lines.push(head);
+    const date = formatDate(m.kickoff, { tz: input.tz, locale: input.locale });
+    const time = formatTime(m.kickoff, { tz: input.tz, locale: input.locale });
+    const zone = input.tz ? ` ${input.tz}` : "";
+    lines.push(`${date} \xB7 ${time}${zone}`);
+  } else {
+    const tail = statusTail(m);
+    lines.push(tail ? `${head} \xB7 ${tail}` : head);
+  }
+  const loc = matchLocation(m);
+  if (loc) lines.push(loc);
+  return lines;
+}
+function formatShareSnippet(input, options = {}) {
+  const style = options.style ?? "social";
+  const includeMarkets = options.includeMarkets !== false;
+  const includeHashtag = options.includeHashtag !== false;
+  const includeInstall = options.includeInstallLine !== false;
+  const signals = input.marketSignals ?? /* @__PURE__ */ new Map();
+  const single = input.matches.length === 1;
+  const blocks = [input.title];
+  if (input.matches.length === 0) {
+    if (input.emptyNote) blocks.push(input.emptyNote);
+  } else if (style === "compact") {
+    blocks.push(input.matches.map((m) => compactLine(m, input, single)).join("\n"));
+  } else {
+    for (const m of input.matches) {
+      const card = socialCard(m, input);
+      const sig = includeMarkets ? signals.get(m.id) : void 0;
+      if (sig) {
+        if (single) card.push("", ...marketBlock(sig, m));
+        else card.push(marketLine(sig, m));
+      }
+      blocks.push(card.join("\n"));
+    }
+  }
+  const footer = [];
+  if (input.source) footer.push(`Live data: ${liveSourceLabel(input.source)}`);
+  footer.push([includeHashtag ? SHARE_HASHTAG : "", SHARE_DISCLAIMER].filter(Boolean).join(" \xB7 "));
+  if (includeInstall && input.installLine) footer.push(`Try it: ${input.installLine}`);
+  blocks.push(footer.join("\n"));
+  return blocks.join("\n\n");
+}
 
 // src/config.ts
 var SUPPORTED_LANGS = ["en", "es", "pt", "fr"];
@@ -2876,6 +3394,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 +3408,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
   };
 }
@@ -3070,8 +3594,8 @@ function statusToken(m, t, c) {
 function matchLine(m, cfg, t, c) {
   const home = `${m.home.flag} ${m.home.name}`;
   const away = `${m.away.name} ${m.away.flag}`;
-  const mid = isLive(m.status) || m.status === "FT" ? c.bold(scoreline(m)) : c.dim("vs");
-  const left = `${home.padEnd(22)} ${mid.padStart(3)}  ${away}`;
+  const mid2 = isLive(m.status) || m.status === "FT" ? c.bold(scoreline(m)) : c.dim("vs");
+  const left = `${home.padEnd(22)} ${mid2.padStart(3)}  ${away}`;
   let right = "";
   if (m.status === "SCHEDULED") {
     right = c.dim(
@@ -3090,34 +3614,117 @@ 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/clipboard.ts
+import { spawnSync } from "child_process";
+function clipboardTools(platform) {
+  if (platform === "darwin") return [{ cmd: "pbcopy", args: [] }];
+  if (platform === "win32") return [{ cmd: "clip", args: [] }];
+  return [
+    { cmd: "wl-copy", args: [] },
+    { cmd: "xclip", args: ["-selection", "clipboard"] },
+    { cmd: "xsel", args: ["--clipboard", "--input"] }
+  ];
+}
+function copyToClipboard(text, platform = process.platform) {
+  for (const { cmd, args } of clipboardTools(platform)) {
+    try {
+      const res = spawnSync(cmd, args, {
+        input: text,
+        stdio: ["pipe", "ignore", "ignore"],
+        timeout: 1e3
+      });
+      if (!res.error && res.status === 0) return true;
+    } catch {
+    }
+  }
+  return false;
+}
 
 // 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 +3734,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 +3756,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 +3772,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 +3944,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 +3967,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 +3983,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 +4005,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 +4027,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 +4040,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 +4103,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 +4124,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 +4154,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 +4189,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 +4199,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 +4243,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 +4300,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 +4338,271 @@ 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));
+}
+function pickShareStyle(v) {
+  return v === "compact" ? "compact" : "social";
+}
+async function reliableShareSignals(ctx, matches) {
+  const raw = await reliableMarketSignals(ctx, matches);
+  const out2 = /* @__PURE__ */ new Map();
+  for (const [id, s] of raw) if (marketDisplayable(s)) out2.set(id, s);
+  return out2;
+}
+function emitShare(ctx, e, copy) {
+  const snippet = formatShareSnippet(e.input, e.options);
+  if (ctx.cfg.json) {
+    emitJson({
+      kind: e.kind,
+      target: e.target,
+      ...e.team ? { team: e.team } : {},
+      source: e.input.source ?? null,
+      informationalOnly: true,
+      style: e.options.style ?? "social",
+      snippet,
+      matches: e.input.matches,
+      marketSignals: Object.fromEntries(e.input.marketSignals ?? /* @__PURE__ */ new Map())
+    });
+  } else {
+    out(snippet);
+  }
+  if (copy) {
+    const ok = (ctx.copy ?? copyToClipboard)(snippet);
+    process.stderr.write(
+      (ok ? "Copied share snippet to clipboard." : "Clipboard unavailable; printed snippet instead.") + "\n"
+    );
+  }
+}
+async function cmdShare(target, team, opts, ctx) {
+  const { cfg, t } = ctx;
+  const baseOptions = {
+    style: pickShareStyle(opts.style),
+    includeMarkets: cfg.markets !== false,
+    includeHashtag: opts.hashtag !== false,
+    includeInstallLine: opts.installLine !== false
+  };
+  const copy = opts.copy === true;
+  if (target === "live") {
+    precheck(cfg, t);
+    const { matches, source: source2 } = await getLiveMatches(adapterFor(ctx));
+    emitShare(
+      ctx,
+      {
+        kind: "live",
+        target: "live",
+        input: {
+          title: "Live match pulse",
+          matches,
+          source: source2,
+          emptyNote: "No matches in play right now.",
+          installLine: "npx @claudinho/cli live",
+          tz: cfg.tz,
+          locale: cfg.lang
+        },
+        // Live snippets stay lean: no market enrichment (and no extra fetch).
+        options: { ...baseOptions, includeMarkets: false }
+      },
+      copy
+    );
+    return;
+  }
+  if (target === "next") {
+    precheck(cfg, t);
+    if (!team) throw new InputError("Usage: claudinho share next <team>");
+    const code = team.toUpperCase();
+    const fixture = nextFixtureForTeam(code);
+    const matches = fixture ? [fixture] : [];
+    const signals2 = await reliableShareSignals(ctx, matches);
+    const teamName = fixture ? fixture.home.code === code ? fixture.home.name : fixture.away.name : code;
+    emitShare(
+      ctx,
+      {
+        kind: "next",
+        target: "next",
+        team: code,
+        input: {
+          title: `Next up for ${teamName}`,
+          matches,
+          marketSignals: signals2,
+          emptyNote: `No upcoming fixture found for ${code}.`,
+          installLine: `npx @claudinho/cli next ${code}`,
+          tz: cfg.tz,
+          locale: cfg.lang
+        },
+        options: baseOptions
+      },
+      copy
+    );
+    return;
+  }
+  if (target && target !== "today" && !isValidDate(target)) {
+    precheck(cfg, t);
+    const adapter = adapterFor(ctx);
+    let match = allFixtures().find((m) => m.id === target);
+    let source2;
+    try {
+      if (match) {
+        const live = await adapter.fetchByDate(match.kickoff.slice(0, 10));
+        match = live.find((m) => m.id === target) ?? match;
+        source2 = adapter.name;
+      }
+    } catch {
+    }
+    const matches = match ? [match] : [];
+    const signals2 = await reliableShareSignals(ctx, matches);
+    emitShare(
+      ctx,
+      {
+        kind: "match",
+        target,
+        input: {
+          title: "Match pulse",
+          matches,
+          marketSignals: signals2,
+          source: source2,
+          emptyNote: `No match found with id ${target}.`,
+          installLine: `npx @claudinho/cli match ${target}`,
+          tz: cfg.tz,
+          locale: cfg.lang
+        },
+        options: baseOptions
+      },
+      copy
+    );
+    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: all, source } = await getMatchesForDate(adapterFor(ctx), date);
+  const todays = fixturesByDate(date, all, cfg.tz);
+  const signals = await reliableShareSignals(ctx, todays);
+  const human = formatDate(`${date}T12:00:00.000Z`, { tz: cfg.tz, locale: cfg.lang });
+  const title = explicitDate ? `Matches \xB7 ${human}` : `Today's matches \xB7 ${human}`;
+  emitShare(
+    ctx,
+    {
+      kind: "today",
+      target: date,
+      input: {
+        title,
+        matches: todays,
+        marketSignals: signals,
+        source,
+        emptyNote: `No matches scheduled for ${human}.`,
+        installLine: "npx @claudinho/cli today",
+        tz: cfg.tz,
+        locale: cfg.lang
+      },
+      options: baseOptions
+    },
+    copy
+  );
 }
 var VIBES = [
   "Shipping code, watching goals.",
@@ -3704,7 +4637,7 @@ function handlePipeError(stream) {
 }
 handlePipeError(process.stdout);
 handlePipeError(process.stderr);
-var VERSION = "0.2.0";
+var VERSION = "0.4.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 +4652,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 +4689,20 @@ 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("share").description("print a shareable, copy-pasteable match snippet (#VibingLaVidaLoca)").argument("[target]", '"today" (default), "live", a date, a match id, or "next"').argument("[team]", 'team code when target is "next" (e.g. MEX)').option("--style <style>", "snippet style: social (default) or compact").option("--copy", "also copy the snippet to the clipboard (best-effort)").option("--no-hashtag", "omit the #VibingLaVidaLoca tag").option("--no-install-line", "omit the install/run cue").action(async (target, team, opts, cmd) => {
+  try {
+    await cmdShare(target, team, opts, 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));
 });