diff --git a/docs/CONTRACTS.md b/docs/CONTRACTS.md
index 4e3ae1f..f5cbd6c 100644
--- a/docs/CONTRACTS.md
+++ b/docs/CONTRACTS.md
@@ -449,14 +449,14 @@ Viewer sprites (server/sprites.ts):
   between them in 24 h already): no Elo or dollars."
 - 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`), at most 20 together, spent on power (+4% damage dealt per point), guard (-4% damage taken) and luck (4% per point that a quick-duel miss lands as a hit), at most 8 each. Profiles carry `bonus` (check-in points), `checkins` and `streak`; the profile answer's `upgrades` has `points`, `fromWins` and `fromCheckins`. 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`.
+- 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) and luck (the chance a quick-duel miss lands as a hit). Levels 1-8 cost 1 point each and give 4% each; 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 and guard 60%, luck 50%; level 16 gives about 44.2%). 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 luck, then guard, then 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.
-- `!wallet` (the StreamElements `wallet` action, also while duels are paused): "@x: $N PixFray dollars, P of 20 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 upgrade limits: common and uncommon +1 to one stat, rare +2, epic +2 and +1 to a second stat, legendary +1 to every stat. 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`.
+- `!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, legendary +1 to every stat. 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`.
 - `!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 1000). 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. 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.
+- 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`).
 - Reason codes: `active_player_cap`, `challenge_not_found`, `channel_full`,
   `config_version_conflict`, `config_version_not_found`, `cooldown` (+`retryAt`), `duel_not_found`,
@@ -485,7 +485,8 @@ Viewer sprites (server/sprites.ts):
 | initialElo | 1000 | 0 to 10000 |
 | eloK | 24 | 1 to 100 |
 | 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) |
+| 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) |
 | winDollars | 5 | 0 to 100 (PixFray dollars for a win) |
 | lossDollars | 3 | 0 to 100 (dollars for a loss) |
 | giveEnabled | true | boolean (`!pay` on or off) |
diff --git a/docs/DUELS.md b/docs/DUELS.md
index 3863ec6..b1a497b 100644
--- a/docs/DUELS.md
+++ b/docs/DUELS.md
@@ -35,8 +35,12 @@ The duel is rolled at once, the moment the challenge is accepted.
 
 ## Upgrades, hats and check-ins
 
-- Each win earns an upgrade point (power, guard, luck) and unlocks hats.
-- `!checkin`, once per live stream, adds a point too, with streak bonuses.
+- Each win earns an upgrade point (power, guard, luck) and unlocks hats. Points have no cap.
+- Levels 1-8 of a stat cost 1 point each; the cost doubles every 8 levels after that, and each level
+  adds less as the stat nears its ceiling. Mods set the highest level that counts on their channel
+  (16 by default); levels above it stay saved.
+- `!checkin`, once per live stream, adds a point too, with streak bonuses: +1 at 3, 7, 14 and 30
+  streams, +2 at 60, +3 at 100, +5 at 200 and +10 at 365.
 - `!pet` shows a fighter's pet.
 
 ## PixFray dollars
diff --git a/docs/STREAMER_SETUP.md b/docs/STREAMER_SETUP.md
index 9a4d14f..db33165 100644
--- a/docs/STREAMER_SETUP.md
+++ b/docs/STREAMER_SETUP.md
@@ -59,6 +59,8 @@ once you allowed the bot or made it a moderator.
 it, click **Connect mod access** and approve the permission while signed in to Twitch as yourself.
 
 Moderators can edit chat commands, use Clear arena, change the balance and review viewer sprites.
+The Rules tab's Check-ins group has **Highest stat level that counts** (16 by default): fighters' upgrade levels above it
+stay saved but don't count in your channel's duels.
 Only you (or the site owner) can click **Reset all ranks**, **Turn PixFray off** or move chat from
 another site.
 
diff --git a/index.html b/index.html
index 5ce158e..7258705 100644
--- a/index.html
+++ b/index.html
@@ -134,8 +134,9 @@ <h1 id="hero-title" data-channel>Your fighter in %SITE_CHANNEL%'s chat</h1>
           </fieldset>
           <fieldset id="upgrades">
             <legend>Upgrades <span class="muted small" id="points-note"></span></legend>
-            <p class="muted small" id="upgrades-help">Each win and each stream check-in (!checkin in chat) gives a point, up to 20. Move points between stats whenever you're not in a duel.</p>
+            <p class="muted small" id="upgrades-help">Each win and each stream check-in (!checkin in chat) gives a point. Move points between stats whenever you're not in a duel.</p>
             <div class="upgrade-list" id="upgrade-list"></div>
+            <div class="filter-buttons" id="upgrade-presets" role="group" aria-label="Suggested builds" hidden></div>
           </fieldset>
         </div>
 
@@ -180,7 +181,7 @@ <h1 id="hero-title" data-channel>Your fighter in %SITE_CHANNEL%'s chat</h1>
         <div class="form-stack" role="tabpanel" id="panel-pets" aria-labelledby="tab-pets" hidden>
           <fieldset id="pets">
             <legend>Pet <span class="muted small" id="pet-note"></span></legend>
-            <p class="muted small">A pet follows your fighter on stream and adds to its stats, on top of the upgrade limit. Buy pets with the PixFray dollars you earn in duels. You keep every pet you buy and bring one at a time.</p>
+            <p class="muted small">A pet follows your fighter on stream and adds to its stats, on top of the channel's level limit. Buy pets with the PixFray dollars you earn in duels. You keep every pet you buy and bring one at a time.</p>
             <div class="char-grid item-grid" id="pet-list" role="radiogroup" aria-label="Pet"></div>
             <p class="status" id="pet-status" role="status"></p>
           </fieldset>
@@ -223,7 +224,7 @@ <h3>Commands</h3>
             <tr><td><code>!fight</code></td><td>Accepts a challenge sent to you. The duel is rolled right away and plays out on stream.</td></tr>
             <tr><td><code>!decline</code></td><td>Turns a challenge down.</td></tr>
             <tr><td><code>!rematch</code></td><td>Challenges the last viewer you fought. If they type <code>!rematch</code> too, the duel starts. Rematches open 30 s after a duel.</td></tr>
-            <tr><td><code>!checkin</code></td><td>Once per stream, while it's live: <span id="cmd-checkin">+1 upgrade point</span>. Check in on streams in a row for +1 more at 3, 7, 14 and 30. One missed stream a week doesn't break the streak.</td></tr>
+            <tr><td><code>!checkin</code></td><td>Once per stream, while it's live: <span id="cmd-checkin">+1 upgrade point</span>. Check in on streams in a row for +1 more at 3, 7, 14 and 30, +2 at 60, +3 at 100, +5 at 200 and +10 at 365. One missed stream a week doesn't break the streak.</td></tr>
             <tr><td><code>!wallet</code></td><td>Posts your PixFray dollars, upgrade points and streak. Each finished duel pays <span id="cmd-dollars">$5 for a win and $3 for a loss</span>.</td></tr>
             <tr><td><code>!pay @viewer 10</code></td><td id="cmd-give">Gives dollars to another fighter while the stream is live: up to $100 per stream, after your first 5 duels.</td></tr>
             <tr><td><code>!pet</code></td><td>Posts the pet you bring and its boost. Add <code>@viewer</code> to see someone else's.</td></tr>
