From 8d0d997fcafcecc66ca15074d6b7d224cb99b232 Mon Sep 17 00:00:00 2001
From: merge-test <merge-test@local>
Date: Sat, 7 Nov 2026 13:38:39 -0500
Subject: [PATCH 1/2] Demo vs full game: Daily best time, 3 demo rides a day,
 no practice split (#641)

- Daily Ride: the practice/ranked chooser is gone. Every ride counts and the
  day's best unaided time is kept. The full game is unlimited; the demo gets
  3 rides a day (counted at start), opened by finishing the Tutorial and
  Grandma's.
- The demo rides the real Daily on Adventurous; #400's Weekly Ride is removed.
- Helping hand on every Daily ride. Any help (SAFETY/SPEED, silent tune,
  ASSIST, helping hand, shortcut) keeps a ride off the board.
- Share strip: today's best plus "1st try".
- Server POST /daily keeps the better time instead of 409ing a second ride
  (board still dark behind DAILY_BOARD_ENABLED).
- Demo: Versus and 5 bike colours locked, 20 opt-in achievements, level scores
  still off the leaderboard (postScores).
- Tests: unit + smoke:daily-best (replaces smoke:ranked), smoke:edition and
  the smokes that clicked the old chooser.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VDbZGpypLbzSQxBu62RC96
---
 README.md                                     |   2 +-
 docs/test-script.md                           |   8 +-
 index.html                                    |  77 +----
 js/achievement-defs.js                        |  67 ++--
 js/auth.js                                    |   4 +-
 js/crash-policy.js                            |   2 -
 js/daily-ride.js                              | 255 ++++++--------
 js/daily-seed.js                              |  23 --
 js/economy-mode.js                            |   2 +-
 js/economy.js                                 |   4 +-
 js/edition.js                                 |  89 +++--
 js/game.js                                    | 318 ++++++++----------
 js/helping-hand-mode.js                       |   1 -
 js/hud.js                                     |  13 +-
 js/lobby.js                                   | 223 ++++++------
 js/lobby/room-protocol.js                     |   2 +-
 js/records.js                                 |   2 +-
 package.json                                  |   2 +-
 scripts/probe-props.mjs                       |   6 +-
 scripts/shot-end-sheets.mjs                   |  13 +-
 scripts/smoke-daily-best.mjs                  | 170 ++++++++++
 scripts/smoke-edition.mjs                     |  95 ++++--
 scripts/smoke-grandma-finish.mjs              |   4 +-
 scripts/smoke-helping-hand.mjs                |  63 ++--
 scripts/smoke-hud-layout.mjs                  |   3 +-
 scripts/smoke-props-3d.mjs                    |   4 +-
 scripts/smoke-ranked-run.mjs                  | 162 ---------
 scripts/smoke-tourist-coop.mjs                | 112 +++---
 scripts/smoke-tv-playtest.mjs                 |  54 +--
 scripts/sync-steam-achievements.js            |   6 +-
 test/unit/achievements.test.mjs               |  52 ++-
 test/unit/crash-policy.test.mjs               |   4 -
 test/unit/daily-board-upsert.test.mjs         |  57 ++++
 test/unit/daily-ride.test.mjs                 | 136 +++++---
 ...d.test.mjs => daily-streak-strip.test.mjs} |  81 ++---
 test/unit/economy.test.mjs                    |  20 +-
 test/unit/edition.test.mjs                    |  36 +-
 test/unit/look-no-thumbs.test.mjs             |   4 +-
 test/unit/room-edition.test.mjs               |  27 +-
 test/unit/weekly-road.test.mjs                |  77 -----
 worker/identity.js                            |   2 +-
 worker/leaderboard.js                         |  55 +--
 42 files changed, 1119 insertions(+), 1218 deletions(-)
 create mode 100644 scripts/smoke-daily-best.mjs
 delete mode 100644 scripts/smoke-ranked-run.mjs
 create mode 100644 test/unit/daily-board-upsert.test.mjs
 rename test/unit/{daily-ranked.test.mjs => daily-streak-strip.test.mjs} (73%)
 delete mode 100644 test/unit/weekly-road.test.mjs

diff --git a/README.md b/README.md
index 9838cd34..58b614ba 100644
--- a/README.md
+++ b/README.md
@@ -189,7 +189,7 @@ npm run smoke:records        # personal bests reach the level card
 npm run smoke:seed           # world reseeding is deterministic and leak-free
 npm run smoke:daily          # the Daily Ride is the same road for everyone
 npm run smoke:ctas           # end-screen wishlist / invite visibility rules
-npm run smoke:ranked         # one ranked run per day; the demo never asks
+npm run smoke:daily-best     # every Daily ride counts; the demo stops at 3 a day
 npm run smoke:lookahead      # the stoker sees road the captain cannot
 npm run smoke:ping           # sprint call, sync multiplier, emotes
 npm run smoke:disruptions    # warned before it acts, released after
diff --git a/docs/test-script.md b/docs/test-script.md
index 3c2b04db..411d3a7a 100644
--- a/docs/test-script.md
+++ b/docs/test-script.md
@@ -113,7 +113,7 @@ CI: `pr-preview.yml` runs PF-01, PF-06 (UI) and the lobby smokes on every PR.
 | SR-09i | iPhone: SHARE in the clip preview offers FULL CLIP (20 s) and SHORT CLIP (10 s, FOR MESSAGES); the short one is cut from the same buffer on a keyframe; after the sheet closes a "Save Video, then send it from Photos" hint shows once; pad B steps back out of the choice; desktop unchanged (#408) | A | `smoke:clip-share` |
 | SR-10 | Victory buttons: NEXT LEVEL, PLAY AGAIN, END RIDE | A | `smoke:flows` |
 | SR-11 | Daily Ride: same road for two players on the same day; difficulty locked | A | `smoke:daily` |
-| SR-12 | Daily Ride ranked: chooser on web, never in demo; share strip has no road spoilers | A | `smoke:ranked` |
+| SR-12 | Daily Ride (#641): no chooser; every ride counts, best kept; help keeps a ride off the board; share strip has the first try and no road spoilers | A | `smoke:daily-best` |
 | SR-13 | Expired `?daily=` link lands on today | A | `smoke:daily` |
 | SR-14 | Slingshot: garage → buy upgrade → aim → launch → tally | A | `smoke:slingshot` |
 | SR-15 | Slingshot aim on phone (portrait and landscape, real touch) | A | `smoke:slingshot-aim` |
@@ -301,9 +301,9 @@ Two devices on different networks for the M rows.
 
 | ID | Check | Tag | Covered by |
 |---|---|---|---|
-| ED-01 | Demo shows Tutorial, Grandma's, Weekly Ride, Slingshot; no Tourist | A | `smoke:edition` |
+| ED-01 | Demo shows Tutorial, Grandma's, Daily Ride, Slingshot; no Tourist; VERSUS and five bike colours shut (#641) | A | `smoke:edition` |
 | ED-02 | Demo-gated items show a wishlist hint, not a dead lock | A | `smoke:edition`, `smoke:ctas` |
-| ED-03 | No ranked runs, streaks or share strip in the demo | A | `smoke:ranked` |
+| ED-03 | Demo Daily Ride: shut until the Tutorial and Grandma's are done, then 3 rides a day, no 4th (#641) | A | `smoke:edition`, `smoke:daily-best` |
 | ED-04 | Wishlist and invite buttons fit at 390 px | A | `smoke:ctas` |
 | ED-05 | The real demo build on Steam matches ED-01 to ED-03 | M | — |
 
@@ -341,7 +341,7 @@ Two devices on different networks for the M rows.
 |---|---|---|---|
 | DB-01 | Dashboard SQL valid against the schema | A | `check:dashboard-sql` |
 | DB-02 | A ride's analytics events (`ride_start`, `crash_recover`, `ride_takeover`, …) reach the dashboard | M | — |
-| DB-03 | Daily Ride leaderboard records a ranked run | M | — |
+| DB-03 | Daily Ride board keeps each player's best clean time of the day (needs DAILY_BOARD_ENABLED) | M | — |
 | DB-04 | Pad relay rate limit refuses a scripted room flood (30/min per IP; refused requests never reach a room) | A | `test/unit/pad-relay-ratelimit` |
 
 ---
diff --git a/index.html b/index.html
index 85a361fa..1efcbd5f 100644
--- a/index.html
+++ b/index.html
@@ -537,13 +537,12 @@
     line-height: 1;
     filter: drop-shadow(0 1px 2px rgba(0,0,0,0.6));
   }
-  /* D-2 · the in-ride "this one counts" badge. */
   /* HUD ZONES (review pass). Everything added in phases A-E was placed
      "top-centre" independently and ended up in a heap: eight overlapping
      elements on desktop, six on a phone. The screen is now divided:
 
        top strip      0 - 90px    #hud-top (speed, sync row, ping row)
-       under strip    92px        #ranked-badge (small, persistent, centred)
+       under strip    92px        #help-badge (small, persistent, centred)
        left edge      centred     #lookahead (a vertical lane map belongs at a side)
        right edge     96px+       #ping-bubbles, then #split-delta
        centre 18%                 #disruption-banner (urgent, transient)
@@ -552,25 +551,7 @@
        above pedals               #coach-card / #coop-coach (never both)
 
      Verified by scripts/smoke-hud-layout.mjs, which fails on any overlap. */
-  #ranked-badge {
-    position: fixed;
-    top: 92px;
-    left: 50%;
-    transform: translateX(-50%);
-    display: none;
-    padding: 3px 10px;
-    border-radius: 999px;
-    background: rgba(255,210,63,0.9);
-    color: #201a00;
-    font-size: 11px;
-    font-weight: 800;
-    letter-spacing: 1px;
-    pointer-events: none;
-    z-index: 56;
-  }
-  #ranked-badge.show { display: block; }
-  /* #403 · the helping hand's badge (💨 / 🎩). Same slot as #ranked-badge: a
-     ranked run never gets help, so the two are never on screen together. */
+  /* #403 · the helping hand's badge (💨 / 🎩). */
   #help-badge {
     position: fixed;
     top: 92px;
@@ -596,35 +577,6 @@
     font-weight: 700;
     font-size: 17px;
   }
-  /* D-2 · practice / ranked chooser. */
-  #daily-mode-overlay {
-    display: none;
-    position: fixed;
-    top: 0; left: 0; right: 0; bottom: 0;
-    background: rgba(8,10,14,0.88);
-    z-index: 120;
-    align-items: center;
-    justify-content: center;
-    padding: 20px;
-  }
-  #daily-mode-overlay.visible { display: flex; }
-  #daily-mode-box {
-    width: 100%;
-    max-width: 340px;
-    text-align: center;
-  }
-  #daily-mode-box h2 { margin: 0 0 4px; font-size: 20px; color: #fff; }
-  #daily-mode-sub { margin: 0 0 16px; font-size: 12px; color: rgba(255,255,255,0.6); }
-  #daily-mode-box uf-button { width: 100%; margin-top: 8px; }
-  #daily-mode-box uf-button[disabled] { opacity: 0.45; cursor: default; }
-  .daily-mode-hint {
-    display: block;
-    margin-top: 3px;
-    font-size: 10px;
-    font-weight: 500;
-    letter-spacing: 0;
-    color: rgba(255,255,255,0.5);
-  }
   /* D-3 · the shareable result strip. */
   #daily-strip {
     margin: 10px auto 0;
@@ -1906,7 +1858,7 @@
     box-sizing: border-box;
   }
   .side-btn:active { filter: brightness(1.4); }
-  /* M4: SAFETY and SPEED are locked on a ranked run. */
+  /* A side button that can't be used right now. */
   .side-btn:disabled { opacity: 0.35; filter: grayscale(1); cursor: not-allowed; }
   #safety-btn {
     grid-area: safety;
@@ -5333,27 +5285,8 @@
   </div>
 </div>
 
-<!-- D-2 · this ride counts. -->
-<div id="ranked-badge">RANKED RUN</div>
 <div id="help-badge" data-tier="0"></div>
 
-<!-- D-2 · Practice or a ranked run, on the Daily Ride only. Shown by the lobby
-     before START RIDE takes effect. The demo build never shows this: it is
-     practice-only there (see game._isDemo). -->
-<div id="daily-mode-overlay">
-  <div id="daily-mode-box">
-    <h2 id="daily-mode-title">Daily Ride</h2>
-    <p id="daily-mode-sub"></p>
-    <uf-button variant="accent" id="btn-daily-ranked">RANKED RUN
-      <span class="daily-mode-hint" id="daily-ranked-hint">One per day. Crashes are fine; ending early is not.</span>
-    </uf-button>
-    <uf-button id="btn-daily-practice">PRACTICE
-      <span class="daily-mode-hint">Unlimited. Nothing recorded but your best.</span>
-    </uf-button>
-    <uf-button id="btn-daily-cancel">&larr; Back</uf-button>
-  </div>
-</div>
-
 <!-- B-4 · signal the two hidden speed sources. -->
 <div id="center-strip-glow"></div>
 <div id="boost-ribbon">BOOST!</div>
@@ -6463,7 +6396,6 @@ <h3>Tandemonium</h3>
       <!-- #400 D4 · a crashed ride still pays for its distance. Filled by js/economy-mode.js. -->
       <div id="gameover-coins" class="ride-coins" style="display:none;"></div>
       <div id="gameover-unlocked" class="end-unlocked" hidden></div>
-      <!-- #403 · a failed ranked run: the attempt is spent; ride the road as practice. -->
       <!-- B-5 · the two things a demo player should be able to do next. Shown by
            _updateCtaButtons(); hidden in the full Steam build. -->
       <!-- D-3 · see the victory overlay. -->
@@ -6472,7 +6404,6 @@ <h3>Tandemonium</h3>
     <div slot="actions">
       <uf-button variant="accent" id="btn-restart">RESTART</uf-button>
       <uf-button id="btn-skip-checkpoint" style="display:none;">&#x1F451; Take the Royal Shortcut</uf-button>
-      <uf-button id="btn-practice-help" style="display:none;">&#x1F6DF; Ride it as practice — with a helping hand</uf-button>
       <uf-button id="btn-gameover-room" style="display:none;">RETURN TO ROOM</uf-button>
       <uf-button id="btn-gameover-lobby">END RIDE TOGETHER</uf-button>
       <uf-button id="btn-gameover-clip" style="display:none;">&#x1F3AC; SAVE CLIP</uf-button>
@@ -6530,7 +6461,7 @@ <h2 id="victory-title" hidden>YOU MADE IT!</h2>
 <!-- #400 · Demo end: NEXT LEVEL after the last road the demo includes. -->
 <div id="demo-end-overlay" style="display:none;">
   <uf-sheet id="demo-end-sheet" open dismissible="false" headline tone="accent" heading="That's the demo!" size="md">
-      <p>The full game has a new road every day, ranked runs and every Slingshot stage.</p>
+      <p>The full game has unlimited Daily Rides, Versus, every bike colour, every Slingshot stage and all 100 achievements.</p>
     <div slot="actions">
       <uf-button variant="accent" class="cta-btn" id="btn-wishlist-demo-end">&#9829; WISHLIST ON STEAM</uf-button>
       <uf-button id="btn-demo-room" style="display:none;">RETURN TO ROOM</uf-button>
diff --git a/js/achievement-defs.js b/js/achievement-defs.js
index eb1d1a15..23dcf025 100644
--- a/js/achievement-defs.js
+++ b/js/achievement-defs.js
@@ -16,17 +16,13 @@
 // Most conditions read L, so an event anywhere (a payout, a launch, a garage
 // purchase) can earn them without a ride in progress.
 //
-// demo: false marks the 18 rows the spec's Demo column calls full-game only,
-// plus sling_stage5: the spec marks it demo ✓, but DEMO_RULES caps the
-// Slingshot at stage 3, so stage 5 can't be cleared in the demo; and
-// daily_streak_3/7: the demo rides the weekly road, which feeds no day streak
-// (21 in all). double_down left this list with #546: the pot of gold no longer
-// ends the run, so a stage 2-3 run can collect it and go on to a best.
-// `full` says why: an edition rule (js/edition.js · DEMO_RULES) blocks it, or
-// 'scope' — a long-haul goal kept for the full game. The demo never awards
-// them; the stats keep counting, so they unlock on the full game's first check.
+// #641 · the demo awards 20 of these (js/edition.js · DEMO_ACHIEVEMENTS, Pete
+// 2026-11-07); `demo` on each row says whether it is one of them. The demo
+// never awards the other 80, but their stats keep counting, so they unlock on
+// the full game's first check.
 
 import { LEVELS, getMedals } from './race-config.js';
+import { DEMO_ACHIEVEMENTS } from './edition.js';
 import { STAGE_GATES, STAGE_GOALS, UPGRADES, upgradeCost } from './slingshot.js';
 import { medalFor, capMedal } from './records.js';
 
@@ -129,13 +125,13 @@ export const ACHIEVEMENTS = [
   { id: 'ten_k',          section: 'distance', name: 'Ten-K Tandem',     icon: '🔟', desc: 'Ride 10 km in total',                 ...km(10000) },
   { id: 'half_marathon',  section: 'distance', name: 'Half Marathon',    icon: '🎽', desc: 'Ride 21.1 km in total',               ...km(21100) },
   { id: 'marathon',       section: 'distance', name: 'Marathon Geese',   icon: '🏃', desc: 'Ride 42.2 km in total',               ...km(42200) },
-  { id: 'century',        section: 'distance', name: 'Century Ride',     icon: '💯', desc: 'Ride 100 km in total',                ...km(100000), demo: false, full: 'scope' },
+  { id: 'century',        section: 'distance', name: 'Century Ride',     icon: '💯', desc: 'Ride 100 km in total',                ...km(100000) },
 
   // ── 3. Coming back ───────────────────────────────────────
   { id: 'rides_10',       section: 'back', name: 'Regular Rider',        icon: '🚲', desc: 'Go on 10 rides of any kind',          ...count('rides', 10) },
   { id: 'days_3',         section: 'back', name: 'Coming Back',          icon: '📆', desc: 'Ride on 3 different days',            ...count('days', 3), unit: 'days' },
   { id: 'days_7',         section: 'back', name: 'Habit Forming',        icon: '🗓️', desc: 'Ride on 7 different days',           ...count('days', 7), unit: 'days' },
-  { id: 'days_30',        section: 'back', name: 'Lifer',                icon: '🪺', desc: 'Ride on 30 different days',           ...count('days', 30), unit: 'days', demo: false, full: 'scope' },
+  { id: 'days_30',        section: 'back', name: 'Lifer',                icon: '🪺', desc: 'Ride on 30 different days',           ...count('days', 30), unit: 'days' },
 
   // ── 4. Levels and medals ─────────────────────────────────
   { id: 'home_sweet',     section: 'medals', name: 'Home Sweet Home',    icon: '🏠', desc: "Finish Grandma's",          condition: s => s.finishedLevel === 'grandma' },
@@ -145,10 +141,10 @@ export const ACHIEVEMENTS = [
   { id: 'grandma_bronze', section: 'medals', name: 'Cookie',             icon: '🍪', desc: "Reach Grandma's inside the bronze time — the slowest of the three medal times; each difficulty has its own", medal: { level: 'grandma', rank: 'bronze' }, condition: s => s.finishedLevel === 'grandma' && rank(s.medal) >= 1 },
   { id: 'grandma_silver', section: 'medals', name: 'Tea and Biscuits',   icon: '🫖', desc: "Reach Grandma's inside the silver time — the middle of the three medal times; each difficulty has its own", medal: { level: 'grandma', rank: 'silver' }, condition: s => s.finishedLevel === 'grandma' && rank(s.medal) >= 2 },
   { id: 'grandma_gold',   section: 'medals', name: "Grandma's Favourite", icon: '🥇', desc: "Reach Grandma's inside the gold time — the fastest of the three medal times; each difficulty has its own", medal: { level: 'grandma', rank: 'gold' }, condition: s => s.finishedLevel === 'grandma' && rank(s.medal) >= 3 },
-  { id: 'daily_gold',     section: 'medals', name: 'Road Scholar',       icon: '📜', desc: "Finish the Daily Ride inside its gold time, on any day (practice counts); each difficulty has its own", medal: { level: 'daily', rank: 'gold' }, condition: s => s.finishedLevel === 'daily' && s.medal === 'gold' },
+  { id: 'daily_gold',     section: 'medals', name: 'Road Scholar',       icon: '📜', desc: "Finish the Daily Ride inside its gold time, on any day; each difficulty has its own", medal: { level: 'daily', rank: 'gold' }, condition: s => s.finishedLevel === 'daily' && s.medal === 'gold' },
   { id: 'all_gold',       section: 'medals', name: 'Gilded Goose',       icon: '👑', desc: "Win gold on both timed roads: Grandma's and the Daily Ride",
     condition: (s, L) => MEDAL_LEVELS.every(id => (L.golds || []).includes(id)),
-    progress: L => [MEDAL_LEVELS.filter(id => (L.golds || []).includes(id)).length, MEDAL_LEVELS.length], demo: false, full: 'scope' },
+    progress: L => [MEDAL_LEVELS.filter(id => (L.golds || []).includes(id)).length, MEDAL_LEVELS.length] },
   { id: 'adventurer',     section: 'medals', name: 'Adventurer',         icon: '🧭', desc: 'Finish any level on Adventurous',     condition: s => fin(s) && s.difficulty === 'adventurous' },
   { id: 'daredevil',      section: 'medals', name: 'Daredevil',          icon: '😈', desc: 'Finish any level on Daredevil',       condition: s => fin(s) && s.difficulty === 'daredevil' },
 
@@ -176,9 +172,9 @@ export const ACHIEVEMENTS = [
   { id: 'sling_first',    section: 'sling', name: 'Fire!',               icon: '🪃', desc: 'Launch from the slingshot',            ...count('slingLaunches', 1) },
   { id: 'sling_stage1',   section: 'sling', name: 'Stage One',           icon: '1️⃣', desc: 'Clear Slingshot stage 1 (300 m)',     ...count('slingStage', 1), stage: 1 },
   { id: 'sling_stage3',   section: 'sling', name: 'Getting the Hang of It', icon: '3️⃣', desc: 'Clear Slingshot stage 3',       ...count('slingStage', 3), stage: 3 },
-  { id: 'sling_stage5',   section: 'sling', name: 'Long Shot',           icon: '5️⃣', desc: 'Clear Slingshot stage 5',             ...count('slingStage', 5), stage: 5, demo: false, full: 'slingStage' },   // spec says demo ✓, but the demo stops at stage 3 (edition.js)
-  { id: 'sling_stage7',   section: 'sling', name: 'Slingshot Royalty',   icon: '7️⃣', desc: 'Clear Slingshot stage 7 (1,050 m)',   ...count('slingStage', 7), stage: 7, demo: false, full: 'slingStage' },
-  { id: 'sling_1000',     section: 'sling', name: 'Kilometre Fling',     icon: '🛫', desc: '1,000 m in one launch',               ...count('slingBest', 1000), stage: stageForDistance(1000), unit: 'm', demo: false, full: 'slingStage' },
+  { id: 'sling_stage5',   section: 'sling', name: 'Long Shot',           icon: '5️⃣', desc: 'Clear Slingshot stage 5',             ...count('slingStage', 5), stage: 5 },
+  { id: 'sling_stage7',   section: 'sling', name: 'Slingshot Royalty',   icon: '7️⃣', desc: 'Clear Slingshot stage 7 (1,050 m)',   ...count('slingStage', 7), stage: 7 },
+  { id: 'sling_1000',     section: 'sling', name: 'Kilometre Fling',     icon: '🛫', desc: '1,000 m in one launch',               ...count('slingBest', 1000), stage: stageForDistance(1000), unit: 'm' },
   { id: 'big_air',        section: 'sling', name: 'Big Air',             icon: '🪂', desc: 'Land a Big Air off a ramp',           ...count('bigAirs', 1) },
   { id: 'frequent_flyer', section: 'sling', name: 'Frequent Flyer',      icon: '✈️', desc: 'Land 25 Big Airs',                    ...count('bigAirs', 25) },
   { id: 'jackpot',        section: 'sling', name: 'Pot of Gold',         icon: '💰', desc: 'Collect the pot of gold',             ...count('jackpots', 1) },   // #546: id kept for saves + Steam
@@ -186,31 +182,31 @@ export const ACHIEVEMENTS = [
   { id: 'full_trail',     section: 'sling', name: 'Full Trail',          icon: '🪙', desc: 'Grab all 5 coins in a trail',         ...count('fullTrails', 1) },
   { id: 'straight_shooter', section: 'sling', name: 'Straight Shooter',  icon: '📐', desc: 'Go 300 m without steering after launch', ...count('straightShots', 1) },
   { id: 'medal_key',      section: 'sling', name: 'Medal Key',           icon: '🗝️', desc: "Win the medal that opens a Slingshot stage: bronze on Grandma's for stage 4, gold for stage 7", ...count('medalKeys', 1) },
-  { id: 'daily_launch',   section: 'sling', name: 'Daily Launch',        icon: '🌅', desc: "Fly the Daily Launch (the Slingshot's daily course)", ...countList('launchDays', 1), demo: false, full: 'dailyLaunch' },
-  { id: 'launch_week',    section: 'sling', name: 'Launch Week',         icon: '📅', desc: "Fly the Daily Launch on 7 different days", ...countList('launchDays', 7), unit: 'days', demo: false, full: 'dailyLaunch' },
+  { id: 'daily_launch',   section: 'sling', name: 'Daily Launch',        icon: '🌅', desc: "Fly the Daily Launch (the Slingshot's daily course)", ...countList('launchDays', 1) },
+  { id: 'launch_week',    section: 'sling', name: 'Launch Week',         icon: '📅', desc: "Fly the Daily Launch on 7 different days", ...countList('launchDays', 7), unit: 'days' },
 
   // ── 9. Tandem Tokens ───────────────────────────────────────
   { id: 'coin_first',     section: 'coins', name: 'Pocket Change',       icon: '🪙', desc: 'Collect your first Tandem Token',          ...count('coinsEarned', 1) },
   { id: 'coins_1000',     section: 'coins', name: 'Token Purse',         icon: '👛', desc: 'Earn 1,000 Tandem Tokens in total',     ...count('coinsEarned', 1000) },
-  { id: 'coins_10000',    section: 'coins', name: 'Goose Egg Nest',      icon: '🥚', desc: 'Earn 10,000 Tandem Tokens in total',    ...count('coinsEarned', 10000), demo: false, full: 'scope' },
+  { id: 'coins_10000',    section: 'coins', name: 'Goose Egg Nest',      icon: '🥚', desc: 'Earn 10,000 Tandem Tokens in total',    ...count('coinsEarned', 10000) },
   { id: 'payday',         section: 'coins', name: 'Payday',              icon: '💰', desc: 'Earn 200 Tandem Tokens from one regular (non-Slingshot) ride', ...count('bestRideCoins', 200) },
   { id: 'first_upgrade',  section: 'coins', name: 'Tinkerer',            icon: '🔧', desc: 'Buy your first garage upgrade',       ...count('upgrades', 1) },
-  { id: 'max_upgrade',    section: 'coins', name: 'Fully Tuned',         icon: '🔩', desc: 'Max out any one upgrade',             condition: (s, L) => !!L.maxedAny, demo: false, full: 'scope' },
-  { id: 'garage_royalty', section: 'coins', name: 'Garage Royalty',      icon: '🏰', desc: 'Max out every upgrade',               condition: (s, L) => !!L.maxedAll, demo: false, full: 'scope' },
+  { id: 'max_upgrade',    section: 'coins', name: 'Fully Tuned',         icon: '🔩', desc: 'Max out any one upgrade',             condition: (s, L) => !!L.maxedAny },
+  { id: 'garage_royalty', section: 'coins', name: 'Garage Royalty',      icon: '🏰', desc: 'Max out every upgrade',               condition: (s, L) => !!L.maxedAll },
   { id: 'big_spender',    section: 'coins', name: 'Big Spender',         icon: '💸', desc: 'Spend 1,000 Tandem Tokens in the garage',     ...count('coinsSpent', 1000) },
-  { id: 'rebuilt',        section: 'coins', name: 'Rebuilt',             icon: '♻️', desc: 'Rebuild the bike (prestige) for the first time', ...count('rebuilds', 1), demo: false, full: 'scope' },
-  { id: 'ship_of_theseus', section: 'coins', name: 'Ship of Theseus',    icon: '⛵', desc: 'Rebuild the bike 5 times',            ...count('rebuilds', 5), demo: false, full: 'scope' },
+  { id: 'rebuilt',        section: 'coins', name: 'Rebuilt',             icon: '♻️', desc: 'Rebuild the bike (prestige) for the first time', ...count('rebuilds', 1) },
+  { id: 'ship_of_theseus', section: 'coins', name: 'Ship of Theseus',    icon: '⛵', desc: 'Rebuild the bike 5 times',            ...count('rebuilds', 5) },
 
   // ── 10. Daily Ride ───────────────────────────────────────
-  { id: 'daily_first',    section: 'daily', name: 'Daily Ride',          icon: '📅', desc: "Do your first ranked Daily Ride", condition: s => s.dailyRanked === true, demo: false, full: 'ranked' },
+  { id: 'daily_first',    section: 'daily', name: 'Daily Ride',          icon: '📅', desc: "Finish your first Daily Ride", condition: s => s.finishedLevel === 'daily' },
   { id: 'daily_streak_3', section: 'daily', name: 'Three in a Row',      icon: '🔁', desc: "Take the Daily Ride on 3 days running", condition: (s, L) => n(s.dailyStreak) >= 3 || n(L.dailyDayBest) >= 3,
-    progress: streakProgress(3), unit: 'days', demo: false, full: 'weeklyRoad' },
+    progress: streakProgress(3), unit: 'days' },
   { id: 'daily_streak_7', section: 'daily', name: 'A Week of Roads',     icon: '🔥', desc: "Take the Daily Ride 7 days running", condition: (s, L) => n(s.dailyStreak) >= 7 || n(L.dailyDayBest) >= 7,
-    progress: streakProgress(7), unit: 'days', demo: false, full: 'weeklyRoad' },
+    progress: streakProgress(7), unit: 'days' },
   { id: 'daily_streak_30', section: 'daily', name: 'A Month of Roads',   icon: '☄️', desc: "Take the Daily Ride 30 days running", condition: (s, L) => n(s.dailyStreak) >= 30 || n(L.dailyDayBest) >= 30,
-    progress: streakProgress(30), unit: 'days', demo: false, full: 'scope' },
+    progress: streakProgress(30), unit: 'days' },
   { id: 'daily_share',    section: 'daily', name: 'Show-Off',            icon: '📣', desc: "Share a Daily Ride result",         ...count('shares', 1) },
