From bbe1d41248780d00e401d8eb463b9b3e80f3c585 Mon Sep 17 00:00:00 2001
From: nesszerra <90105158+Finesssee@users.noreply.github.com>
Date: Thu, 15 Oct 2026 22:07:34 +0700
Subject: [PATCH 1/3] Ranked duels per pair per live stream

- pairRankedPerStream config (default 5, 0 = no limit) replaces the fixed 5 per 24 h
- offline duels are unrated and pay nothing; past the pair limit they pay half
- last ranked duel tag, !stats @name shows ranked duels left
- !resetpair @a @b and the mod-page Reset pair count
---
 admin/index.html         |   9 +++
 docs/CONTRACTS.md        |  40 ++++++++-----
 docs/DUELS.md            |  15 +++--
 server/channel.ts        | 120 ++++++++++++++++++++++++++++++++++++---
 server/game.ts           |  81 +++++++++++++++++++++-----
 server/model.ts          |  17 +++++-
 server/streamelements.ts |  36 ++++++++----
 src/admin.ts             |  45 +++++++++++++++
 tests/channel.test.ts    |  49 +++++++++++++++-
 tests/game.test.ts       | 112 +++++++++++++++++++++++++++++++++---
 10 files changed, 462 insertions(+), 62 deletions(-)

diff --git a/admin/index.html b/admin/index.html
index 6425731..da0b236 100644
--- a/admin/index.html
+++ b/admin/index.html
@@ -116,6 +116,15 @@ <h2 id="gift-title">Gift PixFray dollars to a saved fighter</h2>
           <div><button class="btn" id="gift-send" type="submit">Gift dollars</button><p class="status" id="gift-status" role="status"></p></div>
         </form>
       </section>
+      <section class="section" aria-labelledby="pair-title">
+        <h2 id="pair-title">Reset ranked duels for one pair</h2>
+        <p class="muted small">Two fighters get a set number of ranked duels against each other per stream (Rules tab). This gives them the full count again for this stream. Mods can also type <code>!resetpair @name @name</code> in chat.</p>
+        <form id="pair-form" class="controls" novalidate>
+          <div><label for="pair-a">First viewer (Twitch name)</label><input id="pair-a" maxlength="26" autocomplete="off" spellcheck="false" required></div>
+          <div><label for="pair-b">Second viewer (Twitch name)</label><input id="pair-b" maxlength="26" autocomplete="off" spellcheck="false" required></div>
+          <div><button class="btn" id="pair-send" type="submit">Reset pair count</button><p class="status" id="pair-status" role="status"></p></div>
+        </form>
+      </section>
     </div>
     <div role="tabpanel" id="panel-rules" aria-labelledby="tab-rules" tabindex="0" hidden>
       <section class="section" aria-labelledby="config-title">
diff --git a/docs/CONTRACTS.md b/docs/CONTRACTS.md
index 14155e0..cac5d2e 100644
--- a/docs/CONTRACTS.md
+++ b/docs/CONTRACTS.md
@@ -174,13 +174,14 @@ channel of that account only, so nobody can turn on someone else's channel.
 | `resetHealth` | none | Every active player goes to maxHp, and respawn is cleared. |
 | `resetRank` | `{userId}` | Sets elo to initialElo and wins and losses to 0. Works for offline profiles too. |
 | `restoreRank` | `{userId, elo, wins, losses}` or `{userId, before}` | Sets one fighter's elo (0 to 10,000), wins and losses (0 to 1,000,000), active or offline, to repair a rank lost to a bug. With `before` (epoch ms) it uses the fighter's last rank history row before that time (404 `no_rank_history` when there is none). Site owner only (403 `{error, reason:"owner_only"}`). 400 `invalid_rank`, 400 `profile_not_found`. Logged as a command (`<owner> restored rank <elo>/<wins>/<losses> -> <userId>`). |
-| `resetAllRanks` | none | The same reset for every stored profile, and the daily pair counts (`pairPlays`) start over. Broadcaster or owner only (403 `{error, reason:"broadcaster_only"}`); clear arena and the other resets stay with mods. |
+| `resetAllRanks` | none | The same reset for every stored profile, and the per-stream pair counts (`pairPlays`) start over. Broadcaster or owner only (403 `{error, reason:"broadcaster_only"}`); clear arena and the other resets stay with mods. |
 | `resetRound` | none | Cancels open duels and sets `round` to 0. |
 | `resetAll` | none | Clears players, duels and locks. Stored profiles stay. |
 | `removePlayer` | `{userId}` | Removes the player from the arena and deletes the stored profile. |
 | `connectChat` | none | Handled by the Worker, not the room. Ensures exactly one Twitch EventSub `channel.chat.message` webhook for this site (section 4) and records it in the room. Where `CHAT_BOT=1` it subscribes as the PixFray bot (condition `{broadcaster_user_id, user_id:<bot id>}`); otherwise only the default channel can connect, with the owner's own subscription (400 on other channels or with `SE_ONLY=1`: use StreamElements). `takeover:true` needs the broadcaster or the owner (403 `broadcaster_only`). Returns `{ok, reason, revision, chatStatus}`. 403 `{error, reconnect:"/auth/login?connect=1"}` when Twitch reports missing authorization; 409 `{reconnect}` when the broadcaster id is unknown; 409 `{error, connectedElsewhere}` when another site holds the chat subscription (retry with `takeover:true` to move it here, section 4); in bot mode 409 `{reconnect:"/auth/login?bot=1"}` until the bot account has signed in and 403 `{reconnect:"/auth/login?channel=x&connect=bot"}` when Twitch refuses the bot; 502 when Twitch fails. |
 | `disconnectChat` | none | Deletes the subscription at Twitch, marks chat disconnected, pauses duels and cancels open ones (`chat_disconnected`). StreamElements commands don't reconnect a channel turned off this way. |
 | `pauseChannel` / `resumeChannel` | none | Handled by the Worker; the broadcaster or the owner only (403 for mods). Turns a signed-up channel off or back on (`channel:<login>.pausedAt`). The broadcaster can't turn back on a channel the owner turned off (403 `owner_off`). Fighters, ranks and settings are kept. Other isolates notice within a minute. 400 for a built-in channel. Returns `{ok:true, channelState}`. |
+| `resetPair` | `{a, b}` (Twitch logins, `@` allowed) | Clears the two fighters' ranked count for this stream (`pairPlays`), so they get the full `pairRankedPerStream` again. Also `!resetpair @a @b` in chat (broadcaster or a mod). 404 `profile_not_found` (`missing` names the login), 400 `invalid_pair` (the same fighter twice). Logged as a command (`<mod> reset pair <a> <b>`). Returns `{ok:true, reason:"pair_reset", a, b, left}`; `left` is `null` when the channel has no limit. |
 | `giftDollars` | `{username, amount}` | Adds PixFray dollars to a saved fighter (`@` allowed before the name), or takes them back with a negative amount; the balance stays between 0 and 1,000,000. `amount` is a whole number from -10000 to 10000, not 0 (400 `invalid_amount`); 404 `profile_not_found`. Logged as a command (`<mod> gift <amount> -> <login>`). Returns `{ok:true, reason:"dollars_gifted", username, displayName, amount, dollars}`. |
 | `saveCommand` / `deleteCommand` / `setCounter` | `{name, reply, oldName?}` / `{name}` / `{name, value}` | The PixFray bot's own text commands (room tables `bot_commands`, `bot_counters`; server/botcommands.ts), any mod. A name is `!` plus 1 to 24 of `a-z0-9_`, stored lowercase (400 `invalid_command_name`); it can't be a PixFray command's name (the channel's names, their defaults, `!give`, `!pay`: 400 `command_name_taken`) or another existing command (400 `command_exists`; `oldName` renames). The reply is 1 to 400 characters after collapsing spaces (`empty_command_reply`, `command_reply_too_long`); once filled in, a line over 480 characters is cut at a word break with `…`, and saving a reply whose worst case would be cut still succeeds with `{warning:"reply_may_be_cut", longest, max:480}`; at most 50 commands (`too_many_commands`). In a reply `${user}` is the sender, `${touser}` the first word after the command without `@` (else the sender), `${count x}` adds 1 to counter `x` and shows it, `${getcount x}` shows it; `$(...)` works the same. Saving creates its counters at 0. `setCounter` takes a whole number from 0 to 1,000,000,000 (`invalid_counter_name`, `invalid_counter_value`); deleting a command keeps its counter. In chat, only the PixFray bot answers them (not StreamElements): each command at most every 5 s, and every 15 s per chatter, inside the bot's 14 command replies per 30 s (section 4). A reply the cap drops doesn't start the cooldown or change counters. `GET /api/admin/:channel` returns `botCommands` (`{commands:[{name, reply}], counters:[{name, value}], max}`). Returns `{ok:true, reason, botCommands}`. |
 | `setDuelModuleOff` | `{value:boolean}` (top level) | Handled by the Worker. Saves the setup checklist tick "StreamElements Duel module turned off". New key keeps it. |