diff --git a/public/dashboard.css b/public/dashboard.css
index 8aa28b8..8af21ab 100644
--- a/public/dashboard.css
+++ b/public/dashboard.css
@@ -981,7 +981,7 @@ fieldset .status:empty {
 }
 .upgrade {
   display: grid;
-  grid-template-columns: minmax(0, 1fr) auto 4.5em auto;
+  grid-template-columns: minmax(0, 1fr) auto 6.5em auto;
   align-items: center;
   gap: var(--space-2);
   padding: var(--space-2) var(--space-3);
diff --git a/server/channel.ts b/server/channel.ts
index 1db28f5..69f5173 100644
--- a/server/channel.ts
+++ b/server/channel.ts
@@ -25,7 +25,8 @@ import {
   hatUnlocked,
   upgradeRules,
   pointsFor,
-  MAX_POINTS,
+  effectiveStats,
+  spentOn,
   HATS,
 } from "./upgrades.ts";
 import { ensurePetSchema, handleRoomPets, petCatalog, petOf, hatPrice } from "./pets.ts";
@@ -346,8 +347,18 @@ const CHAT_PENDING_CHECK_MS = 3 * 60_000; // a subscription still awaiting webho
 const ACCOUNT_RETRY_MS = 3_600_000; // a failed Twitch account-age lookup is retried after an hour
 const LIVE_CACHE_MS = 60_000; // !checkin asks Twitch whether the channel is live at most once a minute
 const FREE_MISS_MS = 7 * 24 * 60 * 60_000; // a streak survives one missed stream per week
-const STREAK_MILESTONES = [3, 7, 14, 30]; // +1 point when the streak reaches one of these (config.streakBonus)
-const MAX_BONUS = 1_000; // stored check-in points; only MAX_POINTS of wins + bonus ever count
+// Extra points when the streak reaches one of these streams (config.streakBonus).
+const STREAK_MILESTONES = new Map([
+  [3, 1],
+  [7, 1],
+  [14, 1],
+  [30, 1],
+  [60, 2],
+  [100, 3],
+  [200, 5],
+  [365, 10],
+]);
+const MAX_BONUS = 1_000_000; // stored check-in points; a sanity bound, far past any real streak
 const MAX_DOLLARS = 1_000_000; // a wallet never holds more
 const MAX_GIFT = 10_000; // the most a mod can add or take back in one gift
 // Every query that builds a profile with normalizeProfileRow reads these columns.
@@ -855,7 +866,7 @@ export class ChannelRoom extends DurableObject<Env> {
       return json({
         ...profile,
         ...(active ? { hp: active.hp, lastSeen: active.lastSeen, respawnAt: active.respawnAt } : {}),
-        upgrades: upgradeRules(profile.wins, profile.bonus),
+        upgrades: upgradeRules(profile.wins, profile.bonus, state.config.maxStatLevel),
         owned: this.owned(userId),
         builds: this.builds(profile),
       });
@@ -893,7 +904,7 @@ export class ChannelRoom extends DurableObject<Env> {
       return json({
         profile: {
           ...shown,
-          upgrades: upgradeRules(shown.wins, shown.bonus),
+          upgrades: upgradeRules(shown.wins, shown.bonus, result.state.config.maxStatLevel),
           owned: this.owned(actorId),
           builds: this.builds(shown),
         },
@@ -1094,7 +1105,7 @@ export class ChannelRoom extends DurableObject<Env> {
         }
         if (devGive[1].toLowerCase() === "wallet") {
           const wallet = this.wallet(channel, uid);
-          return json({ wallet, reply: seWalletText(wallet, { who, origin: "", channel, maxPoints: MAX_POINTS }) });
+          return json({ wallet, reply: seWalletText(wallet, { who, origin: "", channel }) });
         }
         const given = await this.give(channel, { userId: uid, target: devTarget, amount: seAmount(devGive[3]) }, now);
         return json({
@@ -1106,7 +1117,7 @@ export class ChannelRoom extends DurableObject<Env> {
         const checked = await this.checkin(channel, { userId: validUserId(userId) }, now);
         return json({
           ...checked,
-          reply: seCheckinText(checked, { who: displayName || username, origin: "", channel, maxPoints: MAX_POINTS }),
+          reply: seCheckinText(checked, { who: displayName || username, origin: "", channel }),
         });
       }
       const parsed = parseGameCommand(line); // the reply is the line a StreamElements bot would post
@@ -2226,7 +2237,6 @@ export class ChannelRoom extends DurableObject<Env> {
           who: (input.displayName as string) || username,
           origin,
           channel,
-          maxPoints: MAX_POINTS,
         }),
         checked.reason,
         checked.reason === "checked_in" ? { streak: checked.streak, points: checked.points } : {},
@@ -2241,7 +2251,6 @@ export class ChannelRoom extends DurableObject<Env> {
           who: (input.displayName as string) || username,
           origin,
           channel,
-          maxPoints: MAX_POINTS,
         }),
         wallet ? "wallet" : "no_fighter",
       );
@@ -2376,9 +2385,9 @@ export class ChannelRoom extends DurableObject<Env> {
     );
   }
 
-  // !checkin: once per stream, only while Twitch says the channel is live. Gives config.checkinPoints, plus 1 when the
-  // streak reaches a milestone. A streak counts this channel's streams with check-ins (the streams table) in a row;
-  // one missed stream a week is forgiven. Points are stored apart from wins (bonus_points), so a rank reset keeps them.
+  // !checkin: once per stream, only while Twitch says the channel is live. Gives config.checkinPoints, plus the
+  // STREAK_MILESTONES extra when the streak reaches a milestone. A streak counts this channel's streams with
+  // check-ins (the streams table) in a row; one missed stream a week is forgiven. Points are stored apart from wins (bonus_points), so a rank reset keeps them.
   async checkin(channel: string, { userId }: { userId: string }, now = Date.now()): Promise<CheckinReply> {
     if (!userId || !this.getProfile(userId, this.readState(channel).config)) return { reason: "no_fighter" };
     let stream: { id: string; startedAt: number } | null;
@@ -2400,9 +2409,20 @@ export class ChannelRoom extends DurableObject<Env> {
         config = state.config;
       const row = sql
         .exec<
-          Pick<ProfileTable, "wins" | "bonus_points" | "streak" | "last_stream" | "last_stream_seq" | "free_miss_at">
+          Pick<
+            ProfileTable,
+            | "wins"
+            | "bonus_points"
+            | "streak"
+            | "last_stream"
+            | "last_stream_seq"
+            | "free_miss_at"
+            | "power"
+            | "guard"
+            | "luck"
+          >
         >(
-          "SELECT wins, bonus_points, streak, last_stream, last_stream_seq, free_miss_at FROM profiles WHERE user_id = ?",
+          "SELECT wins, bonus_points, streak, last_stream, last_stream_seq, free_miss_at, power, guard, luck FROM profiles WHERE user_id = ?",
           userId,
         )
         .toArray()[0];
@@ -2422,13 +2442,15 @@ export class ChannelRoom extends DurableObject<Env> {
       const missed = row.last_stream_seq > 0 ? seq - row.last_stream_seq - 1 : -1;
       const freeMiss = missed === 1 && now - row.free_miss_at >= FREE_MISS_MS;
       const streak = missed === 0 || freeMiss ? row.streak + 1 : 1;
-      const milestone = Boolean(config.streakBonus) && STREAK_MILESTONES.includes(streak);
-      const points = config.checkinPoints + (milestone ? 1 : 0);
+      const extra = config.streakBonus ? STREAK_MILESTONES.get(streak) || 0 : 0;
+      const milestone = extra > 0;
+      const points = config.checkinPoints + extra;
       const bonus = Math.min(MAX_BONUS, row.bonus_points + points);
       // The total counts only wins the stream has shown, like !wallet: a quick duel still playing doesn't give it away.
       const wins = row.wins - (hiddenResults(state, now).get(userId)?.wins || 0);
-      if (test)
-        return { reason: "checked_in", test: true, streak, points, milestone, freeMiss, total: pointsFor(wins, bonus) };
+      const total = pointsFor(wins, bonus),
+        unspent = Math.max(0, total - spentOn(effectiveStats(row, wins, bonus)));
+      if (test) return { reason: "checked_in", test: true, streak, points, milestone, freeMiss, total, unspent };
       sql.exec(
         "UPDATE profiles SET bonus_points = ?, checkins = checkins + 1, streak = ?, last_stream = ?, last_stream_seq = ?, free_miss_at = ? WHERE user_id = ?",
         bonus,
@@ -2443,7 +2465,7 @@ export class ChannelRoom extends DurableObject<Env> {
         active.bonus = bonus;
         this.writeState(state);
       } // the next duel counts the new points
-      return { reason: "checked_in", streak, points, milestone, freeMiss, total: pointsFor(wins, bonus) };
+      return { reason: "checked_in", streak, points, milestone, freeMiss, total, unspent };
     });
   }
 
diff --git a/server/game.ts b/server/game.ts
index bcb1b64..90f8b13 100644
--- a/server/game.ts
+++ b/server/game.ts
@@ -1,5 +1,5 @@
 import site from "../site.config.js";
-import { cleanStats, effectiveStats, emptyStats, knownHat, scaledDamage, STAT_STEP } from "./upgrades.ts";
+import { cleanStats, effectiveStats, emptyStats, knownHat, scaledDamage, statValue } from "./upgrades.ts";
 import { cleanBoost, TIERS } from "./pets.ts";
 import { cleanCosmetics } from "./cosmetics.ts";
 import type { Stats } from "./upgrades.ts";
@@ -43,9 +43,12 @@ const DEFAULT_CONFIG: Config = {
   sharedCooldownMs: 1_000,
   initialElo: 1_000,
   eloK: 24,
-  // !checkin: upgrade points per stream check-in, and +1 more at a streak of 3, 7, 14 and 30 streams.
+  // !checkin: upgrade points per stream check-in, and extra points at streak milestones (server/channel.ts
+  // STREAK_MILESTONES: +1 at 3, 7, 14 and 30 streams, +2 at 60, +3 at 100, +5 at 200, +10 at 365).
   checkinPoints: 1,
   streakBonus: true,
+  // The highest level of each upgrade stat that counts on this channel; levels above it stay saved.
+  maxStatLevel: 16,
   // PixFray dollars (server/channel.ts payDuels, give). Saved fighters earn them per finished duel.
   winDollars: 5,
   lossDollars: 3,
@@ -546,6 +549,7 @@ function settleQuickDuel(state: GameState, duel: Duel, rolls: unknown, now: numb
         player(state, id)?.wins,
         player(state, id)?.bonus,
         player(state, id)?.petBoost,
+        state.config.maxStatLevel,
       ),
     ]),
   );
@@ -570,7 +574,7 @@ function settleQuickDuel(state: GameState, duel: Duel, rolls: unknown, now: numb
     const die = 1 + Math.floor(rollAt(i) * 6);
     let outcome: Swing["outcome"] = die === 6 ? "crit" : die === 5 ? "hit" : die <= 2 ? "counter" : "miss";
     // stats has an entry for both fighters (built from [duel.a, duel.b] above)
-    const lucky = outcome === "miss" && rollAt(LUCK_ROLLS + i) < STAT_STEP * stats[attacker]!.luck;
+    const lucky = outcome === "miss" && rollAt(LUCK_ROLLS + i) < statValue("luck", stats[attacker]!.luck);
     if (lucky) outcome = "hit";
     const swing: Swing = {
       attackerId: attacker,
@@ -752,8 +756,8 @@ function applyAbility(state: GameState, duel: Duel, actor: Player, abilityName:
     const damage = scaledDamage(
       // not the heal branch, so ability is abilities.strike or abilities.heavy
       (ability as Abilities["strike"]).damage,
-      effectiveStats(actor.stats, actor.wins, actor.bonus, actor.petBoost),
-      effectiveStats(foe?.stats, foe?.wins, foe?.bonus, foe?.petBoost),
+      effectiveStats(actor.stats, actor.wins, actor.bonus, actor.petBoost, state.config.maxStatLevel),
+      effectiveStats(foe?.stats, foe?.wins, foe?.bonus, foe?.petBoost, state.config.maxStatLevel),
     );
     duel.hp[targetId] = Math.max(0, before - damage);
     amount = before - duel.hp[targetId];
@@ -879,6 +883,7 @@ function validateConfigPatch(patch: Untrusted): { ok: true; patch: ConfigPatch }
     eloK: [1, 100],
     maxOnStream: ON_STREAM,
     checkinPoints: [0, 3],
+    maxStatLevel: [1, 200],
     winDollars: [0, 100],
     lossDollars: [0, 100],
     giveMaxPerStream: [0, 10_000],
diff --git a/server/model.ts b/server/model.ts
index b4b6979..91cb5bc 100644
--- a/server/model.ts
+++ b/server/model.ts
@@ -45,6 +45,7 @@ export type Config = {
   eloK: number;
   checkinPoints: number;
   streakBonus: boolean;
+  maxStatLevel: number;
   winDollars: number;
   lossDollars: number;
   giveEnabled: boolean;
diff --git a/server/pets.ts b/server/pets.ts
index 7bd2547..bdc064e 100644
--- a/server/pets.ts
+++ b/server/pets.ts
@@ -104,7 +104,7 @@ export const PRICE_KEYS: Record<string, keyof PetPriceConfig> = {
   epic: "petPriceEpic",
   legendary: "petPriceLegendary",
 };
-export const MAX_BOOST = 2; // per stat, on top of the upgrade points (it may go past MAX_PER_STAT)
+export const MAX_BOOST = 2; // per stat, on top of the upgrade points (it may go past the channel's maxStatLevel)
 export const CUSTOM_PET_ID = /^p-[a-z0-9-]{1,40}$/;
 export const PET_LIMITS = Object.freeze({ maxPets: 24, maxBytes: 65_536, maxSide: 64, maxLabel: 24 });
 const BODY_LIMIT = Math.ceil(PET_LIMITS.maxBytes / 3) * 4 + 4_000;
diff --git a/server/streamelements.ts b/server/streamelements.ts
index 83f1f47..d78916e 100644
--- a/server/streamelements.ts
+++ b/server/streamelements.ts
@@ -359,13 +359,15 @@ export type CheckinReply = {
   milestone?: boolean;
   freeMiss?: boolean;
   total?: number;
+  /** Points not spent on stats yet. */
+  unspent?: number;
   test?: boolean;
 };
-type SePointsOptions = { who?: string | undefined; maxPoints?: number | undefined } & SeLinkOptions;
+type SePointsOptions = { who?: string | undefined } & SeLinkOptions;
 
 export function seCheckinText(
   r: CheckinReply | null | undefined,
-  { who = "", origin = "", channel = "", maxPoints = 20 }: SePointsOptions = {},
+  { who = "", origin = "", channel = "" }: SePointsOptions = {},
 ): string {
   const me = short(who) || "you";
   switch (r?.reason) {
@@ -377,15 +379,12 @@ export function seCheckinText(
       ]
         .filter(Boolean)
         .join(", ");
-      const gain = r.points ? `+${r.points} upgrade point${r.points === 1 ? "" : "s"} (${extras})` : `${extras}`;
+      const gain = r.points ? `+${r.points} point${r.points === 1 ? "" : "s"} (${extras})` : `${extras}`;
       const link = siteLink(origin, channel, "#upgrades");
-      // total! : checkin always sends it with checked_in
-      const total =
-        r.total! >= maxPoints
-          ? `${maxPoints} of ${maxPoints} points, the most a fighter can hold.`
-          : `${r.total} of ${maxPoints} points.`;
+      const unspent = r.unspent || 0;
+      const total = `${r.total} point${r.total === 1 ? "" : "s"}, ${unspent ? unspent + " unspent." : "all spent."}`;
       if (r.test) return `[Test, not saved] @${me} would check in: ${gain}. ${total}`;
-      return `@${me} checked in: ${gain}. ${total}${r.points && link ? " Spend them at " + link : ""}`;
+      return `@${me} checked in: ${gain}. ${total}${unspent && link ? " Spend them at " + link : ""}`;
     }
     case "already_checked_in":
       return `@${me}, you already checked in this stream (${r.streak}-stream streak). Come back next stream!`;
@@ -400,11 +399,11 @@ export function seCheckinText(
 // !wallet: dollars, upgrade points and streak. w = ChannelRoom.wallet() or null (no fighter).
 export function seWalletText(
   w: { dollars: number; points: number; streak: number } | null | undefined,
-  { who = "", origin = "", channel = "", maxPoints = 20 }: SePointsOptions = {},
+  { who = "", origin = "", channel = "" }: SePointsOptions = {},
 ): string {
   const me = short(who) || "you";
   if (!w) return noFighter(me, true, origin, channel);
-  return `@${me}: $${w.dollars} PixFray dollars, ${w.points} of ${maxPoints} upgrade points, ${w.streak}-stream streak.`;
+  return `@${me}: $${w.dollars} PixFray dollars, ${w.points} upgrade point${w.points === 1 ? "" : "s"}, ${w.streak}-stream streak.`;
 }
 
 // !pet [@name]: p = ChannelRoom.petInfo() -> { name, pet: {label, tier, boost} | null }, or null (no fighter).
diff --git a/server/upgrades.ts b/server/upgrades.ts
index 1db9bf5..2b56551 100644
--- a/server/upgrades.ts
+++ b/server/upgrades.ts
@@ -1,20 +1,26 @@
 // Fighter upgrades and hats: the rules live here so the duel math, profile saving and the dashboard agree.
-// Every win earns one upgrade point, and so does every stream check-in (bonus points, kept on a rank reset), up to
-// MAX_POINTS in total. Points go into three stats, at most MAX_PER_STAT each,
-// and can be moved around (respec) for free whenever the fighter is not in a duel.
-//   power: +4% damage dealt per point      guard: -4% damage taken per point
-//   luck:  4% per point that a miss still lands as a hit
+// Every win earns one upgrade point, and so does every stream check-in (bonus points, kept on a rank reset), with no
+// cap. Points buy stat levels: levels 1-8 cost 1 point each, and the cost doubles every 8 levels after that (9-16
+// cost 2, 17-24 cost 4, ...). Points can be moved around (respec) for free whenever the fighter is not in a duel.
+//   power: +4% damage dealt per level      guard: -4% damage taken per level
+//   luck:  4% per level that a miss still lands as a hit
+// Above level 8 each level adds half a step at first and the effect closes in on the stat's ceiling (statValue).
+// A channel's maxStatLevel (config) caps the levels that count there; levels above it stay saved.
 // Hats are cosmetic; some unlock at a number of wins. The overlay draws them (src/served/hats.ts).
 
 export const STATS = ["power", "guard", "luck"] as const; // const: each stat a literal, so Stat names them
 export type Stat = (typeof STATS)[number];
-/** Points in each stat. */
+/** Levels in each stat. */
 export type Stats = Record<Stat, number>;
 /** Stat-shaped input from storage, a request or a pet boost: any value per stat, cleaned before use. */
 export type LooseStats = Partial<Record<Stat, unknown>>;
-export const MAX_PER_STAT = 8;
-export const MAX_POINTS = 20;
+/** Levels up to here keep the full step and cost 1 point each. */
+export const FULL_STEP_LEVELS = 8;
+/** A sanity bound on stored levels; reaching it would cost over 268 million points. */
+export const LEVEL_LIMIT = 200;
 export const STAT_STEP = 0.04;
+/** The most each stat's effect can reach, as a fraction (0.6 is 60%). */
+export const STAT_CEILING: Record<Stat, number> = { power: 0.6, guard: 0.6, luck: 0.5 };
 
 export type Hat = { id: string; label: string; wins: number };
 export const HATS: Hat[] = [
@@ -31,47 +37,68 @@ export const HATS: Hat[] = [
 const HAT_WINS = new Map(HATS.map((h) => [h.id, h.wins]));
 
 const whole = (n: unknown): number => (Number.isInteger(n) && n > 0 ? n : 0);
-// Points from wins plus check-in (bonus) points, capped at MAX_POINTS.
-export const pointsFor = (wins: unknown, bonus: unknown = 0): number =>
-  Math.min(MAX_POINTS, whole(wins) + whole(bonus));
+// Points from wins plus check-in (bonus) points.
+export const pointsFor = (wins: unknown, bonus: unknown = 0): number => whole(wins) + whole(bonus);
+
+// Points the level-th level of a stat costs: 1 for levels 1-8, then doubling every 8 levels.
+export const levelCost = (level: number): number => 2 ** Math.floor((Math.max(1, level) - 1) / FULL_STEP_LEVELS);
+// Points that buy a stat up to this level: 8 for level 8, 24 for 16, 56 for 24, 120 for 32.
+export function levelSpend(level: number): number {
+  const n = Math.max(0, Math.floor(level)),
+    tiers = Math.floor(n / FULL_STEP_LEVELS);
+  return FULL_STEP_LEVELS * (2 ** tiers - 1) + (n % FULL_STEP_LEVELS) * 2 ** tiers;
+}
+// Points a build spends.
+export const spentOn = (stats: Stats): number => STATS.reduce((sum, key) => sum + levelSpend(stats[key]), 0);
+
+// What a stat's levels do, as a fraction: 4% a level up to level 8 (so earlier builds keep their strength), then
+// half that step at first, closing in on STAT_CEILING without reaching it.
+export function statValue(stat: Stat, level: number): number {
+  const n = Math.max(0, level || 0);
+  if (n <= FULL_STEP_LEVELS) return STAT_STEP * n;
+  const base = STAT_STEP * FULL_STEP_LEVELS,
+    room = STAT_CEILING[stat] - base;
+  return base + room * (1 - Math.exp(-((STAT_STEP / 2) * (n - FULL_STEP_LEVELS)) / room));
+}
 
 export function emptyStats(): Stats {
   return { power: 0, guard: 0, luck: 0 };
 }
 
-// Any input -> whole numbers within 0..MAX_PER_STAT for each stat.
+// Any input -> whole numbers within 0..LEVEL_LIMIT for each stat.
 export function cleanStats(input?: unknown): Stats {
   const out = emptyStats();
   for (const key of STATS) {
     // Any value: ?. reads undefined from null or undefined, and Number() turns whatever it reads into a number
     const v = Number((input as LooseStats | null | undefined)?.[key]);
-    out[key] = Number.isInteger(v) ? Math.max(0, Math.min(MAX_PER_STAT, v)) : 0;
+    out[key] = Number.isInteger(v) ? Math.max(0, Math.min(LEVEL_LIMIT, v)) : 0;
   }
   return out;
 }
 
-// Stats the fighter can use with these points. A rank reset lowers the points; the excess comes off
-// luck first, then guard, then power, so a stored build never counts for more than the points allow.
-// boost (the active pet's, server/pets.ts) is added after the cap, so it may take a stat past MAX_PER_STAT.
+// Levels the fighter can use with these points. A rank reset lowers the points; levels come off luck first, then
+// guard, then power, until the build fits, so a stored build never counts for more than the points allow.
+// maxLevel (the channel's maxStatLevel) then caps each stat; levels above it stay saved but don't count.
+// boost (the active pet's, server/pets.ts) is added after both, so it may take a stat past the cap.
 export function effectiveStats(
   stats: unknown,
   wins: unknown,
   bonus: unknown = 0,
   boost: LooseStats | null = null,
+  maxLevel = LEVEL_LIMIT,
 ): Stats {
-  const out = cleanStats(stats);
-  let extra = STATS.reduce((sum, key) => sum + out[key], 0) - pointsFor(wins, bonus);
+  const out = cleanStats(stats),
+    points = pointsFor(wins, bonus);
+  let spent = spentOn(out);
   // const: each key a Stat, so out[key] type-checks
-  for (const key of ["luck", "guard", "power"] as const) {
-    const cut = Math.min(out[key], Math.max(0, extra));
-    out[key] -= cut;
-    extra -= cut;
-  }
+  for (const key of ["luck", "guard", "power"] as const)
+    while (spent > points && out[key] > 0) spent -= levelCost(out[key]--);
+  for (const key of STATS) out[key] = Math.min(out[key], Math.max(0, maxLevel));
   if (boost) for (const key of STATS) out[key] += Number.isInteger(boost[key]) && boost[key] > 0 ? boost[key] : 0;
   return out;
 }
 
-// For saving: null when the build spends more points than the fighter has or breaks a stat cap.
+// For saving: null when the build spends more points than the fighter has or isn't whole levels.
 export function validStats(input: unknown, wins: unknown, bonus: unknown = 0): Stats | null {
   if (input === undefined || input === null) return emptyStats();
   if (typeof input !== "object" || Array.isArray(input)) return null;
@@ -79,10 +106,49 @@ export function validStats(input: unknown, wins: unknown, bonus: unknown = 0): S
   for (const key of STATS) {
     // A non-array object (checked above); each value is checked below
     const v = (input as LooseStats)[key] ?? 0;
-    if (!Number.isInteger(v) || v < 0 || v > MAX_PER_STAT) return null;
+    if (!Number.isInteger(v) || v < 0 || v > LEVEL_LIMIT) return null;
     out[key] = v;
   }
-  return STATS.reduce((sum, key) => sum + out[key], 0) <= pointsFor(wins, bonus) ? out : null;
+  return spentOn(out) <= pointsFor(wins, bonus) ? out : null;
+}
+
+/** A suggested build: how much each stat weighs. */
+export type Preset = { id: string; label: string; weights: Partial<Record<string, number>> };
+// Suggested builds for the fighter page. A preset shows once every stat it weighs exists here.
+export const PRESETS: Preset[] = [
+  { id: "balanced", label: "Balanced", weights: { power: 1, guard: 1, luck: 1 } },
+  { id: "brawler", label: "Brawler", weights: { power: 1, guard: 1 } },
+  { id: "lucky-striker", label: "Lucky striker", weights: { power: 1, luck: 1 } },
+  { id: "iron-wall", label: "Iron wall", weights: { guard: 3, power: 1 } },
+  { id: "glass-cannon", label: "Glass cannon", weights: { power: 3, crit: 2, luck: 1 } },
+  { id: "tank", label: "Tank", weights: { guard: 3, vitality: 3, power: 1 } },
+  { id: "counter-puncher", label: "Counter-puncher", weights: { counter: 3, guard: 2, dodge: 1 } },
+  { id: "duelist", label: "Duelist", weights: { power: 2, crit: 2, dodge: 1, luck: 1 } },
+  { id: "gambler", label: "Gambler", weights: { luck: 3, crit: 3 } },
+  { id: "ghost", label: "Ghost", weights: { dodge: 3, luck: 2, counter: 1 } },
+  { id: "bruiser", label: "Bruiser", weights: { power: 2, vitality: 2, guard: 1 } },
+  { id: "sharpshooter", label: "Sharpshooter", weights: { crit: 3, luck: 2, power: 1 } },
+];
+export const presetReady = (preset: Preset): boolean =>
+  Object.keys(preset.weights).every((key) => (STATS as readonly string[]).includes(key));
+
+// A preset spread over these points. Each step buys a level for the weighted stat furthest below its share (ties go
+// in STATS order), until none can take another level.
+export function presetStats(preset: Preset, points: number, maxLevel = LEVEL_LIMIT): Stats {
+  const out = emptyStats(),
+    weight = (key: Stat) => preset.weights[key] || 0,
+    keys = STATS.filter((key) => weight(key) > 0),
+    top = Math.min(maxLevel, LEVEL_LIMIT);
+  let left = Math.max(0, points);
+  for (;;) {
+    const open = keys.filter((key) => out[key] < top && levelCost(out[key] + 1) <= left);
+    const next = open.reduce<Stat | null>(
+      (a, b) => (a === null || (out[b] + 1) / weight(b) < (out[a] + 1) / weight(a) ? b : a),
+      null,
+    );
+    if (next === null) return out;
+    left -= levelCost(++out[next]);
+  }
 }
 
 export const knownHat = (id: unknown): boolean => HAT_WINS.has(typeof id === "string" ? id : "");
@@ -90,21 +156,21 @@ export const hatUnlocked = (id: unknown, wins: unknown): boolean =>
   // knownHat(id) is true only for a string id that HAT_WINS holds, so the cast holds and get() finds it
   knownHat(id) && (Number.isInteger(wins) ? wins : 0) >= HAT_WINS.get(id as string)!;
 
-// Damage after the dealer's power and the target's guard; at least 1 so a blow always counts.
+// Damage after the dealer's power and the target's guard (through statValue); at least 1 so a blow always counts.
 export function scaledDamage(
   base: number,
   dealerStats?: Partial<Stats> | null,
   targetStats?: Partial<Stats> | null,
 ): number {
-  const factor = (1 + STAT_STEP * (dealerStats?.power || 0)) * (1 - STAT_STEP * (targetStats?.guard || 0));
+  const factor = (1 + statValue("power", dealerStats?.power || 0)) * (1 - statValue("guard", targetStats?.guard || 0));
   return Math.max(1, Math.round(base * factor));
 }
 
 /** The rules upgradeRules sends to the dashboard. */
 export type UpgradeRules = {
   stats: typeof STATS;
-  maxPerStat: number;
-  maxPoints: number;
+  /** The channel's maxStatLevel: levels above it don't count there. */
+  maxLevel: number;
   points: number;
   fromWins: number;
   fromCheckins: number;
@@ -113,11 +179,10 @@ export type UpgradeRules = {
 };
 
 // Rules for the dashboard, sent with the profile so the page never hard-codes them.
-export function upgradeRules(wins: unknown, bonus: unknown = 0): UpgradeRules {
+export function upgradeRules(wins: unknown, bonus: unknown = 0, maxLevel = LEVEL_LIMIT): UpgradeRules {
   return {
     stats: STATS,
-    maxPerStat: MAX_PER_STAT,
-    maxPoints: MAX_POINTS,
+    maxLevel,
     points: pointsFor(wins, bonus),
     fromWins: whole(wins),
     fromCheckins: whole(bonus),
diff --git a/src/admin.ts b/src/admin.ts
index 0cbaf01..befc304 100644
--- a/src/admin.ts
+++ b/src/admin.ts
@@ -118,7 +118,7 @@ const GROUPS: { title: string; visible?: (config: Config, admin: Admin) => boole
       { key: "eloK", label: "Elo K-factor", unit: "K", min: 1, max: 100 },
     ],
   },
-  // !checkin (server/channel.ts checkin). Wins and check-in points together are capped at 20.
+  // !checkin (server/channel.ts checkin) and how far upgrade levels count here (server/upgrades.ts effectiveStats).
   {
     title: "Check-ins",
     fields: [
@@ -127,8 +127,9 @@ const GROUPS: { title: string; visible?: (config: Config, admin: Admin) => boole
         key: "streakBonus",
         label: "Streak bonus",
         bool: true,
-        hint: "+1 point at a streak of 3, 7, 14 and 30 streams",
+        hint: "+1 point at a streak of 3, 7, 14 and 30 streams, +2 at 60, +3 at 100, +5 at 200, +10 at 365",
       },
+      { key: "maxStatLevel", label: "Highest stat level that counts", unit: "levels", min: 1, max: 200 },
     ],
   },
   // PixFray dollars (server/channel.ts payDuels and give). Mods gift dollars from the Players tab.
diff --git a/src/dashboard.ts b/src/dashboard.ts
index 02a42cf..b50911a 100644
--- a/src/dashboard.ts
+++ b/src/dashboard.ts
@@ -22,7 +22,16 @@ import {
   DEFAULT_COLOR,
   applyChannel,
 } from "./ui.ts";
-import { upgradeRules, effectiveStats, STAT_STEP } from "../server/upgrades.ts";
+import {
+  upgradeRules,
+  effectiveStats,
+  levelCost,
+  presetReady,
+  presetStats,
+  spentOn,
+  statValue,
+  PRESETS,
+} from "../server/upgrades.ts";
 import { CHARACTER_GROUPS } from "./character-groups.ts";
 import { skyBackdrop } from "./scrub.ts";
 import { initSpriteMaker } from "./sprite-maker.ts";
@@ -224,11 +233,12 @@ function peekOn(el: HTMLElement, field: keyof Loadout, value: string) {
     peekTimer = setTimeout(() => render3d(), 80);
   });
 }
-const pct = (n: number) => Math.round(n * STAT_STEP * 100) + "%";
+// A stat's effect at a level as a percentage, to one decimal above level 8 where the steps shrink.
+const pct = (k: Stat, n: number) => Math.round(statValue(k, n) * 1000) / 10 + "%";
 const STAT_TEXT = {
-  power: { label: "Power", effect: (n: number) => "+" + pct(n) + " damage dealt" },
-  guard: { label: "Guard", effect: (n: number) => "−" + pct(n) + " damage taken" },
-  luck: { label: "Luck", effect: (n: number) => pct(n) + " of misses still hit" },
+  power: { label: "Power", effect: (n: number) => "+" + pct("power", n) + " damage dealt" },
+  guard: { label: "Guard", effect: (n: number) => "−" + pct("guard", n) + " damage taken" },
+  luck: { label: "Luck", effect: (n: number) => pct("luck", n) + " of misses still hit" },
 };
 const REASONS: Record<string, string> = {
   in_duel: "finish your open challenge or duel before moving upgrade points.",
@@ -248,7 +258,7 @@ const REASONS: Record<string, string> = {
 
 const STATS: Stat[] = ["power", "guard", "luck"];
 const str = (v: unknown) => (typeof v === "string" ? v : "");
-const rules = () => upgradeRules(state.profile?.wins || 0, state.profile?.bonus || 0);
+const rules = () => upgradeRules(state.profile?.wins || 0, state.profile?.bonus || 0, state.config?.maxStatLevel);
 // A saved build (or profile) as an editable loadout, with only ids this page knows.
 function loadoutOf(b: Build | null | undefined): Loadout {
   const p = state.profile;
@@ -854,22 +864,19 @@ function renderUpgrades() {
   const r = rules(),
     list = $("#upgrade-list") as HTMLDivElement, // element type from the page HTML
     canEdit = canShop();
-  const used = r.stats.reduce((sum, k) => sum + state.d.stats[k], 0),
-    left = r.points - used;
+  const left = r.points - spentOn(state.d.stats);
   // element type from the page HTML
   ($("#points-note") as HTMLSpanElement).textContent = canEdit ? "(" + left + " of " + r.points + " points free)" : "";
   const from = r.fromCheckins
     ? " You have " + r.fromWins + " from wins and " + r.fromCheckins + " from check-ins."
     : "";
   ($("#upgrades-help") as HTMLParagraphElement).textContent = canEdit // element type from the page HTML
-    ? "Each win and each stream check-in (!checkin in chat) gives a point, up to " +
-      r.maxPoints +
-      "." +
+    ? "Each win and each stream check-in (!checkin in chat) gives a point. Levels 1 to 8 cost 1 point each, and the cost doubles every 8 levels after that. Levels above " +
+      r.maxLevel +
+      " don't count on this channel." +
       from +
       " Move points between stats whenever you're not in a duel."
-    : "Save your fighter, then each win and each stream check-in (!checkin in chat) gives an upgrade point, up to " +
-      r.maxPoints +
-      ".";
+    : "Save your fighter, then each win and each stream check-in (!checkin in chat) gives an upgrade point.";
   const shown = canEdit ? state.d.stats : { power: 0, guard: 0, luck: 0 };
   const link = $("#points-link") as HTMLAnchorElement; // element type from the page HTML
   link.hidden = !canEdit || left <= 0;
@@ -878,8 +885,11 @@ function renderUpgrades() {
     ...r.stats.map((k) => {
       const t = STAT_TEXT[k],
         n = shown[k],
+        counted = Math.min(n, r.maxLevel),
         extra = petById(state.d.pet)?.boost?.[k] || 0,
-        total = n + extra;
+        total = counted + extra,
+        cost = levelCost(n + 1),
+        atCap = n >= r.maxLevel;
       const step = (d: number) => () => {
         state.d.stats[k] += d;
         renderUpgrades();
@@ -888,7 +898,15 @@ function renderUpgrades() {
       // The plain effect of everything the fighter has in this stat, pet included.
       const effect = total
         ? t.effect(total) + (extra ? " (" + extra + " from your pet)" : "")
-        : t.effect(1) + " per point";
+        : t.effect(1) + " per level";
+      // Why "+" is off, or what it costs, in quiet text next to the stat.
+      const next = !canEdit
+        ? ""
+        : atCap
+          ? n > r.maxLevel
+            ? "Levels above " + r.maxLevel + " don't count here"
+            : "Highest level on this channel"
+          : "Next level costs " + cost + (cost === 1 ? " point" : " points");
       return h(
         "div",
         { class: "upgrade" },
@@ -897,12 +915,13 @@ function renderUpgrades() {
           { class: "upgrade-name" },
           h("strong", {}, t.label),
           h("span", { class: "muted small" }, effect),
-          // a segmented meter: one cell per point, the pet's bonus in a lighter tone after them
+          next ? h("span", { class: "muted small" }, next) : null,
+          // a segmented meter: one cell per level up to the channel's cap, the pet's bonus in a lighter tone after them
           h(
             "span",
             { class: "meter", "aria-hidden": "true" },
-            ...Array.from({ length: Math.max(r.maxPerStat, total) }, (_, i) =>
-              h("i", { class: i < n ? "on" : i < total ? "pet" : "" }),
+            ...Array.from({ length: Math.min(Math.max(r.maxLevel, total), 24) }, (_, i) =>
+              h("i", { class: i < counted ? "on" : i < total ? "pet" : "" }),
             ),
           ),
         ),
@@ -911,7 +930,12 @@ function renderUpgrades() {
           {
             type: "button",
             class: "btn btn-small",
-            "aria-label": "Take a point out of " + t.label,
+            "aria-label":
+              "Take a level out of " +
+              t.label +
+              ", refunds " +
+              levelCost(n) +
+              (levelCost(n) === 1 ? " point" : " points"),
             disabled: !canEdit || n <= 0,
             onclick: step(-1),
           },
@@ -920,15 +944,15 @@ function renderUpgrades() {
         h(
           "span",
           { class: "upgrade-value num", title: extra ? "+" + extra + " from your pet" : null },
-          n + " / " + r.maxPerStat + (extra ? " +" + extra : ""),
+          n + " / " + r.maxLevel + (extra ? " +" + extra : ""),
         ),
         h(
           "button",
           {
             type: "button",
             class: "btn btn-small",
-            "aria-label": "Put a point into " + t.label,
-            disabled: !canEdit || left <= 0 || n >= r.maxPerStat,
+            "aria-label": "Put a level into " + t.label + " for " + cost + (cost === 1 ? " point" : " points"),
+            disabled: !canEdit || cost > left || atCap,
             onclick: step(1),
           },
           "+",
@@ -936,6 +960,26 @@ function renderUpgrades() {
       );
     }),
   );
+  // Suggested builds: each spreads all the points by its weights; the viewer still presses Save profile.
+  const presets = $("#upgrade-presets") as HTMLDivElement; // element type from the page HTML
+  presets.hidden = !canEdit;
+  presets.replaceChildren(
+    ...PRESETS.filter(presetReady).map((preset) =>
+      h(
+        "button",
+        {
+          type: "button",
+          class: "btn btn-small",
+          onclick: () => {
+            state.d.stats = presetStats(preset, r.points, r.maxLevel);
+            renderUpgrades();
+            renderSave();
+          },
+        },
+        preset.label,
+      ),
+    ),
+  );
 }
 
 // Characters: search by name, filter by group; unfiltered, the list starts with 12 (plus the picked one).
diff --git a/src/parse.ts b/src/parse.ts
index 0b9ae60..8b40c5f 100644
--- a/src/parse.ts
+++ b/src/parse.ts
@@ -214,6 +214,7 @@ export type StateConfig = {
   challengeTimeoutMs: number;
   rematchDelayMs: number;
   checkinPoints?: number;
+  maxStatLevel?: number;
   winDollars?: number;
   lossDollars?: number;
   giveEnabled?: boolean;
@@ -226,6 +227,7 @@ const STATE_CONFIG: Spec = {
   challengeTimeoutMs: num,
   rematchDelayMs: num,
   checkinPoints: opt(num),
+  maxStatLevel: opt(num),
   winDollars: opt(num),
   lossDollars: opt(num),
   giveEnabled: opt(bool),
diff --git a/tests/channel.test.ts b/tests/channel.test.ts
index 70f1b1b..9c5da49 100644
--- a/tests/channel.test.ts
+++ b/tests/channel.test.ts
@@ -1211,16 +1211,16 @@ test("!checkin: once per stream while live, streaks with one free miss a week, m
   await live({ live: true, streamId: "s1" });
   assert.equal(
     await say("u1", "alice"),
-    "@alice checked in: +1 upgrade point (1-stream streak). 1 of 20 points. Spend them at https://test.example/?channel=nesszerra#upgrades",
+    "@alice checked in: +1 point (1-stream streak). 1 point, 1 unspent. Spend them at https://test.example/?channel=nesszerra#upgrades",
   );
   assert.equal(
     await say("u1", "alice"),
     "@alice, you already checked in this stream (1-stream streak). Come back next stream!",
   );
   await live({ live: true, streamId: "s2" });
-  assert.ok((await say("u1", "alice")).includes("+1 upgrade point (2-stream streak). 2 of 20"));
+  assert.ok((await say("u1", "alice")).includes("+1 point (2-stream streak). 2 points, 2 unspent."));
   await live({ live: true, streamId: "s3" });
-  assert.ok((await say("u1", "alice")).includes("+2 upgrade points (3-stream streak, streak bonus). 4 of 20"));
+  assert.ok((await say("u1", "alice")).includes("+2 points (3-stream streak, streak bonus). 4 points, 4 unspent."));
   // Alice misses s4: the free miss keeps her streak. Missing s6 too, within the week, starts it over.
   for (const [stream, who] of [
     ["s4", ["u2", "bob"]],
@@ -1230,8 +1230,8 @@ test("!checkin: once per stream while live, streaks with one free miss a week, m
   ] satisfies [string, [string, string]][]) {
     await live({ live: true, streamId: stream });
     const reply = await say(...who);
-    if (stream === "s5") assert.ok(reply.includes("+1 upgrade point (4-stream streak, free miss used). 5 of 20"));
-    if (stream === "s7") assert.ok(reply.includes("+1 upgrade point (1-stream streak). 6 of 20"));
+    if (stream === "s5") assert.ok(reply.includes("+1 point (4-stream streak, free miss used). 5 points, 5 unspent."));
+    if (stream === "s7") assert.ok(reply.includes("+1 point (1-stream streak). 6 points, 6 unspent."));
   }
   let p = (await r.call("/profile?userId=u1")).body;
   assert.deepEqual([p.bonus, p.checkins, p.streak, p.upgrades.points, p.upgrades.fromCheckins], [6, 5, 1, 6, 6]);
@@ -1256,7 +1256,26 @@ test("!checkin: once per stream while live, streaks with one free miss a week, m
   assert.equal((await cfg({ streakBonus: "yes" })).body.error, "invalid_config_streakBonus");
   assert.equal((await cfg({ checkinPoints: 0, streakBonus: false })).status, 200);
   await live({ live: true, streamId: "s8" });
-  assert.equal(await say("u1", "alice"), "@alice checked in: 2-stream streak. 6 of 20 points.");
+  assert.equal(await say("u1", "alice"), "@alice checked in: 2-stream streak. 6 points, all spent.");
+  // Long streaks give more at each milestone: +2 at 60 and +3 at 100.
+  assert.equal((await cfg({ streakBonus: true })).status, 200);
+  r.ctx.storage.sql.exec("UPDATE profiles SET streak = 59 WHERE user_id = 'u1'");
+  await live({ live: true, streamId: "s9" });
+  assert.equal(
+    await say("u1", "alice"),
+    "@alice checked in: +2 points (60-stream streak, streak bonus). 8 points, all spent.",
+  );
+  r.ctx.storage.sql.exec("UPDATE profiles SET streak = 99 WHERE user_id = 'u1'");
+  await live({ live: true, streamId: "s10" });
+  assert.equal(
+    await say("u1", "alice"),
+    "@alice checked in: +3 points (100-stream streak, streak bonus). 11 points, 2 unspent. Spend them at https://test.example/?channel=nesszerra#upgrades",
+  );
+  // maxStatLevel takes 1 to 200 levels.
+  assert.equal((await cfg({ maxStatLevel: 0 })).body.error, "invalid_config_maxStatLevel");
+  assert.equal((await cfg({ maxStatLevel: 2.5 })).body.error, "invalid_config_maxStatLevel");
+  assert.equal((await cfg({ maxStatLevel: 24 })).status, 200);
+  assert.equal((await r.call("/profile?userId=u1")).body.upgrades.maxLevel, 24);
   // A wrong key never reaches the check-in.
   assert.equal(
     (
@@ -1317,10 +1336,7 @@ test("dollars: paid once per finished duel and hidden until the stream shows it;
     "paid in the same transaction as the result",
   );
   // Until the stream has shown the fight, !wallet and the website show the old balance.
-  assert.equal(
-    await cmd("u1", "alice", "wallet"),
-    "@alice: $0 PixFray dollars, 0 of 20 upgrade points, 0-stream streak.",
-  );
+  assert.equal(await cmd("u1", "alice", "wallet"), "@alice: $0 PixFray dollars, 0 upgrade points, 0-stream streak.");
   assert.equal((await r.call("/profile?userId=u1")).body.dollars, 0);
   const winId = win === "alice" ? "u1" : "u2",
     point = { stats: { power: 1, guard: 0, luck: 0 } };
@@ -1335,7 +1351,7 @@ test("dollars: paid once per finished duel and hidden until the stream shows it;
     assert.equal((await r.save(winId, win, point)).body.profile.stats.power, 1, "the point is spendable once shown");
     assert.equal(
       await cmd(win === "alice" ? "u1" : "u2", win, "wallet"),
-      `@${win}: $5 PixFray dollars, 1 of 20 upgrade points, 0-stream streak.`,
+      `@${win}: $5 PixFray dollars, 1 upgrade point, 0-stream streak.`,
     );
     r.advance("nesszerra", { type: "tick" }, Date.now());
     assert.deepEqual([dollars()[win], dollars()[lose]], [5, 3], "never paid twice");
@@ -1407,7 +1423,7 @@ test("dollars: paid once per finished duel and hidden until the stream shows it;
   const dev = async (text: string) =>
     (await r.call("/dev-chat", { method: "POST", body: { userId: "u3", username: "cara", displayName: "cara", text } }))
       .body.reply;
-  assert.equal(await dev("!wallet"), "@cara: $140 PixFray dollars, 3 of 20 upgrade points, 0-stream streak.");
+  assert.equal(await dev("!wallet"), "@cara: $140 PixFray dollars, 3 upgrade points, 0-stream streak.");
   assert.equal(await dev("!pay @bob 5"), "@cara gave $5 to @bob. You have $135 left.");
   // A wallet at the $1,000,000 cap: a gift that wouldn't fit is refused, and nobody loses dollars.
   await live({ live: true, streamId: "s3" });
@@ -1471,7 +1487,7 @@ test("!checkin asks Twitch whether the channel is live, keeps the answer a minut
     "no pretend streams without the dev token",
   );
   helix = () => Response.json({ data: [{ id: "4242", type: "live", started_at: "2026-10-04T10:00:00Z" }] });
-  assert.ok((await say("u1", "alice")).includes("@alice checked in: +1 upgrade point"));
+  assert.ok((await say("u1", "alice")).includes("@alice checked in: +1 point"));
   assert.match(await say("u2", "bob"), /^@bob checked in/);
   assert.equal(
     calls.filter((u) => u.includes("/helix/streams?user_login=nesszerra")).length,
@@ -1546,7 +1562,7 @@ test("dev-chat (test site only): refused without DEV_TOOLS_TOKEN; with it, a lin
   await r.call("/dev-live", { method: "POST", body: { live: true, streamId: "s1" } });
   const checked = await say("b1", "testbot_a", "!checkin");
   assert.equal(checked.body.reason, "checked_in");
-  assert.ok(checked.body.reply.startsWith("@testbot_a checked in: +1 upgrade point"), checked.body.reply);
+  assert.ok(checked.body.reply.startsWith("@testbot_a checked in: +1 point"), checked.body.reply);
 });
 
 test("account age: looked up once per fighter; a duel with an account under 7 days old is just for fun", async () => {
@@ -2608,7 +2624,7 @@ test("!checkin does not count a win the stream has not shown yet", async () => {
   const winner: [string, string] = d.winnerId === "u1" ? ["u1", "alice"] : ["u2", "bob"];
   assert.match(
     (await r.say(winner[0], winner[1], "!checkin")).reply,
-    / 1 of 20 points\./,
+    / 1 point, 1 unspent\./,
     "the hidden win is not counted",
   );
 });
@@ -2703,7 +2719,7 @@ test("!checkin test mode: answers while offline with what a check-in would give,
   const test = (on: boolean) => r.call("/checkin-test", { method: "POST", body: { on, by: "ModMia" } });
   await r.save("u1", "alice");
   await live({ live: true, streamId: "s1" });
-  assert.match(await say("u1", "alice"), /^@alice checked in: \+1 upgrade point \(1-stream streak\)/);
+  assert.match(await say("u1", "alice"), /^@alice checked in: \+1 point \(1-stream streak\)/);
   await live({ live: false });
   assert.equal((await r.call("/admin")).body.checkinTest, null);
   const on = (await test(true)).body.checkinTest;
@@ -2711,7 +2727,7 @@ test("!checkin test mode: answers while offline with what a check-in would give,
   assert.ok(on.until > Date.now() + 14 * 60_000 && on.until <= Date.now() + 15 * 60_000);
   assert.deepEqual((await r.call("/admin")).body.checkinTest, on);
   const before = (await r.call("/profile?userId=u1")).body;
-  const reply = "[Test, not saved] @alice would check in: +1 upgrade point (2-stream streak). 2 of 20 points.";
+  const reply = "[Test, not saved] @alice would check in: +1 point (2-stream streak). 2 points, 2 unspent.";
   assert.equal(await say("u1", "alice"), reply, "the next stream continues the streak");
   assert.equal(await say("u1", "alice"), reply, "repeatable: nothing was saved");
   const after = (await r.call("/profile?userId=u1")).body;
@@ -2724,7 +2740,7 @@ test("!checkin test mode: answers while offline with what a check-in would give,
   assert.match(await say("u2", "bob"), /no fighter/, "a viewer without a fighter still hears how to get one");
   // live wins over test mode: a real check-in, saved
   await live({ live: true, streamId: "s2" });
-  assert.match(await say("u1", "alice"), /^@alice checked in: \+1 upgrade point \(2-stream streak\)/);
+  assert.match(await say("u1", "alice"), /^@alice checked in: \+1 point \(2-stream streak\)/);
   await live({ live: false });
   assert.equal((await test(false)).body.checkinTest, null);
   assert.equal(await say("u1", "alice"), "Check-ins open while nesszerra is live. See you next stream!");
diff --git a/tests/game.test.ts b/tests/game.test.ts
index f4f03dc..1a7ce83 100644
--- a/tests/game.test.ts
+++ b/tests/game.test.ts
@@ -1209,11 +1209,11 @@ test("the bot result line says how the duel was won", async () => {
 });
 
 // ---------- upgrades (server/upgrades.ts) ----------
-test("upgrade points: one per win plus check-in points, up to 20, at most 8 per stat; a rank reset trims luck, then guard, then power", async () => {
+test("upgrade points: one per win plus check-in points with no cap; a rank reset trims luck, then guard, then power", async () => {
   const u = await import("../server/upgrades.ts");
   assert.deepEqual(
-    [0, 3, 20, 40].map((w) => u.pointsFor(w)),
-    [0, 3, 20, 20],
+    [0, 3, 20, 400].map((w) => u.pointsFor(w)),
+    [0, 3, 20, 400],
   );
   assert.deepEqual(
     [
@@ -1223,7 +1223,7 @@ test("upgrade points: one per win plus check-in points, up to 20, at most 8 per
       [-1, 4],
       [2, 1.5],
     ].map(([w, b]) => u.pointsFor(w, b)),
-    [5, 20, 20, 4, 2],
+    [5, 24, 25, 4, 2],
   );
   assert.deepEqual(u.validStats({ power: 2, guard: 1 }, 3), { power: 2, guard: 1, luck: 0 });
   assert.equal(u.validStats({ power: 2, guard: 2 }, 3), null, "more points than wins");
@@ -1232,8 +1232,10 @@ test("upgrade points: one per win plus check-in points, up to 20, at most 8 per
     { power: 2, guard: 2, luck: 0 },
     "a check-in point covers the fourth",
   );
-  assert.deepEqual(u.validStats({ power: 8 }, 20), { power: 8, guard: 0, luck: 0 });
-  assert.equal(u.validStats({ power: 9 }, 20), null, "over the per-stat cap");
+  assert.deepEqual(u.validStats({ power: 8 }, 8), { power: 8, guard: 0, luck: 0 });
+  assert.equal(u.validStats({ power: 9 }, 9), null, "level 9 costs 2 points");
+  assert.deepEqual(u.validStats({ power: 9 }, 10), { power: 9, guard: 0, luck: 0 });
+  assert.equal(u.validStats({ power: 201 }, 1e12), null, "past the level limit");
   assert.equal(u.validStats({ power: 1.5 }, 10), null);
   assert.deepEqual(u.effectiveStats({ power: 3, guard: 3, luck: 3 }, 5), { power: 3, guard: 2, luck: 0 });
   assert.deepEqual(
@@ -1241,14 +1243,74 @@ test("upgrade points: one per win plus check-in points, up to 20, at most 8 per
     { power: 3, guard: 3, luck: 1 },
     "check-in points survive a rank reset",
   );
-  const r = u.upgradeRules(4, 3);
-  assert.deepEqual([r.points, r.fromWins, r.fromCheckins, r.maxPoints, r.maxPerStat], [7, 4, 3, 20, 8]);
+  assert.deepEqual(
+    u.effectiveStats({ power: 10, guard: 0, luck: 0 }, 11),
+    { power: 9, guard: 0, luck: 0 },
+    "trimming refunds level 10 at 2 points",
+  );
+  const r = u.upgradeRules(4, 3, 16);
+  assert.deepEqual([r.points, r.fromWins, r.fromCheckins, r.maxLevel], [7, 4, 3, 16]);
   assert.equal(u.hatUnlocked("crown", 19), false);
   assert.equal(u.hatUnlocked("crown", 20), true);
   assert.equal(u.hatUnlocked("cap", 0), true);
   assert.equal(u.hatUnlocked("sombrero", 99), false);
 });
 
+test("upgrade levels: cost doubles every 8 levels and the effect closes in on each stat's ceiling", async () => {
+  const u = await import("../server/upgrades.ts");
+  assert.deepEqual(
+    [1, 8, 9, 16, 17, 24, 25].map((l) => u.levelCost(l)),
+    [1, 1, 2, 2, 4, 4, 8],
+  );
+  assert.deepEqual(
+    [0, 5, 8, 9, 16, 24, 32].map((l) => u.levelSpend(l)),
+    [0, 5, 8, 10, 24, 56, 120],
+  );
+  assert.equal(u.spentOn({ power: 16, guard: 8, luck: 1 }), 33);
+  assert.deepEqual(
+    [0, 1, 8].map((l) => u.statValue("power", l)),
+    [0, 0.04, 0.32],
+    "levels 1 to 8 keep 4% each",
+  );
+  const p9 = u.statValue("power", 9),
+    p16 = u.statValue("power", 16),
+    p200 = u.statValue("power", 200);
+  assert.ok(p9 > 0.32 && p9 < 0.34, "level 9 adds about half a step: " + p9);
+  assert.equal(Math.round(p16 * 1000) / 10, 44.2);
+  assert.equal(Math.round(u.statValue("power", 10) * 1000) / 10, 35.7, "a pet taking power 8 to 10");
+  assert.ok(p200 < 0.6 && p200 > 0.59, "power stays under its 60% ceiling: " + p200);
+  assert.ok(u.statValue("luck", 200) < 0.5, "luck stays under 50%");
+  assert.equal(u.scaledDamage(100, { power: 8 }, { guard: 8 }), 90, "1.32 * 0.68 of 100");
+});
+
+test("upgrade levels: a channel's maxStatLevel caps what counts, and a pet's boost goes on top", async () => {
+  const u = await import("../server/upgrades.ts");
+  assert.deepEqual(u.effectiveStats({ power: 20, guard: 2 }, 1000, 0, null, 16), { power: 16, guard: 2, luck: 0 });
+  assert.deepEqual(
+    u.effectiveStats({ power: 20 }, 1000, 0, { power: 2, luck: 1 }, 16),
+    { power: 18, guard: 0, luck: 1 },
+    "the boost lands after the cap",
+  );
+  assert.deepEqual(u.effectiveStats({ power: 20 }, 1000), { power: 20, guard: 0, luck: 0 }, "no cap given");
+});
+
+test("upgrade presets spread the points by weight within the channel's level cap", async () => {
+  const u = await import("../server/upgrades.ts");
+  const preset = (id: string) => u.PRESETS.find((p) => p.id === id)!; // each id is in PRESETS
+  assert.equal(u.PRESETS.length, 12);
+  assert.deepEqual(
+    u.PRESETS.filter(u.presetReady).map((p) => p.id),
+    ["balanced", "brawler", "lucky-striker", "iron-wall"],
+  );
+  assert.deepEqual(u.presetStats(preset("balanced"), 6), { power: 2, guard: 2, luck: 2 });
+  assert.deepEqual(u.presetStats(preset("balanced"), 7), { power: 3, guard: 2, luck: 2 });
+  assert.deepEqual(u.presetStats(preset("iron-wall"), 8), { power: 2, guard: 6, luck: 0 });
+  assert.deepEqual(u.presetStats(preset("brawler"), 1000, 16), { power: 16, guard: 16, luck: 0 }, "stops at the cap");
+  assert.deepEqual(u.presetStats(preset("brawler"), 0), { power: 0, guard: 0, luck: 0 });
+  const built = u.presetStats(preset("balanced"), 100, 32);
+  assert.ok(u.spentOn(built) <= 100 && u.validStats(built, 100) !== null);
+});
+
 function upgraded(stats: Record<string, Partial<Stats>>) {
   const w = arena({ quick: true });
   for (const [login, s] of Object.entries(stats)) {
diff --git a/tests/ui.ts b/tests/ui.ts
index 26ac051..8bd7064 100644
--- a/tests/ui.ts
+++ b/tests/ui.ts
@@ -41,6 +41,7 @@ const config = {
   eloK: 24,
   checkinPoints: 1,
   streakBonus: true,
+  maxStatLevel: 16,
   winDollars: 5,
   lossDollars: 3,
   giveEnabled: true,
@@ -566,11 +567,17 @@ try {
     await page.evaluate(() => scrollTo(0, 0));
     await page.screenshot({ path: shots + "/viewer-pets-" + s.name + ".png", fullPage: true });
     await page.locator("#tab-fighter").click();
-    await page.getByRole("button", { name: "Put a point into Power" }).click();
-    await page.getByRole("button", { name: "Put a point into Power" }).click();
-    await page.getByRole("button", { name: "Put a point into Luck" }).click();
+    assert.deepEqual(
+      await page.locator("#upgrade-presets button").allTextContents(),
+      ["Balanced", "Brawler", "Lucky striker", "Iron wall"],
+      "only presets for the stats this channel has",
+    );
+    assert.match((await page.locator("#upgrade-list").textContent())!, /Next level costs 1 point/); // element text, never null
+    await page.getByRole("button", { name: "Put a level into Power for 1 point" }).click();
+    await page.getByRole("button", { name: "Put a level into Power for 1 point" }).click();
+    await page.getByRole("button", { name: "Put a level into Luck for 1 point" }).click();
     assert.equal(
-      await page.getByRole("button", { name: "Put a point into Guard" }).isDisabled(),
+      await page.getByRole("button", { name: "Put a level into Guard for 1 point" }).isDisabled(),
       true,
       "no points left",
     );
@@ -597,7 +604,7 @@ try {
     }); // the saved ability is kept as is
     assert.match(
       (await page.locator("#upgrade-list").textContent())!, // element text, never null
-      /2 \/ 8 \+1/,
+      /2 \/ 16 \+1/,
       "the mouse adds +1 power past the points",
     );
     assert.match(