-  { id: 'daily_practice_10', section: 'daily', name: 'Practice Makes Perfect', icon: '🔂', desc: "Finish 10 Daily Ride practice runs", ...count('dailyPractice', 10) },
+  { id: 'daily_practice_10', section: 'daily', name: 'Practice Makes Perfect', icon: '🔂', desc: "Finish 10 Daily Rides", ...count('dailyPractice', 10) },
 
   // ── 11. Riding together ──────────────────────────────────
   // A-2: Perfect Sync is reachable by cooperation — each paired beat adds +0.10
@@ -219,10 +215,10 @@ export const ACHIEVEMENTS = [
   { id: 'perfect_sync',   section: 'together', name: 'Perfect Sync',     icon: '🤝', desc: 'Stay in sync for 10 s',     condition: s => s.offsetScore > 0.9 && s.syncDuration >= 10 },
   { id: 'team_player',    section: 'together', name: 'Team Player',      icon: '🤜', desc: '80% or more safe-riding contribution in co-op', condition: s => s.isMultiplayer && s.safePct >= 80 },
   { id: 'pair_10_rides',  section: 'together', name: 'Regulars',         icon: '👫', desc: 'Ride 10 times with the same partner', condition: s => s.pairRides >= 10 },
-  { id: 'pair_100km',     section: 'together', name: 'A Hundred Together', icon: '🛣️', desc: 'Ride 100 km with the same partner', condition: s => s.pairDistanceKm >= 100, demo: false, full: 'scope' },
+  { id: 'pair_100km',     section: 'together', name: 'A Hundred Together', icon: '🛣️', desc: 'Ride 100 km with the same partner', condition: s => s.pairDistanceKm >= 100 },
   { id: 'coop_first',     section: 'together', name: 'The Two of Us',    icon: '💞', desc: 'Finish a co-op ride',                 ...count('coopFinishes', 1) },
   { id: 'social_goose',   section: 'together', name: 'Social Goose',     icon: '🦢', desc: 'Finish co-op rides with 3 different partners', ...countList('partners', 3) },
-  { id: 'standing_date',  section: 'together', name: 'Standing Date',    icon: '💐', desc: 'Keep a 4-week pair streak',           condition: s => n(s.pairWeekStreak) >= 4, demo: false, full: 'scope' },
+  { id: 'standing_date',  section: 'together', name: 'Standing Date',    icon: '💐', desc: 'Keep a 4-week pair streak',           condition: s => n(s.pairWeekStreak) >= 4 },
 
   // ── 12. Versus ───────────────────────────────────────────
   { id: 'versus_first',   section: 'versus', name: 'Rivals',             icon: '⚔️', desc: 'Finish a versus race',                ...count('versusRaces', 1) },
@@ -240,8 +236,8 @@ export const ACHIEVEMENTS = [
   { id: 'gone_with_wind', section: 'chaos', hidden: true, name: 'Gone With the Wind', icon: '🌪️', desc: 'Get pushed by 10 gusts', ...count('gusts', 10) },
 
   // ── 14. Exploring ────────────────────────────────────────
-  { id: 'distance_between_us', section: 'explore', name: 'The Distance Between Us', icon: '📍', desc: 'Finish a Tourist ride', condition: s => s.touristFinished === true, demo: false, full: 'tourist' },
-  { id: 'grand_tour',     section: 'explore', name: 'Grand Tour',        icon: '🗺️', desc: 'Ride 5 km in total in Tourist',       ...count('touristDistance', 5000), unit: 'm', demo: false, full: 'tourist' },
+  { id: 'distance_between_us', section: 'explore', name: 'The Distance Between Us', icon: '📍', desc: 'Finish a Tourist ride', condition: s => s.touristFinished === true },
+  { id: 'grand_tour',     section: 'explore', name: 'Grand Tour',        icon: '🗺️', desc: 'Ride 5 km in total in Tourist',       ...count('touristDistance', 5000), unit: 'm' },
 
   // ── 15. Grandma's in every colour ────────────────────────
   // F-1 hid these (riding the same 250 m seven times); restored 2026-10-20
@@ -256,9 +252,9 @@ export const ACHIEVEMENTS = [
 
   // ── #500 · added after the first 100 (Clean riding section, last in the list); sling_500 Half a Klick was dropped to stay at Steam's 100 cap (stage 3 already needs 540 m) ──
   { id: 'look_no_thumbs', section: 'clean', name: 'Look, No Thumbs',     icon: '🎮', desc: 'Finish a ride steering only by tilting your controller', condition: s => fin(s) && s.gyroOnly === true },
-].map(a => ({ demo: true, hidden: false, ...a }));
+].map(a => ({ hidden: false, ...a, demo: DEMO_ACHIEVEMENTS.includes(a.id) }));
 
-/** The ids the demo never awards (the spec's Demo column "—"). */
+/** The ids the demo never awards (#641: everything outside DEMO_ACHIEVEMENTS). */
 export const DEMO_UNEARNABLE = ACHIEVEMENTS.filter(a => !a.demo).map(a => a.id);
 
 export function getDefinition(id) {
@@ -526,8 +522,7 @@ export function applyEvent(prev, type, d = {}, today = null) {
         L.coopFinishes += 1;
         if (d.partnerKey) L.partners = addUnique(L.partners, d.partnerKey);
       }
-      // The demo's weekly road (d.weekly) is one road a week: it feeds no day streak.
-      if (d.finishedLevel === 'daily' && !d.weekly && today && L.lastDailyDay !== today) {
+      if (d.finishedLevel === 'daily' && today && L.lastDailyDay !== today) {
         const gap = L.lastDailyDay ? daysBetween(L.lastDailyDay, today) : 0;
         L.dailyDayRun = gap === 1 ? L.dailyDayRun + 1 : 1;
         L.dailyDayBest = Math.max(L.dailyDayBest, L.dailyDayRun);
diff --git a/js/auth.js b/js/auth.js
index a1e8c2fe..e051da94 100644
--- a/js/auth.js
+++ b/js/auth.js
@@ -387,7 +387,7 @@ export class AuthManager {
     return res.ok ? res.json() : null;
   }
 
-  /** D-6 · submit the day's ranked run. 409 means it is already used. */
+  /** D-6 / #641 · submit a finished Daily Ride; the server keeps the day's best. */
   async submitDaily(data) {
     if (!this.token) return null;
     const res = await fetch(`${API_BASE}/daily`, {
@@ -398,7 +398,7 @@ export class AuthManager {
       },
       body: JSON.stringify(data),
     });
-    if (res.status === 409) return { alreadyRidden: true };
+    if (res.status === 409) return { alreadyRidden: true };   // a pre-#641 server
     return res.ok ? res.json() : null;
   }
 
diff --git a/js/crash-policy.js b/js/crash-policy.js
index c6e1de43..2d83c18c 100644
--- a/js/crash-policy.js
+++ b/js/crash-policy.js
@@ -17,14 +17,12 @@ export const STUCK_AFTER_CRASHES = 3;
 /**
  * @param {object} ctx
  * @param {number} ctx.crashesThisSegment  including the one that just happened
- * @param {boolean} [ctx.rankedRun]        a Phase D ranked attempt
  * @param {boolean} [ctx.rideOver]         time-up, or the player pressed END RIDE
  * @returns {{ action: 'resume'|'modal', reason: string }}
  */
 export function decideAfterCrash(ctx) {
   const crashes = ctx.crashesThisSegment || 0;
   if (ctx.rideOver) return { action: 'modal', reason: 'ride-over' };
-  if (ctx.rankedRun) return { action: 'modal', reason: 'ranked' };
   if (crashes >= STUCK_AFTER_CRASHES) return { action: 'modal', reason: 'stuck' };
   return { action: 'resume', reason: 'beat' };
 }
diff --git a/js/daily-ride.js b/js/daily-ride.js
index 3b387413..a1056120 100644
--- a/js/daily-ride.js
+++ b/js/daily-ride.js
@@ -2,18 +2,27 @@
 // DAILY RIDE (pure) — the road everyone rides today
 // ============================================================
 //
-// C-2 (the practice-only form of plan item D-1). One 500 m road, generated from
-// today's day key, identical for every player in the world until 09:00 UTC.
+// C-2 / #641. One 500 m road, generated from today's day key, identical for
+// every player in the world until 09:00 UTC.
 //
-// In the demo this is practice only: unlimited runs, normal rules, personal
-// bests from B-3. Ranked runs, streaks, the share strip and the partners board
-// are Phase D, on the web build after the demo cut — a fest visitor plays once
-// for about fourteen minutes, so retention machinery would be shipped to nobody.
+// #641 (Pete, 2026-11-07) — one rule for both editions: there is no practice /
+// ranked split. Every ride on the road counts, and your BEST unaided time of
+// the day is the one that goes on the board. The full game rides it as often
+// as it likes; the demo gets three rides a day (edition.js · dailyRideCap).
+// A ride counts when it starts, so this module keeps:
+//
+//   started   rides begun today (a restart is a new ride, a checkpoint retry
+//             is not — the caller decides, see game.js · _startCountdown)
+//   practice  rides FINISHED today (the field keeps its old name so saves from
+//             before #641 still read as finishes for streaks and the card)
+//   best      the fastest unaided finish today (a 🛟 finish counts as a finish
+//             but is not a best — #403)
+//   first     the first ride's result, for the share strip's "first try"
 //
 // DOM-free and storage-agnostic so it can be tested: the store is any object
 // with get(key)/set(key, value).
 
-import { dailyKey, dailySeed, weeklyKey, weeklySeed } from './daily-seed.js';
+import { dailyKey, dailySeed } from './daily-seed.js';
 
 export const STORAGE_KEY = 'tandemonium_daily';
 
@@ -48,43 +57,84 @@ export function formatDayLabel(key) {
 
 /** What has this player done on the given day's road? */
 export function dailyStatus(store, key) {
-  const all = readAll(store);
-  const entry = all[key];
-  // #398: a ranked run goes through recordRanked, not recordPractice, so the
-  // card has to read it from here or the day still says "not ridden yet".
-  const ranked = (entry && entry.ranked) || {};
+  const entry = readAll(store)[key];
   return {
-    practiced: (entry && entry.practice) || 0,
-    best: (entry && entry.best) || null,
-    ranked: { solo: ranked.solo || null, pair: ranked.pair || null }
+    started: (entry && entry.started) || 0,
+    finished: (entry && entry.practice) || 0,
+    best: bestOf(entry),
+    first: firstTryOf(entry)
   };
 }
 
+/** Rides started on the given day's road (what the demo's cap counts). */
+export function ridesStarted(store, key) {
+  const entry = readAll(store)[key];
+  return (entry && entry.started) || 0;
+}
+
 /**
- * #512 · has this device finished the given day's road (practice, or a ranked
- * run that was not a DNF)? Read BEFORE recording a finish to know whether it is
- * the day's first, which pays the daily habit bonus (js/economy.js · dailyBonus).
+ * #512 · has this device finished the given day's road? Read BEFORE recording
+ * a finish to know whether it is the day's first, which pays the daily habit
+ * bonus (js/economy.js · dailyBonus).
  */
 export function finishedToday(store, key) {
-  const entry = readAll(store)[key];
-  if (!entry) return false;
-  if (entry.practice > 0) return true;
-  return Object.values(entry.ranked || {}).some(r => r && !r.dnf);
+  return hasFinish(readAll(store)[key]);
+}
+
+/**
+ * #641 · a ride on the road has started. Returns this ride's number today
+ * (1 = the first try), which the caller hands back to recordDailyFinish.
+ */
+export function recordRideStart(store, key) {
+  const all = readAll(store);
+  const entry = all[key] || { practice: 0, best: null };
+  entry.started = (entry.started || 0) + 1;
+  all[key] = entry;
+  writeAll(store, prune(all, key));
+  return entry.started;
 }
 
-/** Count one finished practice run, keeping the day's best time. */
-export function recordPractice(store, key, timeMs) {
+/**
+ * Count one finished ride, keeping the day's best unaided time. `rideNo` is
+ * recordRideStart's number for this ride: ride 1's result is the first try.
+ * @param {{timeMs?:number, helped?:boolean, skipped?:boolean, rideNo?:number}} run
+ */
+export function recordDailyFinish(store, key, run = {}) {
   const all = readAll(store);
   const entry = all[key] || { practice: 0, best: null };
-  entry.practice += 1;
-  if (typeof timeMs === 'number' && timeMs > 0 && (!entry.best || timeMs < entry.best)) {
-    entry.best = Math.round(timeMs);
+  entry.practice = (entry.practice || 0) + 1;
+  const clean = !run.helped && !run.skipped;
+  const t = run.timeMs;
+  if (clean && typeof t === 'number' && t > 0 && (!entry.best || t < entry.best)) {
+    entry.best = Math.round(t);
+  }
+  if (run.rideNo === 1 && !entry.first) {
+    entry.first = run.skipped ? { skipped: true }
+      : { timeMs: typeof t === 'number' && t > 0 ? Math.round(t) : null, helped: !!run.helped };
   }
   all[key] = entry;
   writeAll(store, prune(all, key));
   return entry;
 }
 
+/** The first ride's result: {timeMs, helped} · {skipped} · {dnf} · null (not ridden / still riding). */
+export function firstTry(store, key) {
+  return firstTryOf(readAll(store)[key]);
+}
+
+function firstTryOf(entry) {
+  if (!entry) return null;
+  if (entry.first) return entry.first;
+  // The first ride ended without a finish once a second one has started.
+  return (entry.started || 0) >= 2 ? { dnf: true } : null;
+}
+
+/** Best time in an entry (a pre-#641 ranked finish already wrote its time here). */
+function bestOf(entry) {
+  if (!entry) return null;
+  return entry.best || null;
+}
+
 /** Drop days older than KEEP_DAYS relative to `todayKey`. */
 export function prune(all, todayKey) {
   const cutoff = Date.parse(todayKey + 'T00:00:00Z') - KEEP_DAYS * 86400000;
@@ -104,70 +154,18 @@ export function prune(all, todayKey) {
 export function dailyDescription(status, key) {
   const label = formatDayLabel(key);
   const bits = [label];
-  // #398: the day's ranked run (solo / pair) counts as ridden, with its time
-  // or DNF, so the card shows that the one ranked attempt has been used.
-  const ranked = (status && status.ranked) || {};
-  for (const mode of ['solo', 'pair']) {
-    const r = ranked[mode];
-    if (!r) continue;
-    const name = mode === 'pair' ? 'Pair ranked' : 'Ranked';
-    bits.push(r.dnf || !(r.timeMs > 0) ? `${name} · DNF` : `${name} ✓ ${formatClock(r.timeMs)}`);
-  }
-  if (status && status.practiced) {
-    bits.push(status.practiced === 1 ? 'ridden once' : `ridden ×${status.practiced}`);
+  if (status && status.finished) {
+    bits.push(status.finished === 1 ? 'finished once' : `finished ×${status.finished}`);
     if (status.best) bits.push(`best ${formatClock(status.best)}`);
+  } else if (status && status.started) {
+    bits.push(status.started === 1 ? 'ridden once' : `ridden ×${status.started}`);
   }
   if (bits.length === 1) return `${label} · not ridden yet`;
   return bits.join(' · ');
 }
 
 /** Fixed subtitle explaining the rules, shown under the description. */
-export const DAILY_RULES_LINE = 'Same road for everyone today · new road at 09:00 UTC (05:00 ET)';
-
-// ── #400 · the demo's weekly road ─────────────────────────────────────────
-//
-// In the demo, the Daily Ride becomes the "Weekly Ride": one road per ISO week
-// (keyed by its Monday, see weeklyKey), ridden on Chill with safety on (D10),
-// practice only. The full game is unchanged. Records and practice counts use
-// the Monday's key, so the storage format is the daily one.
-
-export const WEEKLY_NAME = 'Weekly Ride';
-export const WEEKLY_DESCRIPTION = 'A new road every week';
-export const WEEKLY_DIFFICULTY = 'chill';
-export const WEEKLY_RULES_LINE = 'Same road for everyone this week · new road every Monday';
-
-/** The base daily level, presented as the weekly road (no key/seed yet). */
-export function asWeeklyRoad(baseLevel) {
-  return {
-    ...baseLevel,
-    name: WEEKLY_NAME,
-    description: WEEKLY_DESCRIPTION,
-    fixedDifficulty: WEEKLY_DIFFICULTY,
-    isWeekly: true
-  };
-}
-
-/** The weekly road with the week's identity attached (cf. resolveDailyLevel). */
-export function resolveWeeklyLevel(baseLevel, { key, seed } = {}) {
-  const k = key || weeklyKey();
-  const level = resolveDailyLevel(asWeeklyRoad(baseLevel), {
-    key: k, seed: typeof seed === 'number' ? seed : weeklySeed()
-  });
-  level.dateLabel = 'Week of ' + shortWeekLabel(level.key);
-  return level;
-}
-
-/** "Sep 28" from a Monday key. */
-function shortWeekLabel(key) {
-  const label = formatDayLabel(key);
-  return label ? label.split(', ')[1] : '';
-}
-
-/** The card line for the weekly road: what you've done on it this week. */
-export function weeklyDescription(status, key) {
-  const label = 'Week of ' + shortWeekLabel(key);
-  return WEEKLY_DESCRIPTION + '<br>' + dailyDescription(status, key).replace(formatDayLabel(key), label);
-}
+export const DAILY_RULES_LINE = 'Same road for everyone today · your best time counts · new road at 09:00 UTC (05:00 ET)';
 
 // ── storage helpers ───────────────────────────────────────────────────────
 
@@ -195,77 +193,6 @@ export function browserStore() {
     set: (k, v) => { try { localStorage.setItem(k, v); } catch { /* ignore */ } }
   };
 }
-
-// ============================================================
-// D-2 · Ranked runs
-// ============================================================
-//
-// On Today's Road a player chooses Practice (unlimited, normal rules) or a
-// Ranked run — ONE per day per mode. The rules, decided in plan §3 decision 8
-// and stated once here:
-//
-//   - solo and pair are independent: riding alone at lunch does not use up the
-//     evening ride with your partner;
-//   - checkpoint rewinds and restarts are allowed, and cost time, as they do in
-//     every other ride. The one-attempt purity of a Spelunky daily is a bad fit
-//     for a game two people play together on a phone;
-//   - END RIDE consumes the run as a DNF, so a bad start cannot be abandoned
-//     for a re-roll. A crash does not consume it;
-//   - Safety mode stays available. It is recorded and flagged rather than
-//     forbidden — this game's audience includes people who cannot ride without
-//     it, and locking them out of the ranked run locks out the persona.
-//
-// Gated to the web build by the caller: a fest visitor plays once for about
-// fourteen minutes, so a daily ranked run in the demo ships to nobody.
-
-export const MODES = ['solo', 'pair'];
-
-/** Has this player used their ranked run for this day and mode? */
-export function rankedDone(store, key, mode) {
-  const all = readAll(store);
-  const entry = all[key];
-  return !!(entry && entry.ranked && entry.ranked[mode]);
-}
-
-/** The stored ranked result for a day and mode, or null. */
-export function rankedResult(store, key, mode) {
-  const all = readAll(store);
-  const entry = all[key];
-  return (entry && entry.ranked && entry.ranked[mode]) || null;
-}
-
-/**
- * Record a ranked run. Refuses to overwrite an existing one — that refusal is
- * the whole of "one run per day".
- * @returns {{ recorded: boolean, result: object|null }}
- */
-export function recordRanked(store, key, mode, run) {
-  if (!MODES.includes(mode)) return { recorded: false, result: null };
-  const all = readAll(store);
-  const entry = all[key] || { practice: 0, best: null };
-  entry.ranked = entry.ranked || {};
-  if (entry.ranked[mode]) return { recorded: false, result: entry.ranked[mode] };
-
-  entry.ranked[mode] = {
-    timeMs: run.dnf ? null : Math.round(run.timeMs || 0),
-    dnf: !!run.dnf,
-    distance: Math.round(run.distance || 0),
-    collectibles: run.collectibles ?? 0,
-    collectiblesTotal: run.collectiblesTotal ?? 0,
-    crashes: run.crashes ?? 0,
-    safety: !!run.safety,
-    sync: typeof run.sync === 'number' ? Math.round(run.sync * 100) : null,
-    partner: run.partner || null,
-    at: run.at || new Date().toISOString()
-  };
-  if (!run.dnf && run.timeMs > 0 && (!entry.best || run.timeMs < entry.best)) {
-    entry.best = Math.round(run.timeMs);
-  }
-  all[key] = entry;
-  writeAll(store, prune(all, key));
-  return { recorded: true, result: entry.ranked[mode] };
-}
-
 // ============================================================
 // D-5 · Streaks
 // ============================================================
@@ -392,7 +319,8 @@ export function recordPartner(store, key, partnerKey) {
 function hasFinish(entry) {
   if (!entry) return false;
   if (entry.practice > 0) return true;
-  return !!(entry.ranked && Object.keys(entry.ranked).length > 0);
+  // A pre-#641 save: the day's ranked run, if it finished.
+  return Object.values(entry.ranked || {}).some(r => r && !r.dnf);
 }
 
 function longestRun(keysDesc) {
@@ -443,7 +371,10 @@ function shiftKey(key, days) {
  *
  * @param {object} r    { key, mode, timeMs, dnf, distance, raceDistance, medal,
  *                        collectibles, collectiblesTotal, crashes, sync, safety,
- *                        practice, streak, partnerName }
+ *                        streak, partnerName, bestMs, first, rides }
+ *   #641: bestMs = today's best unaided time (shown instead of this ride's
+ *   when it is faster); first = firstTry() — shown as "1st try" once the day
+ *   has more than one ride (rides = rides started today).
  * @param {object} opts { origin }
  */
 export function buildShareStrip(r, opts = {}) {
@@ -458,14 +389,20 @@ export function buildShareStrip(r, opts = {}) {
   const parts = [];
   // The pair marker rides on the time rather than standing as its own field —
   // "👥 2:41" reads as "two of us, 2:41"; "👥 · 2:41" reads as a missing value.
-  const time = r.dnf ? `DNF @ ${Math.round(r.distance || 0)}m` : formatClock(r.timeMs);
+  const best = r.bestMs > 0 && (r.dnf || !(r.timeMs > 0) || r.bestMs < r.timeMs) ? r.bestMs : null;
+  const time = best ? formatClock(best)
+    : r.dnf ? `DNF @ ${Math.round(r.distance || 0)}m` : formatClock(r.timeMs);
   parts.push(r.mode === 'pair' ? `👥 ${time}` : time);
   if (r.medal && MEDALS[r.medal]) parts.push(MEDALS[r.medal]);
   if (r.collectiblesTotal) parts.push(`🎁 ${r.collectibles || 0}/${r.collectiblesTotal}`);
   if (r.crashes) parts.push(`💥 ${r.crashes}`);
   if (r.mode === 'pair' && typeof r.sync === 'number') parts.push(`🔗 ${Math.round(r.sync)}%`);
   if (r.safety) parts.push('🛡️');
-  if (r.practice) parts.push('🏋️');
+  // #641 · the first try, next to the day's best — the one-shot number.
+  if (r.first && (r.rides || 0) > 1) {
+    const f = r.first;
+    parts.push('1st try ' + (f.dnf ? 'DNF' : f.skipped ? '👑' : formatClock(f.timeMs) + (f.helped ? '🛟' : '')));
+  }
   if (r.streak >= 2) parts.push(`🔥 ${r.streak}`);
   const line2 = parts.join(' · ');
 
diff --git a/js/daily-seed.js b/js/daily-seed.js
index 4f4862c5..5f104954 100644
--- a/js/daily-seed.js
+++ b/js/daily-seed.js
@@ -51,29 +51,6 @@ export function dailySeed(date = new Date()) {
   return seedFromKey(dailyKey(date));
 }
 
-/**
- * #400 · the demo's "Weekly Ride": which week's road is current at
- * `date`, named by its Monday's day key. Built on dailyKey, so the week rolls
- * over at the same 09:00 UTC, on Monday.
- * @returns {string} 'YYYY-MM-DD' (always a Monday)
- */
-export function weeklyKey(date = new Date()) {
-  const day = dailyKey(date);
-  const d = new Date(day + 'T00:00:00Z');
-  const sinceMonday = (d.getUTCDay() + 6) % 7;     // Monday = 0
-  d.setUTCDate(d.getUTCDate() - sinceMonday);
-  return d.toISOString().slice(0, 10);
-}
-
-/**
- * The seed for the week's road. Deliberately the seed of the Monday's daily
- * road: the weekly road IS that Monday's Today's Road, so a day's records and
- * the week's never describe two different roads under one key.
- */
-export function weeklySeed(date = new Date()) {
-  return seedFromKey(weeklyKey(date));
-}
-
 // Salt table — one per thing the world seeds. Keep these stable: changing a
 // salt silently changes every existing daily road.
 export const SALT = {
diff --git a/js/economy-mode.js b/js/economy-mode.js
index def038cc..42a11ff0 100644
--- a/js/economy-mode.js
+++ b/js/economy-mode.js
@@ -190,7 +190,7 @@ class EconomyMode {
     const outcome = finished ? this._lastRecordOutcome : null;
     const mode = this._touristRoute ? 'tourist'
       : level.isTutorial ? 'tutorial'
-      : level.isDaily ? (this._rankedRunActive ? 'daily-ranked' : 'daily')
+      : level.isDaily ? 'daily'
       : this.mode;
     // M2: one ledger per ride (Game._rideRef), not per RaceManager — a retry of
     // segment 1 builds a new RaceManager but is the same ride.
diff --git a/js/economy.js b/js/economy.js
index 61c53517..c365ea59 100644
--- a/js/economy.js
+++ b/js/economy.js
@@ -3,7 +3,7 @@
 // ============================================================
 //
 // #400 D4: every ride rewards you. Solo levels (tutorial included), Today's
-// Road (practice and ranked), co-op (each device pays its own wallet for the
+// Road (every ride counts, #641), co-op (each device pays its own wallet for the
 // shared ride), local versus (once per race) and Tourist all pay through
 // scoreRide() into the one wallet (js/wallet.js). Slingshot keeps its own
 // scoreRun (js/slingshot.js) and pays into the same wallet.
@@ -31,7 +31,7 @@ export const RIDE_PAY = Object.freeze({
   finish: 25,                           // reaching the finish (Tourist: arriving)
   medal: Object.freeze({ bronze: 25, silver: 50, gold: 100 }),
   newBest: 50,                          // beating your previous best on that road
-  dailyFirst: 50,                       // the first Daily Ride finished each day (ranked or practice)
+  dailyFirst: 50,                       // the first Daily Ride finished each day
   streakPerDay: 10,                     // + per day of the streak beyond the first…
   streakCap: 100,                       // …up to this
 });
diff --git a/js/edition.js b/js/edition.js
index 34f81c1e..03d0faf0 100644
--- a/js/edition.js
+++ b/js/edition.js
@@ -1,5 +1,5 @@
 // ============================================================
-// EDITION — full game vs demo (#400)
+// EDITION — full game vs demo (#400, redefined by #641)
 //
 // The demo is a restricted set of the full game, not a fork. Every place that
 // behaves differently in the demo reads these rules instead of re-parsing the
@@ -16,10 +16,13 @@ export const FULL_RULES = Object.freeze({
   isDemo: false,
   /** Level ids offered in the level lists (lobby + NEXT LEVEL). null = all. */
   levels: null,
-  /** The Daily Ride becomes the "Weekly Ride": one seeded road per ISO week. */
-  weeklyRoad: false,
-  /** Ranked Today's Road runs + leaderboard submission. */
-  ranked: true,
+  /**
+   * #641 · Daily Ride rides a day. null = unlimited. A ride counts when it
+   * starts (a restart is a new ride; a checkpoint retry is not).
+   */
+  dailyRideCap: null,
+  /** #641 · achievements that must be earned before the Daily Ride opens. */
+  dailyNeeds: Object.freeze([]),
   /** Slingshot card + garage. maxStage = last stage playable (null = no cap). */
   slingshot: Object.freeze({ enabled: true, maxStage: null }),
   /** Tourist entries (still also need a Maps key — see tourist-config.js). */
@@ -27,24 +30,68 @@ export const FULL_RULES = Object.freeze({
   /** RIDE TOGETHER (online + couch co-op) and VERSUS. */
   rideTogether: true,
   versus: true,
+  /** #641 · bike colours offered in the chooser. null = all. */
+  bikes: null,
+  /** #641 · achievements this edition can award. null = all 100. */
+  achievements: null,
+  /** Level scores go to the 🏆 leaderboard (game._submitScore). */
+  postScores: true,
 });
 
 /**
- * The demo (#400, Pete 2026-10-04): Tutorial, Grandma's and one road a week.
- * The Slingshot stays in with an early stage gate that points at the full game.
- * Multiplayer stays. These are the knobs to change when the demo is redefined.
+ * #641 · the 20 the demo can award (Pete, 2026-11-07). The rest keep counting
+ * their stats, so they unlock on the full game's first check.
+ */
+export const DEMO_ACHIEVEMENTS = Object.freeze([
+  'first_pedal', 'tutorial_done', 'first_crash', 'first_remount', 'first_boost',
+  'home_sweet', 'grandma_bronze', 'grandma_silver', 'grandma_gold', 'first_km',
+  'new_best', 'daily_first', 'daily_gold', 'sling_first', 'sling_stage3',
+  'jackpot', 'first_upgrade', 'coop_first', 'grandma_orange', 'days_3',
+]);
+
+/**
+ * The demo (#641, Pete 2026-11-07, replacing #400's Weekly Ride): Tutorial,
+ * Grandma's, the real Daily Ride (3 rides a day, opened by finishing the
+ * Tutorial and Grandma's), and the Slingshot to stage 3. Co-op stays; Versus,
+ * Tourist, five bike colours and 80 achievements are the full game's.
  */
 export const DEMO_RULES = Object.freeze({
   isDemo: true,
   levels: Object.freeze(['tutorial', 'grandma', 'daily']),
-  weeklyRoad: true,
-  ranked: false,
+  dailyRideCap: 3,
+  dailyNeeds: Object.freeze(['tutorial_done', 'home_sweet']),
   slingshot: Object.freeze({ enabled: true, maxStage: 3 }),
   tourist: false,
   rideTogether: true,
-  versus: true,
+  versus: false,
+  bikes: Object.freeze(['default', 'bike_orange']),
+  achievements: DEMO_ACHIEVEMENTS,
+  postScores: false,   // as #400: the demo's level scores stay off the 🏆 leaderboard
 });
 
+/** #641 · may this edition award achievement `id`? */
+export function achievementAllowed(rules, id) {
+  return !rules.achievements || rules.achievements.includes(id);
+}
+
+/** #641 · is bike preset `key` offered by this edition? */
+export function bikeAllowed(rules, key) {
+  return !rules.bikes || rules.bikes.includes(key);
+}
+
+/**
+ * #641 · can another Daily Ride start? `started` = rides already started on
+ * today's road, `earnedIds` = the player's earned achievement ids.
+ * @returns {{ok:true, left:number|null} | {ok:false, reason:'needs'|'cap', needs?:string[]}}
+ */
+export function dailyRideGate(rules, started, earnedIds = []) {
+  const needs = (rules.dailyNeeds || []).filter(id => !earnedIds.includes(id));
+  if (needs.length) return { ok: false, reason: 'needs', needs };
+  if (rules.dailyRideCap == null) return { ok: true, left: null };
+  const left = Math.max(0, rules.dailyRideCap - Math.max(0, Math.floor(Number(started) || 0)));
+  return left > 0 ? { ok: true, left } : { ok: false, reason: 'cap' };
+}
+
 /**
  * Is this the demo? `?demo=1` (web demo link, and what electron/main.js
  * appends when launched with --demo or TANDEMONIUM_DEMO=1), or an explicit
@@ -135,7 +182,8 @@ export function buildJoinUrl(base, code, { demo = false, media = false } = {}) {
  * client (the build before this list existed).
  *   tourist      co-op Map Tourists (touristPlan / touristReady barrier)
  *   helpingHand  follows the captain's helping-hand tier (timer scaling)
- *   weeklyRoad   knows the demo's Weekly Ride
+ *   weeklyRoad   knew #400's Weekly Ride. #641 retired that road; the cap
+ *                stays advertised so this build still reads as current.
  *   v2LevelSync  adopts levelSync {difficulty, roadKind, key, seed}; refuses
  *                a level its edition does not allow (levelRefused)
  */
@@ -161,8 +209,8 @@ export function partnerFromProfile(profile) {
 /**
  * The rules a room rides by: the MOST RESTRICTIVE of the two sides. Either
  * player on the demo → DEMO_RULES for both. An OLD partner (or one not heard
- * from yet) → no ranked, no Map Tourists, no helping hand. A partner without
- * the 'tourist' cap → no Map Tourists.
+ * from yet) → no Map Tourists, no helping hand. A partner without the
+ * 'tourist' cap → no Map Tourists.
  * @param {object} mine     this side's FULL_RULES / DEMO_RULES
  * @param {{edition:string, caps:string[]|null}|null} partner
  */
@@ -171,7 +219,6 @@ export function mergeRoomRules(mine, partner) {
   const base = mine.isDemo || (partner && partner.edition === 'demo') ? DEMO_RULES : mine;
   return Object.freeze({
     ...base,
-    ranked: base.ranked && !!caps,
     tourist: base.tourist && !!caps && caps.includes('tourist'),
     helpingHand: !!caps && caps.includes('helpingHand'),
     partnerOld: !caps,
@@ -180,17 +227,17 @@ export function mergeRoomRules(mine, partner) {
 
 /**
  * Stoker: may it ride the level in this levelSync under ITS OWN edition?
- * The road kind is the captain's (`roadKind`); a captain that sends none is
- * an old build, whose shared road is always Today's Road ('daily').
- * @returns {{ok:true, roadKind:'daily'|'weekly'|null} | {ok:false, reason:string}}
+ * #641: there is one shared road again (the Daily Ride), so its kind is
+ * always 'daily'. An old #400 demo captain asking for its 'weekly' road is
+ * refused: this side can't build that road any more.
+ * @returns {{ok:true, roadKind:'daily'|null} | {ok:false, reason:string}}
  */
 export function levelSyncVerdict(rules, level, msg = {}) {
   if (!level) return { ok: false, reason: 'unknown' };
   if (!levelAllowed(rules, level.id)) return { ok: false, reason: rules.isDemo ? 'demo' : 'level' };
   if (!level.isDaily) return { ok: true, roadKind: null };
-  const roadKind = msg.roadKind === 'weekly' ? 'weekly' : 'daily';
-  if (roadKind === 'daily' && rules.weeklyRoad) return { ok: false, reason: 'demo' };
-  return { ok: true, roadKind };
+  if (msg.roadKind === 'weekly') return { ok: false, reason: 'level' };
+  return { ok: true, roadKind: 'daily' };
 }
 
 // ── cached, browser-facing ──────────────────────────────────
diff --git a/js/game.js b/js/game.js
index 6db0f983..de9f2f49 100644
--- a/js/game.js
+++ b/js/game.js
@@ -31,7 +31,7 @@ const ACTIVE_TEXT = {
 };
 import { makePlacementSalt, dailyKey } from './daily-seed.js';
 import {
-  recordPractice, recordRanked, recordPartner, computeStreak, computePairStreak, finishedToday,
+  recordDailyFinish, recordRideStart, ridesStarted, firstTry, dailyStatus, recordPartner, computeStreak, computePairStreak, finishedToday,
   buildShareStrip, browserStore
 } from './daily-ride.js';
 import { getLevelById, LEVELS, getInstructions, getMedals, TUTORIAL_PHASES, TUTORIAL_LAST_PHASE } from './race-config.js';
@@ -100,7 +100,7 @@ import { TeamRig } from './versus/team-rig.js';
 import { VersusHud } from './versus/versus-hud.js';
 import { VersusPedalHud } from './versus/versus-pedal-hud.js';
 import { isBotTeam } from './versus/versus-bot.js';
-import { isDemoEdition, getEditionRules, nextAllowedLevel } from './edition.js';
+import { isDemoEdition, getEditionRules, nextAllowedLevel, dailyRideGate } from './edition.js';
 import { mergeRoomRules, partnerFromProfile } from './edition.js'; // PR #397 M1
 import { isMediaEnabled } from './edition.js'; // room camera/mic (#400 D7)
 import { installPhonePadUI } from './remote/phone-pad-ui.js'; // phone remote (#421)
@@ -590,14 +590,6 @@ class Game {
     // Lobby / Room button
     this._lobbyBtn = document.getElementById('lobby-btn');
     this._lobbyBtn.addEventListener('click', () => {
-      // D-2: leaving a ranked run mid-ride spends it, as a DNF. Otherwise a bad
-      // start could be abandoned for a re-roll, and "one run per day" would
-      // mean "as many runs as it takes to like the first checkpoint".
-      if (this._rankedRunActive && this.state === 'playing') {
-        const ok = confirm('End your ranked run? It counts as unfinished for today.');
-        if (!ok) return;
-        this._recordRankedDnf();
-      }
       if (analytics.getCurrentRideId()) {
         analytics.endRide({
           completed: false,
@@ -728,17 +720,6 @@ class Game {
       this._resumeCountdown();
     });
 
-    // #403 · a failed ranked run: the attempt is spent (as a DNF), so ride the
-    // same road again as practice, where the helping hand is on.
-    this._onTap('btn-practice-help', () => {
-      this._hideGameOver();
-      try { analytics.trackEvent('ranked_to_practice', { distance: this.bike ? Math.round(this.bike.distanceTraveled) : 0 }); } catch {}
-      if (this._rankedRunActive) this._recordRankedDnf();
-      if (this.mode === 'captain' && this.net) this.net.sendProfile({ type: 'dailyMode', mode: 'practice' });
-      if (this.lobby) this.lobby._dailyMode = 'practice';
-      this._resetGame(false, true);
-    });
-
     // Game Over: restart
     this._onTap('btn-restart', () => {
       if (this.mode === 'stoker' && this.net) {
@@ -1100,8 +1081,11 @@ class Game {
     const cur = this.lobby.selectedLevel;
     if (!cur) return null;
     const locked = this.lobby._lockedLevelIds;
+    // #641: the Daily Ride's gate is read live — finishing Grandma's (the ride
+    // this NEXT LEVEL follows) is what opens it in the demo, after the lobby's
+    // cards last looked.
     const next = nextAllowedLevel(LEVELS, cur.id, this._roomRules(),   // M1: a room's rules
-      (l) => !!(locked && locked.has(l.id)));
+      (l) => (l.isDaily && this.lobby._dailyGate) ? !this.lobby._dailyGate().ok : !!(locked && locked.has(l.id)));
     return next ? this.lobby.resolveRoadLevel(next) : null;
   }
 
@@ -1468,23 +1452,14 @@ class Game {
       }
       // Handle tilt status from partner (motion availability only — NOT a
       // steering-capability signal; a desktop partner steers without tilt).
-      // D-2: the captain chose practice or ranked for the pair. The countdown
-      // event is a bare byte, so the mode needs its own message; the stoker
-      // stores the pair result too, so it has to know.
       // #403: the captain's helping-hand tier and flags.
       if (profile && profile.type === HELP_PROFILE_TYPE) {
         this._onHelpProfile(profile);
         return;
       }
-      if (profile && profile.type === 'dailyMode') {
-        // #403: the captain turned a failed ranked run into practice — it is
-        // spent on this side too.
-        if (this._rankedRunActive && profile.mode !== 'ranked' && this.state !== 'lobby') this._recordRankedDnf();
-        // PR #397 M1: never ranked when this side's (or the room's) rules say no.
-        this._rankedRunActive = profile.mode === 'ranked' && this._roomRules().ranked;
-        if (this.hud && this.hud.setRankedBadge) this.hud.setRankedBadge(this._rankedRunActive);
-        return;
-      }
+      // #641: no ranked runs any more. A pre-#641 captain still sends its
+      // practice/ranked choice; there is nothing to do with it.
+      if (profile && profile.type === 'dailyMode') return;
       // #400: the partner's side of the co-op Tourist ready barrier.
       if (profile && profile.type === ROOM_MSG.TOURIST_READY) {
         this._partnerTouristReady = !!profile.ok;
@@ -2207,10 +2182,17 @@ class Game {
     if (this.mode === 'versus') { this._startVersusCountdown(); return; }
 
     // #400 D4 / M2: a ride left for a new one still pays its distance. First,
-    // before the bike or world is reset and before _rankedRunActive is
-    // recomputed for the next ride (m14). Idempotent through the ledger.
+    // before the bike or world is reset (m14). Idempotent through the ledger.
     this._payoutAbandon();
 
+    // #641 · the demo's three Daily Rides a day: a NEW ride (not a retry of
+    // segment 1) on the road can't start once they are used. Every way in —
+    // RESTART, PLAY AGAIN, the quick menu — comes through here.
+    if (this._dailyRideBlocked()) {
+      this._leaveForDailyCap();
+      return;
+    }
+
     this.state = 'countdown';
     this.countdownTimer = 3.0;
     this._recenterPhonesForRide();
@@ -2226,15 +2208,15 @@ class Game {
     // Apply difficulty preset and create DDA manager
     const difficultyName = this.lobby.selectedDifficulty || 'adventurous';
     applyDifficulty(difficultyName);
-    // D-2: no dynamic difficulty on a ranked run. Everyone rides the same road
-    // under the same rules, or the times mean nothing. Every ddaManager call
-    // site is already null-guarded (grep: `this.ddaManager &&`).
+    // Every ddaManager call site is null-guarded (grep: `this.ddaManager &&`).
+    // #641: the Daily Ride keeps the DDA and the helping hand; a ride that used
+    // either posts no board time (_dailyRideClean).
     // #403: a retry of the first segment comes through here too (the bike goes
     // back to the start line). It keeps the DDA, so its failure count — and the
     // helping hand — survive; a new ride starts a fresh one.
-    const keepHelp = !!this._helpKeepRide && !!this.ddaManager && !this._rankedRunActive;
+    const keepHelp = !!this._helpKeepRide && !!this.ddaManager;
     this._helpKeepRide = false;
-    this.ddaManager = (this._rankedRunActive || !this._rideSystemOn('dda')) ? null
+    this.ddaManager = !this._rideSystemOn('dda') ? null
       : (keepHelp ? this.ddaManager : new DDAManager(difficultyName));
     if (keepHelp) this.ddaManager.applyInvisibleAdjustments();
     this._assistWeight = 0;
@@ -2357,33 +2339,19 @@ class Game {
       flavorNum.textContent = '3';
       flavorNum.className = 'tick-3 pop';
     }
-    // D-2 · is this the day's ranked run? The lobby asked; the demo never does
-    // (practice only there), and a stoker takes whatever the captain chose.
-    // The chooser sets _dailyMode per ride and it is CONSUMED here: without
-    // clearing it, every later Today's Road ride in the session would claim to
-    // be ranked, show the badge, and try to spend a run that is already gone.
-    // The stoker never chooses: its value arrives in the captain's `dailyMode`
-    // message, which can land either side of the countdown event, so this must
-    // not overwrite it.
-    if (this.mode !== 'stoker') {
-      const chosenMode = this.lobby._dailyMode;
-      this.lobby._dailyMode = null;
-      this._rankedRunActive = !!(level.isDaily && chosenMode === 'ranked' && getEditionRules().ranked);
-    }
-    // #403: the DDA above was created before this ride was known to be ranked
-    // (the flag still held the previous ride's value), so a ranked run used to
-    // get the silent tune and the ASSIST offer. Ranked stays pure.
-    if (this._rankedRunActive) this.ddaManager = null;
-    this._applyRankedLocks();   // M4: SAFETY and SPEED off and locked on a ranked run
-    if (this._rankedRunActive && this.mode === 'captain' && this.net) {
-      // The countdown event is a bare byte, so the mode needs its own message.
-      this.net.sendProfile({ type: 'dailyMode', mode: 'ranked', key: level.key });
-    }
-
     // M2: the payout ledger is keyed by RIDE: start line → finish or abandon,
     // through any checkpoint restarts. A retry of segment 1 is the same ride.
-    if (!this._sameRideNext || !this._rideRef) this._rideRef = {};
+    const newRide = !this._sameRideNext || !this._rideRef;
+    if (newRide) this._rideRef = {};
     this._sameRideNext = false;
+    // #641 · a new ride on the Daily Ride counts (the demo's cap, the first
+    // try) and starts out clean: SAFETY, SPEED, ASSIST, the silent tune or the
+    // helping hand at any point make it a ride that posts no board time.
+    if (newRide) {
+      this._rideAided = false;
+      this._dailyRideNo = (level.isDaily && level.key && this.mode !== 'versus')
+        ? recordRideStart(browserStore(), level.key) : 0;
+    }
     this.raceManager = new RaceManager(level);
     this.hud.raceManager = this.raceManager;
     this._helpStartRide(keepHelp);   // #403: before the first budget is shown
@@ -2446,7 +2414,7 @@ class Game {
     // along; they would all land at the start (#432).
     if (this._rideSystemOn('disruptions') && !level.isTourist) this._startDisruptions(level, difficultyName);
     else this._disruptions = [];
-    if (this.hud.setRankedBadge) this.hud.setRankedBadge(this._rankedRunActive);
+
 
     // Tutorial: place all items from all phases so they're visible ahead
     if (level.isTutorial && this._tutorialActive) {
@@ -2825,6 +2793,9 @@ class Game {
     this._closePause();   // #459: RESTART from the pause menu, or a partner's reset while paused
     // Slingshot: every reset is back into the slingshot, never to a checkpoint.
     if (this.isSlingshot) { this._resetToSling(); return; }
+    // #641: PLAY AGAIN / NEXT LEVEL onto the Daily Ride is a new ride — refuse
+    // it here, before the partner is told to reset, when the demo's are used.
+    if (fromBeginning && !fromRemote && this._dailyCapReached()) { this._leaveForDailyCap(); return; }
     // M2: pay what the ride has done before the bike goes back (the ledger
     // makes a second payout of the same metres pay nothing).
     this._payoutAbandon();
@@ -3350,12 +3321,6 @@ class Game {
     if (lobbyBtn) lobbyBtn.textContent = this.net ? 'END RIDE TOGETHER' : 'END RIDE';
 
     const skipBtn = document.getElementById('btn-skip-checkpoint');
-    // #403 · a failed ranked run: offer the same road as practice, with help.
-    const practiceBtn = document.getElementById('btn-practice-help');
-    if (practiceBtn) {
-      const level = this.lobby.selectedLevel;
-      practiceBtn.style.display = (this._rankedRunActive && this.mode !== 'stoker' && level && level.isDaily) ? '' : 'none';
-    }
     // B-5: wishlist + send-a-link, after the ride buttons.
     this._updateCtaButtons('gameover');
     // #400 D4: a crashed ride still pays for its distance.
@@ -3506,10 +3471,10 @@ class Game {
       html += '<div class="victory-stat">' + earned + chase + '</div>';
     }
 
-    // C-2 / D-2 · Today's Road counts its own rides, so the card can say what
-    // you have done today, and the day's ranked run is spent here if this was
-    // one. The stoker's screen shows the captain's numbers but writes nothing
-    // from them — except the pair result, which is genuinely both riders'.
+    // C-2 / #641 · the Daily Ride counts its own finishes, so the card can say
+    // what you have done today and the share strip knows the first try. The
+    // stoker's screen shows the captain's numbers but writes nothing from them
+    // — except the pair result, which is genuinely both riders'.
     if (level.isDaily && level.key) {
       const store = browserStore();
       const dailyMode = this._dailyRunMode();
@@ -3518,31 +3483,22 @@ class Game {
       // record goes in, consumed by the payout (_payoutRide).
       const firstToday = !finishedToday(store, level.key);
       let recorded = false;
-      if (this._rankedRunActive) {
-        recorded = true;
-        recordRanked(store, level.key, dailyMode, {
-          timeMs: summary.timeMs,
-          distance: summary.distance,
-          collectibles: summary.collectibles,
-          collectiblesTotal: summary.collectiblesTotal,
-          crashes: summary.crashes,
-          safety: this.safetyMode,
-          sync: this.sharedPedal ? this.sharedPedal.offsetScore : null,
-          partner: this._partnerKey()
-        });
-      } else if (!fromRemote && !help.skipped) {
+      if (!fromRemote && !help.skipped) {
         // #403: a 🛟 finish counts as finishing the road (streaks, Slingshot's
-        // gate) but its time is not the practice best; a shortcut is neither.
-        recordPractice(store, level.key, help.helped ? null : summary.timeMs);
+        // gate) but its time is not the day's best; a shortcut is neither.
+        recordDailyFinish(store, level.key, {
+          timeMs: summary.timeMs, helped: help.helped, skipped: help.skipped, rideNo: this._dailyRideNo
+        });
         recorded = true;
       }
       if (recorded) this._dailyBonusInfo = { firstToday, streak: computeStreak(store, level.key).current };
+      if (!fromRemote) html += this._dailyVictoryLine();
       if (dailyMode === 'pair' && this._partnerKey()) {
         recordPartner(store, level.key, this._partnerKey());
       }
       try {
         analytics.trackEvent('daily_finish', {
-          key: level.key, mode: dailyMode, ranked: this._rankedRunActive,
+          key: level.key, mode: dailyMode, clean: this._dailyRideClean(), ride_no: this._dailyRideNo || 0,
           time_ms: summary.timeMs, safety: this.safetyMode, crashes: summary.crashes,
           geese_scattered: this.geeseManager ? this.geeseManager.getDisruptedCount() : 0   // #364
         });
@@ -3564,34 +3520,81 @@ class Game {
     return html;
   }
 
+  // ── #641 · the Daily Ride: every ride counts, the best clean time posts ──
+
   /**
-   * #398 · a ranked run is over (finish, END RIDE / DNF, quit, disconnect):
-   * nothing is ranked any more, and the RANKED RUN badge must not follow the
-   * player back into the lobby.
+   * Did this ride use no help at all? SAFETY or SPEED switched on at any
+   * point, the DDA's silent tune, ASSIST, the helping hand or the Royal
+   * Shortcut each make it a ride whose time stays off the board.
    */
-  _endRankedRun() {
-    this._rankedRunActive = false;
-    this._applyRankedLocks();   // M4: SAFETY and SPEED back as the player had them
-    if (this.hud && this.hud.setRankedBadge) this.hud.setRankedBadge(false);
+  _dailyRideClean() {
+    const help = this._helpFlags ? this._helpFlags() : { helped: false, skipped: false };
+    return !this._rideAided && !help.helped && !help.skipped;
   }
 
-  /** D-2 · spend the day's ranked run as an unfinished attempt. */
-  _recordRankedDnf() {
-    const level = this.lobby.selectedLevel;
-    if (!level || !level.isDaily || !level.key) return;
-    recordRanked(browserStore(), level.key, this._dailyRunMode(), {
-      dnf: true,
-      distance: this.bike ? this.bike.distanceTraveled : 0,
-      crashes: this.raceManager ? this.raceManager.crashCount : 0,
-      safety: this.safetyMode,
-      partner: this._partnerKey()
-    });
-    this._endRankedRun();
+  /** Per frame while riding: note any help the ride is using. */
+  _noteRideAided() {
+    if (this._rideAided) return;
+    if (this.safetyMode || this.autoSpeed || (this.ddaManager && this.ddaManager._adjustmentsActive)) {
+      this._rideAided = true;
+    }
+  }
+
+  /**
+   * The edition's gate for starting ANOTHER Daily Ride from this device:
+   * {ok, left} or {ok:false, reason:'needs'|'cap'} (edition.dailyRideGate).
+   */
+  _dailyGate() {
+    const level = this.lobby && this.lobby.selectedLevel;
+    if (!level || !level.isDaily || !level.key) return { ok: true, left: null };
+    // One gate for the lobby and the game (lobby._dailyGate reads the saved list).
+    if (this.lobby._dailyGate) return this.lobby._dailyGate();
+    const earned = this.achievements ? this.achievements.getEarnedIds() : [];
+    return dailyRideGate(this._roomRules(), ridesStarted(browserStore(), level.key), earned);
+  }
+
+  /**
+   * Would the countdown about to run start a NEW Daily Ride the demo has no
+   * rides left for? A retry of segment 1 is the same ride, and the stoker
+   * never decides (the captain's side counts).
+   */
+  _dailyRideBlocked() {
+    if (this._sameRideNext && this._rideRef) return false;
+    return this._dailyCapReached();
+  }
+
+  /** Are the demo's Daily Rides for today used up (captain / solo / local side)? */
+  _dailyCapReached() {
+    const level = this.lobby && this.lobby.selectedLevel;
+    if (!level || !level.isDaily || this.mode === 'stoker' || this.mode === 'versus') return false;
+    const gate = this._dailyGate();
+    return !gate.ok && gate.reason === 'cap';
+  }
+
+  /** Out of Daily Rides: back to the room (a room stays together) or the lobby, and say why. */
+  _leaveForDailyCap() {
+    this._hideVictory();
+    this._hideGameOver();
+    if (this.net && this.net.connected) this._returnToRoom();
+    else this._returnToLobby();
+    this._showDailyCapNotice();
+  }
+
+  /** The Daily Ride's line on the victory sheet: rides left (demo) and whether the time posts. */
+  _dailyVictoryLine() {
+    const bits = [];
+    const cap = this._roomRules().dailyRideCap;
+    if (cap != null && this._dailyRideNo) {
+      bits.push('📅 Daily Ride ' + Math.min(this._dailyRideNo, cap) + ' of ' + cap + ' today');
+    }
+    if (!this._dailyRideClean()) bits.push('🛟 Help used, so this time stays off the board');
+    return bits.length ? '<div class="victory-stat">' + bits.join(' · ') + '</div>' : '';
+  }
+
+  _showDailyCapNotice() {
     try {
-      analytics.trackEvent('daily_finish', {
-        key: level.key, mode: this._dailyRunMode(), ranked: true, dnf: true,
-        distance: this.bike ? Math.round(this.bike.distanceTraveled) : 0
-      });
+      showInfoToast('📅', 'That’s today’s three Daily Rides',
+        'A new road arrives at 09:00 UTC. The full game rides it as often as you like.');
     } catch {}
   }
 
@@ -4439,7 +4442,7 @@ class Game {
         (pair.rides || 0) + ' ride' + (pair.rides === 1 ? '' : 's') + ' together' +
         (km >= 0.1 ? ' · ' + km.toFixed(1) + ' km' : '') +
         (previousBest ? ' · best ' + records.formatTime(previousBest) : '') +
-        (pair.daily_streak >= 2 && !getEditionRules().weeklyRoad ? ' · 🔥 ' + pair.daily_streak : '') +
+        (pair.daily_streak >= 2 ? ' · 🔥 ' + pair.daily_streak : '') +
       '</div>' +
       (beat ? '<div class="pair-panel-best">⭐ NEW PAIR BEST</div>' : '');
     el.style.display = 'block';
@@ -4448,14 +4451,15 @@ class Game {
   }
 
   /**
-   * D-6 · send the day's ranked run to the server, once. A 409 means this
-   * account has already ridden today in this mode, which is not an error —
-   * it is the rule working.
+   * D-6 / #641 · send a finished Daily Ride to the board. Every clean finish
+   * goes; the server keeps the account's best time of the day per mode. A
+   * helped ride, a DNF and the stoker's copy of the captain's finish never go.
    */
-  async _submitDailyRanked(summary) {
+  async _submitDailyBest(summary, fromRemote = false) {
     const level = this.lobby.selectedLevel;
     const auth = this.lobby.auth;
-    if (!level || !level.isDaily || !this._rankedRunActive) return;
+    if (!level || !level.isDaily || !level.key || fromRemote) return;
+    if (!summary || summary.dnf || !(summary.timeMs > 0) || !this._dailyRideClean()) return;
     if (!auth || !auth.isLoggedIn()) return;      // a local result is still kept
     if (!DAILY_BOARD_ENABLED) return;
 
@@ -4464,21 +4468,21 @@ class Game {
         dayKey: level.key,
         mode: this._dailyRunMode(),
         timeMs: summary.timeMs,
-        dnf: !!summary.dnf,
+        dnf: false,
         distance: summary.distance,
         collectibles: summary.collectibles,
         crashes: summary.crashes,
-        safetyUsed: this.safetyMode,
+        safetyUsed: false,
         syncPct: this.sharedPedal ? Math.round(this.sharedPedal.offsetScore * 100) : null,
         partnerUserId: this._partnerServerId || (this._seatAccount() ? this._seatAccount().user.id : null)
       });
-      if (res && res.alreadyRidden) {
-        analytics.trackEvent('daily_submit_duplicate', { key: level.key });
+      if (res && res.success) {
+        analytics.trackEvent('daily_submit', { key: level.key, improved: !!res.improved });
       }
     } catch { /* the ride is already recorded locally; the server can wait */ }
   }
 
-  /** D-2 · 'solo' or 'pair' — the two independent ranked runs per day. */
+  /** D-2 · 'solo' or 'pair' — the two independent board entries per day. */
   _dailyRunMode() {
     return (this.mode === 'solo') ? 'solo' : 'pair';
   }
@@ -4508,9 +4512,11 @@ class Game {
    * pure, tested function; this method only gathers the numbers.
    */
   _buildDailyStripHtml(summary, level) {
-    if (!level.isDaily || !level.key || this._isDemo) return '';
+    if (!level.isDaily || !level.key) return '';
     const store = browserStore();
     const mode = this._dailyRunMode();
+    // #641 · the day so far: the best clean time and the first try.
+    const day = dailyStatus(store, level.key);
     const partnerKey = this._partnerKey();
     const streak = mode === 'pair' && partnerKey
       ? computePairStreak(store, partnerKey, level.key).current
@@ -4524,13 +4530,18 @@ class Game {
       dnf: !!summary.dnf,
       distance: summary.distance,
       raceDistance: summary.raceDistance || level.distance,
-      medal: this._helpMedal(summary.timeMs, thresholds),   // #403
+      // #641: the strip leads with the day's best, so its medal is the best's.
+      medal: day.best && !(summary.timeMs > 0 && summary.timeMs <= day.best)
+        ? records.medalFor(day.best, thresholds)
+        : this._helpMedal(summary.timeMs, thresholds),   // #403
       collectibles: summary.collectibles,
       collectiblesTotal: summary.collectiblesTotal,
       crashes: summary.crashes,
       sync: this.sharedPedal ? Math.round(this.sharedPedal.offsetScore * 100) : undefined,
       safety: this.safetyMode,
-      practice: !this._rankedRunActive,
+      bestMs: day.best,
+      first: firstTry(store, level.key),
+      rides: day.started,
       streak,
       partnerName: mode === 'pair' ? this._partnerName : null
     }, { origin: location.origin });
@@ -4757,11 +4768,8 @@ class Game {
 
     // F-1 · the loops the plan built. Read from the local stores, so they work
     // signed out; the pair numbers come from the server panel when there is one.
-    // #400: no day streaks off the demo's weekly road.
-    const weekly = !!(level.isWeekly || getEditionRules().weeklyRoad);
-    if (level.isDaily && level.key && !weekly) {
+    if (level.isDaily && level.key) {
       const store = browserStore();
-      state.dailyRanked = this._rankedRunActive;
       const mode = this._dailyRunMode();
       const partnerKey = this._partnerKey();
       state.dailyStreak = mode === 'pair' && partnerKey
@@ -4784,7 +4792,6 @@ class Game {
       isCoop: this.mode === 'captain' || this.mode === 'stoker' || this.mode === 'local',
       partnerKey,
       touristFinished: !!(this.isTourist || this._touristRoute),
-      weekly,   // m5: the weekly road feeds no day streak
       pairWeekStreak: partnerKey ? computePairStreak(browserStore(), partnerKey, level.key || dailyKey()).current : 0,
     });
     // #500 · Look, No Thumbs: earned by each rider on THIS device who steered the
@@ -5215,8 +5222,9 @@ class Game {
 
     // Auto-submit score if logged in
     this._submitScore();
-    // D-6 / D-8: the day's ranked result, and what the two of you have done.
-    this._submitDailyRanked(summary);
+    // D-6 / D-8 · #641: a clean Daily finish goes to the board (the server keeps
+    // the day's best), and what the two of you have done.
+    this._submitDailyBest(summary, fromRemote);
     this._renderPairPanel(summary);
 
     // Show NEXT LEVEL button if there's a next level. #400: in the demo, after
@@ -5289,7 +5297,7 @@ class Game {
     const auth = this.lobby.auth;
     if (!auth || !auth.isLoggedIn()) return;
     // Demo mode: don't save scores to leaderboard
-    if (!getEditionRules().ranked) return;
+    if (!getEditionRules().postScores) return;
 
     const level = this.lobby.selectedLevel;
     const raceSummary = this.raceManager ? this.raceManager.getSummary(this.bike.distanceTraveled) : null;
@@ -5516,7 +5524,6 @@ class Game {
       this._overlayFocus.input = this.input;
     }
     this._payoutAbandon();   // #400 D4: an abandoned ride still pays its distance
-    this._endRankedRun();   // #398
     this._helpEndRide();    // #403
     if (this._coachVisible) this._dismissCoachCard();
     this._hideTouristGoal();   // E-7
@@ -5671,7 +5678,6 @@ class Game {
     this._waitingForCaptain = false;
     this._closePause();      // #459
     this._payoutAbandon();   // #400 D4
-    this._endRankedRun();   // #398
     this._helpEndRide();    // #403
     // A short ride can end before the first-ride coach card does; don't carry
     // it over the room (_returnToLobby does the same).
@@ -6885,8 +6891,7 @@ class Game {
     const segmentKey = this.raceManager ? this.raceManager.passedCheckpoints.size : 0;
     this._crashState = countCrash(this._crashState || { segmentKey: -1, crashes: 0 }, segmentKey);
     const decision = decideAfterCrash({
-      crashesThisSegment: this._crashState.crashes,
-      rankedRun: !!this._rankedRunActive        // Phase D sets this
+      crashesThisSegment: this._crashState.crashes
     });
 
     if (decision.action === 'modal') {
@@ -7245,6 +7250,8 @@ class Game {
       if (this.mode === 'versus') this._pollVersusRecenter();
       else { this._pollDpad(); this._pollP2Recenter(); }
 
+      // #641: any help the ride uses keeps a Daily time off the board.
+      if (this.mode !== 'versus' && this.mode !== 'stoker') this._noteRideAided();
       // Playing state — dispatch by mode
       if (this.mode === 'solo') {
         this._updateSolo(dt * this._crashScale(this.bike));   // #484 slow-mo
@@ -7683,34 +7690,7 @@ class Game {
     this._updateSafetyBtn();
   }
 
-  /**
-   * M4 · ranked fairness. A ranked run rides with SAFETY and SPEED (cruise)
-   * forced off, and both buttons (HUD, D-pad, quick menu) disabled for the
-   * ride — `safetyUsed` is only sampled at the finish, so toggling mid-run
-   * would otherwise submit as safety-free. When the run is over the player's
-   * own choices come back. Called whenever _rankedRunActive changes.
-   */
-  _applyRankedLocks() {
-    const lock = !!this._rankedRunActive;
-    if (lock) {
-      // (Safety the helping hand turned on is not the player's choice — m13.)
-      if (!this._rankedLockPrev) this._rankedLockPrev = { safety: this._helpSafetyPrev === false ? false : this.safetyMode, speed: this.autoSpeed };
-      this.safetyMode = false;
-      this.autoSpeed = false;
-    } else if (this._rankedLockPrev) {
-      this.safetyMode = this._rankedLockPrev.safety;
-      this.autoSpeed = this._rankedLockPrev.speed;
-      this._rankedLockPrev = null;
-    }
-    this._updateSafetyBtn();
-    if (this.speedBtn) {
-      this.speedBtn.className = 'side-btn ' + (this.autoSpeed ? 'speed-on' : 'speed-off');
-      this.speedBtn.textContent = this.autoSpeed ? 'ON\nSPEED' : 'SPEED';
-      this.speedBtn.disabled = lock;
-    }
-    if (this.safetyBtn) this.safetyBtn.disabled = lock;
-    if (this.quickMenu && this.quickMenu.sync) this.quickMenu.sync();
-  }
+
 
   _recordBalanceCrashIfNew(wasFallen) {
     if (!wasFallen && this.bike.fallen && !this._lastCrashCause) {
diff --git a/js/helping-hand-mode.js b/js/helping-hand-mode.js
index e8621076..b4c13b42 100644
--- a/js/helping-hand-mode.js
+++ b/js/helping-hand-mode.js
@@ -34,7 +34,6 @@ class HelpingHandMode {
     if (this.mode === 'versus' || this.isSlingshot) return false;
     if (level.isTutorial || this._tutorialActive) return false;
     if (level.timerEnabled === false || this._touristRoute || this.isTourist) return false;
-    if (this._rankedRunActive) return false;   // ranked stays pure (D-2)
     // PR #397 M1: an old-build partner can't follow the tier (its timer would
     // run out first), so a room with one gets no helping hand at all.
     if (this._roomRules && !this._roomRules().helpingHand && (this.mode === 'captain' || this.mode === 'stoker')) return false;
diff --git a/js/hud.js b/js/hud.js
index 5184ee2e..7018b91e 100644
--- a/js/hud.js
+++ b/js/hud.js
@@ -237,20 +237,9 @@ export class HUD {
     this._splitDeltaTimer = setTimeout(() => { el.className = ''; }, 1500);
   }
 
-  /**
-   * D-2 · say when a ride counts. A ranked run looks exactly like a practice
-   * run from the saddle, and finding out afterwards that the one that counted
-   * was the one you were not trying on would be miserable.
-   */
-  setRankedBadge(on) {
-    const el = this._rankedBadgeEl || (this._rankedBadgeEl = document.getElementById('ranked-badge'));
-    if (el) el.classList.toggle('show', !!on);
-  }
-
   /**
    * #403 · the helping hand's badge: 💨 (Tier 1) or 🎩 (Tier 2) while a tier is
-   * on, so the easier retry reads as a game mechanic, not a hidden nerf. It sits
-   * where the RANKED RUN badge does — a ranked run never gets help.
+   * on, so the easier retry reads as a game mechanic, not a hidden nerf.
    */
   setHelpBadge(tier, label = '') {
     const el = this._helpBadgeEl || (this._helpBadgeEl = document.getElementById('help-badge'));
diff --git a/js/lobby.js b/js/lobby.js
index c25ccc72..f134f4fd 100644
--- a/js/lobby.js
+++ b/js/lobby.js
@@ -46,13 +46,12 @@ import { InputManager, isSteamTwinPad } from './input-manager.js';
 import { isMobile, isTV, RELAY_URL, BIKE_MODEL_PATH, CHOOSER_MODEL_PATH, TUNE, GUEST_NAME, applySteeringFeel, snapshotTuningBase, saveSteeringFeelPref, BALANCE_DEFAULTS } from './config.js';
 import { getCurrentTier } from './quality.js';
 import { LEVELS, getMedals } from './race-config.js';
-import { makePlacementSalt, dailyKey, dailySeed, weeklyKey } from './daily-seed.js';
+import { makePlacementSalt, dailyKey, dailySeed } from './daily-seed.js';
 import { planRoute, planExplore, skipLabel, isValidPoint } from './tourist-route.js';
 import { getMapsApiKey, geocodeAddress, resolveOriginAt } from './tourist-config.js';
 import {
   resolveDailyLevel, dailyStatus, dailyDescription, browserStore, DAILY_RULES_LINE,
-  rankedResult, computeStreak, formatDayLabel, formatClock,
-  asWeeklyRoad, resolveWeeklyLevel, weeklyDescription, WEEKLY_RULES_LINE
+  ridesStarted
 } from './daily-ride.js';
 import * as records from './records.js';
 import { isTutorialDone, tutorialStore } from './tutorial-progress.js';
@@ -80,7 +79,7 @@ import { RoomStore } from './lobby/room-store.js';
 import { RoomProtocol, ROOM_MSG } from './lobby/room-protocol.js';
 import { NetSession } from './lobby/net-session.js';
 import { renderRoomQR, joinUrl } from './lobby/room-qr.js';
-import { isDemoEdition, getEditionRules, levelAllowed, carriedQuery } from './edition.js';
+import { isDemoEdition, getEditionRules, levelAllowed, carriedQuery, dailyRideGate, bikeAllowed } from './edition.js';
 import { mergeRoomRules, roomProfileFields, partnerFromProfile, levelSyncVerdict } from './edition.js'; // PR #397 M1
 import { isMediaEnabled } from './edition.js'; // room camera/mic (#400 D7)
 import { versusBotAllowed } from './versus/versus-bot.js';
@@ -1201,7 +1200,20 @@ export class Lobby {
     // VERSUS (local split-screen team racing) — desktop-only, like local co-op:
     // needs multiple physical controllers on one machine.
     const btnVersus = document.getElementById('btn-versus');
-    if (btnVersus && !isMobile) {
+    // #641: Versus is the full game's. The demo shows it shut, with a tag, and
+    // a press says where it is rather than doing nothing.
+    const versusInEdition = getEditionRules().versus;
+    if (btnVersus && !isMobile && !versusInEdition) {
+      btnVersus.style.display = '';
+      btnVersus.classList.add('lobby-role-locked');
+      btnVersus.style.opacity = '0.55';
+      const desc = btnVersus.querySelector('.lobby-role-desc');
+      if (desc) desc.textContent = '🔒 In the full game';
+      btnVersus.addEventListener('click', () => {
+        showInfoToast('🔒', 'Versus is in the full game', 'Race side by side, 2–4 players. Wishlist Tandemonium on Steam.');
+        analytics.trackEvent('demo_locked', { what: 'versus' });
+      });
+    } else if (btnVersus && !isMobile) {
       btnVersus.style.display = '';
       btnVersus.addEventListener('click', async () => {
         analytics.trackEvent('versus_setup_opened');
@@ -1264,22 +1276,6 @@ export class Lobby {
       this._showStep(this.levelStep);
     });
 
-    // D-2 · Today's Road asks one question before the ride: practice, or the
-    // day's ranked run? The chooser intercepts START RIDE and calls it back.
-    for (const [id, mode] of [['btn-daily-ranked', 'ranked'], ['btn-daily-practice', 'practice']]) {
-      const btn = document.getElementById(id);
-      if (btn) btn.addEventListener('click', () => {
-        if (btn.disabled) return;
-        this._dailyMode = mode;
-        document.getElementById('daily-mode-overlay').classList.remove('visible');
-        this._startRide();
-      });
-    }
-    const cancelBtn = document.getElementById('btn-daily-cancel');
-    if (cancelBtn) cancelBtn.addEventListener('click', () => {
-      document.getElementById('daily-mode-overlay').classList.remove('visible');
-    });
-
     // Levels step: START RIDE button — works for solo, multiplayer, and local co-op
     document.getElementById('btn-start-ride').addEventListener('click', () => {
       // #517: the Slingshot card was picked — START RIDE opens its garage.
@@ -1291,9 +1287,9 @@ export class Lobby {
         analytics.trackEvent('slingshot_open');
         return;
       }
-      // D-2: on Today's Road, ask first — unless this is the demo, which is
-      // practice-only, or the chooser has already been answered.
-      if (this._shouldAskDailyMode()) { this._showDailyModeChooser(); return; }
+      // #641: the Daily Ride's gate (the demo opens it after the Tutorial and
+      // Grandma's, then gives it three rides a day). The stoker never starts.
+      if (this.selectedLevel && this.selectedLevel.isDaily && !this._dailyGateAllows()) return;
       this._startRide();
     });
 
@@ -1490,7 +1486,7 @@ export class Lobby {
     const store = records.load();
     // Today's Road is recorded under today's day (or week) key; the card's
     // level is the unresolved base, so pass the key it would ride today.
-    const roadKey = level.isWeekly ? weeklyKey() : level.isDaily ? dailyKey() : undefined;
+    const roadKey = level.isDaily ? dailyKey() : undefined;
     const best = records.getBest(store, records.key(records.levelRecordId(level, roadKey), this.selectedDifficulty, cardMode));
     const thresholds = getMedals(level.id, this.selectedDifficulty);
     if (!best) {
@@ -1534,7 +1530,7 @@ export class Lobby {
     const extra = { difficulty: this.selectedDifficulty };
     if (level && level.isDaily) {
       extra.key = level.key; extra.seed = level.seed;
-      extra.roadKind = level.isWeekly ? 'weekly' : 'daily';
+      extra.roadKind = 'daily';
     }
     return extra;
   }
@@ -1545,64 +1541,17 @@ export class Lobby {
   }
 
   /**
-   * #400 · the shared road with its identity attached: Today's Road, or in the
-   * demo Weekly Ride (rules.weeklyRoad). Any other level comes back as is.
-   * `key`/`seed` are the captain's when a stoker resolves it (C-2).
+   * The shared road with its identity attached (the Daily Ride, in both
+   * editions since #641). Any other level comes back as is. `key`/`seed` are
+   * the captain's when a stoker resolves it (C-2).
    */
   resolveRoadLevel(level, { key, seed } = {}) {
     if (!level || !level.isDaily) return level;
-    if (this.roomRules().weeklyRoad) return resolveWeeklyLevel(level, { key, seed });
     return resolveDailyLevel(level, {
       key: key || dailyKey(), seed: typeof seed === 'number' ? seed : dailySeed()
     });
   }
 
-  /**
-   * D-2 · should the practice/ranked chooser appear?
-   *
-   * Only on Today's Road, only in the web build, and only for the person who
-   * decides: in a room the captain chooses for the pair and the stoker rides
-   * whatever was chosen.
-   */
-  _shouldAskDailyMode() {
-    if (!this.selectedLevel || !this.selectedLevel.isDaily) return false;
-    if (!this.roomRules().ranked) return false;        // demo is practice-only; so is a room with a demo/old partner
-    if (this._pendingMode === 'multiplayer' && this._roomRole !== 'captain') return false;
-    return true;
-  }
-
-  /** D-2 · the chooser itself. RANKED is disabled once the day's run is used. */
-  _showDailyModeChooser() {
-    const overlay = document.getElementById('daily-mode-overlay');
-    if (!overlay) { this._dailyMode = 'practice'; this._startRide(); return; }
-
-    const key = this.selectedLevel.key || dailyKey();
-    const mode = this._pendingMode === 'multiplayer' || this._pendingMode === 'local' ? 'pair' : 'solo';
-    const store = browserStore();
-    const done = rankedResult(store, key, mode);
-
-    const sub = document.getElementById('daily-mode-sub');
-    if (sub) {
-      const streak = computeStreak(store, key);
-      const streakText = streak.current >= 2 ? ` · 🔥 ${streak.current}` : '';
-      sub.textContent = `${formatDayLabel(key)} · ${mode === 'pair' ? 'riding as a pair' : 'riding solo'}${streakText}`;
-    }
-
-    const rankedBtn = document.getElementById('btn-daily-ranked');
-    const hint = document.getElementById('daily-ranked-hint');
-    if (rankedBtn) {
-      rankedBtn.disabled = !!done;
-      if (hint) {
-        hint.textContent = done
-          ? (done.dnf ? 'Done for today — ended early.' : `Done for today — ${formatClock(done.timeMs)}.`)
-          : 'One per day. Crashes are fine; ending early is not.';
-      }
-    }
-
-    overlay.classList.add('visible');
-    analytics.trackEvent('daily_chooser', { key, mode, ranked_available: !done });
-  }
-
   // ============================================================
   // E-6 / E-8 · "Ride the distance between you"
   // ============================================================
@@ -1888,18 +1837,49 @@ export class Lobby {
   }
 
   /**
-   * C-2 · Today's Road (or the weekly road) card text: which day it is, what
-   * you've done on it (practice and the ranked run, #398), and when it changes.
+   * C-2 · the Daily Ride card text: which day it is, what you've done on it,
+   * and when it changes. #641: in the demo, why it is shut (the Tutorial and
+   * Grandma's open it; three rides a day) or how many rides are left.
    */
   _roadDescHtml(level) {
-    if (level.isWeekly) {
-      const key = weeklyKey();
-      return weeklyDescription(dailyStatus(browserStore(), key), key) +
-        '<br><span class="level-card-daily-rule">' + WEEKLY_RULES_LINE + '</span>';
-    }
     const key = dailyKey();
-    return dailyDescription(dailyStatus(browserStore(), key), key) +
-      '<br><span class="level-card-daily-rule">' + DAILY_RULES_LINE + '</span>';
+    const gate = this._dailyGate();
+    const rule = '<br><span class="level-card-daily-rule">' + DAILY_RULES_LINE + '</span>';
+    if (!gate.ok) return '&#x1F512; ' + this._dailyGateText(gate) + rule;
+    let line = dailyDescription(dailyStatus(browserStore(), key), key);
+    if (gate.left != null) line += ' · ' + gate.left + ' of ' + this.roomRules().dailyRideCap + ' rides left';
+    return line + rule;
+  }
+
+  /** #641 · can this device start another Daily Ride? (edition.dailyRideGate) */
+  _dailyGate() {
+    // Read the saved list, not this._achievements: the game holds its own
+    // manager, and the Grandma's finish that opens the road is earned there.
+    let earned = [];
+    try {
+      const raw = localStorage.getItem('tandemonium_achievements');
+      if (raw) earned = JSON.parse(raw).map(a => a.id);
+    } catch { /* empty */ }
+    return dailyRideGate(this.roomRules(), ridesStarted(browserStore(), dailyKey()), earned);
+  }
+
+  /** #641 · the words for a shut Daily Ride. */
+  _dailyGateText(gate) {
+    if (gate.reason === 'needs') {
+      const names = { tutorial_done: 'the Tutorial', home_sweet: 'Grandma’s' };
+      const list = gate.needs.map(id => names[id] || id);
+      return 'Finish ' + list.join(' and ') + ' to open the Daily Ride';
+    }
+    return 'That’s today’s ' + this.roomRules().dailyRideCap + ' rides · the full game rides it as often as you like';
+  }
+
+  /** #641 · true when a Daily Ride may start; otherwise says why and returns false. */
+  _dailyGateAllows() {
+    const gate = this._dailyGate();
+    if (gate.ok) return true;
+    showInfoToast('🔒', 'Daily Ride', this._dailyGateText(gate));
+    analytics.trackEvent('daily_gate', { reason: gate.reason });
+    return false;
   }
 
   /** B-3 · re-render the record line (and Today's Road's day line) on every visible level card. */
@@ -1909,17 +1889,30 @@ export class Lobby {
       if (!line) return;
       const base = LEVELS.find(l => l.id === card.dataset.levelId);
       if (!base) return;
-      // Same swap as the card builder: in the demo the shared road is the Weekly Ride.
-      const level = base.isDaily && this.roomRules().weeklyRoad ? asWeeklyRoad(base) : base;
-      // The day line changes after every ride on Today's Road (a practice
-      // count, the ranked time), and the cards are built once at boot.
+      const level = base;
+      // The day line changes after every ride on the Daily Ride, and the cards
+      // are built once at boot. #641: so does its gate (the demo's lock).
       const desc = level.isDaily && card.querySelector('.level-card-desc');
       if (desc) desc.innerHTML = this._roadDescHtml(level);
+      if (level.isDaily) this._applyDailyLock(card);
       const inVersus = !!card.closest('#versus-level-list, [id*="versus"]');
       line.textContent = this._recordLine(level, inVersus ? 'versus' : (this.net ? 'coop' : 'solo'));
     });
   }
 
+  /**
+   * #641 · show the Daily Ride card shut (greyed, skipped by the default pick
+   * and by NEXT LEVEL) while its gate is closed. It stays clickable, so a
+   * click explains what opens it.
+   */
+  _applyDailyLock(card) {
+    const shut = !this._dailyGate().ok;
+    card.classList.toggle('level-locked', shut);
+    this._lockedLevelIds = this._lockedLevelIds || new Set();
+    if (shut) this._lockedLevelIds.add(card.dataset.levelId);
+    else this._lockedLevelIds.delete(card.dataset.levelId);
+  }
+
   _buildLevelCardsShared({ container, isClickable, mode, showTutorial, startBtn, backBtn, step }) {
     container.innerHTML = '';
     const buttons = [];
@@ -1938,12 +1931,10 @@ export class Lobby {
     // C-2: Today's Road is not in the VERSUS list — versus has its own rules
     // (two teams, one screen) and a shared daily result means nothing there.
     const isVersus = mode === 'versus';
-    // #400: every list offers only what this edition includes; in the demo the
-    // shared road is the Weekly Ride.
+    // #400: every list offers only what this edition includes.
     const rules = this.roomRules();   // PR #397 M1: a room offers what BOTH sides can ride
     const levels = LEVELS.filter(l =>
-      (showTutorial || !l.isTutorial) && !(isVersus && l.isDaily) && levelAllowed(rules, l.id))
-      .map(l => (l.isDaily && rules.weeklyRoad ? asWeeklyRoad(l) : l));
+      (showTutorial || !l.isTutorial) && !(isVersus && l.isDaily) && levelAllowed(rules, l.id));
     this._lockedLevelIds = this._lockedLevelIds || new Set();   // read by NEXT LEVEL
 
     levels.forEach(level => {
@@ -1989,8 +1980,11 @@ export class Lobby {
           // first visit instead of an absence.
           '<div class="level-card-record">' + this._recordLine(level, mode) + '</div>';
 
+        if (level.isDaily) this._applyDailyLock(card);   // #641
         if (isClickable) {
           card.addEventListener('click', () => {
+            // #641: a shut Daily Ride explains itself instead of being picked.
+            if (level.isDaily && !this._dailyGateAllows()) return;
             // C-2: Today's Road resolves its identity at the moment it is picked
             // — the day key and seed come from the clock now, not from whenever
             // this page was loaded (someone may have left it open overnight).
@@ -2175,9 +2169,7 @@ export class Lobby {
     // C-2: Today's Road is one road at one difficulty for everyone — a shared
     // road that each player tunes to taste is not a shared road.
     const daily = LEVELS.find(l => l.id === levelId && l.isDaily);
-    // #400 D10: the demo's weekly road rides on Chill (safety on).
-    const roadDifficulty = daily && this.roomRules().weeklyRoad
-      ? asWeeklyRoad(daily).fixedDifficulty : (daily && daily.fixedDifficulty);
+    const roadDifficulty = daily && daily.fixedDifficulty;
     const forced = isTutorial ? 'chill' : (daily ? roadDifficulty : null);
     const diffBtns = document.querySelectorAll('#difficulty-selector .difficulty-btn');
     if (forced && !isTutorial) {
@@ -4283,7 +4275,7 @@ export class Lobby {
     try { param = new URLSearchParams(window.location.search).get('daily'); } catch { return; }
     if (!param) return;
 
-    const today = getEditionRules().weeklyRoad ? weeklyKey() : dailyKey();   // #400
+    const today = dailyKey();
     const expired = param !== today;
     const level = LEVELS.find(l => l.isDaily);
     if (!level) return;
@@ -5194,12 +5186,8 @@ export class Lobby {
       // C-2: for Today's Road, take the captain's key and seed rather than
       // reading this device's clock — otherwise a stoker on the far side of
       // the 09:00 UTC rollover would ride a different road with the same name.
-      // PR #397 M1: and the captain's road KIND (weekly / daily), not one
-      // resolved from this side's edition.
       this.selectedLevel = picked && picked.isDaily
-        ? (verdict.roadKind === 'weekly'
-          ? resolveWeeklyLevel(picked, { key: profile.key, seed: profile.seed })
-          : resolveDailyLevel(picked, { key: profile.key || dailyKey(), seed: typeof profile.seed === 'number' ? profile.seed : dailySeed() }))
+        ? resolveDailyLevel(picked, { key: profile.key || dailyKey(), seed: typeof profile.seed === 'number' ? profile.seed : dailySeed() })
         : (picked || this.selectedLevel);
       // Track if captain selected tutorial — stoker needs _forceWizard too
       this._forceWizard = (profile.levelId === 'tutorial');
@@ -5210,7 +5198,7 @@ export class Lobby {
       // Update difficulty selector (disable harder options for tutorial)
       this._updateDifficultyVisibility(profile.levelId);
       // PR #397 M1: the captain's effective difficulty wins over the one this
-      // side would force (e.g. a full stoker on a demo captain's weekly road).
+      // side would force (e.g. a full stoker on a demo captain's road).
       if (typeof profile.difficulty === 'string' && profile.difficulty) this._adoptDifficulty(profile.difficulty);
     } else if (profile.type === ROOM_MSG.CAMERA_TOGGLE) {
       // Partner toggled their camera — update state and refresh PiP
@@ -5306,7 +5294,7 @@ export class Lobby {
     this._lastLevelRefused = profile.levelId || '';   // read by smoke:tourist
     if (profile.reason === 'demo') {
       showInfoToast('🔒', 'Your partner is on the demo',
-        'They can ride the Tutorial, Grandma’s House and the Weekly Ride with you.');
+        'They can ride the Tutorial, Grandma’s House and the Daily Ride with you.');
     } else {
       showInfoToast('🔒', 'Your partner can’t ride that one', 'Pick another level to ride together.');
     }
@@ -7694,22 +7682,7 @@ export class Lobby {
       this._modalFocus.poll();
       return;
     }
-    // #576 · Today's Road chooser (RANKED RUN / PRACTICE / Back) over the levels
-    // step: the pad moves between its buttons and A picks; B is Back. It had no
-    // branch here, so the pad kept driving the step underneath it.
-    const dailyOverlay = document.getElementById('daily-mode-overlay');
-    if (dailyOverlay && dailyOverlay.classList.contains('visible')) {
-      if (this._activeModal !== 'daily') {
-        this._activeModal = 'daily';
-        this._modalBack = () => dailyOverlay.classList.remove('visible');
-        const items = ['btn-daily-ranked', 'btn-daily-practice', 'btn-daily-cancel']
-          .map((id) => document.getElementById(id))
-          .filter((el) => el && !el.disabled && !el.hasAttribute('disabled'));
-        this._modalFocus.setSpatial(items, items[0]);
-      }
-      this._modalFocus.poll();
-      return;
-    }
+
     // #540: an achievement's detail card over the leaderboard — only its Close
     // to focus; B closes it and the grid gets the pad back (uf-sheet:close).
     if (this._achievementDetailOpen()) {
@@ -8329,7 +8302,10 @@ export class Lobby {
   _applyPresetToPreview() {
     const key = this._presetKeys[this._presetIndex];
     const nameEl = document.getElementById('bike-name');
-    const locked = HOLIDAY_BIKES[key] && !this._isHolidayUnlocked(key);
+    // #641: the demo rides Grandma's Classic and Marmalade Express; the other
+    // colours show, shut, as the full game's.
+    const demoLocked = !bikeAllowed(getEditionRules(), key);
+    const locked = demoLocked || (HOLIDAY_BIKES[key] && !this._isHolidayUnlocked(key));
     nameEl.style.color = locked ? 'rgba(255,255,255,0.3)' : (BIKE_COLORS[key] || 'rgba(68, 255, 102, 0.7)');
 
     // Reset all materials to originals
@@ -8356,6 +8332,10 @@ export class Lobby {
         hintEl.style.cssText = 'font-size:10px;color:rgba(255,255,255,0.5);margin-top:2px;text-align:center;';
         nameEl.parentNode.insertBefore(hintEl, nameEl.nextSibling);
       }
+      if (demoLocked) {
+        hintEl.textContent = 'In the full game';
+        hintEl.style.display = '';
+      } else {
       // Show per-bike progress: ✓ won / ✗ not yet
       let earnedIds = [];
       try {
@@ -8374,6 +8354,7 @@ export class Lobby {
           : `<span style="color:rgba(255,255,255,0.4)">${l}</span>`
       ).join('<br>');
       hintEl.style.display = '';
+      }
 
       // Grey out the preview model
       this.selectedPreset = null;
diff --git a/js/lobby/room-protocol.js b/js/lobby/room-protocol.js
index c10cfbfb..8acd342a 100644
--- a/js/lobby/room-protocol.js
+++ b/js/lobby/room-protocol.js
@@ -38,7 +38,7 @@ export const RoomProtocol = {
    * rollover must ride the captain's road, not a road of their own.
    *
    * PR #397 M1: `extra` also carries the room's EFFECTIVE road — roadKind
-   * ('daily' | 'weekly') and difficulty — which the stoker adopts instead of
+   * ('daily'; #400's 'weekly' is retired) and difficulty — which the stoker adopts instead of
    * resolving from its own edition. Old stokers read only key/seed.
    */
   levelSync: (levelId, extra = null) =>
diff --git a/js/records.js b/js/records.js
index 899f6b45..2f3b171b 100644
--- a/js/records.js
+++ b/js/records.js
@@ -30,7 +30,7 @@ export function key(levelId, difficulty, mode = 'solo') {
 }
 
 /**
- * The level id a record is kept under. Today's Road (and the weekly road) is a
+ * The level id a record is kept under. Today's Road is a
  * different road every day/week, so its record carries the day: yesterday's
  * best is not a target for today's road. The game writes with the resolved
  * level's own key; the lobby card passes today's key (the card's level is the
diff --git a/package.json b/package.json
index e7163a43..3b883de6 100644
--- a/package.json
+++ b/package.json
@@ -35,7 +35,7 @@
     "smoke:ctas": "node scripts/smoke-demo-ctas.mjs",
     "smoke:daily": "node scripts/smoke-daily-ride.mjs",
     "check:dashboard-sql": "node scripts/check-dashboard-sql.mjs",
-    "smoke:ranked": "node scripts/smoke-ranked-run.mjs",
+    "smoke:daily-best": "node scripts/smoke-daily-best.mjs",
     "smoke:tutorial": "node scripts/smoke-tutorial-first.mjs",
     "smoke:lookahead": "node scripts/smoke-lookahead.mjs",
     "smoke:ping": "node scripts/smoke-sync-ping.mjs",
diff --git a/scripts/probe-props.mjs b/scripts/probe-props.mjs
index 9dd1f5b4..6b593149 100644
--- a/scripts/probe-props.mjs
+++ b/scripts/probe-props.mjs
@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // probe-props.mjs · #478 — what the road props cost to draw: renderer calls and
 // triangles for one frame, and how many of them are presents, cones and
-// Grandma's house, on Grandma's and Today's Road (practice).
+// Grandma's house, on Grandma's and the Daily Ride.
 //
 //   node scripts/probe-props.mjs [--difficulty=daredevil] [--port=8977] [--json=out.json]
 //
@@ -23,9 +23,7 @@ async function ride(levelId) {
   await page.evaluate((id) => document.querySelector(`#level-cards .level-card[data-level-id="${id}"]`).click(), levelId);
   await page.evaluate((d) => { window._game.lobby.selectedDifficulty = d; }, DIFF);
   await sleep(300);
-  await clickId(page, 'btn-start-ride');
-  await sleep(500);
-  await clickId(page, 'btn-daily-practice');
+  await clickId(page, 'btn-start-ride');   // #641: START RIDE starts the Daily Ride too (no chooser)
   await waitState(page, 'playing');
   return page;
 }
diff --git a/scripts/shot-end-sheets.mjs b/scripts/shot-end-sheets.mjs
index 6cabb13d..ea803a5c 100644
--- a/scripts/shot-end-sheets.mjs
+++ b/scripts/shot-end-sheets.mjs
@@ -3,8 +3,8 @@
 // viewports Pete cares about, so a layout change can be eyeballed without a
 // playtest. Not a smoke (nothing is checked beyond "no page errors"); it writes
 // <outDir>/<viewport>-<scene>.png:
-//   grandma-victory · grandma-gameover · daily-practice-victory (first of the
-//   day, 3-day streak) · daily-ranked-victory · coop-victory (local co-op)
+//   grandma-victory · grandma-gameover · daily-victory (first of the day,
+//   3-day streak) · coop-victory (local co-op)
 // at lap 1280×800 (laptop / Steam Deck), tv 1920×1080 and phone 844×390
 // (landscape). Headless renders slowly, so distances are set directly.
 //   node scripts/shot-end-sheets.mjs [--out <dir>] [--only lap,tv,phone]
@@ -84,18 +84,15 @@ for (const [vpName, vp] of Object.entries(VIEWPORTS)) {
     await page.close();
   }
 
-  // The Daily Ride, practice then ranked: first finish of the day on a 3-day streak.
-  for (const mode of ['practice', 'ranked']) {
+  // The Daily Ride (#641: START RIDE starts it, every ride counts): first finish of the day on a 3-day streak.
+  {
     const page = await open(vp, { tandemonium_daily: STREAK });
     await pickLevel(page, 'daily', 'adventurous');
     await clickId(page, 'btn-start-ride');
-    await sleep(400);
-    const chooser = await page.evaluate(() => document.getElementById('daily-mode-overlay')?.classList.contains('visible'));
-    if (chooser) await clickId(page, 'btn-daily-' + mode);
     await waitState(page, 'playing');
     await collectSome(page, 5, 23);
     await finishRide(page);
-    await shot(page, `${vpName}-daily-${mode}-victory`);
+    await shot(page, `${vpName}-daily-victory`);
     await page.close();
   }
 
diff --git a/scripts/smoke-daily-best.mjs b/scripts/smoke-daily-best.mjs
new file mode 100644
index 00000000..e573c234
--- /dev/null
+++ b/scripts/smoke-daily-best.mjs
@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+// smoke-daily-best.mjs — #641: the Daily Ride has no practice/ranked split.
+//   START RIDE starts a ride that counts (a checkpoint retry is the same ride);
+//   every finish is recorded, the best stays; any help (SAFETY here) keeps a
+//   ride off the board; the share strip shows the best and the first try;
+//   the demo opens the road after the Tutorial and Grandma's, then stops at 3.
+import http from 'node:http'; import fs from 'node:fs'; import path from 'node:path'; import puppeteer from 'puppeteer';
+const ROOT=process.cwd(); const PORT=8923;
+const MIME={'.html':'text/html','.js':'text/javascript','.css':'text/css','.png':'image/png','.jpg':'image/jpeg','.svg':'image/svg+xml','.glb':'model/gltf-binary','.mp3':'audio/mpeg','.json':'application/json'};
+const server=http.createServer((q,r)=>{const u=decodeURIComponent(q.url.split('?')[0]);const f=path.join(ROOT,u==='/'?'index.html':u);
+ fs.stat(f,(e,st)=>{if(e||st.isDirectory())return r.writeHead(404).end();r.writeHead(200,{'Content-Type':MIME[path.extname(f)]||'application/octet-stream'});fs.createReadStream(f).pipe(r);});});
+await new Promise(r=>server.listen(PORT,'127.0.0.1',r));
+const errors=[];
+const browser=await puppeteer.launch({headless:'new',args:['--no-sandbox','--use-gl=swiftshader','--enable-unsafe-swiftshader','--mute-audio']});
+
+async function open(query='') {
+  const page=await browser.newPage(); await page.setViewport({width:1280,height:800});
+  await page.setRequestInterception(true);
+  page.on('request',(req)=>{const u=req.url(); if(u.startsWith(`http://127.0.0.1:${PORT}`))return req.continue();
+   let m=u.match(/three@[^/]+\/build\/three\.module\.js/);
+   if(m)return req.respond({status:200,contentType:'text/javascript',headers:{'Access-Control-Allow-Origin':'*'},body:fs.readFileSync(path.join(ROOT,'node_modules/three/build/three.module.js'))});
+   m=u.match(/three@[^/]+\/examples\/jsm\/(.+)$/); const f=m&&path.join(ROOT,'node_modules/three/examples/jsm/'+m[1]);
+   if(f&&fs.existsSync(f))return req.respond({status:200,contentType:'text/javascript',headers:{'Access-Control-Allow-Origin':'*'},body:fs.readFileSync(f)});
+   return req.abort();});
+  page.on('pageerror', e => { errors.push(e.message); console.log('  PAGEERROR:', e.message); });
+  // D6 (#400): a returning player; the first-launch tutorial has its own smoke (smoke:tutorial).
+  await page.evaluateOnNewDocument(() => { try { localStorage.setItem('tandemonium_tutorial_done', 'smoke'); } catch {} });
+  await page.goto(`http://127.0.0.1:${PORT}/index.html${query}`,{waitUntil:'domcontentloaded'});
+  await page.waitForFunction(()=>!!window._game,{timeout:30000});
+  return page;
+}
+
+
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+async function until(page, fn, arg, ms = 5000) {
+  const end = Date.now() + ms;
+  while (Date.now() < end) { const v = await page.evaluate(fn, arg); if (v) return v; await sleep(100); }
+  return page.evaluate(fn, arg);
+}
+async function pickDaily(page) {
+  await page.evaluate(() => {
+    document.getElementById('tap-to-start')?.click();
+    (document.getElementById('btn-solo') || Array.from(document.querySelectorAll('button, uf-button')).find(x=>/solo/i.test(x.textContent)))?.click();
+  });
+  await until(page, () => !!document.querySelector('#level-cards .level-card[data-level-id="daily"]'));
+  await page.evaluate(() => document.querySelector('#level-cards .level-card[data-level-id="daily"]')?.click());
+}
+const SUMMARY = (timeMs) => ({ timeMs, distance: 500, raceDistance: 500, collectibles: 9, collectiblesTotal: 12, crashes: 1 });
+
+// ── 1. Full game: no chooser; START RIDE starts a counted ride ──────────────
+const web = await open();
+await pickDaily(web);
+const gone = await web.evaluate(() => ({
+  overlay: !!document.getElementById('daily-mode-overlay'),
+  badge: !!document.getElementById('ranked-badge'),
+  practiceHelp: !!document.getElementById('btn-practice-help'),
+}));
+await web.evaluate(() => document.getElementById('btn-start-ride').click());
+await until(web, () => window._game.state === 'countdown' || window._game.state === 'playing', null, 8000);
+const start = await web.evaluate(async () => {
+  const g = window._game;
+  const d = await import('./js/daily-ride.js');
+  return { state: g.state, level: g.lobby.selectedLevel.id, rideNo: g._dailyRideNo,
+           started: d.ridesStarted(d.browserStore(), g.lobby.selectedLevel.key),
+           safetyLocked: !!g.safetyBtn.disabled, speedLocked: !!g.speedBtn.disabled };
+});
+console.log('start:', JSON.stringify(start), 'removed:', JSON.stringify(gone));
+
+// ── 2. A finish counts; help keeps it off the board; the strip has the first try ──
+const rides = await web.evaluate(async (S) => {
+  const g = window._game, l = g.lobby;
+  const d = await import('./js/daily-ride.js');
+  const key = l.selectedLevel.key;
+  const S1 = JSON.parse(S.replace('T', '120000'));
+  g.safetyMode = false; g.autoSpeed = false; g._noteRideAided();
+  const clean1 = g._dailyRideClean();
+  g._buildRecordHtml(S1, false);
+  const after1 = d.dailyStatus(d.browserStore(), key);
+  g._buildDailyStripHtml(S1, l.selectedLevel);
+  const strip1 = g._dailyStripText;
+  // A checkpoint-1 retry is the same ride.
+  g._resetGame(false, false);
+  const afterRetry = d.ridesStarted(d.browserStore(), key);
+  // Back to the lobby and ride again: a new ride. SAFETY on → not clean.
+  g._returnToLobby();
+  document.getElementById('tap-to-start')?.click();
+  document.getElementById('btn-solo')?.click();
+  document.querySelector('#level-cards .level-card[data-level-id="daily"]').click();
+  document.getElementById('btn-start-ride').click();
+  const ride2No = g._dailyRideNo;
+  g.safetyMode = true; g._noteRideAided();
+  const clean2 = g._dailyRideClean();
+  const line2 = g._dailyVictoryLine();
+  g.safetyMode = false;
+  const S2 = JSON.parse(S.replace('T', '110000'));
+  g._buildRecordHtml(S2, false);
+  const after2 = d.dailyStatus(d.browserStore(), key);
+  g._buildDailyStripHtml(S2, l.selectedLevel);
+  const strip2 = g._dailyStripText;
+  const card = (l._refreshRecordLines(), document.querySelector('#level-cards .level-card[data-level-id="daily"] .level-card-desc').textContent);
+  g._returnToLobby();
+  return { clean1, after1, strip1, afterRetry, ride2No, clean2, line2, after2, strip2, card };
+}, JSON.stringify(SUMMARY('T')).replace('"T"', 'T'));
+console.log('rides:', JSON.stringify(rides, null, 1));
+
+// ── 3. Demo: shut, then open, then three rides and no fourth ────────────────
+// Same origin, same storage: start the demo with today's rides and badges cleared.
+await web.evaluate(() => { localStorage.removeItem('tandemonium_daily'); localStorage.removeItem('tandemonium_achievements'); });
+const demo = await open('?demo=1');
+await pickDaily(demo);
+const demoRun = await demo.evaluate(async () => {
+  const g = window._game, l = g.lobby;
+  const d = await import('./js/daily-ride.js');
+  const { dailyKey } = await import('./js/daily-seed.js');
+  const { LEVELS } = await import('./js/race-config.js');
+  const card = () => document.querySelector('#level-cards .level-card[data-level-id="daily"]');
+  const out = { shutAtFirst: card().classList.contains('level-locked'), pickedWhenShut: l.selectedLevel && l.selectedLevel.id };
+  localStorage.setItem('tandemonium_achievements', JSON.stringify([{ id: 'tutorial_done', earnedAt: 1 }, { id: 'home_sweet', earnedAt: 1 }]));
+  l._refreshRecordLines();
+  out.openAfter = !card().classList.contains('level-locked');
+  card().click();
+  document.getElementById('btn-start-ride').click();
+  out.ride1 = { state: g.state, rideNo: g._dailyRideNo, line: g._dailyVictoryLine() };
+  g._returnToLobby();
+  while (d.ridesStarted(d.browserStore(), dailyKey()) < 3) d.recordRideStart(d.browserStore(), dailyKey());
+  g._dailyRideNo = 3;
+  out.line3 = g._dailyVictoryLine();
+  // A 4th: START RIDE refuses in the lobby…
+  document.getElementById('tap-to-start')?.click();
+  document.getElementById('btn-solo')?.click();
+  l._refreshRecordLines();
+  out.shutAfter3 = card().classList.contains('level-locked');
+  out.cardText = card().querySelector('.level-card-desc').textContent;
+  l.selectedLevel = l.resolveRoadLevel(LEVELS.find(x => x.isDaily));
+  document.getElementById('btn-start-ride').click();
+  out.afterStart = { state: g.state, started: d.ridesStarted(d.browserStore(), dailyKey()) };
+  // …and PLAY AGAIN (a reset from the beginning) goes back instead of riding.
+  g.mode = 'solo';
+  g._resetGame(false, true);
+  out.afterPlayAgain = { state: g.state, started: d.ridesStarted(d.browserStore(), dailyKey()) };
+  return out;
+});
+console.log('demo:', JSON.stringify(demoRun, null, 1));
+
+const checks = {
+  chooserGone: !gone.overlay && !gone.badge && !gone.practiceHelp,
+  startRideStartsRide: (start.state === 'countdown' || start.state === 'playing') && start.level === 'daily' &&
+    start.rideNo === 1 && start.started === 1,
+  safetySpeedNeverLocked: !start.safetyLocked && !start.speedLocked,
+  cleanRideIsClean: rides.clean1 === true,
+  finishCounts: rides.after1.finished === 1 && rides.after1.best === 120000,
+  oneRideNoFirstTry: /2:00/.test(rides.strip1) && !/1st try/.test(rides.strip1) && rides.strip1.split('\n').length === 4,
+  retryIsSameRide: rides.afterRetry === 1,
+  secondRideCounts: rides.ride2No === 2 && rides.after2.started === 2 && rides.after2.finished === 2,
+  safetyKeepsOffBoard: rides.clean2 === false && /stays off the board/.test(rides.line2),
+  bestAndFirstTry: rides.after2.best === 110000 && /1:50/.test(rides.strip2) && /1st try 2:00/.test(rides.strip2),
+  cardSaysBest: /finished ×2 · best 1:50/.test(rides.card),
+  demoShutThenOpen: demoRun.shutAtFirst && demoRun.pickedWhenShut !== 'daily' && demoRun.openAfter,
+  demoRideCounts: demoRun.ride1.rideNo === 1 && /Daily Ride 1 of 3 today/.test(demoRun.ride1.line),
+  demoThirdLine: /Daily Ride 3 of 3 today/.test(demoRun.line3),
+  demoNoFourth: demoRun.shutAfter3 && /today’s 3 rides/.test(demoRun.cardText) &&
+    demoRun.afterStart.state === 'lobby' && demoRun.afterStart.started === 3 &&
+    demoRun.afterPlayAgain.state === 'lobby' && demoRun.afterPlayAgain.started === 3,
+  noPageErrors: errors.length === 0,
+};
+console.log(checks);
+const ok = Object.values(checks).every(Boolean);
+console.log(ok ? '✔ every Daily ride counts, help stays off the board, the strip has the first try, the demo stops at 3'
+               : '✖ the Daily Ride is wrong');
+await browser.close(); server.close(); process.exit(ok ? 0 : 1);
diff --git a/scripts/smoke-edition.mjs b/scripts/smoke-edition.mjs
index fd314807..7af985fe 100644
--- a/scripts/smoke-edition.mjs
+++ b/scripts/smoke-edition.mjs
@@ -1,9 +1,11 @@
 #!/usr/bin/env node
-// smoke-edition.mjs — #400: what each edition offers in the menus.
-//   demo (?demo=1): SOLO shows exactly Tutorial, Grandma's, Weekly Ride
-//     (+ the Slingshot card) — no Tourist even with a Maps key; the road rides
-//     on Chill with the week's key; NEXT LEVEL from Grandma's goes to the
-//     weekly road, and from there to the demo's end screen, never elsewhere.
+// smoke-edition.mjs — #400 / #641: what each edition offers in the menus.
+//   demo (?demo=1): SOLO shows exactly Tutorial, Grandma's, Daily Ride
+//     (+ the Slingshot card) — no Tourist even with a Maps key. #641: the
+//     Daily Ride is today's real road on Adventurous, shut until the Tutorial
+//     and Grandma's are done, then three rides a day (a 4th is refused);
+//     NEXT LEVEL from Grandma's goes to it once open, and from there to the
+//     demo's end screen, never elsewhere. VERSUS and five bike colours are shut.
 //   full game (?key=dummy): the Tourist card is under SOLO and RIDE TOGETHER
 //     (captain), not VERSUS; the road is the Daily Ride.
 //   PR #397 B4: the demo survives an invite (?demo=1&room=X keeps demo after
@@ -59,15 +61,34 @@ async function lists(page) {
   });
 }
 
-// Pick the road card, then walk NEXT LEVEL.
+// #641 · the road card's state: shut (greyed) or open, and what it says.
+const cardState = () => {
+  const card = document.querySelector('#level-cards .level-card[data-level-id="daily"]');
+  return { locked: card.classList.contains('level-locked'), desc: card.querySelector('.level-card-desc').textContent };
+};
+
+// Pick the road card (shut, then opened), then walk NEXT LEVEL.
 async function walk(page) {
-  return page.evaluate(async () => {
+  return page.evaluate(async (cardStateSrc) => {
+    const cardState = eval(cardStateSrc);
     const g = window._game, l = g.lobby;
     const { LEVELS } = await import('./js/race-config.js');
-    const { weeklyKey, dailyKey } = await import('./js/daily-seed.js');
-    document.querySelector('#level-cards .level-card[data-level-id="daily"]').click();
+    const { dailyKey } = await import('./js/daily-seed.js');
+    const road = () => document.querySelector('#level-cards .level-card[data-level-id="daily"]');
+    // Fresh: nothing earned. The demo's road is shut and a click doesn't pick it.
+    l.selectedLevel = LEVELS.find(x => x.id === 'grandma');
+    const shut = cardState();
+    road().click();
+    shut.pickedAfterClick = l.selectedLevel.id;
+    shut.nextFromGrandma = (g._nextLevel() || {}).id || null;
+    // The Tutorial and Grandma's done: the road opens (read live, no reload).
+    localStorage.setItem('tandemonium_achievements', JSON.stringify([
+      { id: 'tutorial_done', earnedAt: 1 }, { id: 'home_sweet', earnedAt: 1 }]));
+    l._refreshRecordLines();
+    const open = cardState();
+    road().click();
     const picked = { id: l.selectedLevel.id, name: l.selectedLevel.name, key: l.selectedLevel.key,
-                     difficulty: l.selectedDifficulty, weeklyKey: weeklyKey(), dailyKey: dailyKey() };
+                     difficulty: l.selectedDifficulty, dailyKey: dailyKey() };
 
     // NEXT LEVEL from Grandma's (the click handler itself, as the victory screen runs it).
     l.selectedLevel = LEVELS.find(x => x.id === 'grandma');
@@ -88,9 +109,25 @@ async function walk(page) {
       document.getElementById('btn-demo-lobby').click();
       endHidden = overlay.style.display === 'none';
     }
-    return { picked, fromGrandma: fromGrandma && fromGrandma.id, afterGrandma,
-             fromRoad: fromRoad && fromRoad.id, endShown, endText, wishlistShown, endHidden };
-  });
+    // #641 · three rides a day: NEXT LEVEL above started one; two more use the day up.
+    const { recordRideStart, ridesStarted, browserStore } = await import('./js/daily-ride.js');
+    while (ridesStarted(browserStore(), dailyKey()) < 3) recordRideStart(browserStore(), dailyKey());
+    l._refreshRecordLines();
+    const capped = cardState();
+    l.selectedLevel = l.resolveRoadLevel(LEVELS.find(x => x.isDaily));
+    g._sameRideNext = false;
+    capped.blocked = g._dailyRideBlocked();
+    capped.ridesStarted = ridesStarted(browserStore(), dailyKey());
+    // VERSUS and the bike colours (#641).
+    const vs = document.getElementById('btn-versus');
+    const versus = { shown: vs && vs.style.display !== 'none', locked: !!vs && vs.classList.contains('lobby-role-locked'),
+                     desc: vs ? vs.textContent.replace(/\s+/g, ' ') : '' };
+    const { bikeAllowed, getEditionRules } = await import('./js/edition.js');
+    const bikes = Object.fromEntries(['default', 'bike_orange', 'bike_red', 'bike_christmas']
+      .map(k => [k, bikeAllowed(getEditionRules(), k)]));
+    return { shut, open, picked, fromGrandma: fromGrandma && fromGrandma.id, afterGrandma,
+             fromRoad: fromRoad && fromRoad.id, endShown, endText, wishlistShown, endHidden, capped, versus, bikes };
+  }, cardState.toString());
 }
 
 const demo = await open('?demo=1&key=dummy');
@@ -106,8 +143,17 @@ const fw = await full.evaluate(async () => {
   const g = window._game, l = g.lobby;
   const { LEVELS } = await import('./js/race-config.js');
   const { dailyKey } = await import('./js/daily-seed.js');
-  document.querySelector('#level-cards .level-card[data-level-id="daily"]').click();
-  const picked = { key: l.selectedLevel.key, difficulty: l.selectedDifficulty, today: dailyKey() };
+  // #641: the full game's road is open from the start, with no ride limit.
+  const roadCard = document.querySelector('#level-cards .level-card[data-level-id="daily"]');
+  const openAtStart = !roadCard.classList.contains('level-locked');
+  roadCard.click();
+  const picked = { key: l.selectedLevel.key, difficulty: l.selectedDifficulty, today: dailyKey(), openAtStart };
+  const { recordRideStart, browserStore } = await import('./js/daily-ride.js');
+  for (let i = 0; i < 5; i++) recordRideStart(browserStore(), dailyKey());
+  g._sameRideNext = false;
+  picked.blockedAfter5 = g._dailyRideBlocked();
+  const vs = document.getElementById('btn-versus');
+  picked.versusOpen = !!vs && vs.style.display !== 'none' && !vs.classList.contains('lobby-role-locked');
   l.selectedLevel = LEVELS.find(x => x.id === 'grandma');
   const next = g._nextLevel();
   l.selectedLevel = l.resolveRoadLevel(LEVELS.find(x => x.isDaily));
@@ -142,18 +188,27 @@ const checks = {
   demoSolo: same(dl.solo, ['tutorial', 'grandma', 'daily', 'slingshot']),
   demoCoop: same(dl.coop, ['tutorial', 'grandma', 'daily']),
   demoVersus: same(dl.versus, ['grandma']),
-  demoRoadNamed: dl.roadName === 'Weekly Ride' && /A new road every week/.test(dl.roadDesc),
+  demoRoadNamed: dl.roadName === 'Daily Ride',
   noModeButton: !dl.modeTouristBtn && !fl.modeTouristBtn,
-  demoRoadWeekly: dw.picked.key === dw.picked.weeklyKey && dw.picked.difficulty === 'chill',
+  demoRoadShutAtFirst: dw.shut.locked && /Finish the Tutorial and Grandma/.test(dw.shut.desc) &&
+    dw.shut.pickedAfterClick === 'grandma' && dw.shut.nextFromGrandma === null,
+  demoRoadOpens: !dw.open.locked && /3 of 3 rides left/.test(dw.open.desc),
+  demoRoadIsToday: dw.picked.id === 'daily' && dw.picked.key === dw.picked.dailyKey && dw.picked.difficulty === 'adventurous',
   demoNextFromGrandma: dw.fromGrandma === 'daily' && dw.afterGrandma.id === 'daily' &&
-    dw.afterGrandma.name === 'Weekly Ride' && dw.afterGrandma.key === dw.picked.weeklyKey &&
-    dw.afterGrandma.difficulty === 'chill',
+    dw.afterGrandma.name === 'Daily Ride' && dw.afterGrandma.key === dw.picked.dailyKey &&
+    dw.afterGrandma.difficulty === 'adventurous',
+  demoThreeRides: dw.capped.locked && /today’s 3 rides/.test(dw.capped.desc) && dw.capped.blocked === true &&
+    dw.capped.ridesStarted === 3,
+  demoVersusShut: dw.versus.shown && dw.versus.locked && /full game/i.test(dw.versus.desc),
+  demoTwoBikes: dw.bikes.default && dw.bikes.bike_orange && !dw.bikes.bike_red && !dw.bikes.bike_christmas,
   demoEnd: dw.fromRoad === null && dw.endShown && /That's the demo/.test(dw.endText) &&
     dw.wishlistShown && dw.endHidden === true,
   fullTouristSolo: fl.solo.includes('tourist') && fl.solo.includes('slingshot'),
   fullTouristCoop: fl.coop.includes('tourist') && !fl.versus.includes('tourist'),
   fullRoadDaily: fl.roadName === 'Daily Ride' && fw.picked.key === fw.picked.today &&
-    fw.picked.difficulty === 'adventurous',
+    fw.picked.difficulty === 'adventurous' && fw.picked.openAtStart,
+  fullNoRideLimit: fw.picked.blockedAfter5 === false,
+  fullVersusOpen: fw.picked.versusOpen,
   fullNextNotLocked: !!fw.next && !fw.nextLocked && fw.fromRoad === null,
   // PR #397 B4a/B4b
   inviteKeepsDemo: boundary.inviteSearch === '?demo=1' && boundary.inviteDemo === true,
diff --git a/scripts/smoke-grandma-finish.mjs b/scripts/smoke-grandma-finish.mjs
index 23c32c26..6a6333cf 100644
--- a/scripts/smoke-grandma-finish.mjs
+++ b/scripts/smoke-grandma-finish.mjs
@@ -22,9 +22,7 @@ async function ride(levelId) {
   await page.waitForFunction((id) => !!document.querySelector(`#level-cards .level-card[data-level-id="${id}"]`), { timeout: 30000 }, levelId);
   await page.evaluate((id) => document.querySelector(`#level-cards .level-card[data-level-id="${id}"]`).click(), levelId);
   await sleep(300);
-  await clickId(page, 'btn-start-ride');
-  await sleep(500);
-  await clickId(page, 'btn-daily-practice');   // Today's Road asks practice or ranked first (web build)
+  await clickId(page, 'btn-start-ride');   // #641: START RIDE starts the Daily Ride too (no chooser)
   await waitState(page, 'playing');
   return page;
 }
diff --git a/scripts/smoke-helping-hand.mjs b/scripts/smoke-helping-hand.mjs
index 23a689f5..7226eb92 100644
--- a/scripts/smoke-helping-hand.mjs
+++ b/scripts/smoke-helping-hand.mjs
@@ -1,13 +1,15 @@
 #!/usr/bin/env node
 // smoke-helping-hand.mjs — #403: retries get easier, visibly.
 //
-// On a practice Today's Road, fail checkpoint 2 again and again:
+// On a Daily Ride, fail checkpoint 2 again and again (#641: every Daily ride
+// gets the helping hand; there is no practice / ranked split any more):
 //   attempts 1-3 ride as designed; attempt 4 gets 💨 Lady Victoria (half gusts,
 //   1.25× time); attempt 5 gets 🎩 Sir Winston (no gusts, 1.5× time, safety on);
 //   after the 5th failure the Royal Shortcut is offered — including when that
 //   failure is a timeout. Passing the checkpoint resets it. An assisted finish
 //   gets bronze at most, with 🛟, and does not overwrite an unassisted best.
-//   A failed ranked run offers "Ride it as practice — with a helping hand".
+//   A helped ride is not "clean" (_dailyRideClean false), so its time stays
+//   off the board; a fresh Daily ride starts with the helping hand ready.
 //
 // The ride is frozen in its countdown between steps (headless rendering runs at
 // ~1.4 fps, and an unattended bike would fall over or time out on its own), so
@@ -37,8 +39,8 @@ async function open() {
   return page;
 }
 
-/** Today's Road, solo, as `mode` ('practice' | 'ranked'); returns once riding, frozen. */
-async function rideDaily(page, mode) {
+/** The Daily Ride, solo; returns once riding, frozen. START RIDE starts it (#641). */
+async function rideDaily(page) {
   await page.evaluate(() => {
     document.getElementById('tap-to-start')?.click();
     (document.getElementById('btn-solo') || Array.from(document.querySelectorAll('button, uf-button')).find(x=>/solo/i.test(x.textContent)))?.click();
@@ -46,10 +48,7 @@ async function rideDaily(page, mode) {
   await sleep(600);
   await page.evaluate(() => document.querySelector('.level-card[data-level-id="daily"]')?.click());
   await sleep(300);
-  await page.evaluate((mode) => {
-    document.getElementById('btn-start-ride').click();
-    document.getElementById(mode === 'ranked' ? 'btn-daily-ranked' : 'btn-daily-practice').click();
-  }, mode);
+  await page.evaluate(() => document.getElementById('btn-start-ride').click());
   await page.waitForFunction(() => window._game?.state === 'playing', { timeout: 180000, polling: 200 });
   await page.evaluate(() => {
     const g = window._game;
@@ -129,9 +128,9 @@ async function failByTimeout(page) {
 }
 
 // ── 1. Practice: fail checkpoint 2 again and again ─────────────────────────
-console.log("practice Daily Ride:");
+console.log("Daily Ride:");
 const page = await open();
-await rideDaily(page, 'practice');
+await rideDaily(page);
 const start = await page.evaluate(() => {
   const g = window._game;
   // Ride past checkpoint 1: the stretch to checkpoint 2 is the one we fail.
@@ -141,11 +140,12 @@ const start = await page.evaluate(() => {
   if (ev) g._handleRaceEvent(ev);
   g.state = 'countdown'; g.countdownTimer = 1e9;
   g.raceManager.resetSegmentTimer(cp1 + 5);
-  return { level: g.lobby.selectedLevel.id, ranked: g._rankedRunActive, dda: !!g.ddaManager,
+  return { level: g.lobby.selectedLevel.id, dda: !!g.ddaManager, eligible: g._helpEligible(), helped: g._helpFlags().helped,
            passed: g.raceManager.passedCheckpoints.size, cp1, safety: g.safetyMode };
 });
 console.log('  ride:', JSON.stringify(start));
-check('a practice daily ride with the DDA on, past checkpoint 1', start.level === 'daily' && !start.ranked && start.dda && start.passed === 1);
+check('a daily ride with the DDA on and the helping hand eligible, past checkpoint 1',
+  start.level === 'daily' && start.dda && start.eligible && !start.helped && start.passed === 1);
 
 const base = await probe(page);
 console.log('  attempt 1:', JSON.stringify(base));
@@ -234,45 +234,32 @@ const fin = await page.evaluate(async () => {
   const th = getMedals(g.lobby.selectedLevel.id, g.lobby.selectedDifficulty);
   const summary = { timeMs: th.gold - 1000, distance: 500, raceDistance: 500, collectibles: 0, collectiblesTotal: 0, crashes: 0 };
   const helped = g._helpFlags().helped;
+  const clean = g._dailyRideClean();
   const html = g._buildRecordHtml(summary, false);
   const after = records.getBest(records.load(), k);
-  return { helped, html, outcome: g._lastRecordOutcome, best: after, realBest };
+  return { helped, clean, html, outcome: g._lastRecordOutcome, best: after, realBest };
 });
 console.log('  assisted finish outcome:', JSON.stringify(fin.outcome), 'best:', JSON.stringify(fin.best));
 check('the ride is flagged helped after a tier was on', fin.helped === true);
+check('a helped Daily ride is not clean (its time stays off the board)', fin.clean === false);
 check('a gold-pace assisted finish shows 🛟 BRONZE, not gold',
   /🛟/.test(fin.html) && /BRONZE/.test(fin.html) && !/GOLD/.test(fin.html) && fin.outcome.medal === 'bronze');
 check("it does not overwrite the unassisted best", fin.best.timeMs === fin.realBest && !fin.best.helped && fin.outcome.isNewBest === false);
 await page.close();
 
-// ── 3. A failed ranked run offers practice with a helping hand ──────────────
-console.log('ranked Today\'s Road:');
+// ── 3. #641: a fresh Daily ride gets the helping hand; no practice button ───
+console.log('a fresh Daily Ride:');
 const rp = await open();
-await rideDaily(rp, 'ranked');
-const ranked = await rp.evaluate(() => {
+await rideDaily(rp);
+const fresh = await rp.evaluate(() => {
   const g = window._game;
-  const before = { ranked: g._rankedRunActive, dda: !!g.ddaManager };
-  g._showGameOver();
-  const btn = document.getElementById('btn-practice-help');
-  return { before, shown: btn.style.display !== 'none', text: btn.textContent,
-           help: document.getElementById('gameover-help').style.display };
+  const before = { dda: !!g.ddaManager, eligible: g._helpEligible(), helped: g._helpFlags().helped,
+    chooser: ['daily-mode-overlay', 'btn-daily-ranked', 'btn-daily-practice', 'btn-practice-help'].filter((id) => document.getElementById(id)) };
+  return { before };
 });
-console.log('  ranked game over:', JSON.stringify(ranked));
-check('ranked: no helping hand on the run itself', ranked.before.ranked === true && ranked.before.dda === false && ranked.help === 'none');
-check('ranked failure offers "Ride it as practice — with a helping hand"', ranked.shown && /Ride it as practice — with a helping hand/.test(ranked.text));
-const practice = await rp.evaluate(async () => {
-  const g = window._game;
-  document.getElementById('btn-practice-help').click();
-  const d = await import('./js/daily-ride.js');
-  const key = g.lobby.selectedLevel.key;
-  const entry = d.readAll ? d.readAll(d.browserStore())[key] : null;
-  return { ranked: g._rankedRunActive, dda: !!g.ddaManager, level: g.lobby.selectedLevel.id,
-           spent: d.rankedDone(d.browserStore(), key, 'solo'), entry,
-           overlay: document.getElementById('gameover-overlay').style.display };
-});
-console.log('  after the button:', JSON.stringify(practice));
-check('it spends the ranked run and starts practice on the same road, with the DDA on',
-  practice.ranked === false && practice.dda === true && practice.level === 'daily' && practice.spent && practice.overlay === 'none');
+console.log('  fresh daily ride:', JSON.stringify(fresh));
+check('a fresh Daily ride: DDA on, helping hand eligible, not yet helped', fresh.before.dda && fresh.before.eligible && !fresh.before.helped);
+check('no practice / ranked chooser and no "Ride it as practice" button', fresh.before.chooser.length === 0, fresh.before.chooser);
 
 // ── 4. Segment 1: a retry goes back to the start line through a fresh
 // countdown, and the count must survive it ─────────────────────────────────
diff --git a/scripts/smoke-hud-layout.mjs b/scripts/smoke-hud-layout.mjs
index 2e4b55e0..5e52907a 100644
--- a/scripts/smoke-hud-layout.mjs
+++ b/scripts/smoke-hud-layout.mjs
@@ -40,7 +40,6 @@ async function check(label, viewport) {
     document.getElementById('ping-call').textContent = '3';
     document.getElementById('ping-call').classList.add('show');
     document.getElementById('ping-bubbles').innerHTML = '<div class="ping-bubble">C👍</div>';
-    document.getElementById('ranked-badge').classList.add('show');
     document.getElementById('split-delta').textContent = '+1.3';
     document.getElementById('split-delta').className = 'show behind';
     document.getElementById('ping-row').classList.add('visible');
@@ -51,7 +50,7 @@ async function check(label, viewport) {
     // #576: the visible strip, not #hud-top (a transparent full-width band); on a
     // wide screen the strip is at the left and the badge sits beside it.
     const ids = ['hud-dashboard','coach-card','lookahead','disruption-banner','ping-call','ping-bubbles',
-                 'ranked-badge','split-delta','pedal-bar','sync-row','ping-row','coop-coach'];
+                 'split-delta','pedal-bar','sync-row','ping-row','coop-coach'];
     const out = {};
     for (const id of ids) {
       const el = document.getElementById(id);
diff --git a/scripts/smoke-props-3d.mjs b/scripts/smoke-props-3d.mjs
index b3bca9b2..9269f53c 100644
--- a/scripts/smoke-props-3d.mjs
+++ b/scripts/smoke-props-3d.mjs
@@ -26,9 +26,7 @@ async function ride(levelId, difficulty = 'daredevil') {
   await page.evaluate((id) => document.querySelector(`#level-cards .level-card[data-level-id="${id}"]`).click(), levelId);
   await page.evaluate((d) => { window._game.lobby.selectedDifficulty = d; }, difficulty);
   await sleep(300);
-  await clickId(page, 'btn-start-ride');
-  await sleep(500);
-  await clickId(page, 'btn-daily-practice');   // Today's Road asks practice or ranked first (web build)
+  await clickId(page, 'btn-start-ride');   // #641: START RIDE starts the Daily Ride too (no chooser)
   await waitState(page, 'playing');
   return page;
 }
diff --git a/scripts/smoke-ranked-run.mjs b/scripts/smoke-ranked-run.mjs
deleted file mode 100644
index a597abd6..00000000
--- a/scripts/smoke-ranked-run.mjs
+++ /dev/null
@@ -1,162 +0,0 @@
-#!/usr/bin/env node
-// smoke-ranked-run.mjs — D-2/D-3/D-5: the chooser appears on the web build and
-// never in the demo, a spent solo run leaves the pair run free, and the share
-// strip is four lines with nothing about the road in them.
-import http from 'node:http'; import fs from 'node:fs'; import path from 'node:path'; import puppeteer from 'puppeteer';
-const ROOT=process.cwd(); const PORT=8923;
-const MIME={'.html':'text/html','.js':'text/javascript','.css':'text/css','.png':'image/png','.jpg':'image/jpeg','.svg':'image/svg+xml','.glb':'model/gltf-binary','.mp3':'audio/mpeg','.json':'application/json'};
-const server=http.createServer((q,r)=>{const u=decodeURIComponent(q.url.split('?')[0]);const f=path.join(ROOT,u==='/'?'index.html':u);
- fs.stat(f,(e,st)=>{if(e||st.isDirectory())return r.writeHead(404).end();r.writeHead(200,{'Content-Type':MIME[path.extname(f)]||'application/octet-stream'});fs.createReadStream(f).pipe(r);});});
-await new Promise(r=>server.listen(PORT,'127.0.0.1',r));
-const browser=await puppeteer.launch({headless:'new',args:['--no-sandbox','--use-gl=swiftshader','--enable-unsafe-swiftshader','--mute-audio']});
-
-async function open(query='') {
-  const page=await browser.newPage(); await page.setViewport({width:1280,height:800});
-  await page.setRequestInterception(true);
-  page.on('request',(req)=>{const u=req.url(); if(u.startsWith(`http://127.0.0.1:${PORT}`))return req.continue();
-   let m=u.match(/three@[^/]+\/build\/three\.module\.js/);
-   if(m)return req.respond({status:200,contentType:'text/javascript',headers:{'Access-Control-Allow-Origin':'*'},body:fs.readFileSync(path.join(ROOT,'node_modules/three/build/three.module.js'))});
-   m=u.match(/three@[^/]+\/examples\/jsm\/(.+)$/); const f=m&&path.join(ROOT,'node_modules/three/examples/jsm/'+m[1]);
-   if(f&&fs.existsSync(f))return req.respond({status:200,contentType:'text/javascript',headers:{'Access-Control-Allow-Origin':'*'},body:fs.readFileSync(f)});
-   return req.abort();});
-  page.on('pageerror', e => console.log('  PAGEERROR:', e.message));
-  // D6 (#400): a returning player; the first-launch tutorial has its own smoke (smoke:tutorial).
-  await page.evaluateOnNewDocument(() => { try { localStorage.setItem('tandemonium_tutorial_done', 'smoke'); } catch {} });
-  await page.goto(`http://127.0.0.1:${PORT}/index.html${query}`,{waitUntil:'domcontentloaded'});
-  await page.waitForFunction(()=>!!window._game,{timeout:30000});
-  return page;
-}
-
-async function pickDaily(page) {
-  await page.evaluate(() => {
-    document.getElementById('tap-to-start')?.click();
-    (document.getElementById('btn-solo') || Array.from(document.querySelectorAll('button, uf-button')).find(x=>/solo/i.test(x.textContent)))?.click();
-  });
-  await new Promise(r=>setTimeout(r,600));
-  await page.evaluate(() => document.querySelector('.level-card[data-level-id="daily"]')?.click());
-  await new Promise(r=>setTimeout(r,300));
-}
-
-// 1. Web build: START RIDE opens the chooser.
-const web = await open();
-await pickDaily(web);
-const chooser = await web.evaluate(() => {
-  document.getElementById('btn-start-ride').click();
-  const o = document.getElementById('daily-mode-overlay');
-  return {
-    visible: o.classList.contains('visible'),
-    rankedDisabled: document.getElementById('btn-daily-ranked').disabled,
-    sub: document.getElementById('daily-mode-sub').textContent
-  };
-});
-console.log('web chooser:', JSON.stringify(chooser));
-
-// 2. Spend the run, reopen: RANKED is disabled with the time shown.
-const afterSpend = await web.evaluate(async () => {
-  const d = await import('./js/daily-ride.js');
-  const { dailyKey } = await import('./js/daily-seed.js');
-  const key = dailyKey();
-  d.recordRanked(d.browserStore(), key, 'solo', { timeMs: 161000, distance: 500 });
-  document.getElementById('daily-mode-overlay').classList.remove('visible');
-  window._game.lobby._showDailyModeChooser();
-  return {
-    rankedDisabled: document.getElementById('btn-daily-ranked').disabled,
-    hint: document.getElementById('daily-ranked-hint').textContent,
-    pairStillFree: !d.rankedDone(d.browserStore(), key, 'pair')
-  };
-});
-console.log('after spending the solo run:', JSON.stringify(afterSpend));
-
-// 3. Demo build: no chooser at all.
-const demo = await open('?demo=1');
-await pickDaily(demo);
-const demoChooser = await demo.evaluate(() => {
-  const ask = window._game.lobby._shouldAskDailyMode();
-  return { asks: ask, isDemo: window._game.lobby.isDemoBuild };
-});
-console.log('demo build:', JSON.stringify(demoChooser));
-
-// 4. The strip, built from a real summary through the game's own method.
-const strip = await web.evaluate(async () => {
-  const g = window._game;
-  const { dailyKey } = await import('./js/daily-seed.js');
-  const level = { ...g.lobby.selectedLevel, key: dailyKey(), isDaily: true, distance: 500 };
-  g.mode = 'solo'; g._rankedRunActive = true; g.safetyMode = false;
-  const html = g._buildDailyStripHtml({
-    timeMs: 161000, distance: 500, raceDistance: 500, collectibles: 9,
-    collectiblesTotal: 12, crashes: 1
-  }, level);
-  return { html, text: g._dailyStripText };
-});
-console.log('strip:\n' + strip.text);
-
-// 5. #398: the RANKED RUN badge never follows the player into the lobby —
-// neither after END RIDE (DNF) nor after a finish / quit (_returnToLobby).
-const badge = await web.evaluate(() => {
-  const g = window._game;
-  const el = document.getElementById('ranked-badge');
-  const shown = () => !!(el && el.classList.contains('show'));
-  g._rankedRunActive = true; g.hud.setRankedBadge(true);
-  const before = shown();
-  g._recordRankedDnf();
-  const afterDnf = { shown: shown(), active: g._rankedRunActive };
-  g._rankedRunActive = true; g.hud.setRankedBadge(true);
-  g._returnToLobby();
-  const afterLobby = { shown: shown(), active: g._rankedRunActive };
-  return { exists: !!el, before, afterDnf, afterLobby };
-});
-console.log('ranked badge:', JSON.stringify(badge));
-
-// 6. #398: the Daily Ride card says the day's ranked run was used.
-const card = await web.evaluate(() => {
-  window._game.lobby._rebuildLevelCards();
-  const d = document.querySelector('.level-card[data-level-id="daily"] .level-card-desc');
-  return d ? d.textContent : null;
-});
-console.log('daily card:', card);
-
-// 7. M4: a ranked run forces SAFETY and SPEED off and locks their buttons (HUD,
-// D-pad and quick menu) for the ride; the player's own choices come back after.
-const locks = await web.evaluate(() => {
-  const g = window._game;
-  const qmHidden = id => { g.quickMenu.sync(); return !!document.getElementById(id)?.hidden; };
-  g.mode = 'solo';
-  g.lobby.selectedLevel = { ...g.lobby.selectedLevel, isDaily: true };
-  g.safetyMode = true; g._safetyTouched = true; g.autoSpeed = true;
-  g.lobby._dailyMode = 'ranked';
-  g._startCountdown();
-  g.safetyBtn.click(); g.speedBtn.click();   // what the D-pad and the HUD do
-  const during = {
-    ranked: g._rankedRunActive, safety: g.safetyMode, speed: g.autoSpeed,
-    safetyDisabled: g.safetyBtn.disabled, speedDisabled: g.speedBtn.disabled,
-    qmSafetyHidden: qmHidden('qm-safety'), qmSpeedHidden: qmHidden('qm-speed'),
-  };
-  g._recordRankedDnf();                     // END RIDE spends the run and ends it
-  const after = {
-    ranked: g._rankedRunActive, safety: g.safetyMode, speed: g.autoSpeed,
-    safetyDisabled: g.safetyBtn.disabled, speedDisabled: g.speedBtn.disabled,
-    qmSafetyHidden: qmHidden('qm-safety'),
-  };
-  g._returnToLobby();
-  return { during, after };
-});
-console.log('ranked locks:', JSON.stringify(locks));
-const locksOk = locks.during.ranked && !locks.during.safety && !locks.during.speed
-  && locks.during.safetyDisabled && locks.during.speedDisabled
-  && locks.during.qmSafetyHidden && locks.during.qmSpeedHidden
-  && !locks.after.ranked && locks.after.safety && locks.after.speed
-  && !locks.after.safetyDisabled && !locks.after.speedDisabled && !locks.after.qmSafetyHidden;
-console.log(locksOk ? '✔ SAFETY and SPEED are locked off on a ranked run and restored after'
-                    : '✖ SAFETY/SPEED ranked lock is wrong');
-
-const badgeOk = badge.exists && badge.before && !badge.afterDnf.shown && !badge.afterDnf.active
-  && !badge.afterLobby.shown && !badge.afterLobby.active;
-const cardOk = !!card && /Ranked ✓ 2:41/.test(card) && !/not ridden yet/.test(card);
-
-const ok = badgeOk && cardOk && locksOk &&chooser.visible && !chooser.rankedDisabled
-  && afterSpend.rankedDisabled && /2:41/.test(afterSpend.hint) && afterSpend.pairStillFree
-  && demoChooser.isDemo && demoChooser.asks === false
-  && /Daily Ride/.test(strip.text) && /2:41/.test(strip.text) && strip.text.split('\n').length === 4;
-console.log(ok ? '✔ ranked runs, the one-per-day rule, the demo gate and the strip all hold'
-               : '✖ something is wrong');
-await browser.close(); server.close(); process.exit(ok?0:1);
diff --git a/scripts/smoke-tourist-coop.mjs b/scripts/smoke-tourist-coop.mjs
index 1bb9c255..00703350 100644
--- a/scripts/smoke-tourist-coop.mjs
+++ b/scripts/smoke-tourist-coop.mjs
@@ -16,14 +16,17 @@
 //      room with a message; a partner that never answers → timeout, never a hang.
 //   4. couch co-op: one screen, P2 seated, Tourist card → a 'local' tiles ride.
 //   PR #397 M1 / m10 / m15 / m16 / m17 — mixed editions and versions in a room:
-//   6. a demo stoker + a full captain ride the weekly road on Chill, unranked,
-//      with no Map Tourists card (most restrictive edition).
+//   6. #641 a demo stoker + a full captain ride the real Daily Ride (today's
+//      key, Adventurous) under demo room rules (3 rides a day), with no Map
+//      Tourists card (most restrictive edition).
 //   7. an OLD-client stoker (room profile without caps): no Map Tourists card,
-//      no ranked chooser, no helping hand on the captain.
+//      no helping hand on the captain (a NEW full stoker does get it, on the
+//      Daily Ride too).
 //   8. a captain whose own Tourist load fails still returns a silent stoker
 //      to the room (EVT_RETURN_ROOM always).
-//   9. a demo stoker refuses a level its edition lacks (Today's Road, from a
-//      new or an old captain), stays on the level list and tells the captain.
+//   9. a demo stoker refuses a level its edition lacks (Map Tourists from a
+//      new captain; an old #400 demo captain's 'weekly' road), stays on the
+//      level list and tells the captain.
 //  10. a touristReady lost in a blip is resent from onConnected.
 //  m15: the partner failing ends the barrier while this side is still loading.
 //  m16: the stoker uses the captain's anchor height.
@@ -47,8 +50,9 @@ export class TilesRenderer {
 const STUB_PLUGINS = ['GoogleCloudAuthPlugin', 'GLTFExtensionsPlugin', 'TileCompressionPlugin', 'TilesFadePlugin', 'ReorientationPlugin']
   .map(n => `export class ${n} { constructor() {} }`).join('\n');
 
-async function open(withKey, query = '') {
+async function open(withKey, query = '', storage = null) {
   const page=await browser.newPage(); await page.setViewport({width:1280,height:800});
+  if (storage) await page.evaluateOnNewDocument((s) => { try { for (const [k, v] of Object.entries(s)) localStorage.setItem(k, v); } catch {} }, storage);
   if (withKey) await page.evaluateOnNewDocument(() => { window.__TOURIST_MAPS_KEY__ = 'test-key-not-real'; });
   await page.setRequestInterception(true);
   page.on('request',(req)=>{const u=req.url(); if(u.startsWith(`http://127.0.0.1:${PORT}`))return req.continue();
@@ -137,9 +141,9 @@ const swapOk = swap.every(({ during, after }) =>
 // ── 2-3. online co-op over a relay ─────────────────────────────────────────
 // Each page gets a fake net whose sendProfile/sendEvent land on the other
 // page's current handlers (lobby's room handler, then the game's).
-async function pair(stokerHasKey, { stokerQuery = '', stokerOld = false } = {}) {
-  const cap = await open(true);
-  const sto = await open(stokerHasKey, stokerQuery);
+async function pair(stokerHasKey, { stokerQuery = '', stokerOld = false, storage = null } = {}) {
+  const cap = await open(true, '', storage);
+  const sto = await open(stokerHasKey, stokerQuery, storage);
   const pages = { captain: cap, stoker: sto };
   const drop = { captain: new Set(), stoker: new Set() };   // message types not delivered FROM a side
   for (const [role, page] of Object.entries(pages)) {
@@ -161,6 +165,7 @@ async function pair(stokerHasKey, { stokerQuery = '', stokerOld = false } = {})
         connected: true, roomCode: 'TSTX', transport: 'relay', audioEnabled: false, _localMediaStream: null,
         sendProfile: (p) => window.__relay('profile', JSON.stringify(p)),
         sendEvent: (e) => window.__relay('event', JSON.stringify(e)),
+        sendEventReliable: (e) => window.__relay('event', JSON.stringify(e)),   // #621
         sendState() {}, sendLean() {}, sendPedal() {}, getQualityStats: () => null, destroy() {},
       };
       window.__fakeNet = net;
@@ -365,56 +370,61 @@ const startCoopRide = async (levelId) => {
   await cap.evaluate((id) => {
     document.querySelector('#level-cards .level-card[data-level-id="' + id + '"]').click();
   }, levelId);
-  await new Promise(r => setTimeout(r, 300));
-  const asked = await cap.evaluate(() => window._game.lobby._shouldAskDailyMode());
+  await cap.waitForFunction((id) => window._game.lobby.selectedLevel && window._game.lobby.selectedLevel.id === id,
+    { timeout: 5000, polling: 50 }, levelId).catch(() => null);
   await cap.evaluate(() => document.getElementById('btn-start-ride').click());
   await cap.waitForFunction(() => window._game.mode === 'captain', { timeout: 15000, polling: 100 }).catch(() => null);
   await sto.waitForFunction(() => window._game.mode === 'stoker', { timeout: 15000, polling: 100 }).catch(() => null);
-  return asked;
 };
-const roomView = (page) => page.evaluate(() => {
-  const g = window._game, l = g.lobby, lv = l.selectedLevel || {};
-  return { mode: g.mode, level: lv.id, weekly: !!lv.isWeekly, key: lv.key, seed: lv.seed, diff: l.selectedDifficulty,
-    ranked: !!g._rankedRunActive, roomRanked: g._roomRules().ranked, roomDemo: g._roomRules().isDemo };
+const roomView = (page) => page.evaluate(async () => {
+  const g = window._game, l = g.lobby, lv = l.selectedLevel || {}, rr = g._roomRules();
+  const { dailyKey } = await import('./js/daily-seed.js');
+  return { mode: g.mode, level: lv.id, key: lv.key, dailyKey: dailyKey(), seed: lv.seed, diff: l.selectedDifficulty,
+    roomDemo: rr.isDemo, rideCap: rr.dailyRideCap, roomTourist: rr.tourist,
+    chooser: !!document.getElementById('daily-mode-overlay') };
 });
 
-// 6. demo stoker + full captain → the weekly road on Chill, unranked, no Map Tourists.
-({ cap, sto } = await pair(true, { stokerQuery: '?demo=1' }));
+// 6. #641 demo stoker + full captain → the real Daily Ride under demo rules, no Map Tourists.
+// The demo's Daily opens after the Tutorial and Grandma's: both sides have earned them.
+const OPENED = { tandemonium_achievements: JSON.stringify([
+  { id: 'tutorial_done', earnedAt: Date.now() }, { id: 'home_sweet', earnedAt: Date.now() }]) };
+({ cap, sto } = await pair(true, { stokerQuery: '?demo=1', storage: OPENED }));
 const demoCards = await cap.evaluate(() => Array.from(document.querySelectorAll('#level-cards .level-card')).map(c => c.dataset.levelId));
-const demoRoadName = await cap.evaluate(() => document.querySelector('#level-cards .level-card[data-level-id="daily"] .level-card-name').textContent);
-const demoAsked = await startCoopRide('daily');
-await cap.evaluate(() => window.__fakeNet.sendProfile({ type: 'dailyMode', mode: 'ranked', key: 'x' }));   // a rogue ranked call
+const demoCard = await cap.evaluate(() => {
+  const c = document.querySelector('#level-cards .level-card[data-level-id="daily"]');
+  return { name: c.querySelector('.level-card-name').textContent, locked: c.classList.contains('level-locked'),
+    desc: c.querySelector('.level-card-desc').textContent };
+});
+await startCoopRide('daily');
+await cap.evaluate(() => window.__fakeNet.sendProfile({ type: 'dailyMode', mode: 'ranked', key: 'x' }));   // an old build's ranked call: ignored
 await new Promise(r => setTimeout(r, 300));
-const demoRoom = { cards: demoCards, roadName: demoRoadName, asked: demoAsked, cap: await roomView(cap), sto: await roomView(sto),
-  weeklyKey: await cap.evaluate(async () => (await import('./js/daily-seed.js')).weeklyKey()) };
+const demoRoom = { cards: demoCards, card: demoCard, cap: await roomView(cap), sto: await roomView(sto) };
 console.log('demo stoker:', JSON.stringify(demoRoom, null, 1));
-const demoRoomOk = !demoRoom.cards.includes('tourist') && demoRoom.roadName === 'Weekly Ride' && demoRoom.asked === false &&
+const demoRoomOk = !demoRoom.cards.includes('tourist') && demoRoom.card.name === 'Daily Ride' && !demoRoom.card.locked &&
   demoRoom.cap.mode === 'captain' && demoRoom.sto.mode === 'stoker' &&
-  demoRoom.cap.weekly && demoRoom.sto.weekly && demoRoom.cap.key === demoRoom.weeklyKey && demoRoom.sto.key === demoRoom.cap.key &&
-  demoRoom.sto.seed === demoRoom.cap.seed && demoRoom.cap.diff === 'chill' && demoRoom.sto.diff === 'chill' &&
-  !demoRoom.cap.ranked && !demoRoom.sto.ranked && !demoRoom.cap.roomRanked && demoRoom.cap.roomDemo && demoRoom.sto.roomDemo;
+  demoRoom.cap.level === 'daily' && demoRoom.sto.level === 'daily' &&
+  demoRoom.cap.key === demoRoom.cap.dailyKey && demoRoom.sto.key === demoRoom.cap.key &&
+  demoRoom.sto.seed === demoRoom.cap.seed && demoRoom.cap.diff === 'adventurous' && demoRoom.sto.diff === 'adventurous' &&
+  demoRoom.cap.roomDemo && demoRoom.sto.roomDemo && demoRoom.cap.rideCap === 3 && demoRoom.sto.rideCap === 3 &&
+  !demoRoom.cap.roomTourist && !demoRoom.sto.roomTourist && !demoRoom.cap.chooser && !demoRoom.sto.chooser;
 await cap.close(); await sto.close();
 
-// 7. OLD-client stoker: no Map Tourists, no ranked chooser, no helping hand.
+// 7. OLD-client stoker: no Map Tourists, no helping hand.
 ({ cap, sto } = await pair(true, { stokerOld: true }));
 const oldCards = await cap.evaluate(() => Array.from(document.querySelectorAll('#level-cards .level-card')).map(c => c.dataset.levelId));
-await cap.evaluate(() => document.querySelector('#level-cards .level-card[data-level-id="daily"]').click());
-const oldAsked = await cap.evaluate(() => window._game.lobby._shouldAskDailyMode());
 await startCoopRide('grandma');
-const oldRoom = { cards: oldCards, asked: oldAsked, cap: await roomView(cap),
+const oldRoom = { cards: oldCards, cap: await roomView(cap),
   help: await cap.evaluate(() => window._game._helpEligible()), partnerOld: await cap.evaluate(() => window._game._roomRules().partnerOld) };
 console.log('old stoker:', JSON.stringify(oldRoom, null, 1));
-const oldRoomOk = !oldRoom.cards.includes('tourist') && oldRoom.asked === false && oldRoom.cap.mode === 'captain' &&
-  oldRoom.cap.level === 'grandma' && oldRoom.help === false && oldRoom.partnerOld === true && !oldRoom.cap.roomRanked;
+const oldRoomOk = !oldRoom.cards.includes('tourist') && oldRoom.cap.mode === 'captain' && !oldRoom.cap.roomTourist &&
+  oldRoom.cap.level === 'grandma' && oldRoom.help === false && oldRoom.partnerOld === true && !oldRoom.cap.roomDemo;
 await cap.close(); await sto.close();
-// ...and the same pair with a NEW full stoker does get the helping hand + ranked chooser.
+// ...and the same pair with a NEW full stoker does get the helping hand, on the Daily Ride too (#641).
 ({ cap, sto } = await pair(true));
-await cap.evaluate(() => document.querySelector('#level-cards .level-card[data-level-id="daily"]').click());
-const newAsked = await cap.evaluate(() => window._game.lobby._shouldAskDailyMode());
-await startCoopRide('grandma');
-const newHelp = await cap.evaluate(() => window._game._helpEligible());
-const newPairOk = newAsked === true && newHelp === true;
-console.log('new stoker:', JSON.stringify({ newAsked, newHelp }));
+await startCoopRide('daily');
+const newHelp = await cap.evaluate(() => ({ level: window._game.lobby.selectedLevel.id, help: window._game._helpEligible(), mode: window._game.mode }));
+const newPairOk = newHelp.level === 'daily' && newHelp.mode === 'captain' && newHelp.help === true;
+console.log('new stoker:', JSON.stringify(newHelp));
 await cap.close(); await sto.close();
 
 // 8. the captain's own Tourist load fails, the stoker never answers: still back to the room.
@@ -438,31 +448,29 @@ const capFailOk = capFail.cap.state === 'lobby' && capFail.sto.state === 'lobby'
   capFail.sto.kind === 'World' && capFail.stoInRoom;
 await cap.close(); await sto.close();
 
-// 9. a demo stoker refuses Today's Road (new captain, then an old one) and stays on the list.
+// 9. a demo stoker refuses a level its edition lacks (Map Tourists from a new
+// captain; an old #400 demo captain's 'weekly' road) and stays on the list.
 ({ cap, sto } = await pair(true, { stokerQuery: '?demo=1' }));
-const before9 = await sto.evaluate(() => JSON.stringify(window._game.lobby.selectedLevel && window._game.lobby.selectedLevel.key || null));
+const before9 = await sto.evaluate(() => JSON.stringify(window._game.lobby.selectedLevel && window._game.lobby.selectedLevel.id || null));
 await cap.evaluate(async () => {
   const { RoomProtocol } = await import('./js/lobby/room-protocol.js');
-  const { dailyKey } = await import('./js/daily-seed.js');
-  window.__fakeNet.sendProfile(RoomProtocol.levelSync('daily', { key: dailyKey(), seed: 99, roadKind: 'daily', difficulty: 'adventurous' }));
+  window.__fakeNet.sendProfile(RoomProtocol.levelSync('tourist', {}));
 });
-await cap.waitForFunction(() => window._game.lobby._lastLevelRefused === 'daily', { timeout: 5000, polling: 50 }).catch(() => null);
+await cap.waitForFunction(() => window._game.lobby._lastLevelRefused === 'tourist', { timeout: 5000, polling: 50 }).catch(() => null);
 const refusedNew = await cap.evaluate(() => window._game.lobby._lastLevelRefused);
 await cap.evaluate(() => { window._game.lobby._lastLevelRefused = null; });
-await cap.evaluate(async () => {   // an old captain: Today's Road with no roadKind, then the start
+await cap.evaluate(async () => {   // an old #400 demo captain: its Weekly Ride (#641 retired it)
   const { dailyKey } = await import('./js/daily-seed.js');
-  window.__fakeNet.sendProfile({ type: 'levelSync', levelId: 'daily', key: dailyKey(), seed: 99 });
-  window.__fakeNet.sendProfile({ type: 'startRide', placementSalt: 1, worldSeed: 99 });
+  window.__fakeNet.sendProfile({ type: 'levelSync', levelId: 'daily', key: dailyKey(), seed: 99, roadKind: 'weekly', difficulty: 'chill' });
 });
 await cap.waitForFunction(() => window._game.lobby._lastLevelRefused === 'daily', { timeout: 5000, polling: 50 }).catch(() => null);
-await new Promise(r => setTimeout(r, 500));
 const refuse = { refusedNew, refusedOld: await cap.evaluate(() => window._game.lobby._lastLevelRefused),
-  stoKeyBefore: before9,
-  stoKeyAfter: await sto.evaluate(() => JSON.stringify(window._game.lobby.selectedLevel && window._game.lobby.selectedLevel.key || null)),
+  stoLevelBefore: before9,
+  stoLevelAfter: await sto.evaluate(() => JSON.stringify(window._game.lobby.selectedLevel && window._game.lobby.selectedLevel.id || null)),
   stoMode: await sto.evaluate(() => window._game.mode), stoState: await sto.evaluate(() => window._game.state),
   stoOnList: await sto.evaluate(() => window._game.lobby._currentStep === window._game.lobby.levelStep) };
 console.log('demo stoker refuses:', JSON.stringify(refuse));
-const refuseOk = refuse.refusedNew === 'daily' && refuse.refusedOld === 'daily' && refuse.stoKeyAfter === refuse.stoKeyBefore &&
+const refuseOk = refuse.refusedNew === 'tourist' && refuse.refusedOld === 'daily' && refuse.stoLevelAfter === refuse.stoLevelBefore &&
   refuse.stoMode !== 'stoker' && refuse.stoState === 'lobby' && refuse.stoOnList;
 await cap.close(); await sto.close();
 
diff --git a/scripts/smoke-tv-playtest.mjs b/scripts/smoke-tv-playtest.mjs
index 0f1cb5e2..d470c33e 100644
--- a/scripts/smoke-tv-playtest.mjs
+++ b/scripts/smoke-tv-playtest.mjs
@@ -1,9 +1,8 @@
 #!/usr/bin/env node
 // smoke:tv-playtest · #576: fixes from the TV / Steam playtest of 2026-11-04.
 //
-//   TP-01  Daily Ride chooser: the pad's focus is on RANKED RUN (or PRACTICE
-//          when the ranked run is spent), ↓ moves, B is Back, A picks PRACTICE
-//          and the ride starts.
+//   TP-01  #641 Daily Ride: no practice / ranked chooser; with the Daily card
+//          picked, A on START RIDE starts the ride directly.
 //   TP-02  Pause menu: SAFETY / AUTO SPEED are there with ON / OFF, the pad
 //          reaches them, A flips the ride's setting and the menu stays open.
 //   TP-03  Pause menu: every button's 3px focus ring fits inside the sheet's
@@ -125,32 +124,37 @@ await pads.press(0, 'B', 160);
 await until(() => document.getElementById('leaderboard-modal').open === false);
 await sleep(400);
 
-// ── TP-01 · Daily Ride chooser ──
-const focusId = () => page.evaluate(() => document.querySelector('#daily-mode-overlay .gamepad-focus')?.id || null);
-const openChooser = () => page.evaluate(() => {
+// ── TP-01 · Daily Ride: START RIDE starts it (#641: no practice / ranked chooser) ──
+await page.evaluate(() => {
   const l = window._game.lobby;
-  l._showStep(l.levelStep);
   l._pendingMode = 'solo';
-  l._showDailyModeChooser();
+  l._showStep(l.levelStep);
 });
-await openChooser();
-const first = await until(() => document.querySelector('#daily-mode-overlay .gamepad-focus')?.id || null, null, 3000);
-const rankedOpen = await page.evaluate(() => !document.getElementById('btn-daily-ranked').disabled);
-check(first === (rankedOpen ? 'btn-daily-ranked' : 'btn-daily-practice'), 'TP-01 the chooser takes the pad: focus on its first live button', { first, rankedOpen });
-await h.shot(page, '2-daily-chooser');
-await pads.press(0, 'DOWN', 160); await sleep(250);
-const second = await focusId();
-check(!!second && second !== first, 'TP-01 ↓ moves to the next choice', { first, second });
-await pads.press(0, 'B', 160); await sleep(400);
-check(await page.evaluate(() => !document.getElementById('daily-mode-overlay').classList.contains('visible')), 'TP-01 B is Back: the chooser closes');
-await sleep(300);
-await openChooser();
-await until(() => !!document.querySelector('#daily-mode-overlay .gamepad-focus'), null, 3000);
-for (let i = 0; i < 3 && (await focusId()) !== 'btn-daily-practice'; i++) { await pads.press(0, 'DOWN', 160); await sleep(250); }
+await until(() => !!document.querySelector('#lobby-level .level-card[data-level-id="daily"]'), null, 5000);
+const picked = await page.evaluate(() => {
+  document.querySelector('#lobby-level .level-card[data-level-id="daily"]').click();
+  const l = window._game.lobby, card = document.querySelector('#lobby-level .level-card[data-level-id="daily"]');
+  return { level: l.selectedLevel && l.selectedLevel.id, isDaily: !!(l.selectedLevel && l.selectedLevel.isDaily), selected: card.classList.contains('selected'), locked: card.classList.contains('level-locked') };
+});
+check(picked.isDaily && picked.selected && !picked.locked, 'TP-01 the full game\'s Daily Ride card is open and picks', picked);
+const noChooser = await page.evaluate(() => ['daily-mode-overlay', 'btn-daily-ranked', 'btn-daily-practice', 'btn-daily-cancel', 'btn-practice-help', 'ranked-badge'].filter((id) => document.getElementById(id)));
+check(noChooser.length === 0, 'TP-01 no practice / ranked chooser on the page', noChooser);
+// The pad lands on START RIDE (the level step's default focus); walk to it if not.
+const startFocus = () => page.evaluate(() => window._game.lobby.lobbyEl.querySelector('.gamepad-focus')?.id || null);
+await page.evaluate(() => window._game.lobby._showStep(window._game.lobby.levelStep));
+await until(() => !!window._game.lobby.lobbyEl.querySelector('.gamepad-focus'), null, 3000);
+for (let i = 0; i < 12 && (await startFocus()) !== 'btn-start-ride'; i++) {
+  const was = await startFocus();
+  await pads.press(0, 'DOWN', 160);
+  await until((w) => (window._game.lobby.lobbyEl.querySelector('.gamepad-focus')?.id || null) !== w, was, 2000);
+}
+const onStart = await startFocus();
+await h.shot(page, '2-daily-start');
 await pads.press(0, 'A', 160);
-const riding = await until(() => window._game.state === 'playing' || window._game.state === 'countdown', null, 120000);
-const rideInfo = await page.evaluate(() => ({ state: window._game.state, ranked: !!window._game._rankedRunActive, chose: window._game.lobby._dailyMode }));
-check(!!riding && !rideInfo.ranked, 'TP-01 A on PRACTICE starts the ride, not ranked', rideInfo);
+const riding = await until(() => window._game.state === 'playing' || window._game.state === 'countdown', null, 60000);
+const rideInfo = await page.evaluate(() => ({ state: window._game.state, level: window._game.lobby.selectedLevel && window._game.lobby.selectedLevel.id,
+  rideNo: window._game._dailyRideNo ?? null }));
+check(onStart === 'btn-start-ride' && !!riding && rideInfo.level === 'daily', 'TP-01 A on START RIDE starts the Daily Ride directly', { onStart, ...rideInfo });
 await until(() => window._game.state === 'playing', null, 60000);
 await sleep(800);
 
diff --git a/scripts/sync-steam-achievements.js b/scripts/sync-steam-achievements.js
index 73378d28..f2e7b30b 100644
--- a/scripts/sync-steam-achievements.js
+++ b/scripts/sync-steam-achievements.js
@@ -84,7 +84,7 @@ function describeCondition(id, fallback) {
     perfect_1k: "Finish Grandma's House with no crashes or restarts",
     team_player: '80%+ safe riding in multiplayer',
     // F-1 · the loops the value & appeal plan built.
-    daily_first: "Take your first ranked Daily Ride",
+    daily_first: "Finish your first Daily Ride",
     daily_streak_7: "Take the Daily Ride seven days running",
     daily_streak_30: "Take the Daily Ride thirty days running",
     pair_10_rides: 'Ride ten times with the same partner',
@@ -109,7 +109,7 @@ function describeCondition(id, fallback) {
     grandma_bronze: "Reach Grandma's inside the bronze time (the slowest of the three medal times; each difficulty has its own, shown on the road's card)",
     grandma_silver: "Reach Grandma's inside the silver time (the middle medal time; each difficulty has its own, shown on the road's card)",
     grandma_gold: "Reach Grandma's inside the gold time (the fastest medal time; each difficulty has its own, shown on the road's card)",
-    daily_gold: "Finish the Daily Ride inside its gold time, on any day (practice counts; each difficulty has its own time)",
+    daily_gold: "Finish the Daily Ride inside its gold time, on any day (each difficulty has its own time)",
     all_gold: "Win gold on both timed roads: Grandma's and the Daily Ride",
     adventurer: 'Finish any level on Adventurous',
     daredevil: 'Finish any level on Daredevil',
@@ -152,7 +152,7 @@ function describeCondition(id, fallback) {
     ship_of_theseus: 'Rebuild the bike 5 times',
     daily_streak_3: "Take the Daily Ride three days running",
     daily_share: "Share a Daily Ride result",
-    daily_practice_10: "Finish 10 Daily Ride practice runs",
+    daily_practice_10: "Finish 10 Daily Rides",
     coop_first: 'Finish a co-op ride',
     social_goose: 'Finish co-op rides with 3 different partners',
     standing_date: 'Keep a 4-week pair streak',
diff --git a/test/unit/achievements.test.mjs b/test/unit/achievements.test.mjs
index 153a8507..77f15452 100644
--- a/test/unit/achievements.test.mjs
+++ b/test/unit/achievements.test.mjs
@@ -25,11 +25,12 @@ const EXISTING = [
 // so the edition rules win. (double_down left this list with #546: the pot of
 // gold no longer ends the run, so a demo stage 2-3 run can pair it with a best.)
 // daily_streak_3/7 (m5): the demo rides the weekly road, which feeds no day streak.
-const SPEC_FULL_ONLY = [
-  'sling_stage5', 'daily_streak_3', 'daily_streak_7',
-  'century', 'days_30', 'all_gold', 'sling_stage7', 'sling_1000', 'daily_launch', 'launch_week',
-  'coins_10000', 'max_upgrade', 'garage_royalty', 'rebuilt', 'ship_of_theseus', 'daily_first',
-  'daily_streak_30', 'pair_100km', 'standing_date', 'distance_between_us', 'grand_tour',
+// #641 · the 20 the demo awards (Pete, 2026-11-07).
+const DEMO_20 = [
+  'first_pedal', 'tutorial_done', 'first_crash', 'first_remount', 'first_boost',
+  'home_sweet', 'grandma_bronze', 'grandma_silver', 'grandma_gold', 'first_km',
+  'new_best', 'daily_first', 'daily_gold', 'sling_first', 'sling_stage3',
+  'jackpot', 'first_upgrade', 'coop_first', 'grandma_orange', 'days_3',
 ];
 
 // Rows per section, in the spec's order.
@@ -112,24 +113,21 @@ test('nothing is earned from a fresh start', () => {
 
 // ── the demo ─────────────────────────────────────────────────────
 
-test('the demo-unearnable list is the spec Demo column + the stage cap (21 full-only, 79 demo)', () => {
-  assert.deepEqual([...DEMO_UNEARNABLE].sort(), [...SPEC_FULL_ONLY].sort());
-  assert.equal(ACHIEVEMENTS.filter(a => a.demo).length, 79);
+test('#641: the demo awards exactly the agreed 20, and the full game all 100', () => {
+  const demo = ACHIEVEMENTS.filter(a => a.demo).map(a => a.id);
+  assert.deepEqual([...demo].sort(), [...DEMO_20].sort());
+  assert.deepEqual([...DEMO_RULES.achievements].sort(), [...DEMO_20].sort());
+  assert.equal(DEMO_UNEARNABLE.length, 80);
+  assert.equal(FULL_RULES.achievements, null);
 });
 
-test('each full-only reason matches the edition rules', () => {
-  for (const a of ACHIEVEMENTS.filter(x => !x.demo)) {
-    switch (a.full) {
-      case 'tourist': assert.equal(DEMO_RULES.tourist, false); assert.equal(FULL_RULES.tourist, true); break;
-      case 'ranked': assert.equal(DEMO_RULES.ranked, false); assert.equal(FULL_RULES.ranked, true); break;
-      case 'dailyLaunch': assert.equal(DEMO_RULES.isDemo, true); break;   // slingshot-mode · _dailyLaunchOn
-      case 'slingStage':
-        assert.ok(a.stage > DEMO_RULES.slingshot.maxStage, `${a.id}: stage ${a.stage} is inside the demo`);
-        assert.equal(FULL_RULES.slingshot.maxStage, null);
-        break;
-      case 'weeklyRoad': assert.equal(DEMO_RULES.weeklyRoad, true); assert.equal(FULL_RULES.weeklyRoad, false); break;
-      case 'scope': break;   // a long-haul goal the spec keeps for the full game
-      default: assert.fail(`${a.id} has no reason to be full-only (${a.full})`);
+test('#641: every demo achievement can be earned inside the demo', () => {
+  for (const a of ACHIEVEMENTS.filter(x => x.demo)) {
+    assert.notEqual(a.section, 'versus', `${a.id}: Versus is full-game only`);
+    assert.notEqual(a.section, 'explore', `${a.id}: Tourist is full-game only`);
+    if (a.section === 'colours') {
+      const bike = a.id === 'grandma_default' ? 'default' : 'bike_' + a.id.slice('grandma_'.length);
+      assert.ok(DEMO_RULES.bikes.includes(bike), `${a.id}: ${bike} is not a demo bike`);
     }
   }
   // …and every Slingshot row the demo can earn fits inside the demo's stages.
@@ -190,12 +188,6 @@ test("stats: Daily Ride day streak and medal keys", () => {
   L = applyEvent(L, 'finish', { finishedLevel: 'daily' }, '2026-10-06');
   assert.equal(L.dailyDayRun, 1);
   assert.equal(L.dailyDayBest, 3);
-  // m5: weekly-road finishes on later days feed no day streak.
-  let W = L;
-  for (const day of ['2026-10-07', '2026-10-08', '2026-10-09']) W = applyEvent(W, 'finish', { finishedLevel: 'daily', weekly: true }, day);
-  assert.equal(W.dailyDayRun, 1);
-  assert.equal(W.dailyDayBest, 3);
-  assert.equal(W.lastDailyDay, '2026-10-06');
   assert.equal(opensMedalGate('grandma', 'bronze'), true);
   assert.equal(opensMedalGate('grandma', null), false);
   L = applyEvent(L, 'finish', { finishedLevel: 'grandma', medal: 'gold', isCoop: true, partnerKey: 'p1' }, '2026-10-06');
@@ -524,11 +516,13 @@ test('manager: the demo never awards a full-game-only achievement', async () =>
   const m = new AchievementManager();
   m.demo = true;
   const got = m.record('coins', { amount: 20000 }).map(a => a.id);
-  assert.ok(got.includes('coins_1000'));
+  // #641: coin_first, coins_1000 and coins_10000 are all full-game only now.
+  assert.ok(!got.includes('coin_first'));
   assert.ok(!got.includes('coins_10000'));
   assert.ok(m.getAllDefinitions().find(d => d.id === 'coins_10000').demoLocked);
   m.demo = false;
-  assert.ok(m.record('share').map(a => a.id).includes('coins_10000'), 'the full game catches up');
+  const caught = m.record('share').map(a => a.id);
+  assert.ok(caught.includes('coins_10000') && caught.includes('coin_first'), 'the full game catches up');
 });
 
 test('the Steam sync script describes every achievement', () => {
diff --git a/test/unit/crash-policy.test.mjs b/test/unit/crash-policy.test.mjs
index 3a2812bd..641d9b94 100644
--- a/test/unit/crash-policy.test.mjs
+++ b/test/unit/crash-policy.test.mjs
@@ -14,10 +14,6 @@ test('the third crash in a segment offers help', () => {
   assert.equal(d.reason, 'stuck');
 });
 
-test('a ranked run ends on any crash', () => {
-  assert.equal(decideAfterCrash({ crashesThisSegment: 1, rankedRun: true }).reason, 'ranked');
-});
-
 test('a finished ride always shows the result', () => {
   assert.equal(decideAfterCrash({ crashesThisSegment: 1, rideOver: true }).reason, 'ride-over');
 });
diff --git a/test/unit/daily-board-upsert.test.mjs b/test/unit/daily-board-upsert.test.mjs
new file mode 100644
index 00000000..a6a65f2a
--- /dev/null
+++ b/test/unit/daily-board-upsert.test.mjs
@@ -0,0 +1,57 @@
+// #641 · POST /daily keeps each account's BEST time of the day per mode.
+// Runs the Worker's real SQL against an in-memory SQLite with the 0009 table.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { DatabaseSync } from 'node:sqlite';
+import { dailyUpsertSql } from '../../worker/leaderboard.js';
+
+function db() {
+  const d = new DatabaseSync(':memory:');
+  d.exec(`CREATE TABLE daily_results (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    user_id INTEGER NOT NULL, day_key TEXT NOT NULL, mode TEXT NOT NULL,
+    time_ms INTEGER, dnf INTEGER NOT NULL DEFAULT 0, distance REAL DEFAULT 0,
+    collectibles INTEGER DEFAULT 0, crashes INTEGER DEFAULT 0, safety_used INTEGER DEFAULT 0,
+    sync_pct INTEGER, partner_user_id INTEGER, created_at TEXT DEFAULT (datetime('now')),
+    UNIQUE (user_id, day_key, mode))`);
+  return d;
+}
+
+/** Submit like handleDailySubmit does; returns rows changed. */
+function submit(d, { user = 1, day = '2026-11-07', mode = 'solo', timeMs = null, dnf = false, crashes = 0 }) {
+  const r = d.prepare(dailyUpsertSql(dnf)).run(
+    user, day, mode, dnf ? null : timeMs, dnf ? 1 : 0, 500, 0, crashes, 0, null, null);
+  return Number(r.changes);
+}
+const row = (d, user = 1, mode = 'solo') =>
+  d.prepare('SELECT time_ms, dnf, crashes FROM daily_results WHERE user_id = ? AND mode = ?').get(user, mode);
+
+test('a faster finish replaces the row; a slower one changes nothing', () => {
+  const d = db();
+  assert.equal(submit(d, { timeMs: 90000, crashes: 2 }), 1);
+  assert.equal(submit(d, { timeMs: 80000, crashes: 0 }), 1, 'improved');
+  assert.deepEqual({ ...row(d) }, { time_ms: 80000, dnf: 0, crashes: 0 });
+  assert.equal(submit(d, { timeMs: 85000, crashes: 5 }), 0, 'slower: not improved');
+  assert.deepEqual({ ...row(d) }, { time_ms: 80000, dnf: 0, crashes: 0 });
+  assert.equal(d.prepare('SELECT COUNT(*) AS n FROM daily_results').get().n, 1, 'still one row');
+});
+
+test('a finish replaces a DNF; a DNF never replaces a finish', () => {
+  const d = db();
+  submit(d, { dnf: true });
+  assert.equal(row(d).dnf, 1);
+  submit(d, { timeMs: 99000 });
+  assert.deepEqual({ ...row(d) }, { time_ms: 99000, dnf: 0, crashes: 0 });
+  assert.equal(submit(d, { dnf: true }), 0);
+  assert.equal(row(d).time_ms, 99000);
+});
+
+test('solo and pair, and each day, are separate rows', () => {
+  const d = db();
+  submit(d, { timeMs: 90000 });
+  submit(d, { timeMs: 95000, mode: 'pair' });
+  submit(d, { timeMs: 70000, day: '2026-11-08' });
+  assert.equal(row(d).time_ms, 90000);
+  assert.equal(row(d, 1, 'pair').time_ms, 95000);
+  assert.equal(d.prepare('SELECT COUNT(*) AS n FROM daily_results').get().n, 3);
+});
diff --git a/test/unit/daily-ride.test.mjs b/test/unit/daily-ride.test.mjs
index 52f15f00..fa8394ed 100644
--- a/test/unit/daily-ride.test.mjs
+++ b/test/unit/daily-ride.test.mjs
@@ -1,27 +1,37 @@
-// C-2 · the road everyone rides today.
+// C-2 / #641 · the road everyone rides today: every ride counts, the best stays.
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import {
-  resolveDailyLevel, formatDayLabel, dailyStatus, recordPractice, prune,
-  dailyDescription, recordRanked, KEEP_DAYS, STORAGE_KEY
+  resolveDailyLevel, formatDayLabel, dailyStatus, prune, dailyDescription,
+  recordRideStart, recordDailyFinish, ridesStarted, firstTry, finishedToday,
+  KEEP_DAYS, STORAGE_KEY
 } from '../../js/daily-ride.js';
 import { dailyKey, dailySeed } from '../../js/daily-seed.js';
 
 const base = { id: 'daily', name: 'Daily Ride', distance: 500, checkpointInterval: 125 };
+const DAY = '2026-09-08';
 
 function memStore() {
   const m = new Map();
   return { get: k => m.get(k) ?? null, set: (k, v) => m.set(k, v), _m: m };
 }
 
+/** One whole ride: start, then finish (as game.js does). */
+function ride(store, key, run = {}) {
+  const rideNo = recordRideStart(store, key);
+  if (run.dnf) return rideNo;
+  recordDailyFinish(store, key, { ...run, rideNo });
+  return rideNo;
+}
+
 test('resolving attaches the day, the seed and a label without touching LEVELS', () => {
-  const frozen = { ...base };
-  const level = resolveDailyLevel(base, { key: '2026-09-08', seed: 12345 });
-  assert.equal(level.key, '2026-09-08');
-  assert.equal(level.seed, 12345);
+  const level = resolveDailyLevel(base, { key: DAY, seed: 1234 });
+  assert.equal(level.key, DAY);
+  assert.equal(level.seed, 1234);
   assert.equal(level.dateLabel, 'Tue, Sep 8');
   assert.equal(level.distance, 500);
-  assert.deepEqual(base, frozen, 'the static level must not be mutated');
+  assert.equal(base.key, undefined, 'the base level is not mutated');
+  assert.equal(base.seed, undefined);
 });
 
 test('resolving with no arguments uses today', () => {
@@ -37,34 +47,74 @@ test('the day label is locale-independent', () => {
 });
 
 test('an untouched day reads as not ridden', () => {
-  const store = memStore();
-  const status = dailyStatus(store, '2026-09-08');
-  assert.deepEqual(status, { practiced: 0, best: null, ranked: { solo: null, pair: null } });
-  assert.equal(dailyDescription(status, '2026-09-08'), 'Tue, Sep 8 · not ridden yet');
+  const status = dailyStatus(memStore(), DAY);
+  assert.deepEqual(status, { started: 0, finished: 0, best: null, first: null });
+  assert.equal(dailyDescription(status, DAY), 'Tue, Sep 8 · not ridden yet');
 });
 
-test('practice runs accumulate and keep the day\'s best', () => {
+test('#641 every ride counts: starts and finishes accumulate, the best is kept', () => {
   const store = memStore();
-  recordPractice(store, '2026-09-08', 161000);
-  recordPractice(store, '2026-09-08', 154500);
-  recordPractice(store, '2026-09-08', 170000);
-  const status = dailyStatus(store, '2026-09-08');
-  assert.equal(status.practiced, 3);
+  ride(store, DAY, { timeMs: 161000 });
+  ride(store, DAY, { timeMs: 154500 });
+  ride(store, DAY, { timeMs: 170000 });
+  const status = dailyStatus(store, DAY);
+  assert.equal(status.started, 3);
+  assert.equal(status.finished, 3);
   assert.equal(status.best, 154500, 'the best of the day, not the last');
-  assert.equal(dailyDescription(status, '2026-09-08'), 'Tue, Sep 8 · ridden ×3 · best 2:35');
+  assert.equal(dailyDescription(status, DAY), 'Tue, Sep 8 · finished ×3 · best 2:35');
+});
+
+test('#641 a ride counts when it starts: a quit ride still uses one', () => {
+  const store = memStore();
+  ride(store, DAY, { dnf: true });
+  assert.equal(ridesStarted(store, DAY), 1);
+  assert.equal(finishedToday(store, DAY), false);
+  assert.equal(dailyDescription(dailyStatus(store, DAY), DAY), 'Tue, Sep 8 · ridden once');
+  ride(store, DAY, { timeMs: 120000 });
+  assert.equal(ridesStarted(store, DAY), 2);
+  assert.match(dailyDescription(dailyStatus(store, DAY), DAY), /finished once · best 2:00/);
 });
 
-test('one ride reads as "ridden once"', () => {
+test('#641 / #403 a helped finish counts as a finish but is not the best', () => {
   const store = memStore();
-  recordPractice(store, '2026-09-08', 120000);
-  assert.match(dailyDescription(dailyStatus(store, '2026-09-08'), '2026-09-08'), /ridden once/);
+  ride(store, DAY, { timeMs: 90000, helped: true });
+  assert.equal(finishedToday(store, DAY), true);
+  assert.equal(dailyStatus(store, DAY).best, null);
+  ride(store, DAY, { timeMs: 110000 });
+  assert.equal(dailyStatus(store, DAY).best, 110000, 'a slower unaided finish is the best');
+  ride(store, DAY, { skipped: true });
+  assert.equal(dailyStatus(store, DAY).best, 110000, 'a shortcut is never a best');
+});
+
+test('#641 the first try is ride 1, whatever happens after it', () => {
+  const s = memStore();
+  assert.equal(firstTry(s, DAY), null);
+  ride(s, DAY, { timeMs: 130000 });
+  assert.deepEqual(firstTry(s, DAY), { timeMs: 130000, helped: false });
+  ride(s, DAY, { timeMs: 100000 });
+  assert.deepEqual(firstTry(s, DAY), { timeMs: 130000, helped: false }, 'a faster second ride is not the first try');
+
+  // The first ride quit: still riding it → null; once ride 2 starts it was a DNF.
+  const q = memStore();
+  recordRideStart(q, DAY);
+  assert.equal(firstTry(q, DAY), null);
+  ride(q, DAY, { timeMs: 100000 });
+  assert.deepEqual(firstTry(q, DAY), { dnf: true });
+
+  // A helped first ride, and a shortcut.
+  const h = memStore();
+  ride(h, DAY, { timeMs: 140000, helped: true });
+  assert.deepEqual(firstTry(h, DAY), { timeMs: 140000, helped: true });
+  const k = memStore();
+  ride(k, DAY, { skipped: true });
+  assert.deepEqual(firstTry(k, DAY), { skipped: true });
 });
 
 test('yesterday\'s rides do not count towards today', () => {
   const store = memStore();
-  recordPractice(store, '2026-09-07', 100000);
-  assert.equal(dailyStatus(store, '2026-09-08').practiced, 0);
-  assert.equal(dailyStatus(store, '2026-09-07').practiced, 1);
+  ride(store, '2026-09-07', { timeMs: 100000 });
+  assert.equal(dailyStatus(store, DAY).started, 0);
+  assert.equal(dailyStatus(store, '2026-09-07').finished, 1);
 });
 
 test('old days are pruned, recent ones are kept', () => {
@@ -81,36 +131,24 @@ test('old days are pruned, recent ones are kept', () => {
 
 test('a store that throws does not take the ride down', () => {
   const angry = { get() { throw new Error('blocked'); }, set() { throw new Error('blocked'); } };
-  assert.doesNotThrow(() => recordPractice(angry, '2026-09-08', 1000));
-  assert.deepEqual(dailyStatus(angry, '2026-09-08'), { practiced: 0, best: null, ranked: { solo: null, pair: null } });
+  assert.doesNotThrow(() => ride(angry, DAY, { timeMs: 1000 }));
+  assert.deepEqual(dailyStatus(angry, DAY), { started: 0, finished: 0, best: null, first: null });
 });
 
 test('the store key is namespaced', () => {
   const store = memStore();
-  recordPractice(store, '2026-09-08', 1000);
+  ride(store, DAY, { timeMs: 1000 });
   assert.ok(store._m.has(STORAGE_KEY));
 });
 
-// #398 · a ranked run used the day's one attempt; the card has to say so.
-test('a ranked finish counts as ridden and shows its time', () => {
-  const store = memStore();
-  recordRanked(store, '2026-09-08', 'solo', { timeMs: 65400, distance: 500 });
-  const status = dailyStatus(store, '2026-09-08');
-  assert.equal(status.ranked.solo.timeMs, 65400);
-  assert.equal(dailyDescription(status, '2026-09-08'), 'Tue, Sep 8 · Ranked ✓ 1:05');
-});
-
-test('a ranked DNF (END RIDE) still reads as the run being used', () => {
-  const store = memStore();
-  recordRanked(store, '2026-09-08', 'solo', { dnf: true, distance: 120 });
-  assert.equal(dailyDescription(dailyStatus(store, '2026-09-08'), '2026-09-08'), 'Tue, Sep 8 · Ranked · DNF');
-});
-
-test('solo and pair ranked runs and practice all show', () => {
+test('a save from before #641 still reads: practice finishes and the ranked best', () => {
   const store = memStore();
-  recordRanked(store, '2026-09-08', 'pair', { timeMs: 70000 });
-  recordRanked(store, '2026-09-08', 'solo', { dnf: true });
-  recordPractice(store, '2026-09-08', 62000);
-  assert.equal(dailyDescription(dailyStatus(store, '2026-09-08'), '2026-09-08'),
-    'Tue, Sep 8 · Ranked · DNF · Pair ranked ✓ 1:10 · ridden once · best 1:02');
+  store.set(STORAGE_KEY, JSON.stringify({
+    [DAY]: { practice: 2, best: 62000, ranked: { solo: { timeMs: 65400 }, pair: { dnf: true } } }
+  }));
+  const status = dailyStatus(store, DAY);
+  assert.equal(status.finished, 2);
+  assert.equal(status.best, 62000);
+  assert.equal(status.started, 0);
+  assert.equal(finishedToday(store, DAY), true);
 });
diff --git a/test/unit/daily-ranked.test.mjs b/test/unit/daily-streak-strip.test.mjs
similarity index 73%
rename from test/unit/daily-ranked.test.mjs
rename to test/unit/daily-streak-strip.test.mjs
index 0915e6b2..24732a3c 100644
--- a/test/unit/daily-ranked.test.mjs
+++ b/test/unit/daily-streak-strip.test.mjs
@@ -1,8 +1,8 @@
-// D-2 / D-3 / D-5 · ranked runs, the share strip, and streaks that forgive.
+// D-3 / D-5 / #641 · the share strip (with the first try), and streaks that forgive.
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import {
-  rankedDone, rankedResult, recordRanked, recordPractice,
+  recordDailyFinish,
   computeStreak, computePairStreak, recordPartner,
   buildShareStrip, isoWeek, daysBetween, MAX_BRIDGED_GAPS
 } from '../../js/daily-ride.js';
@@ -12,58 +12,8 @@ function memStore() {
   return { get: k => m.get(k) ?? null, set: (k, v) => m.set(k, v) };
 }
 
-// ── D-2 · ranked runs ─────────────────────────────────────────────────────
-
-test('one ranked run per day per mode', () => {
-  const s = memStore();
-  assert.equal(rankedDone(s, '2026-09-08', 'solo'), false);
-
-  const first = recordRanked(s, '2026-09-08', 'solo', { timeMs: 161000, distance: 500 });
-  assert.equal(first.recorded, true);
-  assert.equal(rankedDone(s, '2026-09-08', 'solo'), true);
-
-  const second = recordRanked(s, '2026-09-08', 'solo', { timeMs: 120000, distance: 500 });
-  assert.equal(second.recorded, false, 'a faster second attempt must not overwrite it');
-  assert.equal(rankedResult(s, '2026-09-08', 'solo').timeMs, 161000);
-});
-
-test('solo and pair runs are independent', () => {
-  const s = memStore();
-  recordRanked(s, '2026-09-08', 'solo', { timeMs: 161000, distance: 500 });
-  assert.equal(rankedDone(s, '2026-09-08', 'pair'), false,
-    'riding alone at lunch must not use up the evening ride with a partner');
-  assert.equal(recordRanked(s, '2026-09-08', 'pair', { timeMs: 150000 }).recorded, true);
-});
-
-test('a new day gives the run back', () => {
-  const s = memStore();
-  recordRanked(s, '2026-09-08', 'solo', { timeMs: 161000 });
-  assert.equal(rankedDone(s, '2026-09-09', 'solo'), false);
-});
-
-test('END RIDE consumes the run as a DNF', () => {
-  const s = memStore();
-  const r = recordRanked(s, '2026-09-08', 'solo', { dnf: true, distance: 320 });
-  assert.equal(r.recorded, true);
-  assert.equal(r.result.dnf, true);
-  assert.equal(r.result.timeMs, null);
-  assert.equal(rankedDone(s, '2026-09-08', 'solo'), true,
-    'a bad start must not be abandonable for a re-roll');
-});
-
-test('safety and sync are recorded, not forbidden', () => {
-  const s = memStore();
-  const r = recordRanked(s, '2026-09-08', 'pair',
-    { timeMs: 150000, safety: true, sync: 0.82, partner: 'sam' });
-  assert.equal(r.result.safety, true);
-  assert.equal(r.result.sync, 82);
-  assert.equal(r.result.partner, 'sam');
-});
-
-test('an unknown mode is refused', () => {
-  const s = memStore();
-  assert.equal(recordRanked(s, '2026-09-08', 'versus', { timeMs: 1 }).recorded, false);
-});
+/** A finished Daily Ride on day `key` (the streak only reads finishes). */
+const recordPractice = (s, key, timeMs) => recordDailyFinish(s, key, { timeMs });
 
 // ── D-5 · streaks ─────────────────────────────────────────────────────────
 
@@ -171,7 +121,7 @@ const RUN = {
   medal: 'silver', collectibles: 9, collectiblesTotal: 12, crashes: 1
 };
 
-test('a ranked solo finish reads exactly as specified', () => {
+test('a solo finish reads exactly as specified', () => {
   assert.equal(buildShareStrip(RUN), [
     "Tandemonium · Daily Ride · Sep 8",
     '2:41 · 🥈 · 🎁 9/12 · 💥 1',
@@ -194,10 +144,27 @@ test('a DNF says how far, not how long', () => {
   assert.match(strip, /▰▰▰▰▰▰▰▰▱▱▱▱ 500m/, 'the bar shows how far they got: 320/500 -> 8 of 12');
 });
 
-test('practice and safety are flagged honestly', () => {
+test('safety is flagged honestly; there is no practice flag any more (#641)', () => {
   const strip = buildShareStrip({ ...RUN, safety: true, practice: true });
   assert.match(strip, /🛡️/);
-  assert.match(strip, /🏋️/);
+  assert.doesNotMatch(strip, /🏋️/);
+});
+
+test('#641 the strip shows the day\'s best, and the first try once there were two rides', () => {
+  // Third ride of the day was slower than the best: the best leads.
+  const strip = buildShareStrip({ ...RUN, timeMs: 170000, bestMs: 150000, rides: 3, first: { timeMs: 175000 } });
+  assert.match(strip, /^2:30 · 🥈/m);
+  assert.match(strip, /1st try 2:55/);
+  // This ride is the best: its own time leads.
+  assert.match(buildShareStrip({ ...RUN, bestMs: 161000, rides: 2, first: { timeMs: 170000 } }), /^2:41 ·.*1st try 2:50/m);
+  // One ride only: the first try IS the time, so it is not repeated.
+  assert.doesNotMatch(buildShareStrip({ ...RUN, bestMs: 161000, rides: 1, first: { timeMs: 161000 } }), /1st try/);
+  // A first ride that ended early, a helped one, a shortcut.
+  assert.match(buildShareStrip({ ...RUN, rides: 2, first: { dnf: true } }), /1st try DNF/);
+  assert.match(buildShareStrip({ ...RUN, rides: 2, first: { timeMs: 180000, helped: true } }), /1st try 3:00🛟/);
+  assert.match(buildShareStrip({ ...RUN, rides: 2, first: { skipped: true } }), /1st try 👑/);
+  // A DNF today with a best from earlier: the best leads.
+  assert.match(buildShareStrip({ ...RUN, dnf: true, distance: 320, bestMs: 150000, rides: 2, first: { timeMs: 150000 } }), /^2:30/m);
 });
 
 test('a streak of two or more is worth showing; one is not', () => {
diff --git a/test/unit/economy.test.mjs b/test/unit/economy.test.mjs
index dae9841f..f7935303 100644
--- a/test/unit/economy.test.mjs
+++ b/test/unit/economy.test.mjs
@@ -184,19 +184,23 @@ test('#512 daily habit: +50 for the first Daily Ride finished today, +10 a strea
   assert.equal(scoreRide({ distance: 500, finished: false, dailyBonus: { firstToday: true, streak: 4 } }).dailyPay, 0, 'only a finish');
 });
 
-test('#512 finishedToday: practice or a non-DNF ranked run; a DNF is not a finish', async () => {
-  const { recordPractice, recordRanked, finishedToday, STORAGE_KEY } = await import('../../js/daily-ride.js');
+test('#512 finishedToday: a finish counts; a started ride, or a pre-#641 ranked DNF, does not', async () => {
+  const { recordDailyFinish, recordRideStart, finishedToday, STORAGE_KEY } = await import('../../js/daily-ride.js');
   const store = memStore();
   const k = '2026-11-04';
   assert.equal(finishedToday(store, k), false);
-  recordRanked(store, k, 'solo', { dnf: true, distance: 120 });
-  assert.equal(finishedToday(store, k), false, 'a ranked DNF');
-  recordPractice(store, k, 90000);
+  recordRideStart(store, k);
+  assert.equal(finishedToday(store, k), false, 'started, not finished');
+  recordDailyFinish(store, k, { timeMs: 90000, rideNo: 1 });
   assert.equal(finishedToday(store, k), true);
   assert.equal(finishedToday(store, '2026-11-05'), false, 'tomorrow is a new day');
-  const s2 = memStore();
-  recordRanked(s2, k, 'pair', { timeMs: 100000, distance: 500 });
-  assert.equal(finishedToday(s2, k), true);
+  // A save from before #641: the day's ranked run.
+  const old = memStore();
+  old.set(STORAGE_KEY, JSON.stringify({ [k]: { practice: 0, best: null, ranked: { solo: { dnf: true } } } }));
+  assert.equal(finishedToday(old, k), false, 'a ranked DNF');
+  const old2 = memStore();
+  old2.set(STORAGE_KEY, JSON.stringify({ [k]: { practice: 0, best: 100000, ranked: { pair: { timeMs: 100000 } } } }));
+  assert.equal(finishedToday(old2, k), true);
   assert.ok(STORAGE_KEY);
 });
 
diff --git a/test/unit/edition.test.mjs b/test/unit/edition.test.mjs
index e030ac2b..3c2526fd 100644
--- a/test/unit/edition.test.mjs
+++ b/test/unit/edition.test.mjs
@@ -1,7 +1,8 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import {
-  FULL_RULES, DEMO_RULES, resolveIsDemo, rulesFor, levelAllowed, resolveMediaEnabled
+  FULL_RULES, DEMO_RULES, resolveIsDemo, rulesFor, levelAllowed, resolveMediaEnabled,
+  dailyRideGate, bikeAllowed, achievementAllowed
 } from '../../js/edition.js';
 
 test('demo is detected from ?demo=1 or the Steam flag, nothing else', () => {
@@ -20,13 +21,36 @@ test('full game offers every level; demo only Tutorial, Grandma and the road', (
   assert.equal(rulesFor(false), FULL_RULES);
 });
 
-test('demo keeps multiplayer, gates the slingshot, is weekly and unranked', () => {
+test('#641 demo: co-op stays, Versus goes, the Slingshot stops at stage 3, two bikes', () => {
   assert.equal(DEMO_RULES.rideTogether, true);
-  assert.equal(DEMO_RULES.versus, true);
-  assert.equal(DEMO_RULES.weeklyRoad, true);
-  assert.equal(DEMO_RULES.ranked, false);
-  assert.ok(DEMO_RULES.slingshot.maxStage >= 1);
+  assert.equal(DEMO_RULES.versus, false);
+  assert.equal(FULL_RULES.versus, true);
+  assert.equal(DEMO_RULES.slingshot.maxStage, 3);
   assert.equal(FULL_RULES.slingshot.maxStage, null);
+  assert.equal(bikeAllowed(DEMO_RULES, 'default'), true);
+  assert.equal(bikeAllowed(DEMO_RULES, 'bike_orange'), true);
+  assert.equal(bikeAllowed(DEMO_RULES, 'bike_red'), false);
+  assert.equal(bikeAllowed(DEMO_RULES, 'bike_christmas'), false);
+  assert.equal(bikeAllowed(FULL_RULES, 'bike_red'), true);
+  assert.equal(achievementAllowed(DEMO_RULES, 'first_pedal'), true);
+  assert.equal(achievementAllowed(DEMO_RULES, 'versus_first'), false);
+  assert.equal(achievementAllowed(FULL_RULES, 'versus_first'), true);
+  // Level scores: the full game posts them, the demo doesn't (as #400).
+  assert.equal(FULL_RULES.postScores, true);
+  assert.equal(DEMO_RULES.postScores, false);
+});
+
+test('#641 Daily Ride gate: the demo opens it after the Tutorial and Grandma\'s, then 3 rides a day', () => {
+  const both = ['tutorial_done', 'home_sweet'];
+  assert.deepEqual(dailyRideGate(DEMO_RULES, 0, []), { ok: false, reason: 'needs', needs: both });
+  assert.deepEqual(dailyRideGate(DEMO_RULES, 0, ['tutorial_done']), { ok: false, reason: 'needs', needs: ['home_sweet'] });
+  assert.deepEqual(dailyRideGate(DEMO_RULES, 0, both), { ok: true, left: 3 });
+  assert.deepEqual(dailyRideGate(DEMO_RULES, 2, both), { ok: true, left: 1 });
+  assert.deepEqual(dailyRideGate(DEMO_RULES, 3, both), { ok: false, reason: 'cap' });
+  assert.deepEqual(dailyRideGate(DEMO_RULES, 9, both), { ok: false, reason: 'cap' });
+  // The full game: open from the start, no limit.
+  assert.deepEqual(dailyRideGate(FULL_RULES, 0, []), { ok: true, left: null });
+  assert.deepEqual(dailyRideGate(FULL_RULES, 50, []), { ok: true, left: null });
 });
 
 test('room camera/mic is off unless ?media=1', () => {
diff --git a/test/unit/look-no-thumbs.test.mjs b/test/unit/look-no-thumbs.test.mjs
index 7a80aacd..e677eb82 100644
--- a/test/unit/look-no-thumbs.test.mjs
+++ b/test/unit/look-no-thumbs.test.mjs
@@ -7,11 +7,11 @@ const ach = ACHIEVEMENTS.find(a => a.id === 'look_no_thumbs');
 const frames = (o = {}) => ({ keyboard: 0, gamepad: 0, motion: 0, 'gamepad-gyro': 0, ...o });
 const G = GYRO_ONLY_MIN_FRAMES;
 
-test('defined: #100 (last), clean section, in the demo, not hidden, Steam name LOOK_NO_THUMBS', () => {
+test('defined: #100 (last), clean section, full game only (#641), not hidden, Steam name LOOK_NO_THUMBS', () => {
   assert.ok(ach);
   assert.equal(ACHIEVEMENTS.length, 100);
   assert.equal(ach.section, 'clean');
-  assert.equal(ach.demo, true);
+  assert.equal(ach.demo, false);
   assert.ok(!ach.hidden);
   assert.equal(ach.id.toUpperCase(), 'LOOK_NO_THUMBS');
 });
diff --git a/test/unit/room-edition.test.mjs b/test/unit/room-edition.test.mjs
index 96281f91..48b868be 100644
--- a/test/unit/room-edition.test.mjs
+++ b/test/unit/room-edition.test.mjs
@@ -32,24 +32,23 @@ test('a profile without caps is an OLD client', () => {
 test('the room rides the MOST RESTRICTIVE edition', () => {
   // full + full (both new): everything.
   const ff = mergeRoomRules(FULL_RULES, FULL_NEW);
-  assert.equal(ff.isDemo, false); assert.equal(ff.ranked, true); assert.equal(ff.tourist, true);
-  assert.equal(ff.helpingHand, true); assert.equal(ff.weeklyRoad, false);
+  assert.equal(ff.isDemo, false); assert.equal(ff.tourist, true);
+  assert.equal(ff.helpingHand, true); assert.equal(ff.dailyRideCap, null);
   // full captain + demo partner: demo rules for both.
   const fd = mergeRoomRules(FULL_RULES, DEMO_NEW);
-  assert.equal(fd.isDemo, true); assert.equal(fd.weeklyRoad, true); assert.equal(fd.ranked, false);
+  assert.equal(fd.isDemo, true); assert.equal(fd.dailyRideCap, 3); assert.equal(fd.versus, false);
   assert.equal(fd.tourist, false); assert.deepEqual([...fd.levels], [...DEMO_RULES.levels]);
   // demo side + full partner: still demo.
   const df = mergeRoomRules(DEMO_RULES, FULL_NEW);
-  assert.equal(df.isDemo, true); assert.equal(df.ranked, false); assert.equal(df.tourist, false);
+  assert.equal(df.isDemo, true); assert.equal(df.dailyRideCap, 3); assert.equal(df.tourist, false);
   // partner without the tourist cap: no Map Tourists, the rest stays.
   const nt = mergeRoomRules(FULL_RULES, { edition: 'full', caps: ['helpingHand'] });
-  assert.equal(nt.tourist, false); assert.equal(nt.ranked, true);
+  assert.equal(nt.tourist, false); assert.equal(nt.helpingHand, true);
 });
 
-test('an OLD partner (or one not heard from yet): no ranked, no Map Tourists, no helping hand (m18)', () => {
+test('an OLD partner (or one not heard from yet): no Map Tourists, no helping hand (m18)', () => {
   for (const partner of [{ edition: 'full', caps: null }, null]) {
     const r = mergeRoomRules(FULL_RULES, partner);
-    assert.equal(r.ranked, false);
     assert.equal(r.tourist, false);
     assert.equal(r.helpingHand, false);
     assert.equal(r.partnerOld, true);
@@ -64,14 +63,14 @@ test('levelSync carries the effective road; old payload shape still readable', (
   assert.deepEqual(RoomProtocol.levelRefused('daily', 'demo'), { type: ROOM_MSG.LEVEL_REFUSED, levelId: 'daily', reason: 'demo' });
 });
 
-test('stoker verdict: adopts the captain road kind, refuses what its edition lacks (m17)', () => {
-  // full stoker on a demo captain's weekly road: rides the weekly road.
-  assert.deepEqual(levelSyncVerdict(FULL_RULES, lvl('daily'), { roadKind: 'weekly' }), { ok: true, roadKind: 'weekly' });
+test('stoker verdict: one shared road for both editions (#641), refuses what its edition lacks (m17)', () => {
+  // #641: the Daily Ride is the same road in the demo and the full game.
   assert.deepEqual(levelSyncVerdict(FULL_RULES, lvl('daily'), { roadKind: 'daily' }), { ok: true, roadKind: 'daily' });
-  // demo stoker: weekly ok; Today's Road (or an old captain, who sends no roadKind) refused.
-  assert.deepEqual(levelSyncVerdict(DEMO_RULES, lvl('daily'), { roadKind: 'weekly' }), { ok: true, roadKind: 'weekly' });
-  assert.deepEqual(levelSyncVerdict(DEMO_RULES, lvl('daily'), { roadKind: 'daily' }), { ok: false, reason: 'demo' });
-  assert.deepEqual(levelSyncVerdict(DEMO_RULES, lvl('daily'), { key: '2026-10-05', seed: 1 }), { ok: false, reason: 'demo' });
+  assert.deepEqual(levelSyncVerdict(DEMO_RULES, lvl('daily'), { roadKind: 'daily' }), { ok: true, roadKind: 'daily' });
+  assert.deepEqual(levelSyncVerdict(DEMO_RULES, lvl('daily'), { key: '2026-10-05', seed: 1 }), { ok: true, roadKind: 'daily' });
+  // an old #400 demo captain's Weekly Ride can't be built any more.
+  assert.deepEqual(levelSyncVerdict(FULL_RULES, lvl('daily'), { roadKind: 'weekly' }), { ok: false, reason: 'level' });
+  assert.deepEqual(levelSyncVerdict(DEMO_RULES, lvl('daily'), { roadKind: 'weekly' }), { ok: false, reason: 'level' });
   assert.deepEqual(levelSyncVerdict(DEMO_RULES, lvl('grandma'), {}), { ok: true, roadKind: null });
   // a level this build doesn't know (a newer captain) is refused, never crashes.
   assert.equal(levelSyncVerdict(FULL_RULES, undefined, {}).ok, false);
diff --git a/test/unit/weekly-road.test.mjs b/test/unit/weekly-road.test.mjs
deleted file mode 100644
index 51ae7ab9..00000000
--- a/test/unit/weekly-road.test.mjs
+++ /dev/null
@@ -1,77 +0,0 @@
-// #400 · the demo's "Weekly Ride" (was "This Week's Road"): one road per ISO week, keyed by its Monday.
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { weeklyKey, weeklySeed, seedFromKey, dailyKey } from '../../js/daily-seed.js';
-import {
-  asWeeklyRoad, resolveWeeklyLevel, weeklyDescription, WEEKLY_NAME, WEEKLY_DIFFICULTY
-} from '../../js/daily-ride.js';
-
-test('the week key is the Monday, for every day of the week', () => {
-  // Mon 2026-09-28 .. Sun 2026-10-04 (after the 09:00 UTC rollover)
-  for (const d of ['28', '29', '30']) {
-    assert.equal(weeklyKey(new Date(`2026-09-${d}T12:00:00Z`)), '2026-09-28');
-  }
-  for (const d of ['01', '02', '03', '04']) {
-    assert.equal(weeklyKey(new Date(`2026-10-${d}T12:00:00Z`)), '2026-09-28');
-  }
-  assert.equal(weeklyKey(new Date('2026-10-05T12:00:00Z')), '2026-10-05');
-});
-
-test('the week rolls over on Monday at 09:00 UTC, like the daily road', () => {
-  assert.equal(weeklyKey(new Date('2026-10-05T08:59:59Z')), '2026-09-28');
-  assert.equal(weeklyKey(new Date('2026-10-05T09:00:00Z')), '2026-10-05');
-});
-
-test('year boundaries: the week that spans New Year belongs to its Monday', () => {
-  // Thu 2026-01-01 is in the week of Mon 2025-12-29.
-  assert.equal(weeklyKey(new Date('2026-01-01T12:00:00Z')), '2025-12-29');
-  assert.equal(weeklyKey(new Date('2026-01-04T12:00:00Z')), '2025-12-29');
-  assert.equal(weeklyKey(new Date('2025-12-31T12:00:00Z')), '2025-12-29');
-  // Mon 2029-01-01 starts its own week; Sun 2028-12-31 is still the old one.
-  assert.equal(weeklyKey(new Date('2029-01-01T12:00:00Z')), '2029-01-01');
-  assert.equal(weeklyKey(new Date('2028-12-31T12:00:00Z')), '2028-12-25');
-  // Leap day.
-  assert.equal(weeklyKey(new Date('2028-02-29T12:00:00Z')), '2028-02-28');
-  // New Year's Day before 09:00 UTC is still the previous day's road/week.
-  assert.equal(weeklyKey(new Date('2029-01-01T08:00:00Z')), '2028-12-25');
-});
-
-test('the week key is always a Monday and a valid day key', () => {
-  for (let t = Date.parse('2026-01-01T00:00:00Z'); t < Date.parse('2027-01-01T00:00:00Z'); t += 5 * 3600 * 1000) {
-    const k = weeklyKey(new Date(t));
-    assert.equal(new Date(k + 'T00:00:00Z').getUTCDay(), 1, k);
-    assert.ok(k <= dailyKey(new Date(t)));
-  }
-});
-
-test('one seed per week: the Monday road', () => {
-  const mon = weeklySeed(new Date('2026-09-28T12:00:00Z'));
-  assert.equal(mon, weeklySeed(new Date('2026-10-04T12:00:00Z')));
-  assert.equal(mon, seedFromKey('2026-09-28'));
-  assert.notEqual(mon, weeklySeed(new Date('2026-10-05T12:00:00Z')));
-});
-
-test('the weekly road is the daily level renamed, on Chill', () => {
-  const base = { id: 'daily', name: 'Daily Ride', isDaily: true, fixedDifficulty: 'adventurous', distance: 500 };
-  const shown = asWeeklyRoad(base);
-  assert.equal(shown.name, WEEKLY_NAME);
-  assert.equal(shown.fixedDifficulty, WEEKLY_DIFFICULTY);
-  assert.equal(WEEKLY_DIFFICULTY, 'chill');
-  assert.equal(shown.isDaily, true);
-  assert.equal(base.name, 'Daily Ride');              // the base is untouched
-
-  const lvl = resolveWeeklyLevel(base, { key: '2026-09-28', seed: 42 });
-  assert.equal(lvl.key, '2026-09-28');
-  assert.equal(lvl.seed, 42);
-  assert.equal(lvl.dateLabel, 'Week of Sep 28');
-  const def = resolveWeeklyLevel(base);
-  assert.equal(def.key, weeklyKey());
-  assert.equal(def.seed, weeklySeed());
-});
-
-test('the card line names the week, not the day', () => {
-  const d = weeklyDescription({ practiced: 0, best: null }, '2026-09-28');
-  assert.match(d, /A new road every week/);
-  assert.match(d, /Week of Sep 28 · not ridden yet/);
-  assert.doesNotMatch(d, /Mon, Sep 28/);
-});
diff --git a/worker/identity.js b/worker/identity.js
index f79ca434..40cd0b6a 100644
--- a/worker/identity.js
+++ b/worker/identity.js
@@ -144,7 +144,7 @@ export async function mergeAccounts(env, from, to, deps = {}) {
   await q(`INSERT OR IGNORE INTO user_achievements (user_id, achievement_id, earned_at, score_id)
            SELECT ?, achievement_id, earned_at, score_id FROM user_achievements WHERE user_id = ?`, to, from);
   await q('DELETE FROM user_achievements WHERE user_id = ?', from);
-  // One ranked daily run per day per mode: keep `to`'s where both rode.
+  // One daily row per day per mode: keep `to`'s where both rode.
   await q('UPDATE OR IGNORE daily_results SET user_id = ? WHERE user_id = ?', to, from);
   await q('DELETE FROM daily_results WHERE user_id = ?', from);
   await q('UPDATE daily_results SET partner_user_id = ? WHERE partner_user_id = ?', to, from);
diff --git a/worker/leaderboard.js b/worker/leaderboard.js
index ff91e485..fbdadbaf 100644
--- a/worker/leaderboard.js
+++ b/worker/leaderboard.js
@@ -648,9 +648,11 @@ async function handlePair(request, env, corsOrigin, userId) {
 }
 
 /**
- * D-6 · POST /daily — record the day's ranked run, once.
- * A second submission for the same (user, day, mode) is a 409, not an update:
- * that refusal is the whole of "one run per day".
+ * D-6 / #641 · POST /daily — a finished Daily Ride. The board shows each
+ * account's BEST time of the day per mode, so a faster finish replaces the
+ * row and a slower one changes nothing. A DNF (only pre-#641 builds send one)
+ * is kept only when the day has no row yet, and never replaces a finish.
+ * Responds { success, improved } — improved = this ride is now the day's best.
  */
 async function handleDailySubmit(request, env, corsOrigin, userId) {
   const body = await request.json();
@@ -672,26 +674,37 @@ async function handleDailySubmit(request, env, corsOrigin, userId) {
     return jsonResponse({ error: 'Implausible time' }, 400, corsOrigin);
   }
 
-  try {
-    await env.DB.prepare(
-      `INSERT INTO daily_results
-       (user_id, day_key, mode, time_ms, dnf, distance, collectibles, crashes, safety_used, sync_pct, partner_user_id)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    ).bind(
-      userId, dayKey, mode, dnf ? null : Math.round(timeMs), dnf ? 1 : 0,
-      distance || 0, collectibles || 0, crashes || 0, safetyUsed ? 1 : 0,
-      typeof syncPct === 'number' ? Math.round(syncPct) : null,
-      partnerUserId || null
-    ).run();
-  } catch (e) {
-    if (/UNIQUE/i.test(String(e && e.message))) {
-      return jsonResponse({ error: 'Already ridden today' }, 409, corsOrigin);
-    }
-    throw e;
-  }
+  const res = await env.DB.prepare(dailyUpsertSql(!!dnf)).bind(
+    userId, dayKey, mode, dnf ? null : Math.round(timeMs), dnf ? 1 : 0,
+    distance || 0, collectibles || 0, crashes || 0, safetyUsed ? 1 : 0,
+    typeof syncPct === 'number' ? Math.round(syncPct) : null,
+    partnerUserId || null
+  ).run();
+  const improved = !dnf && !!(res && res.meta && res.meta.changes > 0);
 
   writeMetric(env, 'daily_submit', mode);
-  return jsonResponse({ success: true }, 200, corsOrigin);
+  return jsonResponse({ success: true, improved }, 200, corsOrigin);
+}
+
+/**
+ * #641 · the daily_results write. One row per (user, day, mode) stays the rule
+ * (the UNIQUE key); what changed is that a better time UPDATES it. A finish
+ * replaces a DNF or a slower finish; a DNF only fills an empty day.
+ */
+export function dailyUpsertSql(dnf) {
+  const insert = `INSERT INTO daily_results
+       (user_id, day_key, mode, time_ms, dnf, distance, collectibles, crashes, safety_used, sync_pct, partner_user_id)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
+  if (dnf) return insert + `
+       ON CONFLICT(user_id, day_key, mode) DO NOTHING`;
+  return insert + `
+       ON CONFLICT(user_id, day_key, mode) DO UPDATE SET
+         time_ms = excluded.time_ms, dnf = 0, distance = excluded.distance,
+         collectibles = excluded.collectibles, crashes = excluded.crashes,
+         safety_used = excluded.safety_used, sync_pct = excluded.sync_pct,
+         partner_user_id = excluded.partner_user_id
+       WHERE daily_results.dnf = 1 OR daily_results.time_ms IS NULL
+          OR excluded.time_ms < daily_results.time_ms`;
 }
 
 /**

From 60224d8f6e64ef9281c9fcb4aa8b5ce5c2998e6e Mon Sep 17 00:00:00 2001
From: merge-test <merge-test@local>
Date: Sat, 7 Nov 2026 14:11:45 -0500
Subject: [PATCH 2/2] Turn on the Daily board; demo level scores post to the
 leaderboard (#641)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VDbZGpypLbzSQxBu62RC96
---
 js/config.js               | 12 +++++-------
 js/edition.js              |  2 +-
 test/unit/edition.test.mjs |  4 ++--
 3 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/js/config.js b/js/config.js
index f735db2d..81ba7e7a 100644
--- a/js/config.js
+++ b/js/config.js
@@ -584,10 +584,8 @@ export function stickResponse(x, deadzone = TUNE.stickDeadzone, curve = TUNE.sti
 // D-6 · Feature flag: the partners board
 // ============================================================
 //
-// The server-side daily board (worker /daily) ships dark. It only ever shows
-// the caller and people they have ridden with, so it cannot look like an empty
-// global leaderboard — but it still has nothing useful to say until enough
-// people are riding Today's Road, and a feature that says nothing teaches
-// players to stop looking. Turn this on after two weeks of daily_* data show
-// real players, and after the migration has been applied.
-export const DAILY_BOARD_ENABLED = false;
+// The server-side daily board (worker /daily). It only ever shows the caller
+// and people they have ridden with, so it cannot look like an empty global
+// leaderboard. #641 (Pete, 2026-11-07): on — every clean Daily finish posts and
+// the server keeps each player's best of the day (demo and full game alike).
+export const DAILY_BOARD_ENABLED = true;
diff --git a/js/edition.js b/js/edition.js
index 03d0faf0..bbfc7c80 100644
--- a/js/edition.js
+++ b/js/edition.js
@@ -66,7 +66,7 @@ export const DEMO_RULES = Object.freeze({
   versus: false,
   bikes: Object.freeze(['default', 'bike_orange']),
   achievements: DEMO_ACHIEVEMENTS,
-  postScores: false,   // as #400: the demo's level scores stay off the 🏆 leaderboard
+  postScores: true,    // #641 (Pete): demo level scores go on the 🏆 leaderboard too
 });
 
 /** #641 · may this edition award achievement `id`? */
diff --git a/test/unit/edition.test.mjs b/test/unit/edition.test.mjs
index 3c2526fd..52d03f87 100644
--- a/test/unit/edition.test.mjs
+++ b/test/unit/edition.test.mjs
@@ -35,9 +35,9 @@ test('#641 demo: co-op stays, Versus goes, the Slingshot stops at stage 3, two b
   assert.equal(achievementAllowed(DEMO_RULES, 'first_pedal'), true);
   assert.equal(achievementAllowed(DEMO_RULES, 'versus_first'), false);
   assert.equal(achievementAllowed(FULL_RULES, 'versus_first'), true);
-  // Level scores: the full game posts them, the demo doesn't (as #400).
+  // Level scores: both editions post them to the 🏆 leaderboard (#641).
   assert.equal(FULL_RULES.postScores, true);
-  assert.equal(DEMO_RULES.postScores, false);
+  assert.equal(DEMO_RULES.postScores, true);
 });
 
 test('#641 Daily Ride gate: the demo opens it after the Tutorial and Grandma\'s, then 3 rides a day', () => {