cito-mcp 0.3.12 → 0.3.14

package/dist/tools/insight.js

@@ -47,10 +47,14 @@ async function loadSide(ctx, game, side, recentLimit, includeRosters) {
             recentForm = extractRows(unwrapPayload(fights.data) ?? fights.data)
                 .slice(0, recentLimit)
                 .map((row) => {
-                // history rows nest bout
+                // History rows nest the bout and carry the fighter's own side as
+                // fighterSlug/opponent/outcome. Merge so normalizeMatch sees both,
+                // and do NOT force 'completed': the fighter's next scheduled bout is
+                // in this list too, and stamping it completed put an unfought fight
+                // at the top of the form with no result.
                 const r = asRecord(row) ?? {};
-                const bout = asRecord(r.bout) ?? r;
-                return normalizeMatch('ufc', { ...bout, ...(r.fighterName ? {} : {}) }, 'completed');
+                const bout = asRecord(r.bout) ?? {};
+                return normalizeMatch('ufc', { ...bout, ...r });
             });
         }
         const stats = await fetchJson(ctx, `/ufc/fighters/${encodeURIComponent(side)}/stats`);
@@ -201,11 +205,15 @@ async function loadSide(ctx, game, side, recentLimit, includeRosters) {
     }
     return { entity, roster, recentForm, keyPlayers, calls, partial, rateLimit };
 }
-function composeH2H(game, sideA, sideB, rows, limit) {
+export function composeH2H(game, sideA, sideB, rows, limit) {
     const al = sideA.toLowerCase();
     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());
@@ -219,7 +227,7 @@ 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 = {
@@ -406,8 +414,10 @@ Example: { "game": "lol", "teamA": "t1", "teamB": "gen-g", "includeH2H": true, "
                     rateLimit = { ...rateLimit, ...hist.headers };
                     if (hist.ok) {
                         rows = extractRows(unwrapPayload(hist.data) ?? hist.data).map((row) => {
+                            // Keep fighterSlug/opponent/outcome alongside the bout; they are
+                            // the only place the two corners exist on a history row.
                             const r = asRecord(row) ?? {};
-                            return asRecord(r.bout) ?? row;
+                            return { ...(asRecord(r.bout) ?? {}), ...r };
                         });
                     }
                     else {
@@ -428,6 +438,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;
@@ -757,6 +792,11 @@ Example: { "game": "ufc", "eventIdOrSlug": "ufc-300", "includeBouts": true, "inc
                     }));
                 }
             }