@@ -250,7 +251,7 @@ Event types and their fields:
 | `challenge_expired` | duelId, a, b |
 | `duel_started` | duelId, a, b, round, hp, maxHp (`{userId: full hp}`, base `maxHp` plus vitality) |
 | `duel_action` | duelId, userId, targetId (the actor for heal), ability, amount, hp. Also sent for the final blow. A quick-duel roll adds die (1-6) and one of miss, crit or counter (userId is then the defender who counters), and finisher on the last blow; upgrades add lucky (luck turned a miss into a hit), luckyCrit (crit turned a hit into a crit) and dodged (the defender's dodge turned a hit or crit into a miss, which a counter may follow). An HP-fight strike or heavy that crits adds crit. |
-| `duel_completed` | duelId, winnerId, loserId, round, respawnAt, hp, ratings. Quick duels may add flawless (ratings of the winner then include bonus) and decision (`hp` or `sudden_death`); an unrated duel adds `unrated` (`new_account` or `pair_cap`). |
+| `duel_completed` | duelId, winnerId, loserId, round, respawnAt, hp, ratings. Quick duels may add flawless (ratings of the winner then include bonus) and decision (`hp` or `sudden_death`); an unrated duel adds `unrated` (`offline`, `new_account` or `pair_cap`). |
 | `duel_cancelled` | duelId, a, b, reason (`inactivity`, `chat_disconnected`, `duels_disabled`, `moderator_cancelled`, `moderator_reset`, `player_removed`), wasActive |
 | `player_respawned` | userId |
 | `player_seen`, `profile_saved` | userId |
@@ -349,7 +350,8 @@ Bot replies and status (room table `bot_status`, one row):
   failed, stays due and is retried every 5 s in reveal order until it is 2 minutes past `revealAt`, then
   skipped; a bot command also posts any due result before its own reply. A line Twitch accepted and then
   dropped (AutoMod, chat settings) counts as done. Alarm errors are logged and never stop the next alarm.
-  An unrated duel's line ends "Just for fun (<reason>): no Elo or dollars."
+  An unrated duel's line ends with its "Just for fun" text (Game rules). The pair's last ranked duel this stream ends
+  "Last ranked duel between them this stream."
   StreamElements channels get no result line; their `!elo` and `!ranks` show it after `revealAt`.
 - `GET /api/admin/:channel` returns `botStatus` `{heardAt, heard, sentAt, sent, failedAt, failed,
   failedReason, failedText, heldAt, heldReason, recent, cap}`; the admin page shows it under Chat.
@@ -357,6 +359,9 @@ Bot replies and status (room table `bot_status`, one row):
   the last command and its age, replies sent and dropped, replies used in the last 30 s, the last
   held-back reason and the reminder state. Anyone else gets "only the broadcaster or a mod can use
   !fray debug."
+- `!resetpair @a @b` (a fixed name, not a StreamElements action) from the broadcaster or a mod runs the `resetPair`
+  admin action: "Ranked duels reset for a and b: 5 left this stream." Anyone else gets "Only the broadcaster or a mod
+  can use !resetpair."; a name with no saved fighter gets "@name has no saved fighter on this channel."
 - `!fray off` / `!fray on` from the broadcaster or a mod sets `config.botEnabled` (a config version
   noted "bot off (chat)"; the admin page's Rules, Chat bot switch is the same setting) and answers
   one line. While it's off the bot answers nothing else (including `!fray on` from viewers) and posts
@@ -447,23 +452,31 @@ Viewer sprites (server/sprites.ts):
   `respawnAt = now + respawnMs`. Elo uses K=`eloK` from `initialElo`. The same pair cannot duel again
   for `rematchDelayMs`.
 - A quick duel (the default, and always the case for StreamElements commands) is rolled at once: turns alternate, challenger first; a d6 per swing gives a crit of 50% maxHp on 6, a hit of 34% on 5, a miss on 3-4 and a defender counter of 34% on 1-2. After 12 rolls more hp wins; equal hp goes to sudden death (the next blow wins). A winner at full hp gets +3 Elo (flawless). The result stays off chat until the stream has shown it: the duel gets `revealAt` = settle time + 2200 ms + 1800 ms per roll + 500 ms + `streamDelayMs` (the channel's stream delay, 6000 by default). Until then the StreamElements reply is only "Fight on: A vs B! Watch the stream for the winner.", and `!elo`, `!ranks`, `/api/leaderboard`, `/api/profile` and `/api/looks` show both fighters' numbers from before the fight (their rank is worked out on those numbers), with full hp and no `respawnAt`; `POST /api/profile` answers with the same masked numbers. Any challenge that involves either fighter answers `result_hidden` ("That fight is still playing on stream."), the same for winner and loser, so a third viewer can't probe who lost; the pair itself gets `rematch_cooldown`. The overlay shows the knockout and the Elo change at the end of the replay (no winner banner); where the PixFray bot reads chat (`chat.bot`), it posts the result line. `/api/state`, the live websocket and the admin snapshot are not masked, because the overlay and mods need them, so anyone who opens the overlay page sees the result before the stream does. The masking keeps chat replies and ranks from spoiling the stream; it does not keep the result secret.
-- Unrated duels: the same two fighters get `PAIR_RATED_PER_DAY` (5) duels that count per rolling 24 h; the next
-  ones between them are `unrated:"pair_cap"` (only rated duels count toward it). A duel where either fighter has a
-  Twitch account under 7 days old (`NEW_ACCOUNT_MS`) is `unrated:"new_account"`. An unrated duel is played and shown
-  and still sets the rematch lock, the KO and `lastOpponentId`, but changes no Elo, wins, losses or dollars (`ratings`
-  deltas are 0, no `payout`, no flawless bonus). The room asks Twitch for a saved fighter's account age once, when the
-  fighter chats or saves, and retries after an hour if Twitch doesn't answer; an unknown age counts as old (fails
-  open). The "Fight on" and result replies add "Just for fun (a Twitch account under 7 days old | 5 ranked duels
-  between them in 24 h already): no Elo or dollars."
+- Unrated duels: the room asks whether the channel is live (`currentStream`, cached 60 s) before each `!challenge`,
+  `!fight` or `!rematch` and passes the answer as the command's `stream`; game.ts keeps it in `state.stream`
+  (`{id, startedAt}` or `null`). If Twitch doesn't answer, the last answer stays; before any answer duels count as
+  live. A duel while the channel is offline is `unrated:"offline"` and pays nothing. The same two fighters get
+  `pairRankedPerStream` (5; 0 = no limit) ranked duels per live stream; the next ones that stream are
+  `unrated:"pair_cap"` and pay half of `winDollars` and `lossDollars`, rounded down. Only ranked duels count
+  (`pairPlays` `{pair, at, stream}`, at most 2000); a new stream id drops the old plays, and plays saved before stream
+  ids count toward the stream they fall in (`at >= startedAt`). The pair's last ranked duel sets `duel.lastRanked`.
+  A duel where either fighter has a Twitch account under 7 days old (`NEW_ACCOUNT_MS`) is `unrated:"new_account"`.
+  The reason checks run in that order: offline, new account, pair limit. An unrated duel is played and shown and
+  still sets the rematch lock, the KO and `lastOpponentId`, but changes no Elo, wins or losses (`ratings` deltas are
+  0, no flawless bonus). The room asks Twitch for a saved fighter's account age once, when the fighter chats or
+  saves, and retries after an hour if Twitch doesn't answer; an unknown age counts as old (fails open). The "Fight
+  on" and result replies add "Just for fun (stream offline): no rank or dollars.", "Just for fun (a Twitch account
+  under 7 days old): no Elo or dollars." or "Just for fun (ranked limit for this pair reached): no Elo, pays half,
+  ranked again next stream."
 - An active duel with no action for `inactivityMs` is cancelled without scoring. Cancelled duels
   return both players to maxHp.
 - Upgrades (server/upgrades.ts): every win earns one point and check-ins add more (`bonus`), with no cap. Points buy levels in power (damage dealt), guard (damage taken), luck (the chance a quick-duel miss lands as a hit), crit (the chance a hit becomes a crit; in an HP fight, that a strike or heavy deals +50%), dodge (the chance a quick-duel hit or crit on you misses), counter (quick duels: +counter damage, and the chance a foe's miss becomes your counter) and vitality (+4 max hp a level, ceiling +60, in both duel kinds; the duel keeps each fighter's full hp in `duel.maxHp`, heals cap there, a flawless win needs it, and blows stay sized on the channel's base `maxHp`). Levels 1-8 cost 1 point each and give 4% each (counter: 2% damage and 2% chance); the cost doubles every 8 levels (9-16 cost 2, 17-24 cost 4), and above level 8 the effect closes in on a ceiling (power, guard and counter damage 60%, luck, crit, dodge and counter chance 50%; a 4% stat at level 16 gives about 44.2%). A quick-duel swing checks, in order and each with its own roll (`rolls[k * 24 + i]`, slot k: die 0, luck 1, crit 2, dodge 3, counter 4; the room sends 120 rolls): the attacker's luck, the attacker's crit, the defender's dodge, the defender's counter. Stored levels stop at 200. The channel's `maxStatLevel` caps the levels that count in its duels; levels above it stay saved. A rank reset that leaves too few points takes levels off vitality, then counter, dodge, crit, luck, guard and power. Profiles carry `bonus` (check-in points), `checkins` and `streak`; the profile answer's `upgrades` has `points`, `fromWins`, `fromCheckins` and `maxLevel`. The fighter page offers suggested builds (`PRESETS`) that fill the levels from the points; the viewer still saves. Points can be moved while the fighter is not in a duel. Hats are cosmetic; some unlock at a number of wins. A rank reset clears Elo and wins but keeps `bonus`.
-- Dollars: every finished ranked duel pays `winDollars` to the winner and `lossDollars` to the loser, saved fighters only. game.ts records it as `duel.payout` and the room adds it to `profiles.dollars` once, in the same transaction (`duel.paid`). Like Elo, a payout stays out of `!wallet`, `/api/profile` and the leaderboard until the stream has shown the fight. Profiles carry `dollars` (at most 1,000,000). Check-ins give points, not dollars. A rank reset, a profile save and a re-save keep dollars; removing a viewer deletes them.
+- Dollars: every finished ranked duel pays `winDollars` to the winner and `lossDollars` to the loser, saved fighters only (a `pair_cap` duel pays half, other unrated duels nothing). game.ts records it as `duel.payout` and the room adds it to `profiles.dollars` once, in the same transaction (`duel.paid`). Like Elo, a payout stays out of `!wallet`, `/api/profile` and the leaderboard until the stream has shown the fight. Profiles carry `dollars` (at most 1,000,000). Check-ins give points, not dollars. A rank reset, a profile save and a re-save keep dollars; removing a viewer deletes them.
 - `!wallet` (the StreamElements `wallet` action, also while duels are paused): "@x: $N PixFray dollars, P upgrade points, S-stream streak." Reasons: `wallet`, `no_fighter`.
 - Pets and the shop (server/pets.ts): 14 built-in pets in 5 tiers, plus up to 24 uploaded per channel. A fighter owns any number of pets (`owned_items`) and brings one (`profiles.pet`); hats can be bought too. A pet's boost is added after the channel's `maxStatLevel` cap: common and uncommon +1 to one stat, rare +2, epic +2 and +1 to a second stat (those use power, guard or luck), legendary +1 to 4 different stats out of all 7, rolled for each owner at purchase (`owned_items.roll`; legendaries bought before rolls existed get one when the room starts). Each owner may reroll a legendary once for free (`owned_items.rerolled`); the new set always differs, and it's refused while the fighter is in a challenge or duel. Pets cost `petPrice<Tier>` dollars; a hat whose wins aren't reached costs `hatPricePerWin` times the wins it needs. The overlay draws the pet behind its fighter at about 40% of its height; epic and legendary pets sparkle, legendary pets hover. Snapshot players and `/api/looks` carry `pet` and `petTier`; players also carry `petBoost`.
 - Cosmetics and builds (server/cosmetics.ts, drawn by src/served/cosmetics.ts): recolor (a CSS filter on the fighter), pet color (the same 8 tints on the pet), accessories, walking trails, win effects (about 3 s over the winner when the overlay shows the result), win taunts (a speech bubble then) and titles (under the nameplate). Each kind has one config price. Owned cosmetics are `owned_items` rows; the worn ones are profile columns. Build slots: 1 free, the 2nd costs `buildSlotPrice`, the 3rd to 5th `buildSlotPriceMore` each. Each slot keeps its own loadout in the `builds` table; saving to a slot makes it the one on stream, and every build can spend the full point pool. Removing a viewer deletes their builds; a rank reset keeps them.
 - `!pet [@name]` (the `pet` action): "@x's pet: Fox (rare), +2 power." Reasons: `pet`, `no_pet` (with the site link for the sender's own), `no_fighter`.
-- `!stats [@name]` (the `stats` action): "@x: Power 10, Guard 8, Crit 4. 12 points unspent. Pet: +2 power." The levels are those that count in duels (capped by `maxStatLevel`), from shown results only; "no upgrades yet" with none. Reasons: `stats`, `no_fighter`.
+- `!stats [@name]` (the `stats` action): "@x: Power 10, Guard 8, Crit 4. 12 points unspent. Pet: +2 power." The levels are those that count in duels (capped by `maxStatLevel`), from shown results only; "no upgrades yet" with none. With @name and a pair limit, it adds "N ranked duels left between you this stream." Reasons: `stats`, `no_fighter`.
 - `!pay @name amount` (the `give` action; on a channel the PixFray bot reads, it's `!give` and `!pay` stays an alias; `a=` is `20` or `$20`): moves dollars between two saved fighters while the channel is live (the same Twitch check as check-ins). In order it refuses with `give_off` (config `giveEnabled` false), `no_fighter`, `give_usage` (no target or no whole amount of at least 1), `target_not_found`, `self_give`, `twitch_error`, `not_live`, `too_few_duels` (fewer than `giveMinDuels` finished duels, `{duels, need}`), `give_cap` (already gave `giveMaxPerStream` this stream), `over_cap` (`{left}`), `not_enough` (`{dollars}`) and `target_full` (`{to, room}`: the receiver's wallet can't hold the amount, so nothing moves). Hidden duel results and payouts don't count yet. The limit is per Twitch stream id (`profiles.give_stream`, `given_in_stream`). Success is `given` with `{amount, to, dollars, left}`; the command log stores the amount.
 - Check-ins (the StreamElements `checkin` action; the test site's dev chat also takes `!checkin`, Twitch EventSub chat does not): once per stream, only while Twitch's Helix `/streams` says the channel is live (cached 60 s; a Twitch error answers "try again" and is not cached). Gives `checkinPoints` (bonus capped at 1,000,000). The streak counts the channel's streams in a row that had any check-in; one missed stream is forgiven once every 7 days. With `streakBonus`, a streak of 3, 7, 14 or 30 gives +1 more, 60 gives +2, 100 gives +3, 200 gives +5 and 365 gives +10. The reply names the total and what is unspent: "@x checked in: +2 points (7-stream streak, streak bonus). 18 points, 3 unspent. Spend them at <link>", or "…, all spent." with no link. Reasons: `checked_in`, `already_checked_in`, `not_live`, `no_fighter`, `twitch_error`. On the test Worker, `POST /api/devtools/<ch>/live` with `{live, streamId?}` (DEV_TOOLS_TOKEN only) replaces the Twitch answer: `true` is live, `false` is offline, and `null` goes back to asking Twitch.
 - Ranked play needs a saved profile (`ranked_sign_in_required`).
@@ -493,6 +506,7 @@ Viewer sprites (server/sprites.ts):
 | sharedCooldownMs | 1000 | 250 to 60000 |
 | initialElo | 1000 | 0 to 10000 |
 | eloK | 24 | 1 to 100 |
+| pairRankedPerStream | 5 | 0 to 50 (ranked duels per pair each live stream; 0 = no limit) |
 | checkinPoints | 1 | 0 to 3 (upgrade points per check-in) |
 | streakBonus | true | boolean (+1 point at a streak of 3, 7, 14 and 30 streams, +2 at 60, +3 at 100, +5 at 200, +10 at 365) |
 | maxStatLevel | 16 | 1 to 200 (the highest level of each upgrade stat that counts in this channel's duels) |
diff --git a/docs/DUELS.md b/docs/DUELS.md
index 33b2086..267307d 100644
--- a/docs/DUELS.md
+++ b/docs/DUELS.md
@@ -60,7 +60,8 @@ The duel is rolled at once, the moment the challenge is accepted.
 
 ## PixFray dollars
 
-- Ranked duels pay saved fighters: $5 a win, $3 a loss.
+- Ranked duels pay saved fighters: $5 a win, $3 a loss. Past the pair limit below, a duel pays half
+  ($2 and $1). Other unrated duels pay nothing.
 - `!wallet` shows your dollars.
 - `!pay @name 10` passes them on (`!give` on channels with the PixFray chat bot). You can pay after
   5 finished duels, at most $100 per stream, and only while the stream is live.
@@ -68,16 +69,22 @@ The duel is rolled at once, the moment the challenge is accepted.
 
 ## Ranked and unrated duels
 
-- The same two fighters get 5 ranked duels per rolling 24 hours. After that they still fight,
-  unrated.
+- Duels count only while the stream is live. Offline duels are unrated and pay nothing. If Twitch
+  can't say whether the stream is live, the last answer stands.
+- The same two fighters get 5 ranked duels per live stream (mods change the number; 0 means no
+  limit). The fifth result says "Last ranked duel between them this stream." After that they still
+  fight, unrated, for half the dollars, and they're ranked again next stream.
+- `!stats @name` adds how many ranked duels you have left against that fighter this stream.
 - A Twitch account under 7 days old also duels unrated. If Twitch can't say how old an account is,
   the duel is ranked.
-- An unrated duel moves no Elo, wins, losses or dollars, and the reply starts "Just for fun".
+- An unrated duel moves no Elo, wins or losses. The reply starts "Just for fun" and says why.
 
 ## What mods and the broadcaster control
 
 - Mods tune every number in the balance editor on the mod controls page. Every change is versioned
   and can be undone.
+- Mods reset one pair's ranked duels for this stream with `!resetpair @name @name` in chat or
+  "Reset pair count" on the mod page.
 - Only the broadcaster (or the site owner) can reset all ranks, make a new StreamElements key, turn
   PixFray off or move chat from another site.
 - Turning PixFray off keeps every fighter and rank.
diff --git a/server/channel.ts b/server/channel.ts
index 189fd12..a3e4234 100644
--- a/server/channel.ts
+++ b/server/channel.ts
@@ -8,6 +8,7 @@ import {
   hiddenResults,
   NEW_ACCOUNT_MS,
   normalizeGameState,
+  pairRankedLeft,
   parseGameCommand,
   reduceGame,
   shownProfile,
@@ -958,6 +959,13 @@ export class ChannelRoom extends DurableObject<Env> {
           gift.ok ? 200 : gift.reason === "profile_not_found" ? 404 : 400,
         );
       }
+      if (action === "resetPair") {
+        const out = this.resetPair(channel, payload.a, payload.b, actorId, actorName);
+        return json(
+          out.ok ? out : { ...out, error: out.reason },
+          out.ok ? 200 : out.reason === "profile_not_found" ? 404 : 400,
+        );
+      }
       if (action === "saveCommand" || action === "deleteCommand" || action === "setCounter") {
         const out = this.editBotCommands(channel, action, payload, actorName || actorId);
         return json(
@@ -1110,7 +1118,7 @@ export class ChannelRoom extends DurableObject<Env> {
         },
       };
       await this.checkAccountAge(userId);
-      const result = this.processChatMessage(channel, msg, now);
+      const result = this.processChatMessage(channel, msg, now, await this.streamNews(channel, line, now));
       if (result.visible) this.broadcast(result.state);
       if (result.changed) await this.scheduleAlarm(result.state);
       const r = result.result || ({} as GameResult); // processChatMessage always has a result; {} only guards against none
@@ -1820,7 +1828,12 @@ export class ChannelRoom extends DurableObject<Env> {
     } else if (kind === "notification" && msg.bot === true) return this.botCommand(channel, msg, origin);
     else if (kind === "notification") {
       await this.checkAccountAge(msg.event?.chatter_user_id);
-      result = this.processChatMessage(channel, msg, now);
+      result = this.processChatMessage(
+        channel,
+        msg,
+        now,
+        await this.streamNews(channel, msg.event?.message?.text, now),
+      );
     } else return json({ ok: true, ignored: true });
     if (result.visible) this.broadcast(result.state);
     if (result.changed) await this.scheduleAlarm(result.state);
@@ -1931,7 +1944,9 @@ export class ChannelRoom extends DurableObject<Env> {
       !Object.values(settings.names).some((n) => String(n).toLowerCase() === first)
     )
       action = BOT_ALIASES[first];
-    if (!action && !custom) return json({ ok: true, reason: "not_command", reply: "" });
+    // !resetpair @a @b (broadcaster or a mod) has a fixed name, like !fray debug.
+    const resetPair = first === "!resetpair" && !action && !custom;
+    if (!action && !custom && !resetPair) return json({ ok: true, reason: "not_command", reply: "" });
     const subscriptionId = String(msg.subscription?.id || "");
     const state = this.readState(channel);
     if (!subscriptionId || subscriptionId !== state.chat.subscriptionId) {
@@ -1990,6 +2005,23 @@ export class ChannelRoom extends DurableObject<Env> {
       if (!line) this.noteBotHeld(channel, "cooldown", { command: custom.name }, false);
       return this.sendBotLines([line], channel);
     }
+    if (resetPair) {
+      const actor = String(ev.chatter_user_login || "").slice(0, 48);
+      if (!boss) return this.sendBotLines(["Only the broadcaster or a mod can use !resetpair."], channel);
+      if (!words[1] || !words[2])
+        return this.sendBotLines(["Type !resetpair @name @name to reset a pair's ranked duels."], channel);
+      const out = this.resetPair(channel, words[1], words[2], chatterId, actor);
+      return this.sendBotLines(
+        [
+          out.ok
+            ? `Ranked duels reset for ${out.a} and ${out.b}: ${typeof out.left === "number" ? out.left + " left this stream" : "no limit on this channel"}.`
+            : out.reason === "profile_not_found"
+              ? `@${normalizeUsername(String(out.missing || "").replace(/^@/, ""))} has no saved fighter on this channel.`
+              : "Pick two different fighters: !resetpair @name @name",
+        ],
+        channel,
+      );
+    }
     // "!fray debug" (broadcaster, mods or the bot account): the bot's health in one line, as the admin page shows it.
     if (action === "help" && String(words[1] || "").toLowerCase() === "debug") {
       const userId = validUserId(ev.chatter_user_id),
@@ -2320,7 +2352,7 @@ export class ChannelRoom extends DurableObject<Env> {
     if (action === "stats") {
       // like !pet, it works while duels are paused
       const self = !target || target === username,
-        info = this.statsInfo(channel, self ? { userId } : { username: target });
+        info = this.statsInfo(channel, self ? { userId } : { username: target, asker: userId });
       return done(
         // the sender's name as sent; short() reads it through String()
         seStatsText(info, {
@@ -2413,7 +2445,12 @@ export class ChannelRoom extends DurableObject<Env> {
       },
     };
     await this.checkAccountAge(userId);
-    const result = this.processChatMessage(channel, msg, Date.now());
+    const result = this.processChatMessage(
+      channel,
+      msg,
+      Date.now(),
+      await this.streamNews(channel, msg.event?.message?.text, now),
+    );
     if (result.visible) this.broadcast(result.state);
     if (result.changed) await this.scheduleAlarm(result.state);
     const r = result.result || ({} as GameResult); // processChatMessage always has a result; {} only guards against none
@@ -2814,7 +2851,10 @@ export class ChannelRoom extends DurableObject<Env> {
   // !pet [@name]: a saved fighter's active pet as the catalog names it, or null when there's no such fighter.
   // !stats [@name]: the upgrade levels that count in duels, unspent points and the pet's boost, as the stream has shown
   // them (a quick duel still playing doesn't give its win away, like !wallet).
-  statsInfo(channel: string, { userId = "", username = "" }: { userId?: string; username?: string }) {
+  statsInfo(
+    channel: string,
+    { userId = "", username = "", asker = "" }: { userId?: string; username?: string; asker?: string },
+  ) {
     const state = this.readState(channel);
     const found = userId ? this.getProfile(userId, state.config) : this.getProfileByUsername(username, state.config);
     if (!found) return null;
@@ -2825,6 +2865,7 @@ export class ChannelRoom extends DurableObject<Env> {
       stats: effectiveStats(own, profile.wins, profile.bonus, null, state.config.maxStatLevel),
       unspent: Math.max(0, pointsFor(profile.wins, profile.bonus) - spentOn(own)),
       petBoost: profile.petBoost,
+      rankedLeft: asker && asker !== profile.userId ? pairRankedLeft(state, asker, profile.userId) : null,
     };
   }
 
@@ -2879,6 +2920,40 @@ export class ChannelRoom extends DurableObject<Env> {
     };
   }
 
+  // Mods start one pair's ranked count for this stream over (game.ts resetPair), by Twitch login, from the mod page or
+  // !resetpair @a @b in chat.
+  resetPair(channel: string, a: unknown, b: unknown, actorId: string, actorName: string) {
+    const config = this.readState(channel).config,
+      find = (name: unknown) =>
+        this.getProfileByUsername(normalizeUsername(String(name || "").replace(/^@/, "")), config);
+    const one = find(a),
+      two = find(b);
+    if (!one || !two)
+      return { ok: false, reason: "profile_not_found", missing: one ? String(b || "") : String(a || "") };
+    const out = this.advance(
+      channel,
+      { type: "admin", actorId, actorName, action: "resetPair", payload: { a: one.userId, b: two.userId } },
+      Date.now(),
+    );
+    if (!out.result.ok) return { ok: false, reason: out.result.reason || "invalid_pair" };
+    logRoomEvent(this, "command", `${actorName || actorId} reset pair ${one.username} ${two.username}`, {
+      channel,
+      action: "resetPair",
+      actorId,
+      actorName,
+      a: one.username,
+      b: two.username,
+      amount: out.result.amount,
+    });
+    return {
+      ok: true,
+      reason: "pair_reset",
+      a: one.displayName || one.username,
+      b: two.displayName || two.username,
+      left: pairRankedLeft(out.state, one.userId, two.userId),
+    };
+  }
+
   // Dollars for finished duels: game.ts finishDuel sets duel.payout, and this adds it to the saved profiles once
   // (duel.paid). Called inside the transaction that wrote the result; returns true when the state needs writing.
   payDuels(state: GameState): boolean {
@@ -3107,6 +3182,30 @@ export class ChannelRoom extends DurableObject<Env> {
     return stream;
   }
 
+  // The live check for a chat line that can start a duel (game.ts noteStream): {id, startedAt}, null offline, or
+  // undefined (another command, no Twitch app, or Twitch didn't answer) so the room keeps its last answer.
+  async streamNews(
+    channel: string,
+    text: unknown,
+    now: number,
+  ): Promise<{ id: string; startedAt: number } | null | undefined> {
+    const action = parseGameCommand(text)?.action;
+    if (action !== "duel" && action !== "accept" && action !== "rematch") return undefined;
+    const dev =
+      Boolean(this.env?.DEV_TOOLS_TOKEN) &&
+      this.ctx.storage.sql.exec("SELECT 1 FROM dev_live WHERE id = 1").toArray().length > 0;
+    if (!dev && !this.env?.TWITCH_CLIENT_ID) return undefined;
+    try {
+      return await this.currentStream(channel, now);
+    } catch (error) {
+      // anything can be thrown
+      logRoomEvent(this, "warn", `live check failed: ${String((error as Thrown)?.message || error).slice(0, 80)}`, {
+        channel,
+      });
+      return undefined;
+    }
+  }
+
   // A saved fighter's Twitch account age, asked once (again after ACCOUNT_RETRY_MS while Twitch doesn't answer).
   async checkAccountAge(userId: unknown): Promise<void> {
     const id = validUserId(userId),
@@ -3180,7 +3279,12 @@ export class ChannelRoom extends DurableObject<Env> {
 
   // One channel.chat.message: a presence update, plus a game command when the text parses as one.
   // No chat replies; rejected commands are logged to the room event list.
-  processChatMessage(channel: string, msg: BotMessage, now: number): ChatOutcome {
+  processChatMessage(
+    channel: string,
+    msg: BotMessage,
+    now: number,
+    stream?: { id: string; startedAt: number } | null,
+  ): ChatOutcome {
     const ev: Partial<ChatEvent> = msg.event && typeof msg.event === "object" ? msg.event : {};
     const userId = validUserId(ev.chatter_user_id);
     const username = normalizeUsername(ev.chatter_user_login);
@@ -3244,6 +3348,7 @@ export class ChannelRoom extends DurableObject<Env> {
             newAccounts,
             quick: subscriptionId === SE_SUBSCRIPTION_ID || msg.quick === true,
             rolls: Array.from({ length: 120 }, () => Math.random()), // 5 slots of 24 (settleQuickDuel)
+            ...(stream !== undefined ? { stream } : {}),
           });
           if (!main.result.ok && main.result.reason !== "duplicate")
             step({
@@ -3474,6 +3579,7 @@ export class ChannelRoom extends DurableObject<Env> {
         decision: d.decision,
         flawless: d.flawless,
         unrated: d.unrated,
+        lastRanked: d.lastRanked,
       });
       const { replies } = await this.sendBotLines([line], channel, { system: 1 }).json<{ replies: string[] }>(); // sendBotLines's answer
       if (!replies.length) return;
diff --git a/server/game.ts b/server/game.ts
index baf361b..b57e54f 100644
--- a/server/game.ts
+++ b/server/game.ts
@@ -62,6 +62,8 @@ const DEFAULT_CONFIG: Config = {
   // PixFray dollars (server/channel.ts payDuels, give). Saved fighters earn them per finished duel.
   winDollars: 5,
   lossDollars: 3,
+  // Ranked duels per pair of fighters per live stream (0 = no limit). Past it they duel unrated for half the dollars.
+  pairRankedPerStream: 5,
   // !give @name amount: on/off, the most one viewer can give per stream, and the finished duels needed first.
   giveEnabled: true,
   giveMaxPerStream: 100,
@@ -134,11 +136,10 @@ const MAX_RECENT_EVENTS = 100;
 const MAX_APPLIED_MESSAGE_IDS = 1_000;
 const MAX_DUEL_HISTORY = 25;
 const ACTIVE_TTL_MS = 10 * 60_000;
-// Anti-farming: the same two fighters get PAIR_RATED_PER_DAY duels that count per 24 h, and a Twitch account younger
-// than NEW_ACCOUNT_MS (the room looks it up) can duel but doesn't move Elo, wins or dollars.
-export const PAIR_RATED_PER_DAY = 5;
+// Anti-farming: the same two fighters get config.pairRankedPerStream duels that count per live stream, and a Twitch
+// account younger than NEW_ACCOUNT_MS (the room looks it up) can duel but doesn't move Elo, wins or dollars.
 export const NEW_ACCOUNT_MS = 7 * 86_400_000;
-const PAIR_WINDOW_MS = 86_400_000;
+const MAX_PAIR_PLAYS = 2_000;
 // Set<unknown> so has() can test values nobody has checked yet.
 const ABILITIES = new Set<unknown>(["strike", "heavy", "heal"]);
 
@@ -391,7 +392,6 @@ function expireState(state: GameState, now: number): boolean {
   }
 
   state.rematchLocks = state.rematchLocks.filter((lock) => lock.until > now);
-  state.pairPlays = state.pairPlays.filter((play) => now - play.at < PAIR_WINDOW_MS);
   const inDuel = new Set(openDuels(state).flatMap((duel) => [duel.a, duel.b]));
   const before = state.players.length;
   state.players = state.players.filter(
@@ -482,15 +482,45 @@ function createChallenge(state: GameState, actor: Player, target: Player, now: n
   return { ok: true, duelId: duel.id };
 }
 
+// The room's latest answer to "is the channel live?" (undefined: no answer this time, keep the last one). A new stream
+// drops the pair counts of earlier ones.
+function noteStream(state: GameState, news: unknown): void {
+  if (news === undefined) return;
+  const live =
+    news && typeof news === "object" && "id" in news && typeof news.id === "string" && news.id
+      ? { id: news.id, startedAt: "startedAt" in news && Number.isFinite(news.startedAt) ? Number(news.startedAt) : 0 }
+      : null;
+  if (live && state.stream?.id !== live.id) state.pairPlays = state.pairPlays.filter((play) => countsFor(play, live));
+  state.stream = live;
+}
+
+// Pair counts from before streams were tracked carry no stream id; they count for the stream they fall in.
+function countsFor(play: GameState["pairPlays"][number], stream: GameState["stream"]): boolean {
+  if (!stream) return !play.stream;
+  return play.stream === stream.id || (play.stream === undefined && play.at >= stream.startedAt);
+}
+
+/** Ranked duels these two fighters have left this stream, or null when the channel sets no limit. */
+export function pairRankedLeft(state: GameState, a: string, b: string): number | null {
+  const cap = state.config.pairRankedPerStream;
+  if (!(cap > 0)) return null;
+  const pair = pairKey(a, b);
+  return Math.max(
+    0,
+    cap - state.pairPlays.filter((play) => play.pair === pair && countsFor(play, state.stream)).length,
+  );
+}
+
 function beginDuel(state: GameState, duel: Duel, now: number, event: { newAccounts?: unknown } = {}): GameResult {
   const a = player(state, duel.a);
   const b = player(state, duel.b);
   if (!a?.registered || !b?.registered) return { ok: false, reason: "ranked_sign_in_required" };
   const young = Array.isArray(event.newAccounts) ? event.newAccounts : [];
-  const pair = pairKey(duel.a, duel.b),
-    plays = state.pairPlays.filter((play) => play.pair === pair && now - play.at < PAIR_WINDOW_MS).length;
-  if (young.includes(duel.a) || young.includes(duel.b)) duel.unrated = "new_account";
-  else if (plays >= PAIR_RATED_PER_DAY) duel.unrated = "pair_cap";
+  const left = pairRankedLeft(state, duel.a, duel.b);
+  if (state.stream === null) duel.unrated = "offline";
+  else if (young.includes(duel.a) || young.includes(duel.b)) duel.unrated = "new_account";
+  else if (left === 0) duel.unrated = "pair_cap";
+  else if (left === 1) duel.lastRanked = true;
   state.round += 1;
   duel.round = state.round;
   duel.status = "active";
@@ -702,7 +732,7 @@ function finishDuel(
   if (!a || !b) return;
   const ratingA = a.elo;
   const ratingB = b.elo;
-  // An unrated duel (new account, or the pair's daily cap) is played out but changes no Elo, wins, losses or dollars.
+  // An unrated duel (offline, new account, or past the pair's limit) is played out but changes no Elo, wins or losses.
   const rated = !duel.unrated;
   if (!rated) bonus = 0;
   const expectedA = 1 / (1 + Math.pow(10, (ratingB - ratingA) / 400));
@@ -722,7 +752,11 @@ function finishDuel(
     b.wins += 1;
     a.losses += 1;
   }
-  if (rated) state.pairPlays.push({ pair: pairKey(duel.a, duel.b), at: now });
+  if (rated && state.config.pairRankedPerStream > 0)
+    state.pairPlays = [
+      ...state.pairPlays,
+      { pair: pairKey(duel.a, duel.b), at: now, stream: state.stream?.id || "" },
+    ].slice(-MAX_PAIR_PLAYS);
   // The loser is knocked out (hp 0) and respawns at full health after respawnMs; the winner is healed at once.
   const winner = winnerId === duel.a ? a : b;
   const loser = winnerId === duel.a ? b : a;
@@ -745,10 +779,12 @@ function finishDuel(
     duel.ratings[winnerId]!.bonus = bonus;
     duel.flawless = true;
   }
-  // Dollars for saved fighters; the room adds them to the profiles once (server/channel.ts payDuels).
+  // Dollars for saved fighters; the room adds them to the profiles once (server/channel.ts payDuels). Past the pair's
+  // limit a duel pays half; offline and new-account duels pay nothing.
+  const pay = (amount: number): number => (rated ? amount : duel.unrated === "pair_cap" ? Math.floor(amount / 2) : 0);
   const payout: Record<string, number> = {};
-  if (rated && winner.registered && state.config.winDollars > 0) payout[winner.userId] = state.config.winDollars;
-  if (rated && loser.registered && state.config.lossDollars > 0) payout[loser.userId] = state.config.lossDollars;
+  if (winner.registered && pay(state.config.winDollars) > 0) payout[winner.userId] = pay(state.config.winDollars);
+  if (loser.registered && pay(state.config.lossDollars) > 0) payout[loser.userId] = pay(state.config.lossDollars);
   if (Object.keys(payout).length) duel.payout = payout;
   if (decision !== "ko") duel.decision = decision;
   state.rematchLocks.push({
@@ -946,6 +982,7 @@ function validateConfigPatch(patch: Untrusted): { ok: true; patch: ConfigPatch }
     maxStatLevel: [1, 200],
     winDollars: [0, 100],
     lossDollars: [0, 100],
+    pairRankedPerStream: [0, 50],
     giveMaxPerStream: [0, 10_000],
     giveMinDuels: [0, 1_000],
     reminderMin: [0, 240],
@@ -1133,12 +1170,24 @@ function applyAdmin(state: GameState, event: AdminEvent, now: number): GameResul
       p.losses = 0;
       dirtyProfileIds.push(p.userId);
     }
-    // a fresh start for everyone, so the daily pair counts start over too
+    // a fresh start for everyone, so the pair counts start over too
     state.pairPlays = [];
     addEvent(state, "all_ranks_reset", now, { actorId });
     return { ok: true, reason: "all_ranks_reset", dirtyProfileIds, resetAllRanks: true, deletedProfileIds };
   }
 
+  // Mods start one pair's ranked count for this stream over (the room resolves the two names to user ids).
+  if (action === "resetPair") {
+    const a = normalizeUserId(payload.a),
+      b = normalizeUserId(payload.b);
+    if (!a || !b || a === b) return { ok: false, reason: "invalid_pair" };
+    const pair = pairKey(a, b),
+      before = state.pairPlays.length;
+    state.pairPlays = state.pairPlays.filter((play) => play.pair !== pair);
+    addEvent(state, "pair_reset", now, { actorId, a, b });
+    return { ok: true, reason: "pair_reset", amount: before - state.pairPlays.length };
+  }
+
   if (action === "resetAll") {
     // docs/CONTRACTS.md: clears players, duels and rematch locks; stored profiles and ranks stay.
     for (const duel of openDuels(state)) cancelDuel(state, duel, now, "moderator_reset");
@@ -1398,6 +1447,7 @@ export function reduceGame(inputState: StoredState, event: GameEvent, now: numbe
     else if (!Number.isFinite(event.timestamp) || now - event.timestamp > 60_000 || event.timestamp - now > 10_000)
       result = { ok: false, reason: "stale_command" };
     else {
+      noteStream(state, event.stream);
       const userId = normalizeUserId(event.userId);
       const parsed = parseGameCommand(event.text);
       const actor = recentProfile(
@@ -1487,6 +1537,7 @@ function normalizeState(input: StoredState): GameState {
   state.duels = Array.isArray(state.duels) ? state.duels : [];
   state.rematchLocks = Array.isArray(state.rematchLocks) ? state.rematchLocks : [];
   state.pairPlays = Array.isArray(state.pairPlays) ? state.pairPlays : [];
+  if (state.stream && typeof state.stream.id !== "string") delete state.stream;
   state.events = Array.isArray(state.events) ? state.events.slice(-MAX_RECENT_EVENTS) : [];
   state.appliedMessageIds = Array.isArray(state.appliedMessageIds)
     ? state.appliedMessageIds.slice(-MAX_APPLIED_MESSAGE_IDS)
diff --git a/server/model.ts b/server/model.ts
index 707395d..d737304 100644
--- a/server/model.ts
+++ b/server/model.ts
@@ -48,6 +48,7 @@ export type Config = {
   maxStatLevel: number;
   winDollars: number;
   lossDollars: number;
+  pairRankedPerStream: number;
   giveEnabled: boolean;
   giveMaxPerStream: number;
   giveMinDuels: number;
@@ -149,8 +150,10 @@ export type Duel = {
   /** userId -> full health in this duel: rules.maxHp plus vitality (server/upgrades.ts bonusHp). */
   maxHp?: Record<string, number>;
   cooldowns?: Record<string, Cooldowns>;
-  /** Played out, but moves no Elo, wins, losses or dollars. */
-  unrated?: "new_account" | "pair_cap";
+  /** Played out, but moves no Elo, wins or losses. Only "pair_cap" pays dollars, half (finishDuel). */
+  unrated?: "offline" | "new_account" | "pair_cap";
+  /** The pair's last ranked duel this stream (config.pairRankedPerStream). */
+  lastRanked?: boolean;
   endedAt?: number;
   cancelReason?: string;
   ratings?: Record<string, Rating>;
@@ -190,7 +193,10 @@ export type GameState = {
   players: Player[];
   duels: Duel[];
   rematchLocks: { pair: string; until: number }[];
-  pairPlays: { pair: string; at: number }[];
+  /** Ranked duels per pair; `stream` is the stream id ("" when never known, missing on entries from before 2026-10-15). */
+  pairPlays: { pair: string; at: number; stream?: string }[];
+  /** The channel's live stream as the room last saw it: null offline, missing before the first answer (counts as live). */
+  stream?: { id: string; startedAt: number } | null;
   events: GameLogEvent[];
   appliedMessageIds: string[];
   nextDuelId: number;
@@ -210,6 +216,9 @@ export type AdminPayload = {
   elo?: unknown;
   wins?: unknown;
   losses?: unknown;
+  /** resetPair: the two fighters' user ids. */
+  a?: unknown;
+  b?: unknown;
 };
 
 /** A chat command as the room hands it to the reducer (server/channel.ts processChatMessage). */
@@ -230,6 +239,8 @@ export type CommandEvent = {
   quick?: unknown;
   /** Numbers in [0, 1) for a quick duel; missing ones come from a hash. */
   rolls?: unknown;
+  /** The room's live check for commands that can start a duel: {id, startedAt}, null offline, undefined unknown. */
+  stream?: unknown;
 };
 
 export type AdminEvent = AdminPayload & {
diff --git a/server/streamelements.ts b/server/streamelements.ts
index e0481bc..55e8203 100644
--- a/server/streamelements.ts
+++ b/server/streamelements.ts
@@ -1,7 +1,7 @@
 // StreamElements chat source. Each game action is a StreamElements custom command whose reply is
 // $(customapi <url>): the bot GETs /api/se/<channel>/<action>?k=..&id=..&u=..&d=..&t=..&m=.. and posts our reply.
 // The trigger word lives only in StreamElements, so commands can be renamed there freely.
-import { hiddenResults, PAIR_RATED_PER_DAY } from "./game.ts";
+import { hiddenResults } from "./game.ts";
 import { boostText } from "./pets.ts";
 import type { Env } from "./env.ts";
 import type { GameResult, GameState, Player } from "./model.ts";
@@ -256,13 +256,16 @@ export function seExpiredText({
 
 // The bot's line once the stream has played a duel (duel.revealAt): who won, how, and both Elo changes. Never earlier, so
 // chat doesn't spoil the stream. On a bot channel this line is the winner announcement (the overlay shows no banner).
-// Why a duel counted for nothing (server/game.ts beginDuel).
-const UNRATED_TEXT: { [reason: string]: string } = {
-  new_account: "a Twitch account under 7 days old",
-  pair_cap: `${PAIR_RATED_PER_DAY} ranked duels between them in 24 h already`,
-};
+// Why a duel moved no rank (server/game.ts beginDuel), and what it still pays (finishDuel).
 export const unratedText = (reason: string): string =>
-  UNRATED_TEXT[reason] ? `Just for fun (${UNRATED_TEXT[reason]}): no Elo or dollars.` : "";
+  reason === "offline"
+    ? "Just for fun (stream offline): no rank or dollars."
+    : reason === "new_account"
+      ? "Just for fun (a Twitch account under 7 days old): no Elo or dollars."
+      : reason === "pair_cap"
+        ? "Just for fun (ranked limit for this pair reached): no Elo, pays half, ranked again next stream."
+        : "";
+export const LAST_RANKED_TEXT = "Last ranked duel between them this stream.";
 
 /** One fighter's Elo change, as in duel.ratings; missing fields print as "undefined" and +0. */
 type ResultRating = { after?: number | undefined; delta?: number | undefined };
@@ -275,6 +278,7 @@ export function seResultText({
   decision = "ko",
   flawless = false,
   unrated = "",
+  lastRanked = false,
 }: {
   winner?: string | undefined;
   loser?: string | undefined;
@@ -283,6 +287,7 @@ export function seResultText({
   decision?: string | undefined;
   flawless?: boolean | undefined;
   unrated?: string | undefined;
+  lastRanked?: boolean | undefined;
 } = {}): string {
   // x as number: undefined < 0 is false, so a missing delta prints as +0
   const d = (x: number | undefined) => ((x as number) < 0 ? "-" : "+") + Math.abs(Number(x) || 0);
@@ -290,7 +295,10 @@ export function seResultText({
     (decision === "hp" ? " on HP" : decision === "sudden_death" ? " in sudden death" : "") +
     (flawless ? ", flawless" : "");
   if (unrated) return `${winner} beat ${loser}${how}! ${unratedText(unrated)}`;
-  return `${winner} beat ${loser}${how}! ${winner} ${w.after} Elo (${d(w.delta)}), ${loser} ${l.after} Elo (${d(l.delta)}).`;
+  return (
+    `${winner} beat ${loser}${how}! ${winner} ${w.after} Elo (${d(w.delta)}), ${loser} ${l.after} Elo (${d(l.delta)}).` +
+    (lastRanked ? " " + LAST_RANKED_TEXT : "")
+  );
 }
 
 // A channel on the PixFray bot has no StreamElements in the way, so its give command is !give (unless mods renamed it).
@@ -430,9 +438,10 @@ export function sePetText(
 }
 
 // !stats [@name]: s = ChannelRoom.statsInfo() -> { name, stats (levels that count in duels), unspent, petBoost }, or
-// null (no fighter). "@x: Power 10, Guard 8, Crit 4. 12 points unspent. Pet: +2 power."
+// null (no fighter). "@x: Power 10, Guard 8, Crit 4. 12 points unspent. Pet: +2 power." For someone else, `rankedLeft`
+// (ranked duels left between the sender and them this stream; missing when the channel has no limit) is appended.
 export function seStatsText(
-  s: { name: string; stats: Stats; unspent: number; petBoost: Stats } | null | undefined,
+  s: { name: string; stats: Stats; unspent: number; petBoost: Stats; rankedLeft?: number | null } | null | undefined,
   {
     who = "",
     target = "",
@@ -446,7 +455,10 @@ export function seStatsText(
   const pet = boostText(s.petBoost);
   return (
     `@${target ? short(s.name) : me}: ${levels.length ? levels.join(", ") : "no upgrades yet"}. ` +
-    `${s.unspent} point${s.unspent === 1 ? "" : "s"} unspent.${pet ? " Pet: " + pet + "." : ""}`
+    `${s.unspent} point${s.unspent === 1 ? "" : "s"} unspent.${pet ? " Pet: " + pet + "." : ""}` +
+    (target && typeof s.rankedLeft === "number"
+      ? ` ${s.rankedLeft} ranked duel${s.rankedLeft === 1 ? "" : "s"} left between you this stream.`
+      : "")
   );
 }
 
@@ -550,7 +562,7 @@ export function seReplyText({
       const [a, b] = duel ? [duel.a, duel.b] : [actorId, other];
       return (
         `Fight on: ${nameOf(state, a)} vs ${nameOf(state, b)}! Watch the stream for the winner.` +
-        (duel?.unrated ? " " + unratedText(duel.unrated) : "")
+        (duel?.unrated ? " " + unratedText(duel.unrated) : duel?.lastRanked ? " " + LAST_RANKED_TEXT : "")
       );
     }
     if (!duel) return MISSED_TEXT; // ok but no duel = the text didn't parse as a command
diff --git a/src/admin.ts b/src/admin.ts
index 08d2775..5e27bfb 100644
--- a/src/admin.ts
+++ b/src/admin.ts
@@ -116,6 +116,13 @@ const GROUPS: { title: string; visible?: (config: Config, admin: Admin) => boole
     fields: [
       { key: "initialElo", label: "Starting Elo", unit: "Elo", min: 0, max: 10000 },
       { key: "eloK", label: "Elo K-factor", unit: "K", min: 1, max: 100 },
+      {
+        key: "pairRankedPerStream",
+        label: "Ranked duels per pair each stream (0: no limit)",
+        unit: "duels",
+        min: 0,
+        max: 50,
+      },
     ],
   },
   // !checkin (server/channel.ts checkin) and how far upgrade levels count here (server/upgrades.ts effectiveStats).
@@ -668,6 +675,44 @@ async function act(
   ($("#gift-amount") as HTMLInputElement).value = "";
   await loadLeaderboard();
 });
+// Pair reset: one pair's ranked duels this stream start over (server/channel.ts resetPair), like !resetpair in chat.
+// element type from the page HTML
+($("#pair-form") as HTMLFormElement).addEventListener("submit", async (e) => {
+  e.preventDefault();
+  // element type from the page HTML
+  const status = $("#pair-status") as HTMLParagraphElement,
+    // element type from the page HTML
+    a = ($("#pair-a") as HTMLInputElement).value.trim().replace(/^@/, ""),
+    // element type from the page HTML
+    b = ($("#pair-b") as HTMLInputElement).value.trim().replace(/^@/, "");
+  if (![a, b].every((name) => /^[a-z0-9_]{1,25}$/i.test(name)))
+    return setStatus(status, "Type both viewers' Twitch names.", "error");
+  if (a.toLowerCase() === b.toLowerCase()) return setStatus(status, "Pick two different viewers.", "error");
+  // element type from the page HTML
+  const button = $("#pair-send") as HTMLButtonElement;
+  button.disabled = true;
+  setStatus(status, "Saving…");
+  const r = await api("/api/admin/" + CHANNEL, { method: "POST", body: { action: "resetPair", payload: { a, b } } });
+  button.disabled = false;
+  if (!r.ok)
+    return setStatus(
+      status,
+      r.status === 404
+        ? (r.data?.missing || a + " or " + b) + " has no saved fighter on " + CHANNEL + "."
+        : "Couldn't reset: " + errorText(r) + ".",
+      "error",
+    );
+  setStatus(
+    status,
+    "Reset " +
+      r.data.a +
+      " and " +
+      r.data.b +
+      ": " +
+      (typeof r.data.left === "number" ? r.data.left + " ranked duels left this stream." : "no limit on this channel."),
+    "ok",
+  );
+});
 // element type from the page HTML
 ($("#reset-all-ranks") as HTMLButtonElement).addEventListener("click", (e) =>
   act("resetAllRanks", undefined, {
diff --git a/tests/channel.test.ts b/tests/channel.test.ts
index 8df749c..bf9eff2 100644
--- a/tests/channel.test.ts
+++ b/tests/channel.test.ts
@@ -3090,10 +3090,57 @@ test("!stats: own levels that count, unspent points and the pet; @name for someo
       })
     ).body.reply;
   assert.equal(await stats("u1", "alice"), "@alice: Power 2, Vitality 3. 5 points unspent.");
-  assert.equal(await stats("u1", "alice", "bob"), "@bob: no upgrades yet. 0 points unspent.");
+  assert.equal(
+    await stats("u1", "alice", "bob"),
+    "@bob: no upgrades yet. 0 points unspent. 5 ranked duels left between you this stream.",
+  );
   assert.match(await stats("u1", "alice", "nobody"), /nobody/);
 });
 
+test("!resetpair @a @b: mods start a pair's ranked count for this stream over; the mod page does the same", async () => {
+  const r = botRoom({});
+  await r.save("u1", "alice");
+  await r.save("u2", "bob");
+  await r.save("u3", "cara");
+  await r.connectChat("sub-bot");
+  const plays = (pair: string, n: number) => Array.from({ length: n }, (_, i) => ({ pair, at: 1 + i, stream: "" }));
+  const seed = () => {
+    const live = r.readState("nesszerra");
+    live.pairPlays = [...plays("u1:u2", 5), ...plays("u1:u3", 2)];
+    r.writeState(live);
+  };
+  seed();
+  assert.match((await r.say("u1", "alice", "!resetpair @alice @bob")).reply, /only the broadcaster or a mod/i);
+  assert.equal(r.readState("nesszerra").pairPlays.length, 7, "a viewer changes nothing");
+  assert.equal(
+    (await r.say("u9", "modmia", "!resetpair @Alice @bob", { mod: true })).reply,
+    "Ranked duels reset for alice and bob: 5 left this stream.",
+  );
+  assert.deepEqual(
+    r.readState("nesszerra").pairPlays.map((p) => p.pair),
+    ["u1:u3", "u1:u3"],
+    "only that pair's count is cleared",
+  );
+  assert.equal(
+    (await r.say("u9", "modmia", "!resetpair @alice @nobody", { mod: true })).reply,
+    "@nobody has no saved fighter on this channel.",
+  );
+  assert.match((await r.say("u9", "modmia", "!resetpair @alice", { mod: true })).reply, /!resetpair @name @name/);
+  assert.match((await r.say("u9", "modmia", "!resetpair @bob @bob", { mod: true })).reply, /two different fighters/);
+  seed();
+  const page = await r.call("/admin", {
+    method: "POST",
+    body: { actorId: "mod1", action: "resetPair", payload: { a: "@BOB", b: "alice" } },
+  });
+  assert.deepEqual([page.status, page.body.ok, page.body.left], [200, true, 5]);
+  assert.equal(r.readState("nesszerra").pairPlays.length, 2);
+  const missing = await r.call("/admin", {
+    method: "POST",
+    body: { actorId: "mod1", action: "resetPair", payload: { a: "bob", b: "zed" } },
+  });
+  assert.deepEqual([missing.status, missing.body.error], [404, "profile_not_found"]);
+});
+
 test("legendary rolls: 4 different stats in STATS order, never the set it replaces; stored text parses back", () => {
   let i = 0;
   const seq = (values: number[]) => () => must(values[i++ % values.length]);
diff --git a/tests/game.test.ts b/tests/game.test.ts
index 26c5f3a..58dd907 100644
--- a/tests/game.test.ts
+++ b/tests/game.test.ts
@@ -9,6 +9,7 @@ import {
   shownProfile,
   replayMs,
   normalizeGameState,
+  pairRankedLeft,
 } from "../server/game.ts";
 import type {
   CommandEvent,
@@ -50,6 +51,8 @@ type Arena = {
   player(login: string): Player;
   duel(id: string | undefined): Duel;
   fight(a: string, b: string): string | undefined;
+  /** The room's live check sent with each command (CommandEvent.stream); undefined sends none. */
+  stream?: { id: string; startedAt: number } | null | undefined;
 };
 
 // Small harness: keeps state and clock, applies events through the pure reducer.
@@ -85,6 +88,7 @@ function arena({ chat = true, viewers = ["alice", "bob", "cara", "dan"], quick =
       displayName: login,
       text,
       timestamp: w.now,
+      ...(w.stream !== undefined ? { stream: w.stream } : {}),
     });
   w.register = (login, extra = {}) =>
     w.apply({
@@ -563,6 +567,12 @@ test("config edits are validated, versioned, and only affect new duels", () => {
     w.apply({ type: "admin", actorId: "mod", action: "config", payload: { patch: { maxDuels: 9 } } }).reason,
     "invalid_config_maxDuels",
   );
+  assert.equal(
+    w.apply({ type: "admin", actorId: "mod", action: "config", payload: { patch: { pairRankedPerStream: 51 } } })
+      .reason,
+    "invalid_config_pairRankedPerStream",
+    "the ranked limit per pair is 0 (none) to 50",
+  );
   assert.equal(
     w.apply({ type: "admin", actorId: "mod", action: "config", payload: { patch: { reminderMin: 5 } } }).reason,
     "invalid_config_reminderMin",
@@ -1200,7 +1210,15 @@ test("the bot result line says how the duel was won", async () => {
   );
   assert.equal(
     seResultText({ winner: "Bean", loser: "Aria", w, l, unrated: "pair_cap" }),
-    "Bean beat Aria! Just for fun (5 ranked duels between them in 24 h already): no Elo or dollars.",
+    "Bean beat Aria! Just for fun (ranked limit for this pair reached): no Elo, pays half, ranked again next stream.",
+  );
+  assert.equal(
+    seResultText({ winner: "Bean", loser: "Aria", w, l, unrated: "offline" }),
+    "Bean beat Aria! Just for fun (stream offline): no rank or dollars.",
+  );
+  assert.equal(
+    seResultText({ winner: "Bean", loser: "Aria", w, l, lastRanked: true }),
+    "Bean beat Aria! Bean 1014 Elo (+14), Aria 989 Elo (-11). Last ranked duel between them this stream.",
   );
   assert.equal(
     seResultText({ winner: "Bean", loser: "Aria", w, l, unrated: "new_account" }),
@@ -1509,18 +1527,30 @@ test("the 2026-10-06 price cut moves prices still at the old defaults and keeps
   assert.equal(later.config.petPriceCommon, 30);
 });
 
-test("a pair gets 5 rated duels a day; later ones are just for fun", () => {
+test("a pair gets 5 ranked duels per stream; later ones are unrated, pay half, and count again next stream", () => {
   const w = arena({ quick: true });
+  w.stream = { id: "s1", startedAt: T0 };
   const fight = () => {
     const d = w.duel(w.fight("alice", "bob"));
     w.advance(120_000);
     return d;
   };
-  for (let i = 0; i < 5; i += 1) assert.equal(fight().unrated, undefined, `duel ${i + 1} is rated`);
+  const paid = (d: Duel, win: number, loss: number) => ({
+    [must(d.winnerId)]: win,
+    [d.winnerId === "id-alice" ? "id-bob" : "id-alice"]: loss,
+  });
+  for (let i = 0; i < 4; i += 1) {
+    const d = fight();
+    assert.deepEqual([d.unrated, d.lastRanked], [undefined, undefined], `duel ${i + 1} is ranked`);
+    assert.deepEqual(d.payout, paid(d, 5, 3));
+  }
+  assert.equal(pairRankedLeft(w.state, "id-bob", "id-alice"), 1);
+  const fifth = fight();
+  assert.deepEqual([fifth.unrated, fifth.lastRanked], [undefined, true], "the fifth is the last ranked one");
   const before = { a: { ...w.player("alice") }, b: { ...w.player("bob") } };
   const sixth = fight();
   assert.equal(sixth.unrated, "pair_cap");
-  assert.equal(sixth.payout, undefined, "no dollars");
+  assert.deepEqual(sixth.payout, paid(sixth, 2, 1), "half of $5 and $3, rounded down");
   for (const [login, was] of [
     ["alice", before.a],
     ["bob", before.b],
@@ -1531,6 +1561,7 @@ test("a pair gets 5 rated duels a day; later ones are just for fun", () => {
   const done = w.state.events.filter((e) => e.type === "duel_completed").at(-1);
   assert.equal(must(done).unrated, "pair_cap");
   assert.equal(w.state.pairPlays.length, 5, "unrated duels are not counted");
+  assert.equal(pairRankedLeft(w.state, "id-alice", "id-bob"), 0);
   const reset = structuredClone(w.state);
   assert.equal(
     reduceGame(reset, { type: "admin", actorId: "mod", action: "resetAllRanks" }, w.now).state.pairPlays.length,
@@ -1538,14 +1569,81 @@ test("a pair gets 5 rated duels a day; later ones are just for fun", () => {
     "reset all ranks starts the pair counts over",
   );
   w.register("cara");
-  assert.equal(w.duel(w.fight("alice", "cara")).unrated, undefined, "other pairs are still rated");
+  assert.equal(w.duel(w.fight("alice", "cara")).unrated, undefined, "other pairs are still ranked");
   w.advance(120_000);
   w.now += 86_400_000;
   w.apply({ type: "tick" });
-  assert.equal(w.state.pairPlays.length, 0, "plays expire after 24 h");
+  assert.equal(w.state.pairPlays.length, 6, "a day passing doesn't reset the count");
   w.register("alice");
   w.register("bob");
-  assert.equal(w.duel(w.fight("alice", "bob")).unrated, undefined, "rated again the next day");
+  assert.equal(w.duel(w.fight("alice", "bob")).unrated, "pair_cap", "still the same stream");
+  w.advance(120_000);
+  w.stream = { id: "s2", startedAt: w.now };
+  assert.equal(w.duel(w.fight("alice", "bob")).unrated, undefined, "ranked again next stream");
+  w.advance(120_000);
+  assert.deepEqual(
+    w.state.pairPlays.map((p) => p.stream),
+    ["s2"],
+    "the old stream's plays are dropped",
+  );
+});
+
+test("offline duels are unrated and pay nothing; a failed live check keeps the last answer", () => {
+  const w = arena({ quick: true });
+  w.stream = null;
+  const d = w.duel(w.fight("alice", "bob"));
+  w.advance(120_000);
+  assert.equal(d.unrated, "offline");
+  assert.equal(d.payout, undefined, "no dollars offline");
+  assert.deepEqual([w.player("alice").wins + w.player("bob").wins, w.state.pairPlays.length], [0, 0]);
+  w.stream = undefined; // the room sends no stream when Twitch didn't answer
+  assert.equal(w.duel(w.fight("alice", "cara")).unrated, "offline", "still offline as last seen");
+});
+
+test("before any live answer duels are ranked; plays from before stream ids count toward the stream they fall in", () => {
+  const w = arena({ quick: true });
+  assert.equal(w.duel(w.fight("alice", "bob")).unrated, undefined, "never checked counts as live");
+  w.advance(120_000);
+  w.state.pairPlays = [
+    { pair: "id-alice:id-bob", at: T0 - 60_000 },
+    { pair: "id-alice:id-bob", at: T0 + 1_000 },
+    { pair: "id-alice:id-bob", at: T0 + 2_000 },
+  ];
+  w.stream = { id: "s1", startedAt: T0 };
+  w.say("cara", "!challenge @dan");
+  assert.equal(pairRankedLeft(w.state, "id-alice", "id-bob"), 3, "two plays since the stream started count");
+  assert.equal(w.state.pairPlays.length, 2, "the play from before the stream is dropped");
+});
+
+test("pairRankedPerStream 0 means no limit", () => {
+  const w = arena({ quick: true });
+  w.state.config.pairRankedPerStream = 0;
+  w.stream = { id: "s1", startedAt: T0 };
+  for (let i = 0; i < 7; i += 1) {
+    const d = w.duel(w.fight("alice", "bob"));
+    w.advance(120_000);
+    assert.deepEqual([d.unrated, d.lastRanked], [undefined, undefined], `duel ${i + 1} is ranked`);
+  }
+  assert.equal(w.state.pairPlays.length, 0, "nothing to count");
+  assert.equal(pairRankedLeft(w.state, "id-alice", "id-bob"), null);
+});
+
+test("mods reset one pair's ranked count", () => {
+  const w = arena({ quick: true });
+  w.state.pairPlays = [
+    { pair: "id-alice:id-bob", at: T0, stream: "" },
+    { pair: "id-alice:id-bob", at: T0, stream: "" },
+    { pair: "id-alice:id-cara", at: T0, stream: "" },
+  ];
+  const admin = (payload: { a?: unknown; b?: unknown }) =>
+    w.apply({ type: "admin", actorId: "mod", action: "resetPair", payload });
+  assert.deepEqual(admin({ a: "id-bob", b: "id-alice" }), { ok: true, reason: "pair_reset", amount: 2 });
+  assert.deepEqual(
+    w.state.pairPlays.map((p) => p.pair),
+    ["id-alice:id-cara"],
+  );
+  assert.equal(admin({ a: "id-bob", b: "id-bob" }).reason, "invalid_pair");
+  assert.equal(admin({ a: "id-bob" }).reason, "invalid_pair");
 });
 
 test("duels with an account younger than 7 days are unrated", () => {

From 6b992fa87b444ffc5e6aacecd156f3d46c6c8e8c Mon Sep 17 00:00:00 2001
From: nesszerra <90105158+Finesssee@users.noreply.github.com>
Date: Thu, 15 Oct 2026 22:16:28 +0700
Subject: [PATCH 2/3] No pair limit by default: live duels are always ranked

Mods can still set pairRankedPerStream in the balance editor.
---
 docs/CONTRACTS.md     |  4 ++--
 docs/DUELS.md         | 14 ++++++++------
 server/game.ts        |  4 ++--
 tests/channel.test.ts |  5 +++++
 tests/game.test.ts    | 17 ++++++++++++++++-
 5 files changed, 33 insertions(+), 11 deletions(-)

diff --git a/docs/CONTRACTS.md b/docs/CONTRACTS.md
index cac5d2e..735274d 100644
--- a/docs/CONTRACTS.md
+++ b/docs/CONTRACTS.md
@@ -456,7 +456,7 @@ Viewer sprites (server/sprites.ts):
   `!fight` or `!rematch` and passes the answer as the command's `stream`; game.ts keeps it in `state.stream`
   (`{id, startedAt}` or `null`). If Twitch doesn't answer, the last answer stays; before any answer duels count as
   live. A duel while the channel is offline is `unrated:"offline"` and pays nothing. The same two fighters get
-  `pairRankedPerStream` (5; 0 = no limit) ranked duels per live stream; the next ones that stream are
+  `pairRankedPerStream` (0 = no limit, the default) ranked duels per live stream; the next ones that stream are
   `unrated:"pair_cap"` and pay half of `winDollars` and `lossDollars`, rounded down. Only ranked duels count
   (`pairPlays` `{pair, at, stream}`, at most 2000); a new stream id drops the old plays, and plays saved before stream
   ids count toward the stream they fall in (`at >= startedAt`). The pair's last ranked duel sets `duel.lastRanked`.
@@ -506,7 +506,7 @@ Viewer sprites (server/sprites.ts):
 | sharedCooldownMs | 1000 | 250 to 60000 |
 | initialElo | 1000 | 0 to 10000 |
 | eloK | 24 | 1 to 100 |
-| pairRankedPerStream | 5 | 0 to 50 (ranked duels per pair each live stream; 0 = no limit) |
+| pairRankedPerStream | 0 | 0 to 50 (ranked duels per pair each live stream; 0 = no limit) |
 | checkinPoints | 1 | 0 to 3 (upgrade points per check-in) |
 | streakBonus | true | boolean (+1 point at a streak of 3, 7, 14 and 30 streams, +2 at 60, +3 at 100, +5 at 200, +10 at 365) |
 | maxStatLevel | 16 | 1 to 200 (the highest level of each upgrade stat that counts in this channel's duels) |
diff --git a/docs/DUELS.md b/docs/DUELS.md
index 267307d..2785022 100644
--- a/docs/DUELS.md
+++ b/docs/DUELS.md
@@ -60,8 +60,8 @@ The duel is rolled at once, the moment the challenge is accepted.
 
 ## PixFray dollars
 
-- Ranked duels pay saved fighters: $5 a win, $3 a loss. Past the pair limit below, a duel pays half
-  ($2 and $1). Other unrated duels pay nothing.
+- Ranked duels pay saved fighters: $5 a win, $3 a loss. Past a pair limit (if mods set one, below), a
+  duel pays half ($2 and $1). Other unrated duels pay nothing.
 - `!wallet` shows your dollars.
 - `!pay @name 10` passes them on (`!give` on channels with the PixFray chat bot). You can pay after
   5 finished duels, at most $100 per stream, and only while the stream is live.
@@ -71,10 +71,12 @@ The duel is rolled at once, the moment the challenge is accepted.
 
 - Duels count only while the stream is live. Offline duels are unrated and pay nothing. If Twitch
   can't say whether the stream is live, the last answer stands.
-- The same two fighters get 5 ranked duels per live stream (mods change the number; 0 means no
-  limit). The fifth result says "Last ranked duel between them this stream." After that they still
-  fight, unrated, for half the dollars, and they're ranked again next stream.
-- `!stats @name` adds how many ranked duels you have left against that fighter this stream.
+- Live duels are always ranked, with no limit per pair. Mods can set a limit per pair each stream in
+  the balance editor (0 means no limit). With one, the last ranked result says "Last ranked duel
+  between them this stream." After that the pair still fights, unrated, for half the dollars, and
+  they're ranked again next stream.
+- With a limit set, `!stats @name` adds how many ranked duels you have left against that fighter this
+  stream.
 - A Twitch account under 7 days old also duels unrated. If Twitch can't say how old an account is,
   the duel is ranked.
 - An unrated duel moves no Elo, wins or losses. The reply starts "Just for fun" and says why.
diff --git a/server/game.ts b/server/game.ts
index b57e54f..a3a423f 100644
--- a/server/game.ts
+++ b/server/game.ts
@@ -63,7 +63,7 @@ const DEFAULT_CONFIG: Config = {
   winDollars: 5,
   lossDollars: 3,
   // Ranked duels per pair of fighters per live stream (0 = no limit). Past it they duel unrated for half the dollars.
-  pairRankedPerStream: 5,
+  pairRankedPerStream: 0,
   // !give @name amount: on/off, the most one viewer can give per stream, and the finished duels needed first.
   giveEnabled: true,
   giveMaxPerStream: 100,
@@ -136,7 +136,7 @@ const MAX_RECENT_EVENTS = 100;
 const MAX_APPLIED_MESSAGE_IDS = 1_000;
 const MAX_DUEL_HISTORY = 25;
 const ACTIVE_TTL_MS = 10 * 60_000;
-// Anti-farming: the same two fighters get config.pairRankedPerStream duels that count per live stream, and a Twitch
+// Anti-farming: mods may cap the ranked duels between two fighters per live stream (config.pairRankedPerStream), and a Twitch
 // account younger than NEW_ACCOUNT_MS (the room looks it up) can duel but doesn't move Elo, wins or dollars.
 export const NEW_ACCOUNT_MS = 7 * 86_400_000;
 const MAX_PAIR_PLAYS = 2_000;
diff --git a/tests/channel.test.ts b/tests/channel.test.ts
index bf9eff2..bf9b6fe 100644
--- a/tests/channel.test.ts
+++ b/tests/channel.test.ts
@@ -3090,6 +3090,10 @@ test("!stats: own levels that count, unspent points and the pet; @name for someo
       })
     ).body.reply;
   assert.equal(await stats("u1", "alice"), "@alice: Power 2, Vitality 3. 5 points unspent.");
+  assert.equal(await stats("u1", "alice", "bob"), "@bob: no upgrades yet. 0 points unspent.", "no limit by default");
+  const capped = r.readState("nesszerra");
+  capped.config.pairRankedPerStream = 5;
+  r.writeState(capped);
   assert.equal(
     await stats("u1", "alice", "bob"),
     "@bob: no upgrades yet. 0 points unspent. 5 ranked duels left between you this stream.",
@@ -3106,6 +3110,7 @@ test("!resetpair @a @b: mods start a pair's ranked count for this stream over; t
   const plays = (pair: string, n: number) => Array.from({ length: n }, (_, i) => ({ pair, at: 1 + i, stream: "" }));
   const seed = () => {
     const live = r.readState("nesszerra");
+    live.config.pairRankedPerStream = 5;
     live.pairPlays = [...plays("u1:u2", 5), ...plays("u1:u3", 2)];
     r.writeState(live);
   };
diff --git a/tests/game.test.ts b/tests/game.test.ts
index 58dd907..f274126 100644
--- a/tests/game.test.ts
+++ b/tests/game.test.ts
@@ -1527,9 +1527,21 @@ test("the 2026-10-06 price cut moves prices still at the old defaults and keeps
   assert.equal(later.config.petPriceCommon, 30);
 });
 
-test("a pair gets 5 ranked duels per stream; later ones are unrated, pay half, and count again next stream", () => {
+test("live duels have no pair limit by default", () => {
   const w = arena({ quick: true });
   w.stream = { id: "s1", startedAt: T0 };
+  assert.equal(w.state.config.pairRankedPerStream, 0);
+  for (let i = 0; i < 7; i += 1) {
+    const d = w.duel(w.fight("alice", "bob"));
+    w.advance(120_000);
+    assert.deepEqual([d.unrated, d.lastRanked], [undefined, undefined], `duel ${i + 1} is ranked`);
+  }
+});
+
+test("with a limit of 5 a pair gets 5 ranked duels per stream; later ones are unrated, pay half, and count again next stream", () => {
+  const w = arena({ quick: true });
+  w.state.config.pairRankedPerStream = 5;
+  w.stream = { id: "s1", startedAt: T0 };
   const fight = () => {
     const d = w.duel(w.fight("alice", "bob"));
     w.advance(120_000);
@@ -1590,6 +1602,7 @@ test("a pair gets 5 ranked duels per stream; later ones are unrated, pay half, a
 
 test("offline duels are unrated and pay nothing; a failed live check keeps the last answer", () => {
   const w = arena({ quick: true });
+  w.state.config.pairRankedPerStream = 5;
   w.stream = null;
   const d = w.duel(w.fight("alice", "bob"));
   w.advance(120_000);
@@ -1602,6 +1615,7 @@ test("offline duels are unrated and pay nothing; a failed live check keeps the l
 
 test("before any live answer duels are ranked; plays from before stream ids count toward the stream they fall in", () => {
   const w = arena({ quick: true });
+  w.state.config.pairRankedPerStream = 5;
   assert.equal(w.duel(w.fight("alice", "bob")).unrated, undefined, "never checked counts as live");
   w.advance(120_000);
   w.state.pairPlays = [
@@ -1630,6 +1644,7 @@ test("pairRankedPerStream 0 means no limit", () => {
 
 test("mods reset one pair's ranked count", () => {
   const w = arena({ quick: true });
+  w.state.config.pairRankedPerStream = 5;
   w.state.pairPlays = [
     { pair: "id-alice:id-bob", at: T0, stream: "" },
     { pair: "id-alice:id-bob", at: T0, stream: "" },

From 11c6b720de4bc62e90fad7dfe8dff9a6f611bf1d Mon Sep 17 00:00:00 2001
From: nesszerra <90105158+Finesssee@users.noreply.github.com>
Date: Thu, 15 Oct 2026 22:28:15 +0700
Subject: [PATCH 3/3] Mod page: pair reset text fits the no-limit default

---
 admin/index.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/admin/index.html b/admin/index.html
index da0b236..811c2e8 100644
--- a/admin/index.html
+++ b/admin/index.html
@@ -118,7 +118,7 @@ <h2 id="gift-title">Gift PixFray dollars to a saved fighter</h2>
       </section>
       <section class="section" aria-labelledby="pair-title">
         <h2 id="pair-title">Reset ranked duels for one pair</h2>
-        <p class="muted small">Two fighters get a set number of ranked duels against each other per stream (Rules tab). This gives them the full count again for this stream. Mods can also type <code>!resetpair @name @name</code> in chat.</p>
+        <p class="muted small">If mods set a limit on ranked duels per pair (balance editor), this gives two fighters their full count again for this stream. Mods can also type <code>!resetpair @name @name</code> in chat.</p>
         <form id="pair-form" class="controls" novalidate>
           <div><label for="pair-a">First viewer (Twitch name)</label><input id="pair-a" maxlength="26" autocomplete="off" spellcheck="false" required></div>
           <div><label for="pair-b">Second viewer (Twitch name)</label><input id="pair-b" maxlength="26" autocomplete="off" spellcheck="false" required></div>