cito-mcp 0.3.13 → 0.3.15

package/dist/envelope.js

@@ -64,7 +64,9 @@ export function mapHttpToCode(status, hints) {
     }
     if (status === 400 && hints?.ambiguous)
         return 'AMBIGUOUS_ENTITY';
-    if (status === 400)
+    // 422 is FastAPI's validation status (tennis). It was falling through to
+    // UPSTREAM, which is marked retryable, so an agent retried a bad argument.
+    if (status === 400 || status === 422)
         return 'VALIDATION';
     if (status >= 500 || status === 0)
         return 'UPSTREAM';

package/dist/tools/insight.js

@@ -13,6 +13,50 @@ async function loadSide(ctx, game, side, recentLimit, includeRosters) {
     let roster = [];
     let recentForm = [];
     let keyPlayers = [];
+    if (game === 'tennis') {
+        // Profile + match log. Without this branch the preview fell to the generic
+        // fallback and presented player ids where names belong.
+        const res = await fetchJson(ctx, `/tennis/players/${encodeURIComponent(side)}`);
+        calls += 1;
+        rateLimit = res.headers;
+        if (res.ok) {
+            const data = asRecord(unwrapPayload(res.data)) ?? {};
+            const career = asRecord(data.career_summary) ?? {};
+            entity = {
+                id: pickString(data.player_id, data.id, side),
+                slug: pickString(data.player_id, data.id, side),
+                name: pickString(data.full_name, data.name, side) ?? side,
+                tour: pickString(data.tour) ?? null,
+                country: pickString(data.ioc, data.country_code) ?? null,
+                hand: pickString(data.hand) ?? null,
+                age: typeof data.age === 'number' ? data.age : null,
+                currentRank: typeof data.current_rank === 'number' ? data.current_rank : null,
+                careerHighRank: typeof data.career_high_rank === 'number' ? data.career_high_rank : null,
+                careerRecord: career.matches_won != null && career.matches_lost != null
+                    ? `${career.matches_won}-${career.matches_lost}`
+                    : null,
+                game,
+            };
+        }
+        else {
+            partial.push(partialFromRejection('entity', {
+                code: mapHttpToCode(res.status),
+                message: `player HTTP ${res.status}`,
+                httpStatus: res.status,
+            }));
+        }
+        const log = await fetchJson(ctx, `/tennis/players/${encodeURIComponent(side)}/matches`, {
+            query: { page_size: recentLimit },
+        });
+        calls += 1;
+        rateLimit = { ...rateLimit, ...log.headers };
+        if (log.ok) {
+            recentForm = extractRows(unwrapPayload(log.data) ?? log.data)
+                .slice(0, recentLimit)
+                .map((row) => normalizeMatch('tennis', row));
+        }
+        return { entity, roster, recentForm, keyPlayers, calls, partial, rateLimit };
+    }
     if (game === 'ufc') {
         const res = await fetchJson(ctx, `/ufc/fighters/${encodeURIComponent(side)}`);
         calls += 1;
@@ -210,6 +254,10 @@ export function composeH2H(game, sideA, sideB, rows, limit) {
     const bl = sideB.toLowerCase();
     const meetings = rows
         .map((row) => normalizeMatch(game, row))
+        // A meeting is a fight that happened. The upcoming bout between the two
+        // sides sits in the same history list and must not count as a prior
+        // meeting, or every preview reports the fight it is previewing as H2H.
+        .filter((m) => m.status === 'completed')
         .filter((m) => {
         const s1 = [m.team1?.id, m.team1?.slug, m.team1?.name].filter(Boolean).map((x) => String(x).toLowerCase());
         const s2 = [m.team2?.id, m.team2?.slug, m.team2?.name].filter(Boolean).map((x) => String(x).toLowerCase());
@@ -223,7 +271,7 @@ export function composeH2H(game, sideA, sideB, rows, limit) {
     return {
         meetings: meetings.length,
         lastMeetings: meetings.slice(0, 5),
-        recordNote: meetings.length ? `${meetings.length} meetings found in window` : 'No H2H meetings in window',
+        recordNote: meetings.length ? `${meetings.length} past meetings found in window` : 'No past H2H meetings in window',
     };
 }
 export const matchPreview = {
@@ -311,6 +359,8 @@ Example: { "game": "lol", "teamA": "t1", "teamB": "gen-g", "includeH2H": true, "
                 path = `/cod/matches/${encodeURIComponent(matchId)}`;
             else if (game === 'ufc')
                 path = `/ufc/bouts/${encodeURIComponent(matchId)}`;
+            else if (game === 'tennis')
+                path = `/tennis/matches/${encodeURIComponent(matchId)}`;
             const res = await fetchJson(ctx, path);
             upstreamCalls += 1;
             rateLimit = res.headers;
@@ -332,6 +382,18 @@ Example: { "game": "lol", "teamA": "t1", "teamB": "gen-g", "includeH2H": true, "
                     teamA = m.team1?.slug || m.team1?.id || m.team1?.name || '';
                 if (!teamB)
                     teamB = m.team2?.slug || m.team2?.id || m.team2?.name || '';
+                // Tennis archive detail carries winner/loser objects; if normalisation
+                // did not surface them as sides, read the ids straight off the record
+                // rather than failing the whole preview.
+                if (game === 'tennis') {
+                    const rec = asRecord(entity) ?? {};
+                    const w = asRecord(rec.winner) ?? asRecord(rec.player1) ?? {};
+                    const l = asRecord(rec.loser) ?? asRecord(rec.player2) ?? {};
+                    if (!teamA)
+                        teamA = pickString(w.id, rec.winner_id, rec.player1_id) ?? '';
+                    if (!teamB)
+                        teamB = pickString(l.id, rec.loser_id, rec.player2_id) ?? '';
+                }
             }
             else {
                 partial.push(partialFromRejection('context', {
@@ -401,6 +463,45 @@ Example: { "game": "lol", "teamA": "t1", "teamB": "gen-g", "includeH2H": true, "
                     if (res.ok)
                         rows = extractRows(res.data);
                 }
+                else if (game === 'tennis') {
+                    // Tennis has a first-class H2H endpoint with the full rivalry; use it
+                    // rather than composing from a short form window, which reported
+                    // Sinner vs Alcaraz as never having met.
+                    const h2hRes = await fetchJson(ctx, '/tennis/h2h', { query: { player1_id: teamA, player2_id: teamB } });
+                    upstreamCalls += 1;
+                    rateLimit = { ...rateLimit, ...h2hRes.headers };
+                    if (h2hRes.ok) {
+                        const rec = asRecord(unwrapPayload(h2hRes.data)) ?? {};
+                        // The payload names both players once at the top; rows name only
+                        // the winner. Resolve the loser's name from the top-level blocks
+                        // so a meeting reads "Sinner vs Alcaraz", not "Sinner vs atp_207989".
+                        const p1 = asRecord(rec.player1) ?? {};
+                        const p2 = asRecord(rec.player2) ?? {};
+                        const nameOf = {
+                            [String(pickString(p1.id) ?? '')]: pickString(p1.name),
+                            [String(pickString(p2.id) ?? '')]: pickString(p2.name),
+                        };
+                        rows = (Array.isArray(rec.matches) ? rec.matches : []).map((row) => {
+                            const r = asRecord(row) ?? {};
+                            const winnerId = pickString(r.winner_id) ?? '';
+                            const loserId = winnerId === pickString(p1.id) ? String(pickString(p2.id) ?? teamB) : String(pickString(p1.id) ?? teamA);
+                            return {
+                                ...r,
+                                outcome: 'COMPLETED',
+                                winner: { id: winnerId, name: pickString(r.winner_name) ?? nameOf[winnerId] },
+                                loser: { id: loserId, name: nameOf[loserId] },
+                                startTime: pickString(r.date),
+                            };
+                        });
+                    }
+                    else {
+                        partial.push(partialFromRejection('h2h', {
+                            code: mapHttpToCode(h2hRes.status),
+                            message: `tennis h2h HTTP ${h2hRes.status}`,
+                            httpStatus: h2hRes.status,
+                        }));
+                    }
+                }
                 else if (game === 'ufc') {
                     // Fighter fight history is the H2H source of truth (not global /bouts page 1).
                     const hist = await fetchJson(ctx, `/ufc/fighters/${encodeURIComponent(teamA)}/fights`, {
@@ -434,6 +535,31 @@ Example: { "game": "lol", "teamA": "t1", "teamB": "gen-g", "includeH2H": true, "
             }
         }
         // Factual briefing lines only — never structural meta like "roster loaded".
+        // Called with teamA + teamB and no matchId, context stayed empty
+        // ({ matchId:null, event:null, startTime:null }) for a headliner whose
+        // own form list had all three. Side A's history carries the booked bout
+        // against side B; that IS the context.
+        if (!matchId && context.matchId == null) {
+            const bl = String(teamB ?? '').toLowerCase();
+            const booked = sideARes.recentForm.find((m) => {
+                if (!m || (m.status !== 'upcoming' && m.status !== 'live'))
+                    return false;
+                const sides = [m.team1?.slug, m.team1?.id, m.team1?.name, m.team2?.slug, m.team2?.id, m.team2?.name]
+                    .filter(Boolean).map((x) => String(x).toLowerCase());
+                return sides.some((x) => x === bl || x.includes(bl) || bl.includes(x));
+            });
+            if (booked) {
+                context = {
+                    ...context,
+                    matchId: booked.matchId !== 'unknown' ? booked.matchId : null,
+                    startTime: booked.startTime,
+                    event: booked.event,
+                    eventName: booked.event?.name ?? null,
+                    status: booked.status,
+                    label: booked.label,
+                };
+            }
+        }
         const talkingPoints = [];
         const sideAName = pickString(asRecord(sideARes.entity)?.name, teamA) ?? teamA;
         const sideBName = pickString(asRecord(sideBRes.entity)?.name, teamB) ?? teamB;
@@ -519,6 +645,32 @@ async function resolveEventKey(ctx, game, q) {
     const needle = q.toLowerCase().trim();
     if (!needle)
         return { key: null, name: null, calls, rateLimit };
+    if (game === 'tennis') {
+        // No free-text search on tournaments upstream; the season calendar is the
+        // complete list and is small enough to match locally.
+        // This year's calendar first, then the two before it: the archive lags
+        // the live season, so the current edition of an event may not exist yet
+        // (no 2026 Wimbledon row while 2025 does).
+        const thisYear = new Date().getUTCFullYear();
+        let hit;
+        for (const year of [thisYear, thisYear - 1, thisYear - 2]) {
+            const res = await fetchJson(ctx, '/tennis/tournaments/calendar', { query: { year } });
+            calls += 1;
+            rateLimit = res.headers;
+            const rows = extractRows(unwrapPayload(res.data) ?? res.data).map((r) => asRecord(r) ?? {});
+            hit =
+                rows.find((r) => String(pickString(r.name) ?? '').toLowerCase() === needle) ??
+                    rows.find((r) => String(pickString(r.name) ?? '').toLowerCase().includes(needle));
+            if (hit)
+                break;
+        }
+        return {
+            key: hit ? (pickString(hit.id, hit.tournament_id) ?? null) : null,
+            name: hit ? (pickString(hit.name) ?? null) : null,
+            calls,
+            rateLimit,
+        };
+    }
     let path = '';
     let query = { limit: 25, page: 1 };
     if (game === 'ufc') {
@@ -1056,6 +1208,67 @@ Example: { "game": "ufc", "eventIdOrSlug": "ufc-300", "includeBouts": true, "inc
                 }
             }
         }
+        else if (game === 'tennis') {
+            // Tournament detail plus the bracket. The draw is only populated once a
+            // tournament has results, so an event still in the future comes back
+            // with the detail and an empty bouts list, and says so.
+            const detail = await fetchJson(ctx, `/tennis/tournaments/${encodeURIComponent(eventKey)}`);
+            upstreamCalls += 1;
+            rateLimit = { ...rateLimit, ...detail.headers };
+            if (detail.ok) {
+                const d = asRecord(unwrapPayload(detail.data)) ?? {};
+                event = {
+                    ...event,
+                    id: pickString(d.id) ?? eventKey,
+                    slug: pickString(d.id) ?? eventKey,
+                    name: pickString(d.name) ?? event.name,
+                    tour: pickString(d.tour) ?? null,
+                    level: pickString(d.level) ?? null,
+                    tier: pickString(d.tier) ?? null,
+                    surface: pickString(d.surface) ?? null,
+                    drawSize: typeof d.draw_size === 'number' ? d.draw_size : null,
+                    city: pickString(d.city) ?? null,
+                    country: pickString(d.country_code) ?? null,
+                    editions: { first: d.first_edition_year ?? null, mostRecent: d.most_recent_edition_year ?? null },
+                    allTimeTitleLeader: d.all_time_title_leader ?? null,
+                };
+            }
+            else {
+                partial.push(partialFromRejection('event', {
+                    code: mapHttpToCode(detail.status),
+                    message: `tournament HTTP ${detail.status}`,
+                    httpStatus: detail.status,
+                }));
+            }
+            if (includeBouts) {
+                const draw = await fetchJson(ctx, `/tennis/tournaments/${encodeURIComponent(eventKey)}/draw`);
+                upstreamCalls += 1;
+                rateLimit = { ...rateLimit, ...draw.headers };
+                if (draw.ok) {
+                    const dd = asRecord(unwrapPayload(draw.data)) ?? {};
+                    const rounds = Array.isArray(dd.rounds) ? dd.rounds : [];
+                    const flat = [];
+                    for (const rr of rounds) {
+                        const rec = asRecord(rr) ?? {};
+                        const roundName = pickString(rec.round_name, rec.name, rec.round) ?? null;
+                        for (const mm of (Array.isArray(rec.matches) ? rec.matches : [])) {
+                            const mr = asRecord(mm) ?? {};
+                            flat.push({ ...mr, id: mr.match_id, round: roundName, tournament_name: event.name, status: 'completed' });
+                        }
+                    }
+                    bouts = flat.slice(0, limit).map((row) => normalizeMatch('tennis', row));
+                    if (!bouts.length)
+                        warnings.push('No draw yet: the tournament has no archived results');
+                }
+                else {
+                    partial.push(partialFromRejection('bouts', {
+                        code: mapHttpToCode(draw.status),
+                        message: `tournament draw HTTP ${draw.status}`,
+                        httpStatus: draw.status,
+                    }));
+                }
+            }
+        }
         else {
             // dota2 — thin: tournament list + recent matches only
             warnings.push('Dota2 event_card is thin; expect partial bouts/standings');

package/dist/tools/live.js

@@ -323,12 +323,37 @@ Example: { "game": "all", "limitPerGame": 10 }`,
                     : undefined;
                 const supervisor = normalized.length === 0 && events.length ? slimUfcSupervisorEvents(events) : undefined;
                 const nextCard = normalized.length === 0 ? slimUfcNextCard(payload) : undefined;
+                // A one-word answer to "is anything wrong?". health{} is the worker's
+                // raw view and on an idle day it reads ok:false / workerAlive:false,
+                // which looks broken. state says what the board means: idle (nothing
+                // on, nothing due), live, stale (a hot card with a dead feed), or
+                // degraded. nextEvent tells an idle board what comes next, fetched
+                // only when the board is empty so a live night pays nothing for it.
+                const state = normalized.length > 0 ? 'live'
+                    : emptyReason === 'worker_stale' || emptyReason === 'worker_down_inferred' ? 'stale'
+                        : emptyReason === 'event_degraded' ? 'degraded'
+                            : 'idle';
+                let nextEvent;
+                if (state === 'idle') {
+                    const up = await fetchJson(ctx, '/ufc/events/upcoming', { query: { limit: 1 } });
+                    upstreamCalls += 1;
+                    const first = asRecord(extractRows(up.ok ? up.data : null)[0]);
+                    if (first) {
+                        nextEvent = {
+                            slug: pickString(first.slug) ?? null,
+                            name: pickString(first.title, first.name) ?? null,
+                            startsAt: pickString(first.startsAt, first.date, first.startTime) ?? null,
+                        };
+                    }
+                }
                 sections.push({
                     game,
                     count: normalized.length,
                     ok: true,
+                    state,
                     note,
                     emptyReason,
+                    nextEvent,
                     health: healthStrip,
                     supervisor,
                     nextCard,

package/dist/tools/match.js

@@ -3,7 +3,7 @@
  */
 import { extractRows, fetchJson, gameNotIncludedHint, asRecord, pickString, unwrapPayload, } from '../client.js';
 import { errorEnvelope, mapHttpToCode, newRequestId, partialFromRejection, successEnvelope, } from '../envelope.js';
-import { normalizeMatch } from './normalize.js';
+import { normalizeMatch, normalizeUfcMethod } from './normalize.js';
 import { boolSchema, gameSchema, isPrimaryGame, parseGame, stringSchema, } from './types.js';
 async function getSection(ctx, path, query) {
     return fetchJson(ctx, path, { query });
@@ -78,7 +78,10 @@ function matchCore(game, matchId, raw) {
         team2: m.team2,
         event: m.event,
         league: m.league,
-        method: pickString(r.method, r.resultMethod) ?? null,
+        // One enum on every surface. match_summary carried the source spelling
+        // here while the profile carried the enum, so consumers normalised anyway.
+        method: (game === 'ufc' ? normalizeUfcMethod(pickString(r.method, r.resultMethod)) : pickString(r.method, r.resultMethod)) ?? null,
+        methodRaw: pickString(r.method, r.resultMethod) ?? null,
         winner: (() => {
             // Never name a winner while play is in progress: the score fallback
             // below reads "who is ahead", which mid-match is a lead, not a result.

package/dist/tools/normalize.js

@@ -324,10 +324,12 @@ export function normalizeMatch(game, row, forcedStatus) {
         team2 = team2 ?? nestedSide(r.teams[1], game);
     }
     const startTime = pickString(r.startTime, r.scheduledAt, r.startsAt, r.date, r.startDate, r.beginAt, asRecord(r.event)?.startsAt, asRecord(r.event)?.startTime, asRecord(r.event)?.date) ?? null;
-    const statusRaw = pickString(r.status, r.state, r.matchStatus, r.boutStatus)?.toLowerCase() ?? '';
+    // Tennis archive rows carry the state as outcome (COMPLETED / RETIREMENT /
+    // WALKOVER); read it, or every finished match reported status unknown.
+    const statusRaw = pickString(r.status, r.state, r.matchStatus, r.boutStatus, r.outcome)?.toLowerCase() ?? '';
     let status = forcedStatus ?? 'unknown';
     if (!forcedStatus) {
-        const hasResult = Boolean(pickString(r.winnerFighterSlug, r.winnerSlug, r.winner, r.method, r.result)) ||
+        const hasResult = Boolean(pickString(r.winnerFighterSlug, r.winnerSlug, r.winner, r.winner_id, r.method, r.result)) ||
             r.resultRound != null ||
             r.isComplete === true ||
             r.completed === true;
@@ -348,7 +350,7 @@ export function normalizeMatch(game, row, forcedStatus) {
             status = 'live';
         else if (looksLive && !kickoffPassed)
             status = 'upcoming';
-        else if (/complete|finished|ended|final|closed|done|official|result/.test(statusRaw) || hasResult) {
+        else if (/complete|finished|ended|final|closed|done|official|result|retire|walkover|default/.test(statusRaw) || hasResult) {
             status = 'completed';
         }
         else if (/upcoming|scheduled|not_?started|unstarted|pending|soon|booked|confirmed|announced|tbd/.test(statusRaw) ||
@@ -374,7 +376,9 @@ export function normalizeMatch(game, row, forcedStatus) {
     // as a win in head_to_head's tally, which reads the scores.
     const historyOutcome = pickString(r.outcome)?.toLowerCase();
     const historyOpponent = pickString(asRecord(r.opponent)?.slug);
-    const resolvedWinnerSlug = pickString(r.winnerFighterSlug, r.winnerSlug, r.winner) ??
+    const resolvedWinnerSlug = 
+    // winner_id is the tennis archive's spelling; winner there is an object.
+    pickString(r.winnerFighterSlug, r.winnerSlug, r.winner, r.winner_id) ??
         (historyOutcome === 'win' && typeof r.fighterSlug === 'string' ? r.fighterSlug
             : historyOutcome === 'loss' && historyOpponent ? historyOpponent
                 : undefined);

package/dist/tools/player.js

@@ -457,7 +457,9 @@ Example: { "game": "cs2", "playerId": "cs2-player-1", "recentLimit": 10, "includ
                 if (res.ok) {
                     const metrics = unwrapPayload(res.data);
                     form = { summary: 'UFC fighter stats', trend: null, window: null, metrics };
-                    seasonStats = metrics;
+                    // form.metrics and seasonStats were the same object twice, byte
+                    // for byte. One copy. seasonStats stays for the games that have
+                    // seasons; a fighter has a career, not a season.
                 }
                 else {
                     partial.push(partialFromRejection('form', {
@@ -551,15 +553,25 @@ Example: { "game": "cs2", "playerId": "cs2-player-1", "recentLimit": 10, "includ
                     ...(player.slug ? { slug: player.slug } : {}),
                 },
             },
-            data: {
-                player,
-                currentTeam,
-                recentMatches,
-                form,
-                career,
-                radar,
-                seasonStats,
-            },
+            // Two rules, so a consumer can tell the difference. A field that can
+            // never apply to this game is OMITTED (a fighter has no team, no radar,
+            // no season). A field that applies but is unknown is NULL (division,
+            // flag). Sending team:null on every UFC profile forever said nothing.
+            data: game === 'ufc'
+                ? {
+                    player: (({ team, role, nationality, ...rest }) => { void team; void role; void nationality; return rest; })(player),
+                    recentMatches,
+                    form,
+                }
+                : {
+                    player,
+                    currentTeam,
+                    recentMatches,
+                    form,
+                    career,
+                    radar,
+                    seasonStats,
+                },
         });
     },
 };

package/dist/tools/standings.js

@@ -125,6 +125,7 @@ Example: { "game": "cod", "season": "2026", "limit": 50 }`,
             stage: stringSchema('Stage key (COD / LoL).'),
             division: stringSchema('UFC division key.'),
             limit: limitSchema({ default: 50, max: 100 }),
+            cursor: stringSchema('Opaque cursor from pagination.nextCursor. UFC world scope spans every division; page with it rather than raising limit.'),
         },
     },
     handler: async (args, ctx) => {
@@ -143,6 +144,9 @@ Example: { "game": "cod", "season": "2026", "limit": 50 }`,
         }
         const game = gameParse.game;
         const limit = clampInt(args.limit, 50, 1, 100);
+        // Cursor is a plain offset. The whole table is in memory (UFC world scope
+        // is 176 rows), so nothing fancier is needed to walk every division.
+        const offset = Math.max(0, Number.parseInt(String(args.cursor ?? '0'), 10) || 0);
         const scope = typeof args.scope === 'string' ? args.scope : undefined;
         const leagueId = typeof args.leagueId === 'string' ? args.leagueId : undefined;
         const tournamentId = typeof args.tournamentId === 'string' ? args.tournamentId : undefined;
@@ -321,7 +325,7 @@ Example: { "game": "cod", "season": "2026", "limit": 50 }`,
         // so limit=50 stops a third of the way through flyweight; a consumer needs
         // to know that happened rather than receive total:null and guess.
         let allRows = extractRows(res.data).map((row, i) => normalizeStandingRow(row, i));
-        let rows = allRows.slice(0, limit);
+        let rows = allRows.slice(offset, offset + limit);
         // UFC rankings may be nested by division
         if (game === 'ufc' && rows.length === 0) {
             const obj = asRecord(res.data) ?? {};
@@ -334,8 +338,29 @@ Example: { "game": "cod", "season": "2026", "limit": 50 }`,
                 }
             }
             allRows = nested.map((row, i) => normalizeStandingRow(row, i));
-            rows = allRows.slice(0, limit);
+            rows = allRows.slice(offset, offset + limit);
         }
+        if (game === 'ufc') {
+            rows = rows.map((row) => {
+                const { played, wins, losses, draws, points, mapDiff, streak, ...rest } = row;
+                void played;
+                void wins;
+                void losses;
+                void draws;
+                void points;
+                void mapDiff;
+                void streak;
+                return rest;
+            });
+        }
+        const standingsPagination = {
+            limit,
+            offset,
+            total: allRows.length,
+            hasMore: offset + rows.length < allRows.length,
+            nextCursor: offset + rows.length < allRows.length ? String(offset + rows.length) : null,
+            prevCursor: offset > 0 ? String(Math.max(0, offset - limit)) : null,
+        };
         const obj = asRecord(res.data);
         const upstreamMeta = asRecord(obj?.meta) ?? {};
         const dataQuality = asRecord(upstreamMeta.dataQuality) ?? {};
@@ -364,6 +389,7 @@ Example: { "game": "cod", "season": "2026", "limit": 50 }`,
                 : 'Rankings dataFreshness=cached or stale.');
         }
         return successEnvelope({
+            pagination: standingsPagination,
             source: 'standings',
             game,
             requestId,

package/dist/tools/team.js

@@ -920,6 +920,9 @@ Example: { "game": "cs2", "sideA": "faze", "sideB": "navi", "limit": 20 }`,
         }
         const meetings = rows
             .map((row) => normalizeMatch(game, row))
+            // Past fights only. The booked bout between the two sides is in the
+            // same list and is not a meeting yet.
+            .filter((m) => m.status === 'completed')
             .filter((m) => sidesMatch(m, matchA, matchB))
             .filter((m) => {
             if (!fromIso && !toIso)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cito-mcp",
-  "version": "0.3.13",
+  "version": "0.3.15",
   "description": "Standalone MCP server for the Cito esports API \u2014 15 curated outcome tools for agents (live, schedule, profiles, standings, previews, event cards).",
   "type": "module",
   "bin": {