cito-mcp 0.5.4 → 0.5.6

package/README.md

@@ -550,6 +550,19 @@ claude mcp add cito -e CITO_API_KEY=cito_… "--" npx -y cito-mcp
 
 ## Changelog (summary)
 
+### 0.5.6
+
+- **Tennis `event_card` draw is a real bracket** (customer audit 2026-11-03). `draw.complete` is true only when every main round to the Final is played (it said true beside `missingRounds` F/SF/QF); every main round is listed with `status` (`completed` / `in_progress` / `not_started` / `incomplete_archive`), `expected` (byes excluded: a 56 draw's R64 holds 24), `byes`, `walkovers`, and `pending` (scheduled / live matches, never presented as results). `drawSize` is the real field (Paris 56, `drawSizeSource`, `bracketSize`, `byes`); `matchesExpected` counts the main draw and is compared with `mainDrawMatchesReturned` (qualifying is reported apart). Each bout carries `winnerId` / `loserId` / `outcome` (a "6-3 6-7 RET" retirement says who won), `startTime`, `nextMatchId` (the bracket edge) and `bracketPosition`; rounds report `included` / `omitted` when `drawMaxMatches` trims them.
+- **Tennis `head_to_head` honours `limit`**: it is sent to `/tennis/h2h`, which pages the meetings while every tally still covers all of them (`meetingsReturned` / `meetingsTotal`; the H2H `level_breakdown` now always sums to `total_matches`).
+- Other tennis audit fixes in the same release: live stats as structured numerator / denominator / pct, `isSimulated` / `liveFeed` on live rows, `setNumber` from `set_number`, and the schedule / rankings / player readers updated for the API changes of 2026-11-03.
+
+### 0.5.5
+
+- **`cs2_veto_sequence` returns the veto.** It called the match head-to-head route and answered with the two teams' head-to-head record (`cs2_team_h2h`) instead of the veto (0.5.1 to 0.5.4). It now calls `/cs2/matches/{matchId}/veto`: `vetoOrder` (every ban, pick and the decider, in order), `vetoStatus` (`complete`, `pending`, `forfeit_no_veto`, `unavailable`), `bestOf` and the maps.
+- **`cs2_opening_duels` with `playerId` works.** It called a route the API does not have (every call was a 404). A player's opening duels now come from the career totals: `openingKills` / `openingDeaths` (null when fewer than 90% of the player's maps record them), the recorded sums, coverage and success rate.
+- **`cs2_team_map_stats` takes `opponentId`** for a map-by-map comparison of two teams (`/cs2/teams/{team}/map-pool/vs/{opponent}`: win rates, round difference, pick/ban/decider rates, their meetings per map, edge). Map rows carry `inPool` / `poolStatus`.
+- `cs2_round_economy` points to `/cs2/maps/{mapId}/economy` for per-player money each round.
+
 ### 0.5.4
 
 - **Apex Legends through `call_api`.** `/apex/...` paths (ALGS events, standings, scores) were refused with `PATH_NOT_ALLOWED` although they are a live REST product. They are allowed now and listed in `list_capabilities`.

package/dist/tools/cs2.js