+            // Bout rows carry no start time of their own; inherit the card's. Without
+            // this the same bout said startTime:null here and the event time on
+            // upcoming_schedule, and a caller had to fetch both to learn when it is.
+            const cardStart = typeof event.date === 'string' ? event.date : null;
+            bouts = bouts.map((b) => ({ ...b, startTime: b.startTime ?? cardStart }));
             if (includeStandings) {
                 const ranks = await fetchJson(ctx, '/ufc/rankings');
                 upstreamCalls += 1;

package/dist/tools/live.js

@@ -77,10 +77,16 @@ export function extractLiveRows(data, game) {
 export function inferUfcEmptyReason(events, health, liveCount) {
     if (liveCount > 0)
         return undefined;
+    const pulses = events.map((ev) => asRecord(ev) ?? {});
+    const hotNow = pulses.some((p) => ['live', 'warming', 'between_bouts', 'degraded'].includes(String(pickString(p.status, p.eventStatus) ?? '').toLowerCase()));
+    // The API's own health block is trusted first, EXCEPT when it blames the
+    // worker on a day nothing is live. It computes worker_stale from heartbeat
+    // lag alone, so an idle Thursday reads the same as a dead worker on fight
+    // night. With no hot card there is nothing to be stale about.
     const fromHealth = pickString(health?.emptyReason);
-    if (fromHealth)
+    if (fromHealth && !(['worker_stale', 'worker_down_inferred'].includes(fromHealth) && !hotNow)) {
         return fromHealth;
-    const pulses = events.map((ev) => asRecord(ev) ?? {});
+    }
     if (!pulses.length) {
         const alive = health?.workerAlive ?? health?.workerStarted;
         if (alive === false)
@@ -94,9 +100,13 @@ export function inferUfcEmptyReason(events, health, liveCount) {
     const freshest = lags.length ? Math.min(...lags) : null;
     const workerAlive = health?.workerAlive ?? health?.workerStarted;
     const hot = statuses.some((s) => ['live', 'warming', 'between_bouts', 'degraded'].includes(s));
-    if (workerAlive === false && (hot || (freshest != null && freshest > 120))) {
+    // Only a HOT card can be stale. On an idle day every event is "scheduled"
+    // and the heartbeat lags because there is nothing to beat about; reporting
+    // that as worker_stale made a quiet Thursday indistinguishable from a dead
+    // worker on fight night. freshest stays computed for the health block.
+    void freshest;
+    if (workerAlive === false && hot)
         return 'worker_stale';
-    }
     if (statuses.some((s) => s === 'degraded'))
         return 'event_degraded';
     if (statuses.some((s) => s === 'warming'))
@@ -126,8 +136,10 @@ export function humanUfcEmptyNote(emptyReason, health) {
         supervisor_warming: 'Card open / pre-gate; no bout live yet',
         between_bouts: 'Between bouts; next may be armed',
         armed_only: 'Next bout armed; not started',
-        worker_stale: 'Worker heartbeat stale — check pm2 ufc-live on VPS 169',
-        worker_down_inferred: 'Worker appears down — check pm2 ufc-live on VPS 169',
+        // Customer-facing. The pm2/VPS operator hint used to be in here and went
+        // out in every empty board; health{} already carries the numbers for us.
+        worker_stale: 'Live feed is behind; scores may lag',
+        worker_down_inferred: 'Live feed unavailable right now',
         event_degraded: 'Sources empty clock / event degraded; not inventing stats',
     };
     const msg = human[reason] || `No live|watching bouts (${reason})`;
@@ -284,9 +296,14 @@ Example: { "game": "all", "limitPerGame": 10 }`,
             if (game === 'ufc') {
                 const health = asRecord(meta?.health) ?? asRecord(payload?.health);
                 const events = Array.isArray(payload?.events) ? payload.events : [];
+                // One decision point. This used to short-circuit on the API's own
+                // emptyReason and only fall back to inferUfcEmptyReason when the API
+                // said nothing, so the idle-day rule inside it never ran: the API
+                // blames the worker on heartbeat lag alone and an empty Thursday came
+                // back as worker_stale. Hand the hint in and let the function weigh it.
+                const upstreamReason = pickString(meta?.emptyReason, health?.emptyReason);
                 const emptyReason = normalized.length === 0
-                    ? pickString(meta?.emptyReason, health?.emptyReason) ??
-                        inferUfcEmptyReason(events, health, normalized.length)
+                    ? inferUfcEmptyReason(events, { ...(health ?? {}), ...(upstreamReason ? { emptyReason: upstreamReason } : {}) }, normalized.length)
                     : undefined;
                 let note;
                 if (normalized.length === 0) {
@@ -306,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

@@ -119,9 +119,17 @@ function sideExtras(o, game) {
         ...(rank ? { rank } : {}),
         // "none" carries no signal for a page; only surface an actual belt state.
         ...(championStatus && championStatus.toLowerCase() !== 'none' ? { championStatus } : {}),
-        ...(division ? { division } : {}),
-        ...(country ? { country } : {}),
-        ...(flag ? { flag } : {}),
+        // UFC corners always carry these keys. A debutant with no ranked division
+        // was shipping with the key ABSENT while every other corner had it, and a
+        // fighter from a country with no flag mapping did the same, which breaks
+        // strict parsers. Null says "not known"; absence says nothing.
+        ...(game === 'ufc'
+            ? { division: division ?? null, country: country ?? null, flag: flag ?? null }
+            : {
+                ...(division ? { division } : {}),
+                ...(country ? { country } : {}),
+                ...(flag ? { flag } : {}),
+            }),
         ...(outcome ? { outcome } : {}),
     };
 }
@@ -151,6 +159,40 @@ function scoreNum(v) {
         return Number(v);
     return null;
 }
+/**
+ * Collapse the six spellings one outcome arrives in ("SUB" / "Submission",
+ * "U-DEC" / "Decision - Unanimous", "KO/TKO" / "TKO") onto one enum. The raw
+ * string is kept alongside as methodRaw; this is a stable key for consumers,
+ * not a rewrite of the source.
+ */
+export function normalizeUfcMethod(raw) {
+    if (!raw)
+        return undefined;
+    const s = raw.trim().toLowerCase();
+    if (!s)
+        return undefined;
+    if (/overturn/.test(s))
+        return 'Overturned';
+    if (/no[\s-]?contest|^nc$/.test(s))
+        return 'NC';
+    if (/^dq$|disqualif/.test(s))
+        return 'DQ';
+    if (/draw/.test(s))
+        return 'Draw';
+    if (/sub/.test(s))
+        return 'SUB';
+    if (/ko|tko|knock|stoppage|strikes|punch|kick|elbow|knee/.test(s))
+        return 'KO/TKO';
+    if (/unanim|^u-?dec$/.test(s))
+        return 'U-DEC';
+    if (/split|^s-?dec$/.test(s))
+        return 'S-DEC';
+    if (/major|^m-?dec$/.test(s))
+        return 'M-DEC';
+    if (/dec/.test(s))
+        return 'DEC';
+    return raw.trim();
+}
 export function normalizeMatch(game, row, forcedStatus) {
     // Always peel { success, data } so UFC bout fighters[] / status are visible.
     const r = asRecord(unwrapPayload(row)) ?? asRecord(row) ?? {};
@@ -216,7 +258,11 @@ export function normalizeMatch(game, row, forcedStatus) {
             const profile = asRecord(o.profile);
             const fighter = asRecord(o.fighter);
             const name = pickString(o.name, o.fighterName, o.displayName, o.nickname, profile?.name, profile?.nickname, fighter?.name, fighter?.nickname);
-            const id = pickString(o.id, o.fighterId, profile?.id, fighter?.id);
+            // o.id on a serialized corner is the ufc_bout_fighters ROW id, unique per
+            // bout, so the same human got a different "id" on every card. Prefer the
+            // fighter's own id wherever the API supplies it; fall back to the row id
+            // only when nothing better exists.
+            const id = pickString(o.fighterId, profile?.id, fighter?.id, o.id);
             const slug = pickString(o.slug, o.fighterSlug, profile?.slug, fighter?.slug);
             const score = scoreNum(o.score ?? o.points);
             return sideFrom(name, id, slug, score, sideExtras(o, game));
@@ -247,6 +293,31 @@ export function normalizeMatch(game, row, forcedStatus) {
             team2 = team2 ?? fromCornerObj(blueF);
         }
     }
+    // UFC fighter-history rows (/ufc/fighters/{slug}/fights). These carry the
+    // fighter as fighterSlug/fighterName, the other corner under opponent, and
+    // the result as outcome, with NO fighters[] and no team1/team2. Every reader
+    // was left with two null sides: head_to_head filtered on those nulls and
+    // reported Jones vs Cormier as never having met, the profile showed
+    // team1:null with the division as the label, and the preview form could not
+    // say who won. One shape, three symptoms.
+    if (game === 'ufc' && !team1 && !team2 && typeof r.fighterSlug === 'string') {
+        const opp = asRecord(r.opponent);
+        const selfCorner = pickString(r.corner)?.toLowerCase();
+        const self = sideFrom(pickString(r.fighterName) ?? String(r.fighterSlug), undefined, String(r.fighterSlug), undefined, sideExtras(r, game));
+        const other = opp
+            ? sideFrom(pickString(opp.name) ?? pickString(opp.slug), undefined, pickString(opp.slug), undefined, sideExtras(opp, game))
+            : null;
+        // Keep red on team1 when we know the corner, so a card and a history row
+        // agree on which side is which.
+        if (selfCorner === 'blue' && other) {
+            team1 = other;
+            team2 = self;
+        }
+        else {
+            team1 = self;
+            team2 = other;
+        }
+    }
     // COD sometimes uses teams[]
     if ((!team1 || !team2) && Array.isArray(r.teams)) {
         team1 = team1 ?? nestedSide(r.teams[0], game);
@@ -296,9 +367,20 @@ export function normalizeMatch(game, row, forcedStatus) {
         else if (hasResult)
             status = 'completed';
     }
+    // The winner, resolved once. Explicit winner fields first; otherwise a
+    // history row states the result from the fighter's own side (outcome: win /
+    // loss), which translates back into a slug. Both the score below and the
+    // result block use this, so a fight the profile shows as a win also counts
+    // 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) ??
+        (historyOutcome === 'win' && typeof r.fighterSlug === 'string' ? r.fighterSlug
+            : historyOutcome === 'loss' && historyOpponent ? historyOpponent
+                : undefined);
     // Winner → score 1-0 for UFC card display when numeric scores absent
     if (game === 'ufc' && team1 && team2 && team1.score == null && team2.score == null) {
-        const winner = pickString(r.winnerFighterSlug, r.winnerSlug, r.winner)?.toLowerCase();
+        const winner = resolvedWinnerSlug?.toLowerCase();
         if (winner) {
             const t1hit = [team1.slug, team1.id, team1.name].some((x) => x && (String(x).toLowerCase() === winner || String(x).toLowerCase().includes(winner) || winner.includes(String(x).toLowerCase())));
             const t2hit = [team2.slug, team2.id, team2.name].some((x) => x && (String(x).toLowerCase() === winner || String(x).toLowerCase().includes(winner) || winner.includes(String(x).toLowerCase())));
@@ -324,7 +406,14 @@ export function normalizeMatch(game, row, forcedStatus) {
     // When both sides lack names, prefer event / weight / bout id over opaque "? vs ?"
     // so agent boards (live_matches, upcoming_schedule, event_card) stay legible.
     const vsLabel = `${team1?.name ?? '?'} vs ${team2?.name ?? '?'}`;
-    const explicit = pickString(r.label, r.title, r.name);
+    const explicitRaw = pickString(r.label, r.title, r.name);
+    // UFC history rows put the division where a title would go ("Heavyweight"),
+    // which then displaced "Jon Jones vs Stipe Miocic" as the label. A label that
+    // merely repeats the weight class is not a matchup; use the sides instead.
+    const explicit = game === 'ufc' && explicitRaw && (team1?.name || team2?.name) &&
+        explicitRaw.toLowerCase() === (pickString(r.weightClass, r.division) ?? '').toLowerCase()
+        ? undefined
+        : explicitRaw;
     const explicitIsPlaceholder = explicit != null && /^\?\s*vs\s*\?$/i.test(explicit.trim());
     const weightOrClass = pickString(r.weightClass, r.division, r.weight_class, r.boutClass);
     let label;
@@ -348,12 +437,13 @@ export function normalizeMatch(game, row, forcedStatus) {
     const cardSectionOrder = numOrNull(r.cardSectionOrder);
     const boutOrder = numOrNull(r.boutOrder);
     const hasCard = cardSection != null || cardPosition != null || cardSectionOrder != null || boutOrder != null;
-    const method = pickString(r.method);
+    const methodRaw = pickString(r.method);
+    const method = normalizeUfcMethod(methodRaw);
     const methodDetails = pickString(r.methodDetails);
     const resultTime = pickString(r.resultTime);
     // UFC sends referee as { id, name, firstName, lastName } — not a string.
     const referee = pickString(r.referee, asRecord(r.referee)?.name);
-    const winnerSlug = pickString(r.winnerFighterSlug, r.winnerSlug, r.winner);
+    const winnerSlug = resolvedWinnerSlug;
     const resultRound = numOrNull(r.resultRound);
     const hasResultDetail = method != null || resultRound != null || winnerSlug != null || resultTime != null;
     const isCancelled = r.isCancelled === true;
@@ -383,6 +473,7 @@ export function normalizeMatch(game, row, forcedStatus) {
             ? {
                 result: {
                     method: method ?? null,
+                    methodRaw: methodRaw ?? null,
                     methodDetails: methodDetails ?? null,
                     round: resultRound,
                     time: resultTime ?? null,

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', {
@@ -479,7 +481,11 @@ Example: { "game": "cs2", "playerId": "cs2-player-1", "recentLimit": 10, "includ
                         .slice(0, recentLimit)
                         .map((row) => {
                         const r = asRecord(row) ?? {};
-                        const bout = asRecord(r.bout) ?? row;
+                        // Merge the row's own corner fields (fighterSlug / opponent /
+                        // outcome) over the nested bout: they are the only place the two
+                        // sides exist on a history row, and without them every entry
+                        // came back team1:null, team2:null with the division as label.
+                        const bout = { ...(asRecord(r.bout) ?? {}), ...r };
                         // Never force 'completed'. A fighter's history endpoint also
                         // returns bouts that are booked but not yet fought, and forcing
                         // the status told agents that a future main event had already
@@ -488,11 +494,16 @@ Example: { "game": "cs2", "playerId": "cs2-player-1", "recentLimit": 10, "includ
                         // reported as completed with result null). Let normalizeMatch
                         // derive it from the result and the start time instead.
                         const m = normalizeMatch('ufc', bout);
+                        // Keep the normalized result OBJECT (method, round, time,
+                        // winnerSlug), the same shape match_preview and match_summary
+                        // return. This used to overwrite it with the string "win",
+                        // giving the profile a fourth result schema of its own. The
+                        // fighter's-eye view lives on outcome instead.
                         return {
                             ...m,
-                            result: pickString(r.result, r.outcome, asRecord(bout)?.result) ?? null,
+                            outcome: pickString(r.outcome)?.toLowerCase() ?? null,
                             opponent: pickString(r.opponentName, asRecord(r.opponent)?.name) ?? null,
-                            method: pickString(asRecord(bout)?.method, r.method) ?? null,
+                            method: m.result?.method ?? null,
                         };
                     });
                 }
@@ -508,7 +519,7 @@ Example: { "game": "cs2", "playerId": "cs2-player-1", "recentLimit": 10, "includ
                             .slice(0, recentLimit)
                             .map((row) => {
                             const r = asRecord(row) ?? {};
-                            const bout = asRecord(r.bout) ?? row;
+                            const bout = { ...(asRecord(r.bout) ?? {}), ...r };
                             // Same as above: derive, never assert. See the note there.
                             return normalizeMatch('ufc', bout);
                         });
@@ -542,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

@@ -21,7 +21,10 @@ export function normalizeStandingRow(row, index) {
         isInterim;
     let rank;
     if (isChampion) {
-        rank = isInterim || rankText === 'IC' ? 'IC' : 'C';
+        // rank is numeric or null; the belt lives in rankText ("C"/"IC") and
+        // championStatus. Mixing a string into a numeric column forced every
+        // consumer to special-case it.
+        rank = null;
     }
     else if (typeof r.rank === 'number') {
         rank = r.rank;
@@ -122,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) => {
@@ -140,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;
@@ -314,7 +321,11 @@ Example: { "game": "cod", "season": "2026", "limit": 50 }`,
                 rateLimit: res.headers,
             });
         }
-        let rows = extractRows(res.data).map((row, i) => normalizeStandingRow(row, i)).slice(0, limit);
+        // Keep the unsliced count. UFC world scope is every division back to back,
+        // 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(offset, offset + limit);
         // UFC rankings may be nested by division
         if (game === 'ufc' && rows.length === 0) {
             const obj = asRecord(res.data) ?? {};
@@ -326,8 +337,30 @@ Example: { "game": "cod", "season": "2026", "limit": 50 }`,
                     nested.push(...asRecord(value).rankings);
                 }
             }
-            rows = nested.map((row, i) => normalizeStandingRow(row, i)).slice(0, limit);
+            allRows = nested.map((row, i) => normalizeStandingRow(row, i));
+            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) ?? {};
@@ -356,6 +389,7 @@ Example: { "game": "cod", "season": "2026", "limit": 50 }`,
                 : 'Rankings dataFreshness=cached or stale.');
         }
         return successEnvelope({
+            pagination: standingsPagination,
             source: 'standings',
             game,
             requestId,
@@ -369,6 +403,8 @@ Example: { "game": "cod", "season": "2026", "limit": 50 }`,
                 season: season ?? null,
                 stage: stage ?? null,
                 rows,
+                total: allRows.length,
+                hasMore: allRows.length > rows.length,
                 updatedAt: pickString(obj?.updatedAt, obj?.lastUpdated, upstreamMeta.syncedAt, upstreamMeta.fetchedAt) ??
                     null,
                 ...(dataFreshness ? { dataFreshness } : {}),

package/dist/tools/team.js

@@ -829,8 +829,11 @@ Example: { "game": "cs2", "sideA": "faze", "sideB": "navi", "limit": 20 }`,
                 });
             }
             const toBouts = (payload) => extractRows(payload).map((row) => {
+                // History rows carry the two corners as fighterSlug/opponent, not on
+                // the nested bout. Dropping them here is why Jones vs Cormier reported
+                // zero meetings while the profile listed both fights.
                 const r = asRecord(row) ?? {};
-                return asRecord(r.bout) ?? row;
+                return { ...(asRecord(r.bout) ?? {}), ...r };
             });
             const fromA = histA.ok ? toBouts(histA.data) : [];
             const fromB = histB.ok ? toBouts(histB.data) : [];
@@ -917,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,7 +1,7 @@
 {
   "name": "cito-mcp",
-  "version": "0.3.12",
-  "description": "Standalone MCP server for the Cito esports API — 15 curated outcome tools for agents (live, schedule, profiles, standings, previews, event cards).",
+  "version": "0.3.14",
+  "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": {
     "cito-mcp": "dist/index.js"