@@ -59,7 +59,8 @@ export const cs2LiveScoreboard = {
 };
 export const cs2RoundEconomy = {
     name: 'cs2_round_economy',
-    description: 'Round-by-round tactical economy for a CS2 map. Classifies every round buy type (Full Buy, Force Buy, Semi-Eco, Full Eco), team equipment spend, freeze-time equipment values, and loss bonus counter.',
+    description: 'Round-by-round tactical economy for a CS2 map. Classifies every round buy type (Full Buy, Force Buy, Semi-Eco, Full Eco), team equipment spend, freeze-time equipment values, and loss bonus counter. '
+        + 'For money per PLAYER each round (startMoney, moneySpent, moneyLeft, equipmentValue, buyType, purchases) use call_api GET /cs2/maps/{mapId}/economy (by=player|team|round; paid plans).',
     inputSchema: {
         type: 'object',
         properties: {
@@ -123,9 +124,9 @@ export const cs2OpeningDuels = {
         const rawPlayer = typeof args.playerId === 'string' ? args.playerId.trim() : '';
         const limit = clampInt(args.limit, 20, 1, 100);
         const path = rawPlayer
-            ? `/cs2/players/${encodeURIComponent(rawPlayer)}/opening-duels`
+            ? `/cs2/players/${encodeURIComponent(rawPlayer)}/career`
             : `/cs2/stats/opening-duels`;
-        const res = await fetchJson(ctx, path, { query: { limit } });
+        const res = await fetchJson(ctx, path, rawPlayer ? {} : { query: { limit } });
         if (!res.ok) {
             return errorEnvelope({
                 code: mapHttpToCode(res.status),
@@ -137,8 +138,29 @@ export const cs2OpeningDuels = {
             });
         }
         const payload = unwrap(res.data);
+        let data = payload;
+        if (rawPlayer) {
+            const p = asRecord(payload) ?? {};
+            const t = asRecord(p.totals) ?? {};
+            const fk = typeof t.openingKillsRecorded === 'number' ? t.openingKillsRecorded : null;
+            const fd = typeof t.openingDeathsRecorded === 'number' ? t.openingDeathsRecorded : null;
+            data = {
+                entityType: 'cs2_player_opening_duels',
+                playerId: p.playerId ?? null,
+                playerNickname: p.playerNickname ?? null,
+                maps: t.maps ?? null,
+                openingKills: t.openingKills ?? null,
+                openingDeaths: t.openingDeaths ?? null,
+                openingKillsRecorded: fk,
+                openingDeathsRecorded: fd,
+                openingDuelMaps: t.openingDuelMaps ?? null,
+                openingDuelCoverage: t.openingDuelCoverage ?? null,
+                openingDuelSuccessRate: fk !== null && fd !== null && fk + fd > 0 ? Math.round((fk / (fk + fd)) * 10000) / 10000 : null,
+                source: `/cs2/players/${rawPlayer}/career`,
+            };
+        }
         return successEnvelope({
-            data: payload,
+            data,
             game: 'cs2',
             source: 'cs2_opening_duels',
             requestId: reqId,
@@ -188,16 +210,18 @@ export const cs2Clutches = {
 };
 export const cs2TeamMapStats = {
     name: 'cs2_team_map_stats',
-    description: 'Team win rates, round win rates, and CT/T side win splits across the competitive map pool (Mirage, Inferno, Nuke, Dust2, Ancient, Anubis, Vertigo) over the last 30 or 90 days.',
+    description: 'Team win rates, round win rates, and CT/T side win splits per map over the last N days. Each map carries inPool / poolStatus (current Active Duty pool) and removedAt. '
+        + 'Pass opponentId to compare two teams map by map instead (GET /cs2/teams/{team}/map-pool/vs/{opponent}): win rates, round difference, pick/ban/decider rates, their meetings on each map and an edge per map.',
     inputSchema: {
         type: 'object',
         properties: {
             teamId: stringSchema('Team ID or slug (e.g. "cs2-team-4608" or "natus-vincere"). Required.', 'cs2-team-4608'),
             days: {
                 type: 'integer',
-                description: 'Timeframe in days: 30, 90, 180, or 365 (default 90).',
+                description: 'Timeframe in days: 30, 90, 180, or 365 (default 90; with opponentId the API default is 180).',
                 default: 90,
             },
+            opponentId: stringSchema('Optional opponent team ID or slug (e.g. "mouz"): returns the map-pool head-to-head of the two teams.', 'mouz'),
         },
         required: ['teamId'],
         additionalProperties: false,
@@ -215,9 +239,12 @@ export const cs2TeamMapStats = {
                 requestId: reqId,
             });
         }
-        const days = typeof args.days === 'number' ? args.days : 90;
-        const path = `/cs2/teams/${encodeURIComponent(rawTeam)}/map-stats`;
-        const res = await fetchJson(ctx, path, { query: { days } });
+        const rawOpponent = typeof args.opponentId === 'string' ? args.opponentId.trim() : '';
+        const days = typeof args.days === 'number' ? args.days : rawOpponent ? undefined : 90;
+        const path = rawOpponent
+            ? `/cs2/teams/${encodeURIComponent(rawTeam)}/map-pool/vs/${encodeURIComponent(rawOpponent)}`
+            : `/cs2/teams/${encodeURIComponent(rawTeam)}/map-stats`;
+        const res = await fetchJson(ctx, path, days === undefined ? {} : { query: { days } });
         if (!res.ok) {
             return errorEnvelope({
                 code: mapHttpToCode(res.status),
@@ -276,7 +303,8 @@ export const cs2UtilityLeaderboard = {
 };
 export const cs2VetoSequence = {
     name: 'cs2_veto_sequence',
-    description: 'Map pick/ban veto sequence for a CS2 match. Shows which team banned which map, map picks, and decider map in chronological order.',
+    description: 'Map pick/ban veto sequence for a CS2 match (GET /cs2/matches/{matchId}/veto). Returns vetoOrder (each ban, pick and the decider in order, with the team), '
+        + 'vetoStatus (complete | pending | forfeit_no_veto | unavailable; vetoOrder is [] unless complete), bestOf and the maps.',
     inputSchema: {
         type: 'object',
         properties: {
@@ -298,8 +326,7 @@ export const cs2VetoSequence = {
                 requestId: reqId,
             });
         }
-        const cleanId = rawId.replace(/^cs2-match-/, '');
-        const path = `/cs2/matches/${encodeURIComponent(cleanId)}/head-to-head`;
+        const path = `/cs2/matches/${encodeURIComponent(rawId)}/veto`;
         const res = await fetchJson(ctx, path);
         if (!res.ok) {
             return errorEnvelope({
@@ -312,10 +339,8 @@ export const cs2VetoSequence = {
             });
         }
         const payload = unwrap(res.data);
-        const r = asRecord(payload);
-        const veto = r?.veto ?? r?.vetoSequence ?? payload;
         return successEnvelope({
-            data: veto,
+            data: payload,
             game: 'cs2',
             source: 'cs2_veto_sequence',
             requestId: reqId,

package/dist/tools/insight.js

@@ -260,20 +260,20 @@ export function composeH2H(game, sideA, sideB, rows, limit) {
 }
 export const matchPreview = {
     name: 'match_preview',
-    description: `COMPOSITE pre-match briefing: sides, roster/form snippets, H2H stub, event context — for pick'ems, articles, and match-page before state.
-
-When to use:
-- Upcoming match deep link
-- "Who should I watch before this game?"
-- App scaffold for preview cards
-
-Prefer over: manually chaining team_profile ×2 + head_to_head + schedule.
-Prefer match_summary when match is completed; match_details for live in-game.
-
-Do not use when: user wants final score/recap of a finished match.
-
-Parallel-safe: yes. Upstream cost: 4–8.
-Tennis H2H accepts an optional surface filter (Hard, Clay, Grass).
+    description: `COMPOSITE pre-match briefing: sides, roster/form snippets, H2H stub, event context — for pick'ems, articles, and match-page before state.
+
+When to use:
+- Upcoming match deep link
+- "Who should I watch before this game?"
+- App scaffold for preview cards
+
+Prefer over: manually chaining team_profile ×2 + head_to_head + schedule.
+Prefer match_summary when match is completed; match_details for live in-game.
+
+Do not use when: user wants final score/recap of a finished match.
+
+Parallel-safe: yes. Upstream cost: 4–8.
+Tennis H2H accepts an optional surface filter (Hard, Clay, Grass).
 Example: { "game": "lol", "teamA": "t1", "teamB": "gen-g", "includeH2H": true, "recentLimit": 5 }`,
     inputSchema: {
         type: 'object',
@@ -707,31 +707,37 @@ async function resolveEventKey(ctx, game, q) {
 }
 export const eventCard = {
     name: 'event_card',
-    description: `COMPOSITE event / fight-night card: identity, bout or match list, optional standings snippet.
-
-When to use:
-- UFC fight night / numbered event page ("UFC 300 card", "Fight Night")
-- CS2 event hub with match list
-- Tournament/event overview before match_preview drill-down
-
-Bouts come back in card order — main event first, then prelims, then early prelims.
-Each bout carries weightClass, titleBout, card placement, and (once fought) result
-{ method, round, time, referee, winnerSlug }. Each corner carries images
-{ headshotUrl, bodyImageUrl, imageUrl, proxiedImageUrl }, record, nickname, rank,
-championStatus, country and flag when upstream supplies them. Use proxiedImageUrl in
-browsers — the image host sends no CORS header. You do not need call_api per fighter for faces.
-
-Prefer over: agent-side resolve + call_api /ufc/events + bout expansion; N+1 match_summary for the card list only; per-fighter call_api just to fetch headshots.
-
-Prefer match_preview for one bout/match briefing; match_summary for completed recaps; live_matches for live-only strips; standings alone for pure tables.
-
-Do not use when: you only need live scores (live_matches); single finished match recap (match_summary); no event name/id yet and game unknown.
-
-Tennis: pass a tournament id/slug to get the draw bracket — rounds carry a round
-code (Q1..R128, QF, SF, F) with each match's players and score. Set is the
-primary tennis path here; there is no separate draw tool.
-
-Parallel-safe: yes. Upstream cost: 1–4.
+    description: `COMPOSITE event / fight-night card: identity, bout or match list, optional standings snippet.
+
+When to use:
+- UFC fight night / numbered event page ("UFC 300 card", "Fight Night")
+- CS2 event hub with match list
+- Tournament/event overview before match_preview drill-down
+
+Bouts come back in card order — main event first, then prelims, then early prelims.
+Each bout carries weightClass, titleBout, card placement, and (once fought) result
+{ method, round, time, referee, winnerSlug }. Each corner carries images
+{ headshotUrl, bodyImageUrl, imageUrl, proxiedImageUrl }, record, nickname, rank,
+championStatus, country and flag when upstream supplies them. Use proxiedImageUrl in
+browsers — the image host sends no CORS header. You do not need call_api per fighter for faces.
+
+Prefer over: agent-side resolve + call_api /ufc/events + bout expansion; N+1 match_summary for the card list only; per-fighter call_api just to fetch headshots.
+
+Prefer match_preview for one bout/match briefing; match_summary for completed recaps; live_matches for live-only strips; standings alone for pure tables.
+
+Do not use when: you only need live scores (live_matches); single finished match recap (match_summary); no event name/id yet and game unknown.
+
+Tennis: pass a tournament id/slug to get the draw bracket — every main round from
+the first to the Final (status completed / in_progress / not_started), then
+qualifying (Q1..Q3). Each result carries winnerId/loserId/outcome (retirements
+included), startTime (null with startTimeUnavailableReason when the source has no
+clock), nextMatchId (the bracket edge) and bracketPosition; scheduled and live
+matches sit in rounds[].pending. draw carries drawSize (real field size, byes
+excluded, e.g. 56), byes, matchesExpected (main draw) and complete (true only
+when every main round to the Final is played). This is the primary tennis path
+here; there is no separate draw tool.
+
+Parallel-safe: yes. Upstream cost: 1–4.
 Example: { "game": "ufc", "eventIdOrSlug": "ufc-300", "includeMatches": true, "includeStandings": false }`,
     inputSchema: {
         type: 'object',
@@ -1245,9 +1251,74 @@ Example: { "game": "ufc", "eventIdOrSlug": "ufc-300", "includeMatches": true, "i
                     const dd = asRecord(unwrapPayload(draw.data)) ?? {};
                     const rawRounds = Array.isArray(dd.rounds) ? dd.rounds : [];
                     const drawSize = typeof dd.draw_size === 'number' ? dd.draw_size : null;
+                    const apiSummary = asRecord(dd.summary);
+                    const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null);
                     const flat = [];
                     let budget = drawMaxMatches ?? Number.POSITIVE_INFINITY;
                     let omittedMatches = 0;
+                    const drawMatch = (mr, roundName) => {
+                        const p1 = asRecord(mr.player1);
+                        const p2 = asRecord(mr.player2);
+                        const winnerId = pickString(mr.winner_id) ??
+                            (p1?.is_winner === true ? pickString(p1?.id) : p2?.is_winner === true ? pickString(p2?.id) : undefined) ??
+                            null;
+                        const loserId = pickString(mr.loser_id) ??
+                            (winnerId && winnerId === pickString(p1?.id) ? pickString(p2?.id) : winnerId ? pickString(p1?.id) : undefined) ??
+                            null;
+                        const row = {
+                            ...mr,
+                            id: mr.match_id,
+                            round: roundName,
+                            tournament_name: event.name,
+                            status: 'completed',
+                            startTime: pickString(mr.start_time) ?? null,
+                        };
+                        flat.push(row);
+                        return presentSides({
+                            ...normalizeMatch('tennis', row),
+                            startTime: pickString(mr.start_time) ?? null,
+                            score: pickString(mr.score) ?? null,
+                            matchNum: typeof mr.match_num === 'number' ? mr.match_num : null,
+                            winnerId,
+                            loserId,
+                            outcome: pickString(mr.outcome) ?? null,
+                            resultStatus: pickString(mr.status) ?? 'completed',
+                            matchDate: pickString(mr.match_date) ?? null,
+                            startTimeKnown: mr.start_time_known === true,
+                            ...(pickString(mr.start_time_unavailable_reason)
+                                ? { startTimeUnavailableReason: pickString(mr.start_time_unavailable_reason) }
+                                : {}),
+                            nextMatchId: pickString(mr.next_match_id) ?? null,
+                            ...(pickString(mr.next_match_source) ? { nextMatchSource: pickString(mr.next_match_source) } : {}),
+                            bracketPosition: num(mr.bracket_position),
+                            nextSlot: asRecord(mr.next_slot)
+                                ? {
+                                    roundCode: pickString(asRecord(mr.next_slot)?.round_code) ?? null,
+                                    position: num(asRecord(mr.next_slot)?.position),
+                                }
+                                : null,
+                            ...(pickString(mr.source_round) ? { sourceRound: pickString(mr.source_round) } : {}),
+                        }, 'tennis');
+                    };
+                    const pendingMatch = (pr) => {
+                        const side = (v) => {
+                            const s = asRecord(v) ?? {};
+                            return { id: pickString(s.id) ?? null, name: pickString(s.name) ?? null, seed: s.seed ?? null };
+                        };
+                        return {
+                            matchId: pickString(pr.match_id) ?? null,
+                            status: pickString(pr.status) ?? null,
+                            player1: side(pr.player1),
+                            player2: side(pr.player2),
+                            startTime: pickString(pr.start_time) ?? null,
+                            startTimeKnown: pr.start_time_known === true,
+                            liveScore: pickString(pr.live_score) ?? null,
+                            winnerId: null,
+                            ...(pickString(pr.source_winner_id) ? { sourceWinnerId: pickString(pr.source_winner_id) } : {}),
+                            nextMatchId: pickString(pr.next_match_id) ?? null,
+                            bracketPosition: num(pr.bracket_position),
+                        };
+                    };
                     drawRounds = rawRounds.map((rr) => {
                         const rec = asRecord(rr) ?? {};
                         const roundCode = pickString(rec.round_code, rec.roundCode) ?? null;
@@ -1256,58 +1327,100 @@ Example: { "game": "ufc", "eventIdOrSlug": "ufc-300", "includeMatches": true, "i
                         const kept = all.slice(0, Math.max(0, budget));
                         omittedMatches += all.length - kept.length;
                         budget -= kept.length;
-                        const matches = kept.map((mm) => {
-                            const mr = asRecord(mm) ?? {};
-                            const row = { ...mr, id: mr.match_id, round: roundName, tournament_name: event.name, status: 'completed' };
-                            flat.push(row);
-                            return presentSides({
-                                ...normalizeMatch('tennis', row),
-                                score: pickString(mr.score) ?? null,
-                                matchNum: typeof mr.match_num === 'number' ? mr.match_num : null,
-                                nextMatchId: pickString(mr.next_match_id) ?? null,
-                            }, 'tennis');
-                        });
+                        const matches = kept.map((mm) => drawMatch(asRecord(mm) ?? {}, roundName));
+                        const pendingRaw = Array.isArray(rec.pending_matches) ? rec.pending_matches : [];
+                        const expected = num(rec.expected_matches) ?? expectedMatchesForRound(roundCode, drawSize);
+                        const apiStatus = pickString(rec.status) ?? null;
                         return {
                             roundCode,
                             roundName,
                             matches,
+                            pending: pendingRaw.map((p) => pendingMatch(asRecord(p) ?? {})),
                             returned: all.length,
-                            expected: expectedMatchesForRound(roundCode, drawSize),
-                            complete: (() => {
-                                const expected = expectedMatchesForRound(roundCode, drawSize);
-                                return expected === null ? null : all.length >= expected;
-                            })(),
+                            included: kept.length,
+                            omitted: all.length - kept.length,
+                            expected,
+                            byes: num(rec.byes),
+                            walkovers: num(rec.walkovers),
+                            status: apiStatus ?? (all.length === 0 ? 'not_started' : expected !== null && all.length >= expected ? 'completed' : 'in_progress'),
+                            complete: typeof rec.complete === 'boolean' ? rec.complete : expected === null ? null : all.length >= expected,
+                            isQualifying: rec.is_qualifying === true || /^Q\d?$/.test(roundCode ?? ''),
                         };
                     });
-                    bouts = flat.slice(0, limit).map((row) => normalizeMatch('tennis', row));
-                    if (!bouts.length)
-                        warnings.push('No draw yet: the tournament has no archived results');
-                    const expectedTotal = drawRounds.reduce((sum, r) => sum + (r.expected ?? 0), 0);
+                    bouts = flat.slice(0, limit).map((row) => {
+                        const n = normalizeMatch('tennis', row);
+                        const r = row;
+                        const p1 = asRecord(r.player1);
+                        const p2 = asRecord(r.player2);
+                        return {
+                            ...n,
+                            startTime: pickString(r.start_time) ?? null,
+                            winnerId: pickString(r.winner_id) ?? (p1?.is_winner === true ? pickString(p1?.id) : p2?.is_winner === true ? pickString(p2?.id) : undefined) ?? null,
+                            loserId: pickString(r.loser_id) ?? null,
+                            outcome: pickString(r.outcome) ?? null,
+                            nextMatchId: pickString(r.next_match_id) ?? null,
+                        };
+                    });
+                    if (!bouts.length) {
+                        const anyPending = drawRounds.some((r) => r.pending.length > 0);
+                        warnings.push(anyPending
+                            ? 'No results yet: every match of this draw is still scheduled or in progress (see draw.rounds[].pending)'
+                            : 'No draw yet: the tournament has no archived results');
+                    }
+                    const mainRounds = drawRounds.filter((r) => !r.isQualifying);
+                    const expectedTotalLocal = drawRounds.reduce((sum, r) => sum + (r.expected ?? 0), 0);
                     const returnedTotal = drawRounds.reduce((sum, r) => sum + r.returned, 0);
+                    const mainReturned = mainRounds.reduce((sum, r) => sum + r.returned, 0);
                     const shortRounds = drawRounds
-                        .filter((r) => r.complete === false)
+                        .filter((r) => r.complete === false && r.status !== 'not_started')
                         .map((r) => `${r.roundCode ?? r.roundName ?? '?'} ${r.returned}/${r.expected}`);
                     const haveCodes = new Set(drawRounds.map((r) => (r.roundCode ?? '').toUpperCase()));
-                    const missingRounds = ['F', 'SF', 'QF']
-                        .filter((c) => !haveCodes.has(c))
-                        .filter((c) => !(c === 'F' && shortRounds.length > 0 && drawSize !== null && returnedTotal < drawSize / 2));
+                    const missingRounds = ['F', 'SF', 'QF'].filter((c) => !haveCodes.has(c));
+                    const roundsNotStarted = mainRounds.filter((r) => r.status === 'not_started').map((r) => r.roundCode);
+                    const roundsInProgress = mainRounds.filter((r) => r.status === 'in_progress').map((r) => r.roundCode);
+                    const roundsIncompleteArchive = mainRounds
+                        .filter((r) => r.status === 'incomplete_archive')
+                        .map((r) => r.roundCode);
+                    const matchesExpected = num(apiSummary?.main_draw_matches_expected) ?? (expectedTotalLocal || null);
+                    const complete = typeof apiSummary?.complete === 'boolean'
+                        ? apiSummary.complete &&
+                            shortRounds.length === 0 &&
+                            missingRounds.length === 0 &&
+                            roundsNotStarted.length === 0
+                        : matchesExpected !== null &&
+                            mainReturned >= matchesExpected &&
+                            shortRounds.length === 0 &&
+                            missingRounds.length === 0;
+                    if (drawSize !== null && event.drawSize !== drawSize) {
+                        event = { ...event, drawSizeRecorded: event.drawSize ?? null, drawSize };
+                    }
                     drawSummary = {
                         drawSize,
+                        drawSizeSource: pickString(dd.draw_size_source) ?? null,
+                        bracketSize: num(dd.bracket_size),
+                        byes: num(dd.byes),
                         roundCount: drawRounds.length,
+                        status: pickString(apiSummary?.status) ?? (complete ? 'completed' : returnedTotal ? 'in_progress' : 'not_started'),
                         matchesReturned: returnedTotal,
-                        matchesExpected: expectedTotal || null,
-                        complete: expectedTotal > 0 ? returnedTotal >= expectedTotal : null,
+                        mainDrawMatchesReturned: mainReturned,
+                        qualifyingMatchesReturned: returnedTotal - mainReturned,
+                        matchesExpected,
+                        matchesPending: drawRounds.reduce((sum, r) => sum + r.pending.length, 0),
+                        complete,
                         shortRounds,
                         missingRounds,
+                        roundsNotStarted,
+                        roundsInProgress,
+                        roundsIncompleteArchive,
                         totalMatchesInCard: flat.length,
                         returnedInBouts: bouts.length,
                         truncated: omittedMatches > 0,
                         omittedMatches,
                         maxMatches: drawMaxMatches,
-                        note: 'matchesReturned counts what the archive holds for this tournament; matchesExpected counts a full draw of drawSize. shortRounds names every round that is short, and missingRounds names a round the bracket should contain but does not.',
+                        note: 'matchesExpected counts the MAIN draw (byes excluded) and is compared with mainDrawMatchesReturned; matchesReturned also counts qualifying. Per round: returned = archived results, included = how many of them this response carries (drawMaxMatches), pending = scheduled / in-progress matches. complete is true only when every main round to the Final is completed.',
                     };
                     if (shortRounds.length) {
-                        warnings.push(`Draw is partial: ${shortRounds.join(', ')}. The archive does not hold every match of this tournament yet.`);
+                        warnings.push(`Draw is partial: ${shortRounds.join(', ')}. ${roundsInProgress.length ? 'The tournament is in progress.' : 'The archive does not hold every match of this tournament yet.'}`);
                     }
                     if (omittedMatches > 0) {
                         warnings.push(`drawMaxMatches=${drawMaxMatches} dropped ${omittedMatches} early-round match(es) from draw.rounds; raise or omit it for the complete bracket.`);

package/dist/tools/match.js

@@ -139,6 +139,14 @@ function matchCore(game, matchId, raw) {
                 },
             }
             : {}),
+        ...(game === 'tennis'
+            ? {
+                canonicalId: pickString(r.canonical_id, r.id, r.match_id) ?? null,
+                tournamentDisplayName: pickString(r.tournament_display_name, asRecord(r.tournament)?.display_name, r.tournament_name) ?? null,
+                resultAvailable: typeof r.result_available === 'boolean' ? r.result_available : Boolean(pickString(r.winner_id)),
+                resultUnavailableReason: pickString(r.result_unavailable_reason) ?? null,
+            }
+            : {}),
     };
     return core;
 }
@@ -163,18 +171,18 @@ function primaryPath(game, matchId) {
 }
 export const matchSummary = {
     name: 'match_summary',
-    description: `COMPOSITE match card: scoreline, key context, player performances, and VOD/demo links when available.
-
-When to use:
-- Match recap / default match UI
-- After user selects a live or completed matchId
-
-Prefer over match_details for chat answers and default UIs.
-Prefer match_details for timelines, full map trees, live state, advanced packages.
-
-Do not use when: no matchId yet (resolve from live/schedule); pure pre-match → match_preview.
-
-Parallel-safe: yes. Upstream cost: 2–5.
+    description: `COMPOSITE match card: scoreline, key context, player performances, and VOD/demo links when available.
+
+When to use:
+- Match recap / default match UI
+- After user selects a live or completed matchId
+
+Prefer over match_details for chat answers and default UIs.
+Prefer match_details for timelines, full map trees, live state, advanced packages.
+
+Do not use when: no matchId yet (resolve from live/schedule); pure pre-match → match_preview.
+
+Parallel-safe: yes. Upstream cost: 2–5.
 Example: { "game": "cs2", "matchId": "cs2-match-123", "view": "summary", "includePlayerStats": true }`,
     inputSchema: {
         type: 'object',
@@ -331,7 +339,7 @@ Example: { "game": "cs2", "matchId": "cs2-match-123", "view": "summary", "includ
                     const p1g = typeof sr.player1_games === 'number' ? sr.player1_games : null;
                     const p2g = typeof sr.player2_games === 'number' ? sr.player2_games : null;
                     return {
-                        setNumber: typeof sr.set_num === 'number' ? sr.set_num : typeof sr.set_number === 'number' ? sr.set_number : null,
+                        setNumber: typeof sr.set_number === 'number' ? sr.set_number : typeof sr.set_num === 'number' ? sr.set_num : null,
                         score: pickString(sr.score) ?? (p1g != null && p2g != null ? `${p1g}-${p2g}` : null),
                         player1Games: p1g,
                         player2Games: p2g,
@@ -558,10 +566,27 @@ export function summarizeTennisMatchStats(data) {
     const stats = asRecord(payload.stats);
     const sets = Array.isArray(payload.sets) ? payload.sets : [];
     const toNum = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null);
+    const liveRows = Array.isArray(payload.stats) ? payload.stats.map((x) => asRecord(x) ?? {}) : null;
+    const liveStats = liveRows
+        ? liveRows.map((r) => ({
+            side: toNum(r.side),
+            key: pickString(r.key) ?? null,
+            name: pickString(r.name) ?? null,
+            category: pickString(r.category) ?? null,
+            kind: pickString(r.kind) ?? null,
+            numerator: toNum(r.numerator),
+            denominator: toNum(r.denominator),
+            pct: toNum(r.pct),
+            display: pickString(r.display) ?? null,
+        }))
+        : null;
     return {
         matchId: pickString(payload.match_id) ?? null,
         score: pickString(payload.score) ?? null,
-        sidesKeyedBy: 'outcome',
+        sidesKeyedBy: liveStats ? 'side' : 'outcome',
+        ...(liveStats ? { liveStats } : {}),
+        statsAvailable: typeof payload.stats_available === 'boolean' ? payload.stats_available : null,
+        statsUnavailableCode: pickString(payload.stats_unavailable_code) ?? null,
         players: stats
             ? {
                 winner: asRecord(stats.winner) ?? null,
@@ -571,7 +596,7 @@ export function summarizeTennisMatchStats(data) {
         sets: sets.map((s) => {
             const sr = asRecord(s) ?? {};
             return {
-                setNumber: toNum(sr.set_num) ?? toNum(sr.set_number),
+                setNumber: toNum(sr.set_number) ?? toNum(sr.set_num),
                 winnerGames: toNum(sr.winner_games),
                 loserGames: toNum(sr.loser_games),
                 player1Games: toNum(sr.player1_games),
@@ -586,23 +611,23 @@ export function summarizeTennisMatchStats(data) {
 }
 export const matchDetails = {
     name: 'match_details',
-    description: `Deep match package: optional timelines, advanced stats, live state/snapshots, full map/game tree, media inventory.
-
-When to use:
-- Analyst deep dive
-- Live in-game window (LoL/CS2/UFC)
-- Full demo list
-
-Prefer over match_summary only when summary is insufficient.
-Prefer match_summary for short answers and default cards.
-
-Do not use when: first-pass live board (use live_matches + match_summary).
-
-Section selection: pass includeTimeline / includeLiveState / includeAdvanced booleans, OR an explicit sections[] list.
-UFC betting lines: sections:["odds"] (opt-in, never in the default set).
-If sections[] is non-empty it wins (booleans are ignored). LoL liveState/advanced require gameId.
-
-Parallel-safe: yes. Upstream cost: 1–8 (section-gated).
+    description: `Deep match package: optional timelines, advanced stats, live state/snapshots, full map/game tree, media inventory.
+
+When to use:
+- Analyst deep dive
+- Live in-game window (LoL/CS2/UFC)
+- Full demo list
+
+Prefer over match_summary only when summary is insufficient.
+Prefer match_summary for short answers and default cards.
+
+Do not use when: first-pass live board (use live_matches + match_summary).
+
+Section selection: pass includeTimeline / includeLiveState / includeAdvanced booleans, OR an explicit sections[] list.
+UFC betting lines: sections:["odds"] (opt-in, never in the default set).
+If sections[] is non-empty it wins (booleans are ignored). LoL liveState/advanced require gameId.
+
+Parallel-safe: yes. Upstream cost: 1–8 (section-gated).
 Example: { "game": "lol", "matchId": "lol-match-1", "includeTimeline": true, "includeLiveState": false }`,
     inputSchema: {
         type: 'object',

package/dist/tools/normalize.js

@@ -136,7 +136,7 @@ function imagesFrom(game, ...sources) {
         headshotUrl: pick('headshotUrl', 'headshot', 'portrait_url'),
         bodyImageUrl: pick('bodyImageUrl', 'fullBodyImageUrl'),
         imageUrl: pick('imageUrl', 'image', 'photoUrl', 'logoUrl', 'logo', 'portrait_url'),
-        proxiedImageUrl: pick('proxiedImageUrl', 'proxiedHeadshotUrl'),
+        proxiedImageUrl: pick('proxiedImageUrl', 'proxiedHeadshotUrl', 'proxied_image_url'),
     };
     if (!images.proxiedImageUrl) {
         images.proxiedImageUrl =
@@ -508,7 +508,7 @@ export function normalizeMatch(game, row, forcedStatus) {
             const p1g = numOrNull(sr.player1_games);
             const p2g = numOrNull(sr.player2_games);
             return {
-                setNumber: numOrNull(sr.set_num) ?? numOrNull(sr.set_number),
+                setNumber: numOrNull(sr.set_number) ?? numOrNull(sr.set_num),
                 score: pickString(sr.score) ?? (p1g !== null && p2g !== null ? `${p1g}-${p2g}` : null),
                 player1Games: p1g,
                 player2Games: p2g,
@@ -557,6 +557,9 @@ export function normalizeMatch(game, row, forcedStatus) {
         ...(tennisSets
             ? { sets: tennisSets, gameScore: tennisGameScore, server: tennisServer, currentSet: tennisCurrentSet }
             : {}),
+        ...(game === 'tennis' && typeof r.is_simulated === 'boolean'
+            ? { isSimulated: r.is_simulated, liveFeed: pickString(r.live_feed) ?? null }
+            : {}),
         ...(isCancelled
             ? { cancelled: { isCancelled: true, reason: pickString(r.cancellationReason) ?? null } }
             : {}),

package/dist/tools/player.js

@@ -35,7 +35,7 @@ function identityFrom(game, raw, idHint, slugHint) {
             headshotUrl: pickString(r.headshotUrl, r.headshot, r.portrait_url) ?? null,
             bodyImageUrl: pickString(r.bodyImageUrl, r.fullBodyImageUrl) ?? null,
             imageUrl: pickString(r.imageUrl, r.image, r.photoUrl, r.portrait_url) ?? null,
-            proxiedImageUrl: pickString(r.proxiedImageUrl, r.proxiedHeadshotUrl) ?? null,
+            proxiedImageUrl: pickString(r.proxiedImageUrl, r.proxiedHeadshotUrl, r.proxied_image_url) ?? null,
             license: pickString(r.portrait_license) ?? null,
             attribution: pickString(r.portrait_attribution) ?? null,
             sourceUrl: pickString(r.portrait_source_url) ?? null,
@@ -44,17 +44,17 @@ function identityFrom(game, raw, idHint, slugHint) {
 }
 export const playerProfile = {
     name: 'player_profile',
-    description: `Player or UFC fighter profile: identity, current team, recent matches, and form/trends/radar when available.
-
-When to use:
-- "How is X playing lately?"
-- Player page scaffold; form inputs for previews
-
-Prefer over: manual multi-call career/trends/matches via call_api.
-
-Do not use when: full team roster needed → team_profile; unresolved name → resolve_entity first.
-
-Parallel-safe: yes. Upstream cost: 2–5.
+    description: `Player or UFC fighter profile: identity, current team, recent matches, and form/trends/radar when available.
+
+When to use:
+- "How is X playing lately?"
+- Player page scaffold; form inputs for previews
+
+Prefer over: manual multi-call career/trends/matches via call_api.
+
+Do not use when: full team roster needed → team_profile; unresolved name → resolve_entity first.
+
+Parallel-safe: yes. Upstream cost: 2–5.
 Example: { "game": "cs2", "playerId": "cs2-player-1", "recentLimit": 10, "includeTrends": true }`,
     inputSchema: {
         type: 'object',
@@ -70,9 +70,9 @@ Example: { "game": "cs2", "playerId": "cs2-player-1", "recentLimit": 10, "includ
             includeTrends: boolSchema('Include trends/radar/career enrichment when available.', true),
             view: {
                 type: 'string',
-                enum: ['summary', 'full'],
+                enum: ['summary', 'full', 'compact'],
                 default: 'summary',
-                description: 'Payload weight. Default summary.',
+                description: 'Payload weight. Default summary. compact (tennis): recentMatches as one slim row per match from the player side (result, opponent{id,name,rank}, score, event, round) instead of full match rows that repeat both players three times.',
             },
         },
     },
@@ -124,7 +124,7 @@ Example: { "game": "cs2", "playerId": "cs2-player-1", "recentLimit": 10, "includ
         const idOrSlug = playerId || slug;
         const recentLimit = clampInt(args.recentLimit, 10, 1, 25);
         const includeTrends = args.includeTrends !== false;
-        const view = args.view === 'full' ? 'full' : 'summary';
+        const view = args.view === 'full' ? 'full' : args.view === 'compact' ? 'compact' : 'summary';
         const partial = [];
         let upstreamCalls = 0;
         let rateLimit = {};
@@ -295,7 +295,7 @@ Example: { "game": "cs2", "playerId": "cs2-player-1", "recentLimit": 10, "includ
             }
             tasks.push((async () => {
                 const res = await fetchJson(ctx, `/tennis/players/${encodeURIComponent(idOrSlug)}/matches`, {
-                    query: { page_size: recentLimit },
+                    query: { page_size: recentLimit, ...(view === 'compact' ? { view: 'summary' } : {}) },
                 });
                 upstreamCalls += 1;
                 rateLimit = { ...rateLimit, ...res.headers };
@@ -534,6 +534,7 @@ function normalizeFormMatch(row) {
         result: pickString(r.result) ?? null,
         opponentId: pickString(r.opponent_id) ?? null,
         opponentRank: num(r.opponent_rank),
+        opponentRankDate: pickString(r.opponent_rank_date) ?? null,
         score: pickString(r.score) ?? null,
         surface: pickString(r.surface) ?? null,
         tournamentId: pickString(r.tournament_id) ?? null,
@@ -541,17 +542,17 @@ function normalizeFormMatch(row) {
 }
 export const playerForm = {
     name: 'player_form',
-    description: `Tennis player form: W/L record over the last N completed matches, current win/loss streak, and per-match rows (opponent, score, surface). Optional surface filter (Hard/Clay/Grass).
-
-When to use:
-- "How is X playing lately?"; current streak; surface-specific record (e.g. clay last 5).
-
-Prefer over: player_profile (identity + career aggregates, no streak); raw form via call_api for agent-normalized rows.
-
-Do not use when: career totals/titles → player_profile with game tennis (wires /stats); ranking deltas → rankings_movers.
-
-Tennis-only. Limit defaults to 10 (max 50, matching the API). Upstream rows arrive newest-first; the streak is the leading run of that order.
-
+    description: `Tennis player form: W/L record over the last N completed matches, current win/loss streak, and per-match rows (opponent, score, surface). Optional surface filter (Hard/Clay/Grass).
+
+When to use:
+- "How is X playing lately?"; current streak; surface-specific record (e.g. clay last 5).
+
+Prefer over: player_profile (identity + career aggregates, no streak); raw form via call_api for agent-normalized rows.
+
+Do not use when: career totals/titles → player_profile with game tennis (wires /stats); ranking deltas → rankings_movers.
+
+Tennis-only. Limit defaults to 10 (max 50, matching the API). Upstream rows arrive newest-first; the streak is the leading run of that order.
+
 Parallel-safe: yes. Upstream cost: 1.`,
     inputSchema: {
         type: 'object',
@@ -700,18 +701,18 @@ Parallel-safe: yes. Upstream cost: 1.`,
 };
 export const playerMatches = {
     name: 'player_matches',
-    description: `Tennis player match log: every archived match for one player, newest first, with opponent, tournament, round, surface and score.
-
-When to use:
-- "Show me Shelton's last 20 matches"; full match history; every match at a given tournament; filtering a player's record by surface.
-
-Prefer over: player_form (a W/L summary with a small window and a streak, not the log); call_api for /tennis/players/{id}/matches.
-
-Do not use when: aggregate totals, titles, or win% → player_stats; identity → player_profile; one match's box score → match_details.
-
-Tennis-only. Limit defaults to 20 (max 50). Rows arrive newest-first. Use
-surface to narrow to Hard/Clay/Grass; tournamentId pins one event.
-
+    description: `Tennis player match log: every archived match for one player, newest first, with opponent, tournament, round, surface and score.
+
+When to use:
+- "Show me Shelton's last 20 matches"; full match history; every match at a given tournament; filtering a player's record by surface.
+
+Prefer over: player_form (a W/L summary with a small window and a streak, not the log); call_api for /tennis/players/{id}/matches.
+
+Do not use when: aggregate totals, titles, or win% → player_stats; identity → player_profile; one match's box score → match_details.
+
+Tennis-only. Limit defaults to 20 (max 50). Rows arrive newest-first. Use
+surface to narrow to Hard/Clay/Grass; tournamentId pins one event.
+
 Parallel-safe: yes. Upstream cost: 1.`,
     inputSchema: {
         type: 'object',
@@ -869,16 +870,16 @@ Parallel-safe: yes. Upstream cost: 1.`,
 };
 export const playerStats = {
     name: 'player_stats',
-    description: `Tennis player career statistics: W/L totals, win percentage, titles, Grand Slam and Masters titles, plus per-surface and per-level breakdowns. Optional surface/year filters.
-
-When to use:
-- "How many titles does Alcaraz have?"; career win%; Grand Slam title count; record on clay; a season-scoped record.
-
-Prefer over: player_profile (identity + a summary block, no breakdowns); player_matches (individual rows, no aggregates).
-
-Do not use when: the match log → player_matches; ranking over time → player_rankings_history.
-
-Tennis-only. Filters are surface (Hard/Clay/Grass/Carpet) and yearFrom/yearTo.
+    description: `Tennis player career statistics: W/L totals, win percentage, titles, Grand Slam and Masters titles, plus per-surface and per-level breakdowns. Optional surface/year filters.
+
+When to use:
+- "How many titles does Alcaraz have?"; career win%; Grand Slam title count; record on clay; a season-scoped record.
+
+Prefer over: player_profile (identity + a summary block, no breakdowns); player_matches (individual rows, no aggregates).
+
+Do not use when: the match log → player_matches; ranking over time → player_rankings_history.
+
+Tennis-only. Filters are surface (Hard/Clay/Grass/Carpet) and yearFrom/yearTo.
 Upstream cost: 1.`,
     inputSchema: {
         type: 'object',

package/dist/tools/schedule.js

@@ -10,8 +10,11 @@ function normalizeScheduled(row) {
     const p2 = asRecord(r.player2) ?? asRecord(r.away) ?? {};
     return {
         matchId: pickString(r.id, r.match_id) ?? null,
+        canonicalId: pickString(r.canonical_id, r.id, r.match_id) ?? null,
         tournamentId: pickString(r.tournament_id) ?? null,
         tournamentName: pickString(r.tournament_name, r.tournament) ?? null,
+        tournamentDisplayName: pickString(r.tournament_display_name, r.tournament_name) ?? null,
+        tournamentShortName: pickString(r.tournament_short_name) ?? null,
         tour: pickString(r.tour) ?? null,
         level: pickString(r.level, r.tier) ?? null,
         surface: pickString(r.surface) ?? null,
@@ -20,9 +23,23 @@ function normalizeScheduled(row) {
         startsAt: pickString(r.starts_at, r.commence_time, r.match_date) ?? null,
         startTimeKnown: typeof r.start_time_known === 'boolean' ? r.start_time_known : null,
         status: pickString(r.status, r.outcome) ?? null,
-        player1: { id: pickString(p1.id, p1.player_id) ?? null, name: pickString(p1.name) ?? null },
-        player2: { id: pickString(p2.id, p2.player_id) ?? null, name: pickString(p2.name) ?? null },
+        player1: {
+            id: pickString(p1.id, p1.player_id) ?? null,
+            canonicalId: pickString(p1.canonical_id, p1.id, p1.player_id) ?? null,
+            name: pickString(p1.name) ?? null,
+        },
+        player2: {
+            id: pickString(p2.id, p2.player_id) ?? null,
+            canonicalId: pickString(p2.canonical_id, p2.id, p2.player_id) ?? null,
+            name: pickString(p2.name) ?? null,
+        },
+        winnerId: pickString(r.winner_id) ?? null,
         score: pickString(r.score, r.score_raw) ?? null,
+        liveScore: pickString(r.live_score) ?? null,
+        resultAvailable: typeof r.result_available === 'boolean'
+            ? r.result_available
+            : Boolean(pickString(r.winner_id) && pickString(r.score, r.score_raw)),
+        resultUnavailableReason: pickString(r.result_unavailable_reason) ?? null,
     };
 }
 function isPlayed(row) {
@@ -116,7 +133,7 @@ Parallel-safe: yes. Upstream cost: 1 or 2.`,
         const limit = clampInt(args.limit, 20, 1, 50);
         const wantScheduled = includeRaw === 'both' || includeRaw === 'scheduled';
         const wantCompleted = includeRaw === 'both' || includeRaw === 'completed';
-        const upstreamPage = 200;
+        const upstreamPage = 500;
         const settled = await Promise.allSettled([
             wantScheduled
                 ? fetchJson(ctx, '/tennis/schedule', { query: { date, limit: upstreamPage } })
@@ -197,14 +214,14 @@ Parallel-safe: yes. Upstream cost: 1 or 2.`,
         const scheduledWindow = scheduled.slice(0, limit);
         const completedWindow = completed.slice(0, limit);
         const completedBySchedule = scheduled.filter(isPlayed);
-        const completedIds = new Set(completed
-            .map((row) => pickString(asRecord(row)?.id, asRecord(row)?.match_id))
-            .filter((id) => Boolean(id)));
+        const idOf = (row) => pickString(asRecord(row)?.canonical_id, asRecord(row)?.id, asRecord(row)?.match_id);
+        const completedIds = new Set(completed.map(idOf).filter((id) => Boolean(id)));
         const overlapIds = [
             ...new Set(completedBySchedule
-                .map((row) => pickString(asRecord(row)?.id, asRecord(row)?.match_id))
+                .map(idOf)
                 .filter((id) => typeof id === 'string' && completedIds.has(id))),
         ];
+        const resultMissing = scheduled.filter((row) => isPlayed(row) && asRecord(row)?.result_available === false).length;
         const statusCounts = {};
         for (const row of scheduled) {
             const key = (pickString(asRecord(row)?.status, asRecord(row)?.outcome) ?? 'UNKNOWN').toUpperCase();
@@ -222,6 +239,7 @@ Parallel-safe: yes. Upstream cost: 1 or 2.`,
             completedCount: completedTotal ?? completed.length,
             completedReturned: completedWindow.length,
             statusBreakdown: statusCounts,
+            playedWithoutResult: resultMissing,
             overlap: {
                 count: overlapIds.length,
                 matchIds: overlapIds.slice(0, 50),

package/dist/tools/team.js

@@ -858,9 +858,10 @@ Example: { "game": "cs2", "sideA": "faze", "sideB": "navi", "limit": 20 }`,
                     ],
                 });
             }
-            const res = await fetchJson(ctx, '/tennis/h2h', {
-                query: { player1_id: tA.id, player2_id: tB.id },
-            });
+            const tennisQuery = { player1_id: tA.id, player2_id: tB.id };
+            if (args.limit !== undefined && args.limit !== null)
+                tennisQuery.limit = limit;
+            const res = await fetchJson(ctx, '/tennis/h2h', { query: tennisQuery });
             upstreamCalls += 1;
             rateLimit = { ...rateLimit, ...res.headers };
             if (!res.ok) {
@@ -893,7 +894,16 @@ Example: { "game": "cs2", "sideA": "faze", "sideB": "navi", "limit": 20 }`,
                     sideA: { idOrSlug: tA.id, name: sideAName },
                     sideB: { idOrSlug: tB.id, name: sideBName },
                     h2h,
-                    notes: ['Record and meetings come from the first-class /tennis/h2h endpoint'],
+                    meetingsReturned: Array.isArray(h2h.matches) ? h2h.matches.length : null,
+                    meetingsTotal: typeof asRecord(h2h.matches_pagination)?.total === 'number'
+                        ? asRecord(h2h.matches_pagination)?.total
+                        : typeof asRecord(h2h.summary)?.total_matches === 'number'
+                            ? asRecord(h2h.summary)?.total_matches
+                            : null,
+                    notes: [
+                        'Record and meetings come from the first-class /tennis/h2h endpoint',
+                        'limit bounds h2h.matches only; summary and every breakdown (surface, level, format) cover all meetings and sum to total_matches (h2h.breakdown_totals).',
+                    ],
                 },
             });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cito-mcp",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "Standalone MCP server for the Cito esports and sports API — curated outcome tools for agents (live scoreboards, round economy, opening duels, clutches, vetoes, rosters, tennis, mma).",
   "type": "module",
   "homepage": "https://cito.gg",