fix(ci): copy CHANGELOG.md into the wasm docker stage — deploys broken since v0.47.0

whats_new_plugin embeds the changelog at compile time (include_str!("../../CHANGELOG.md"), shipped 2026-07-13), but the Dockerfile's wasm-builder stage copies an explicit file list that never included CHANGELOG.md — every docker-build since (10 runs, v0.48.x and v0.49.0 content) failed in build_wasm.sh while web-e2e (full checkout) stayed green, so the web has been serving the July 14 image. Also add CHANGELOG.md to the workflow's trigger paths so changelog cuts redeploy the web and the What's-new card stays fresh. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
chore(ci): retrigger web deploy — run 579 failed post-#189, cause TBD (logs 404)
2026-07-16 18:53:13 -07:00 · 2026-07-16 18:41:27 -07:00 · 2026-07-16 18:11:59 -07:00 · 2026-07-17 01:11:25 +00:00 · 2026-07-16 18:06:02 -07:00 · 2026-07-17 00:48:15 +00:00
102 changed files with 8771 additions and 4748 deletions
@@ -1,4 +1,4 @@
-# Build and deploy the solitaire server Docker image.
+# Build and deploy the solitaire server Docker image. (retriggered 2026-07-16)
 name: Build and Deploy

 on:
@@ -10,9 +10,14 @@ on:
      - 'solitaire_web/**'
      - 'solitaire_sync/**'
      - 'solitaire_core/**'
+      - 'solitaire_data/**'
      - 'solitaire_engine/**'
      - 'Cargo.toml'
      - 'Cargo.lock'
+      - 'build_wasm.sh'
+      # The engine embeds CHANGELOG.md (What's-new card) — changelog cuts
+      # must redeploy the web so the card content stays fresh.
+      - 'CHANGELOG.md'
      - 'solitaire_server/Dockerfile'
      - '.gitea/workflows/docker-build.yml'

@@ -36,12 +41,9 @@ jobs:
        id: meta
        run: echo "sha=${GITHUB_SHA::8}" >> "$GITHUB_OUTPUT"

-      # WASM artifact freshness is owned by the `web-wasm-rebuild` workflow,
-      # which rebuilds pkg/ in CI on every master change to a wasm-feeding crate
-      # and commits it back (CI is the single source of truth — the artifacts
-      # aren't byte-reproducible on contributor machines). That pkg/ commit then
-      # triggers this workflow, so the deployed image always ships fresh wasm.
-      # No drift check is needed here.
+      # The wasm bundles (solitaire_server/web/pkg/) are not in the repo —
+      # the Dockerfile's wasm-builder stage builds them from source inside
+      # this image build, so the deployed image always ships fresh wasm.

      - name: Log in to Gitea registry
        uses: docker/login-action@v3
@@ -1,7 +1,20 @@
 # Workspace gate: the same clippy + test commands CLAUDE.md §6 requires
 # locally, run on every master push and pull request. Until this workflow
 # existed, nothing in CI ran the test suite at all — a direct push to
-# master (or the web-wasm-rebuild bot commit) was entirely unguarded.
+# master was entirely unguarded.
+#
+# Build caching (2026-07-13): the Gitea actions cache never restored on
+# this instance — every run back through run 597 logged "No cache found"
+# even for exact keys saved successfully ("Cache saved successfully") by
+# a run an hour earlier, including master→master restores. Until the
+# cache server on the runner host is fixed, Swatinem/rust-cache is pure
+# overhead here. `rust-host` is a HOST executor (its filesystem persists
+# between runs — ~/.cargo and the rustup toolchain already carry over),
+# so we get warm builds by pointing CARGO_TARGET_DIR at a persistent
+# path on the runner instead of tarring gigabytes through a cache API
+# that never returns them. Concurrent runs are safe: cargo serialises
+# on the target-dir lock.
+
 name: Test

 on:
@@ -28,8 +41,27 @@ on:
  workflow_dispatch:

 jobs:
+  # Seconds-long formatting gate in its own job so a rustfmt slip fails
+  # here instead of after a 35-minute cold build (run 600 spent its
+  # whole build budget to report an unformatted file).
+  fmt:
+    runs-on: rust-host
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install Rust 1.95.0
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: 1.95.0
+          components: rustfmt
+
+      - name: Format check
+        run: cargo fmt --check
+
  test:
    runs-on: rust-host
+    needs: fmt

    # Full debuginfo made the solitaire_engine test-binary link peak past the
    # runner's memory — ld was OOM-killed (signal 9) on runs 447 and 486.
@@ -40,10 +72,19 @@ jobs:
    # test binaries concurrently; as the workspace grew (runs 514/516/519)
    # two+ simultaneous ld processes OOM-killed the runner again even at
    # line-tables-only. Two jobs keeps at most two links in flight — the
-    # compile-throughput cost is small next to the cache-warm build.
+    # compile-throughput cost is small next to the warm build.
+    #
+    # CARGO_INCREMENTAL=0: incremental artifacts bloat the persistent
+    # target dir for little benefit in CI (rust-cache used to set this
+    # for the same reason).
+    #
+    # CARGO_TARGET_DIR: persistent on the runner host — see the header
+    # comment. The prune step below keeps it from growing unbounded.
    env:
      CARGO_PROFILE_DEV_DEBUG: line-tables-only
      CARGO_BUILD_JOBS: '2'
+      CARGO_INCREMENTAL: '0'
+      CARGO_TARGET_DIR: /home/runner/.cache/ferrous-solitaire/target

    steps:
      - name: Checkout
@@ -53,10 +94,21 @@ jobs:
        uses: dtolnay/rust-toolchain@master
        with:
          toolchain: 1.95.0
-          components: clippy, rustfmt
+          components: clippy

-      - name: Cache cargo build
-        uses: Swatinem/rust-cache@v2
+      # Toolchain or lockfile bumps strand stale artifacts nothing will
+      # ever reuse; reset the dir when it crosses 40 GiB rather than
+      # curating it (a cold rebuild every few weeks is cheaper than the
+      # bookkeeping).
+      - name: Prune persistent target dir when oversized
+        run: |
+          limit_kb=$((40 * 1024 * 1024))
+          used_kb=$(du -sk "$CARGO_TARGET_DIR" 2>/dev/null | cut -f1 || echo 0)
+          echo "persistent target dir: $((used_kb / 1024)) MiB (limit $((limit_kb / 1024)) MiB)"
+          if [ "${used_kb:-0}" -gt "$limit_kb" ]; then
+            echo "over limit — clearing for a fresh cold build"
+            rm -rf "$CARGO_TARGET_DIR"
+          fi

      # Native link deps for the Bevy crates (engine/app/web) on a bare
      # ubuntu runner: ALSA + udev for input/audio, X11 + Wayland for winit.
@@ -67,9 +119,6 @@ jobs:
            libasound2-dev libudev-dev pkg-config libx11-dev libxcursor-dev \
            libxrandr-dev libxi-dev libwayland-dev libxkbcommon-dev

-      - name: Format check
-        run: cargo fmt --check
-
      # SQLX_OFFLINE uses the checked-in `.sqlx/` query cache (no live DB),
      # same as the web-e2e workflow's server prebuild.
      - name: Clippy (deny warnings)
@@ -8,9 +8,13 @@ on:
      - 'solitaire_server/src/**'
      - 'solitaire_server/e2e/**'
      - 'solitaire_wasm/**'
+      - 'solitaire_web/**'
+      - 'solitaire_engine/**'
+      - 'solitaire_data/**'
      - 'solitaire_core/**'
      - 'Cargo.toml'
      - 'Cargo.lock'
+      - 'build_wasm.sh'
      - '.gitea/workflows/web-e2e.yml'
  workflow_dispatch:

@@ -24,10 +28,31 @@ jobs:

      - name: Install Rust
        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: wasm32-unknown-unknown

      - name: Cache cargo build
        uses: Swatinem/rust-cache@v2

+      # The wasm bundles (solitaire_server/web/pkg/) are not in the repo —
+      # build them here so the served pages have real wasm to load. Tool
+      # versions are pinned; keep in sync with solitaire_server/Dockerfile.
+      - name: Install wasm-bindgen-cli + wasm-pack (pinned)
+        uses: taiki-e/install-action@v2
+        with:
+          tool: wasm-bindgen-cli@0.2.120,wasm-pack@0.14.0
+
+      - name: Install binaryen 130 (wasm-opt, pinned)
+        run: |
+          set -euo pipefail
+          curl -sSL \
+            https://github.com/WebAssembly/binaryen/releases/download/version_130/binaryen-version_130-x86_64-linux.tar.gz \
+            | tar xz
+          echo "$PWD/binaryen-version_130/bin" >> "$GITHUB_PATH"
+
+      - name: Build WASM artifacts
+        run: ./build_wasm.sh
+
      # Prebuild the server so Playwright's `webServer` (which runs
      # `cargo run -p solitaire_server`) starts from a compiled binary instead
      # of cold-compiling the whole dependency graph (axum/sqlx/reqwest) inside
@@ -1,89 +0,0 @@
-name: Web WASM Rebuild
-
-# CI is the single source of truth for solitaire_server/web/pkg/.
-#
-# The wasm artifacts cannot be reproduced byte-for-byte on an arbitrary
-# contributor machine: even with identical rustc 1.95.0 / LLVM 22.1.2, the same
-# flags, the same Cargo.lock and remapped source paths, the output still differs
-# by host environment. So rather than police freshness with a rebuild-and-diff
-# gate (which false-failed for exactly that reason), CI rebuilds the artifacts
-# itself on every master change to a wasm-feeding crate and commits them back.
-#
-# Result: the deployed pkg/ can't silently rot, and contributors never need to
-# run build_wasm.sh by hand. The commit touches only pkg/, which is not in this
-# workflow's trigger paths (so it does not re-trigger here) but does match
-# docker-build's, so the refreshed wasm deploys.
-
-on:
-  push:
-    branches: [master]
-    paths:
-      - 'solitaire_core/**'
-      - 'solitaire_engine/**'
-      - 'solitaire_data/**'
-      - 'solitaire_sync/**'
-      - 'solitaire_wasm/**'
-      - 'solitaire_web/**'
-      - 'Cargo.toml'
-      - 'Cargo.lock'
-      - 'build_wasm.sh'
-      - '.gitea/workflows/web-wasm-rebuild.yml'
-  workflow_dispatch:
-
-concurrency:
-  group: web-wasm-rebuild
-  cancel-in-progress: false
-
-jobs:
-  rebuild:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          token: ${{ secrets.CI_TOKEN }}
-
-      - name: Install Rust 1.95.0
-        uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: 1.95.0
-          targets: wasm32-unknown-unknown
-
-      - name: Cache cargo build
-        uses: Swatinem/rust-cache@v2
-
-      - name: Install wasm-bindgen-cli + wasm-pack (pinned)
-        uses: taiki-e/install-action@v2
-        with:
-          tool: wasm-bindgen-cli@0.2.120,wasm-pack@0.14.0
-
-      - name: Install binaryen 130 (wasm-opt, pinned)
-        run: |
-          set -euo pipefail
-          curl -sSL \
-            https://github.com/WebAssembly/binaryen/releases/download/version_130/binaryen-version_130-x86_64-linux.tar.gz \
-            | tar xz
-          echo "$PWD/binaryen-version_130/bin" >> "$GITHUB_PATH"
-
-      - name: Rebuild WASM artifacts
-        run: ./build_wasm.sh
-
-      - name: Commit refreshed artifacts if changed
-        run: |
-          set -euo pipefail
-          if git diff --quiet -- solitaire_server/web/pkg/; then
-            echo "pkg/ already up to date — nothing to commit."
-            exit 0
-          fi
-          git config user.email "ci@gitea.local"
-          git config user.name "Gitea CI"
-          git add solitaire_server/web/pkg/
-          git commit -m "chore(web): regenerate wasm artifacts"
-          # master is unprotected; retry once if the tip moved under us.
-          git push origin HEAD:master || {
-            git fetch origin master
-            git rebase origin/master
-            git push origin HEAD:master
-          }
@@ -41,3 +41,7 @@ deploy/*-auth-secret.yaml
 # Local token-saving helper scripts (peek/cargoclip/testfail/diffclip/etc.) —
 # inspection-only Go tools, not committed. Tracked scripts/*.sh and *.md stay.
 scripts/*.go
+
+# WASM bundles — built by build_wasm.sh locally and by the Docker wasm-builder
+# stage / web-e2e workflow in CI; never committed (issue #156)
+solitaire_server/web/pkg/
@@ -145,7 +145,6 @@ Shared API contract types imported by both the game client (`solitaire_data`) an
 Owns:
 - `SyncPayload`, `SyncResponse`, `ConflictReport`
 - `ChallengeGoal`, `LeaderboardEntry`
- `ApiError` enum
 - Merge logic (pure functions, no I/O)

 ### `solitaire_data`
@@ -193,7 +192,7 @@ Owns:
 ### `solitaire_wasm`
 **Dependencies:** `solitaire_core`, `serde`, `serde_json`, `chrono`, `wasm-bindgen`, `serde-wasm-bindgen`.

-WebAssembly bindings for browser-side replay playback. Compiled to `cdylib` via `wasm-pack build`; the output lives in `solitaire_server/web/pkg/` and is served statically by the server.
+WebAssembly bindings for browser-side replay playback. Compiled to `cdylib` via `wasm-pack build` (`build_wasm.sh`); the output lands in `solitaire_server/web/pkg/` — gitignored, built in CI (Docker `wasm-builder` stage, web-e2e workflow) — and is served statically by the server.

 Intentionally **does not** depend on `solitaire_data` (which pulls in `dirs`, `keyring`, `reqwest`, and other non-WASM crates). Instead it defines a minimal `Replay` mirror with the same serde shape as `solitaire_data::Replay` — the JSON wire format is the compatibility contract.

@@ -257,7 +256,7 @@ solitaire_sync::merge(local, remote)
    │
    ▼
 Write merged result to disk
-    │  fires SyncCompleteEvent
+    │
    ▼
 Bevy main thread reads updated StatsResource
 ```
@@ -377,7 +376,6 @@ struct StateChangedEvent;
 struct CardFlippedEvent(u32);
 struct GameWonEvent { score: i32, time_seconds: u64 }
 struct AchievementUnlockedEvent(AchievementRecord);
-struct SyncCompleteEvent(Result<SyncResponse, String>);
 ```

 ### Layout System
@@ -745,7 +743,7 @@ All endpoints are under the base URL configured by the user (e.g., `https://soli
 | Method | Path | Auth | Notes |
 |---|---|---|---|
 | GET | `/replays/:id` | None | Serves `web/index.html`; JS fetches `/api/replays/:id` and steps through via the `solitaire_wasm` WASM module |
-| GET | `/web/*` | None | Static assets served via `ServeDir` from `solitaire_server/web/` (includes `web/pkg/` with wasm-bindgen output) |
+| GET | `/web/*` | None | Static assets served via `ServeDir` from `solitaire_server/web/` (includes `web/pkg/` with wasm-bindgen output — gitignored, produced by `build_wasm.sh` / CI) |

 ### Account Management

@@ -6,6 +6,178 @@ project follows [Semantic Versioning](https://semver.org/).

 ## [Unreleased]

+## [0.49.0] — 2026-07-16
+
+### Added
+
+- **See what sync did.** After every sync, the Account tab shows exactly
+  what the merge decided — a "no conflicts" note, or one line per
+  reconciled field with both values ("this device: 3 / server: 5"). When
+  a merge wasn't clean, a toast summarises it: "Synced — 2 conflicts,
+  kept newer values". (#189)
+- **One-file backup.** Settings → Account → Local data can now export
+  every save (settings, stats, achievements, progress) into a single
+  backup file next to your other saves — and restore from it later or on
+  another machine. Restores never silently reset anything: a missing or
+  incompatible backup shows an error and leaves your data untouched.
+  (#189)
+
+### Changed
+
+- Under the hood, the scheduler-ambiguity gate now covers the full
+  plugin cluster (22 plugins) — 585 undefined-order system pairs were
+  pinned or proven independent, eliminating a whole class of
+  "works-on-my-frame" bugs in modes, replays, input, and chrome. (#188)
+
+## [0.48.1] — 2026-07-15
+
+### Added
+
+- **Reduce Transparency.** Settings → Accessibility gains a toggle that
+  replaces the see-through glass toolbar with a solid panel, so cards
+  behind it can never reduce readability. High Contrast mode now also
+  makes the glass markedly more opaque with a brighter outline. (#187)
+
+### Changed
+
+- **The toolbar gets out of your way.** While you're dragging a card,
+  the floating toolbar slides off the bottom edge and returns when you
+  drop — bottom-row piles are never hidden behind it. Instant (no
+  animation) when Reduce Motion is on. (#187)
+
+## [0.48.0] — 2026-07-15
+
+### Changed
+
+- **Floating glass tab bar** (touch). The bottom action bar is now a
+  floating translucent pill — Undo, Draw, Hint, and Pause — with a
+  separate round Menu button beside it, hovering above the bottom edge
+  instead of docking to it. Draw stays expanded as the highlighted
+  action; the other buttons reveal their label while held (instantly,
+  with reduce-motion on). Same actions, same behaviour — new clothes.
+  (#186)
+- **Consistent empty, loading, and error screens.** The theme store,
+  leaderboard, and replay list now share one visual language for
+  "nothing here yet", "still loading", and "something went wrong" —
+  each with a next step instead of a dead end. (#184)
+
+### Fixed
+
+- **Hotkeys during drags.** Pressing Undo, New Game, Draw, or a mode
+  key mid-drag no longer fights the card you're holding — game-mutating
+  hotkeys are ignored until the card is dropped. (#185)
+
+## [0.47.0] — 2026-07-13
+
+### Added
+
+- **"What's new" on update.** The first launch after an update shows a
+  one-time card summarising what changed — like this one, right now.
+  Dismiss it and it never repeats; fresh installs never see it. (#180)
+- **Situational tips.** Two one-time teaches that fire from play, not a
+  tour: staring at a stuck board for a while points you at Hint, and an
+  engaged game quietly mentions the long-press quick-action menu —
+  unless you've already found it yourself. (#181)
+- **UI scale.** Settings → Accessibility now has a UI Scale control
+  (90% / 100% / 115% / 130%) that resizes every menu, button, and HUD
+  element live. The table always fits your screen regardless. (#182)
+- **Hold `/` for shortcuts** (desktop). A reference card of every
+  keyboard binding appears while `/` is held. The onboarding tour and
+  this card now share one binding table, so they can never disagree —
+  the tour's copy had drifted from reality. (#183)
+
+## [0.46.0] — 2026-07-13
+
+### Added
+
+- **Theme-store previews.** The store modal now shows each theme's
+  preview image next to its name — the server has advertised them since
+  the store launched; the client finally fetches them. Thumbnails load
+  in the background, pop in as they arrive, and are remembered for the
+  session. (#179)
+- **Hint ghost preview.** Asking for a hint now also plays a translucent
+  copy of the suggested card gliding to its destination (twice, then it
+  fades) alongside the usual highlights — you see the move, not just the
+  pieces. Automatically disabled when reduce-motion is on. (#179)
+
+### Changed
+
+- **One toast style, one place.** Queued info banners and instant
+  celebration/warning/error toasts now share a single bottom-anchored
+  stack that clears the touch action bar; simultaneous toasts stack
+  upward instead of overlapping. (#178)
+
+### Fixed
+
+- **Touch onboarding copy.** The how-to-play slide no longer tells touch
+  players to left/right-click; it now describes drag, double-tap, and
+  the bottom-bar Hint button. (#178)
+- **First launch shows one screen at a time.** On a fresh install the
+  Home screen no longer spawns underneath the welcome tour; the order is
+  now onboarding → Home → table. (#178)
+
+## [0.45.0] — 2026-07-13
+
+### Added
+
+- **Thumb-reach action bar on touch (menu redesign Phase F).** The bottom
+  bar slims to five buttons: an enlarged **Undo · Draw · Hint** trio
+  (96×64 px targets) between compact Menu and Pause. **Draw is new** — it
+  draws from the stock exactly like tapping the deck, without the reach to
+  the top of a tall folded screen. Help, Modes, and New Game moved off the
+  touch bar (Menu → System, the Home grid, and Home's hero button cover
+  them). Desktop keeps its seven-button bar unchanged.
+- **Hold-to-repeat Undo.** Press and hold Undo to step back repeatedly
+  (~5.5 undos/s after a short delay) instead of tap-tap-tap. Every step
+  goes through the normal undo path, so scoring penalties apply as usual.
+
+## [0.44.0] — 2026-07-13
+
+### Added
+
+- **Home is now a real home (menu redesign Phase B).** The mode picker became
+  a hierarchy: a **Continue** card (mode · elapsed · score) appears while a
+  game is in progress and returns to the table; a hero **New Game** button
+  replays your last mode with the current deal options in one tap; deal
+  options (draw 1/3, a new **winnable-only** toggle, difficulty tiers) moved
+  into a disclosure under the hero; the six modes sit in a compact symmetric
+  2×3 grid with descriptions on wide screens; and the stats strip moved to
+  the bottom. Wide viewports (desktop, unfolded foldables) get a two-pane
+  layout — launch surfaces left, Continue/daily/stats right. Cancel is now
+  **Back to table** and only appears while a live game exists. (#175)
+
+### Fixed
+
+- **Save files are self-contained (schema v6).** Like replays in 0.43.3, a
+  saved game now stores the dealt board via the upstream session serializers
+  instead of re-dealing from the seed on load; v4/v5 saves still load through
+  the legacy path and rewrite as v6 on next save. (#171)
+
+### Internal
+
+- **CI is ~9× faster.** Root-caused why the actions cache never restored on
+  the host-executor runner (per-run workdir paths poisoned the cache version
+  hash); the test workflow now uses a persistent on-runner target dir, and a
+  seconds-long `fmt` gate fails formatting mistakes before the build. Warm
+  full-gate runs: 4m29s, down from ~40 min. (#176)
+
+## [0.43.3] — 2026-07-10
+
+### Fixed
+
+- **Replays are now self-contained (schema v4).** A replay stores the dealt
+  board itself via the upstream `card_game` session serializers instead of
+  re-dealing from the seed at playback time, so replays survive RNG and
+  upstream upgrades that change the seed→deal mapping — the failure that had
+  silently broken every stored replay. The web player and web game now
+  exchange the full payload through the wasm layer (the old JS path hardcoded
+  `schema_version: 2`, uploaded empty move lists, and corrupted u64 seeds via
+  `Math.round`), and the replay viewer reports unplayable old-format replays
+  in the caption instead of dying silently. Pre-v4 replays are rejected by a
+  version gate; local histories repopulate with new wins. (#170)
+- **Difficulty-mode wins can upload.** The server's replay `mode` validation
+  now accepts data-carrying `GameMode` variants (previously a 400). (#170)
+
 ## [0.42.0] — 2026-07-06

 ### Added
@@ -7333,6 +7333,7 @@ dependencies = [
 "proptest",
 "rand 0.10.1",
 "serde",
+ "serde_json",
 "thiserror 2.0.18",
 ]

@@ -13,9 +13,10 @@
 # Run from the repo root:
 #   ./build_wasm.sh
 #
-# The generated pkg/ files are committed to git so self-hosters who don't
-# touch the WASM crates can skip this step.  Regenerate after any change to
-# solitaire_wasm/, solitaire_web/, solitaire_engine/, or solitaire_core/.
+# The generated pkg/ files are NOT committed to git (issue #156). CI builds
+# them where needed: the Docker image's wasm-builder stage for deployment,
+# and the web-e2e workflow for browser tests. Run this script locally before
+# serving /web or /play from a source checkout.

 set -euo pipefail

@@ -1,7 +1,9 @@
 # Menu UX Redesign — July 2026

-Status: PLANNING. Visual identity (Terminal / base16-eighties) is settled and
-out of scope — this is about **structure and interaction**, not colors or type.
+Status: IN PROGRESS. A / E / C / G shipped in v0.43.0; B implemented on
+`feat/home-hierarchy` (2026-07-13); F / H and the I–M backlog remain open.
+Visual identity (Terminal / base16-eighties) is settled and out of
+scope — this is about **structure and interaction**, not colors or type.

 ## Diagnosis (from code survey, 2026-07-07)

@@ -197,8 +199,13 @@ slimming), then **B**, then **F/G/H** as independent follow-ups.
 ## Open decisions

 1. ~~Settings: tabs vs. sub-pages~~ — **DECIDED 2026-07-07: tabs.**
-2. Deal options: disclosure on Classic card (proposed) vs. keep global row?
-3. Time Attack + Seed: top-level cards (proposed, grid stays symmetric) vs.
-   tucked under a "More" card?
-4. Stitch mockups for Phase B, or iterate directly in-engine?
-5. Phase F bottom bar: touch-only (proposed) or also desktop?
+2. ~~Deal options: disclosure on Classic card vs. keep global row~~ —
+   **DECIDED 2026-07-09: disclosure on the Classic card / New Game hero.**
+3. ~~Time Attack + Seed: top-level cards vs. "More" card~~ —
+   **DECIDED 2026-07-09: top-level cards, symmetric 2×3 grid.**
+4. ~~Stitch mockups for Phase B, or iterate directly in-engine~~ —
+   **DECIDED 2026-07-09: directly in-engine.**
+5. ~~Phase F bottom bar: touch-only vs. also desktop~~ —
+   **DECIDED 2026-07-13: touch-only.** Desktop keeps the current top
+   band; the bar is additive per §3.3 so a later desktop rollout stays
+   a settings flag away.
@@ -2,8 +2,8 @@
 # Live-watch the Gitea Actions deploy pipeline for Ferrous Solitaire.
 #
 # Polls recent workflow runs and prints a compact status block each cycle.
-# Stops when the newest docker-build (the deploy) has completed and no
-# web-wasm-rebuild is still pending — i.e. the full fix is live.
+# Stops when the newest docker-build (the deploy) has completed — the wasm
+# is built inside that image build, so no other workflow gates the deploy.
 #
 # Usage:  ./scripts/watch_deploy.sh [interval_seconds]
 #   token is read from ~/.config/tea/config.yml (never printed).
@@ -49,16 +49,15 @@ for r in runs:
        r.get("id"), str(r.get("head_sha"))[:7], wf[:18],
        r.get("status"), r.get("conclusion")))
 db = [r for r in runs if "docker-build" in str(r.get("path"))]
-wr_pending = any(r.get("status") != "completed" for r in runs if "web-wasm-rebuild" in str(r.get("path")))
 top = db[0] if db else None
-live = bool(top and top.get("status")=="completed" and top.get("conclusion")=="success" and not wr_pending)
-print("STATE=%s" % ("LIVE" if live else ("WAIT_WASM" if wr_pending else "DEPLOYING")))
+live = bool(top and top.get("status")=="completed" and top.get("conclusion")=="success")
+print("STATE=%s" % ("LIVE" if live else "DEPLOYING"))
 PY
 )"
  echo "$out" | grep -v '^STATE='
  if echo "$out" | grep -q '^STATE=LIVE'; then
    echo ""
-    echo "DEPLOY LIVE — newest docker-build succeeded, no wasm rebuild pending."
+    echo "DEPLOY LIVE — newest docker-build succeeded."
    echo "   Test: https://klondike.aleshym.co/play?v=${RANDOM}"
    break
  fi
@@ -9,7 +9,8 @@ default = []
 test-support = []

 [dev-dependencies]
-proptest = "1"
+proptest   = "1"
+serde_json = { workspace = true }

 [dependencies]
 serde     = { workspace = true }
@@ -22,11 +22,17 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 ///   indices for enum variants. No longer loadable — v3 files are discarded.
 /// - v4: `saved_moves` uses upstream `KlondikeInstruction` serde with named enum
 ///   variants (e.g. `"Foundation1"` instead of `0`).
-/// - v5 (current): `score`, `undo_count`, and `recycle_count` are no longer
+/// - v5: `score`, `undo_count`, and `recycle_count` are no longer
 ///   persisted. They are derived from the upstream `card_game`/`klondike` session
 ///   stats, which are rebuilt by replaying `saved_moves` on load. Older files that
 ///   still carry those keys load fine — the extra fields are ignored.
-pub const GAME_STATE_SCHEMA_VERSION: u32 = 5;
+/// - v6 (current): `saved_moves` replaced by `recording`, the upstream
+///   `card_game` session serialisation carrying the dealt board explicitly.
+///   Loading no longer re-deals from `seed`, so in-progress saves survive
+///   RNG/upstream upgrades that change the seed→deal mapping (the failure
+///   class that PR #170 fixed for replays). v4/v5 files still load through
+///   the legacy seed path and are rewritten as v6 on next save.
+pub const GAME_STATE_SCHEMA_VERSION: u32 = 6;

 /// Default move budget for a solvability check. Matches the winnable-deal retry
 /// loop in the engine.
@@ -95,8 +101,8 @@ pub enum GameMode {
    Difficulty(DifficultyLevel),
 }

-/// Output struct for schema v4 serialisation. `saved_moves` uses upstream
-/// `KlondikeInstruction` serde, which produces named enum variants.
+/// Output struct for schema v6 serialisation. `recording` is the upstream
+/// session serialisation (config + dealt board + instruction list).
 #[derive(Debug, Clone, Serialize)]
 struct PersistedGameState {
    pub draw_mode: DrawStockConfig,
@@ -105,15 +111,16 @@ struct PersistedGameState {
    pub seed: u64,
    pub take_from_foundation: bool,
    pub schema_version: u32,
-    pub saved_moves: Vec<KlondikeInstruction>,
+    pub recording: SessionRecording,
 }

-/// Input struct that accepts schema v4 and v5 `saved_moves` formats.
+/// Input struct that accepts schema v4, v5, and v6 save formats.
 ///
-/// `saved_moves` is deserialised directly as upstream `KlondikeInstruction`
-/// (named-variant serde). `score`, `undo_count`, and `recycle_count` are
-/// intentionally absent: all three are rebuilt by replaying the instruction
-/// history through the upstream session stats. Older v4 save files still carry
+/// v6 files carry `recording` (the upstream session serialisation, deal
+/// included); v4/v5 files carry `saved_moves` and rebuild the deal from
+/// `seed`. `score`, `undo_count`, and `recycle_count` are intentionally
+/// absent: all three are rebuilt by replaying the instruction history
+/// through the upstream session stats. Older v4 save files still carry
 /// those keys; serde ignores them.
 #[derive(Debug, Clone, Deserialize)]
 struct PersistedGameStateIn {
@@ -126,7 +133,12 @@ struct PersistedGameStateIn {
    pub take_from_foundation: bool,
    #[serde(default = "schema_v1")]
    pub schema_version: u32,
+    /// v4/v5 only. Replayed against a seed-dealt board.
+    #[serde(default)]
    pub saved_moves: Vec<KlondikeInstruction>,
+    /// v6 only. Carries the dealt board explicitly.
+    #[serde(default)]
+    pub recording: Option<SessionRecording>,
 }

 #[cfg(feature = "test-support")]
@@ -222,7 +234,7 @@ impl Serialize for GameState {
            seed: self.seed,
            take_from_foundation: self.take_from_foundation,
            schema_version: GAME_STATE_SCHEMA_VERSION,
-            saved_moves: self.saved_moves(),
+            recording: self.recording(),
        }
        .serialize(serializer)
    }
@@ -232,34 +244,51 @@ impl<'de> Deserialize<'de> for GameState {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let persisted = PersistedGameStateIn::deserialize(deserializer)?;

-        // Accept v4 (upstream named-variant serde) and v5 (current, derived
-        // stats). v3 (legacy u8-index format) and all others are rejected.
-        match persisted.schema_version {
-            4 | 5 => {}
+        // Accept v6 (current, recording-based), plus v4/v5 (legacy seed-dealt
+        // saves — loadable while the seed→deal mapping they were written
+        // under still holds; rewritten as v6 on the next save). v3 (legacy
+        // u8-index format) and all others are rejected.
+        let (mut game, instructions) = match persisted.schema_version {
+            6 => {
+                let Some(recording) = persisted.recording else {
+                    return Err(serde::de::Error::custom(
+                        "v6 save file is missing the session recording",
+                    ));
+                };
+                // The dealt board and session config come from the recording
+                // itself; `seed` is presentation metadata only.
+                Self::from_recording(&recording, persisted.seed, persisted.mode)
+            }
+            4 | 5 => (
+                Self {
+                    mode: persisted.mode,
+                    elapsed_seconds: 0,
+                    seed: persisted.seed,
+                    take_from_foundation: true,
+                    session: Self::new_session(persisted.seed, persisted.draw_mode),
+                    #[cfg(feature = "test-support")]
+                    test_pile_state: None,
+                },
+                persisted.saved_moves,
+            ),
            v => {
                return Err(serde::de::Error::custom(format!(
                    "unsupported GameState schema version {v}"
                )));
            }
-        }
-
-        let mut game = Self {
-            mode: persisted.mode,
-            elapsed_seconds: persisted.elapsed_seconds,
-            seed: persisted.seed,
-            take_from_foundation: persisted.take_from_foundation,
-            session: Self::new_session(persisted.seed, persisted.draw_mode),
-            #[cfg(feature = "test-support")]
-            test_pile_state: None,
        };
+        game.mode = persisted.mode;
+        game.elapsed_seconds = persisted.elapsed_seconds;
+        game.take_from_foundation = persisted.take_from_foundation;

-        // Replay the saved instruction history. The upstream session tracks
-        // score components and recycle_count as it processes each move, so the
-        // derived stats are correct once replay completes. `undo_count()` resets
-        // to 0 across save/load because undone moves are not part of the saved
-        // forward history.
+        // Replay the saved instruction history with validation — a tampered
+        // or corrupt file must surface an error, not a silently wrong board.
+        // The upstream session tracks score components and recycle_count as
+        // it processes each move, so the derived stats are correct once
+        // replay completes. `undo_count()` resets to 0 across save/load
+        // because undone moves are not part of the saved forward history.
        let replay_config = Self::replay_config(persisted.draw_mode);
-        for instruction in persisted.saved_moves {
+        for instruction in instructions {
            if !game
                .session
                .state()
@@ -277,6 +306,90 @@ impl<'de> Deserialize<'de> for GameState {
    }
 }

+/// Self-contained recording of one deal plus every instruction applied to it.
+///
+/// Serialises via the upstream `card_game` [`Session`] serde, whose wire
+/// format is `{config, initial_state, instructions}` — the dealt board is
+/// stored **explicitly**, so playback never depends on the seed→deal mapping
+/// staying stable across RNG or upstream-crate upgrades. This is the payload
+/// replays must persist; a bare seed is only sufficient for the exact build
+/// that recorded it.
+#[derive(Debug, Clone)]
+pub struct SessionRecording(Session<Klondike>);
+
+impl SessionRecording {
+    /// Builds a recording by dealing a fresh board from `seed` and
+    /// force-applying `instructions` **without validation**.
+    ///
+    /// Fixture/test aid only — production recordings come from
+    /// [`GameState::recording`], whose history is valid by construction.
+    /// Invalid instructions are absorbed by the upstream session's
+    /// `Option`-based pile pops rather than rejected, so a recording built
+    /// here may not replay cleanly through
+    /// [`GameState::apply_instruction`]'s validation.
+    pub fn from_instructions_unchecked(
+        seed: u64,
+        draw_mode: DrawStockConfig,
+        instructions: impl IntoIterator<Item = KlondikeInstruction>,
+    ) -> Self {
+        let mut session = GameState::new_session(seed, draw_mode);
+        for instruction in instructions {
+            session.process_instruction(instruction);
+        }
+        Self(session)
+    }
+
+    /// The dealt board the recording starts from (before any instruction).
+    fn initial_state(&self) -> &Klondike {
+        self.0
+            .history()
+            .first()
+            .map(|snapshot| snapshot.state())
+            .unwrap_or_else(|| self.0.state().state())
+    }
+
+    /// Ordered instruction list, replayable via
+    /// [`GameState::apply_instruction`] against the game returned by
+    /// [`GameState::from_recording`].
+    pub fn instructions(&self) -> Vec<KlondikeInstruction> {
+        self.0
+            .history()
+            .iter()
+            .map(|snapshot| *snapshot.instruction())
+            .collect()
+    }
+
+    /// Number of recorded instructions.
+    pub fn len(&self) -> usize {
+        self.0.history().len()
+    }
+
+    /// `true` when no instructions have been recorded.
+    pub fn is_empty(&self) -> bool {
+        self.0.history().is_empty()
+    }
+}
+
+impl PartialEq for SessionRecording {
+    fn eq(&self, other: &Self) -> bool {
+        self.initial_state() == other.initial_state() && self.instructions() == other.instructions()
+    }
+}
+
+impl Eq for SessionRecording {}
+
+impl Serialize for SessionRecording {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        self.0.serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for SessionRecording {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        Session::deserialize(deserializer).map(Self)
+    }
+}
+
 impl GameState {
    /// Creates a new Classic-mode game dealt from the given seed and draw mode.
    pub fn new(seed: u64, draw_mode: DrawStockConfig) -> Self {
@@ -296,6 +409,44 @@ impl GameState {
        }
    }

+    /// Snapshot of the live session for replay persistence: the dealt board
+    /// plus the forward instruction history (undone moves are absent — the
+    /// session pops them). Serialise the returned [`SessionRecording`] with
+    /// the upstream `card_game` serializers; rebuild playback with
+    /// [`Self::from_recording`].
+    pub fn recording(&self) -> SessionRecording {
+        SessionRecording(self.session.clone())
+    }
+
+    /// Rebuilds the initial-deal game plus the ordered instruction list from
+    /// a [`SessionRecording`].
+    ///
+    /// The board and the session config (including draw mode) come from the
+    /// recording itself, so playback is independent of the current build's
+    /// seed→deal mapping. `seed` and `mode` are presentation metadata carried
+    /// alongside the recording by the replay file. Step through the returned
+    /// instructions with [`Self::apply_instruction`], which re-validates each
+    /// one and fails gracefully on corrupt input.
+    pub fn from_recording(
+        recording: &SessionRecording,
+        seed: u64,
+        mode: GameMode,
+    ) -> (Self, Vec<KlondikeInstruction>) {
+        let game = Self {
+            mode,
+            elapsed_seconds: 0,
+            seed,
+            take_from_foundation: true,
+            session: Session::new(
+                recording.initial_state().clone(),
+                recording.0.config().clone(),
+            ),
+            #[cfg(feature = "test-support")]
+            test_pile_state: None,
+        };
+        (game, recording.instructions())
+    }
+
    /// Whether the player draws one or three cards from the stock per turn.
    /// Derived from the underlying session config (set once at deal time).
    pub fn draw_mode(&self) -> DrawStockConfig {
@@ -339,6 +490,32 @@ impl GameState {
        self.session.stats().stats().recycle_count()
    }

+    /// Number of cards moved onto foundations this game, read from the
+    /// upstream session stats. Cumulative like [`Self::recycle_count`] —
+    /// not rolled back on undo.
+    pub fn move_to_foundation_count(&self) -> u32 {
+        self.session.stats().stats().move_to_foundation_count()
+    }
+
+    /// Number of stacks moved onto tableaus (from stock or another tableau)
+    /// this game, read from the upstream session stats. Cumulative — not
+    /// rolled back on undo.
+    pub fn move_to_tableau_count(&self) -> u32 {
+        self.session.stats().stats().move_to_tableau_count()
+    }
+
+    /// Number of cards taken back off a foundation this game, read from the
+    /// upstream session stats. Cumulative — not rolled back on undo.
+    pub fn move_from_foundation_count(&self) -> u32 {
+        self.session.stats().stats().move_from_foundation_count()
+    }
+
+    /// Number of face-down cards revealed (flipped up) this game, read from
+    /// the upstream session stats. Cumulative — not rolled back on undo.
+    pub fn flip_up_count(&self) -> u32 {
+        self.session.stats().stats().flip_up_bonus_count()
+    }
+
    /// Total moves made this game (draws, recycles, and card moves), derived
    /// from the session's instruction history length.
    pub fn move_count(&self) -> u32 {
@@ -402,16 +579,6 @@ impl GameState {
        KlondikeAdapter::config_for(self.draw_mode(), self.take_from_foundation)
    }

-    /// Collects the session instruction history as upstream types for schema v4
-    /// serialisation.
-    fn saved_moves(&self) -> Vec<KlondikeInstruction> {
-        self.session
-            .history()
-            .iter()
-            .map(|snapshot| *snapshot.instruction())
-            .collect()
-    }
-
    /// Returns the deterministic instruction history for the current deal as
    /// upstream [`KlondikeInstruction`] values.
    ///
@@ -1512,4 +1679,162 @@ mod tests {
        assert!(easy.is_err());
        assert!(matches!(medium, Ok(Some(_))));
    }
+
+    /// Play a few real moves on a fresh deal and return the game.
+    fn game_with_some_moves(seed: u64) -> GameState {
+        let mut game = GameState::new(seed, DrawStockConfig::DrawOne);
+        for _ in 0..40 {
+            let instructions = game.possible_instructions();
+            let applied = instructions
+                .into_iter()
+                .find(|i| game.clone().apply_instruction(*i).is_ok())
+                .and_then(|i| game.apply_instruction(i).ok());
+            if applied.is_none() && game.draw().is_err() {
+                break;
+            }
+        }
+        assert!(
+            !game.instruction_history().is_empty(),
+            "test needs at least one recorded move"
+        );
+        game
+    }
+
+    #[test]
+    fn recording_round_trips_through_upstream_serde() {
+        let game = game_with_some_moves(51);
+        let recording = game.recording();
+        let json = serde_json::to_string(&recording).expect("serialize recording");
+        let restored: SessionRecording = serde_json::from_str(&json).expect("parse recording");
+        assert_eq!(recording, restored);
+        assert_eq!(recording.instructions(), game.instruction_history());
+    }
+
+    #[test]
+    fn from_recording_replays_to_identical_board_without_seed_dealing() {
+        let game = game_with_some_moves(145);
+        let recording = game.recording();
+        let json = serde_json::to_string(&recording).expect("serialize recording");
+        let restored: SessionRecording = serde_json::from_str(&json).expect("parse recording");
+
+        // Deliberately pass a DIFFERENT seed: the board must come from the
+        // recording, proving playback no longer depends on seed→deal mapping.
+        let (mut replayed, instructions) =
+            GameState::from_recording(&restored, 0xDEAD_BEEF, game.mode);
+        assert_eq!(replayed.draw_mode(), game.draw_mode());
+        for instruction in instructions {
+            replayed
+                .apply_instruction(instruction)
+                .expect("recorded instruction must replay cleanly");
+        }
+        for pile in [KlondikePile::Stock]
+            .into_iter()
+            .chain(crate::TABLEAUS.map(KlondikePile::Tableau))
+            .chain(crate::FOUNDATIONS.map(KlondikePile::Foundation))
+        {
+            assert_eq!(
+                replayed.pile(pile),
+                game.pile(pile),
+                "pile {pile:?} differs"
+            );
+        }
+        assert_eq!(replayed.waste_cards(), game.waste_cards());
+        assert_eq!(replayed.move_count(), game.move_count());
+    }
+
+    /// v6 save files carry the deal in the recording; the `seed` field is
+    /// presentation metadata. Corrupting it must not change the loaded board.
+    #[test]
+    fn v6_save_load_ignores_seed_for_dealing() {
+        let game = game_with_some_moves(51);
+        let mut value = serde_json::to_value(&game).expect("serialise");
+        assert_eq!(value["schema_version"], 6);
+        value["seed"] = serde_json::Value::from(0xDEAD_BEEF_u64);
+        let loaded: GameState =
+            serde_json::from_value(value).expect("v6 save with wrong seed must still load");
+        assert_eq!(loaded.stock_cards(), game.stock_cards());
+        assert_eq!(loaded.waste_cards(), game.waste_cards());
+        for index in 0..7 {
+            let t = GameState::tableau_from_index(index).expect("tableau index");
+            assert_eq!(
+                loaded.pile(KlondikePile::Tableau(t)),
+                game.pile(KlondikePile::Tableau(t)),
+                "tableau {index} differs"
+            );
+        }
+        assert_eq!(loaded.move_count(), game.move_count());
+        assert_eq!(loaded.score(), game.score());
+    }
+
+    /// Legacy v5 files (seed + saved_moves, no recording) must still load
+    /// through the seed-dealt path until players resave as v6.
+    #[test]
+    fn v5_legacy_save_still_loads() {
+        let game = game_with_some_moves(145);
+        let v5 = serde_json::json!({
+            "draw_mode": game.draw_mode(),
+            "mode": game.mode,
+            "elapsed_seconds": 12,
+            "seed": game.seed,
+            "take_from_foundation": true,
+            "schema_version": 5,
+            "saved_moves": game.instruction_history(),
+        });
+        let loaded: GameState =
+            serde_json::from_value(v5).expect("v5 save must load via the legacy seed path");
+        assert_eq!(loaded.move_count(), game.move_count());
+        assert_eq!(loaded.stock_cards(), game.stock_cards());
+        assert_eq!(loaded.elapsed_seconds, 12);
+    }
+
+    /// A v6 file without the recording payload is malformed and must be
+    /// rejected with an error rather than silently re-dealt from the seed.
+    #[test]
+    fn v6_save_without_recording_is_rejected() {
+        let game = GameState::new(7, DrawStockConfig::DrawOne);
+        let mut value = serde_json::to_value(&game).expect("serialise");
+        value.as_object_mut().expect("object").remove("recording");
+        let err = serde_json::from_value::<GameState>(value)
+            .expect_err("v6 save without recording must fail");
+        assert!(err.to_string().contains("recording"), "got: {err}");
+    }
+
+    /// A recording whose instruction list is invalid for its own deal must
+    /// be rejected on load — tampered or corrupt files surface an error,
+    /// never a silently wrong board.
+    #[test]
+    fn v6_save_with_invalid_history_is_rejected() {
+        use klondike::{DstFoundation, Foundation, KlondikePile};
+        // A foundation move from an empty tableau is never legal on a fresh
+        // deal's first instruction slot for this source shape.
+        let bogus = KlondikeInstruction::DstFoundation(DstFoundation {
+            src: KlondikePile::Foundation(Foundation::Foundation1),
+            foundation: Foundation::Foundation2,
+        });
+        let recording =
+            SessionRecording::from_instructions_unchecked(7, DrawStockConfig::DrawOne, [bogus]);
+        let v6 = serde_json::json!({
+            "draw_mode": DrawStockConfig::DrawOne,
+            "mode": GameMode::Classic,
+            "elapsed_seconds": 0,
+            "seed": 7,
+            "take_from_foundation": true,
+            "schema_version": 6,
+            "recording": recording,
+        });
+        let err =
+            serde_json::from_value::<GameState>(v6).expect_err("invalid history must be rejected");
+        assert!(err.to_string().contains("invalid"), "got: {err}");
+    }
+
+    #[test]
+    fn from_recording_of_fresh_deal_returns_empty_instructions() {
+        let game = GameState::new(7, DrawStockConfig::DrawThree);
+        let recording = game.recording();
+        assert!(recording.is_empty());
+        let (replayed, instructions) = GameState::from_recording(&recording, 7, game.mode);
+        assert!(instructions.is_empty());
+        assert_eq!(replayed.stock_cards(), game.stock_cards());
+        assert_eq!(replayed.draw_mode(), DrawStockConfig::DrawThree);
+    }
 }
@@ -20,7 +20,9 @@ pub use klondike::{

 // Solvability check API (delegates to `card_game::Session::solve`); replaces the
 // former `solitaire_data::solver` wrapper module.
-pub use game_state::{DEFAULT_SOLVE_MOVES_BUDGET, DEFAULT_SOLVE_STATES_BUDGET, SolveOutcome};
+pub use game_state::{
+    DEFAULT_SOLVE_MOVES_BUDGET, DEFAULT_SOLVE_STATES_BUDGET, SessionRecording, SolveOutcome,
+};

 // Spider rules (second `card_game::Game` implementation; engine UI is a
 // later phase — nothing outside solitaire_core consumes these yet).
@@ -133,6 +133,12 @@ pub use challenge::{CHALLENGE_SEEDS, challenge_count, challenge_seed_for};
 pub mod difficulty_seeds;
 pub use difficulty_seeds::{DifficultySeeds, seeds_for};

+pub mod transfer;
+pub use transfer::{
+    BundleError, DATA_BUNDLE_SCHEMA_VERSION, DataBundle, data_bundle_path, load_bundle_from,
+    save_bundle_to,
+};
+
 pub mod settings;
 pub use settings::{
    AnimSpeed, REPLAY_MOVE_INTERVAL_STEP_SECS, SOLVER_DEAL_RETRY_CAP, Settings, SyncBackend,
@@ -12,22 +12,24 @@
 //! carries any other version so older replays are silently dropped instead
 //! of crashing the loader.
 //!
-//! The recording is intentionally minimal — only the
-//! [`KlondikeInstruction`](solitaire_core::KlondikeInstruction) inputs that
-//! successfully advanced the game. `Undo` is **not** recorded: a replay
-//! represents the canonical path the player ultimately took to win, so
-//! backed-out missteps simply do not appear in the move list. The starting
-//! deal is not stored either — the [`seed`](Replay::seed) +
-//! [`draw_mode`](Replay::draw_mode) + [`mode`](Replay::mode) are sufficient
-//! for `GameState::new_with_mode` to rebuild the identical layout.
+//! The payload is a [`SessionRecording`](solitaire_core::SessionRecording):
+//! the upstream `card_game` session serialisation, which stores the dealt
+//! board **explicitly** plus the ordered instruction list. `Undo` is not
+//! recorded: a replay represents the canonical path the player ultimately
+//! took to win, so backed-out missteps simply do not appear (the session
+//! pops them from its history).
+//!
+//! Storing the deal (rather than re-dealing from [`seed`](Replay::seed) at
+//! playback time, as schemas ≤ v3 did) makes replays immune to seed→deal
+//! mapping drift across RNG or upstream-crate upgrades — the exact failure
+//! that silently broke every pre-upgrade replay. `seed`, `draw_mode`, and
+//! `mode` remain as presentation/indexing metadata only.
 //!
 //! Each recorded move is the player's atomic *input*, not its outcome.
 //! `KlondikeInstruction::RotateStock` covers every click on the stock pile;
 //! the engine resolves draw-vs-recycle deterministically from the current
 //! stock state during playback, so the same input always produces the same
-//! effect on the same starting deal. Runtime-only pile-position types are
-//! never serialised — the instruction itself serialises via its compact
-//! upstream serde representation.
+//! effect on the same starting deal.

 use std::fs;
 use std::io;
@@ -35,7 +37,7 @@ use std::path::{Path, PathBuf};

 use chrono::NaiveDate;
 use serde::{Deserialize, Serialize};
-use solitaire_core::{DrawStockConfig, KlondikeInstruction, game_state::GameMode};
+use solitaire_core::{DrawStockConfig, SessionRecording, game_state::GameMode};

 const LATEST_REPLAY_FILE_NAME: &str = "latest_replay.json";
 const REPLAY_HISTORY_FILE_NAME: &str = "replays.json";
@@ -77,13 +79,19 @@ fn history_schema_v0() -> u32 {
 ///   variants which carried the *outcome* of a stock interaction rather
 ///   than the player's atomic input.
 /// - v2: `Draw` + `Recycle` collapsed into a single `StockClick` variant.
-/// - v3 (current): the bespoke `ReplayMove` serde mirror was dropped. Moves
-///   are now stored directly as upstream
-///   [`KlondikeInstruction`](solitaire_core::KlondikeInstruction) (compact
-///   int serde); `StockClick` is now `RotateStock`. Pile-position types are
-///   runtime-only and are never serialised. v1/v2 files fail to deserialise
-///   and are discarded by the loader.
-pub const REPLAY_SCHEMA_VERSION: u32 = 3;
+/// - v3: the bespoke `ReplayMove` serde mirror was dropped. Moves
+///   were stored directly as upstream `KlondikeInstruction` (compact
+///   int serde); `StockClick` became `RotateStock`. Pile-position types are
+///   runtime-only and are never serialised. The starting deal was still
+///   rebuilt from the seed at playback time.
+/// - v4 (current): the bare `moves` list was replaced by a
+///   [`SessionRecording`](solitaire_core::SessionRecording) — the upstream
+///   `card_game` session serialisation carrying the dealt board explicitly
+///   plus the instruction list. Playback no longer re-deals from the seed,
+///   so replays survive RNG/upstream upgrades that change the seed→deal
+///   mapping (which invalidated every v3 replay). v1–v3 files fail the
+///   version gate and are discarded by the loader.
+pub const REPLAY_SCHEMA_VERSION: u32 = 4;

 /// Default value for [`Replay::schema_version`] when deserialising files
 /// that pre-date the field. Any value other than [`REPLAY_SCHEMA_VERSION`]
@@ -94,9 +102,10 @@ fn schema_v0() -> u32 {

 /// A complete recording of a single winning game.
 ///
-/// Replays are reconstructed by rebuilding a fresh
-/// `GameState::new_with_mode(seed, draw_mode, mode)` and applying the
-/// [`moves`](Self::moves) in order. The presentation fields
+/// Replays are reconstructed via
+/// `GameState::from_recording(&replay.recording, replay.seed, replay.mode)`,
+/// which rebuilds the recorded deal directly and returns the instruction
+/// list to step through. The presentation fields
 /// ([`time_seconds`](Self::time_seconds), [`final_score`](Self::final_score),
 /// [`recorded_at`](Self::recorded_at)) drive the Stats UI caption such as
 /// "Replay (2:14 win on 2026-05-02)".
@@ -105,8 +114,9 @@ pub struct Replay {
    /// Schema version. See [`REPLAY_SCHEMA_VERSION`].
    #[serde(default = "schema_v0")]
    pub schema_version: u32,
-    /// Seed used for the deal — replay rasterises the deck via
-    /// `GameState::new_with_mode(seed, draw_mode, mode)`.
+    /// Seed the recorded game was originally dealt from. Presentation /
+    /// indexing metadata only — playback rebuilds the board from
+    /// [`recording`](Self::recording), never by re-dealing this seed.
    pub seed: u64,
    /// Draw mode the recorded game was played in.
    pub draw_mode: DrawStockConfig,
@@ -119,11 +129,10 @@ pub struct Replay {
    pub final_score: i32,
    /// ISO-8601 date the win was recorded.
    pub recorded_at: NaiveDate,
-    /// Ordered move list. Each entry is the atomic
-    /// [`KlondikeInstruction`](solitaire_core::KlondikeInstruction) the player
-    /// issued, replayable against a fresh `GameState` constructed from the
-    /// seed via `GameState::apply_instruction`.
-    pub moves: Vec<KlondikeInstruction>,
+    /// The dealt board plus the ordered instruction list, serialised via the
+    /// upstream `card_game` session serializers. Self-contained: playback
+    /// needs nothing else to reproduce the game move-for-move.
+    pub recording: SessionRecording,
    /// Public share URL for this replay on the active sync backend, set
    /// by `sync_plugin::poll_replay_upload_result` when the upload
    /// task resolves. `None` when the player won on a local-only
@@ -133,11 +142,12 @@ pub struct Replay {
    /// [`REPLAY_SCHEMA_VERSION`].
    #[serde(default)]
    pub share_url: Option<String>,
-    /// Index into [`moves`](Self::moves) of the move that triggered
-    /// the win condition (i.e. completed the last foundation pile).
+    /// Index into the [`recording`](Self::recording)'s instruction list
+    /// of the move that triggered the win condition (i.e. completed the
+    /// last foundation pile).
    ///
    /// For replays recorded by the live engine this is always
-    /// `Some(moves.len() - 1)` because recording freezes on win — but
+    /// `Some(recording.len() - 1)` because recording freezes on win — but
    /// the field is stored explicitly so the playback UI can read it
    /// directly without re-deriving "the last move was the win" each
    /// time, and to leave room for future recording semantics that
@@ -172,7 +182,7 @@ impl Replay {
        time_seconds: u64,
        final_score: i32,
        recorded_at: NaiveDate,
-        moves: Vec<KlondikeInstruction>,
+        recording: SessionRecording,
    ) -> Self {
        Self {
            schema_version: REPLAY_SCHEMA_VERSION,
@@ -182,7 +192,7 @@ impl Replay {
            time_seconds,
            final_score,
            recorded_at,
-            moves,
+            recording,
            share_url: None,
            win_move_index: None,
        }
@@ -193,7 +203,7 @@ impl Replay {
    /// [`Replay::new`]:
    ///
    /// ```ignore
-    /// let replay = Replay::new(...).with_win_move_index(Some(recording.moves.len() - 1));
+    /// let replay = Replay::new(...).with_win_move_index(recording.len().checked_sub(1));
    /// ```
    ///
    /// `None` is a valid input — useful for tests that don't care about
@@ -430,7 +440,8 @@ pub fn migrate_legacy_latest_replay(latest_path: &Path, history_path: &Path) {
 mod tests {
    use super::*;
    use klondike::{
-        DstFoundation, DstTableau, Foundation, KlondikePile, KlondikePileStack, Tableau,
+        DstFoundation, DstTableau, Foundation, KlondikeInstruction, KlondikePile,
+        KlondikePileStack, Tableau,
    };
    use std::env;

@@ -447,18 +458,22 @@ mod tests {
            134,
            5_120,
            date,
-            vec![
-                KlondikeInstruction::RotateStock,
-                KlondikeInstruction::DstTableau(DstTableau {
-                    src: KlondikePileStack::Stock,
-                    tableau: Tableau::Tableau4,
-                }),
-                KlondikeInstruction::RotateStock,
-                KlondikeInstruction::DstFoundation(DstFoundation {
-                    src: KlondikePile::Tableau(Tableau::Tableau4),
-                    foundation: Foundation::Foundation1,
-                }),
-            ],
+            SessionRecording::from_instructions_unchecked(
+                12345,
+                DrawStockConfig::DrawThree,
+                [
+                    KlondikeInstruction::RotateStock,
+                    KlondikeInstruction::DstTableau(DstTableau {
+                        src: KlondikePileStack::Stock,
+                        tableau: Tableau::Tableau4,
+                    }),
+                    KlondikeInstruction::RotateStock,
+                    KlondikeInstruction::DstFoundation(DstFoundation {
+                        src: KlondikePile::Tableau(Tableau::Tableau4),
+                        foundation: Foundation::Foundation1,
+                    }),
+                ],
+            ),
        )
    }

@@ -518,25 +533,22 @@ mod tests {
    /// rolling history wiped on the v0.19.0 update.
    #[test]
    fn replay_loads_when_share_url_field_is_absent() {
-        let pre_v019_json = format!(
-            r#"{{
-                "schema_version": {schema},
-                "seed": 1,
-                "draw_mode": "DrawOne",
-                "mode": "Classic",
-                "time_seconds": 60,
-                "final_score": 100,
-                "recorded_at": "2025-01-01",
-                "moves": []
-            }}"#,
-            schema = REPLAY_SCHEMA_VERSION,
-        );
-        let parsed: Replay = serde_json::from_str(&pre_v019_json)
-            .expect("pre-v0.19.0 replay JSON must still deserialise");
+        // Build a current-schema JSON object, then strip the optional
+        // fields to simulate a file written before they existed.
+        let mut value = serde_json::to_value(sample_replay()).expect("serialise sample");
+        let obj = value.as_object_mut().expect("replay serialises as object");
+        obj.remove("share_url");
+        obj.remove("win_move_index");
+        let parsed: Replay = serde_json::from_value(value)
+            .expect("replay JSON without optional fields must still deserialise");
        assert!(
            parsed.share_url.is_none(),
            "missing share_url field must default to None",
        );
+        assert!(
+            parsed.win_move_index.is_none(),
+            "missing win_move_index field must default to None",
+        );
    }

    /// Atomic-write contract — `.tmp` must not be left behind after
@@ -588,7 +600,11 @@ mod tests {
            60,
            id,
            date,
-            vec![KlondikeInstruction::RotateStock],
+            SessionRecording::from_instructions_unchecked(
+                id as u64,
+                DrawStockConfig::DrawOne,
+                [KlondikeInstruction::RotateStock],
+            ),
        )
    }

@@ -824,22 +840,14 @@ mod tests {
        let path = tmp_path("legacy_no_win_move_index");
        let _ = fs::remove_file(&path);

-        // Hand-rolled minimal current-schema replay JSON with no
-        // win_move_index field — the additive field must still default to None.
-        let no_field = format!(
-            r#"{{
-            "schema_version": {schema},
-            "seed": 1,
-            "draw_mode": "DrawOne",
-            "mode": "Classic",
-            "time_seconds": 60,
-            "final_score": 100,
-            "recorded_at": "2026-05-02",
-            "moves": []
-        }}"#,
-            schema = REPLAY_SCHEMA_VERSION,
-        );
-        fs::write(&path, no_field).expect("write fixture");
+        // Current-schema replay JSON with the win_move_index field stripped —
+        // the additive field must still default to None.
+        let mut value = serde_json::to_value(sample_replay()).expect("serialise sample");
+        value
+            .as_object_mut()
+            .expect("replay serialises as object")
+            .remove("win_move_index");
+        fs::write(&path, serde_json::to_string(&value).expect("to_string")).expect("write fixture");

        let loaded = load_latest_replay_from(&path).expect("load");
        assert_eq!(loaded.win_move_index, None);
@@ -9,7 +9,10 @@ use std::io;
 use std::path::{Path, PathBuf};

 use serde::{Deserialize, Serialize};
-use solitaire_core::{DrawStockConfig, game_state::DifficultyLevel};
+use solitaire_core::{
+    DrawStockConfig,
+    game_state::{DifficultyLevel, GameMode},
+};

 const SETTINGS_FILE_NAME: &str = "settings.json";

@@ -151,6 +154,14 @@ pub struct Settings {
    /// `#[serde(default)]`.
    #[serde(default)]
    pub reduce_motion_mode: bool,
+    /// When `true`, replaces translucent "glass" chrome (the floating
+    /// touch tab bar) with opaque fills so table content behind it can
+    /// never reduce label/icon contrast. The accessibility counterpart
+    /// of iOS "Reduce Transparency". Older `settings.json` files written
+    /// before this field existed deserialize cleanly to `false` thanks
+    /// to `#[serde(default)]`.
+    #[serde(default)]
+    pub reduce_transparency_mode: bool,
    /// Window size and screen position to restore on next launch. `None`
    /// means "use platform defaults" — set on first run, then populated
    /// as the player resizes / moves the window. Older `settings.json`
@@ -248,6 +259,38 @@ pub struct Settings {
    /// cleanly to `None` via `#[serde(default)]`.
    #[serde(default)]
    pub last_difficulty: Option<DifficultyLevel>,
+    /// Mode of the last game the player launched from the home overlay.
+    /// The home hero "New Game" button replays this mode with one tap.
+    /// Older `settings.json` files written before this field existed
+    /// deserialize cleanly to `GameMode::Classic` via `#[serde(default)]`.
+    #[serde(default)]
+    pub last_mode: GameMode,
+    /// The release version whose "What's new" card the player has already
+    /// seen (e.g. `"0.46.0"`). Empty on installs that predate the card,
+    /// which correctly reads as "there is news to show" after an upgrade;
+    /// fresh installs stamp it silently when onboarding completes. Older
+    /// `settings.json` files deserialize cleanly to `""` via
+    /// `#[serde(default)]`.
+    #[serde(default)]
+    pub last_seen_whats_new: String,
+    /// `true` once the one-shot "Stuck? Try a hint" contextual tip has
+    /// fired (or been suppressed as unnecessary). Phase I teach: fired
+    /// by the situation, shown once, like `shown_achievement_onboarding`.
+    #[serde(default)]
+    pub shown_stall_hint_tip: bool,
+    /// `true` once the one-shot radial-menu contextual tip has fired —
+    /// or the player has already opened the radial menu on their own,
+    /// which marks the tip as unnecessary without showing it.
+    #[serde(default)]
+    pub shown_radial_menu_tip: bool,
+    /// Global UI scale multiplier applied to all UI chrome (HUD, modals,
+    /// action bar) — the table itself stays window-fit via
+    /// `compute_layout`. Cycles through 0.9 / 1.0 / 1.15 / 1.3 in
+    /// Settings → Accessibility; clamped to `[UI_SCALE_MIN,
+    /// UI_SCALE_MAX]` by [`Settings::sanitized`]. Older `settings.json`
+    /// files deserialize cleanly to `1.0` via the serde default.
+    #[serde(default = "default_ui_scale")]
+    pub ui_scale: f32,
    /// Custom public name displayed on the leaderboard. When `None`, the
    /// player's server `username` is used instead. Trimmed to 32 characters
    /// before submission. Older `settings.json` files written before this
@@ -356,6 +399,16 @@ fn default_replay_move_interval_secs() -> f32 {
    0.45
 }

+/// Lowest / highest UI scale the settings row offers; anything outside
+/// (hand-edited settings.json) clamps here on load.
+pub const UI_SCALE_MIN: f32 = 0.9;
+/// See [`UI_SCALE_MIN`].
+pub const UI_SCALE_MAX: f32 = 1.3;
+
+fn default_ui_scale() -> f32 {
+    1.0
+}
+
 fn default_matomo_site_id() -> u32 {
    1
 }
@@ -406,6 +459,7 @@ impl Default for Settings {
            color_blind_mode: false,
            high_contrast_mode: false,
            reduce_motion_mode: false,
+            reduce_transparency_mode: false,
            window_geometry: None,
            selected_theme_id: default_theme_id(),
            shown_achievement_onboarding: false,
@@ -415,6 +469,11 @@ impl Default for Settings {
            disable_smart_default_size: false,
            replay_move_interval_secs: default_replay_move_interval_secs(),
            last_difficulty: None,
+            last_mode: GameMode::Classic,
+            last_seen_whats_new: String::new(),
+            shown_stall_hint_tip: false,
+            shown_radial_menu_tip: false,
+            ui_scale: default_ui_scale(),
            leaderboard_display_name: None,
            leaderboard_opted_in: false,
            take_from_foundation: true,
@@ -450,6 +509,7 @@ impl Settings {
            replay_move_interval_secs: self
                .replay_move_interval_secs
                .clamp(REPLAY_MOVE_INTERVAL_MIN_SECS, REPLAY_MOVE_INTERVAL_MAX_SECS),
+            ui_scale: self.ui_scale.clamp(UI_SCALE_MIN, UI_SCALE_MAX),
            selected_theme_id,
            ..self
        }
@@ -477,7 +477,7 @@ mod tests {
    /// again must reproduce byte-identical JSON. `undo_count` deliberately resets
    /// to 0 on load because only the forward instruction history is persisted.
    #[test]
-    fn game_state_v5_mid_game_round_trip() {
+    fn game_state_v6_mid_game_round_trip() {
        use solitaire_core::KlondikeInstruction;
        use solitaire_core::game_state::GameState;

@@ -518,11 +518,16 @@ mod tests {

        save_game_state_to(&path, &gs).expect("save");

-        // Verify the file carries the v5 schema marker.
+        // Verify the file carries the v6 schema marker and the recording.
        let json = fs::read_to_string(&path).expect("read json");
+        let parsed: serde_json::Value = serde_json::from_str(&json).expect("parse saved json");
+        assert_eq!(
+            parsed["schema_version"], 6,
+            "saved file must use schema version 6",
+        );
        assert!(
-            json.contains("\"schema_version\"") && json.contains('5'),
-            "saved file must use schema version 5",
+            parsed["recording"].is_object(),
+            "saved file must embed the session recording",
        );

        let loaded =
@@ -530,7 +535,7 @@ mod tests {

        // The forward instruction history round-trips, so the reconstructed board
        // re-serialises to byte-identical JSON.
-        let path_reload = gs_path("v5_mid_game_reload");
+        let path_reload = gs_path("v6_mid_game_reload");
        let _ = fs::remove_file(&path_reload);
        save_game_state_to(&path_reload, &loaded).expect("re-save loaded");
        assert_eq!(
@@ -19,6 +19,10 @@ use thiserror::Error;
 /// so downloading it is pure waste.
 pub const MAX_THEME_DOWNLOAD_BYTES: u64 = 20 * 1024 * 1024;

+/// Hard cap on a preview PNG download — previews are small decorative
+/// thumbnails; anything past this is a misconfigured server.
+pub const MAX_PREVIEW_BYTES: u64 = 512 * 1024;
+
 /// Errors surfaced by [`ThemeStoreClient`].
 #[derive(Debug, Error)]
 pub enum ThemeStoreError {
@@ -110,6 +114,42 @@ impl ThemeStoreClient {
        verify_archive(&bytes, entry)?;
        Ok(bytes.to_vec())
    }
+
+    /// Fetch the preview PNG the catalog advertises for `entry`.
+    ///
+    /// Returns `Http(404)` when the entry carries no `preview_url` —
+    /// the same shape the server answers with when the file is absent,
+    /// so callers only handle one "no preview" case. Previews are
+    /// decorative; unlike archives they carry no checksum, only the
+    /// [`MAX_PREVIEW_BYTES`] size cap.
+    pub async fn fetch_preview(
+        &self,
+        entry: &ThemeCatalogEntry,
+    ) -> Result<Vec<u8>, ThemeStoreError> {
+        let Some(path) = entry.preview_url.as_deref() else {
+            return Err(ThemeStoreError::Http(404));
+        };
+        let resp = self
+            .client
+            .get(format!("{}{}", self.base_url, path))
+            .send()
+            .await
+            .map_err(|e| ThemeStoreError::Network(e.to_string()))?;
+        if !resp.status().is_success() {
+            return Err(ThemeStoreError::Http(resp.status().as_u16()));
+        }
+        let bytes = resp
+            .bytes()
+            .await
+            .map_err(|e| ThemeStoreError::Network(e.to_string()))?;
+        if bytes.len() as u64 > MAX_PREVIEW_BYTES {
+            return Err(ThemeStoreError::Oversized {
+                expected: MAX_PREVIEW_BYTES,
+                got: bytes.len() as u64,
+            });
+        }
+        Ok(bytes.to_vec())
+    }
 }

 /// Checks downloaded `bytes` against the catalog `entry`'s declared
@@ -0,0 +1,137 @@
+//! Local data export/import (Phase M — sync transparency).
+//!
+//! Bundles every player-owned JSON save (settings, stats, achievements,
+//! progress) into one versioned backup file so a player can move their
+//! data between devices without an account, or keep a manual backup.
+//!
+//! The bundle deliberately excludes the in-progress game and the replay
+//! history: the former is transient, the latter can be large and is
+//! shareable through the replay upload path instead.
+
+use std::fs;
+use std::io;
+use std::path::{Path, PathBuf};
+
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+
+use crate::settings::Settings;
+use solitaire_sync::{AchievementRecord, PlayerProgress, StatsSnapshot};
+
+/// Bundle format version. Bump on any breaking shape change; the loader
+/// rejects newer versions rather than misreading them.
+pub const DATA_BUNDLE_SCHEMA_VERSION: u32 = 1;
+
+/// File name of the default backup location (next to the other saves).
+pub const DATA_BUNDLE_FILE_NAME: &str = "ferrous-solitaire-backup.json";
+
+/// One-file backup of every player-owned JSON save.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DataBundle {
+    /// Format version — see [`DATA_BUNDLE_SCHEMA_VERSION`].
+    pub schema_version: u32,
+    /// When the bundle was written.
+    pub exported_at: DateTime<Utc>,
+    pub settings: Settings,
+    pub stats: StatsSnapshot,
+    pub achievements: Vec<AchievementRecord>,
+    pub progress: PlayerProgress,
+}
+
+/// Why a bundle could not be loaded.
+#[derive(Debug, thiserror::Error)]
+pub enum BundleError {
+    #[error("could not read backup file: {0}")]
+    Io(#[from] io::Error),
+    #[error("backup file is not valid JSON: {0}")]
+    Parse(#[from] serde_json::Error),
+    #[error("backup was written by a newer app version (schema {found} > {supported})")]
+    UnsupportedVersion { found: u32, supported: u32 },
+}
+
+/// Default backup path: `<data dir>/<app dir>/ferrous-solitaire-backup.json`,
+/// or `None` when no data directory is available on this platform.
+pub fn data_bundle_path() -> Option<PathBuf> {
+    crate::data_dir().map(|d| d.join(crate::APP_DIR_NAME).join(DATA_BUNDLE_FILE_NAME))
+}
+
+/// Write `bundle` to `path` atomically (`.tmp` → rename), creating parent
+/// directories as needed. Mirrors the other save-file writers.
+pub fn save_bundle_to(path: &Path, bundle: &DataBundle) -> io::Result<()> {
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+    let json = serde_json::to_string_pretty(bundle).map_err(io::Error::other)?;
+    let tmp = path.with_extension("json.tmp");
+    fs::write(&tmp, json.as_bytes())?;
+    fs::rename(&tmp, path)?;
+    Ok(())
+}
+
+/// Read and validate a bundle from `path`. Unlike the per-file loaders this
+/// does NOT default-on-error — an import silently replacing player data
+/// with defaults would be destructive, so every failure is surfaced.
+pub fn load_bundle_from(path: &Path) -> Result<DataBundle, BundleError> {
+    let data = fs::read(path)?;
+    let bundle: DataBundle = serde_json::from_slice(&data)?;
+    if bundle.schema_version > DATA_BUNDLE_SCHEMA_VERSION {
+        return Err(BundleError::UnsupportedVersion {
+            found: bundle.schema_version,
+            supported: DATA_BUNDLE_SCHEMA_VERSION,
+        });
+    }
+    Ok(bundle)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn sample_bundle() -> DataBundle {
+        DataBundle {
+            schema_version: DATA_BUNDLE_SCHEMA_VERSION,
+            exported_at: Utc::now(),
+            settings: Settings::default(),
+            stats: StatsSnapshot {
+                games_played: 7,
+                ..Default::default()
+            },
+            achievements: vec![],
+            progress: PlayerProgress::default(),
+        }
+    }
+
+    #[test]
+    fn round_trips_through_disk() {
+        let dir = std::env::temp_dir().join(format!("bundle_test_{}", std::process::id()));
+        let path = dir.join(DATA_BUNDLE_FILE_NAME);
+        let bundle = sample_bundle();
+        save_bundle_to(&path, &bundle).expect("save should succeed");
+        let loaded = load_bundle_from(&path).expect("load should succeed");
+        assert_eq!(loaded.schema_version, DATA_BUNDLE_SCHEMA_VERSION);
+        assert_eq!(loaded.stats.games_played, 7);
+        let _ = fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn rejects_newer_schema() {
+        let dir = std::env::temp_dir().join(format!("bundle_test_v_{}", std::process::id()));
+        let path = dir.join(DATA_BUNDLE_FILE_NAME);
+        let mut bundle = sample_bundle();
+        bundle.schema_version = DATA_BUNDLE_SCHEMA_VERSION + 1;
+        save_bundle_to(&path, &bundle).expect("save should succeed");
+        assert!(matches!(
+            load_bundle_from(&path),
+            Err(BundleError::UnsupportedVersion { .. })
+        ));
+        let _ = fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn missing_file_is_an_io_error() {
+        assert!(matches!(
+            load_bundle_from(Path::new("/nonexistent/backup.json")),
+            Err(BundleError::Io(_))
+        ));
+    }
+}
@@ -67,6 +67,16 @@ pub struct AchievementsResource(pub Vec<AchievementRecord>);
 #[derive(Resource, Debug, Clone)]
 pub struct AchievementsStoragePath(pub Option<PathBuf>);

+/// Set wrapping the win-path achievement evaluator. It writes
+/// `AchievementsResource`/`ProgressResource` and emits unlock events; UI
+/// readers of those (HUD popovers, the stats/achievements panels) order
+/// themselves `.after(AchievementEval)`. The replay-completion evaluator is
+/// deliberately NOT a member: it runs after `AutoComplete`, and panel chains
+/// that need `.after(AchievementEval)` run before `AutoComplete` — putting
+/// both in one set would close an ordering cycle (#143).
+#[derive(bevy::ecs::schedule::SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct AchievementEval;
+
 pub struct AchievementPlugin {
    pub storage_path: Option<PathBuf>,
 }
@@ -119,9 +129,13 @@ impl Plugin for AchievementPlugin {
            .add_systems(
                Update,
                evaluate_on_win
+                    .in_set(AchievementEval)
                    .after(GameMutation)
                    .after(StatsUpdate)
-                    .after(ProgressUpdate),
+                    .after(ProgressUpdate)
+                    // The unlock/XP/level-up events it emits are drained by
+                    // the toast pipeline this frame (#143).
+                    .before(crate::animation_plugin::AnimFx),
            )
            // Achievement-onboarding cue: fires once after the player's very
            // first win to teach the Achievements panel exists. Must run
@@ -131,20 +145,50 @@ impl Plugin for AchievementPlugin {
                Update,
                fire_achievement_onboarding_toast
                    .after(GameMutation)
-                    .after(StatsUpdate),
+                    .after(StatsUpdate)
+                    .in_set(crate::game_plugin::InfoToastWriters)
+                    .ambiguous_with(crate::game_plugin::InfoToastWriters)
+                    // Writes the one-shot onboarding flag into
+                    // SettingsResource: board painters re-read settings, so
+                    // land the write first; UiTextFx members read disjoint
+                    // settings fields (reduce-motion), so writer/reader
+                    // order there is provably irrelevant (#143).
+                    .before(crate::card_plugin::BoardVisuals)
+                    .ambiguous_with(crate::ui_theme::UiTextFx)
+                    .in_set(crate::settings_plugin::SettingsAccess)
+                    .ambiguous_with(crate::settings_plugin::SettingsAccess),
            )
            // Open/close/tab handling moved to `you_hub_plugin`
            // (Phase E) — this plugin now owns body content + scroll.
-            .add_systems(Update, scroll_achievements_panel)
            .add_systems(
                Update,
-                crate::ui_modal::touch_scroll_panel::<AchievementsScrollable>,
+                scroll_achievements_panel
+                    .in_set(crate::ui_modal::PanelScroll)
+                    .ambiguous_with(crate::ui_modal::PanelScroll),
+            )
+            .add_systems(
+                Update,
+                crate::ui_modal::touch_scroll_panel::<AchievementsScrollable>
+                    .in_set(crate::ui_modal::PanelScroll)
+                    .ambiguous_with(crate::ui_modal::PanelScroll),
            )
            // Event-driven unlock: observe `ReplayPlaybackState` and unlock
            // `cinephile` the first time playback runs to natural completion.
            // Reads the resource via `Option<Res<_>>` so headless tests that
            // omit `ReplayPlaybackPlugin` still build.
-            .add_systems(Update, evaluate_cinephile_on_replay_completion);
+            .add_systems(
+                Update,
+                // Shares the unlock stream and AchievementsResource with
+                // evaluate_on_win; ordered after it and before the toast
+                // pipeline that drains the unlock events (#143).
+                evaluate_cinephile_on_replay_completion
+                    .after(evaluate_on_win)
+                    // The stats overlay's watch-replay button (ordered
+                    // before AutoComplete) writes ReplayPlaybackState this
+                    // system reads.
+                    .after(crate::auto_complete_plugin::AutoComplete)
+                    .before(crate::animation_plugin::AnimFx),
+            );
    }
 }

@@ -1343,7 +1387,9 @@ mod tests {

    use crate::replay_playback::ReplayPlaybackState;
    use chrono::NaiveDate;
-    use solitaire_core::{DrawStockConfig, KlondikeInstruction, game_state::GameMode};
+    use solitaire_core::{
+        DrawStockConfig, KlondikeInstruction, SessionRecording, game_state::GameMode,
+    };
    use solitaire_data::Replay;

    /// Headless app variant that injects a default `ReplayPlaybackState`
@@ -1364,7 +1410,11 @@ mod tests {
            10,
            100,
            NaiveDate::from_ymd_opt(2026, 5, 5).expect("valid date"),
-            vec![KlondikeInstruction::RotateStock],
+            SessionRecording::from_instructions_unchecked(
+                1,
+                DrawStockConfig::DrawOne,
+                [KlondikeInstruction::RotateStock],
+            ),
        )
    }

@@ -1408,12 +1458,8 @@ mod tests {

        // Frame 1: enter Playing. The observer's first sample sees
        // `last_was_playing = false` and `now_playing = true`.
-        *app.world_mut().resource_mut::<ReplayPlaybackState>() = ReplayPlaybackState::Playing {
-            replay: dummy_replay(),
-            cursor: 0,
-            secs_to_next: 0.0,
-            paused: false,
-        };
+        *app.world_mut().resource_mut::<ReplayPlaybackState>() =
+            ReplayPlaybackState::playing(dummy_replay(), 0, 0.0, false);
        app.update();
        assert!(
            !cinephile_unlocked(&app),
@@ -1442,12 +1488,8 @@ mod tests {
    fn cinephile_does_not_unlock_on_stop_button_abort() {
        let mut app = cinephile_app();

-        *app.world_mut().resource_mut::<ReplayPlaybackState>() = ReplayPlaybackState::Playing {
-            replay: dummy_replay(),
-            cursor: 0,
-            secs_to_next: 0.0,
-            paused: false,
-        };
+        *app.world_mut().resource_mut::<ReplayPlaybackState>() =
+            ReplayPlaybackState::playing(dummy_replay(), 0, 0.0, false);
        app.update();

        // Direct Playing → Inactive — the path the Stop button takes via
@@ -1473,12 +1515,8 @@ mod tests {
        let mut app = cinephile_app();

        // First completion cycle to unlock.
-        *app.world_mut().resource_mut::<ReplayPlaybackState>() = ReplayPlaybackState::Playing {
-            replay: dummy_replay(),
-            cursor: 0,
-            secs_to_next: 0.0,
-            paused: false,
-        };
+        *app.world_mut().resource_mut::<ReplayPlaybackState>() =
+            ReplayPlaybackState::playing(dummy_replay(), 0, 0.0, false);
        app.update();
        *app.world_mut().resource_mut::<ReplayPlaybackState>() = ReplayPlaybackState::Completed;
        app.update();
@@ -1496,12 +1534,8 @@ mod tests {
        // Second cycle: Inactive → Playing → Completed once more.
        *app.world_mut().resource_mut::<ReplayPlaybackState>() = ReplayPlaybackState::Inactive;
        app.update();
-        *app.world_mut().resource_mut::<ReplayPlaybackState>() = ReplayPlaybackState::Playing {
-            replay: dummy_replay(),
-            cursor: 0,
-            secs_to_next: 0.0,
-            paused: false,
-        };
+        *app.world_mut().resource_mut::<ReplayPlaybackState>() =
+            ReplayPlaybackState::playing(dummy_replay(), 0, 0.0, false);
        app.update();
        *app.world_mut().resource_mut::<ReplayPlaybackState>() = ReplayPlaybackState::Completed;
        app.update();
@@ -1520,12 +1554,8 @@ mod tests {
    fn cinephile_fires_once_across_completed_linger() {
        let mut app = cinephile_app();

-        *app.world_mut().resource_mut::<ReplayPlaybackState>() = ReplayPlaybackState::Playing {
-            replay: dummy_replay(),
-            cursor: 0,
-            secs_to_next: 0.0,
-            paused: false,
-        };
+        *app.world_mut().resource_mut::<ReplayPlaybackState>() =
+            ReplayPlaybackState::playing(dummy_replay(), 0, 0.0, false);
        app.update();
        *app.world_mut().resource_mut::<ReplayPlaybackState>() = ReplayPlaybackState::Completed;
        app.update();
@@ -29,7 +29,9 @@ use crate::events::{
 use crate::game_plugin::GameMutation;
 use crate::layout::LayoutResource;
 use crate::pause_plugin::PausedResource;
+use crate::platform::USE_TOUCH_UI_LAYOUT;
 use crate::progress_plugin::LevelUpEvent;
+use crate::safe_area::SafeAreaAnchoredBottom;
 use crate::settings_plugin::{SettingsChangedEvent, SettingsResource};
 use crate::time_attack_plugin::TimeAttackEndedEvent;
 use crate::ui_theme::{
@@ -160,9 +162,82 @@ pub struct ActiveToast {
 /// Duration of each queued info-toast in seconds.
 const QUEUED_TOAST_SECS: f32 = 2.5;

+/// Marker on the persistent bottom-anchored flex column every toast
+/// spawns into (Phase H). Stacking through one container gives queued
+/// and immediate toasts a single shared anchor — simultaneous toasts
+/// stack upward instead of relying on the old staggered-percentage
+/// anchors to dodge each other.
+#[derive(Component, Debug)]
+pub struct ToastStackRoot;
+
+/// Marker on every toast card node (both paths). Freshly spawned toasts
+/// start `Visibility::Hidden` and unparented; [`adopt_toasts_into_stack`]
+/// re-parents them under [`ToastStackRoot`] and reveals them — one frame
+/// of latency, imperceptible at toast timescales, in exchange for the 14
+/// toast handlers keeping their `Commands`-only signatures.
+#[derive(Component, Debug)]
+pub struct ToastNode;
+
+/// Logical-pixel gap between the screen bottom and the toast stack,
+/// before safe-area insets. Clears the floating glass tab bar on touch
+/// (its margin + height + breathing room); desktop's docked bar needs less.
+const TOAST_STACK_BASE_BOTTOM_PX: f32 = if USE_TOUCH_UI_LAYOUT {
+    crate::hud_plugin::tab_bar::TAB_BAR_CLEARANCE_PX
+} else {
+    72.0
+};
+
+/// Spawns the persistent [`ToastStackRoot`] container at startup.
+fn spawn_toast_stack_root(mut commands: Commands) {
+    commands.spawn((
+        ToastStackRoot,
+        Node {
+            position_type: PositionType::Absolute,
+            bottom: Val::Px(TOAST_STACK_BASE_BOTTOM_PX),
+            left: Val::Px(0.0),
+            width: Val::Percent(100.0),
+            // Newest toast sits nearest the bottom edge; older ones
+            // push upward.
+            flex_direction: FlexDirection::ColumnReverse,
+            align_items: AlignItems::Center,
+            row_gap: VAL_SPACE_2,
+            ..default()
+        },
+        SafeAreaAnchoredBottom {
+            base_bottom: TOAST_STACK_BASE_BOTTOM_PX,
+        },
+        ZIndex(Z_TOAST),
+    ));
+}
+
+/// Re-parents freshly spawned [`ToastNode`]s under the stack root and
+/// reveals them. No-op when every toast is already adopted.
+fn adopt_toasts_into_stack(
+    mut commands: Commands,
+    orphans: Query<Entity, (With<ToastNode>, Without<ChildOf>)>,
+    root: Query<Entity, With<ToastStackRoot>>,
+) {
+    let Ok(root) = root.single() else {
+        return;
+    };
+    for toast in &orphans {
+        commands
+            .entity(toast)
+            .insert((ChildOf(root), Visibility::Inherited));
+    }
+}
+
 /// Drives all linear card animations (`CardAnim`), toast notifications, deal stagger, win cascade, and the auto-complete card-slide sequence.
 pub struct AnimationPlugin;

+/// Set wrapping this plugin's Update chain (card slide/cascade animation and
+/// the toast pipeline). Ordered after [`crate::card_animation::CardTweenFx`]
+/// on the shared visual spine — members write card `Transform`s, which every
+/// other painter set also touches — and after the toast/stat/progress writer
+/// sets so the toast handlers drain this frame's events (#143).
+#[derive(bevy::ecs::schedule::SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct AnimFx;
+
 impl Plugin for AnimationPlugin {
    fn build(&self, app: &mut App) {
        // Register the events this plugin consumes so tests that don't include
@@ -185,13 +260,37 @@ impl Plugin for AnimationPlugin {
            .init_resource::<EffectiveSlideDuration>()
            .init_resource::<ToastQueue>()
            .init_resource::<ActiveToast>()
-            .add_systems(Startup, init_slide_duration)
+            .add_systems(Startup, (init_slide_duration, spawn_toast_stack_root))
+            .configure_sets(
+                Update,
+                AnimFx
+                    // Visual spine: …BoardVisuals < MarkerVisuals <
+                    // CardTweenFx < AnimFx < FeedbackFx (#143). GameMutation
+                    // ordering is inherited transitively.
+                    .after(crate::card_animation::CardTweenFx)
+                    .after(crate::table_plugin::MarkerVisuals)
+                    // Stats/progress must settle before the win/level-up
+                    // toast handlers read their events. (No edge against
+                    // InfoToastWriters: toast writers exist on both sides
+                    // of this set — enqueue_toasts drains via cursor and
+                    // joins the club instead; a toast surfacing one frame
+                    // later is invisible.)
+                    .after(crate::stats_plugin::StatsUpdate)
+                    .after(crate::progress_plugin::ProgressUpdate)
+                    .after(GameMutation)
+                    // HUD text pulses are disjoint from the card entities
+                    // this set animates (see UiTextFx × BoardVisuals, #143).
+                    .ambiguous_with(crate::ui_theme::UiTextFx),
+            )
            .add_systems(
                Update,
                (
                    advance_card_anims,
-                    sync_slide_duration,
-                    handle_win_cascade,
+                    // Both drain SettingsChangedEvent / read anim-speed
+                    // fields via cursor; a home deal-option edit surfacing
+                    // one frame later is invisible (#143).
+                    sync_slide_duration.ambiguous_with(crate::settings_plugin::SettingsAccess),
+                    handle_win_cascade.ambiguous_with(crate::settings_plugin::SettingsAccess),
                    handle_achievement_toast,
                    handle_levelup_toast,
                    handle_daily_goal_announcement_toast,
@@ -199,15 +298,23 @@ impl Plugin for AnimationPlugin {
                    handle_weekly_toast,
                    handle_time_attack_toast,
                    handle_challenge_toast,
-                    handle_settings_toast,
+                    handle_settings_toast.ambiguous_with(crate::settings_plugin::SettingsAccess),
                    handle_auto_complete_toast,
                    handle_xp_awarded_toast,
                    handle_move_rejected_toast,
                    handle_warning_toast,
                    tick_toasts,
-                    (enqueue_toasts, drive_toast_display).chain(),
+                    (
+                        enqueue_toasts
+                            .in_set(crate::game_plugin::InfoToastWriters)
+                            .ambiguous_with(crate::game_plugin::InfoToastWriters),
+                        drive_toast_display,
+                    )
+                        .chain(),
+                    adopt_toasts_into_stack,
                )
-                    .after(GameMutation),
+                    .chain()
+                    .in_set(AnimFx),
            );
    }
 }
@@ -637,26 +744,14 @@ impl ToastVariant {
    }
 }

-/// Spawns a bottom-anchored `ToastEntity` for the queued toast system.
+/// Spawns a `ToastEntity` for the queued toast system.
 ///
 /// Queued toasts always carry [`ToastVariant::Info`] — the queue is fed
 /// by [`InfoToastEvent`] which is by definition neutral system info.
 /// Variants other than `Info` belong on the immediate-fire path
 /// ([`spawn_toast`]) where the call site knows the semantic intent.
 fn spawn_queued_toast(commands: &mut Commands, message: String) -> Entity {
-    spawn_toast_node(
-        commands,
-        ToastEntity,
-        message,
-        ToastVariant::Info,
-        // Slightly taller anchor than the immediate-fire path so a
-        // queued info banner doesn't collide with a celebration toast
-        // fired in the same frame.
-        Val::Percent(6.0),
-        Val::Percent(15.0),
-        Val::Percent(70.0),
-        UiRect::axes(VAL_SPACE_4, VAL_SPACE_2),
-    )
+    spawn_toast_node(commands, ToastEntity, message, ToastVariant::Info)
 }

 fn handle_xp_awarded_toast(mut commands: Commands, mut events: MessageReader<XpAwardedEvent>) {
@@ -744,12 +839,6 @@ fn spawn_toast(
        (ToastOverlay, ToastTimer(duration_secs)),
        message,
        variant,
-        // Sits above the queued banner so a celebration toast spawned
-        // alongside a queued info message remains readable.
-        Val::Percent(14.0),
-        Val::Percent(25.0),
-        Val::Percent(50.0),
-        UiRect::axes(VAL_SPACE_4, VAL_SPACE_3),
    );
 }

@@ -766,31 +855,25 @@ fn spawn_toast(
 ///   rungs; 18 is the closest rung that preserves the scale invariants
 ///   tested in `ui_theme::tests`.
 /// - [`RADIUS_MD`] corners.
-/// - Bottom-anchored absolute position; `bottom_pct` differs between
-///   queued and immediate paths so they layer instead of overlap.
-// The 8-argument signature is intentional — these are the per-toast
-// layout values that genuinely differ between the queued and fire-and-
-// forget call sites. A struct wrapper would just rename the same data.
-#[allow(clippy::too_many_arguments)]
+///
+/// Layout is owned by [`ToastStackRoot`] (Phase H): the node spawns
+/// hidden and unpositioned, and [`adopt_toasts_into_stack`] slots it
+/// into the shared bottom-anchored column — one anchor for every toast,
+/// simultaneous toasts stack instead of overlapping.
 fn spawn_toast_node<B: Bundle>(
    commands: &mut Commands,
    bundle: B,
    message: String,
    variant: ToastVariant,
-    bottom_pct: Val,
-    left_pct: Val,
-    width_pct: Val,
-    padding: UiRect,
 ) -> Entity {
    commands
        .spawn((
            bundle,
+            ToastNode,
+            Visibility::Hidden,
            Node {
-                position_type: PositionType::Absolute,
-                left: left_pct,
-                bottom: bottom_pct,
-                width: width_pct,
-                padding,
+                max_width: Val::Percent(70.0),
+                padding: UiRect::axes(VAL_SPACE_4, VAL_SPACE_3),
                justify_content: JustifyContent::Center,
                align_items: AlignItems::Center,
                border: UiRect::all(Val::Px(1.0)),
@@ -799,7 +882,6 @@ fn spawn_toast_node<B: Bundle>(
            },
            BackgroundColor(BG_ELEVATED),
            BorderColor::all(variant.border_color()),
-            ZIndex(Z_TOAST),
        ))
        .with_children(|b| {
            b.spawn((
@@ -1315,4 +1397,85 @@ mod tests {
    fn cascade_duration_instant_is_zero() {
        assert_eq!(cascade_duration_secs(AnimSpeed::Instant), 0.0);
    }
+
+    // -----------------------------------------------------------------------
+    // Phase H: unified toast stack
+    // -----------------------------------------------------------------------
+
+    /// Both toast paths must end up as visible children of the single
+    /// [`ToastStackRoot`] — the Phase H "one anchor" contract.
+    #[test]
+    fn queued_and_immediate_toasts_stack_under_one_root() {
+        let mut app = App::new();
+        app.add_plugins(MinimalPlugins).add_plugins(AnimationPlugin);
+        app.update(); // Startup: spawns the stack root.
+
+        // One immediate (error) toast + one queued (info) toast in the
+        // same frame — the exact collision case the old staggered
+        // anchors existed to dodge.
+        use solitaire_core::{KlondikePile, Tableau};
+        app.world_mut().write_message(MoveRejectedEvent {
+            from: KlondikePile::Tableau(Tableau::Tableau1),
+            to: KlondikePile::Tableau(Tableau::Tableau2),
+            count: 1,
+        });
+        app.world_mut()
+            .write_message(InfoToastEvent("stacked info".to_string()));
+        app.update(); // handlers spawn both toasts (hidden, unparented)
+        app.update(); // adopt_toasts_into_stack re-parents + reveals
+
+        let root = app
+            .world_mut()
+            .query_filtered::<Entity, With<ToastStackRoot>>()
+            .single(app.world())
+            .expect("exactly one ToastStackRoot must exist");
+
+        let toasts: Vec<(Entity, &ChildOf, &Visibility)> = app
+            .world_mut()
+            .query_filtered::<(Entity, &ChildOf, &Visibility), With<ToastNode>>()
+            .iter(app.world())
+            .collect();
+        assert_eq!(
+            toasts.len(),
+            2,
+            "both the immediate and the queued toast must be adopted"
+        );
+        for (entity, child_of, visibility) in toasts {
+            assert_eq!(
+                child_of.parent(),
+                root,
+                "toast {entity} must be a child of the shared stack root"
+            );
+            assert_eq!(
+                *visibility,
+                Visibility::Inherited,
+                "adopted toast {entity} must be revealed"
+            );
+        }
+    }
+
+    /// Toast nodes must not carry their own absolute positioning — the
+    /// stack root owns layout (regression guard against reintroducing
+    /// per-path anchors).
+    #[test]
+    fn toast_nodes_have_no_absolute_position() {
+        let mut app = App::new();
+        app.add_plugins(MinimalPlugins).add_plugins(AnimationPlugin);
+        app.update();
+
+        app.world_mut()
+            .write_message(WarningToastEvent("layout check".to_string()));
+        app.update();
+
+        let node = app
+            .world_mut()
+            .query_filtered::<&Node, With<ToastNode>>()
+            .single(app.world())
+            .expect("warning toast must spawn a ToastNode");
+        assert_eq!(
+            node.position_type,
+            PositionType::Relative,
+            "toast nodes are flex children of the stack, not absolute overlays"
+        );
+    }
 }
@@ -0,0 +1,127 @@
+//! SVG builders for the floating tab bar's action icons.
+//!
+//! The touch tab bar (`hud_plugin::tab_bar`) is icon-first, but the bundled
+//! FiraMono face has no icon glyphs (and the Geometric Shapes block U+25xx
+//! is missing on Android entirely), so the icons are authored here as tiny
+//! stroke-based SVGs and rasterised through the same `usvg`/`resvg` pipeline
+//! as the card themes (`assets::rasterize_svg`).
+//!
+//! Icons are drawn in **white** on a transparent background inside a
+//! 24-unit logical box; the spawn site tints them to the theme colour via
+//! `ImageNode::color` (a per-node multiply), so one texture serves every
+//! button state.
+
+use bevy::image::Image;
+use bevy::math::UVec2;
+
+use super::svg_loader::{SvgLoaderError, rasterize_svg};
+
+/// Rasterisation size for one tab-bar icon texture. Icons display at
+/// 24 logical px; 96 px texels keep them crisp at the Fold's 1.2 scale
+/// factor (and any future 3× phone) while staying trivially small.
+pub const HUD_ICON_TEXTURE_PX: u32 = 96;
+
+/// The five actions the floating touch tab bar can show.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum HudIcon {
+    /// Counter-clockwise "take back" arrow.
+    Undo,
+    /// Two offset card outlines — draw from the stock.
+    Draw,
+    /// Lightbulb — highlight a suggested move.
+    Hint,
+    /// Two vertical bars.
+    Pause,
+    /// Three-line hamburger — the floating menu button.
+    Menu,
+}
+
+impl HudIcon {
+    /// Build the icon's SVG document. All icons share one visual language:
+    /// 2-unit white strokes, round caps, transparent fill, 24-unit box.
+    pub fn svg(self) -> String {
+        let body = match self {
+            // Arrow head pointing left into a half-circle sweeping back
+            // over the top — the conventional undo mark.
+            HudIcon::Undo => concat!(
+                r##"<path d="M 8 5 L 4 9 L 8 13"/>"##,
+                r##"<path d="M 4 9 H 14 A 5.5 5.5 0 0 1 14 20 H 8"/>"##,
+            ),
+            // Back card peeks out behind the front card; the front card is
+            // drawn second so its stroke reads on top.
+            HudIcon::Draw => concat!(
+                r##"<rect x="8.5" y="3" width="11" height="15" rx="2"/>"##,
+                r##"<rect x="4" y="6.5" width="11" height="15" rx="2"/>"##,
+            ),
+            // Bulb dome with a flat lamp base beneath.
+            HudIcon::Hint => concat!(
+                r##"<path d="M 9 15.5 A 6.5 6.5 0 1 1 15 15.5 V 18 H 9 Z"/>"##,
+                r##"<path d="M 10 21 H 14"/>"##,
+            ),
+            HudIcon::Pause => concat!(
+                r##"<path d="M 9 6 V 18"/>"##,
+                r##"<path d="M 15 6 V 18"/>"##,
+            ),
+            HudIcon::Menu => concat!(
+                r##"<path d="M 4 6.5 H 20"/>"##,
+                r##"<path d="M 4 12 H 20"/>"##,
+                r##"<path d="M 4 17.5 H 20"/>"##,
+            ),
+        };
+        format!(
+            concat!(
+                r##"<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24">"##,
+                r##"<g fill="none" stroke="#ffffff" stroke-width="2" "##,
+                r##"stroke-linecap="round" stroke-linejoin="round">{body}</g>"##,
+                r##"</svg>"##,
+            ),
+            body = body
+        )
+    }
+
+    /// Rasterise this icon into a Bevy [`Image`] at
+    /// [`HUD_ICON_TEXTURE_PX`] square.
+    pub fn rasterize(self) -> Result<Image, SvgLoaderError> {
+        rasterize_svg(self.svg().as_bytes(), UVec2::splat(HUD_ICON_TEXTURE_PX))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const ALL: [HudIcon; 5] = [
+        HudIcon::Undo,
+        HudIcon::Draw,
+        HudIcon::Hint,
+        HudIcon::Pause,
+        HudIcon::Menu,
+    ];
+
+    /// Every icon must survive the real usvg/resvg pipeline at the real
+    /// texture size — a malformed path here would otherwise only surface
+    /// as a blank button on device.
+    #[test]
+    fn every_icon_rasterizes_at_texture_size() {
+        for icon in ALL {
+            let img = icon.rasterize().expect("icon SVG must rasterise");
+            assert_eq!(img.width(), HUD_ICON_TEXTURE_PX, "{icon:?} width");
+            assert_eq!(img.height(), HUD_ICON_TEXTURE_PX, "{icon:?} height");
+        }
+    }
+
+    /// Rasterised icons must contain visible (non-transparent) pixels —
+    /// guards against a stroke accidentally drawn outside the viewBox.
+    #[test]
+    fn every_icon_has_visible_pixels() {
+        for icon in ALL {
+            let img = icon.rasterize().expect("icon SVG must rasterise");
+            let data = img.data.as_ref().expect("rasterised image has data");
+            let opaque = data.chunks_exact(4).filter(|px| px[3] > 0).count();
+            assert!(
+                opaque > 100,
+                "{icon:?} renders only {opaque} visible pixels"
+            );
+        }
+    }
+}
@@ -5,6 +5,7 @@
 //! custom `AssetSource` implementations used by the theme system.

 pub mod card_face_svg;
+pub mod hud_icon_svg;
 pub mod icon_svg;
 pub mod sources;
 pub mod svg_loader;
@@ -201,27 +201,6 @@ pub(crate) fn advance_card_animations(
    }
 }

-// ---------------------------------------------------------------------------
-// Win cascade
-// ---------------------------------------------------------------------------
-
-/// Win-cascade scatter targets — 8 points beyond the window edges.
-///
-/// Scaled by `radius` (pass `layout.card_size.x * 8.0` for a good result).
-pub fn win_scatter_targets(radius: f32) -> [Vec2; 8] {
-    let r = radius;
-    [
-        Vec2::new(r, r),
-        Vec2::new(-r, r),
-        Vec2::new(r, -r),
-        Vec2::new(-r, -r),
-        Vec2::new(0.0, r),
-        Vec2::new(0.0, -r),
-        Vec2::new(r, 0.0),
-        Vec2::new(-r, 0.0),
-    ]
-}
-
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -304,21 +283,4 @@ mod tests {
            .with_z_lift(12.0);
        assert!((anim.z_lift - 12.0).abs() < 1e-6);
    }
-
-    #[test]
-    fn win_scatter_has_eight_targets() {
-        let targets = win_scatter_targets(800.0);
-        assert_eq!(targets.len(), 8);
-    }
-
-    #[test]
-    fn win_scatter_targets_are_off_center() {
-        for t in win_scatter_targets(400.0) {
-            let dist = t.length();
-            assert!(
-                dist > 100.0,
-                "scatter target should be well off-center: {t:?}"
-            );
-        }
-    }
 }
@@ -31,16 +31,6 @@
 //! ));
 //! ```
 //!
-//! # Win cascade with `Expressive` curve
-//!
-//! The existing `AnimationPlugin` drives the win cascade with `CardAnim`
-//! (linear). To use the curve-based cascade instead, disable
-//! `handle_win_cascade` in `AnimationPlugin` and register `WinCascadePlugin`
-//! (declared below) which uses `CardAnimation` + `MotionCurve::Expressive`.
-//!
-//! They **must not both be active** — both write to `Transform` on the same
-//! 52 entities and will race.
-//!
 //! # Coexistence rules
 //!
 //! | Condition | Safe? |
@@ -58,24 +48,21 @@ pub mod interaction;
 pub mod timing;
 pub mod tuning;

-pub use animation::{CardAnimation, win_scatter_targets};
+pub use animation::CardAnimation;
 pub use chain::AnimationChain;
 pub use curves::{MotionCurve, sample_curve};
 pub use diagnostics::{FrameTimeDiagnostics, WINDOW_SIZE as DIAG_WINDOW_SIZE};
 pub use interaction::{BufferedInput, HoverState, InputBuffer};
 pub use timing::{
-    DEAL_INTERVAL_SECS, MAX_DURATION_SECS, MIN_DURATION_SECS, WIN_CASCADE_INTERVAL_SECS,
-    cascade_delay, compute_duration, micro_vary,
+    DEAL_INTERVAL_SECS, MAX_DURATION_SECS, MIN_DURATION_SECS, compute_duration, micro_vary,
 };
 pub use tuning::{AnimationTuning, InputPlatform};

 use bevy::prelude::*;
 use bevy::window::RequestRedraw;

-use crate::card_plugin::CardEntity;
 use crate::events::{DrawRequestEvent, GameWonEvent, MoveRequestEvent, UndoRequestEvent};
 use crate::game_plugin::GameMutation;
-use crate::layout::LayoutResource;
 use crate::resources::DragState;

 use animation::advance_card_animations;
@@ -96,6 +83,14 @@ use tuning::update_input_platform;
 /// long as no single entity carries both `CardAnim` and `CardAnimation`.
 pub struct CardAnimationPlugin;

+/// Set wrapping this plugin's Update chain (curve tweens, hover/drag
+/// visuals). First anim stage on the visual spine: …BoardVisuals <
+/// MarkerVisuals < CardTweenFx < [`crate::animation_plugin::AnimFx`] <
+/// FeedbackFx — members write card `Transform`s, which every other painter
+/// set also touches (#143).
+#[derive(bevy::ecs::schedule::SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct CardTweenFx;
+
 impl Plugin for CardAnimationPlugin {
    fn build(&self, app: &mut App) {
        // Register events and resources idempotently — double-registration is
@@ -128,7 +123,14 @@ impl Plugin for CardAnimationPlugin {
                    // still present in the same frame it was removed (deferred
                    // commands aren't applied until the next ApplyDeferred
                    // point), causing a 1-frame gap between every chain step.
-                    ApplyDeferred,
+                    //
+                    // `ambiguous_with_all`: an explicit sync point conflicts
+                    // (on `World`) with every unordered system in the
+                    // schedule. Only the flush of THIS chain's commands needs
+                    // ordering — the chain edges provide that; whether an
+                    // unrelated system's commands flush here or at the next
+                    // sync point is immaterial to it (#143).
+                    ApplyDeferred.ambiguous_with_all(),
                    // After each animation finishes, pop the next chain segment.
                    advance_animation_chains,
                    // Interaction visuals (run after animation for final positions).
@@ -136,68 +138,25 @@ impl Plugin for CardAnimationPlugin {
                    apply_hover_scale,
                    apply_drag_visual,
                    // Drain buffered inputs only when no animations remain.
-                    drain_input_buffer,
+                    // It re-emits buffered undo/new-game requests, so it
+                    // joins the self-ambiguous writer clubs (#143).
+                    drain_input_buffer
+                        .in_set(crate::game_plugin::UndoRequestWriters)
+                        .ambiguous_with(crate::game_plugin::UndoRequestWriters),
                )
                    .chain()
-                    .after(GameMutation),
-            );
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Optional: win cascade with Expressive curve
-// ---------------------------------------------------------------------------
-
-/// Optional plugin that replaces the linear win cascade in `AnimationPlugin`
-/// with an `Expressive`-curve cascade.
-///
-/// **Do not register this alongside `AnimationPlugin`'s win cascade** — they
-/// will race on the same card entities. To use this plugin, prevent
-/// `AnimationPlugin` from handling `GameWonEvent` (or remove it and manage
-/// win toasts manually).
-pub struct WinCascadePlugin;
-
-impl Plugin for WinCascadePlugin {
-    fn build(&self, app: &mut App) {
-        app.add_systems(Update, trigger_expressive_win_cascade.after(GameMutation));
-    }
-}
-
-/// Inserts `CardAnimation` (Expressive curve) on every card when `GameWonEvent` fires.
-///
-/// Cards scatter to 8 off-screen positions with per-card stagger. The z-lift
-/// creates a "burst" effect as cards fly outward.
-fn trigger_expressive_win_cascade(
-    mut events: MessageReader<GameWonEvent>,
-    cards: Query<(Entity, &Transform), With<CardEntity>>,
-    layout: Option<Res<LayoutResource>>,
-    mut commands: Commands,
-) {
-    if events.read().next().is_none() {
-        return;
-    }
-
-    let radius = layout.as_ref().map_or(800.0, |l| l.0.card_size.x * 8.0);
-
-    let targets = win_scatter_targets(radius);
-
-    for (index, (entity, transform)) in cards.iter().enumerate() {
-        let start_xy = transform.translation.truncate();
-        let start_z = transform.translation.z;
-        let target = targets[index % targets.len()];
-
-        commands.entity(entity).insert(
-            CardAnimation::slide(
-                start_xy,
-                start_z,
-                target,
-                start_z + 60.0,
-                MotionCurve::Expressive,
+                    .in_set(CardTweenFx),
            )
-            .with_delay(cascade_delay(index, WIN_CASCADE_INTERVAL_SECS))
-            .with_duration(0.65)
-            .with_z_lift(25.0),
-        );
+            .configure_sets(
+                Update,
+                CardTweenFx
+                    .after(GameMutation)
+                    .after(crate::table_plugin::MarkerVisuals)
+                    // HUD text pulses touch Transform on UI entities only —
+                    // disjoint from the card entities this set animates
+                    // (same rationale as UiTextFx × BoardVisuals, #143).
+                    .ambiguous_with(crate::ui_theme::UiTextFx),
+            );
    }
 }

@@ -433,19 +392,4 @@ mod tests {
        let state = HoverState::default();
        assert!(state.entity.is_none());
    }
-
-    #[test]
-    fn win_scatter_produces_eight_distinct_points() {
-        let targets = win_scatter_targets(600.0);
-        assert_eq!(targets.len(), 8);
-        // All must be different.
-        for i in 0..8 {
-            for j in (i + 1)..8 {
-                assert_ne!(
-                    targets[i], targets[j],
-                    "scatter targets {i} and {j} must be distinct"
-                );
-            }
-        }
-    }
 }
@@ -49,17 +49,6 @@ pub fn micro_vary(duration: f32, entity_index: u32) -> f32 {
    duration * (1.0 + variation)
 }

-/// Returns the pre-animation delay for card at `index` in a staggered cascade.
-///
-/// `delay = index × interval_secs`.
-#[inline]
-pub fn cascade_delay(index: usize, interval_secs: f32) -> f32 {
-    index as f32 * interval_secs
-}
-
-/// Recommended per-card interval for the win cascade (Normal speed).
-pub const WIN_CASCADE_INTERVAL_SECS: f32 = 0.018;
-
 /// Recommended per-card interval for deal animations (Normal speed).
 pub const DEAL_INTERVAL_SECS: f32 = 0.022;

@@ -137,22 +126,4 @@ mod tests {
            "micro_vary should differ for different indices"
        );
    }
-
-    #[test]
-    fn cascade_delay_zero_index_is_zero() {
-        assert_eq!(cascade_delay(0, 0.018), 0.0);
-    }
-
-    #[test]
-    fn cascade_delay_scales_linearly() {
-        let interval = 0.018;
-        for i in 0..52usize {
-            let expected = i as f32 * interval;
-            let actual = cascade_delay(i, interval);
-            assert!(
-                (actual - expected).abs() < 1e-6,
-                "cascade_delay({i}) = {actual}, expected {expected}"
-            );
-        }
-    }
 }
@@ -592,7 +592,9 @@ impl Plugin for CardPlugin {
                    tick_right_click_highlights,
                    clear_right_click_highlights_on_state_change,
                    clear_right_click_highlights_on_pause,
-                    tick_hint_highlight,
+                    // Reads only the anim-speed/reduce-motion flags; a frame
+                    // of lag is invisible (#143).
+                    tick_hint_highlight.ambiguous_with(crate::settings_plugin::SettingsAccess),
                    update_stock_empty_indicator,
                    update_stock_count_badge.run_if(resource_changed::<GameStateResource>),
                    collect_resize_events,
@@ -11,8 +11,7 @@ use solitaire_data::{challenge_count, challenge_seed_for, save_progress_to};
 use crate::events::{
    GameWonEvent, InfoToastEvent, NewGameRequestEvent, StartChallengeRequestEvent,
 };
-use crate::game_plugin::GameMutation;
-use crate::progress_plugin::{ProgressResource, ProgressStoragePath, ProgressUpdate};
+use crate::progress_plugin::{ProgressResource, ProgressStoragePath};
 use crate::resources::GameStateResource;

 /// Minimum player level required to start a Challenge run.
@@ -38,8 +37,28 @@ impl Plugin for ChallengePlugin {
            .add_message::<StartChallengeRequestEvent>()
            .add_message::<InfoToastEvent>()
            // Run after ProgressUpdate so we don't fight ProgressPlugin's add_xp.
-            .add_systems(Update, advance_on_challenge_win.after(ProgressUpdate))
-            .add_systems(Update, handle_start_challenge_request.before(GameMutation));
+            // Ordering comes from the mode-completion chain configured in
+            // progress_plugin; the toast it emits joins the writer club
+            // drained by the toast pipeline this frame (#143).
+            .add_systems(
+                Update,
+                advance_on_challenge_win
+                    .in_set(crate::progress_plugin::ChallengeCompletion)
+                    .in_set(crate::game_plugin::InfoToastWriters)
+                    .ambiguous_with(crate::game_plugin::InfoToastWriters),
+            )
+            // ModeStart places it between the stats abandon-recorder and
+            // GameMutation; it shares the new-game request/toast streams
+            // with the other writers (#143).
+            .add_systems(
+                Update,
+                handle_start_challenge_request
+                    .in_set(crate::game_plugin::ModeStart)
+                    .in_set(crate::game_plugin::NewGameRequestWriters)
+                    .ambiguous_with(crate::game_plugin::NewGameRequestWriters)
+                    .in_set(crate::game_plugin::InfoToastWriters)
+                    .ambiguous_with(crate::game_plugin::InfoToastWriters),
+            );
    }
 }

@@ -0,0 +1,194 @@
+//! Hold-`/` hotkey cheat sheet (Phase J).
+//!
+//! While `/` is held on a keyboard platform, a lightweight overlay
+//! lists every binding from [`crate::hotkeys::HOTKEYS`] — the same
+//! table the onboarding slide teaches from, so the two can never
+//! disagree. Releasing the key hides it instantly; it never captures
+//! input, never pauses the game, and never spawns while a modal owns
+//! the screen (which also keeps it out of the seed-entry text field's
+//! way).
+//!
+//! Not a `spawn_modal` modal on purpose: modals are sticky and guarded;
+//! this is a momentary reference card, closer to a tooltip than a
+//! dialog.
+
+use bevy::input::ButtonInput;
+use bevy::prelude::*;
+
+use crate::font_plugin::FontResource;
+use crate::hotkeys::HOTKEYS;
+use crate::platform::SHOW_KEYBOARD_ACCELERATORS;
+use crate::ui_modal::ModalScrim;
+use crate::ui_theme::{
+    ACCENT_PRIMARY, BG_ELEVATED, BORDER_STRONG, HighContrastBorder, RADIUS_MD, TEXT_PRIMARY,
+    TEXT_SECONDARY, TYPE_BODY, TYPE_CAPTION, VAL_SPACE_1, VAL_SPACE_2, VAL_SPACE_3, VAL_SPACE_4,
+    Z_TOOLTIP,
+};
+
+/// Marker on the cheat-sheet overlay root.
+#[derive(Component, Debug)]
+pub struct CheatSheetOverlay;
+
+/// Registers the hold-`/` driver. Inert on touch-first builds.
+pub struct CheatSheetPlugin;
+
+impl Plugin for CheatSheetPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<ButtonInput<KeyCode>>()
+            .add_systems(Update, drive_cheat_sheet);
+    }
+}
+
+/// Shows the overlay while `/` is held (and no modal owns the screen);
+/// hides it the frame the key releases.
+fn drive_cheat_sheet(
+    keys: Res<ButtonInput<KeyCode>>,
+    scrims: Query<(), With<ModalScrim>>,
+    existing: Query<Entity, With<CheatSheetOverlay>>,
+    font_res: Option<Res<FontResource>>,
+    mut commands: Commands,
+) {
+    if !SHOW_KEYBOARD_ACCELERATORS {
+        return;
+    }
+    let held = keys.pressed(KeyCode::Slash);
+    if held && existing.is_empty() && scrims.is_empty() {
+        spawn_cheat_sheet(&mut commands, font_res.as_deref());
+    } else if !held {
+        for entity in &existing {
+            commands.entity(entity).despawn();
+        }
+    }
+}
+
+fn spawn_cheat_sheet(commands: &mut Commands, font_res: Option<&FontResource>) {
+    let font_handle = font_res.map(|f| f.0.clone()).unwrap_or_default();
+    let font_header = TextFont {
+        font: font_handle.clone(),
+        font_size: TYPE_BODY,
+        ..default()
+    };
+    let font_keys = TextFont {
+        font: font_handle.clone(),
+        font_size: TYPE_CAPTION,
+        ..default()
+    };
+    let font_desc = TextFont {
+        font: font_handle,
+        font_size: TYPE_CAPTION,
+        ..default()
+    };
+
+    commands
+        .spawn((
+            CheatSheetOverlay,
+            Node {
+                position_type: PositionType::Absolute,
+                right: Val::Px(16.0),
+                top: Val::Percent(8.0),
+                flex_direction: FlexDirection::Column,
+                row_gap: VAL_SPACE_1,
+                padding: UiRect::all(VAL_SPACE_4),
+                border: UiRect::all(Val::Px(1.0)),
+                border_radius: BorderRadius::all(Val::Px(RADIUS_MD)),
+                max_height: Val::Percent(84.0),
+                overflow: Overflow::scroll_y(),
+                ..default()
+            },
+            BackgroundColor(BG_ELEVATED),
+            BorderColor::all(BORDER_STRONG),
+            HighContrastBorder::with_default(BORDER_STRONG),
+            GlobalZIndex(Z_TOOLTIP),
+        ))
+        .with_children(|panel| {
+            panel.spawn((
+                Text::new("Keyboard shortcuts"),
+                font_header.clone(),
+                TextColor(TEXT_PRIMARY),
+                Node {
+                    margin: UiRect::bottom(VAL_SPACE_2),
+                    ..default()
+                },
+            ));
+            for row in HOTKEYS {
+                panel
+                    .spawn(Node {
+                        flex_direction: FlexDirection::Row,
+                        column_gap: VAL_SPACE_3,
+                        ..default()
+                    })
+                    .with_children(|line| {
+                        line.spawn((
+                            Text::new(row.keys),
+                            font_keys.clone(),
+                            TextColor(ACCENT_PRIMARY),
+                            Node {
+                                min_width: Val::Px(110.0),
+                                ..default()
+                            },
+                        ));
+                        line.spawn((
+                            Text::new(row.description),
+                            font_desc.clone(),
+                            TextColor(TEXT_SECONDARY),
+                        ));
+                    });
+            }
+        });
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn app() -> App {
+        let mut app = App::new();
+        app.add_plugins(MinimalPlugins)
+            .add_plugins(CheatSheetPlugin);
+        app.update();
+        app
+    }
+
+    fn overlay_count(app: &mut App) -> usize {
+        app.world_mut()
+            .query::<&CheatSheetOverlay>()
+            .iter(app.world())
+            .count()
+    }
+
+    #[test]
+    fn holding_slash_shows_and_release_hides() {
+        let mut app = app();
+        app.world_mut()
+            .resource_mut::<ButtonInput<KeyCode>>()
+            .press(KeyCode::Slash);
+        app.update();
+        assert_eq!(overlay_count(&mut app), 1, "held / must show the sheet");
+        // Still held on later frames: exactly one overlay, no stacking.
+        app.update();
+        assert_eq!(overlay_count(&mut app), 1);
+
+        app.world_mut()
+            .resource_mut::<ButtonInput<KeyCode>>()
+            .release(KeyCode::Slash);
+        app.update();
+        app.update();
+        assert_eq!(overlay_count(&mut app), 0, "release must hide the sheet");
+    }
+
+    #[test]
+    fn suppressed_while_a_modal_is_open() {
+        let mut app = app();
+        app.world_mut().spawn(ModalScrim);
+        app.update();
+        app.world_mut()
+            .resource_mut::<ButtonInput<KeyCode>>()
+            .press(KeyCode::Slash);
+        app.update();
+        assert_eq!(
+            overlay_count(&mut app),
+            0,
+            "the sheet must not spawn over a modal (or into a text field)"
+        );
+    }
+}
@@ -0,0 +1,309 @@
+//! Contextual one-time tips (Phase I of the 2026-07 UI redesign).
+//!
+//! Everything the first-run onboarding doesn't cover is invisible until
+//! stumbled upon: hint cycling, the radial quick-action menu. These
+//! tips fire **from the situation, not a tour** — each exactly once,
+//! recorded in `Settings` like `shown_achievement_onboarding`:
+//!
+//! - **Stall tip** — after [`STALL_TIP_SECS`] with no board change in an
+//!   active game, an info toast points at Hint. A player staring at a
+//!   stuck board is the one moment the tip is welcome.
+//! - **Radial tip** — once a game reaches [`RADIAL_TIP_MIN_MOVES`] moves
+//!   (an engaged player) and the radial menu has never been opened, an
+//!   info toast teaches the long-press / right-click gesture. Opening
+//!   the radial organically marks the tip as unnecessary — it is never
+//!   shown to someone who already knows.
+//!
+//! Tips render through the queued [`InfoToastEvent`] path, so they share
+//! the unified toast stack and never interrupt play.
+
+use bevy::prelude::*;
+
+use solitaire_data::save_settings_to;
+
+use crate::events::{InfoToastEvent, StateChangedEvent};
+use crate::game_plugin::GameMutation;
+use crate::pause_plugin::PausedResource;
+use crate::platform::SHOW_KEYBOARD_ACCELERATORS;
+use crate::radial_menu::RightClickRadialState;
+use crate::resources::GameStateResource;
+use crate::settings_plugin::{SettingsResource, SettingsStoragePath};
+use crate::ui_modal::ModalScrim;
+
+/// Seconds without any board change before the stall tip fires.
+/// Long enough that normal thinking never triggers it; short enough to
+/// reach a genuinely stuck player before they quit.
+const STALL_TIP_SECS: f32 = 45.0;
+
+/// Move count at which an engaged player earns the radial-menu teach.
+const RADIAL_TIP_MIN_MOVES: u32 = 15;
+
+/// Stall-tip copy per platform input vocabulary.
+const STALL_TIP: &str = if SHOW_KEYBOARD_ACCELERATORS {
+    "Stuck? Press H for a hint."
+} else {
+    "Stuck? Tap Hint in the bottom bar for a suggested move."
+};
+
+/// Radial-tip copy per platform input vocabulary.
+const RADIAL_TIP: &str = if SHOW_KEYBOARD_ACCELERATORS {
+    "Tip: right-click a card for quick actions."
+} else {
+    "Tip: long-press a card for quick actions."
+};
+
+/// Seconds of board inactivity, frozen while paused / a modal is open,
+/// reset by every [`StateChangedEvent`].
+#[derive(Resource, Debug, Default)]
+pub struct StallClock(pub f32);
+
+/// Registers the stall clock and the two tip triggers.
+pub struct ContextualTipsPlugin;
+
+impl Plugin for ContextualTipsPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<StallClock>()
+            .add_message::<InfoToastEvent>()
+            .add_message::<StateChangedEvent>()
+            .add_systems(
+                Update,
+                (
+                    tick_stall_clock,
+                    fire_stall_hint_tip
+                        .in_set(crate::game_plugin::InfoToastWriters)
+                        .ambiguous_with(crate::game_plugin::InfoToastWriters),
+                    observe_radial_menu_use,
+                    fire_radial_menu_tip
+                        .in_set(crate::game_plugin::InfoToastWriters)
+                        .ambiguous_with(crate::game_plugin::InfoToastWriters),
+                )
+                    .chain()
+                    .after(GameMutation),
+            );
+    }
+}
+
+/// Advances the stall clock; resets on any board change; freezes while
+/// paused, while a modal owns the screen, or when the game is over.
+fn tick_stall_clock(
+    time: Res<Time>,
+    mut state_events: MessageReader<StateChangedEvent>,
+    paused: Option<Res<PausedResource>>,
+    scrims: Query<(), With<ModalScrim>>,
+    game: Option<Res<GameStateResource>>,
+    mut clock: ResMut<StallClock>,
+) {
+    if state_events.read().next().is_some() {
+        clock.0 = 0.0;
+        return;
+    }
+    if paused.is_some_and(|p| p.0)
+        || !scrims.is_empty()
+        || game.as_ref().is_none_or(|g| g.0.is_won())
+    {
+        // Frozen, not reset: backgrounding into a menu mid-stall
+        // shouldn't restart the wait.
+        return;
+    }
+    clock.0 += time.delta_secs();
+}
+
+/// Fires the one-shot stall tip once the clock passes the threshold in
+/// a game the player has actually started (at least one move).
+fn fire_stall_hint_tip(
+    clock: Res<StallClock>,
+    game: Option<Res<GameStateResource>>,
+    mut settings: Option<ResMut<SettingsResource>>,
+    storage_path: Option<Res<SettingsStoragePath>>,
+    mut toast: MessageWriter<InfoToastEvent>,
+) {
+    let Some(s) = settings.as_mut() else { return };
+    if s.0.shown_stall_hint_tip || clock.0 < STALL_TIP_SECS {
+        return;
+    }
+    if game
+        .as_ref()
+        .is_none_or(|g| g.0.move_count() == 0 || g.0.is_won())
+    {
+        return;
+    }
+    toast.write(InfoToastEvent(STALL_TIP.to_string()));
+    s.0.shown_stall_hint_tip = true;
+    persist(storage_path.as_deref(), &s.0);
+}
+
+/// A player who opens the radial menu on their own doesn't need the
+/// teach — mark the tip done silently.
+fn observe_radial_menu_use(
+    radial: Option<Res<RightClickRadialState>>,
+    mut settings: Option<ResMut<SettingsResource>>,
+    storage_path: Option<Res<SettingsStoragePath>>,
+) {
+    let Some(radial) = radial else { return };
+    if !radial.is_active() {
+        return;
+    }
+    let Some(s) = settings.as_mut() else { return };
+    if s.0.shown_radial_menu_tip {
+        return;
+    }
+    s.0.shown_radial_menu_tip = true;
+    persist(storage_path.as_deref(), &s.0);
+}
+
+/// Fires the one-shot radial teach for an engaged player who has never
+/// opened the menu themselves.
+fn fire_radial_menu_tip(
+    game: Option<Res<GameStateResource>>,
+    mut settings: Option<ResMut<SettingsResource>>,
+    storage_path: Option<Res<SettingsStoragePath>>,
+    mut toast: MessageWriter<InfoToastEvent>,
+) {
+    let Some(s) = settings.as_mut() else { return };
+    if s.0.shown_radial_menu_tip {
+        return;
+    }
+    if game
+        .as_ref()
+        .is_none_or(|g| g.0.move_count() < RADIAL_TIP_MIN_MOVES || g.0.is_won())
+    {
+        return;
+    }
+    toast.write(InfoToastEvent(RADIAL_TIP.to_string()));
+    s.0.shown_radial_menu_tip = true;
+    persist(storage_path.as_deref(), &s.0);
+}
+
+fn persist(storage_path: Option<&SettingsStoragePath>, settings: &solitaire_data::Settings) {
+    if let Some(p) = storage_path
+        && let Some(path) = p.0.as_deref()
+        && let Err(e) = save_settings_to(path, settings)
+    {
+        warn!("contextual tips: failed to persist tip flag: {e}");
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bevy::ecs::message::Messages;
+    use solitaire_core::{DrawStockConfig, game_state::GameState};
+    use solitaire_data::Settings;
+
+    fn app_with(settings: Settings, game: GameState) -> App {
+        let mut app = App::new();
+        app.add_plugins(MinimalPlugins)
+            .add_plugins(ContextualTipsPlugin);
+        app.insert_resource(SettingsResource(settings));
+        app.insert_resource(GameStateResource(game));
+        app.update();
+        app
+    }
+
+    fn info_toast_count(app: &App) -> usize {
+        let events = app.world().resource::<Messages<InfoToastEvent>>();
+        let mut cursor = events.get_cursor();
+        cursor.read(events).count()
+    }
+
+    fn started_game() -> GameState {
+        let mut game = GameState::new(7, DrawStockConfig::DrawOne);
+        game.draw().expect("draw from fresh deal");
+        game
+    }
+
+    #[test]
+    fn stall_tip_fires_once_past_threshold() {
+        let mut app = app_with(Settings::default(), started_game());
+        app.world_mut().resource_mut::<StallClock>().0 = STALL_TIP_SECS + 1.0;
+        app.update();
+
+        assert_eq!(info_toast_count(&app), 1, "stall tip must fire");
+        assert!(
+            app.world()
+                .resource::<SettingsResource>()
+                .0
+                .shown_stall_hint_tip,
+            "the tip flag must set so it never repeats"
+        );
+
+        app.world_mut().resource_mut::<StallClock>().0 = STALL_TIP_SECS + 30.0;
+        app.world_mut()
+            .resource_mut::<Messages<InfoToastEvent>>()
+            .clear();
+        app.update();
+        assert_eq!(info_toast_count(&app), 0, "the tip is one-shot");
+    }
+
+    #[test]
+    fn stall_tip_needs_a_started_unwon_game() {
+        // Untouched deal: staring at the launch screen is not a stall.
+        let mut app = app_with(
+            Settings::default(),
+            GameState::new(7, DrawStockConfig::DrawOne),
+        );
+        app.world_mut().resource_mut::<StallClock>().0 = STALL_TIP_SECS + 1.0;
+        app.update();
+        assert_eq!(info_toast_count(&app), 0, "no tip on an untouched deal");
+
+        // Won game: nothing to hint at.
+        let mut won = started_game();
+        won.set_test_won(true);
+        let mut app = app_with(Settings::default(), won);
+        app.world_mut().resource_mut::<StallClock>().0 = STALL_TIP_SECS + 1.0;
+        app.update();
+        assert_eq!(info_toast_count(&app), 0, "no tip on a won game");
+    }
+
+    #[test]
+    fn stall_clock_resets_on_state_change() {
+        let mut app = app_with(Settings::default(), started_game());
+        app.world_mut().resource_mut::<StallClock>().0 = 30.0;
+        app.world_mut().write_message(StateChangedEvent);
+        app.update();
+        assert_eq!(
+            app.world().resource::<StallClock>().0,
+            0.0,
+            "any board change must reset the stall clock"
+        );
+    }
+
+    #[test]
+    fn radial_tip_fires_for_engaged_player() {
+        let mut game = started_game();
+        game.set_test_move_count(RADIAL_TIP_MIN_MOVES);
+        let mut app = app_with(Settings::default(), game);
+        app.update();
+
+        assert_eq!(
+            info_toast_count(&app),
+            1,
+            "radial tip must fire at the move threshold"
+        );
+        assert!(
+            app.world()
+                .resource::<SettingsResource>()
+                .0
+                .shown_radial_menu_tip
+        );
+    }
+
+    #[test]
+    fn radial_tip_suppressed_after_organic_use() {
+        let mut game = started_game();
+        game.set_test_move_count(RADIAL_TIP_MIN_MOVES);
+        let mut app = app_with(
+            Settings {
+                shown_radial_menu_tip: true,
+                ..Settings::default()
+            },
+            game,
+        );
+        app.update();
+        assert_eq!(
+            info_toast_count(&app),
+            0,
+            "a player who used the radial menu never sees the teach"
+        );
+    }
+}
@@ -14,14 +14,14 @@ use crate::platform::{
 };
 use crate::{
    AchievementPlugin, AnimationPlugin, AssetSourcesPlugin, AutoCompletePlugin,
-    CardAnimationPlugin, CardPlugin, ChallengePlugin, CursorPlugin, DailyChallengePlugin,
-    DiagnosticsHudPlugin, DifficultyPlugin, FeedbackAnimPlugin, FontPlugin, GamePlugin, HelpPlugin,
-    HomePlugin, HudPlugin, InputPlugin, OnboardingPlugin, PausePlugin, PlayBySeedPlugin,
-    ProfilePlugin, ProgressPlugin, RadialMenuPlugin, ReplayOverlayPlugin, ReplayPlaybackPlugin,
-    SafeAreaInsetsPlugin, SelectionPlugin, SettingsPlugin, SolutionPlaybackPlugin, SplashPlugin,
-    StatsPlugin, SyncProvider, TablePlugin, ThemePlugin, ThemeRegistryPlugin, TimeAttackPlugin,
-    TouchSelectionPlugin, UiFocusPlugin, UiModalPlugin, UiTooltipPlugin, WeeklyGoalsPlugin,
-    WinSummaryPlugin,
+    CardAnimationPlugin, CardPlugin, ChallengePlugin, CheatSheetPlugin, ContextualTipsPlugin,
+    CursorPlugin, DailyChallengePlugin, DiagnosticsHudPlugin, DifficultyPlugin, FeedbackAnimPlugin,
+    FontPlugin, GamePlugin, HelpPlugin, HomePlugin, HudPlugin, InputPlugin, OnboardingPlugin,
+    PausePlugin, PlayBySeedPlugin, ProfilePlugin, ProgressPlugin, RadialMenuPlugin,
+    ReplayOverlayPlugin, ReplayPlaybackPlugin, SafeAreaInsetsPlugin, SelectionPlugin,
+    SettingsPlugin, SolutionPlaybackPlugin, SplashPlugin, StatsPlugin, SyncProvider, TablePlugin,
+    ThemePlugin, ThemeRegistryPlugin, TimeAttackPlugin, TouchSelectionPlugin, UiFocusPlugin,
+    UiModalPlugin, UiTooltipPlugin, WeeklyGoalsPlugin, WhatsNewPlugin, WinSummaryPlugin,
 };
 #[cfg(not(target_arch = "wasm32"))]
 use crate::{
@@ -115,6 +115,9 @@ impl Plugin for CoreGamePlugin {
            .add_plugins(PausePlugin)
            .add_plugins(SettingsPlugin::default())
            .add_plugins(OnboardingPlugin)
+            .add_plugins(WhatsNewPlugin)
+            .add_plugins(ContextualTipsPlugin)
+            .add_plugins(CheatSheetPlugin)
            .add_plugins(WinSummaryPlugin)
            .add_plugins(UiModalPlugin)
            .add_plugins(UiFocusPlugin)
@@ -76,12 +76,31 @@ pub struct CursorPlugin;

 impl Plugin for CursorPlugin {
    fn build(&self, app: &mut App) {
+        // All three read the DragState/game state the input chain and
+        // mutation systems settle, so they run after both. The highlight
+        // painters write card/overlay Sprites and join the visual spine
+        // ahead of the board painters; the cursor icon touches only the
+        // window cursor (#143).
        app.add_systems(
            Update,
            (
-                update_cursor_icon,
-                update_drop_highlights.run_if(resource_changed::<DragState>),
-                update_drop_target_overlays,
+                update_cursor_icon
+                    .after(crate::input_plugin::PointerInput)
+                    .after(crate::game_plugin::GameMutation)
+                    .after(crate::selection_plugin::SelectionFx)
+                    .before(crate::card_plugin::BoardVisuals),
+                (
+                    update_drop_highlights.run_if(resource_changed::<DragState>),
+                    update_drop_target_overlays,
+                )
+                    .chain()
+                    .after(crate::input_plugin::PointerInput)
+                    .after(crate::game_plugin::GameMutation)
+                    // Selection maintenance clears DragState and the hint
+                    // poll writes highlight sprites — both settle first.
+                    .after(crate::selection_plugin::SelectionFx)
+                    .after(crate::pending_hint::PendingHint)
+                    .before(crate::card_plugin::BoardVisuals),
            ),
        );
    }
@@ -24,8 +24,8 @@ use crate::events::{
    GameWonEvent, InfoToastEvent, NewGameRequestEvent, StartDailyChallengeRequestEvent,
    WarningToastEvent, XpAwardedEvent,
 };
-use crate::game_plugin::GameMutation;
-use crate::progress_plugin::{ProgressResource, ProgressStoragePath, ProgressUpdate};
+
+use crate::progress_plugin::{ProgressResource, ProgressStoragePath};
 use crate::resources::GameStateResource;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::sync_plugin::SyncProviderResource;
@@ -124,17 +124,51 @@ impl Plugin for DailyChallengePlugin {
            .add_message::<StartDailyChallengeRequestEvent>()
            .add_message::<WarningToastEvent>()
            .add_message::<XpAwardedEvent>()
-            // record/award after the base ProgressUpdate so we don't fight
-            // ProgressPlugin's add_xp on the same frame.
-            .add_systems(Update, handle_daily_completion.after(ProgressUpdate))
-            .add_systems(Update, handle_start_daily_request.before(GameMutation))
-            .add_systems(Update, check_daily_expiry_warning)
-            .add_systems(Update, check_date_rollover);
+            // Ordering comes from the mode-completion chain configured in
+            // progress_plugin; the toast it emits joins the writer club
+            // drained by the toast pipeline this frame (#143).
+            .add_systems(
+                Update,
+                handle_daily_completion
+                    .in_set(crate::progress_plugin::DailyCompletion)
+                    .in_set(crate::game_plugin::InfoToastWriters)
+                    .ambiguous_with(crate::game_plugin::InfoToastWriters),
+            )
+            // ModeStart places it between the stats abandon-recorder and
+            // GameMutation; it shares the new-game request/toast streams
+            // with the other writers (#143).
+            .add_systems(
+                Update,
+                handle_start_daily_request
+                    .in_set(crate::game_plugin::ModeStart)
+                    .in_set(crate::game_plugin::NewGameRequestWriters)
+                    .ambiguous_with(crate::game_plugin::NewGameRequestWriters)
+                    .in_set(crate::game_plugin::InfoToastWriters)
+                    .ambiguous_with(crate::game_plugin::InfoToastWriters),
+            )
+            // One chain for the DailyChallengeResource writers/readers:
+            // the local date rollover replaces today's challenge and the
+            // expiry warning reads it. Before ModeStart so a rollover
+            // lands before the start handler reads the seed this frame
+            // (#143).
+            .add_systems(
+                Update,
+                (
+                    check_date_rollover,
+                    check_daily_expiry_warning
+                        .in_set(crate::game_plugin::WarningToastWriters)
+                        .ambiguous_with(crate::game_plugin::WarningToastWriters),
+                )
+                    .chain()
+                    .before(crate::game_plugin::ModeStart),
+            );

        // Server-challenge fetch uses SyncProviderResource (reqwest), not available on wasm.
+        // The poll replaces DailyChallengeResource, so it heads the same
+        // pre-ModeStart timeline as the rollover/expiry chain above (#143).
        #[cfg(not(target_arch = "wasm32"))]
        app.add_systems(Startup, fetch_server_challenge)
-            .add_systems(Update, poll_server_challenge);
+            .add_systems(Update, poll_server_challenge.before(check_date_rollover));
    }
 }

@@ -21,7 +21,6 @@ use solitaire_core::game_state::{DifficultyLevel, GameMode};
 use solitaire_data::difficulty_seeds::seeds_for;

 use crate::events::{NewGameRequestEvent, StartDifficultyRequestEvent};
-use crate::game_plugin::GameMutation;

 // ---------------------------------------------------------------------------
 // Resources
@@ -77,7 +76,16 @@ impl Plugin for DifficultyPlugin {
        app.init_resource::<DifficultyIndexResource>()
            .add_message::<StartDifficultyRequestEvent>()
            .add_message::<NewGameRequestEvent>()
-            .add_systems(Update, handle_difficulty_request.before(GameMutation));
+            // ModeStart places it between the stats abandon-recorder and
+            // GameMutation; it shares the new-game request stream with the
+            // other writers (#143).
+            .add_systems(
+                Update,
+                handle_difficulty_request
+                    .in_set(crate::game_plugin::ModeStart)
+                    .in_set(crate::game_plugin::NewGameRequestWriters)
+                    .ambiguous_with(crate::game_plugin::NewGameRequestWriters),
+            );
    }
 }

@@ -5,7 +5,6 @@ use solitaire_core::KlondikePile;
 use solitaire_core::game_state::GameMode;
 use solitaire_core::{Card, Suit};
 use solitaire_data::AchievementRecord;
-use solitaire_sync::SyncResponse;

 /// Request to move `count` cards from `from` to `to`. Fired by input systems,
 /// consumed by `GamePlugin`.
@@ -152,6 +151,18 @@ pub struct SyncLogoutRequestEvent;
 #[derive(Message, Debug, Clone, Copy, Default)]
 pub struct DeleteAccountRequestEvent;

+/// Request to export every JSON save into one local backup bundle
+/// (Phase M — sync transparency). Fired by the Account tab's "Export
+/// data" button; handled in the `Last` schedule by `settings_plugin`.
+#[derive(Message, Debug, Clone, Copy, Default)]
+pub struct DataExportRequestEvent;
+
+/// Request to restore every JSON save from the local backup bundle
+/// (Phase M — sync transparency). Fired by the Account tab's "Import
+/// data" button; handled in the `Last` schedule by `settings_plugin`.
+#[derive(Message, Debug, Clone, Copy, Default)]
+pub struct DataImportRequestEvent;
+
 /// Request to toggle the pause overlay. Fired by the HUD "Pause" button so
 /// the same toggle path runs whether the player presses `Esc` or clicks.
 /// Consumed by `pause_plugin::toggle_pause`, which honours the same drag /
@@ -248,16 +259,6 @@ pub struct ToggleLeaderboardRequestEvent;
 #[derive(Message, Debug, Clone, Copy, Default)]
 pub struct ToggleHomeRequestEvent;

-/// Fired by `SyncPlugin` after a pull task resolves and the merged result has
-/// been persisted to disk. `Ok(SyncResponse)` carries the merged payload plus
-/// any `ConflictReport`s the merge produced. `Err(String)` carries a
-/// human-readable failure message (network, auth, serialization, etc.).
-///
-/// UI systems listen for this to refresh views without polling
-/// `SyncStatusResource`. See [ARCHITECTURE.md §4](../../ARCHITECTURE.md).
-#[derive(Message, Debug, Clone)]
-pub struct SyncCompleteEvent(pub Result<SyncResponse, String>);
-
 /// Generic informational toast message. Any system can fire this to display
 /// a short string to the player, e.g. "Locked — reach level 5".
 #[derive(Message, Debug, Clone)]
@@ -49,10 +49,11 @@ use solitaire_core::klondike_adapter::foundation_from_slot;
 use solitaire_data::AnimSpeed;

 use crate::animation_plugin::CardAnim;
-use crate::card_plugin::CardEntity;
+use crate::card_animation::{MotionCurve, sample_curve};
+use crate::card_plugin::{CardEntity, CardEntityIndex};
 use crate::events::{
-    DrawRequestEvent, FoundationCompletedEvent, MoveRejectedEvent, MoveRequestEvent,
-    NewGameRequestEvent,
+    DrawRequestEvent, FoundationCompletedEvent, HintVisualEvent, MoveRejectedEvent,
+    MoveRequestEvent, NewGameRequestEvent, StateChangedEvent,
 };
 use crate::game_plugin::GameMutation;
 use crate::layout::LayoutResource;
@@ -197,6 +198,22 @@ pub fn deal_stagger_jitter(card_id: u32) -> f32 {
 /// animation systems.
 pub struct FeedbackAnimPlugin;

+/// Set wrapping the shake/settle/deal/flourish systems. Last anim stage on
+/// the visual spine: …MarkerVisuals < CardTweenFx <
+/// [`crate::animation_plugin::AnimFx`] < FeedbackFx. Runs after
+/// MarkerVisuals because the foundation flourish tints pile-marker sprites,
+/// which the marker painters also write; the tint must win within the frame
+/// (#143). GameMutation ordering is inherited transitively.
+#[derive(bevy::ecs::schedule::SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct FeedbackFx;
+
+/// Set wrapping the hint-ghost chain (spawn → tick → despawn). Ghost
+/// entities are `Without<CardEntity>` sprites owned solely by this chain —
+/// systems that animate other entity domains (e.g. the win-summary camera
+/// shake) declare themselves `.ambiguous_with(HintGhostFx)` (#143).
+#[derive(bevy::ecs::schedule::SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct HintGhostFx;
+
 impl Plugin for FeedbackAnimPlugin {
    fn build(&self, app: &mut App) {
        // Register the events this plugin consumes so it can run in isolation
@@ -207,23 +224,70 @@ impl Plugin for FeedbackAnimPlugin {
            .add_message::<MoveRejectedEvent>()
            .add_message::<NewGameRequestEvent>()
            .add_message::<FoundationCompletedEvent>()
+            .add_message::<HintVisualEvent>()
+            .add_message::<StateChangedEvent>()
            .add_message::<RequestRedraw>()
+            .configure_sets(
+                Update,
+                FeedbackFx
+                    .after(GameMutation)
+                    .after(crate::animation_plugin::AnimFx)
+                    // HUD text pulses are disjoint from the card/marker
+                    // entities this set animates (see UiTextFx ×
+                    // BoardVisuals, #143).
+                    .ambiguous_with(crate::ui_theme::UiTextFx),
+            )
            .add_systems(
                Update,
                (
-                    start_shake_anim.after(GameMutation),
+                    // Reads only the reduce-motion flag; a frame of lag is
+                    // invisible (#143).
+                    start_shake_anim.ambiguous_with(crate::settings_plugin::SettingsAccess),
                    tick_shake_anim,
-                    start_settle_anim.after(GameMutation),
+                    start_settle_anim,
                    // tick_foundation_flourish writes the full Transform.scale
                    // (Vec3); tick_settle_anim writes only scale.y on top of
                    // it. Ordering ensures the settle's y-only write always
                    // applies last so it wins on the ~0.15 s overlap when both
                    // components are present on the same King entity.
-                    tick_foundation_flourish.before(tick_settle_anim),
+                    tick_foundation_flourish,
                    tick_settle_anim,
-                    start_deal_anim.after(GameMutation),
-                    start_foundation_flourish.after(GameMutation),
-                ),
+                    start_deal_anim,
+                    start_foundation_flourish,
+                )
+                    .chain()
+                    .in_set(FeedbackFx),
+            )
+            // Hint ghost (Phase H): the spawn reads card Transform/Sprite,
+            // so it orders after the board painters; the tick only touches
+            // ghost entities (Without<CardEntity>) and stays conflict-free.
+            .add_systems(
+                Update,
+                (
+                    spawn_hint_ghost
+                        .after(GameMutation)
+                        .after(crate::card_plugin::BoardVisuals),
+                    tick_hint_ghosts,
+                    despawn_hint_ghosts_on_state_change.after(GameMutation),
+                )
+                    .chain()
+                    .in_set(HintGhostFx)
+                    // The spawn reads card Sprites the marker painters (theme
+                    // apply, pile highlights) also write — those settle first.
+                    // Ghost entities are Without<CardEntity> and never HUD
+                    // chrome, and the spawn reads only the reduce-motion flag
+                    // (frame-lag invisible) (#143).
+                    .after(crate::table_plugin::MarkerVisuals)
+                    // …and the card tweens/slides, whose Transform writes
+                    // the spawn snapshot must not race.
+                    .after(crate::card_animation::CardTweenFx)
+                    // FeedbackFx (deal slide, shake) is the last Transform
+                    // writer on the spine — the ghost snapshot reads after
+                    // the whole visual pipeline has settled.
+                    .after(FeedbackFx)
+                    .ambiguous_with(crate::ui_theme::UiTextFx)
+                    .in_set(crate::settings_plugin::SettingsAccess)
+                    .ambiguous_with(crate::settings_plugin::SettingsAccess),
            );
    }
 }
@@ -664,6 +728,147 @@ fn pile_cards(
    }
 }

+// ---------------------------------------------------------------------------
+// Phase H — hint ghost-motion preview
+// ---------------------------------------------------------------------------
+
+/// Duration of one ghost glide from the hinted card to its destination.
+const HINT_GHOST_PASS_SECS: f32 = 0.7;
+/// How many glides one hint plays before the ghost despawns. Two reads
+/// as "this move, over there" without outstaying the 2 s static
+/// highlight it accompanies.
+const HINT_GHOST_PASSES: f32 = 2.0;
+/// Ghost translucency — clearly a projection, never mistakable for the
+/// real card.
+const HINT_GHOST_ALPHA: f32 = 0.45;
+/// Ghost render depth: above every settled pile (~1.04 max) and the
+/// in-flight `CardAnim` lift (50), below a dragged card (500).
+const HINT_GHOST_Z: f32 = 400.0;
+
+/// A translucent copy of the hinted card gliding to the suggested
+/// destination (Phase H). Purely decorative — despawned by timer, by a
+/// newer hint, or by any state change.
+#[derive(Component, Debug)]
+pub struct HintGhost {
+    start: Vec3,
+    target: Vec3,
+    elapsed: f32,
+}
+
+/// Normalised progress of the current glide pass, restarting from the
+/// source each pass. Pure for unit testing.
+fn hint_ghost_pass_t(elapsed: f32) -> f32 {
+    (elapsed % HINT_GHOST_PASS_SECS) / HINT_GHOST_PASS_SECS
+}
+
+/// Ghost alpha at `pass_t` — full strength for most of the glide, then
+/// fading over the last 20 % so the loop restart reads as a repeat
+/// rather than a teleport. Pure for unit testing.
+fn hint_ghost_alpha(pass_t: f32) -> f32 {
+    let fade_in_tail = ((pass_t - 0.8) / 0.2).clamp(0.0, 1.0);
+    HINT_GHOST_ALPHA * (1.0 - fade_in_tail)
+}
+
+/// Spawns the ghost when a hint fires. The static highlights (source
+/// card + gold destination pile) still spawn regardless; under
+/// reduce-motion they are the whole story and no ghost appears
+/// (`design-system.md` §Accessibility).
+#[allow(clippy::too_many_arguments)]
+fn spawn_hint_ghost(
+    mut events: MessageReader<HintVisualEvent>,
+    settings: Option<Res<SettingsResource>>,
+    index: Option<Res<CardEntityIndex>>,
+    layout: Option<Res<LayoutResource>>,
+    cards: Query<(&Transform, &Sprite), With<CardEntity>>,
+    existing: Query<Entity, With<HintGhost>>,
+    mut commands: Commands,
+) {
+    if events.is_empty() {
+        return;
+    }
+    if settings.is_some_and(|s| s.0.reduce_motion_mode) {
+        events.clear();
+        return;
+    }
+    let (Some(index), Some(layout)) = (index, layout) else {
+        events.clear();
+        return;
+    };
+    for ev in events.read() {
+        // A fresh hint replaces any ghost still in flight.
+        for entity in &existing {
+            commands.entity(entity).despawn();
+        }
+        let Some(card_entity) = index.get(&ev.source_card) else {
+            continue;
+        };
+        let Ok((transform, sprite)) = cards.get(card_entity) else {
+            continue;
+        };
+        let Some(&dest) = layout.0.pile_positions.get(&ev.dest_pile) else {
+            continue;
+        };
+        let start = transform.translation.truncate().extend(HINT_GHOST_Z);
+        let mut ghost_sprite = sprite.clone();
+        ghost_sprite.color = ghost_sprite.color.with_alpha(HINT_GHOST_ALPHA);
+        commands.spawn((
+            HintGhost {
+                start,
+                target: dest.extend(HINT_GHOST_Z),
+                elapsed: 0.0,
+            },
+            ghost_sprite,
+            Transform::from_translation(start),
+        ));
+    }
+}
+
+/// Advances every ghost: eased glide per pass, tail fade, despawn after
+/// [`HINT_GHOST_PASSES`]. Frozen while paused, like every other
+/// decorative animation.
+#[allow(clippy::type_complexity)]
+fn tick_hint_ghosts(
+    time: Res<Time>,
+    paused: Option<Res<PausedResource>>,
+    mut ghosts: Query<
+        (Entity, &mut HintGhost, &mut Transform, &mut Sprite),
+        (Without<CardEntity>, Without<PileMarker>),
+    >,
+    mut commands: Commands,
+) {
+    if paused.is_some_and(|p| p.0) {
+        return;
+    }
+    let dt = time.delta_secs();
+    for (entity, mut ghost, mut transform, mut sprite) in ghosts.iter_mut() {
+        ghost.elapsed += dt;
+        if ghost.elapsed >= HINT_GHOST_PASS_SECS * HINT_GHOST_PASSES {
+            commands.entity(entity).despawn();
+            continue;
+        }
+        let pass_t = hint_ghost_pass_t(ghost.elapsed);
+        let eased = sample_curve(MotionCurve::SmoothSnap, pass_t);
+        transform.translation = ghost.start.lerp(ghost.target, eased);
+        sprite.color = sprite.color.with_alpha(hint_ghost_alpha(pass_t));
+    }
+}
+
+/// A ghost previews a move against the *current* board; the moment the
+/// board changes (move, undo, draw, new game) it is stale and vanishes.
+fn despawn_hint_ghosts_on_state_change(
+    mut events: MessageReader<StateChangedEvent>,
+    ghosts: Query<Entity, With<HintGhost>>,
+    mut commands: Commands,
+) {
+    if events.is_empty() {
+        return;
+    }
+    events.clear();
+    for entity in &ghosts {
+        commands.entity(entity).despawn();
+    }
+}
+
 // ---------------------------------------------------------------------------
 // Unit tests (pure functions only — no Bevy world required)
 // ---------------------------------------------------------------------------
@@ -955,4 +1160,147 @@ mod tests {
            "FoundationFlourish must not be inserted under reduce-motion"
        );
    }
+
+    // -----------------------------------------------------------------------
+    // Phase H — hint ghost-motion preview
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn hint_ghost_pass_t_restarts_each_pass() {
+        assert_eq!(hint_ghost_pass_t(0.0), 0.0);
+        // Just past one full pass, progress wraps back near zero.
+        assert!(hint_ghost_pass_t(HINT_GHOST_PASS_SECS + 0.01) < 0.1);
+    }
+
+    #[test]
+    fn hint_ghost_alpha_fades_only_in_the_tail() {
+        assert_eq!(hint_ghost_alpha(0.0), HINT_GHOST_ALPHA);
+        assert_eq!(hint_ghost_alpha(0.79), HINT_GHOST_ALPHA);
+        assert!(hint_ghost_alpha(0.9) < HINT_GHOST_ALPHA);
+        assert!(hint_ghost_alpha(1.0).abs() < 1e-6);
+    }
+
+    /// App with one indexed card entity and a real layout, ready to
+    /// receive `HintVisualEvent`s.
+    fn ghost_app(reduce_motion: bool) -> (App, Card) {
+        use solitaire_core::{Deck, Rank, Suit};
+
+        let mut app = App::new();
+        app.add_plugins(MinimalPlugins)
+            .add_plugins(FeedbackAnimPlugin);
+        // Sibling systems in the plugin take GameStateResource
+        // non-optionally; give them a fresh deal.
+        app.insert_resource(GameStateResource(
+            solitaire_core::game_state::GameState::new(1, solitaire_core::DrawStockConfig::DrawOne),
+        ));
+        app.insert_resource(SettingsResource(solitaire_data::Settings {
+            reduce_motion_mode: reduce_motion,
+            ..Default::default()
+        }));
+
+        let card = Card::new(Deck::Deck1, Suit::Spades, Rank::Ace);
+        let entity = app
+            .world_mut()
+            .spawn((
+                CardEntity { card: card.clone() },
+                Sprite::default(),
+                Transform::from_xyz(-100.0, 40.0, 1.0),
+            ))
+            .id();
+        let mut index = CardEntityIndex::default();
+        index.0.insert(card.clone(), entity);
+        app.insert_resource(index);
+        app.insert_resource(LayoutResource(crate::layout::compute_layout(
+            Vec2::new(1280.0, 720.0),
+            0.0,
+            0.0,
+            true,
+        )));
+        app.update();
+        (app, card)
+    }
+
+    fn fire_hint(app: &mut App, card: Card) {
+        use solitaire_core::Tableau;
+        app.world_mut().write_message(HintVisualEvent {
+            source_card: card,
+            dest_pile: KlondikePile::Tableau(Tableau::Tableau2),
+        });
+        app.update();
+    }
+
+    fn ghost_count(app: &mut App) -> usize {
+        app.world_mut()
+            .query::<&HintGhost>()
+            .iter(app.world())
+            .count()
+    }
+
+    #[test]
+    fn hint_event_spawns_one_ghost_at_the_source_card() {
+        let (mut app, card) = ghost_app(false);
+        fire_hint(&mut app, card);
+
+        assert_eq!(ghost_count(&mut app), 1, "hint must spawn one ghost");
+        let transform = app
+            .world_mut()
+            .query_filtered::<&Transform, With<HintGhost>>()
+            .single(app.world())
+            .expect("ghost transform");
+        // The tick system may have advanced the ghost by one real-time
+        // frame already; assert it is still essentially at the source.
+        assert!(
+            transform
+                .translation
+                .truncate()
+                .distance(Vec2::new(-100.0, 40.0))
+                < 5.0,
+            "ghost must start at the hinted card, got {:?}",
+            transform.translation
+        );
+        assert_eq!(transform.translation.z, HINT_GHOST_Z);
+    }
+
+    #[test]
+    fn hint_ghost_suppressed_under_reduce_motion() {
+        let (mut app, card) = ghost_app(true);
+        fire_hint(&mut app, card);
+
+        assert_eq!(
+            ghost_count(&mut app),
+            0,
+            "no ghost may spawn under reduce-motion; the static highlight is the whole story"
+        );
+    }
+
+    #[test]
+    fn state_change_despawns_the_ghost() {
+        let (mut app, card) = ghost_app(false);
+        fire_hint(&mut app, card);
+        assert_eq!(ghost_count(&mut app), 1);
+
+        app.world_mut().write_message(StateChangedEvent);
+        app.update();
+        app.update();
+
+        assert_eq!(
+            ghost_count(&mut app),
+            0,
+            "a board change makes the previewed move stale — the ghost must vanish"
+        );
+    }
+
+    #[test]
+    fn second_hint_replaces_the_first_ghost() {
+        let (mut app, card) = ghost_app(false);
+        fire_hint(&mut app, card.clone());
+        fire_hint(&mut app, card);
+        app.update();
+
+        assert_eq!(
+            ghost_count(&mut app),
+            1,
+            "re-hinting must replace the in-flight ghost, not stack a second"
+        );
+    }
 }
@@ -86,11 +86,51 @@ pub struct NewGameRequestWriters;
 #[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
 pub struct UndoRequestWriters;

+/// Self-ambiguous set for writers of `DrawRequestEvent` — same rationale as
+/// [`NewGameRequestWriters`]: consumers drain the queue, append order is
+/// meaningless (#143). Members: keyboard `D`/`Space`, stock click, touch
+/// stock tap (input_plugin), and the touch action bar's Draw button
+/// (hud_plugin, Phase F).
+#[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct DrawRequestWriters;
+
 /// Self-ambiguous set for writers of `InfoToastEvent` — toasts queue in
 /// arrival order and any same-frame order is fine (#143).
 #[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
 pub struct InfoToastWriters;

+/// Self-ambiguous club for writers of `MoveRequestEvent` (drag drops, stock
+/// clicks, radial menu, selection keys, replay step button). Consumers drain
+/// the whole queue — append order is meaningless (#143). Same rules as
+/// [`NewGameRequestWriters`]: do NOT hang ordering edges off this set.
+#[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct MoveRequestWriters;
+
+/// Self-ambiguous club for writers of `WarningToastEvent` (daily-expiry
+/// warning, leaderboard opt-in/out failure polls). The toast pipeline
+/// drains the whole queue — append order is meaningless (#143). Same
+/// rules as [`InfoToastWriters`].
+#[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct WarningToastWriters;
+
+/// Set + self-ambiguous club for the mode-start request handlers (challenge,
+/// daily, time-attack, play-by-seed, difficulty). Each drains its own
+/// request stream and resets `GameStateResource` for its mode; only one
+/// stream carries an event on any real frame, so member order is irrelevant
+/// (club), while the set as a whole runs between the stats abandon-recorder
+/// ([`crate::stats_plugin::AbandonRecord`], which must read the old game
+/// first) and [`GameMutation`] (#143).
+#[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ModeStart;
+
+/// Set wrapping `GamePlugin`'s pre-mutation game-state spine (elapsed-time
+/// tick, settings sync, restore prompt). Sits between
+/// [`crate::settings_plugin::SettingsMutation`] and [`GameMutation`]; other
+/// pre-mutation readers of `GameStateResource` (e.g. the stats
+/// abandon-recorder) order themselves `.after(PreMutation)` (#143).
+#[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct PreMutation;
+
 /// Persistence path for the in-progress game state file. `None` disables I/O.
 #[derive(Resource, Debug, Clone)]
 pub struct GameStatePath(pub Option<PathBuf>);
@@ -259,7 +299,14 @@ impl Plugin for GamePlugin {
                    .in_set(InfoToastWriters)
                    .ambiguous_with(InfoToastWriters),
            )
-            .add_systems(Update, record_replay_on_win.after(GameMutation))
+            .add_systems(
+                Update,
+                record_replay_on_win
+                    .after(GameMutation)
+                    // Before the playback skip-recorder (which runs after
+                    // AutoComplete) — both touch RecordingReplay (#143).
+                    .before(crate::auto_complete_plugin::AutoComplete),
+            )
            .add_systems(
                Update,
                (
@@ -293,9 +340,20 @@ impl Plugin for GamePlugin {
                        .ambiguous_with(NewGameRequestWriters),
                )
                    .chain()
+                    .in_set(PreMutation),
+            )
+            .configure_sets(
+                Update,
+                PreMutation
                    .after(crate::settings_plugin::SettingsMutation)
                    .before(GameMutation),
            )
+            .configure_sets(
+                Update,
+                ModeStart
+                    .after(crate::stats_plugin::AbandonRecord)
+                    .before(GameMutation),
+            )
            .init_resource::<AutoSaveTimer>()
            .add_systems(Update, auto_save_game_state.after(GameMutation))
            .add_systems(Last, save_game_state_on_exit);
@@ -1062,11 +1120,16 @@ pub fn record_replay_on_win(
        if recording.moves.is_empty() {
            continue;
        }
+        // The session itself is the authoritative recording: its history
+        // holds the dealt board plus the forward instruction list (undos
+        // already popped), and it serialises via the upstream card_game
+        // serializers so playback never re-deals from the seed.
+        let session_recording = game.0.recording();
        // Recording freezes on win, so the move that triggered the
        // win condition is the last one in the list. Storing the
        // index explicitly lets the playback UI read the WIN MOVE
        // position directly instead of re-deriving it on every render.
-        let win_move_index = recording.moves.len().checked_sub(1);
+        let win_move_index = session_recording.len().checked_sub(1);
        let replay = Replay::new(
            game.0.seed,
            game.0.draw_mode(),
@@ -1074,7 +1137,7 @@ pub fn record_replay_on_win(
            ev.time_seconds,
            ev.score,
            Utc::now().date_naive(),
-            recording.moves.clone(),
+            session_recording,
        )
        .with_win_move_index(win_move_index);
        let Some(p) = path.as_ref().and_then(|r| r.0.as_deref()) else {
@@ -853,17 +853,15 @@ fn replay_recording_freezes_into_replay_on_game_won() {
    let mut app = test_app(7654);
    app.insert_resource(ReplayPath(Some(path.clone())));

-    // Push two recorded instructions manually so we can verify they
-    // survive the freeze/save round-trip without having to drive a
-    // real win. Both are `RotateStock` — the only instruction
-    // constructible without the runtime-only `klondike` pile-stack
-    // types (which the engine intentionally does not depend on); the
-    // round-trip shape is identical for any instruction variant.
-    {
-        let mut recording = app.world_mut().resource_mut::<RecordingReplay>();
-        recording.moves.push(KlondikeInstruction::RotateStock);
-        recording.moves.push(KlondikeInstruction::RotateStock);
-    }
+    // Drive two real draws so the *session* history (the source the
+    // freeze now serialises from, via `GameState::recording()`) holds
+    // two instructions. `RotateStock` is the only instruction the
+    // engine can drive without the runtime-only `klondike` pile-stack
+    // types; the round-trip shape is identical for any variant.
+    app.world_mut().write_message(DrawRequestEvent);
+    app.update();
+    app.world_mut().write_message(DrawRequestEvent);
+    app.update();

    // Fire the win event the engine emits when the last foundation
    // completes — `record_replay_on_win` listens for it.
@@ -895,9 +893,15 @@ fn replay_recording_freezes_into_replay_on_game_won() {
        loaded.time_seconds, 250,
        "time_seconds must come from the win event"
    );
-    assert_eq!(loaded.moves.len(), 2, "every recorded move must round-trip");
-    assert!(matches!(loaded.moves[0], KlondikeInstruction::RotateStock));
-    assert!(matches!(loaded.moves[1], KlondikeInstruction::RotateStock));
+    let instructions = loaded.recording.instructions();
+    assert_eq!(instructions.len(), 2, "every recorded move must round-trip");
+    assert!(matches!(instructions[0], KlondikeInstruction::RotateStock));
+    assert!(matches!(instructions[1], KlondikeInstruction::RotateStock));
+    assert_eq!(
+        loaded.win_move_index,
+        Some(1),
+        "win move index must point at the last recorded instruction",
+    );

    #[cfg(not(target_arch = "wasm32"))]
    let _ = std::fs::remove_file(&path);
@@ -54,12 +54,23 @@ impl Plugin for HelpPlugin {
            .add_message::<TouchInput>()
            .add_systems(
                Update,
-                (
-                    toggle_help_screen,
-                    handle_help_close_button,
-                    scroll_help_panel,
-                    crate::ui_modal::touch_scroll_panel::<HelpScrollable>,
-                ),
+                (toggle_help_screen, handle_help_close_button)
+                    .chain()
+                    // FocusKeys consumes Esc after the modal handlers
+                    // (mirrors toggle_settings_screen, #143).
+                    .before(crate::ui_focus::FocusKeys),
+            )
+            .add_systems(
+                Update,
+                scroll_help_panel
+                    .in_set(crate::ui_modal::PanelScroll)
+                    .ambiguous_with(crate::ui_modal::PanelScroll),
+            )
+            .add_systems(
+                Update,
+                crate::ui_modal::touch_scroll_panel::<HelpScrollable>
+                    .in_set(crate::ui_modal::PanelScroll)
+                    .ambiguous_with(crate::ui_modal::PanelScroll),
            );
    }
 }
@@ -0,0 +1,169 @@
+//! Single source of truth for the desktop keyboard bindings (Phase J).
+//!
+//! Two static hotkey tables had already diverged (onboarding's slide
+//! and Help's controls reference); every future drift multiplies. This
+//! module owns THE table: the onboarding slide renders the
+//! [`HotkeyRow::essential`] subset, the hold-`/` cheat sheet
+//! ([`crate::cheat_sheet_plugin`]) renders everything.
+//!
+//! The table is hand-maintained but **pinned by test** against the
+//! handlers that actually consume each key — adding a binding without
+//! updating this table (or vice versa) is designed to fail review, not
+//! runtime. A registry generated from the input systems themselves is
+//! the eventual ideal; this is the honest 90 % at 1 % of the cost.
+
+/// One row of the hotkey table.
+#[derive(Debug, Clone, Copy)]
+pub struct HotkeyRow {
+    /// Display form of the key(s), e.g. `"D / Space"`.
+    pub keys: &'static str,
+    /// One-line action description.
+    pub description: &'static str,
+    /// `true` for the beginner-relevant subset the onboarding slide
+    /// shows; the cheat sheet always shows every row.
+    pub essential: bool,
+}
+
+/// Every desktop keyboard binding, in teaching order.
+pub const HOTKEYS: &[HotkeyRow] = &[
+    HotkeyRow {
+        keys: "D / Space",
+        description: "Draw from stock",
+        essential: true,
+    },
+    HotkeyRow {
+        keys: "U",
+        description: "Undo last move (hold to repeat)",
+        essential: true,
+    },
+    HotkeyRow {
+        keys: "H",
+        description: "Hint (repeat to cycle alternatives)",
+        essential: true,
+    },
+    HotkeyRow {
+        keys: "Tab → Enter",
+        description: "Pick a card; arrows pick where; Enter to drop",
+        essential: true,
+    },
+    HotkeyRow {
+        keys: "N",
+        description: "New Classic game",
+        essential: true,
+    },
+    HotkeyRow {
+        keys: "M",
+        description: "Open Home (then 1–6 to pick a mode)",
+        essential: true,
+    },
+    HotkeyRow {
+        keys: "Esc",
+        description: "Pause / resume; close the top dialog",
+        essential: true,
+    },
+    HotkeyRow {
+        keys: "F1",
+        description: "Help / controls",
+        essential: true,
+    },
+    HotkeyRow {
+        keys: "S",
+        description: "Stats & progression",
+        essential: true,
+    },
+    HotkeyRow {
+        keys: "A",
+        description: "Achievements",
+        essential: true,
+    },
+    HotkeyRow {
+        keys: "O",
+        description: "Settings",
+        essential: true,
+    },
+    HotkeyRow {
+        keys: "P",
+        description: "Profile",
+        essential: false,
+    },
+    HotkeyRow {
+        keys: "L",
+        description: "Leaderboard",
+        essential: false,
+    },
+    HotkeyRow {
+        keys: "C",
+        description: "Daily Challenge",
+        essential: false,
+    },
+    HotkeyRow {
+        keys: "Z",
+        description: "Zen mode",
+        essential: false,
+    },
+    HotkeyRow {
+        keys: "X",
+        description: "Challenge mode",
+        essential: false,
+    },
+    HotkeyRow {
+        keys: "T",
+        description: "Time Attack",
+        essential: false,
+    },
+    HotkeyRow {
+        keys: "G",
+        description: "Give up the current deal",
+        essential: false,
+    },
+    HotkeyRow {
+        keys: "[ / ]",
+        description: "Volume down / up",
+        essential: false,
+    },
+    HotkeyRow {
+        keys: "F11",
+        description: "Toggle fullscreen",
+        essential: false,
+    },
+    HotkeyRow {
+        keys: "/ (hold)",
+        description: "This cheat sheet",
+        essential: false,
+    },
+];
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn table_is_populated_and_well_formed() {
+        assert!(!HOTKEYS.is_empty());
+        for row in HOTKEYS {
+            assert!(!row.keys.trim().is_empty(), "empty keys cell");
+            assert!(
+                !row.description.trim().is_empty(),
+                "empty description for {}",
+                row.keys
+            );
+        }
+    }
+
+    #[test]
+    fn essential_subset_is_a_teachable_size() {
+        let essentials = HOTKEYS.iter().filter(|r| r.essential).count();
+        assert!(
+            (6..=12).contains(&essentials),
+            "the onboarding slide wants a skimmable essential set, got {essentials}"
+        );
+    }
+
+    #[test]
+    fn keys_cells_are_unique() {
+        let mut seen = std::collections::HashSet::new();
+        for row in HOTKEYS {
+            assert!(seen.insert(row.keys), "duplicate hotkey row: {}", row.keys);
+        }
+    }
+}
@@ -109,12 +109,19 @@ pub(super) fn apply_action_fade(
 /// Visual feedback for every action button — paints idle / hover / pressed
 /// states by mutating `BackgroundColor` whenever the interaction state
 /// changes. One query covers all action buttons via the shared
-/// `ActionButton` marker.
+/// `ActionButton` marker. Glass tab-bar buttons are excluded: they carry
+/// their own per-button colour triple and are painted by
+/// `paint_glass_tab_buttons` instead (this system's opaque `ACTION_BTN_*`
+/// fills would destroy the translucent glass look).
 #[allow(clippy::type_complexity)]
 pub(super) fn paint_action_buttons(
    mut buttons: Query<
        (&Interaction, &mut BackgroundColor),
-        (With<ActionButton>, Changed<Interaction>),
+        (
+            With<ActionButton>,
+            Without<GlassTabButton>,
+            Changed<Interaction>,
+        ),
    >,
 ) {
    for (interaction, mut bg) in &mut buttons {
@@ -30,6 +30,86 @@ pub(super) fn handle_undo_button(
    }
 }

+/// Seconds the Undo button must be continuously held before hold-to-repeat
+/// kicks in. Long enough that a normal tap (press + release inside one or
+/// two frames) never triggers a second undo.
+const UNDO_HOLD_INITIAL_DELAY_SECS: f32 = 0.45;
+
+/// Interval between repeated undos while the hold continues. ~5.5 undos/s —
+/// fast enough to unwind a long line, slow enough to release in time when
+/// the board reaches the state the player wants.
+const UNDO_HOLD_REPEAT_INTERVAL_SECS: f32 = 0.18;
+
+/// Hold-to-repeat undo (Phase F): while the Undo button stays pressed,
+/// fire additional [`UndoRequestEvent`]s after an initial delay, one per
+/// repeat interval. The plain tap path stays in [`handle_undo_button`]
+/// (its `Changed<Interaction>` filter fires exactly once per press);
+/// this system only adds events once the hold outlives the delay, so a
+/// tap never double-undoes.
+///
+/// Each repeat goes through the normal request queue — the scoring
+/// penalty and No-Undo-mode gating in the consumer apply to every step.
+pub(super) fn repeat_undo_on_hold(
+    time: Res<Time>,
+    buttons: Query<&Interaction, With<UndoButton>>,
+    mut state: ResMut<UndoHoldState>,
+    mut undo: MessageWriter<UndoRequestEvent>,
+) {
+    let held = buttons.iter().any(|i| *i == Interaction::Pressed);
+    if !held {
+        if state.held_secs != 0.0 {
+            state.held_secs = 0.0;
+        }
+        return;
+    }
+
+    let before = state.held_secs;
+    state.held_secs += time.delta_secs();
+    if undo_hold_crossed_fire_boundary(before, state.held_secs) {
+        undo.write(UndoRequestEvent);
+    }
+}
+
+/// `true` when a hold that lasted `before` seconds at the previous frame
+/// and `now` seconds this frame should fire a repeat undo: once when the
+/// hold first outlives the initial delay, then once per repeat-interval
+/// boundary. Pure so the timing contract is unit-testable without
+/// fighting `Time`.
+pub(super) fn undo_hold_crossed_fire_boundary(before: f32, now: f32) -> bool {
+    if now < UNDO_HOLD_INITIAL_DELAY_SECS {
+        return false;
+    }
+    if before < UNDO_HOLD_INITIAL_DELAY_SECS {
+        // Crossed the initial-delay threshold this frame — first repeat.
+        return true;
+    }
+    // Fire once each time the hold crosses another repeat-interval boundary.
+    let intervals_before =
+        ((before - UNDO_HOLD_INITIAL_DELAY_SECS) / UNDO_HOLD_REPEAT_INTERVAL_SECS).floor();
+    let intervals_now =
+        ((now - UNDO_HOLD_INITIAL_DELAY_SECS) / UNDO_HOLD_REPEAT_INTERVAL_SECS).floor();
+    intervals_now > intervals_before
+}
+
+/// Click on the touch action bar's Draw button — same
+/// [`DrawRequestEvent`] the stock-pile tap writes, so the consumer's
+/// rules (recycle, won-game rejection) apply identically. Skipped while
+/// paused, mirroring `handle_stock_click`'s guard.
+pub(super) fn handle_draw_button(
+    interaction_query: Query<&Interaction, (With<DrawButton>, Changed<Interaction>)>,
+    paused: Option<Res<PausedResource>>,
+    mut draw: MessageWriter<DrawRequestEvent>,
+) {
+    if paused.is_some_and(|p| p.0) {
+        return;
+    }
+    for interaction in &interaction_query {
+        if *interaction == Interaction::Pressed {
+            draw.write(DrawRequestEvent);
+        }
+    }
+}
+
 pub(super) fn handle_pause_button(
    interaction_query: Query<&Interaction, (With<PauseButton>, Changed<Interaction>)>,
    mut pause: MessageWriter<PauseRequestEvent>,
@@ -12,11 +12,13 @@ use bevy::window::WindowResized;
 mod fx;
 mod interaction;
 mod spawn;
+pub(crate) mod tab_bar;
 mod updates;

 pub use fx::*;
 use interaction::*;
 use spawn::*;
+use tab_bar::*;
 use updates::*;

 // On wasm32 AvatarPlugin is gated out; define a placeholder type so the
@@ -28,7 +30,7 @@ struct AvatarResource(Option<bevy::prelude::Handle<bevy::prelude::Image>>);
 use crate::challenge_plugin::CHALLENGE_UNLOCK_LEVEL;
 use crate::daily_challenge_plugin::DailyChallengeResource;
 use crate::events::{
-    HelpRequestEvent, InfoToastEvent, NewGameRequestEvent, PauseRequestEvent,
+    DrawRequestEvent, HelpRequestEvent, InfoToastEvent, NewGameRequestEvent, PauseRequestEvent,
    StartChallengeRequestEvent, StartDailyChallengeRequestEvent, StartTimeAttackRequestEvent,
    StartZenRequestEvent, ToggleAchievementsRequestEvent, ToggleHomeRequestEvent,
    ToggleLeaderboardRequestEvent, ToggleProfileRequestEvent, ToggleSettingsRequestEvent,
@@ -313,6 +315,18 @@ pub struct UndoButton;
 #[derive(Component, Debug)]
 pub struct PauseButton;

+/// Accumulated hold time on the Undo button, driving hold-to-repeat undo
+/// (Phase F). `handle_undo_button` owns the instant first undo on press;
+/// `repeat_undo_on_hold` starts firing additional [`UndoRequestEvent`]s
+/// once the hold passes `UNDO_HOLD_INITIAL_DELAY_SECS` and then every
+/// `UNDO_HOLD_REPEAT_INTERVAL_SECS`. Each repeated undo goes through the
+/// normal request path, so the existing scoring penalty applies per step.
+#[derive(Resource, Debug, Default)]
+pub struct UndoHoldState {
+    /// Seconds the Undo button has been continuously held.
+    held_secs: f32,
+}
+
 /// Marker on the "Help" action button. Click fires [`HelpRequestEvent`],
 /// mirroring the `F1` keyboard accelerator.
 #[derive(Component, Debug)]
@@ -323,31 +337,27 @@ pub struct HelpButton;
 #[derive(Component, Debug)]
 pub struct HintButton;

+/// Marker on the touch action bar's "Draw" button (Phase F). Click fires
+/// [`DrawRequestEvent`] — same queue as tapping the stock pile — so the
+/// draw action is within thumb reach without stretching to the top of a
+/// tall folded screen. Touch layout only; desktop draws via stock
+/// click / `D` / `Space`.
+#[derive(Component, Debug)]
+pub struct DrawButton;
+
 /// Android HUD label for the Hint button — shared with the help screen's
 /// controls reference so both always agree.
 #[cfg(target_os = "android")]
 pub(crate) const ANDROID_HINT_LABEL: &str = "Hint";

+/// Hint label used by the touch action bar. Aliases [`ANDROID_HINT_LABEL`]
+/// on Android so the bar and the help screen's controls reference can
+/// never drift; the non-Android value only exists so the touch spawn
+/// path stays host-compilable for tests.
 #[cfg(target_os = "android")]
-const ACTION_BAR_LABELS: [&str; 7] = [
-    "Menu",
-    "Undo",
-    "Pause",
-    "Help",
-    ANDROID_HINT_LABEL,
-    "Mode",
-    "New",
-];
+const TOUCH_HINT_LABEL: &str = ANDROID_HINT_LABEL;
 #[cfg(not(target_os = "android"))]
-const ACTION_BAR_LABELS: [&str; 7] = [
-    "Menu \u{2193}",
-    "Undo",
-    "Pause",
-    "Help",
-    "Hint",
-    "Modes \u{2193}",
-    "New Game",
-];
+const TOUCH_HINT_LABEL: &str = "Hint";
 #[cfg(target_os = "android")]
 const ACTION_BAR_COLUMN_GAP: Val = Val::Px(4.0);
 #[cfg(not(target_os = "android"))]
@@ -455,6 +465,7 @@ impl Plugin for HudPlugin {
        // idempotent.
        app.add_message::<NewGameRequestEvent>()
            .add_message::<UndoRequestEvent>()
+            .add_message::<DrawRequestEvent>()
            .add_message::<PauseRequestEvent>()
            .add_message::<HelpRequestEvent>()
            .add_message::<StartZenRequestEvent>()
@@ -471,6 +482,7 @@ impl Plugin for HudPlugin {
            .init_resource::<PreviousScore>()
            .init_resource::<HudActionFade>()
            .init_resource::<HudVisibility>()
+            .init_resource::<UndoHoldState>()
            // Escape-close handlers for popovers read this; init defensively
            // so HudPlugin works under MinimalPlugins in tests.
            .init_resource::<ButtonInput<KeyCode>>()
@@ -505,13 +517,31 @@ impl Plugin for HudPlugin {
                Update,
                (restore_hud_on_modal, apply_hud_visibility)
                    .chain()
-                    .before(LayoutSystem::UpdateOnResize),
+                    .before(LayoutSystem::UpdateOnResize)
+                    // Toggles Visibility on HUD chrome roots only — joins
+                    // the chrome club (#143).
+                    .in_set(UiTextFx)
+                    .ambiguous_with(UiTextFx),
            )
            .add_systems(
                Update,
                (
-                    update_hud_avatar.after(crate::settings_plugin::SettingsMutation),
-                    handle_avatar_button.ambiguous_with(HudButtons),
+                    update_hud_avatar
+                        // Same-frame-exact after the settings spine, so NOT
+                        // a SettingsAccess member — but the club's readers
+                        // and the home deal-option writers touch settings
+                        // fields the avatar never reads (#143).
+                        .ambiguous_with(crate::settings_plugin::SettingsAccess)
+                        .after(crate::settings_plugin::SettingsMutation)
+                        // Two more settings writers arrived with the wider
+                        // ambiguity cluster: the pause overlay's draw-mode
+                        // toggle and the achievement onboarding flag (#143).
+                        .after(crate::pause_plugin::PauseMutation)
+                        .after(crate::game_plugin::InfoToastWriters),
+                    handle_avatar_button
+                        .ambiguous_with(HudButtons)
+                        .in_set(crate::profile_plugin::ProfileToggleWriters)
+                        .ambiguous_with(crate::profile_plugin::ProfileToggleWriters),
                ),
            )
            .add_systems(
@@ -526,7 +556,11 @@ impl Plugin for HudPlugin {
            // the board painters that resize card/label text (#143).
            .add_systems(
                Update,
-                update_hud_typography.after(crate::card_plugin::BoardVisuals),
+                update_hud_typography
+                    .after(crate::card_plugin::BoardVisuals)
+                    // Writes HUD TextFont only — chrome club (#143).
+                    .in_set(UiTextFx)
+                    .ambiguous_with(UiTextFx),
            )
            .add_systems(
                Update,
@@ -539,16 +573,26 @@ impl Plugin for HudPlugin {
                    .after(GameMutation)
                    .in_set(UiTextFx)
                    .ambiguous_with(UiTextFx)
-                    .ambiguous_with(crate::card_plugin::BoardVisuals),
+                    .ambiguous_with(crate::card_plugin::BoardVisuals)
+                    // Reads only the reduce-motion flag; a frame of lag is
+                    // invisible (#143).
+                    .in_set(crate::settings_plugin::SettingsAccess)
+                    .ambiguous_with(crate::settings_plugin::SettingsAccess),
            )
            .add_systems(
                Update,
                (start_streak_flourish, advance_streak_flourish)
                    .chain()
                    .after(GameMutation)
+                    // Reads the streak-milestone events StatsUpdate emits.
+                    .after(crate::stats_plugin::StatsUpdate)
                    .in_set(UiTextFx)
                    .ambiguous_with(UiTextFx)
-                    .ambiguous_with(crate::card_plugin::BoardVisuals),
+                    .ambiguous_with(crate::card_plugin::BoardVisuals)
+                    // Reads only the reduce-motion flag; a frame of lag is
+                    // invisible (#143).
+                    .in_set(crate::settings_plugin::SettingsAccess)
+                    .ambiguous_with(crate::settings_plugin::SettingsAccess),
            )
            .add_systems(
                Update,
@@ -560,23 +604,60 @@ impl Plugin for HudPlugin {
                        .in_set(crate::game_plugin::UndoRequestWriters)
                        .ambiguous_with(crate::game_plugin::UndoRequestWriters)
                        .before(GameMutation),
+                    repeat_undo_on_hold
+                        .in_set(crate::game_plugin::UndoRequestWriters)
+                        .ambiguous_with(crate::game_plugin::UndoRequestWriters)
+                        .before(GameMutation),
+                    handle_draw_button
+                        .in_set(crate::game_plugin::DrawRequestWriters)
+                        .ambiguous_with(crate::game_plugin::DrawRequestWriters)
+                        .before(GameMutation),
                    handle_pause_button,
                    handle_help_button,
                    handle_hint_button
                        .after(GameMutation)
+                        // A press cancels/spawns the solver task before
+                        // this frame's drop/poll pass (#143).
+                        .before(crate::pending_hint::PendingHint)
                        .in_set(crate::game_plugin::InfoToastWriters)
                        .ambiguous_with(crate::game_plugin::InfoToastWriters),
-                    handle_modes_button,
+                    // The modes/menu popovers repaint the player level from
+                    // ProgressResource — read it after this frame's XP award
+                    // settles (#143).
+                    handle_modes_button
+                        .after(crate::progress_plugin::ProgressUpdate)
+                        .after(crate::achievement_plugin::AchievementEval),
                    handle_mode_option_click
                        .in_set(NewGameRequestWriters)
                        .ambiguous_with(NewGameRequestWriters),
                    handle_modes_backdrop_click,
                    close_modes_popover_on_escape,
                    handle_menu_button,
-                    handle_menu_option_click,
+                    handle_menu_option_click
+                        .after(crate::progress_plugin::ProgressUpdate)
+                        .after(crate::achievement_plugin::AchievementEval)
+                        .in_set(crate::profile_plugin::ProfileToggleWriters)
+                        .ambiguous_with(crate::profile_plugin::ProfileToggleWriters),
                    handle_menu_backdrop_click,
                    close_menu_popover_on_escape,
                    paint_action_buttons,
+                    paint_glass_tab_buttons,
+                    drive_tab_expansion,
+                    // Writes tab-label TextColor and reads TextFont — entity-
+                    // disjoint from the UiTextFx readout writers (tab labels
+                    // vs HUD readouts), which Bevy can't prove, so declare it.
+                    animate_tab_expansion
+                        .ambiguous_with(UiTextFx)
+                        // Tab-label fonts are never card/corner-label fonts.
+                        .ambiguous_with(crate::card_plugin::BoardVisuals)
+                        // Reads only reduce-motion; a frame of lag is
+                        // invisible, so it joins the settings-reader club.
+                        .in_set(crate::settings_plugin::SettingsAccess)
+                        .ambiguous_with(crate::settings_plugin::SettingsAccess),
+                    // Reads only reduce-motion — settings-reader club (#143).
+                    duck_tab_bar_during_drag
+                        .in_set(crate::settings_plugin::SettingsAccess)
+                        .ambiguous_with(crate::settings_plugin::SettingsAccess),
                )
                    .chain()
                    .in_set(HudButtons)
@@ -360,6 +360,7 @@ pub(super) fn handle_avatar_button(
 pub(super) fn spawn_action_buttons(
    font_res: Option<Res<FontResource>>,
    windows: Query<&Window>,
+    images: Option<ResMut<Assets<Image>>>,
    mut commands: Commands,
 ) {
    let action_font_size =
@@ -370,9 +371,18 @@ pub(super) fn spawn_action_buttons(
        ..default()
    };

-    // Bottom bar: full-width, centered, sits above the gesture-navigation zone.
+    // Touch layout: the floating glass tab bar (pill + circular Menu).
+    // `Assets<Image>` is absent under `MinimalPlugins`; `rasterize_into`
+    // returning `None` switches the bar to its text-fallback form.
+    if USE_TOUCH_UI_LAYOUT {
+        let icons = images.and_then(|mut imgs| TabIcons::rasterize_into(&mut imgs));
+        spawn_glass_tab_bar(&mut commands, &font, icons.as_ref());
+        return;
+    }
+
+    // Desktop bottom bar: full-width, centered, docked to the bottom edge.
    // `SafeAreaAnchoredBottom` applies the correct logical-pixel inset once
-    // Android reports it (frames 1-3); initial value is 0.0.
+    // the platform reports it; initial value is 0.0.
    commands
        .spawn((
            Node {
@@ -400,83 +410,89 @@ pub(super) fn spawn_action_buttons(
            HudActionBar,
        ))
        .with_children(|row| {
-            // The trailing `order` argument feeds `Focusable { group: Hud, order }`
-            // so Tab cycles the action bar in visual reading order.
-            // Undo and Pause are the primary gameplay actions — full brightness.
-            // Menu, Help, Hint, Modes, New are navigation/utility — dimmed.
-            spawn_action_button(
-                row,
-                MenuButton,
-                ACTION_BAR_LABELS[0],
-                None,
-                "Open Stats, Achievements, Profile, Settings, or Leaderboard.",
-                &font,
-                0,
-                TEXT_SECONDARY,
-            );
-            spawn_action_button(
-                row,
-                UndoButton,
-                ACTION_BAR_LABELS[1],
-                Some("U"),
-                "Take back your last move. Costs points and blocks No Undo.",
-                &font,
-                1,
-                TEXT_PRIMARY,
-            );
-            spawn_action_button(
-                row,
-                PauseButton,
-                ACTION_BAR_LABELS[2],
-                Some("Esc"),
-                "Pause the game and freeze the timer.",
-                &font,
-                2,
-                TEXT_PRIMARY,
-            );
-            spawn_action_button(
-                row,
-                HelpButton,
-                ACTION_BAR_LABELS[3],
-                Some("F1"),
-                "Show controls, rules, and keyboard shortcuts.",
-                &font,
-                3,
-                TEXT_SECONDARY,
-            );
-            spawn_action_button(
-                row,
-                HintButton,
-                ACTION_BAR_LABELS[4],
-                Some("H"),
-                "Highlight a suggested move. Cycles through alternatives on repeat taps.",
-                &font,
-                4,
-                TEXT_SECONDARY,
-            );
-            spawn_action_button(
-                row,
-                ModesButton,
-                ACTION_BAR_LABELS[5],
-                None,
-                "Switch modes: Classic, Daily, Zen, Challenge, Time Attack.",
-                &font,
-                5,
-                TEXT_SECONDARY,
-            );
-            spawn_action_button(
-                row,
-                NewGameButton,
-                ACTION_BAR_LABELS[6],
-                Some("N"),
-                "Start a fresh deal. Confirms first if a game is in progress.",
-                &font,
-                6,
-                TEXT_SECONDARY,
-            );
+            spawn_desktop_action_bar(row, &font);
        });
 }

+/// Desktop action bar — unchanged by Phase F (decision 5: the touch bar
+/// is touch-only). All seven actions, uniform sizing.
+pub(super) fn spawn_desktop_action_bar(row: &mut ChildSpawnerCommands, font: &TextFont) {
+    // The trailing `order` argument feeds `Focusable { group: Hud, order }`
+    // so Tab cycles the action bar in visual reading order.
+    // Undo and Pause are the primary gameplay actions — full brightness.
+    // Menu, Help, Hint, Modes, New are navigation/utility — dimmed.
+    spawn_action_button(
+        row,
+        MenuButton,
+        "Menu \u{2193}",
+        None,
+        "Open Stats, Achievements, Profile, Settings, or Leaderboard.",
+        font,
+        0,
+        TEXT_SECONDARY,
+    );
+    spawn_action_button(
+        row,
+        UndoButton,
+        "Undo",
+        Some("U"),
+        "Take back your last move. Hold to keep undoing. Costs points and blocks No Undo.",
+        font,
+        1,
+        TEXT_PRIMARY,
+    );
+    spawn_action_button(
+        row,
+        PauseButton,
+        "Pause",
+        Some("Esc"),
+        "Pause the game and freeze the timer.",
+        font,
+        2,
+        TEXT_PRIMARY,
+    );
+    spawn_action_button(
+        row,
+        HelpButton,
+        "Help",
+        Some("F1"),
+        "Show controls, rules, and keyboard shortcuts.",
+        font,
+        3,
+        TEXT_SECONDARY,
+    );
+    spawn_action_button(
+        row,
+        HintButton,
+        "Hint",
+        Some("H"),
+        "Highlight a suggested move. Cycles through alternatives on repeat taps.",
+        font,
+        4,
+        TEXT_SECONDARY,
+    );
+    spawn_action_button(
+        row,
+        ModesButton,
+        "Modes \u{2193}",
+        None,
+        "Switch modes: Classic, Daily, Zen, Challenge, Time Attack.",
+        font,
+        5,
+        TEXT_SECONDARY,
+    );
+    spawn_action_button(
+        row,
+        NewGameButton,
+        "New Game",
+        Some("N"),
+        "Start a fresh deal. Confirms first if a game is in progress.",
+        font,
+        6,
+        TEXT_SECONDARY,
+    );
+}
+
 /// Spawns a single action button as a child of `row`. Each button shares
 /// the same node geometry, idle colour, and `ActionButton` marker so
 /// `paint_action_buttons` can recolour all of them with one query.
@@ -510,13 +526,34 @@ pub(super) fn spawn_action_button<M: Component>(
        None
    };

+    let (pad, min_w, min_h) = action_button_metrics();
+    spawn_action_button_sized(
+        row, marker, label, hotkey, tooltip, font, order, text_color, pad, min_w, min_h,
+    );
+}
+
+/// Shared body of [`spawn_action_button`] — one place owns the component
+/// set so `paint_action_buttons`, tooltips, and the focus ring treat every
+/// bar button identically.
+#[allow(clippy::too_many_arguments)]
+fn spawn_action_button_sized<M: Component>(
+    row: &mut ChildSpawnerCommands,
+    marker: M,
+    label: &str,
+    hotkey: Option<&'static str>,
+    tooltip: &'static str,
+    font: &TextFont,
+    order: i32,
+    text_color: Color,
+    pad: UiRect,
+    min_w: Val,
+    min_h: Val,
+) {
    let hotkey_font = TextFont {
        font: font.font.clone(),
        font_size: TYPE_CAPTION,
        ..default()
    };
-    let (pad, min_w, min_h) = action_button_metrics();
-
    row.spawn((
        marker,
        ActionButton,
@@ -0,0 +1,529 @@
+//! Floating "liquid glass" touch tab bar — layout and animation.
+//!
+//! Replaces the docked full-width touch action bar (Phase F) with an
+//! iOS-26-style floating arrangement: a pill of icon buttons hovering
+//! above the bottom edge, plus a detached circular Menu button to its
+//! right. The *visual treatment* (translucent sheen, specular rim, drop
+//! shadow) lives in [`crate::ui_glass`]; this module owns only geometry,
+//! button wiring, and the expand/collapse label animation, so the glass
+//! material can be swapped without touching layout.
+//!
+//! Interaction compatibility: every button keeps the same marker
+//! components as the old bar (`UndoButton`, `DrawButton`, …) plus
+//! `ActionButton`, `Button`, `Tooltip`, and `Focusable`, so the click
+//! handlers, tooltips, focus ring, and the tap-to-toggle chrome guard in
+//! `interaction.rs` all work unchanged.
+//!
+//! Expansion model (user decision, 2026-07-15): **Draw** — the most
+//! frequent action — is the persistently-expanded "active" pill showing
+//! icon + label; the other buttons are icon-only and reveal their label
+//! with a width-animated slide while pressed.
+
+use super::*;
+use crate::assets::hud_icon_svg::HudIcon;
+use crate::ui_glass::{GLASS_BORDER_PX, glass_surface};
+use crate::ui_theme::{ACCENT_PRIMARY_HOVER, SPACE_3};
+use bevy::text::{LineBreak, TextLayout};
+use bevy::ui::{Overflow, UiTransform, Val2};
+
+use crate::resources::DragState;
+use crate::safe_area::SafeAreaInsets;
+
+/// Height of both the pill and the circular Menu button, in logical px.
+/// 64 keeps the inner 48-px buttons comfortably past the 44-px touch
+/// floor with 8 px of glass around them.
+pub(crate) const TAB_BAR_HEIGHT: f32 = 64.0;
+
+/// Gap between the bar and the bottom screen edge (the "floating" margin;
+/// the Android gesture-bar inset is added on top by `SafeAreaAnchoredBottom`).
+const TAB_BAR_MARGIN: f32 = SPACE_3;
+
+/// Vertical space UI stacked above the bar (the toast stack) must clear:
+/// floating margin + bar height + one spacing step of breathing room.
+pub(crate) const TAB_BAR_CLEARANCE_PX: f32 = TAB_BAR_MARGIN + TAB_BAR_HEIGHT + SPACE_2;
+
+/// Diameter of a button inside the pill (and its fully-round radius ×2).
+const TAB_BUTTON_SIZE: f32 = 48.0;
+
+/// Displayed icon size in logical px (texture is rasterised larger; see
+/// `assets::hud_icon_svg::HUD_ICON_TEXTURE_PX`).
+const TAB_ICON_PX: f32 = 24.0;
+
+/// FiraMono glyph advance as a fraction of font size. The bar is
+/// monospace-only, so `chars × advance × font_size` is the exact label
+/// width — the same ratio `action_bar_font_size` documents.
+const FIRA_ADVANCE: f32 = 0.62;
+
+/// Gap between an icon and its revealed label, folded into the animated
+/// wrapper width so it collapses together with the text.
+const LABEL_LEAD_PX: f32 = SPACE_2;
+
+/// Idle fill of an inactive icon button — fully transparent so the pill's
+/// glass shows through untouched.
+const GLASS_BTN_IDLE: Color = Color::srgba(1.0, 1.0, 1.0, 0.0);
+/// Hover fill of an inactive icon button (desktop pointer / DPAD focus).
+const GLASS_BTN_HOVER: Color = Color::srgba(1.0, 1.0, 1.0, 0.08);
+/// Pressed fill of an inactive icon button.
+const GLASS_BTN_PRESSED: Color = Color::srgba(1.0, 1.0, 1.0, 0.14);
+/// Pressed state of the active (accent-filled) pill — darker than idle so
+/// the press reads as the surface receding, mirroring `BG_ELEVATED_PRESSED`.
+const GLASS_ACTIVE_PRESSED: Color = Color::srgb(0.55, 0.22, 0.22);
+
+/// Idle / hovered / pressed fills for one tab-bar button. Presence of this
+/// component also routes the button to `paint_glass_tab_buttons` instead of
+/// the legacy `paint_action_buttons` (which excludes it).
+#[derive(Component, Debug)]
+pub struct GlassTabButton {
+    idle: Color,
+    hovered: Color,
+    pressed: Color,
+}
+
+/// Animated label-reveal state, on the clipping wrapper node between the
+/// button and its `Text` label. `progress` ∈ [0, 1] maps to wrapper width
+/// via [`expansion_width`]; `target` is where it is heading.
+#[derive(Component, Debug)]
+pub struct TabLabelWrap {
+    /// Current reveal amount, 0 = collapsed, 1 = fully expanded.
+    pub progress: f32,
+    /// Reveal amount the animation is moving towards.
+    pub target: f32,
+    /// `true` keeps the label expanded regardless of interaction —
+    /// the persistent Draw pill, and every button in text-fallback mode.
+    persistent: bool,
+    /// Label length; width is recomputed from the live font size each
+    /// frame so viewport-driven font rescales stay correct.
+    label_chars: usize,
+    /// Last width written to the node, to skip no-op layout writes.
+    last_width: f32,
+}
+
+/// Marker on the label `Text` inside a [`TabLabelWrap`].
+#[derive(Component, Debug)]
+pub struct TabLabel;
+
+/// Duck-away state on the bar container: while a card drag is committed
+/// the whole bar slides below the screen edge so it never occludes a
+/// drop target on the bottom tableau rows, then slides back on release.
+/// `progress` ∈ [0, 1]; 1 = fully off-screen.
+#[derive(Component, Debug)]
+pub struct TabBarDuck {
+    /// Current slide amount, animated by [`duck_tab_bar_during_drag`].
+    pub progress: f32,
+}
+
+/// Extra slide distance past the bar's own height so its drop shadow
+/// (16 px blur + 6 px offset) also clears the screen edge.
+const DUCK_SHADOW_ALLOWANCE_PX: f32 = 24.0;
+
+/// Rasterised icon textures for the five tab-bar actions.
+pub(super) struct TabIcons {
+    undo: Handle<Image>,
+    draw: Handle<Image>,
+    hint: Handle<Image>,
+    pause: Handle<Image>,
+    menu: Handle<Image>,
+}
+
+impl TabIcons {
+    /// Rasterise all five icons into `images`. Returns `None` (and warns)
+    /// if any icon fails — the caller then falls back to text-only labels,
+    /// so a bad SVG degrades the look, never the playability.
+    pub(super) fn rasterize_into(images: &mut Assets<Image>) -> Option<Self> {
+        let mut add = |icon: HudIcon| match icon.rasterize() {
+            Ok(img) => Some(images.add(img)),
+            Err(e) => {
+                warn!("tab_bar: failed to rasterise {icon:?} icon: {e}");
+                None
+            }
+        };
+        Some(Self {
+            undo: add(HudIcon::Undo)?,
+            draw: add(HudIcon::Draw)?,
+            hint: add(HudIcon::Hint)?,
+            pause: add(HudIcon::Pause)?,
+            menu: add(HudIcon::Menu)?,
+        })
+    }
+}
+
+/// Wrapper width in logical px for a label of `chars` monospace glyphs at
+/// `font_size`, revealed to `progress`. Pure so the animation curve is
+/// unit-testable without an app.
+pub(super) fn expansion_width(chars: usize, font_size: f32, progress: f32) -> f32 {
+    progress.clamp(0.0, 1.0) * (LABEL_LEAD_PX + chars as f32 * font_size * FIRA_ADVANCE)
+}
+
+/// Advance `progress` towards `target` by one frame of `dt` seconds.
+/// Linear tween over `MOTION_SLIDE_SECS`, snapping when reduce-motion is
+/// active. Pure for the same reason as [`expansion_width`].
+pub(super) fn step_expansion(progress: f32, target: f32, dt: f32, reduce_motion: bool) -> f32 {
+    if reduce_motion {
+        return target;
+    }
+    let max_step = dt / crate::ui_theme::MOTION_SLIDE_SECS;
+    progress + (target - progress).clamp(-max_step, max_step)
+}
+
+/// Spawns the floating glass tab bar: one full-width invisible flex row
+/// (carrying the `HudActionBar` marker so chrome show/hide keeps working)
+/// centring the glass pill and the detached circular Menu button.
+///
+/// `icons: None` (rasteriser unavailable, e.g. `MinimalPlugins` tests, or
+/// an SVG regression) switches every button to text-fallback: labels stay
+/// expanded so the bar remains fully usable without textures.
+pub(super) fn spawn_glass_tab_bar(
+    commands: &mut Commands,
+    font: &TextFont,
+    icons: Option<&TabIcons>,
+) {
+    let text_fallback = icons.is_none();
+    commands
+        .spawn((
+            Node {
+                position_type: PositionType::Absolute,
+                bottom: Val::Px(TAB_BAR_MARGIN),
+                left: Val::Px(0.0),
+                width: Val::Percent(100.0),
+                flex_direction: FlexDirection::Row,
+                justify_content: JustifyContent::Center,
+                align_items: AlignItems::Center,
+                column_gap: VAL_SPACE_3,
+                ..default()
+            },
+            ZIndex(Z_HUD),
+            SafeAreaAnchoredBottom {
+                base_bottom: TAB_BAR_MARGIN,
+            },
+            HudActionBar,
+            TabBarDuck { progress: 0.0 },
+            UiTransform::IDENTITY,
+        ))
+        .with_children(|bar| {
+            // The main pill: Undo · [Draw] · Hint · Pause.
+            bar.spawn((
+                Node {
+                    height: Val::Px(TAB_BAR_HEIGHT),
+                    flex_direction: FlexDirection::Row,
+                    align_items: AlignItems::Center,
+                    padding: UiRect::axes(Val::Px(SPACE_2), Val::Px(0.0)),
+                    column_gap: Val::Px(4.0),
+                    border: UiRect::all(Val::Px(GLASS_BORDER_PX)),
+                    border_radius: BorderRadius::all(Val::Px(TAB_BAR_HEIGHT / 2.0)),
+                    ..default()
+                },
+                glass_surface(),
+            ))
+            .with_children(|pill| {
+                spawn_tab_button(
+                    pill,
+                    UndoButton,
+                    "Undo",
+                    "Take back your last move. Hold to keep undoing. Costs points and blocks No Undo.",
+                    font,
+                    0,
+                    icons.map(|i| i.undo.clone()),
+                    false,
+                    text_fallback,
+                );
+                spawn_tab_button(
+                    pill,
+                    DrawButton,
+                    "Draw",
+                    "Draw from the stock — same as tapping the deck.",
+                    font,
+                    1,
+                    icons.map(|i| i.draw.clone()),
+                    true,
+                    text_fallback,
+                );
+                spawn_tab_button(
+                    pill,
+                    HintButton,
+                    TOUCH_HINT_LABEL,
+                    "Highlight a suggested move. Cycles through alternatives on repeat taps.",
+                    font,
+                    2,
+                    icons.map(|i| i.hint.clone()),
+                    false,
+                    text_fallback,
+                );
+                spawn_tab_button(
+                    pill,
+                    PauseButton,
+                    "Pause",
+                    "Pause the game and freeze the timer.",
+                    font,
+                    3,
+                    icons.map(|i| i.pause.clone()),
+                    false,
+                    text_fallback,
+                );
+            });
+
+            // The detached circular Menu button, same glass material.
+            bar.spawn((
+                MenuButton,
+                ActionButton,
+                Button,
+                GlassTabButton {
+                    idle: GLASS_BTN_IDLE,
+                    hovered: GLASS_BTN_HOVER,
+                    pressed: GLASS_BTN_PRESSED,
+                },
+                Tooltip::new(
+                    "Open Home, Stats, Achievements, Profile, Settings, or Leaderboard.",
+                ),
+                Focusable {
+                    group: FocusGroup::Hud,
+                    order: 4,
+                },
+                Node {
+                    width: Val::Px(TAB_BAR_HEIGHT),
+                    height: Val::Px(TAB_BAR_HEIGHT),
+                    justify_content: JustifyContent::Center,
+                    align_items: AlignItems::Center,
+                    border: UiRect::all(Val::Px(GLASS_BORDER_PX)),
+                    border_radius: BorderRadius::all(Val::Px(TAB_BAR_HEIGHT / 2.0)),
+                    ..default()
+                },
+                BackgroundColor(GLASS_BTN_IDLE),
+                glass_surface(),
+            ))
+            .with_children(|circle| {
+                if let Some(icons) = icons {
+                    spawn_tab_icon(circle, icons.menu.clone(), TEXT_PRIMARY);
+                } else {
+                    // Text fallback: a menu glyph-free label keeps the
+                    // button discoverable without any texture.
+                    circle.spawn((
+                        Text::new("Menu"),
+                        TextLayout::new_with_linebreak(LineBreak::NoWrap),
+                        font.clone(),
+                        TextColor(TEXT_PRIMARY),
+                    ));
+                }
+            });
+        });
+}
+
+/// Spawns one button inside the pill: icon, then the width-animated label
+/// wrapper. `active` gives the accent-filled persistent pill (Draw);
+/// `text_fallback` pins every label open when icons are unavailable.
+#[allow(clippy::too_many_arguments)]
+fn spawn_tab_button<M: Component>(
+    pill: &mut ChildSpawnerCommands,
+    marker: M,
+    label: &str,
+    tooltip: &'static str,
+    font: &TextFont,
+    order: i32,
+    icon: Option<Handle<Image>>,
+    active: bool,
+    text_fallback: bool,
+) {
+    let (idle, hovered, pressed) = if active {
+        (ACCENT_PRIMARY, ACCENT_PRIMARY_HOVER, GLASS_ACTIVE_PRESSED)
+    } else {
+        (GLASS_BTN_IDLE, GLASS_BTN_HOVER, GLASS_BTN_PRESSED)
+    };
+    let icon_tint = if active { TEXT_PRIMARY } else { TEXT_SECONDARY };
+    let persistent = active || text_fallback;
+    let start = if persistent { 1.0 } else { 0.0 };
+    let chars = label.chars().count();
+
+    pill.spawn((
+        marker,
+        ActionButton,
+        Button,
+        GlassTabButton {
+            idle,
+            hovered,
+            pressed,
+        },
+        Tooltip::new(tooltip),
+        Focusable {
+            group: FocusGroup::Hud,
+            order,
+        },
+        Node {
+            height: Val::Px(TAB_BUTTON_SIZE),
+            min_width: Val::Px(TAB_BUTTON_SIZE),
+            flex_direction: FlexDirection::Row,
+            justify_content: JustifyContent::Center,
+            align_items: AlignItems::Center,
+            padding: UiRect::axes(Val::Px(SPACE_3), Val::Px(0.0)),
+            border_radius: BorderRadius::all(Val::Px(TAB_BUTTON_SIZE / 2.0)),
+            ..default()
+        },
+        BackgroundColor(idle),
+    ))
+    .with_children(|b| {
+        if let Some(handle) = icon {
+            spawn_tab_icon(b, handle, icon_tint);
+        }
+        // The clipping wrapper the animation drives. Label text sits
+        // left-anchored inside, so growing the width reveals it
+        // left-to-right and shrinking clips it from the right.
+        b.spawn((
+            TabLabelWrap {
+                progress: start,
+                target: start,
+                persistent,
+                label_chars: chars,
+                last_width: f32::NAN,
+            },
+            Node {
+                overflow: Overflow::clip(),
+                width: Val::Px(expansion_width(chars, font.font_size, start)),
+                height: Val::Percent(100.0),
+                align_items: AlignItems::Center,
+                justify_content: JustifyContent::FlexEnd,
+                ..default()
+            },
+        ))
+        .with_children(|wrap| {
+            let mut color = TEXT_PRIMARY;
+            color.set_alpha(start);
+            wrap.spawn((
+                TabLabel,
+                ActionButtonLabel,
+                Text::new(label),
+                TextLayout::new_with_linebreak(LineBreak::NoWrap),
+                font.clone(),
+                TextColor(color),
+            ));
+        });
+    });
+}
+
+/// One fixed-size tinted icon node.
+fn spawn_tab_icon(parent: &mut ChildSpawnerCommands, handle: Handle<Image>, tint: Color) {
+    parent.spawn((
+        ImageNode {
+            color: tint,
+            ..ImageNode::new(handle)
+        },
+        Node {
+            width: Val::Px(TAB_ICON_PX),
+            height: Val::Px(TAB_ICON_PX),
+            flex_shrink: 0.0,
+            ..default()
+        },
+    ));
+}
+
+/// Sets each label wrapper's animation target from its button's
+/// interaction state: persistent wrappers pin to 1, the rest expand while
+/// pressed or hovered and collapse on release.
+pub(super) fn drive_tab_expansion(
+    buttons: Query<(&Interaction, &Children), With<GlassTabButton>>,
+    mut wraps: Query<&mut TabLabelWrap>,
+) {
+    for (interaction, children) in &buttons {
+        for child in children.iter() {
+            let Ok(mut wrap) = wraps.get_mut(child) else {
+                continue;
+            };
+            let target = if wrap.persistent || !matches!(interaction, Interaction::None) {
+                1.0
+            } else {
+                0.0
+            };
+            // Bypass change detection on no-ops so `animate_tab_expansion`
+            // and layout stay idle while nothing moves.
+            if wrap.target != target {
+                wrap.target = target;
+            }
+        }
+    }
+}
+
+/// Advances every label reveal towards its target and writes the wrapper
+/// width + label alpha. Width is derived from the label's *live* font size,
+/// so the Fold's posture-change font rescale re-widens expanded labels
+/// automatically. Node writes are skipped when the width is unchanged to
+/// avoid dirtying UI layout every frame.
+pub(super) fn animate_tab_expansion(
+    time: Res<Time>,
+    settings: Option<Res<SettingsResource>>,
+    mut wraps: Query<(&mut TabLabelWrap, &mut Node, &Children)>,
+    mut labels: Query<(&TextFont, &mut TextColor), With<TabLabel>>,
+) {
+    let reduce_motion = settings.as_deref().is_some_and(|s| s.0.reduce_motion_mode);
+    let dt = time.delta_secs();
+    for (mut wrap, mut node, children) in &mut wraps {
+        for child in children.iter() {
+            let Ok((font, mut text_color)) = labels.get_mut(child) else {
+                continue;
+            };
+            let next = step_expansion(wrap.progress, wrap.target, dt, reduce_motion);
+            let width = expansion_width(wrap.label_chars, font.font_size, next);
+            // `!=` (not epsilon) is deliberate: last_width starts NaN so the
+            // first frame always writes, and equal floats mean a true no-op.
+            if next != wrap.progress || width != wrap.last_width {
+                wrap.progress = next;
+                wrap.last_width = width;
+                node.width = Val::Px(width);
+                text_color.0.set_alpha(next);
+            }
+            break;
+        }
+    }
+}
+
+/// Slides the bar off the bottom edge while a card drag is committed and
+/// back once it ends. Effectively touch-only: the desktop docked bar
+/// never carries [`TabBarDuck`], so the query is empty there.
+///
+/// The slide animates `UiTransform::translation` (a render-time offset,
+/// +y = down) rather than `Node::bottom`, for two reasons: layout is
+/// never dirtied mid-drag (the whole point is not to cost frames while
+/// the player is dragging), and `Node::bottom` is owned by the safe-area
+/// anchor system — two writers on one field would fight.
+pub(super) fn duck_tab_bar_during_drag(
+    time: Res<Time>,
+    settings: Option<Res<SettingsResource>>,
+    drag: Option<Res<DragState>>,
+    insets: Option<Res<SafeAreaInsets>>,
+    windows: Query<&Window>,
+    mut bars: Query<(&mut TabBarDuck, &mut UiTransform), With<HudActionBar>>,
+) {
+    let target = if drag.as_deref().is_some_and(|d| d.committed) {
+        1.0
+    } else {
+        0.0
+    };
+    let reduce_motion = settings.as_deref().is_some_and(|s| s.0.reduce_motion_mode);
+    let dt = time.delta_secs();
+    // Physical-px inset → logical, same conversion the safe-area anchors
+    // apply (CLAUDE.md §10): the bar sits `inset` above its base position,
+    // so the slide must cover that extra travel to fully clear the edge.
+    let scale = windows.iter().next().map_or(1.0, |w| w.scale_factor());
+    let inset_logical = insets.as_deref().map_or(0.0, |i| i.bottom / scale);
+    let slide_px = TAB_BAR_CLEARANCE_PX + inset_logical + DUCK_SHADOW_ALLOWANCE_PX;
+    for (mut duck, mut transform) in &mut bars {
+        let next = step_expansion(duck.progress, target, dt, reduce_motion);
+        if next == duck.progress && duck.progress == target {
+            continue;
+        }
+        duck.progress = next;
+        transform.translation = Val2::px(0.0, next * slide_px);
+    }
+}
+
+/// Idle / hover / pressed feedback for glass tab buttons — the glass
+/// counterpart of `paint_action_buttons`, using each button's own colour
+/// triple so the accent-filled active pill and the transparent icon
+/// buttons share one system.
+pub(super) fn paint_glass_tab_buttons(
+    mut buttons: Query<(&Interaction, &GlassTabButton, &mut BackgroundColor), Changed<Interaction>>,
+) {
+    for (interaction, style, mut bg) in &mut buttons {
+        bg.0 = match interaction {
+            Interaction::Pressed => style.pressed,
+            Interaction::Hovered => style.hovered,
+            Interaction::None => style.idle,
+        };
+    }
+}
@@ -670,7 +670,7 @@ fn hud_elements_carry_expected_tooltip_strings() {
    );
    assert_eq!(
        tooltip_for::<UndoButton>(&mut app),
-        "Take back your last move. Costs points and blocks No Undo."
+        "Take back your last move. Hold to keep undoing. Costs points and blocks No Undo."
    );
    assert_eq!(
        tooltip_for::<PauseButton>(&mut app),
@@ -899,3 +899,285 @@ fn hud_focus_only_engages_when_button_hovered() {
        "Hud-engaged Tab must focus a Hud-grouped entity"
    );
 }
+
+// ---------------------------------------------------------------------------
+// Phase F: touch action bar + hold-to-repeat undo
+// ---------------------------------------------------------------------------
+
+/// Bare app (no `HudPlugin`) so bar-content assertions count only the
+/// buttons the tested spawn function creates — `headless_app` would
+/// pre-spawn the platform-default bar and pollute the counts.
+///
+/// The touch branch spawns the glass tab bar with `icons: None`
+/// (`MinimalPlugins` has no `Assets<Image>`), which exercises the
+/// text-fallback path — same markers, labels pinned expanded.
+fn bar_only_app(touch: bool) -> App {
+    let mut app = App::new();
+    app.add_plugins(MinimalPlugins);
+    app.update();
+    let font = TextFont::default();
+    let world = app.world_mut();
+    let mut commands = world.commands();
+    if touch {
+        spawn_glass_tab_bar(&mut commands, &font, None);
+    } else {
+        commands.spawn(Node::default()).with_children(|row| {
+            spawn_desktop_action_bar(row, &font);
+        });
+    }
+    app.update();
+    app
+}
+
+fn count_buttons<C: Component>(app: &mut App) -> usize {
+    app.world_mut()
+        .query_filtered::<(), With<C>>()
+        .iter(app.world())
+        .count()
+}
+
+#[test]
+fn touch_tab_bar_has_thumb_trio_plus_menu_and_pause() {
+    let mut app = bar_only_app(true);
+
+    assert_eq!(count_buttons::<UndoButton>(&mut app), 1);
+    assert_eq!(count_buttons::<DrawButton>(&mut app), 1);
+    assert_eq!(count_buttons::<HintButton>(&mut app), 1);
+    assert_eq!(count_buttons::<MenuButton>(&mut app), 1);
+    assert_eq!(count_buttons::<PauseButton>(&mut app), 1);
+
+    // Utility actions live elsewhere on touch: Help in Menu → System,
+    // modes on the Home screen, New Game on Home's hero button.
+    assert_eq!(count_buttons::<HelpButton>(&mut app), 0);
+    assert_eq!(count_buttons::<ModesButton>(&mut app), 0);
+    assert_eq!(count_buttons::<NewGameButton>(&mut app), 0);
+}
+
+/// The glass bar floats: its container must carry a bottom margin (not be
+/// docked at 0) both before and after safe-area insets arrive.
+#[test]
+fn glass_tab_bar_floats_above_bottom_edge() {
+    let mut app = bar_only_app(true);
+    let world = app.world_mut();
+    let mut q = world.query_filtered::<(&Node, &SafeAreaAnchoredBottom), With<HudActionBar>>();
+    let (node, anchor) = q.single(world).expect("glass bar container exists");
+    assert!(anchor.base_bottom > 0.0, "bar must float, not dock");
+    assert_eq!(node.bottom, Val::Px(anchor.base_bottom));
+}
+
+/// Draw is the persistently-expanded active pill (user decision
+/// 2026-07-15); with `icons: None` every wrapper is pinned expanded via
+/// text fallback, so instead assert on the *persistent* flag's effect:
+/// all wrappers spawn at full reveal and target full reveal.
+#[test]
+fn glass_tab_bar_text_fallback_pins_labels_expanded() {
+    let mut app = bar_only_app(true);
+    let world = app.world_mut();
+    let mut q = world.query::<&TabLabelWrap>();
+    let wraps: Vec<_> = q.iter(world).collect();
+    assert_eq!(wraps.len(), 4, "Undo/Draw/Hint/Pause each carry a wrapper");
+    for wrap in wraps {
+        assert_eq!(wrap.progress, 1.0);
+        assert_eq!(wrap.target, 1.0);
+    }
+}
+
+/// Focus order must match visual reading order: pill buttons left to
+/// right, then the detached Menu circle.
+#[test]
+fn glass_tab_bar_focus_order_reads_left_to_right() {
+    let mut app = bar_only_app(true);
+
+    for (f, expected) in [
+        (focusable_for::<UndoButton>(&mut app), 0),
+        (focusable_for::<DrawButton>(&mut app), 1),
+        (focusable_for::<HintButton>(&mut app), 2),
+        (focusable_for::<PauseButton>(&mut app), 3),
+        (focusable_for::<MenuButton>(&mut app), 4),
+    ] {
+        assert_eq!(f.group, FocusGroup::Hud);
+        assert_eq!(f.order, expected);
+    }
+}
+
+/// `expansion_width` is the single source of truth for the label reveal:
+/// zero when collapsed, lead + monospace advance when expanded, linear
+/// in between.
+#[test]
+fn expansion_width_is_linear_in_progress() {
+    assert_eq!(expansion_width(4, 16.0, 0.0), 0.0);
+    let full = expansion_width(4, 16.0, 1.0);
+    assert!(full > 4.0 * 16.0 * 0.62, "full width includes the lead gap");
+    let half = expansion_width(4, 16.0, 0.5);
+    assert!((half - full / 2.0).abs() < f32::EPSILON * 100.0);
+    // Out-of-range progress clamps rather than extrapolating.
+    assert_eq!(expansion_width(4, 16.0, 1.5), full);
+}
+
+/// While a committed drag is active the bar must slide down (positive
+/// `UiTransform` y — off-screen) and return to identity once the drag
+/// ends. Manual time steps make the tween deterministic.
+#[test]
+fn tab_bar_ducks_during_committed_drag_and_returns() {
+    use crate::resources::DragState;
+    use bevy::ui::UiTransform;
+
+    let mut app = bar_only_app(true);
+    set_manual_time_step(&mut app, 0.05);
+    app.add_systems(Update, duck_tab_bar_during_drag);
+    app.insert_resource(DragState {
+        committed: true,
+        ..default()
+    });
+
+    let translation_y_px = |app: &mut App| -> f32 {
+        let world = app.world_mut();
+        let mut q = world.query_filtered::<&UiTransform, With<HudActionBar>>();
+        let t = q.single(world).expect("bar carries UiTransform");
+        match t.translation.y {
+            Val::Px(px) => px,
+            other => panic!("duck must write Val::Px, got {other:?}"),
+        }
+    };
+
+    // 0.18s slide at 0.05s/frame: fully ducked within 5 frames.
+    app.update();
+    app.update();
+    let mid = translation_y_px(&mut app);
+    assert!(mid > 0.0, "bar must start sliding down: {mid}");
+    for _ in 0..5 {
+        app.update();
+    }
+    let ducked = translation_y_px(&mut app);
+    assert!(
+        ducked > TAB_BAR_CLEARANCE_PX,
+        "fully ducked bar must clear its own floating footprint: {ducked}"
+    );
+
+    // Drag ends → bar slides back to identity.
+    app.world_mut().resource_mut::<DragState>().committed = false;
+    for _ in 0..8 {
+        app.update();
+    }
+    assert_eq!(translation_y_px(&mut app), 0.0);
+}
+
+/// The tween must move at the `MOTION_SLIDE_SECS` rate, never overshoot,
+/// and snap instantly under reduce-motion.
+#[test]
+fn step_expansion_tweens_and_respects_reduce_motion() {
+    // One 60 fps frame covers 1/(0.18*60) ≈ 9.3% of the reveal.
+    let one_frame = step_expansion(0.0, 1.0, 1.0 / 60.0, false);
+    assert!(one_frame > 0.0 && one_frame < 0.2);
+    // A huge dt clamps at the target instead of overshooting.
+    assert_eq!(step_expansion(0.0, 1.0, 10.0, false), 1.0);
+    // Collapse works symmetrically.
+    assert!(step_expansion(1.0, 0.0, 1.0 / 60.0, false) < 1.0);
+    // Reduce-motion snaps regardless of dt.
+    assert_eq!(step_expansion(0.0, 1.0, 0.0, true), 1.0);
+}
+
+#[test]
+fn desktop_action_bar_keeps_all_seven_and_no_draw() {
+    let mut app = bar_only_app(false);
+
+    for (count, name) in [
+        (count_buttons::<MenuButton>(&mut app), "Menu"),
+        (count_buttons::<UndoButton>(&mut app), "Undo"),
+        (count_buttons::<PauseButton>(&mut app), "Pause"),
+        (count_buttons::<HelpButton>(&mut app), "Help"),
+        (count_buttons::<HintButton>(&mut app), "Hint"),
+        (count_buttons::<ModesButton>(&mut app), "Modes"),
+        (count_buttons::<NewGameButton>(&mut app), "New Game"),
+    ] {
+        assert_eq!(count, 1, "desktop bar must keep its {name} button");
+    }
+    assert_eq!(
+        count_buttons::<DrawButton>(&mut app),
+        0,
+        "Draw is touch-only (decision 5); desktop draws via stock click / D / Space"
+    );
+}
+
+#[test]
+fn draw_button_press_fires_draw_request() {
+    let mut app = headless_app();
+    app.world_mut()
+        .resource_mut::<Messages<DrawRequestEvent>>()
+        .clear();
+
+    app.world_mut().spawn((DrawButton, Interaction::Pressed));
+    app.update();
+
+    let events = app.world().resource::<Messages<DrawRequestEvent>>();
+    let mut cursor = events.get_cursor();
+    assert_eq!(
+        cursor.read(events).count(),
+        1,
+        "pressing the Draw button must fire exactly one DrawRequestEvent"
+    );
+}
+
+#[test]
+fn draw_button_press_is_noop_while_paused() {
+    let mut app = headless_app();
+    app.insert_resource(PausedResource(true));
+    app.world_mut()
+        .resource_mut::<Messages<DrawRequestEvent>>()
+        .clear();
+
+    app.world_mut().spawn((DrawButton, Interaction::Pressed));
+    app.update();
+
+    let events = app.world().resource::<Messages<DrawRequestEvent>>();
+    let mut cursor = events.get_cursor();
+    assert_eq!(
+        cursor.read(events).count(),
+        0,
+        "the Draw button must be inert while paused (mirrors the stock-click guard)"
+    );
+}
+
+/// The timing contract for hold-to-repeat undo, exercised through the
+/// pure boundary function so no wall-clock is involved. Delay = 0.45 s,
+/// interval = 0.18 s → boundaries at 0.45, 0.63, 0.81, …
+#[test]
+fn undo_hold_boundary_math() {
+    // A tap never repeats.
+    assert!(!undo_hold_crossed_fire_boundary(0.0, 0.05));
+    assert!(!undo_hold_crossed_fire_boundary(0.2, 0.44));
+    // Crossing the initial delay fires the first repeat.
+    assert!(undo_hold_crossed_fire_boundary(0.44, 0.46));
+    // Inside the first repeat interval: quiet.
+    assert!(!undo_hold_crossed_fire_boundary(0.46, 0.62));
+    // Each interval boundary fires exactly once.
+    assert!(undo_hold_crossed_fire_boundary(0.62, 0.64));
+    assert!(!undo_hold_crossed_fire_boundary(0.64, 0.80));
+    assert!(undo_hold_crossed_fire_boundary(0.80, 0.82));
+}
+
+#[test]
+fn undo_hold_state_accumulates_and_resets_on_release() {
+    let mut app = headless_app();
+    let button = app
+        .world_mut()
+        .spawn((UndoButton, Interaction::Pressed))
+        .id();
+    app.update();
+    app.update();
+    app.update();
+
+    assert!(
+        app.world().resource::<UndoHoldState>().held_secs > 0.0,
+        "held time must accumulate while the Undo button stays pressed"
+    );
+
+    app.world_mut().entity_mut(button).insert(Interaction::None);
+    app.update();
+
+    assert_eq!(
+        app.world().resource::<UndoHoldState>().held_secs,
+        0.0,
+        "releasing the Undo button must reset the hold state"
+    );
+}
@@ -554,11 +554,11 @@ pub(super) fn action_bar_font_size(window_width: f32) -> f32 {

 pub(super) fn action_button_metrics() -> (UiRect, Val, Val) {
    if USE_TOUCH_UI_LAYOUT {
-        // Tight 3 px horizontal padding (down from 4) trims 14 px off the row
-        // total across 7 buttons, and a 44 px min_width (down from 52) lets the
-        // shortest labels ("New", "Help") shrink to their text rather than
-        // padding the row out past the 900 logical-px viewport. min_height
-        // stays at 44 px to preserve the comfortable touch target.
+        // Tight 3 px horizontal padding keeps the compact buttons narrow;
+        // Phase F trimmed the touch bar to 5 buttons (2 compact + 3
+        // primary), so width pressure is lower than the old 7-button row.
+        // min_height stays at 44 px to preserve the comfortable touch
+        // target on the compact buttons.
        (
            UiRect::axes(Val::Px(3.0), Val::Px(4.0)),
            Val::Px(44.0),
@@ -58,6 +58,14 @@ use crate::touch_selection_plugin::TouchSelectionState;
 use crate::ui_theme::{MOTION_DRAG_REJECT_SECS, STATE_SUCCESS, STATE_WARNING};
 use solitaire_core::DrawStockConfig;

+/// Set wrapping the core pointer/keyboard input chain (clicks, drags, touch,
+/// hotkeys). Runs between [`crate::game_plugin::PreMutation`] (it reads the
+/// ticked game state) and [`crate::selection_plugin::SelectionKeySet`] (the
+/// selection keys check `DragState::is_idle`); request events it emits are
+/// consumed at `GameMutation` in the same frame (#143).
+#[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct PointerInput;
+
 /// System-set labels used to anchor external systems relative to the touch
 /// drag pipeline without duplicating the internal chain ordering.
 #[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
@@ -136,11 +144,28 @@ impl Plugin for InputPlugin {
            .add_systems(
                Update,
                (
-                    handle_keyboard_core,
+                    // The three `DrawRequestEvent` writers join the
+                    // self-ambiguous `DrawRequestWriters` set so the HUD's
+                    // touch Draw button (hud_plugin, Phase F) can write the
+                    // same queue without tripping the ambiguity gate. The
+                    // `.chain()` still orders them relative to each other.
+                    handle_keyboard_core
+                        .in_set(crate::game_plugin::DrawRequestWriters)
+                        .ambiguous_with(crate::game_plugin::DrawRequestWriters)
+                        // N/Z/X/… and U also feed the shared new-game and
+                        // undo request streams (#143).
+                        .in_set(crate::game_plugin::NewGameRequestWriters)
+                        .ambiguous_with(crate::game_plugin::NewGameRequestWriters)
+                        .in_set(crate::game_plugin::UndoRequestWriters)
+                        .ambiguous_with(crate::game_plugin::UndoRequestWriters),
                    handle_keyboard_hint,
                    handle_keyboard_forfeit,
-                    handle_stock_click,
-                    handle_touch_stock_tap,
+                    handle_stock_click
+                        .in_set(crate::game_plugin::DrawRequestWriters)
+                        .ambiguous_with(crate::game_plugin::DrawRequestWriters),
+                    handle_touch_stock_tap
+                        .in_set(crate::game_plugin::DrawRequestWriters)
+                        .ambiguous_with(crate::game_plugin::DrawRequestWriters),
                    handle_double_click,
                    // Mouse drag pipeline.
                    start_drag,
@@ -148,29 +173,61 @@ impl Plugin for InputPlugin {
                    end_drag.before(GameMutation),
                    // Touch drag pipeline (parallel path through DragState).
                    touch_start_drag.in_set(TouchDragSet::AfterStartDrag),
-                    touch_follow_drag,
+                    // Moves the dragged card's Transform; UiTextFx members
+                    // animate chrome entities only — disjoint domains Bevy
+                    // can't prove (#143).
+                    touch_follow_drag.ambiguous_with(crate::ui_theme::UiTextFx),
                    handle_double_tap, // before touch_end_drag: reads drag state pre-clear
                    touch_end_drag
                        .after(TouchDragSet::BeforeEndDrag)
                        .before(GameMutation),
+                    // Reads StateChangedEvent via cursor — a reset one frame
+                    // after the mutation is invisible (the cycle index only
+                    // matters on the next H press), so it rides at the end
+                    // of the input chain instead of chasing every
+                    // StateChanged writer (#143).
+                    // It also drains the new-game request stream via its own
+                    // cursor, so it joins the writer club the same way
+                    // enqueue_toasts does (#143).
+                    reset_hint_cycle_on_state_change
+                        .in_set(crate::game_plugin::NewGameRequestWriters)
+                        .ambiguous_with(crate::game_plugin::NewGameRequestWriters),
                )
-                    .chain(),
+                    .chain()
+                    .in_set(PointerInput),
            )
-            .add_systems(Update, reset_hint_cycle_on_state_change);
+            .configure_sets(
+                Update,
+                PointerInput
+                    .after(crate::game_plugin::PreMutation)
+                    .before(crate::selection_plugin::SelectionKeySet)
+                    .before(crate::ui_focus::FocusKeys),
+            );
        // F11 fullscreen toggle is desktop-only; Android windows are always full-screen.
+        // It writes only `Window.mode`; no system reads the mode, and the
+        // geometry change it triggers arrives via WindowResized events on a
+        // later frame — order against Window readers is provably irrelevant
+        // (#143).
        #[cfg(not(target_os = "android"))]
-        app.add_systems(Update, handle_fullscreen);
+        app.add_systems(Update, handle_fullscreen.ambiguous_with_all());
        app
            // Async hint pipeline: state-change drop runs before the
            // poll system so a move applied this frame cancels any
-            // in-flight task before its result can be surfaced.
+            // in-flight task before its result can be surfaced. The poll
+            // emits the hint toast and the pile-highlight event the board
+            // painters consume this frame (#143).
            .add_systems(
                Update,
                (
                    crate::pending_hint::drop_pending_hint_on_state_change,
-                    crate::pending_hint::poll_pending_hint_task,
+                    crate::pending_hint::poll_pending_hint_task
+                        .in_set(crate::game_plugin::InfoToastWriters)
+                        .ambiguous_with(crate::game_plugin::InfoToastWriters),
                )
-                    .chain(),
+                    .chain()
+                    .in_set(crate::pending_hint::PendingHint)
+                    .after(GameMutation)
+                    .before(crate::auto_complete_plugin::AutoComplete),
            );
    }
 }
@@ -204,6 +261,7 @@ fn handle_keyboard_core(
    keys: Res<ButtonInput<KeyCode>>,
    paused: Option<Res<PausedResource>>,
    progress: Option<Res<ProgressResource>>,
+    drag: Res<DragState>,
    mut ev: CoreKeyboardMessages<'_>,
    mut time_attack: Option<ResMut<TimeAttackResource>>,
    selection: Option<Res<SelectionState>>,
@@ -216,6 +274,19 @@ fn handle_keyboard_core(
        return;
    }

+    // Mutual exclusion with pointer drags — mirrors `handle_selection_keys`.
+    // Undo / draw / new-game during an active mouse or touch drag would fire
+    // a StateChangedEvent whose card re-sync inserts a `CardAnim` on the
+    // dragged cards, fighting `follow_drag`'s per-frame Transform writes and
+    // leaving `DragState` origin indices stale against the mutated state.
+    // The keyboard-drag sentinel may proceed: `clear_selection_on_state_change`
+    // already drops that lift cleanly when the state moves.
+    if !drag.is_idle()
+        && drag.active_touch_id != Some(crate::selection_plugin::KEYBOARD_DRAG_TOUCH_ID)
+    {
+        return;
+    }
+
    // During replay playback (Playing or Completed) all game-input shortcuts
    // are suppressed. The replay overlay owns Space (pause/resume) and the
    // arrow keys (step). Letting game input through would mutate
@@ -462,11 +533,19 @@ pub fn emit_hint_visuals(
 fn handle_keyboard_forfeit(
    keys: Res<ButtonInput<KeyCode>>,
    paused: Option<Res<PausedResource>>,
+    drag: Res<DragState>,
    mut requests: MessageWriter<ForfeitRequestEvent>,
 ) {
    if paused.is_some_and(|p| p.0) {
        return;
    }
+    // Same pointer-drag exclusion as `handle_keyboard_core` — forfeiting
+    // mid-drag would mutate the game state under the dragged cards.
+    if !drag.is_idle()
+        && drag.active_touch_id != Some(crate::selection_plugin::KEYBOARD_DRAG_TOUCH_ID)
+    {
+        return;
+    }
    if !keys.just_pressed(KeyCode::KeyG) {
        return;
    }
@@ -1370,17 +1449,37 @@ pub fn best_tableau_destination_for_stack(
    None
 }

+/// Decide the auto-move for the face-up run headed by the clicked/tapped card.
+///
+/// The move covers **exactly** `run_len` cards — the run from the clicked
+/// card to the top of its pile. A lone top card goes to its best foundation
+/// (or tableau) destination; a multi-card run goes whole to the best tableau
+/// column. Runs larger or smaller than the clicked one are never considered.
+///
+/// Returns `(destination, count)`, or `None` when the clicked run has no
+/// legal destination.
+pub fn auto_move_for_run(
+    clicked_card: &Card,
+    pile: &KlondikePile,
+    game: &GameState,
+    run_len: usize,
+) -> Option<(KlondikePile, usize)> {
+    if run_len == 1 {
+        best_destination(clicked_card, game).map(|dest| (dest, 1))
+    } else {
+        best_tableau_destination_for_stack(clicked_card, pile, game, run_len)
+    }
+}
+
 /// System that detects double-clicks on face-up cards and fires `MoveRequestEvent`
 /// to the best legal destination.
 ///
-/// Move priority:
-/// 1. Move the single **top** card to its best foundation (or tableau) destination.
-/// 2. If no single-card move exists and the clicked card is the base of a
-///    multi-card face-up stack, move the whole stack to the best tableau column.
+/// The move covers exactly the face-up run headed by the clicked card —
+/// see [`auto_move_for_run`].
 ///
-/// When a multi-card stack double-click finds no legal destination (Priority 2
-/// returns `None`), fires `MoveRejectedEvent` with `from == to == pile` so the
-/// invalid-move sound plays and the source pile cards shake as feedback.
+/// When the clicked run has no legal destination, fires `MoveRejectedEvent`
+/// with `from == to == pile` so the invalid-move sound plays and the source
+/// pile cards shake as feedback.
 #[allow(clippy::too_many_arguments)]
 fn handle_double_click(
    buttons: Res<ButtonInput<MouseButton>>,
@@ -1411,7 +1510,11 @@ fn handle_double_click(
        return;
    };

-    // The topmost card in the draggable run — used as the double-click key.
+    // The clicked card heads the run and keys the double-click: two clicks
+    // on different cards of the same stack are not a double-click.
+    let Some(clicked_card) = card_ids.first() else {
+        return;
+    };
    let Some(top_card) = card_ids.last() else {
        return;
    };
@@ -1426,31 +1529,15 @@ fn handle_double_click(

    let now = time.elapsed_secs();
    let prev = last_click
-        .get(top_card)
+        .get(clicked_card)
        .copied()
        .unwrap_or(f32::NEG_INFINITY);

    if now - prev <= DOUBLE_CLICK_WINDOW {
        // Double-click confirmed.
-        last_click.remove(top_card);
+        last_click.remove(clicked_card);

-        // Priority 1: move the single top card (foundation preferred, then tableau).
-        if let Some(dest) = best_destination(top_card, &game.0) {
-            moves.write(MoveRequestEvent {
-                from: pile,
-                to: dest,
-                count: 1,
-            });
-            return;
-        }
-
-        // Priority 2: if the player clicked the base of a multi-card face-up
-        // stack (card_ids.len() > 1), try moving the whole stack to another
-        // tableau column.
-        if card_ids.len() > 1
-            && let Some((bottom_card, _)) = pile_cards.get(stack_index)
-            && let Some((dest, count)) =
-                best_tableau_destination_for_stack(bottom_card, &pile, &game.0, card_ids.len())
+        if let Some((dest, count)) = auto_move_for_run(clicked_card, &pile, &game.0, card_ids.len())
        {
            moves.write(MoveRequestEvent {
                from: pile,
@@ -1460,14 +1547,10 @@ fn handle_double_click(
            return;
        }

-        // Both priorities failed — play the invalid-move sound and shake
-        // the source pile as feedback. `MoveRejectedEvent` with
-        // `from == to` routes the shake to the source pile (which
-        // `start_shake_anim` reads from `ev.to`). Pre-fix, this branch
-        // only fired for multi-card stacks, so a double-click on a
-        // single card with no legal destination did nothing — no
-        // sound, no shake. Now both single-card and stack misses get
-        // the same feedback.
+        // No legal destination for the clicked run — play the invalid-move
+        // sound and shake the source pile as feedback. `MoveRejectedEvent`
+        // with `from == to` routes the shake to the source pile (which
+        // `start_shake_anim` reads from `ev.to`).
        rejected.write(MoveRejectedEvent {
            from: pile,
            to: pile,
@@ -1475,7 +1558,7 @@ fn handle_double_click(
        });
    } else {
        // Single click — record the time.
-        last_click.insert(top_card.clone(), now);
+        last_click.insert(clicked_card.clone(), now);
    }
 }

@@ -1491,10 +1574,9 @@ fn handle_double_click(
 /// `cards`, and `origin_pile`; once `touch_end_drag` fires those fields
 /// are cleared and the tap/drag distinction is permanently lost.
 ///
-/// Move priority:
-/// 1. Single top card to its best foundation (or tableau).
-/// 2. Whole face-up run to best tableau column when no single-card move exists.
-/// 3. `MoveRejectedEvent` for audio + shake feedback when no legal move found.
+/// The move covers exactly the face-up run headed by the tapped card —
+/// see [`auto_move_for_run`]. Fires `MoveRejectedEvent` for audio + shake
+/// feedback when the tapped run has no legal destination.
 #[allow(clippy::too_many_arguments)]
 fn handle_double_tap(
    mut touch_events: MessageReader<TouchInput>,
@@ -1554,8 +1636,7 @@ fn handle_double_tap(
            return;
        }

-        let Some((found_card, found_face_up)) = pile_cards.iter().find(|(c, _)| c == top_card)
-        else {
+        let Some((_, found_face_up)) = pile_cards.iter().find(|(c, _)| c == top_card) else {
            return;
        };
        if !*found_face_up {
@@ -1591,53 +1672,27 @@ fn handle_double_tap(

        // --- One-tap auto-move (original behaviour) ---

-        // Priority 1: move single top card.
-        if let Some(dest) = best_destination(found_card, &game.0) {
+        // Move exactly the run headed by the tapped card.
+        if let Some(tapped_card) = drag.cards.first()
+            && let Some((dest, count)) =
+                auto_move_for_run(tapped_card, tapped_pile, &game.0, drag.cards.len())
+        {
            for (entity, ce, mut sprite) in card_sprites.iter_mut() {
-                if ce.card == *top_card {
+                if drag.cards.contains(&ce.card) {
                    sprite.color = STATE_SUCCESS;
                    commands.entity(entity).insert(HintHighlight {
                        remaining: DOUBLE_TAP_FLASH_SECS,
                    });
-                    break;
                }
            }
            moves.write(MoveRequestEvent {
                from: *tapped_pile,
                to: dest,
-                count: 1,
+                count,
            });
            return;
        }

-        // Priority 2: move whole face-up stack to best tableau column.
-        if drag.cards.len() > 1 {
-            let stack_index = pile_cards.len() - drag.cards.len();
-            if let Some((bottom_card, _)) = pile_cards.get(stack_index)
-                && let Some((dest, count)) = best_tableau_destination_for_stack(
-                    bottom_card,
-                    tapped_pile,
-                    &game.0,
-                    drag.cards.len(),
-                )
-            {
-                for (entity, ce, mut sprite) in card_sprites.iter_mut() {
-                    if drag.cards.contains(&ce.card) {
-                        sprite.color = STATE_SUCCESS;
-                        commands.entity(entity).insert(HintHighlight {
-                            remaining: DOUBLE_TAP_FLASH_SECS,
-                        });
-                    }
-                }
-                moves.write(MoveRequestEvent {
-                    from: *tapped_pile,
-                    to: dest,
-                    count,
-                });
-                return;
-            }
-        }
-
        rejected.write(MoveRejectedEvent {
            from: *tapped_pile,
            to: *tapped_pile,
@@ -429,6 +429,118 @@ fn best_tableau_destination_for_stack_returns_none_when_no_legal_move() {
    );
 }

+// -----------------------------------------------------------------------
+// auto_move_for_run pure-function tests (issue #158)
+// -----------------------------------------------------------------------
+//
+// These need real positions — `can_move_cards` validates against the live
+// session, not the `set_test_*` overlays. Seeds 51 and 145 both deal an
+// Ace and its Two on tableau tops plus an opposite-color Three elsewhere,
+// letting two moves build a face-up [Three, Two] run whose top card is
+// foundation-eligible (the bait the pre-#158 code would take).
+
+/// Deal `seed`, send the Ace on tableau 1 to its foundation, then stack the
+/// matching Two from `two_from` onto the opposite-color Three on `run_on`.
+/// Returns the game with a 2-card face-up run on `run_on`.
+fn deal_run_with_foundation_bait(seed: u64, two_from: Tableau, run_on: Tableau) -> GameState {
+    let mut game = GameState::new(seed, DrawStockConfig::DrawOne);
+    let (ace, _) = game
+        .pile(KlondikePile::Tableau(Tableau::Tableau1))
+        .last()
+        .cloned()
+        .expect("seed deals a card on tableau 1");
+    let foundation = best_destination(&ace, &game).expect("ace has a foundation home");
+    game.move_cards(KlondikePile::Tableau(Tableau::Tableau1), foundation, 1)
+        .expect("ace moves to foundation");
+    game.move_cards(
+        KlondikePile::Tableau(two_from),
+        KlondikePile::Tableau(run_on),
+        1,
+    )
+    .expect("two stacks onto three");
+    game
+}
+
+#[test]
+fn auto_move_for_run_moves_exact_clicked_run_not_top_card() {
+    let game = deal_run_with_foundation_bait(51, Tableau::Tableau6, Tableau::Tableau5);
+    let run_pile = KlondikePile::Tableau(Tableau::Tableau5);
+    let cards = game.pile(run_pile);
+    let (top, _) = cards.last().cloned().expect("run pile has cards");
+    let (clicked, _) = cards[cards.len() - 2].clone();
+
+    // The bait: the lone top card has a foundation move available.
+    assert!(
+        matches!(
+            best_destination(&top, &game),
+            Some(KlondikePile::Foundation(_))
+        ),
+        "precondition: run top card must be foundation-eligible"
+    );
+
+    // Clicking the run base must move exactly the 2-card run to a tableau.
+    match auto_move_for_run(&clicked, &run_pile, &game, 2) {
+        Some((KlondikePile::Tableau(dest), 2)) => assert_ne!(dest, Tableau::Tableau5),
+        other => panic!("expected a whole-run tableau move, got {other:?}"),
+    }
+}
+
+#[test]
+fn auto_move_for_run_rejects_when_clicked_run_cannot_move() {
+    let game = deal_run_with_foundation_bait(145, Tableau::Tableau4, Tableau::Tableau7);
+    let run_pile = KlondikePile::Tableau(Tableau::Tableau7);
+    let cards = game.pile(run_pile);
+    let (top, _) = cards.last().cloned().expect("run pile has cards");
+    let (clicked, _) = cards[cards.len() - 2].clone();
+
+    assert!(
+        matches!(
+            best_destination(&top, &game),
+            Some(KlondikePile::Foundation(_))
+        ),
+        "precondition: run top card must be foundation-eligible"
+    );
+
+    // The 2-card run has no legal home — the top card's foundation move
+    // must NOT be taken as a substitute.
+    assert_eq!(
+        auto_move_for_run(&clicked, &run_pile, &game, 2),
+        None,
+        "an immovable clicked run must not fall back to a top-card move"
+    );
+}
+
+#[test]
+fn auto_move_for_run_single_card_prefers_foundation() {
+    // Seed 51 after the Ace reaches the foundation: the Two on tableau 6
+    // is a lone face-up card that could go to the foundation OR onto the
+    // Three on tableau 5. Foundation must win.
+    let mut game = GameState::new(51, DrawStockConfig::DrawOne);
+    let (ace, _) = game
+        .pile(KlondikePile::Tableau(Tableau::Tableau1))
+        .last()
+        .cloned()
+        .expect("seed 51 deals a card on tableau 1");
+    let foundation = best_destination(&ace, &game).expect("ace has a foundation home");
+    game.move_cards(KlondikePile::Tableau(Tableau::Tableau1), foundation, 1)
+        .expect("ace moves to foundation");
+
+    let two_pile = KlondikePile::Tableau(Tableau::Tableau6);
+    let (two, _) = game.pile(two_pile).last().cloned().expect("two on top");
+    assert!(
+        game.can_move_cards(&two_pile, &KlondikePile::Tableau(Tableau::Tableau5), 1),
+        "precondition: a tableau destination also exists"
+    );
+
+    assert!(
+        matches!(
+            auto_move_for_run(&two, &two_pile, &game, 1),
+            Some((KlondikePile::Foundation(_), 1))
+        ),
+        "a lone top card still prefers the foundation"
+    );
+}
+
 // -----------------------------------------------------------------------
 // Task #28 — find_hint pure-function tests
 // -----------------------------------------------------------------------
@@ -705,3 +817,123 @@ fn pressing_h_spawns_pending_hint_task() {
        "pressing H must spawn an async hint task",
    );
 }
+
+// -----------------------------------------------------------------------
+// Pointer-drag / keyboard mutual exclusion.
+//
+// A state mutation fired while `follow_drag` is writing the dragged cards'
+// transforms every frame would make the card re-sync insert a `CardAnim`
+// on the same entities (two systems fighting over `Transform`) and leave
+// `DragState`'s origin indices stale. `handle_keyboard_core` and
+// `handle_keyboard_forfeit` therefore swallow game-mutating shortcuts
+// while a mouse or touch drag is live, mirroring `handle_selection_keys`.
+// The keyboard-lift sentinel is exempt: `clear_selection_on_state_change`
+// drops that lift cleanly when the state moves.
+// -----------------------------------------------------------------------
+
+fn keyboard_core_app() -> App {
+    let mut app = App::new();
+    app.add_plugins(MinimalPlugins);
+    app.add_message::<UndoRequestEvent>();
+    app.add_message::<NewGameRequestEvent>();
+    app.add_message::<InfoToastEvent>();
+    app.add_message::<DrawRequestEvent>();
+    app.add_message::<StartZenRequestEvent>();
+    app.init_resource::<ButtonInput<KeyCode>>();
+    app.init_resource::<DragState>();
+    app.add_systems(Update, handle_keyboard_core);
+    app
+}
+
+fn press_key(app: &mut App, key: KeyCode) {
+    let mut input = app.world_mut().resource_mut::<ButtonInput<KeyCode>>();
+    input.release(key);
+    input.clear();
+    input.press(key);
+}
+
+fn message_count<M: Message>(app: &App) -> usize {
+    let messages = app.world().resource::<Messages<M>>();
+    let mut cursor = messages.get_cursor();
+    cursor.read(messages).count()
+}
+
+fn set_drag(app: &mut App, active_touch_id: Option<u64>) {
+    let mut drag = app.world_mut().resource_mut::<DragState>();
+    drag.cards = vec![Card::new(Deck::Deck1, Suit::Clubs, Rank::Two)];
+    drag.committed = true;
+    drag.active_touch_id = active_touch_id;
+}
+
+#[test]
+fn u_key_fires_undo_when_no_drag_active() {
+    let mut app = keyboard_core_app();
+    press_key(&mut app, KeyCode::KeyU);
+    app.update();
+    assert_eq!(
+        message_count::<UndoRequestEvent>(&app),
+        1,
+        "U with an idle DragState must fire UndoRequestEvent",
+    );
+}
+
+#[test]
+fn u_key_ignored_during_committed_mouse_drag() {
+    let mut app = keyboard_core_app();
+    set_drag(&mut app, None); // mouse drag
+    press_key(&mut app, KeyCode::KeyU);
+    app.update();
+    assert_eq!(
+        message_count::<UndoRequestEvent>(&app),
+        0,
+        "U during a mouse drag must be swallowed",
+    );
+}
+
+#[test]
+fn draw_key_ignored_during_touch_drag() {
+    let mut app = keyboard_core_app();
+    set_drag(&mut app, Some(7)); // real touch id
+    press_key(&mut app, KeyCode::KeyD);
+    app.update();
+    assert_eq!(
+        message_count::<DrawRequestEvent>(&app),
+        0,
+        "D during a touch drag must be swallowed",
+    );
+}
+
+#[test]
+fn u_key_allowed_during_keyboard_lift() {
+    let mut app = keyboard_core_app();
+    set_drag(
+        &mut app,
+        Some(crate::selection_plugin::KEYBOARD_DRAG_TOUCH_ID),
+    );
+    press_key(&mut app, KeyCode::KeyU);
+    app.update();
+    assert_eq!(
+        message_count::<UndoRequestEvent>(&app),
+        1,
+        "the keyboard-lift sentinel must not block core shortcuts",
+    );
+}
+
+#[test]
+fn g_key_forfeit_ignored_during_mouse_drag() {
+    let mut app = App::new();
+    app.add_plugins(MinimalPlugins);
+    app.add_message::<ForfeitRequestEvent>();
+    app.init_resource::<ButtonInput<KeyCode>>();
+    app.init_resource::<DragState>();
+    app.add_systems(Update, handle_keyboard_forfeit);
+
+    set_drag(&mut app, None);
+    press_key(&mut app, KeyCode::KeyG);
+    app.update();
+    assert_eq!(
+        message_count::<ForfeitRequestEvent>(&app),
+        0,
+        "G during a mouse drag must be swallowed",
+    );
+}
@@ -24,13 +24,13 @@ use crate::font_plugin::FontResource;
 use crate::settings_plugin::{SettingsResource, SettingsStoragePath};
 use crate::sync_plugin::SyncProviderResource;
 use crate::ui_modal::{
-    ButtonVariant, ModalScrim, ScrimDismissible, spawn_modal, spawn_modal_actions,
-    spawn_modal_button, spawn_modal_header,
+    ButtonVariant, ModalScrim, ScrimDismissible, spawn_empty_state, spawn_modal,
+    spawn_modal_actions, spawn_modal_button, spawn_modal_header,
 };
 use crate::ui_theme::{
-    ACCENT_PRIMARY, BG_ELEVATED, BORDER_SUBTLE, RADIUS_SM, STATE_INFO, TEXT_DISABLED, TEXT_PRIMARY,
-    TEXT_SECONDARY, TYPE_BODY, TYPE_BODY_LG, TYPE_CAPTION, VAL_SPACE_2, VAL_SPACE_3, VAL_SPACE_4,
-    Z_MODAL_PANEL, Z_PAUSE_DIALOG,
+    ACCENT_PRIMARY, BG_ELEVATED, BORDER_SUBTLE, RADIUS_SM, TEXT_DISABLED, TEXT_PRIMARY,
+    TEXT_SECONDARY, TYPE_BODY, TYPE_CAPTION, VAL_SPACE_2, VAL_SPACE_3, VAL_SPACE_4, Z_MODAL_PANEL,
+    Z_PAUSE_DIALOG,
 };

 // ---------------------------------------------------------------------------
@@ -158,18 +158,38 @@ impl Plugin for LeaderboardPlugin {
                    poll_leaderboard_fetch,
                    update_leaderboard_panel,
                    handle_opt_in_button,
-                    poll_opt_in_task,
+                    // The polls share the warning-toast stream with the
+                    // daily-expiry check (drained wholesale, #143).
+                    poll_opt_in_task
+                        .in_set(crate::game_plugin::WarningToastWriters)
+                        .ambiguous_with(crate::game_plugin::WarningToastWriters),
                    handle_opt_out_button,
-                    poll_opt_out_task,
+                    poll_opt_out_task
+                        .in_set(crate::game_plugin::WarningToastWriters)
+                        .ambiguous_with(crate::game_plugin::WarningToastWriters),
                    handle_set_display_name_button,
                    handle_display_name_text_input,
                    handle_display_name_confirm,
                    handle_display_name_cancel,
-                    update_leaderboard_public_name_label,
+                    // Writes one marker-filtered Text label — disjoint from
+                    // the HUD/stats text painters (UiTextFx club, #143).
+                    update_leaderboard_public_name_label
+                        .in_set(crate::ui_theme::UiTextFx)
+                        .ambiguous_with(crate::ui_theme::UiTextFx),
                )
-                    .chain(),
+                    .chain()
+                    // Opt-in state and display name live in
+                    // SettingsResource — the whole chain joins the
+                    // screen-plugin settings club (#143).
+                    .in_set(crate::settings_plugin::SettingsAccess)
+                    .ambiguous_with(crate::settings_plugin::SettingsAccess),
            )
-            .add_systems(Update, scroll_leaderboard_panel);
+            .add_systems(
+                Update,
+                scroll_leaderboard_panel
+                    .in_set(crate::ui_modal::PanelScroll)
+                    .ambiguous_with(crate::ui_modal::PanelScroll),
+            );
    }
 }

@@ -536,11 +556,6 @@ fn spawn_leaderboard_screen(
            font_size: TYPE_CAPTION,
            ..default()
        };
-        let font_status = TextFont {
-            font: font_handle.clone(),
-            font_size: TYPE_BODY_LG,
-            ..default()
-        };
        let font_row = TextFont {
            font: font_handle.clone(),
            font_size: TYPE_BODY,
@@ -647,30 +662,31 @@ fn spawn_leaderboard_screen(
        .with_children(|body| {
            match data {
                LeaderboardResource::Idle => {
-                    body.spawn((
-                        Text::new("Fetching\u{2026}"),
-                        font_status.clone(),
-                        TextColor(STATE_INFO),
-                    ));
+                    spawn_empty_state(
+                        body,
+                        "\u{21BB}",
+                        "Fetching the leaderboard\u{2026}",
+                        None,
+                        font_res,
+                    );
                }
                LeaderboardResource::Error(_) => {
-                    body.spawn((
-                        Text::new("Couldn't reach the leaderboard. Try again later."),
-                        font_status.clone(),
-                        TextColor(TEXT_SECONDARY),
-                    ));
+                    spawn_empty_state(
+                        body,
+                        "!",
+                        "Couldn't reach the leaderboard.",
+                        Some("Try again later."),
+                        font_res,
+                    );
                }
                LeaderboardResource::Loaded(rows) if rows.is_empty() => {
-                    body.spawn((
-                        Text::new("Be the first on the leaderboard."),
-                        font_status.clone(),
-                        TextColor(TEXT_PRIMARY),
-                    ));
-                    body.spawn((
-                        Text::new("Win a game and opt in to appear here."),
-                        font_row.clone(),
-                        TextColor(TEXT_SECONDARY),
-                    ));
+                    spawn_empty_state(
+                        body,
+                        "\u{2660}",
+                        "Be the first on the leaderboard.",
+                        Some("Win a game and opt in to appear here."),
+                        font_res,
+                    );
                }
                LeaderboardResource::Loaded(rows) => {
                    // Column headers
@@ -15,6 +15,8 @@ pub mod avatar_plugin;
 pub mod card_animation;
 pub mod card_plugin;
 pub mod challenge_plugin;
+pub mod cheat_sheet_plugin;
+pub mod contextual_tips_plugin;
 pub mod core_game_plugin;
 pub mod cursor_plugin;
 pub mod daily_challenge_plugin;
@@ -26,6 +28,7 @@ pub mod font_plugin;
 pub mod game_plugin;
 pub mod help_plugin;
 pub mod home_plugin;
+pub mod hotkeys;
 pub mod hud_plugin;
 pub mod input_plugin;
 pub mod layout;
@@ -60,10 +63,12 @@ pub mod theme_store_plugin;
 pub mod time_attack_plugin;
 pub mod touch_selection_plugin;
 pub mod ui_focus;
+pub mod ui_glass;
 pub mod ui_modal;
 pub mod ui_theme;
 pub mod ui_tooltip;
 pub mod weekly_goals_plugin;
+pub mod whats_new_plugin;
 pub mod win_summary_plugin;
 pub mod you_hub_plugin;

@@ -83,9 +88,8 @@ pub use avatar_plugin::{AvatarFetchEvent, AvatarPlugin, AvatarResource};
 pub use card_animation::{
    AnimationChain, AnimationTuning, BufferedInput, CardAnimation, CardAnimationPlugin,
    DEAL_INTERVAL_SECS, DIAG_WINDOW_SIZE, FrameTimeDiagnostics, HoverState, InputBuffer,
-    InputPlatform, MAX_DURATION_SECS, MIN_DURATION_SECS, MotionCurve, WIN_CASCADE_INTERVAL_SECS,
-    WinCascadePlugin, cascade_delay, compute_duration, micro_vary, sample_curve,
-    win_scatter_targets,
+    InputPlatform, MAX_DURATION_SECS, MIN_DURATION_SECS, MotionCurve, compute_duration, micro_vary,
+    sample_curve,
 };
 pub use card_plugin::{
    CardEntity, CardImageSet, CardLabel, CardPlugin, HintHighlight, HintHighlightTimer,
@@ -94,6 +98,8 @@ pub use card_plugin::{
 pub use challenge_plugin::{
    CHALLENGE_UNLOCK_LEVEL, ChallengeAdvancedEvent, ChallengePlugin, challenge_progress_label,
 };
+pub use cheat_sheet_plugin::{CheatSheetOverlay, CheatSheetPlugin};
+pub use contextual_tips_plugin::ContextualTipsPlugin;
 pub use core_game_plugin::CoreGamePlugin;
 pub use cursor_plugin::CursorPlugin;
 pub use daily_challenge_plugin::{
@@ -107,7 +113,7 @@ pub use events::{
    HintVisualEvent, InfoToastEvent, ManualSyncRequestEvent, MoveRejectedEvent, MoveRequestEvent,
    NewGameRequestEvent, PauseRequestEvent, StartChallengeRequestEvent,
    StartDailyChallengeRequestEvent, StartDifficultyRequestEvent, StartPlayBySeedRequestEvent,
-    StartTimeAttackRequestEvent, StartZenRequestEvent, StateChangedEvent, SyncCompleteEvent,
+    StartTimeAttackRequestEvent, StartZenRequestEvent, StateChangedEvent,
    ToggleAchievementsRequestEvent, ToggleLeaderboardRequestEvent, ToggleProfileRequestEvent,
    ToggleSettingsRequestEvent, ToggleStatsRequestEvent, UndoRequestEvent, WinStreakMilestoneEvent,
    XpAwardedEvent,
@@ -195,6 +201,7 @@ pub use ui_modal::{
 };
 pub use ui_tooltip::{Tooltip, UiTooltipPlugin};
 pub use weekly_goals_plugin::{WeeklyGoalCompletedEvent, WeeklyGoalsPlugin};
+pub use whats_new_plugin::{WhatsNewPending, WhatsNewPlugin, WhatsNewScreen};
 pub use win_summary_plugin::{
    ScreenShakeResource, SessionAchievements, WinSummaryPending, WinSummaryPlugin, format_win_time,
 };
@@ -84,66 +84,11 @@ struct OnboardingSkipButton;
 pub struct OnboardingSlideIndex(pub u8);

 // ---------------------------------------------------------------------------
-// Slide data — hotkey rows are taken verbatim from `help_plugin.rs` so the
-// two screens stay in sync without a shared abstraction.
+// Slide data — the hotkey slide renders the essential subset of the
+// shared table in `crate::hotkeys` (Phase J unified the previously
+// diverging copies here and in help_plugin).
 // ---------------------------------------------------------------------------

-/// A single `key — description` pair shown on slide 3.
-#[cfg(not(target_os = "android"))]
-struct HotkeyRow {
-    keys: &'static str,
-    description: &'static str,
-}
-
-/// Most-used shortcuts from the `help_plugin` canonical list.
-///
-/// Updating the list in `help_plugin.rs` should be mirrored here. The
-/// ARCHITECTURE.md decision log calls out that we copy values rather than
-/// refactor the help plugin.
-#[cfg(not(target_os = "android"))]
-const HOTKEYS: &[HotkeyRow] = &[
-    HotkeyRow {
-        keys: "D / Space",
-        description: "Draw from stock",
-    },
-    HotkeyRow {
-        keys: "U",
-        description: "Undo last move",
-    },
-    HotkeyRow {
-        keys: "Tab → Enter",
-        description: "Pick a card; arrows pick where; Enter to drop",
-    },
-    HotkeyRow {
-        keys: "N",
-        description: "New Classic game",
-    },
-    HotkeyRow {
-        keys: "M",
-        description: "Open Mode Launcher (then 1–5 to pick)",
-    },
-    HotkeyRow {
-        keys: "S",
-        description: "Stats & progression",
-    },
-    HotkeyRow {
-        keys: "A",
-        description: "Achievements",
-    },
-    HotkeyRow {
-        keys: "O",
-        description: "Settings",
-    },
-    HotkeyRow {
-        keys: "Esc",
-        description: "Pause / resume",
-    },
-    HotkeyRow {
-        keys: "F1",
-        description: "Help / controls",
-    },
-];
-
 // ---------------------------------------------------------------------------
 // Plugin
 // ---------------------------------------------------------------------------
@@ -153,12 +98,26 @@ pub struct OnboardingPlugin;

 impl Plugin for OnboardingPlugin {
    fn build(&self, app: &mut App) {
-        app.init_resource::<OnboardingSlideIndex>()
-            .add_systems(Update, spawn_if_first_run)
-            .add_systems(
-                Update,
-                (handle_onboarding_buttons, handle_onboarding_keyboard).chain(),
-            );
+        app.init_resource::<OnboardingSlideIndex>().add_systems(
+            Update,
+            // One chain: all three touch the slide index and the
+            // first-run flag in SettingsResource. Club membership
+            // declares the settings access disjoint from the other
+            // screen plugins'; the keyboard handler runs before
+            // FocusKeys like every other Esc consumer (#143).
+            (
+                spawn_if_first_run,
+                handle_onboarding_buttons,
+                handle_onboarding_keyboard.before(crate::ui_focus::FocusKeys),
+            )
+                .chain()
+                // Before the settings spine: the first-run flag write
+                // lands before every same-frame settings reader (they
+                // all sit at or after SettingsMutation transitively).
+                .before(crate::settings_plugin::SettingsMutation)
+                .in_set(crate::settings_plugin::SettingsAccess)
+                .ambiguous_with(crate::settings_plugin::SettingsAccess),
+        );
    }
 }

@@ -313,6 +272,10 @@ fn complete_onboarding(
    despawn_screen(commands, screens);
    if let Some(s) = settings {
        s.0.first_run_complete = true;
+        // A fresh install has nothing "new" to announce — stamp the
+        // running release so the What's-new card (Phase I) only ever
+        // fires after an actual upgrade.
+        s.0.last_seen_whats_new = crate::whats_new_plugin::current_release_version();
        persist(path.map(|p| &p.0), &s.0);
    }
 }
@@ -382,20 +345,27 @@ fn spawn_slide_welcome(commands: &mut Commands, font_res: Option<&FontResource>)
    });
 }

+/// How-to-play body copy, phrased for the platform's input vocabulary —
+/// a touch player never left-clicks (Phase H polish; spotted in the
+/// emulator smoke of v0.44.0).
+#[cfg(target_os = "android")]
+const HOW_TO_PLAY_BODY: &str = "Drag any face-up card to move it between piles. \
+     You can drag a whole column at once by grabbing the topmost card \
+     you want to move. Double-tap a face-up card to send it to a \
+     foundation pile automatically (when the move is legal). \
+     Tap Hint in the bottom bar for a suggested move.";
+#[cfg(not(target_os = "android"))]
+const HOW_TO_PLAY_BODY: &str = "Left-click and drag any face-up card to move it between piles. \
+     You can drag a whole column at once by grabbing the topmost card \
+     you want to move. Double-click a face-up card to send it to a \
+     foundation pile automatically (when the move is legal). \
+     Right-click a card for a hint — valid destinations will highlight.";
+
 /// Slide 2 — How to play.
 fn spawn_slide_how_to_play(commands: &mut Commands, font_res: Option<&FontResource>) {
    spawn_modal(commands, OnboardingScreen, Z_ONBOARDING, |card| {
        spawn_modal_header(card, "Drag cards to play", font_res);
-        spawn_modal_body_text(
-            card,
-            "Left-click and drag any face-up card to move it between piles. \
-             You can drag a whole column at once by grabbing the topmost card \
-             you want to move. Double-click a face-up card to send it to a \
-             foundation pile automatically (when the move is legal). \
-             Right-click a card for a hint — valid destinations will highlight.",
-            TEXT_SECONDARY,
-            font_res,
-        );
+        spawn_modal_body_text(card, HOW_TO_PLAY_BODY, TEXT_SECONDARY, font_res);
        spawn_modal_actions(card, |actions| {
            spawn_modal_button(
                actions,
@@ -435,8 +405,10 @@ fn spawn_slide_hotkeys(commands: &mut Commands, font_res: Option<&FontResource>)
    spawn_modal(commands, OnboardingScreen, Z_ONBOARDING, |card| {
        spawn_modal_header(card, "Keyboard shortcuts", font_res);

-        // Vertical list of `key — description` rows, same chip style as HelpScreen.
-        for row in HOTKEYS {
+        // Vertical list of `key — description` rows, same chip style as
+        // HelpScreen. Essential subset only — the full table lives on
+        // the hold-`/` cheat sheet.
+        for row in crate::hotkeys::HOTKEYS.iter().filter(|r| r.essential) {
            card.spawn(Node {
                flex_direction: FlexDirection::Row,
                align_items: AlignItems::Center,
@@ -815,22 +787,15 @@ mod tests {
    }

    // -----------------------------------------------------------------------
-    // Hotkey list is non-empty (guards against accidental truncation)
+    // Hotkey slide renders a non-empty essential subset (the table's own
+    // integrity tests live in `crate::hotkeys`)
    // -----------------------------------------------------------------------

    #[test]
-    fn hotkey_list_is_non_empty() {
-        assert!(!HOTKEYS.is_empty(), "HOTKEYS must not be empty");
-    }
-
-    #[test]
-    fn all_hotkey_rows_have_non_empty_fields() {
-        for row in HOTKEYS {
-            assert!(!row.keys.is_empty(), "hotkey key field must not be empty");
-            assert!(
-                !row.description.is_empty(),
-                "hotkey description must not be empty"
-            );
-        }
+    fn hotkey_slide_subset_is_non_empty() {
+        assert!(
+            crate::hotkeys::HOTKEYS.iter().any(|r| r.essential),
+            "the onboarding slide needs at least one essential hotkey"
+        );
    }
 }
@@ -104,6 +104,15 @@ pub fn draw_mode_label(mode: DrawStockConfig) -> &'static str {
 /// to disk, and routes the Forfeit confirm-modal flow.
 pub struct PausePlugin;

+/// Set wrapping every system that mutates [`PausedResource`] or drives the
+/// pause/forfeit modal flow. Runs as one deterministic chain between
+/// [`crate::settings_plugin::SettingsMutation`] (the pause overlay's
+/// draw-mode toggle writes `SettingsResource`) and
+/// [`crate::game_plugin::GameMutation`], so every system ordered after
+/// `GameMutation` observes this frame's pause state transitively (#143).
+#[derive(bevy::ecs::schedule::SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct PauseMutation;
+
 impl Plugin for PausePlugin {
    fn build(&self, app: &mut App) {
        // add_message is idempotent — other plugins may register these
@@ -116,28 +125,55 @@ impl Plugin for PausePlugin {
            .add_message::<crate::events::ShowSolutionRequestEvent>()
            .add_message::<InfoToastEvent>()
            .init_resource::<PausedResource>()
+            .configure_sets(
+                Update,
+                PauseMutation
+                    .after(crate::settings_plugin::SettingsMutation)
+                    // Before the pre-mutation game-state spine: the elapsed
+                    // timer must observe this frame's pause transition, and
+                    // the draw-mode toggle's settings write must land before
+                    // sync_settings_to_game forwards it.
+                    .before(crate::game_plugin::PreMutation)
+                    .before(crate::game_plugin::GameMutation)
+                    // toggle_pause must see SelectionState *before*
+                    // handle_selection_keys clears it, so it can skip Escape
+                    // when a card is selected. The other members mutate
+                    // PausedResource, which the selection keys read.
+                    .before(SelectionKeySet)
+                    // HUD buttons read PausedResource (e.g. hint is inert
+                    // while paused) — order them after this frame's pause
+                    // transition.
+                    .before(crate::hud_plugin::HudButtons),
+            )
            .add_systems(
                Update,
                (
-                    // toggle_pause must see SelectionState *before* handle_selection_keys
-                    // clears it, so it can skip Escape when a card is selected.
-                    // It must also run *before* handle_forfeit_keyboard so the
-                    // ForfeitConfirmScreen is still alive when toggle_pause's
-                    // early-return guard checks for it — otherwise an Esc that
-                    // closes the forfeit modal would also open pause in the
-                    // same frame.
+                    // toggle_pause must run *before* handle_forfeit_keyboard
+                    // so the ForfeitConfirmScreen is still alive when
+                    // toggle_pause's early-return guard checks for it —
+                    // otherwise an Esc that closes the forfeit modal would
+                    // also open pause in the same frame. The chain preserves
+                    // that edge and makes the whole pause/forfeit flow
+                    // deterministic (all members share PausedResource and
+                    // the forfeit message streams).
+                    // Reads only motion/display settings fields — disjoint
+                    // from the screen-plugin club's writes (#143).
                    toggle_pause
-                        .before(SelectionKeySet)
-                        .before(handle_forfeit_keyboard),
-                    handle_pause_draw_buttons,
+                        .in_set(crate::settings_plugin::SettingsAccess)
+                        .ambiguous_with(crate::settings_plugin::SettingsAccess),
+                    auto_resume_on_overlay,
+                    handle_pause_draw_buttons
+                        .in_set(crate::settings_plugin::SettingsAccess)
+                        .ambiguous_with(crate::settings_plugin::SettingsAccess),
                    handle_pause_resume_button,
                    handle_pause_forfeit_button,
                    handle_pause_solution_button,
                    handle_forfeit_request,
-                    handle_forfeit_confirm_buttons,
                    handle_forfeit_keyboard,
-                    auto_resume_on_overlay,
-                ),
+                    handle_forfeit_confirm_buttons,
+                )
+                    .chain()
+                    .in_set(PauseMutation),
            );
    }
 }
@@ -39,6 +39,13 @@ use crate::resources::{GameStateResource, HintCycleIndex};
 /// emits the hint visuals once the task completes. At most one task
 /// is ever in flight: a fresh H press while a previous task is
 /// running drops the previous task and queues the new one.
+/// Set wrapping the async hint pipeline (state-change drop → poll). The
+/// HUD hint button orders `.before` it so a press cancels/spawns before
+/// this frame's poll; the drag-highlight painters order `.after` it so
+/// the hint sprite writes are settled (#143).
+#[derive(bevy::ecs::schedule::SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct PendingHint;
+
 #[derive(Resource, Default)]
 pub struct PendingHintTask {
    /// `Some` while the solver is still working on a verdict.
@@ -115,10 +115,27 @@ impl Plugin for PlayBySeedPlugin {
                Update,
                (
                    handle_open_dialog,
-                    handle_text_input,
-                    tick_debounce_and_spawn_solver_task,
-                    poll_solver_task,
-                    handle_confirm,
+                    // Writes the marker-filtered seed-dialog Text nodes —
+                    // disjoint from the other text painters (UiTextFx
+                    // club, #143).
+                    handle_text_input
+                        .in_set(crate::ui_theme::UiTextFx)
+                        .ambiguous_with(crate::ui_theme::UiTextFx),
+                    tick_debounce_and_spawn_solver_task
+                        .in_set(crate::ui_theme::UiTextFx)
+                        .ambiguous_with(crate::ui_theme::UiTextFx)
+                        // Reads deal settings for the solver spawn; a frame
+                        // of lag is invisible (#143).
+                        .in_set(crate::settings_plugin::SettingsAccess)
+                        .ambiguous_with(crate::settings_plugin::SettingsAccess),
+                    poll_solver_task
+                        .in_set(crate::ui_theme::UiTextFx)
+                        .ambiguous_with(crate::ui_theme::UiTextFx),
+                    // Shares the new-game request stream with the other
+                    // writers (drained wholesale at GameMutation, #143).
+                    handle_confirm
+                        .in_set(crate::game_plugin::NewGameRequestWriters)
+                        .ambiguous_with(crate::game_plugin::NewGameRequestWriters),
                    handle_cancel,
                )
                    .chain()
@@ -60,6 +60,14 @@ pub struct DailyCalendarDot {
 /// [`spawn_profile_body`] for this tab's content.
 pub struct ProfilePlugin;

+/// Self-ambiguous club for writers of
+/// [`crate::events::ToggleProfileRequestEvent`] (HUD avatar button, home
+/// profile chip, HUD menu option). The You-hub reader drains the whole
+/// queue, so writer append order is irrelevant; `you_hub_plugin` orders
+/// its open/tab handling after the club (#143).
+#[derive(bevy::ecs::schedule::SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ProfileToggleWriters;
+
 /// Marker on the scrollable body Node inside the Profile modal.
 ///
 /// The Profile panel renders sync info, progression (incl. 14-day
@@ -82,7 +90,12 @@ impl Plugin for ProfilePlugin {
            .add_message::<MouseWheel>()
            // Open/close/tab handling moved to `you_hub_plugin`
            // (Phase E) — this plugin now owns body content + scroll.
-            .add_systems(Update, scroll_profile_panel);
+            .add_systems(
+                Update,
+                scroll_profile_panel
+                    .in_set(crate::ui_modal::PanelScroll)
+                    .ambiguous_with(crate::ui_modal::PanelScroll),
+            );
    }
 }

@@ -37,6 +37,21 @@ pub struct LevelUpEvent {
 #[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ProgressUpdate;

+/// Set for `challenge_plugin::advance_on_challenge_win`. See the
+/// mode-completion chain configured in `ProgressPlugin::build` (#143).
+#[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ChallengeCompletion;
+
+/// Set for `daily_challenge_plugin::handle_daily_completion`. See the
+/// mode-completion chain configured in `ProgressPlugin::build` (#143).
+#[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct DailyCompletion;
+
+/// Set for `weekly_goals_plugin::evaluate_weekly_goals`. See the
+/// mode-completion chain configured in `ProgressPlugin::build` (#143).
+#[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct WeeklyGoalsEval;
+
 /// Bevy plugin that awards XP on `GameWonEvent`, persists `PlayerProgress`,
 /// and emits `LevelUpEvent` whenever a win crosses a level boundary.
 ///
@@ -74,7 +89,27 @@ impl Plugin for ProgressPlugin {
            .add_message::<GameWonEvent>()
            .add_systems(
                Update,
-                award_xp_on_win.after(GameMutation).in_set(ProgressUpdate),
+                award_xp_on_win
+                    .after(GameMutation)
+                    .in_set(ProgressUpdate)
+                    // Base win XP lands before the mode bonuses so the
+                    // level-up attribution is stable.
+                    .before(ChallengeCompletion),
+            )
+            // Mode-completion evaluators, pinned in one explicit chain
+            // INSIDE ProgressUpdate — every `.after(ProgressUpdate)`
+            // reader then sees fully-settled progress. Each evaluator
+            // drains GameWonEvent via its own cursor and writes disjoint
+            // ProgressResource fields plus XP, but a daily win also counts
+            // toward weekly goals, so two members can fire on the same
+            // frame — we pin an order rather than argue the XP/level-up
+            // event stream is commutative (#143).
+            .configure_sets(
+                Update,
+                (ChallengeCompletion, DailyCompletion, WeeklyGoalsEval)
+                    .chain()
+                    .in_set(ProgressUpdate)
+                    .after(GameMutation),
            );
    }
 }
@@ -185,16 +185,31 @@ impl Plugin for RadialMenuPlugin {
            // Tests inject `RadialCursorOverride` themselves; production
            // never touches it. We do not `init_resource` here so the
            // cursor-from-window path is the default.
+            // The radial gesture reacts to pointer state the drag pipeline
+            // settles, and its release handler feeds the shared move
+            // request stream consumed at GameMutation this frame, so the
+            // chain sits between PointerInput and GameMutation. The redraw
+            // reads settings (reduce-motion) where a frame of lag is
+            // invisible — SettingsAccess club (#143).
            .add_systems(
                Update,
                (
                    radial_open_on_right_click,
                    radial_open_on_long_press,
                    radial_track_cursor,
-                    radial_handle_release_or_cancel,
-                    radial_redraw_overlay,
+                    radial_handle_release_or_cancel
+                        .in_set(crate::game_plugin::MoveRequestWriters)
+                        .ambiguous_with(crate::game_plugin::MoveRequestWriters),
+                    radial_redraw_overlay
+                        .in_set(crate::settings_plugin::SettingsAccess)
+                        .ambiguous_with(crate::settings_plugin::SettingsAccess),
                )
-                    .chain(),
+                    .chain()
+                    .after(crate::input_plugin::PointerInput)
+                    // Selection keys also touch DragState (mutual pointer/
+                    // keyboard exclusion) — keys settle first.
+                    .after(crate::selection_plugin::SelectionKeySet)
+                    .before(crate::game_plugin::GameMutation),
            );
    }
 }
@@ -122,12 +122,8 @@ pub(crate) fn format_move_body(instruction: &KlondikeInstruction) -> String {
 /// `▌ MOVE LOG · COMPLETE` in `Completed`.
 pub(crate) fn format_move_log_header(state: &ReplayPlaybackState) -> String {
    match state {
-        ReplayPlaybackState::Playing { replay, cursor, .. } => {
-            format!(
-                "\u{258C} MOVE LOG \u{00B7} {}/{}",
-                cursor,
-                replay.moves.len()
-            )
+        ReplayPlaybackState::Playing { moves, cursor, .. } => {
+            format!("\u{258C} MOVE LOG \u{00B7} {}/{}", cursor, moves.len())
        }
        ReplayPlaybackState::Completed => "\u{258C} MOVE LOG \u{00B7} COMPLETE".to_string(),
        ReplayPlaybackState::Inactive => String::new(),
@@ -135,7 +131,7 @@ pub(crate) fn format_move_log_header(state: &ReplayPlaybackState) -> String {
 }

 /// Pure helper — formats the kth-most-recently-applied move's row
-/// text. `k = 1` is the active row (`replay.moves[cursor - 1]`,
+/// text. `k = 1` is the active row (`moves[cursor - 1]`,
 /// displayed as `"{cursor} │ {body}"`). `k = 2` is the row above
 /// that (`moves[cursor - 2]` displayed as `"{cursor - 1} │ {body}"`),
 /// and so on.
@@ -147,14 +143,14 @@ pub(crate) fn format_move_log_header(state: &ReplayPlaybackState) -> String {
 ///   for k=1 and k=2 only, k=3 returns empty).
 /// - The move list is shorter than expected (defensive guard).
 pub(crate) fn format_kth_recent_row(state: &ReplayPlaybackState, k: usize) -> String {
-    let ReplayPlaybackState::Playing { replay, cursor, .. } = state else {
+    let ReplayPlaybackState::Playing { moves, cursor, .. } = state else {
        return String::new();
    };
    if k == 0 || k > *cursor {
        return String::new();
    }
    let zero_idx = *cursor - k;
-    let Some(m) = replay.moves.get(zero_idx) else {
+    let Some(m) = moves.get(zero_idx) else {
        return String::new();
    };
    let display_idx = *cursor - k + 1;
@@ -162,7 +158,7 @@ pub(crate) fn format_kth_recent_row(state: &ReplayPlaybackState, k: usize) -> St
 }

 /// Pure helper — formats the kth-NEXT move's row text. `k = 1`
-/// is the move that will apply next (`replay.moves[cursor]`,
+/// is the move that will apply next (`moves[cursor]`,
 /// displayed as `cursor + 1`); `k = 2` is the move after that,
 /// and so on.
 ///
@@ -174,14 +170,14 @@ pub(crate) fn format_kth_recent_row(state: &ReplayPlaybackState, k: usize) -> St
 ///   replay — late in the move list, the trailing next rows
 ///   stay empty).
 pub(crate) fn format_kth_next_row(state: &ReplayPlaybackState, k: usize) -> String {
-    let ReplayPlaybackState::Playing { replay, cursor, .. } = state else {
+    let ReplayPlaybackState::Playing { moves, cursor, .. } = state else {
        return String::new();
    };
    if k == 0 {
        return String::new();
    }
    let zero_idx = *cursor + k - 1;
-    let Some(m) = replay.moves.get(zero_idx) else {
+    let Some(m) = moves.get(zero_idx) else {
        return String::new();
    };
    let display_idx = *cursor + k;
@@ -383,7 +383,7 @@ pub struct ReplayOverlayMoveLogPrevRow {
 /// Marker on a "next move" row below the active row. `offset`
 /// is the 1-based distance forward from the active row:
 /// `offset = 1` is the move that will apply next
-/// (`replay.moves[cursor]`, displayed as `cursor + 1`),
+/// (`moves[cursor]`, displayed as `cursor + 1`),
 /// `offset = 2` is the one after that, and so on. Up to
 /// [`MOVE_LOG_NEXT_ROWS`] rows render below the active row.
 ///
@@ -464,25 +464,71 @@ impl Plugin for ReplayOverlayPlugin {
                Update,
                (
                    react_to_state_change,
-                    update_banner_label,
-                    update_progress_text,
-                    update_floating_progress_chip,
-                    update_scrub_fill,
-                    update_move_log_header,
-                    update_move_log_active_row,
-                    update_move_log_prev_rows,
-                    update_move_log_next_rows,
-                    update_mini_tableau_foundations,
-                    update_mini_tableau_stock_waste,
-                    update_pause_button_label,
+                    // Marker-filtered Text/Node repaints — each owns one
+                    // disjoint overlay marker, so they join the UiTextFx
+                    // club alongside the HUD text painters (#143).
+                    update_banner_label
+                        .in_set(crate::ui_theme::UiTextFx)
+                        .ambiguous_with(crate::ui_theme::UiTextFx),
+                    update_progress_text
+                        .in_set(crate::ui_theme::UiTextFx)
+                        .ambiguous_with(crate::ui_theme::UiTextFx),
+                    update_floating_progress_chip
+                        .in_set(crate::ui_theme::UiTextFx)
+                        .ambiguous_with(crate::ui_theme::UiTextFx),
+                    update_scrub_fill
+                        .in_set(crate::ui_theme::UiTextFx)
+                        .ambiguous_with(crate::ui_theme::UiTextFx),
+                    update_move_log_header
+                        .in_set(crate::ui_theme::UiTextFx)
+                        .ambiguous_with(crate::ui_theme::UiTextFx),
+                    update_move_log_active_row
+                        .in_set(crate::ui_theme::UiTextFx)
+                        .ambiguous_with(crate::ui_theme::UiTextFx),
+                    update_move_log_prev_rows
+                        .in_set(crate::ui_theme::UiTextFx)
+                        .ambiguous_with(crate::ui_theme::UiTextFx),
+                    update_move_log_next_rows
+                        .in_set(crate::ui_theme::UiTextFx)
+                        .ambiguous_with(crate::ui_theme::UiTextFx),
+                    update_mini_tableau_foundations
+                        .in_set(crate::ui_theme::UiTextFx)
+                        .ambiguous_with(crate::ui_theme::UiTextFx),
+                    update_mini_tableau_stock_waste
+                        .in_set(crate::ui_theme::UiTextFx)
+                        .ambiguous_with(crate::ui_theme::UiTextFx),
+                    update_pause_button_label
+                        .in_set(crate::ui_theme::UiTextFx)
+                        .ambiguous_with(crate::ui_theme::UiTextFx),
                    handle_pause_button,
-                    handle_step_button,
+                    // Step/scrub dispatch into the shared move/draw/undo
+                    // request streams (drained wholesale at GameMutation),
+                    // so they join the writer clubs (#143).
+                    handle_step_button
+                        .in_set(crate::game_plugin::MoveRequestWriters)
+                        .ambiguous_with(crate::game_plugin::MoveRequestWriters)
+                        .in_set(crate::game_plugin::DrawRequestWriters)
+                        .ambiguous_with(crate::game_plugin::DrawRequestWriters),
                    handle_pause_keyboard,
                    handle_stop_keyboard,
-                    handle_arrow_keyboard,
+                    handle_arrow_keyboard
+                        .in_set(crate::game_plugin::MoveRequestWriters)
+                        .ambiguous_with(crate::game_plugin::MoveRequestWriters)
+                        .in_set(crate::game_plugin::UndoRequestWriters)
+                        .ambiguous_with(crate::game_plugin::UndoRequestWriters)
+                        .in_set(crate::game_plugin::DrawRequestWriters)
+                        .ambiguous_with(crate::game_plugin::DrawRequestWriters),
                    handle_stop_button,
                )
-                    .chain(),
+                    .chain()
+                    // After the playback driver so painters render the
+                    // post-tick state; before GameMutation so the step /
+                    // scrub events are consumed this frame. Click handlers
+                    // writing ReplayPlaybackState stay at the end of the
+                    // chain — a press is observed by react_to_state_change
+                    // next frame (state-driven loop, see above) (#143).
+                    .after(crate::replay_playback::ReplayPlayback)
+                    .before(crate::game_plugin::GameMutation),
            );
    }
 }
@@ -1258,11 +1304,11 @@ fn keybind_footer_hint_text() -> &'static str {
 /// `win_move_index >= total` (defensive — shouldn't happen) doesn't
 /// position the marker outside the track.
 fn win_move_marker_pct(state: &ReplayPlaybackState) -> Option<f32> {
-    let ReplayPlaybackState::Playing { replay, .. } = state else {
+    let ReplayPlaybackState::Playing { replay, moves, .. } = state else {
        return None;
    };
    let idx = replay.win_move_index?;
-    let total = replay.moves.len();
+    let total = moves.len();
    if total == 0 {
        return None;
    }
@@ -1,7 +1,7 @@
 use super::*;
 use chrono::NaiveDate;
 use solitaire_core::{DrawStockConfig, game_state::GameMode};
-use solitaire_core::{Foundation, KlondikeInstruction, KlondikePile, Tableau};
+use solitaire_core::{Foundation, KlondikeInstruction, KlondikePile, SessionRecording, Tableau};
 use solitaire_core::{Rank, Suit};
 use solitaire_data::Replay;

@@ -17,9 +17,11 @@ fn synthetic_replay(move_count: usize) -> Replay {
        120,
        1_000,
        NaiveDate::from_ymd_opt(2026, 5, 2).expect("valid date"),
-        (0..move_count)
-            .map(|_| KlondikeInstruction::RotateStock)
-            .collect(),
+        SessionRecording::from_instructions_unchecked(
+            42,
+            DrawStockConfig::DrawOne,
+            (0..move_count).map(|_| KlondikeInstruction::RotateStock),
+        ),
    )
 }

@@ -93,12 +95,7 @@ fn overlay_spawns_when_playback_starts() {

    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 0, 0.5, false),
    );
    app.update();

@@ -117,12 +114,7 @@ fn overlay_progress_text_reflects_cursor() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 5,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 5, 0.5, false),
    );
    app.update();

@@ -138,12 +130,7 @@ fn overlay_stop_button_click_clears_playback() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 0, 0.5, false),
    );
    app.update();
    assert_eq!(overlay_root_count(&mut app), 1);
@@ -195,12 +182,7 @@ fn floating_chip_spawns_and_despawns_with_overlay() {

    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(5),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(5), 0, 0.5, false),
    );
    app.update();
    assert_eq!(
@@ -232,12 +214,7 @@ fn overlay_despawns_when_playback_returns_to_inactive() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(3),
-            cursor: 1,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(3), 1, 0.5, false),
    );
    app.update();
    assert_eq!(overlay_root_count(&mut app), 1);
@@ -260,12 +237,7 @@ fn overlay_text_changes_on_completed() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(7),
-            cursor: 7,
-            secs_to_next: 0.0,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(7), 7, 0.0, false),
    );
    app.update();
    assert_eq!(banner_text(&mut app), "\u{258C} replay");
@@ -314,30 +286,30 @@ fn scrub_pct_covers_state_corners() {
    assert_eq!(scrub_pct(&ReplayPlaybackState::Inactive), 0.0);
    assert_eq!(scrub_pct(&ReplayPlaybackState::Completed), 100.0);
    assert_eq!(
-        scrub_pct(&ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        }),
+        scrub_pct(&ReplayPlaybackState::playing(
+            synthetic_replay(10),
+            0,
+            0.5,
+            false,
+        )),
        0.0,
    );
    assert_eq!(
-        scrub_pct(&ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 5,
-            secs_to_next: 0.5,
-            paused: false,
-        }),
+        scrub_pct(&ReplayPlaybackState::playing(
+            synthetic_replay(10),
+            5,
+            0.5,
+            false,
+        )),
        50.0,
    );
    assert_eq!(
-        scrub_pct(&ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 10,
-            secs_to_next: 0.5,
-            paused: false,
-        }),
+        scrub_pct(&ReplayPlaybackState::playing(
+            synthetic_replay(10),
+            10,
+            0.5,
+            false,
+        )),
        100.0,
    );
 }
@@ -367,12 +339,12 @@ fn format_game_caption_covers_state_corners() {
    // Mar = 31, Apr = 30, May 2 = 122). Synthetic_replay always
    // uses this date so the assertion is stable.
    assert_eq!(
-        format_game_caption(&ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 5,
-            secs_to_next: 0.5,
-            paused: false,
-        }),
+        format_game_caption(&ReplayPlaybackState::playing(
+            synthetic_replay(10),
+            5,
+            0.5,
+            false,
+        )),
        Some("GAME #2026-122".to_string()),
    );

@@ -381,12 +353,7 @@ fn format_game_caption_covers_state_corners() {
    let mut early_january = synthetic_replay(10);
    early_january.recorded_at = NaiveDate::from_ymd_opt(2026, 1, 5).expect("valid date");
    assert_eq!(
-        format_game_caption(&ReplayPlaybackState::Playing {
-            replay: early_january,
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        }),
+        format_game_caption(&ReplayPlaybackState::playing(early_january, 0, 0.5, false,)),
        Some("GAME #2026-005".to_string()),
    );
 }
@@ -399,12 +366,7 @@ fn overlay_game_caption_shows_replay_date() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 0, 0.5, false),
    );
    app.update();
    assert_eq!(game_caption_text(&mut app), "GAME #2026-122");
@@ -431,12 +393,7 @@ fn overlay_scrub_fill_tracks_cursor() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(8),
-            cursor: 2,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(8), 2, 0.5, false),
    );
    app.update();
    assert_eq!(
@@ -447,12 +404,7 @@ fn overlay_scrub_fill_tracks_cursor() {

    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(8),
-            cursor: 6,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(8), 6, 0.5, false),
    );
    app.update();
    assert_eq!(
@@ -497,12 +449,7 @@ fn win_move_marker_pct_is_none_for_completed() {
 fn win_move_marker_pct_is_none_when_replay_lacks_field() {
    // Synthetic replay constructor leaves win_move_index as None
    // (legacy / pre-`ab857bb` path).
-    let state = ReplayPlaybackState::Playing {
-        replay: synthetic_replay(10),
-        cursor: 0,
-        secs_to_next: 0.5,
-        paused: false,
-    };
+    let state = ReplayPlaybackState::playing(synthetic_replay(10), 0, 0.5, false);
    assert_eq!(win_move_marker_pct(&state), None);
 }

@@ -511,12 +458,12 @@ fn win_move_marker_pct_is_some_at_correct_position() {
    // 10 moves, win at index 9 → marker sits at 90 % of the track.
    // Matches the recording semantic: cursor reaches the marker
    // exactly when the about-to-apply move IS the win move.
-    let state = ReplayPlaybackState::Playing {
-        replay: synthetic_replay(10).with_win_move_index(Some(9)),
-        cursor: 0,
-        secs_to_next: 0.5,
-        paused: false,
-    };
+    let state = ReplayPlaybackState::playing(
+        synthetic_replay(10).with_win_move_index(Some(9)),
+        0,
+        0.5,
+        false,
+    );
    assert_eq!(win_move_marker_pct(&state), Some(90.0));
 }

@@ -524,12 +471,12 @@ fn win_move_marker_pct_is_some_at_correct_position() {
 fn win_move_marker_pct_clamps_to_track_bounds() {
    // Defensive: if a malformed replay carried `win_move_index >=
    // total`, the marker must still sit on the track, not past it.
-    let state = ReplayPlaybackState::Playing {
-        replay: synthetic_replay(5).with_win_move_index(Some(99)),
-        cursor: 0,
-        secs_to_next: 0.5,
-        paused: false,
-    };
+    let state = ReplayPlaybackState::playing(
+        synthetic_replay(5).with_win_move_index(Some(99)),
+        0,
+        0.5,
+        false,
+    );
    assert_eq!(win_move_marker_pct(&state), Some(100.0));
 }

@@ -538,12 +485,12 @@ fn marker_spawned_when_replay_has_win_move_index() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(8).with_win_move_index(Some(7)),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(
+            synthetic_replay(8).with_win_move_index(Some(7)),
+            0,
+            0.5,
+            false,
+        ),
    );
    app.update();
    assert_eq!(
@@ -559,12 +506,7 @@ fn marker_not_spawned_when_replay_lacks_win_move_index() {
    // Default constructor → win_move_index: None (legacy replay).
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(8),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(8), 0, 0.5, false),
    );
    app.update();
    assert_eq!(
@@ -579,12 +521,12 @@ fn marker_despawns_when_replay_state_returns_to_inactive() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(8).with_win_move_index(Some(7)),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(
+            synthetic_replay(8).with_win_move_index(Some(7)),
+            0,
+            0.5,
+            false,
+        ),
    );
    app.update();
    assert_eq!(win_marker_count(&mut app), 1);
@@ -608,12 +550,12 @@ fn win_move_marker_carries_hc_background_marker() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(8).with_win_move_index(Some(7)),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(
+            synthetic_replay(8).with_win_move_index(Some(7)),
+            0,
+            0.5,
+            false,
+        ),
    );
    app.update();

@@ -669,12 +611,7 @@ fn scrub_notches_spawn_with_overlay() {

    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 0, 0.5, false),
    );
    app.update();
    assert_eq!(
@@ -693,12 +630,7 @@ fn scrub_notches_carry_high_contrast_background_marker() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 0, 0.5, false),
    );
    app.update();

@@ -723,12 +655,7 @@ fn scrub_track_carries_high_contrast_background_marker() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 0, 0.5, false),
    );
    app.update();

@@ -759,12 +686,7 @@ fn scrub_notches_despawn_with_overlay() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 0, 0.5, false),
    );
    app.update();
    assert_eq!(scrub_notch_count(&mut app), 5);
@@ -821,12 +743,7 @@ fn scrub_notch_labels_spawn_with_overlay() {

    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 0, 0.5, false),
    );
    app.update();
    assert_eq!(
@@ -844,12 +761,7 @@ fn scrub_notch_labels_carry_helper_strings() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 0, 0.5, false),
    );
    app.update();

@@ -870,12 +782,7 @@ fn scrub_notch_labels_despawn_with_overlay() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 0, 0.5, false),
    );
    app.update();
    assert_eq!(scrub_notch_label_count(&mut app), 5);
@@ -947,12 +854,7 @@ fn keybind_footer_spawns_with_overlay() {

    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 0, 0.5, false),
    );
    app.update();
    assert_eq!(
@@ -970,12 +872,7 @@ fn keybind_footer_paints_helper_strings() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 0, 0.5, false),
    );
    app.update();

@@ -999,12 +896,7 @@ fn keybind_footer_carries_high_contrast_border_marker() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 0, 0.5, false),
    );
    app.update();

@@ -1025,12 +917,7 @@ fn keybind_footer_despawns_with_overlay() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 0, 0.5, false),
    );
    app.update();
    assert_eq!(keybind_footer_count(&mut app), 1);
@@ -1054,12 +941,7 @@ fn scrub_notches_spawn_even_without_win_marker() {
    // Default constructor → win_move_index: None.
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(8),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(8), 0, 0.5, false),
    );
    app.update();
    assert_eq!(
@@ -1144,12 +1026,7 @@ fn format_move_body_handles_stock_cycle() {
 /// `Inactive` → empty.
 #[test]
 fn format_move_log_header_covers_state_branches() {
-    let playing = ReplayPlaybackState::Playing {
-        replay: synthetic_replay(10),
-        cursor: 3,
-        secs_to_next: 0.5,
-        paused: false,
-    };
+    let playing = ReplayPlaybackState::playing(synthetic_replay(10), 3, 0.5, false);
    assert_eq!(
        format_move_log_header(&playing),
        "\u{258C} MOVE LOG \u{00B7} 3/10"
@@ -1167,24 +1044,14 @@ fn format_move_log_header_covers_state_branches() {
 /// `replay.moves[N - 1]` and the row reads `"N | ..."`.
 #[test]
 fn format_active_move_row_handles_cursor_zero_and_positive() {
-    let cursor_zero = ReplayPlaybackState::Playing {
-        replay: synthetic_replay(10),
-        cursor: 0,
-        secs_to_next: 0.5,
-        paused: false,
-    };
+    let cursor_zero = ReplayPlaybackState::playing(synthetic_replay(10), 0, 0.5, false);
    assert_eq!(
        format_active_move_row(&cursor_zero),
        "",
        "cursor=0 means no move applied yet; row stays empty",
    );

-    let cursor_three = ReplayPlaybackState::Playing {
-        replay: synthetic_replay(10),
-        cursor: 3,
-        secs_to_next: 0.5,
-        paused: false,
-    };
+    let cursor_three = ReplayPlaybackState::playing(synthetic_replay(10), 3, 0.5, false);
    // synthetic_replay produces all StockClicks, so the body
    // is "stock cycle". The displayed index is 3 (cursor),
    // matching the most-recently-applied move at moves[2].
@@ -1208,12 +1075,7 @@ fn move_log_panel_spawns_with_overlay() {

    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 0, 0.5, false),
    );
    app.update();
    assert_eq!(
@@ -1232,12 +1094,7 @@ fn move_log_panel_header_paints_helper_string() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(8),
-            cursor: 2,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(8), 2, 0.5, false),
    );
    app.update();
    assert_eq!(
@@ -1254,12 +1111,7 @@ fn move_log_active_row_repaints_on_cursor_advance() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 0, 0.5, false),
    );
    app.update();
    assert_eq!(
@@ -1271,12 +1123,7 @@ fn move_log_active_row_repaints_on_cursor_advance() {
    // Advance cursor to 2 (most-recently-applied move is moves[1]).
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 2,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 2, 0.5, false),
    );
    app.update();
    assert_eq!(
@@ -1292,12 +1139,7 @@ fn move_log_active_row_repaints_on_cursor_advance() {
 /// early in a replay don't paint stale text.
 #[test]
 fn format_kth_recent_row_handles_in_range_and_out_of_range() {
-    let state_at_three = ReplayPlaybackState::Playing {
-        replay: synthetic_replay(10),
-        cursor: 3,
-        secs_to_next: 0.5,
-        paused: false,
-    };
+    let state_at_three = ReplayPlaybackState::playing(synthetic_replay(10), 3, 0.5, false);
    // k=1 → active (most recent applied). cursor=3 → display=3.
    assert_eq!(
        format_kth_recent_row(&state_at_three, 1),
@@ -1348,12 +1190,7 @@ fn move_log_prev_rows_spawn_with_panel() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 3,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 3, 0.5, false),
    );
    app.update();
    assert_eq!(
@@ -1371,12 +1208,7 @@ fn move_log_prev_rows_paint_helper_strings_at_spawn() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 5,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 5, 0.5, false),
    );
    app.update();

@@ -1401,12 +1233,7 @@ fn move_log_prev_rows_repaint_on_cursor_advance() {
    // Start at cursor=2: offset 1 → k=2 → display=1, offset 2 → k=3 → empty (k > cursor).
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 2,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 2, 0.5, false),
    );
    app.update();
    assert_eq!(
@@ -1422,12 +1249,7 @@ fn move_log_prev_rows_repaint_on_cursor_advance() {
    // Advance to cursor=5 — both offsets now have history.
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 5,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 5, 0.5, false),
    );
    app.update();
    assert_eq!(
@@ -1465,12 +1287,7 @@ fn move_log_next_row_text_at_offset(app: &mut App, offset: u8) -> String {
 /// alongside in-range correctness.
 #[test]
 fn format_kth_next_row_handles_in_range_and_out_of_range() {
-    let state_at_three = ReplayPlaybackState::Playing {
-        replay: synthetic_replay(10),
-        cursor: 3,
-        secs_to_next: 0.5,
-        paused: false,
-    };
+    let state_at_three = ReplayPlaybackState::playing(synthetic_replay(10), 3, 0.5, false);
    // k=1 → moves[3], display=4
    assert_eq!(
        format_kth_next_row(&state_at_three, 1),
@@ -1498,12 +1315,7 @@ fn move_log_next_rows_spawn_with_panel() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 3,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 3, 0.5, false),
    );
    app.update();
    assert_eq!(
@@ -1520,12 +1332,7 @@ fn move_log_next_rows_paint_helper_strings_at_spawn() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 5,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 5, 0.5, false),
    );
    app.update();

@@ -1549,12 +1356,7 @@ fn move_log_next_rows_underfill_at_replay_end() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 9,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 9, 0.5, false),
    );
    app.update();
    assert_eq!(
@@ -1578,12 +1380,7 @@ fn active_row_wrapper_carries_accent_primary_background() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 3,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 3, 0.5, false),
    );
    app.update();

@@ -1621,12 +1418,7 @@ fn active_row_text_uses_high_contrast_color_for_highlight() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 3,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 3, 0.5, false),
    );
    app.update();

@@ -1647,24 +1439,14 @@ fn active_row_text_uses_high_contrast_color_for_highlight() {
 /// dropping it has to also update this test.
 #[test]
 fn active_row_format_includes_focus_prefix() {
-    let state = ReplayPlaybackState::Playing {
-        replay: synthetic_replay(10),
-        cursor: 5,
-        secs_to_next: 0.5,
-        paused: false,
-    };
+    let state = ReplayPlaybackState::playing(synthetic_replay(10), 5, 0.5, false);
    let row = format_active_move_row(&state);
    assert!(
        row.starts_with('\u{25B6}'),
        "active-row format must start with ▶ focus marker; got {row:?}",
    );
    // Cursor=0 still returns empty, never just the prefix.
-    let cursor_zero = ReplayPlaybackState::Playing {
-        replay: synthetic_replay(10),
-        cursor: 0,
-        secs_to_next: 0.5,
-        paused: false,
-    };
+    let cursor_zero = ReplayPlaybackState::playing(synthetic_replay(10), 0, 0.5, false);
    assert_eq!(
        format_active_move_row(&cursor_zero),
        "",
@@ -1679,12 +1461,7 @@ fn move_log_panel_despawns_with_overlay() {
    let mut app = headless_app();
    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(10),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(10), 0, 0.5, false),
    );
    app.update();
    assert_eq!(move_log_panel_count(&mut app), 1);
@@ -1728,21 +1505,11 @@ fn unique_button<M: Component>(app: &mut App) -> Entity {
 }

 fn pressed_paused_state(replay_len: usize, cursor: usize) -> ReplayPlaybackState {
-    ReplayPlaybackState::Playing {
-        replay: synthetic_replay(replay_len),
-        cursor,
-        secs_to_next: 0.5,
-        paused: true,
-    }
+    ReplayPlaybackState::playing(synthetic_replay(replay_len), cursor, 0.5, true)
 }

 fn running_state(replay_len: usize, cursor: usize) -> ReplayPlaybackState {
-    ReplayPlaybackState::Playing {
-        replay: synthetic_replay(replay_len),
-        cursor,
-        secs_to_next: 0.5,
-        paused: false,
-    }
+    ReplayPlaybackState::playing(synthetic_replay(replay_len), cursor, 0.5, false)
 }

 #[test]
@@ -2191,12 +1958,7 @@ fn dim_layer_spawns_and_despawns_with_overlay() {

    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(5),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(5), 0, 0.5, false),
    );
    app.update();
    assert_eq!(
@@ -2255,12 +2017,7 @@ fn mini_tableau_panel_spawns_and_despawns_with_overlay() {

    set_state(
        &mut app,
-        ReplayPlaybackState::Playing {
-            replay: synthetic_replay(5),
-            cursor: 0,
-            secs_to_next: 0.5,
-            paused: false,
-        },
+        ReplayPlaybackState::playing(synthetic_replay(5), 0, 0.5, false),
    );
    app.update();
    assert_eq!(
@@ -83,11 +83,11 @@ pub(crate) fn update_floating_progress_chip(
    // any). `cursor` is the index of the *next* move to apply, so
    // the most-recently-applied move sits at `cursor - 1`.
    let dest_pile = match state.as_ref() {
-        ReplayPlaybackState::Playing { replay, cursor, .. } if *cursor > 0 => {
+        ReplayPlaybackState::Playing { moves, cursor, .. } if *cursor > 0 => {
            // The destination pile is recoverable directly from the
            // instruction — no live state needed. `RotateStock` has no
            // destination (the chip hides over the stock pile).
-            match &replay.moves[cursor - 1] {
+            match &moves[cursor - 1] {
                KlondikeInstruction::DstFoundation(dst) => {
                    Some(KlondikePile::Foundation(dst.foundation))
                }
@@ -1,11 +1,12 @@
 //! In-engine replay playback core.
 //!
 //! When the player clicks "Watch replay" on the Stats overlay, the live
-//! game state is reset to the deal seeded from the replay's `seed` /
-//! `mode` / `draw_mode`, and the engine ticks through `replay.moves` at a
-//! steady cadence — firing the canonical [`MoveRequestEvent`] /
-//! [`DrawRequestEvent`] for each one. The existing animation pipeline
-//! plays back identically to a live game.
+//! game state is reset to the recorded deal — rebuilt directly from
+//! `replay.recording` via `GameState::from_recording`, never by
+//! re-dealing the seed — and the engine ticks through the recording's
+//! instruction list at a steady cadence, firing the canonical
+//! [`MoveRequestEvent`] / [`DrawRequestEvent`] for each one. The
+//! existing animation pipeline plays back identically to a live game.
 //!
 //! ## Public surface
 //!
@@ -95,7 +96,7 @@ pub const REPLAY_COMPLETION_LINGER_SECS: f32 = 5.0;
 /// 3. The tick system [`tick_replay_playback`] advances `cursor` once
 ///    per [`REPLAY_MOVE_INTERVAL_SECS`] and fires the canonical event
 ///    for each [`KlondikeInstruction`].
-/// 4. When `cursor == replay.moves.len()`, the state transitions to
+/// 4. When `cursor == moves.len()`, the state transitions to
 ///    [`Completed`](Self::Completed). It lingers for
 ///    [`REPLAY_COMPLETION_LINGER_SECS`] (driven by
 ///    [`auto_clear_completed_replay`]) before returning to
@@ -109,14 +110,20 @@ pub enum ReplayPlaybackState {
    #[default]
    Inactive,
    /// A replay is currently being played back. The overlay reads
-    /// `replay.moves.len()` for the denominator of the progress
+    /// `moves.len()` for the denominator of the progress
    /// indicator and `cursor` for the numerator.
    Playing {
        /// The replay being played back. Owned so the state is the
        /// only place playback metadata lives — no separate resource
-        /// needed.
-        replay: Replay,
-        /// Index of the next move to apply, in `[0, replay.moves.len()]`.
+        /// needed. Boxed: the v4 recording embeds the dealt board and
+        /// would otherwise dwarf the other variants
+        /// (`clippy::large_enum_variant`).
+        replay: Box<Replay>,
+        /// Instruction list extracted once from `replay.recording` at
+        /// [`start_replay_playback`] time, so the per-frame tick indexes
+        /// a plain slice instead of re-walking the recording.
+        moves: Vec<KlondikeInstruction>,
+        /// Index of the next move to apply, in `[0, moves.len()]`.
        cursor: usize,
        /// Seconds remaining until the next move is dispatched.
        secs_to_next: f32,
@@ -138,6 +145,19 @@ pub enum ReplayPlaybackState {
 }

 impl ReplayPlaybackState {
+    /// Construct a [`Self::Playing`] state, extracting the instruction
+    /// list from `replay.recording` once up front.
+    pub fn playing(replay: Replay, cursor: usize, secs_to_next: f32, paused: bool) -> Self {
+        let moves = replay.recording.instructions();
+        Self::Playing {
+            replay: Box::new(replay),
+            moves,
+            cursor,
+            secs_to_next,
+            paused,
+        }
+    }
+
    /// Returns `true` when a replay is currently being played back.
    pub fn is_playing(&self) -> bool {
        matches!(self, Self::Playing { .. })
@@ -156,7 +176,7 @@ impl ReplayPlaybackState {
    /// the total is no longer available in `Completed`.
    pub fn progress(&self) -> Option<(usize, usize)> {
        match self {
-            Self::Playing { replay, cursor, .. } => Some((*cursor, replay.moves.len())),
+            Self::Playing { moves, cursor, .. } => Some((*cursor, moves.len())),
            Self::Inactive | Self::Completed => None,
        }
    }
@@ -191,7 +211,11 @@ pub fn start_replay_playback(
 ) {
    use solitaire_core::game_state::GameState;

-    let fresh = GameState::new_with_mode(replay.seed, replay.draw_mode, replay.mode);
+    // The recording carries the dealt board and the session config
+    // (including draw mode), so the fresh game is bit-identical to the
+    // recorded deal regardless of how the current build maps seeds to
+    // deals — `replay.seed` is presentation metadata only.
+    let (fresh, moves) = GameState::from_recording(&replay.recording, replay.seed, replay.mode);
    commands.insert_resource(GameStateResource(fresh));

    // Initial `secs_to_next` uses the constant rather than reading
@@ -201,7 +225,8 @@ pub fn start_replay_playback(
    // unusually short setting; subsequent ticks read the live setting
    // every frame via [`tick_replay_playback`].
    **state = ReplayPlaybackState::Playing {
-        replay,
+        replay: Box::new(replay),
+        moves,
        cursor: 0,
        secs_to_next: REPLAY_MOVE_INTERVAL_SECS,
        paused: false,
@@ -256,7 +281,7 @@ pub fn step_replay_playback(
    draws_writer: &mut MessageWriter<DrawRequestEvent>,
 ) -> bool {
    let ReplayPlaybackState::Playing {
-        replay,
+        moves,
        cursor,
        paused: true,
        ..
@@ -264,10 +289,10 @@ pub fn step_replay_playback(
    else {
        return false;
    };
-    if *cursor >= replay.moves.len() {
+    if *cursor >= moves.len() {
        return false;
    }
-    let instruction = replay.moves[*cursor];
+    let instruction = moves[*cursor];
    dispatch_instruction(instruction, *cursor, game, moves_writer, draws_writer);
    *cursor += 1;
    true
@@ -362,7 +387,7 @@ pub fn step_backwards_replay_playback(
 /// Drains `secs_to_next` by `time.delta_secs()`. When the countdown
 /// expires, fires the canonical event for the move at `cursor`,
 /// increments `cursor`, and resets `secs_to_next`. When `cursor`
-/// reaches `replay.moves.len()`, transitions to
+/// reaches `moves.len()`, transitions to
 /// [`ReplayPlaybackState::Completed`].
 ///
 /// The advance loop is a `while`, not an `if`, so coarse time steps
@@ -384,10 +409,11 @@ fn tick_replay_playback(
    let mut transition_to_completed = false;

    if let ReplayPlaybackState::Playing {
-        replay,
+        moves,
        cursor,
        secs_to_next,
        paused,
+        ..
    } = state.as_mut()
    {
        // While paused, the cursor and the timer freeze together —
@@ -397,8 +423,8 @@ fn tick_replay_playback(
        // path.
        if !*paused {
            *secs_to_next -= dt;
-            while *secs_to_next <= 0.0 && *cursor < replay.moves.len() {
-                let instruction = replay.moves[*cursor];
+            while *secs_to_next <= 0.0 && *cursor < moves.len() {
+                let instruction = moves[*cursor];
                dispatch_instruction(
                    instruction,
                    *cursor,
@@ -410,7 +436,7 @@ fn tick_replay_playback(
                *secs_to_next += interval;
            }

-            if *cursor >= replay.moves.len() {
+            if *cursor >= moves.len() {
                transition_to_completed = true;
            }
        }
@@ -524,6 +550,14 @@ fn fire_state_changed_on_completion(
    *last_was_completed = now_completed;
 }

+/// Set wrapping the replay playback driver chain (tick → auto-clear →
+/// completion `StateChangedEvent`). The tick feeds `MoveRequestEvent` /
+/// `DrawRequestEvent` into this frame's [`GameMutation`], so the set sits
+/// on the pre-mutation spine; the overlay UI (`replay_overlay`) orders
+/// itself after this set so its painters render the post-tick state (#143).
+#[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ReplayPlayback;
+
 /// Bevy plugin that initialises [`ReplayPlaybackState`] and drives
 /// playback ticks, completion linger, and the recording-pause guard.
 ///
@@ -536,18 +570,46 @@ impl Plugin for ReplayPlaybackPlugin {
    fn build(&self, app: &mut App) {
        app.init_resource::<ReplayPlaybackState>()
            .add_message::<StateChangedEvent>()
-            .add_systems(
+            .configure_sets(
                Update,
-                (
-                    tick_replay_playback,
-                    auto_clear_completed_replay,
-                    fire_state_changed_on_completion,
-                )
-                    .chain(),
+                ReplayPlayback
+                    .after(crate::game_plugin::PreMutation)
+                    // Input first: a stop/pause press or a drag-emitted
+                    // request this frame is observed before the tick fires
+                    // the next scripted move (#143).
+                    .after(crate::input_plugin::PointerInput)
+                    .before(GameMutation),
            )
            .add_systems(
                Update,
-                record_replay_skip_during_playback.after(GameMutation),
+                (
+                    // The tick shares the move/draw request streams with the
+                    // pointer/keyboard writers (drained wholesale at
+                    // GameMutation) and reads playback speed from settings.
+                    tick_replay_playback
+                        .in_set(crate::game_plugin::MoveRequestWriters)
+                        .ambiguous_with(crate::game_plugin::MoveRequestWriters)
+                        .in_set(crate::game_plugin::DrawRequestWriters)
+                        .ambiguous_with(crate::game_plugin::DrawRequestWriters)
+                        .in_set(crate::settings_plugin::SettingsAccess)
+                        .ambiguous_with(crate::settings_plugin::SettingsAccess),
+                    auto_clear_completed_replay,
+                    // Chained before GameMutation: explicit order against the
+                    // mutation systems' StateChangedEvent writes; readers
+                    // drain the whole queue after GameMutation.
+                    fire_state_changed_on_completion,
+                )
+                    .chain()
+                    .in_set(ReplayPlayback),
+            )
+            .add_systems(
+                Update,
+                record_replay_skip_during_playback
+                    .after(GameMutation)
+                    // After AutoComplete so the stats overlay's watch-replay
+                    // handler (which resets ReplayPlaybackState) and the
+                    // win-path recorder have both settled (#143).
+                    .after(crate::auto_complete_plugin::AutoComplete),
            );
    }
 }
@@ -562,8 +624,7 @@ mod tests {
    use crate::game_plugin::GamePlugin;
    use bevy::time::TimeUpdateStrategy;
    use chrono::NaiveDate;
-    use solitaire_core::KlondikeInstruction;
-    use solitaire_core::{DrawStockConfig, game_state::GameMode};
+    use solitaire_core::{DrawStockConfig, SessionRecording, game_state::GameMode};
    use std::time::Duration;

    /// Builds a headless `App` with `MinimalPlugins`, `GamePlugin`, and
@@ -612,11 +673,11 @@ mod tests {
            60,
            500,
            NaiveDate::from_ymd_opt(2026, 5, 5).expect("valid date"),
-            vec![
-                KlondikeInstruction::RotateStock,
-                KlondikeInstruction::RotateStock,
-                KlondikeInstruction::RotateStock,
-            ],
+            SessionRecording::from_instructions_unchecked(
+                12345,
+                DrawStockConfig::DrawOne,
+                [KlondikeInstruction::RotateStock; 3],
+            ),
        )
    }

@@ -673,11 +734,14 @@ mod tests {
        let state = app.world().resource::<ReplayPlaybackState>();
        match state {
            ReplayPlaybackState::Playing {
-                cursor, replay: r, ..
+                cursor,
+                replay: r,
+                moves,
+                ..
            } => {
                assert_eq!(*cursor, 0);
                assert_eq!(r.seed, replay.seed);
-                assert_eq!(r.moves.len(), 3);
+                assert_eq!(moves.len(), 3);
            }
            other => panic!("expected Playing, got {other:?}"),
        }
@@ -778,7 +842,11 @@ mod tests {
            10,
            100,
            NaiveDate::from_ymd_opt(2026, 5, 5).expect("valid date"),
-            vec![KlondikeInstruction::RotateStock],
+            SessionRecording::from_instructions_unchecked(
+                42,
+                DrawStockConfig::DrawOne,
+                [KlondikeInstruction::RotateStock],
+            ),
        );
        start_playback(&mut app, one_move);
        app.update();
@@ -887,7 +955,11 @@ mod tests {
                10,
                100,
                NaiveDate::from_ymd_opt(2026, 5, 5).expect("valid date"),
-                vec![KlondikeInstruction::RotateStock; 10],
+                SessionRecording::from_instructions_unchecked(
+                    7,
+                    DrawStockConfig::DrawOne,
+                    [KlondikeInstruction::RotateStock; 10],
+                ),
            )
        }

@@ -102,6 +102,25 @@ pub enum SyncStatus {
 #[derive(Resource, Debug, Clone, Default)]
 pub struct SyncStatusResource(pub SyncStatus);

+/// Outcome of the most recent successful sync merge (Phase M — sync
+/// transparency). `None` until the first pull of the session resolves.
+///
+/// The Account tab renders the conflict details; the sync poller emits a
+/// one-line toast summary when `conflicts` is non-empty.
+#[derive(Resource, Debug, Clone, Default)]
+pub struct SyncConflictLog(pub Option<SyncMergeSummary>);
+
+/// Timestamp + per-field conflict list captured from
+/// [`solitaire_sync::merge`] after a pull resolves.
+#[derive(Debug, Clone)]
+pub struct SyncMergeSummary {
+    /// When the merge resolved.
+    pub at: DateTime<Utc>,
+    /// Fields that could not be merged deterministically (best-effort
+    /// resolution already applied — see `solitaire_sync::merge`).
+    pub conflicts: Vec<solitaire_sync::ConflictReport>,
+}
+
 /// Tracks which hint the player is currently cycling through.
 ///
 /// Incremented on each H press so repeated presses reveal different moves.
@@ -74,10 +74,28 @@ impl Plugin for SafeAreaInsetsPlugin {
            .add_systems(
                Update,
                (
-                    apply_safe_area_anchors,
-                    apply_safe_area_bottom_anchors,
-                    apply_safe_area_to_modal_scrims,
-                    on_app_resumed,
+                    // All three write Node padding on disjoint chrome roots
+                    // (top anchors / bottom anchors / modal scrims); chained
+                    // for a deterministic pass, and they join the UiTextFx
+                    // chrome club — anchored roots are never the label/
+                    // tooltip/readout entities the other members touch,
+                    // which Bevy can't prove from the queries (#143).
+                    (
+                        apply_safe_area_anchors,
+                        apply_safe_area_bottom_anchors,
+                        apply_safe_area_to_modal_scrims,
+                    )
+                        .chain()
+                        .in_set(crate::ui_theme::UiTextFx)
+                        .ambiguous_with(crate::ui_theme::UiTextFx)
+                        // UiScale is written on the settings mutator spine.
+                        .after(crate::settings_plugin::SettingsMutation),
+                    // Emits a synthetic WindowResized on resume only; every
+                    // reader drains the queue via cursor, and a resume
+                    // already spans hundreds of ms, so whether the synthetic
+                    // event lands this frame or next is invisible — same
+                    // argument as handle_fullscreen (#143).
+                    on_app_resumed.ambiguous_with_all(),
                ),
            );

@@ -101,9 +119,10 @@ impl Plugin for SafeAreaInsetsPlugin {
 fn apply_safe_area_anchors(
    insets: Res<SafeAreaInsets>,
    windows: Query<&Window>,
+    ui_scale: Option<Res<UiScale>>,
    mut q: Query<(&SafeAreaAnchoredTop, &mut Node)>,
 ) {
-    if !insets.is_changed() {
+    if !insets.is_changed() && !ui_scale.as_ref().is_some_and(|s| s.is_changed()) {
        return;
    }
    // Android's WindowInsets API returns physical pixels; Bevy UI's Val::Px
@@ -119,19 +138,31 @@ fn apply_safe_area_anchors(
        );
    }
    let top_logical = raw_top.min(max_inset);
+    // `bevy::ui::UiScale` (Phase K) multiplies every Val::Px at layout
+    // time. `base_top` is UI chrome and SHOULD scale with the rest of
+    // the interface, but the system-bar inset is physical reality —
+    // pre-divide it so the post-multiplication offset stays exact.
+    let ui = effective_ui_scale(ui_scale.as_deref());
    for (anchor, mut node) in &mut q {
-        node.top = Val::Px(anchor.base_top + top_logical);
+        node.top = Val::Px(anchor.base_top + top_logical / ui);
    }
 }

+/// The live UI scale, defensively clamped — a zero or negative scale
+/// would flip or destroy the inset math.
+fn effective_ui_scale(ui_scale: Option<&UiScale>) -> f32 {
+    ui_scale.map_or(1.0, |s| s.0.max(0.1))
+}
+
 /// Re-applies `base_bottom + insets.bottom / scale` to every entity carrying
 /// [`SafeAreaAnchoredBottom`] whenever [`SafeAreaInsets`] changes.
 fn apply_safe_area_bottom_anchors(
    insets: Res<SafeAreaInsets>,
    windows: Query<&Window>,
+    ui_scale: Option<Res<UiScale>>,
    mut q: Query<(&SafeAreaAnchoredBottom, &mut Node)>,
 ) {
-    if !insets.is_changed() {
+    if !insets.is_changed() && !ui_scale.as_ref().is_some_and(|s| s.is_changed()) {
        return;
    }
    let scale = windows.iter().next().map_or(1.0, |w| w.scale_factor());
@@ -144,8 +175,12 @@ fn apply_safe_area_bottom_anchors(
        );
    }
    let bottom_logical = raw_bottom.min(max_inset);
+    // See `apply_safe_area_anchors`: the physical inset is pre-divided
+    // by the UI scale so a 90% setting can't sink the action bar into
+    // the gesture zone (and 130% doesn't over-inset it).
+    let ui = effective_ui_scale(ui_scale.as_deref());
    for (anchor, mut node) in &mut q {
-        node.bottom = Val::Px(anchor.base_bottom + bottom_logical);
+        node.bottom = Val::Px(anchor.base_bottom + bottom_logical / ui);
    }
 }

@@ -163,19 +198,23 @@ fn apply_safe_area_bottom_anchors(
 fn apply_safe_area_to_modal_scrims(
    insets: Res<SafeAreaInsets>,
    windows: Query<&Window>,
+    ui_scale: Option<Res<UiScale>>,
    mut scrims: Query<&mut Node, With<ModalScrim>>,
    new_scrims: Query<(), (With<ModalScrim>, Added<ModalScrim>)>,
 ) {
    let has_new = !new_scrims.is_empty();
-    if !insets.is_changed() && !has_new {
+    if !insets.is_changed() && !has_new && !ui_scale.as_ref().is_some_and(|s| s.is_changed()) {
        return;
    }
    let scale = windows.iter().next().map_or(1.0, |w| w.scale_factor());
    let window_height = windows.iter().next().map_or(800.0, |w| w.height());
    // Clamp each inset to 25% of screen height so an unexpectedly large OS
    // value can't push the modal card off the visible area entirely.
-    let top_logical = (insets.top / scale).min(window_height * 0.25);
-    let bottom_logical = (insets.bottom / scale).min(window_height * 0.25);
+    // Physical insets are pre-divided by the UI scale — see
+    // `apply_safe_area_anchors`.
+    let ui = effective_ui_scale(ui_scale.as_deref());
+    let top_logical = (insets.top / scale).min(window_height * 0.25) / ui;
+    let bottom_logical = (insets.bottom / scale).min(window_height * 0.25) / ui;
    for mut node in &mut scrims {
        // Set both edges so the scrim's content box equals the usable area
        // between the status bar and the gesture/navigation bar. With
@@ -23,14 +23,43 @@ mod tests {
    use bevy::ecs::schedule::{LogLevel, ScheduleBuildSettings};
    use bevy::prelude::*;

+    use crate::achievement_plugin::AchievementPlugin;
+    use crate::animation_plugin::AnimationPlugin;
    use crate::auto_complete_plugin::AutoCompletePlugin;
+    use crate::card_animation::CardAnimationPlugin;
    use crate::card_plugin::CardPlugin;
+    use crate::challenge_plugin::ChallengePlugin;
+    use crate::cursor_plugin::CursorPlugin;
+    use crate::daily_challenge_plugin::DailyChallengePlugin;
+    use crate::difficulty_plugin::DifficultyPlugin;
+    use crate::feedback_anim_plugin::FeedbackAnimPlugin;
    use crate::game_plugin::GamePlugin;
+    use crate::help_plugin::HelpPlugin;
+    use crate::home_plugin::HomePlugin;
    use crate::hud_plugin::HudPlugin;
+    use crate::input_plugin::InputPlugin;
+    use crate::leaderboard_plugin::LeaderboardPlugin;
+    use crate::onboarding_plugin::OnboardingPlugin;
+    use crate::pause_plugin::PausePlugin;
+    use crate::play_by_seed_plugin::PlayBySeedPlugin;
+    use crate::profile_plugin::ProfilePlugin;
+    use crate::progress_plugin::ProgressPlugin;
+    use crate::radial_menu::RadialMenuPlugin;
+    use crate::replay_overlay::ReplayOverlayPlugin;
+    use crate::replay_playback::ReplayPlaybackPlugin;
+    use crate::safe_area::SafeAreaInsetsPlugin;
+    use crate::selection_plugin::SelectionPlugin;
    use crate::settings_plugin::SettingsPlugin;
+    use crate::splash_plugin::SplashPlugin;
+    use crate::stats_plugin::StatsPlugin;
    use crate::table_plugin::TablePlugin;
+    use crate::time_attack_plugin::TimeAttackPlugin;
+    use crate::touch_selection_plugin::TouchSelectionPlugin;
    use crate::ui_focus::UiFocusPlugin;
    use crate::ui_modal::UiModalPlugin;
+    use crate::ui_tooltip::UiTooltipPlugin;
+    use crate::weekly_goals_plugin::WeeklyGoalsPlugin;
+    use crate::win_summary_plugin::WinSummaryPlugin;

    /// The backlog (302 pairs on 2026-07-06) was burned down to ZERO the
    /// same day (#143, PRs #146–#149) — this is now a hard gate. If your
@@ -51,7 +80,40 @@ mod tests {
            .add_plugins(AutoCompletePlugin)
            .add_plugins(UiModalPlugin)
            .add_plugins(UiFocusPlugin)
-            .add_plugins(SettingsPlugin::headless());
+            .add_plugins(SettingsPlugin::headless())
+            // Batch: game-adjacent plugins (all already exercised headless
+            // by the engine behaviour tests).
+            .add_plugins(ProgressPlugin::headless())
+            .add_plugins(StatsPlugin::headless())
+            .add_plugins(AchievementPlugin::headless())
+            .add_plugins(SelectionPlugin)
+            .add_plugins(AnimationPlugin)
+            .add_plugins(CardAnimationPlugin)
+            .add_plugins(FeedbackAnimPlugin)
+            .add_plugins(PausePlugin)
+            // Batch: screen/overlay plugins.
+            .add_plugins(HomePlugin::headless())
+            .add_plugins(WinSummaryPlugin)
+            .add_plugins(SplashPlugin)
+            .add_plugins(HelpPlugin)
+            .add_plugins(OnboardingPlugin)
+            .add_plugins(ProfilePlugin)
+            .add_plugins(LeaderboardPlugin)
+            // Batch: mode/replay/input plugins.
+            .add_plugins(ChallengePlugin)
+            .add_plugins(DailyChallengePlugin)
+            .add_plugins(TimeAttackPlugin)
+            .add_plugins(WeeklyGoalsPlugin)
+            .add_plugins(PlayBySeedPlugin)
+            .add_plugins(DifficultyPlugin)
+            .add_plugins(ReplayPlaybackPlugin)
+            .add_plugins(ReplayOverlayPlugin)
+            .add_plugins(RadialMenuPlugin)
+            .add_plugins(InputPlugin)
+            .add_plugins(TouchSelectionPlugin)
+            .add_plugins(UiTooltipPlugin)
+            .add_plugins(CursorPlugin)
+            .add_plugins(SafeAreaInsetsPlugin);
        app.init_resource::<ButtonInput<KeyCode>>();
        app
    }
@@ -134,6 +134,14 @@ impl KeyboardDragState {
 #[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
 pub struct SelectionKeySet;

+/// Set wrapping the post-mutation selection maintenance chain (clearing the
+/// selection on state change, painting the highlight). Runs between
+/// [`crate::game_plugin::GameMutation`] and
+/// [`crate::card_plugin::BoardVisuals`] so the painters read the settled
+/// selection/drag state (#143).
+#[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SelectionFx;
+
 /// Marker component placed on the outline sprite used as the keyboard-selection
 /// highlight.
 ///
@@ -158,14 +166,35 @@ impl Plugin for SelectionPlugin {
                (
                    handle_selection_keys
                        .in_set(SelectionKeySet)
-                        .before(GameMutation),
-                    clear_selection_on_state_change.after(GameMutation),
-                    update_selection_highlight.after(GameMutation).run_if(
-                        resource_changed::<SelectionState>
-                            .or(resource_changed::<KeyboardDragState>)
-                            .or(resource_changed::<GameStateResource>),
-                    ),
+                        .before(GameMutation)
+                        // Enter-to-move feeds the shared move request
+                        // stream (drained wholesale at GameMutation, #143).
+                        .in_set(crate::game_plugin::MoveRequestWriters)
+                        .ambiguous_with(crate::game_plugin::MoveRequestWriters),
+                    (
+                        clear_selection_on_state_change,
+                        update_selection_highlight.run_if(
+                            resource_changed::<SelectionState>
+                                .or(resource_changed::<KeyboardDragState>)
+                                .or(resource_changed::<GameStateResource>),
+                        ),
+                    )
+                        .chain()
+                        .in_set(SelectionFx),
                ),
+            )
+            .configure_sets(
+                Update,
+                SelectionFx
+                    .after(GameMutation)
+                    .before(crate::card_plugin::BoardVisuals),
+            )
+            .configure_sets(
+                Update,
+                // Selection reads GameStateResource (legal destinations) —
+                // run after the pre-mutation spine that ticks/mutates it
+                // (#143).
+                SelectionKeySet.after(crate::game_plugin::PreMutation),
            );
    }
 }
@@ -0,0 +1,139 @@
+//! Phase M (sync transparency): local backup export/import.
+//!
+//! Runs in the `Last` schedule — the export snapshot is taken after the
+//! whole frame settles, and the import's resource rewrites become visible
+//! to every Update system on the next frame, keeping this rare bulk
+//! operation off the annotated Update spine entirely.
+
+use bevy::prelude::*;
+use chrono::Utc;
+use solitaire_data::{DataBundle, data_bundle_path, load_bundle_from, save_bundle_to};
+
+use crate::achievement_plugin::{AchievementsResource, AchievementsStoragePath};
+use crate::events::{
+    DataExportRequestEvent, DataImportRequestEvent, InfoToastEvent, WarningToastEvent,
+};
+use crate::progress_plugin::{ProgressResource, ProgressStoragePath};
+use crate::stats_plugin::{StatsResource, StatsStoragePath};
+
+use super::{SettingsChangedEvent, SettingsResource, SettingsStoragePath};
+
+/// Drains the export/import request streams and performs the file IO.
+///
+/// The bundle is small (a few KB of JSON), so the write happens inline
+/// rather than on the async pool — one synchronous write per explicit
+/// button press, never per frame.
+#[allow(clippy::too_many_arguments)]
+pub(super) fn handle_data_transfer(
+    mut exports: MessageReader<DataExportRequestEvent>,
+    mut imports: MessageReader<DataImportRequestEvent>,
+    mut settings: ResMut<SettingsResource>,
+    settings_path: Res<SettingsStoragePath>,
+    stats: Option<ResMut<StatsResource>>,
+    stats_path: Option<Res<StatsStoragePath>>,
+    achievements: Option<ResMut<AchievementsResource>>,
+    achievements_path: Option<Res<AchievementsStoragePath>>,
+    progress: Option<ResMut<ProgressResource>>,
+    progress_path: Option<Res<ProgressStoragePath>>,
+    mut settings_changed: MessageWriter<SettingsChangedEvent>,
+    mut info_toast: MessageWriter<InfoToastEvent>,
+    mut warning_toast: MessageWriter<WarningToastEvent>,
+) {
+    let export_requested = exports.read().next().is_some();
+    let import_requested = imports.read().next().is_some();
+    if !export_requested && !import_requested {
+        return;
+    }
+    // The bundle lives next to settings.json (same app data dir in
+    // production); deriving it from the injected settings path keeps
+    // tests off the real platform directory.
+    let path = settings_path
+        .0
+        .as_ref()
+        .map(|p| p.with_file_name(solitaire_data::transfer::DATA_BUNDLE_FILE_NAME))
+        .or_else(data_bundle_path);
+    let Some(path) = path else {
+        warning_toast.write(WarningToastEvent(
+            "No data directory available on this platform".to_string(),
+        ));
+        return;
+    };
+
+    // An import in the same frame as an export would race on the file;
+    // real UI can't produce both, but be deterministic anyway: export
+    // first, then import reads what was just written (a no-op restore).
+    if export_requested {
+        let bundle = DataBundle {
+            schema_version: solitaire_data::DATA_BUNDLE_SCHEMA_VERSION,
+            exported_at: Utc::now(),
+            settings: settings.0.clone(),
+            stats: stats.as_ref().map(|s| s.0.clone()).unwrap_or_default(),
+            achievements: achievements
+                .as_ref()
+                .map(|a| a.0.clone())
+                .unwrap_or_default(),
+            progress: progress.as_ref().map(|p| p.0.clone()).unwrap_or_default(),
+        };
+        match save_bundle_to(&path, &bundle) {
+            Ok(()) => {
+                info_toast.write(InfoToastEvent(format!(
+                    "Data exported to {}",
+                    path.display()
+                )));
+            }
+            Err(e) => {
+                warn!("data export failed: {e}");
+                warning_toast.write(WarningToastEvent(format!("Export failed: {e}")));
+            }
+        }
+    }
+
+    if import_requested {
+        match load_bundle_from(&path) {
+            Ok(bundle) => {
+                settings.0 = bundle.settings;
+                if let Some(target) = &settings_path.0
+                    && let Err(e) = solitaire_data::save_settings_to(target, &settings.0)
+                {
+                    warn!("import: failed to persist settings: {e}");
+                }
+                // Settings appliers (theme, audio, layout) react to the
+                // change event exactly as if edited in the panel.
+                settings_changed.write(SettingsChangedEvent(settings.0.clone()));
+
+                if let Some(mut s) = stats {
+                    s.0 = bundle.stats;
+                    if let Some(target) = stats_path.as_ref().and_then(|p| p.0.as_ref())
+                        && let Err(e) = solitaire_data::save_stats_to(target, &s.0)
+                    {
+                        warn!("import: failed to persist stats: {e}");
+                    }
+                }
+                if let Some(mut a) = achievements {
+                    a.0 = bundle.achievements;
+                    if let Some(target) = achievements_path.as_ref().and_then(|p| p.0.as_ref())
+                        && let Err(e) = solitaire_data::save_achievements_to(target, &a.0)
+                    {
+                        warn!("import: failed to persist achievements: {e}");
+                    }
+                }
+                if let Some(mut p) = progress {
+                    p.0 = bundle.progress;
+                    if let Some(target) = progress_path.as_ref().and_then(|pp| pp.0.as_ref())
+                        && let Err(e) = solitaire_data::save_progress_to(target, &p.0)
+                    {
+                        warn!("import: failed to persist progress: {e}");
+                    }
+                }
+                info_toast.write(InfoToastEvent(format!(
+                    "Backup from {} restored",
+                    bundle.exported_at.format("%Y-%m-%d %H:%M UTC")
+                )));
+            }
+            Err(e) => {
+                warn!("data import failed: {e}");
+                warning_toast.write(WarningToastEvent(format!("Import failed: {e}")));
+            }
+        }
+    }
+}
@@ -353,6 +353,14 @@ pub(super) fn handle_settings_buttons(
                    **t = on_off_label(settings.0.reduce_motion_mode);
                }
            }
+            SettingsButton::ToggleReduceTransparency => {
+                settings.0.reduce_transparency_mode = !settings.0.reduce_transparency_mode;
+                persist(&path, &settings.0);
+                changed.write(SettingsChangedEvent(settings.0.clone()));
+                // Text refreshed by `update_reduce_transparency_text`; the
+                // glass chrome itself follows via `update_glass_surfaces`
+                // next frame.
+            }
            SettingsButton::ToggleTouchInputMode => {
                use solitaire_data::settings::TouchInputMode;
                settings.0.touch_input_mode = match settings.0.touch_input_mode {
@@ -363,6 +371,14 @@ pub(super) fn handle_settings_buttons(
                changed.write(SettingsChangedEvent(settings.0.clone()));
                // Text refreshed by `update_touch_input_mode_text` next frame.
            }
+            SettingsButton::CycleUiScale => {
+                settings.0.ui_scale = next_ui_scale(settings.0.ui_scale);
+                persist(&path, &settings.0);
+                changed.write(SettingsChangedEvent(settings.0.clone()));
+                // Text refreshed by `update_ui_scale_text`; the live
+                // `bevy::ui::UiScale` resource follows via
+                // `sync_ui_scale_resource` next frame.
+            }
            SettingsButton::ToggleWinnableDealsOnly => {
                settings.0.winnable_deals_only = !settings.0.winnable_deals_only;
                persist(&path, &settings.0);
@@ -417,6 +433,9 @@ pub(super) fn handle_settings_buttons(
            SettingsButton::OpenThemeStore => {
                // Handled by `handle_sync_buttons`.
            }
+            SettingsButton::ExportData | SettingsButton::ImportData => {
+                // Handled by `handle_sync_buttons`.
+            }
            SettingsButton::Done => {
                screen.0 = false;
            }
@@ -444,14 +463,18 @@ pub(super) fn handle_tab_buttons(
 }

 /// Handles sync-related settings buttons: Sync Now, Connect, Disconnect,
-/// and Delete Account. Split from `handle_settings_buttons` to stay within
-/// Bevy's 16-parameter system limit.
+/// Delete Account, and the Phase M Export/Import data pair. Split from
+/// `handle_settings_buttons` to stay within Bevy's 16-parameter system
+/// limit.
+#[allow(clippy::too_many_arguments)]
 pub(super) fn handle_sync_buttons(
    interaction_query: Query<(&Interaction, &SettingsButton), Changed<Interaction>>,
    mut manual_sync: MessageWriter<ManualSyncRequestEvent>,
    mut configure_sync: MessageWriter<SyncConfigureRequestEvent>,
    mut logout_sync: MessageWriter<SyncLogoutRequestEvent>,
    mut delete_account: MessageWriter<DeleteAccountRequestEvent>,
+    mut export_data: MessageWriter<crate::events::DataExportRequestEvent>,
+    mut import_data: MessageWriter<crate::events::DataImportRequestEvent>,
    #[cfg(not(target_arch = "wasm32"))] mut open_theme_store: MessageWriter<
        crate::events::ThemeStoreOpenRequestEvent,
    >,
@@ -484,6 +507,12 @@ pub(super) fn handle_sync_buttons(
            SettingsButton::DeleteAccount => {
                delete_account.write(DeleteAccountRequestEvent);
            }
+            SettingsButton::ExportData => {
+                export_data.write(crate::events::DataExportRequestEvent);
+            }
+            SettingsButton::ImportData => {
+                import_data.write(crate::events::DataImportRequestEvent);
+            }
            _ => {}
        }
    }
@@ -25,6 +25,7 @@ use crate::events::{
 use crate::resources::SettingsScrollPos;
 use crate::theme::ThemeThumbnailPair;

+mod data_transfer;
 mod input;
 mod ui;
 mod updates;
@@ -87,6 +88,19 @@ pub struct SettingsChangedEvent(pub Settings);
 #[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
 pub struct SettingsMutation;

+/// Self-ambiguous club for the screen/overlay systems that touch
+/// [`SettingsResource`] (onboarding first-run flag, home difficulty/draw
+/// chips, leaderboard opt-in and display name, pause draw toggle, splash
+/// reduce-motion reads, …). Each accessor touches its own disjoint fields,
+/// and the modal-stacking guard means at most one of these screens is
+/// interactive at a time — same-frame access order is provably irrelevant,
+/// so members declare `.in_set(SettingsAccess).ambiguous_with(SettingsAccess)`
+/// (#143). [`SettingsMutation`] is nested inside the club (its members keep
+/// their internal chain). Do NOT add members whose settings read must be
+/// same-frame-exact; order those `.after(SettingsMutation)` instead.
+#[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SettingsAccess;
+
 /// Marker on the root Settings panel entity.
 #[derive(Component, Debug)]
 pub struct SettingsPanel;
@@ -111,6 +125,12 @@ struct ThemeText;
 #[derive(Component, Debug)]
 struct SyncStatusText;

+/// Marks the headline `Text` node of the last-merge summary in the
+/// Account tab (Phase M — sync transparency). Tests query it to assert
+/// the summary rendered.
+#[derive(Component, Debug)]
+pub(super) struct SyncMergeSummaryText;
+
 /// Marks the `Text` node showing the active card-back index.
 #[derive(Component, Debug)]
 struct CardBackText;
@@ -135,10 +155,18 @@ struct HighContrastText;
 #[derive(Component, Debug)]
 struct ReduceMotionText;

+/// Marks the `Text` node showing the current reduce-transparency state.
+#[derive(Component, Debug)]
+struct ReduceTransparencyText;
+
 /// Marks the `Text` node showing the current touch input mode state.
 #[derive(Component, Debug)]
 struct TouchInputModeText;

+/// Marks the `Text` node showing the current UI scale percentage.
+#[derive(Component, Debug)]
+struct UiScaleText;
+
 /// Marks the `Text` node showing the live tooltip-delay value.
 #[derive(Component, Debug)]
 struct TooltipDelayText;
@@ -273,10 +301,18 @@ enum SettingsButton {
    /// non-essential motion (card-slide animations become instant
    /// snaps) per `design-system.md` §Accessibility (#3).
    ToggleReduceMotion,
+    /// Toggle the [`Settings::reduce_transparency_mode`] flag — swaps
+    /// translucent glass chrome (the floating touch tab bar) for opaque
+    /// fills so table content never bleeds through UI text.
+    ToggleReduceTransparency,
    /// Toggle [`Settings::touch_input_mode`] between `OneTap`
    /// (auto-move on tap, default) and `TapToSelect` (first tap selects
    /// a card/stack, second tap on a target pile moves it).
    ToggleTouchInputMode,
+    /// Cycle [`Settings::ui_scale`] through 90 % → 100 % → 115 % →
+    /// 130 % → 90 %. Applied live via `bevy::ui::UiScale`; the table
+    /// stays window-fit (Phase K).
+    CycleUiScale,
    /// Toggle the [`Settings::winnable_deals_only`] flag. When on, new
    /// random Classic-mode deals are filtered through
    /// [`solitaire_core::game_state::GameState::solve_fresh_deal`] until one is provably
@@ -305,6 +341,10 @@ enum SettingsButton {
    DisconnectSync,
    /// Open the account-deletion confirmation modal.
    DeleteAccount,
+    /// Write every JSON save into one backup bundle (Phase M).
+    ExportData,
+    /// Restore every JSON save from the backup bundle (Phase M).
+    ImportData,
    Done,
    /// Select a specific card-back by index from the picker row.
    SelectCardBack(usize),
@@ -353,7 +393,9 @@ impl SettingsButton {
            // run before continuing to the picker rows.
            SettingsButton::ToggleHighContrast => 61,
            SettingsButton::ToggleReduceMotion => 62,
-            SettingsButton::ToggleTouchInputMode => 63,
+            SettingsButton::ToggleReduceTransparency => 63,
+            SettingsButton::ToggleTouchInputMode => 64,
+            SettingsButton::CycleUiScale => 65,
            // Picker rows — every swatch in a row shares the row's
            // priority so entity-index tiebreaking yields left → right.
            SettingsButton::SelectCardBack(_) => 70,
@@ -368,6 +410,8 @@ impl SettingsButton {
            SettingsButton::ConnectSync => 91,
            SettingsButton::DisconnectSync => 92,
            SettingsButton::DeleteAccount => 93,
+            SettingsButton::ExportData => 94,
+            SettingsButton::ImportData => 95,
            // Done is tagged by `attach_focusable_to_modal_buttons` and
            // never reaches `attach_focusable_to_settings_buttons`; the
            // value here is only a fallback for completeness.
@@ -421,6 +465,15 @@ impl Plugin for SettingsPlugin {
            .add_message::<SyncConfigureRequestEvent>()
            .add_message::<SyncLogoutRequestEvent>()
            .add_message::<DeleteAccountRequestEvent>()
+            .add_message::<crate::events::DataExportRequestEvent>()
+            .add_message::<crate::events::DataImportRequestEvent>()
+            // Idempotent — the sync plugin also registers it; needed here
+            // so the transfer handler's failure toasts work headless.
+            .add_message::<crate::events::WarningToastEvent>()
+            // Bulk backup/restore lives in Last: the export snapshot is
+            // taken post-frame and an import's rewrites surface next
+            // frame — keeps the rare path off the annotated Update spine.
+            .add_systems(Last, data_transfer::handle_data_transfer)
            .add_message::<ToggleSettingsRequestEvent>()
            .add_message::<crate::events::ThemeStoreOpenRequestEvent>()
            .add_message::<InfoToastEvent>()
@@ -441,7 +494,12 @@ impl Plugin for SettingsPlugin {
                Update,
                SettingsMutation
                    .after(crate::layout::LayoutSystem::UpdateOnResize)
-                    .before(crate::game_plugin::GameMutation),
+                    .before(crate::game_plugin::GameMutation)
+                    // Nested in the club: members keep their chain, but
+                    // their pairs against other screen-plugin settings
+                    // accessors are declared irrelevant (#143).
+                    .in_set(SettingsAccess)
+                    .ambiguous_with(SettingsAccess),
            )
            .add_systems(
                Update,
@@ -449,6 +507,11 @@ impl Plugin for SettingsPlugin {
                    handle_volume_keys,
                    record_window_geometry_changes,
                    persist_window_geometry_after_debounce,
+                    // State sync, not UI — runs even under `headless()`
+                    // so the live `bevy::ui::UiScale` always mirrors the
+                    // setting; rides the mutator spine so it is ordered
+                    // after every settings writer this frame.
+                    sync_ui_scale_resource,
                )
                    .chain()
                    .in_set(SettingsMutation),
@@ -459,8 +522,12 @@ impl Plugin for SettingsPlugin {
                    toggle_settings_screen
                        .before(crate::ui_focus::FocusKeys)
                        .ambiguous_with(crate::hud_plugin::HudButtons),
-                    scroll_settings_panel,
-                    crate::ui_modal::touch_scroll_panel::<SettingsPanelScrollable>,
+                    scroll_settings_panel
+                        .in_set(crate::ui_modal::PanelScroll)
+                        .ambiguous_with(crate::ui_modal::PanelScroll),
+                    crate::ui_modal::touch_scroll_panel::<SettingsPanelScrollable>
+                        .in_set(crate::ui_modal::PanelScroll)
+                        .ambiguous_with(crate::ui_modal::PanelScroll),
                )
                    .chain(),
            );
@@ -492,6 +559,7 @@ impl Plugin for SettingsPlugin {
                    update_high_contrast_backgrounds.run_if(resource_changed::<SettingsResource>),
                    update_reduce_motion_text,
                    update_touch_input_mode_text,
+                    update_ui_scale_text,
                    update_tooltip_delay_text,
                    update_time_bonus_multiplier_text,
                    update_replay_move_interval_text,
@@ -499,6 +567,16 @@ impl Plugin for SettingsPlugin {
                    update_smart_default_size_text,
                ),
            );
+            app.add_systems(
+                Update,
+                (
+                    update_reduce_transparency_text,
+                    // Guards internally on settings-change / newly added
+                    // glass — `Added<GlassSurface>` can't be expressed as
+                    // a resource run condition.
+                    update_glass_surfaces,
+                ),
+            );
            app.add_systems(
                Update,
                (
@@ -736,3 +736,150 @@ fn scroll_clamps_offset_to_zero_at_top() {
        "scrolling past top must clamp to 0, got {offset}"
    );
 }
+
+// ---------------------------------------------------------------------------
+// Phase K: UI scale
+// ---------------------------------------------------------------------------
+
+#[test]
+fn ui_scale_steps_cycle_and_wrap() {
+    assert_eq!(next_ui_scale(0.9), 1.0);
+    assert_eq!(next_ui_scale(1.0), 1.15);
+    assert_eq!(next_ui_scale(1.15), 1.3);
+    assert_eq!(next_ui_scale(1.3), 0.9, "the cycle must wrap");
+    // A hand-edited in-between value advances to the next larger step.
+    assert_eq!(next_ui_scale(1.05), 1.15);
+}
+
+#[test]
+fn ui_scale_label_formats_as_percent() {
+    assert_eq!(ui_scale_label(0.9), "90%");
+    assert_eq!(ui_scale_label(1.0), "100%");
+    assert_eq!(ui_scale_label(1.15), "115%");
+    assert_eq!(ui_scale_label(1.3), "130%");
+}
+
+#[test]
+fn ui_scale_setting_syncs_the_bevy_resource() {
+    let mut app = headless_app();
+    app.insert_resource(UiScale(1.0));
+    app.world_mut()
+        .resource_mut::<SettingsResource>()
+        .0
+        .ui_scale = 1.3;
+    app.update();
+
+    assert!(
+        (app.world().resource::<UiScale>().0 - 1.3).abs() < f32::EPSILON,
+        "Settings::ui_scale must drive bevy::ui::UiScale"
+    );
+}
+
+#[test]
+fn ui_scale_out_of_range_sanitizes_on_load() {
+    use solitaire_data::settings::{UI_SCALE_MAX, UI_SCALE_MIN};
+
+    let wild = Settings {
+        ui_scale: 5.0,
+        ..Settings::default()
+    }
+    .sanitized();
+    assert_eq!(wild.ui_scale, UI_SCALE_MAX);
+
+    let tiny = Settings {
+        ui_scale: 0.1,
+        ..Settings::default()
+    }
+    .sanitized();
+    assert_eq!(tiny.ui_scale, UI_SCALE_MIN);
+}
+
+// ---------------------------------------------------------------------------
+// Phase M: local data export / import
+// ---------------------------------------------------------------------------
+
+/// App with a real (temp-dir) settings path so the data-transfer handler
+/// derives its bundle path inside the temp dir instead of the platform
+/// data directory.
+fn transfer_app(dir: &std::path::Path) -> App {
+    let mut app = App::new();
+    app.add_plugins(MinimalPlugins).add_plugins(SettingsPlugin {
+        storage_path: Some(dir.join("settings.json")),
+        ui_enabled: false,
+    });
+    app.init_resource::<ButtonInput<KeyCode>>();
+    app.update();
+    app
+}
+
+#[test]
+fn export_then_import_round_trips_settings() {
+    let dir = std::env::temp_dir().join(format!("settings_transfer_{}", std::process::id()));
+    std::fs::create_dir_all(&dir).expect("temp dir");
+    let mut app = transfer_app(&dir);
+
+    app.world_mut()
+        .resource_mut::<SettingsResource>()
+        .0
+        .sfx_volume = 0.25;
+    app.world_mut()
+        .write_message(crate::events::DataExportRequestEvent);
+    app.update();
+    assert!(
+        dir.join(solitaire_data::transfer::DATA_BUNDLE_FILE_NAME)
+            .exists(),
+        "export should write the bundle next to settings.json"
+    );
+
+    // Clobber the live value, then restore from the bundle.
+    app.world_mut()
+        .resource_mut::<SettingsResource>()
+        .0
+        .sfx_volume = 1.0;
+    app.world_mut()
+        .write_message(crate::events::DataImportRequestEvent);
+    app.update();
+    // Import handling runs in Last of the same frame; the rewrite is
+    // visible immediately after update() returns.
+    let restored = app.world().resource::<SettingsResource>().0.sfx_volume;
+    assert!(
+        (restored - 0.25).abs() < f32::EPSILON,
+        "import should restore the exported value, got {restored}"
+    );
+
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[test]
+fn import_without_backup_warns_instead_of_defaulting() {
+    let dir =
+        std::env::temp_dir().join(format!("settings_transfer_missing_{}", std::process::id()));
+    std::fs::create_dir_all(&dir).expect("temp dir");
+    let mut app = transfer_app(&dir);
+
+    app.world_mut()
+        .resource_mut::<SettingsResource>()
+        .0
+        .sfx_volume = 0.25;
+    app.world_mut()
+        .write_message(crate::events::DataImportRequestEvent);
+    app.update();
+
+    // Settings untouched (no silent default-restore)…
+    let v = app.world().resource::<SettingsResource>().0.sfx_volume;
+    assert!(
+        (v - 0.25).abs() < f32::EPSILON,
+        "failed import must not touch settings"
+    );
+    // …and the failure is surfaced as a warning toast.
+    let msgs = app
+        .world()
+        .resource::<Messages<crate::events::WarningToastEvent>>();
+    let mut cursor = msgs.get_cursor();
+    assert!(
+        cursor.read(msgs).any(|w| w.0.contains("Import failed")),
+        "missing backup should emit a warning toast"
+    );
+
+    let _ = std::fs::remove_dir_all(&dir);
+}
@@ -46,6 +46,7 @@ pub(super) fn spawn_settings_panel(
    scroll_offset: f32,
    font_res: Option<&FontResource>,
    theme_overrides_back: bool,
+    conflict_log: Option<&crate::resources::SyncConflictLog>,
    active_tab: SettingsTab,
 ) {
    spawn_modal(commands, SettingsPanel, Z_MODAL_PANEL, |card| {
@@ -100,7 +101,9 @@ pub(super) fn spawn_settings_panel(
                font_res,
            ),
            SettingsTab::Accessibility => spawn_accessibility_tab(body, settings, font_res),
-            SettingsTab::Account => spawn_account_tab(body, settings, sync_status, font_res),
+            SettingsTab::Account => {
+                spawn_account_tab(body, settings, sync_status, conflict_log, font_res)
+            }
        });

        // Done is the only action — primary so the player always knows
@@ -317,6 +320,15 @@ fn spawn_accessibility_tab(
        "Skips card-slide animations and other non-essential motion. Cards snap instantly to their target.",
        font_res,
    );
+    toggle_row(
+        body,
+        "Reduce Transparency",
+        ReduceTransparencyText,
+        on_off_label(settings.reduce_transparency_mode),
+        SettingsButton::ToggleReduceTransparency,
+        "Replaces the see-through glass toolbar with a solid panel so cards behind it never reduce readability.",
+        font_res,
+    );
    toggle_row(
        body,
        "Touch Input Mode",
@@ -326,6 +338,15 @@ fn spawn_accessibility_tab(
        "One-tap: tap a card to auto-move it. Tap to select: first tap selects a card, second tap on a pile moves it.",
        font_res,
    );
+    toggle_row(
+        body,
+        "UI Scale",
+        UiScaleText,
+        ui_scale_label(settings.ui_scale),
+        SettingsButton::CycleUiScale,
+        "Scales all menus, buttons, and HUD text. The table itself always fits the screen.",
+        font_res,
+    );
    tooltip_delay_row(body, settings.tooltip_delay_secs, font_res);
 }

@@ -335,6 +356,7 @@ fn spawn_account_tab(
    body: &mut ChildSpawnerCommands,
    settings: &Settings,
    sync_status: &str,
+    conflict_log: Option<&crate::resources::SyncConflictLog>,
    font_res: Option<&FontResource>,
 ) {
    // --- Privacy (only shown when a Matomo URL is configured) ---
@@ -354,6 +376,144 @@ fn spawn_account_tab(
    // --- Sync ---
    section_label(body, "Sync", font_res);
    sync_row(body, sync_status, &settings.sync_backend, font_res);
+    spawn_sync_merge_summary(body, conflict_log, font_res);
+
+    // --- Local data (Phase M) --- backup/restore of the JSON saves;
+    // filesystem-backed, so not offered on the wasm build.
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        section_label(body, "Local data", font_res);
+        local_data_row(body, font_res);
+    }
+}
+
+/// `Export data` / `Import data` pill buttons plus a caption naming the
+/// backup file (Phase M). Mirrors the sync row's pill-button styling.
+#[cfg(not(target_arch = "wasm32"))]
+fn local_data_row(parent: &mut ChildSpawnerCommands, font_res: Option<&FontResource>) {
+    let button_font = TextFont {
+        font: font_res.map(|f| f.0.clone()).unwrap_or_default(),
+        font_size: TYPE_CAPTION,
+        ..default()
+    };
+    let caption_font = button_font.clone();
+
+    let small_button = |row: &mut ChildSpawnerCommands,
+                        marker: SettingsButton,
+                        label: &str,
+                        tooltip: String,
+                        font: TextFont| {
+        row.spawn((
+            marker,
+            Button,
+            Tooltip::new(tooltip),
+            Node {
+                padding: UiRect::axes(VAL_SPACE_3, VAL_SPACE_2),
+                justify_content: JustifyContent::Center,
+                border: UiRect::all(Val::Px(1.0)),
+                border_radius: BorderRadius::all(Val::Px(RADIUS_SM)),
+                ..default()
+            },
+            BackgroundColor(BG_ELEVATED_HI),
+            BorderColor::all(BORDER_SUBTLE),
+            HighContrastBorder::with_default(BORDER_SUBTLE),
+        ))
+        .with_children(|b| {
+            b.spawn((Text::new(label.to_string()), font, TextColor(TEXT_PRIMARY)));
+        });
+    };
+
+    parent
+        .spawn(Node {
+            flex_direction: FlexDirection::Column,
+            row_gap: VAL_SPACE_2,
+            ..default()
+        })
+        .with_children(|col| {
+            col.spawn(Node {
+                flex_direction: FlexDirection::Row,
+                align_items: AlignItems::Center,
+                column_gap: VAL_SPACE_3,
+                flex_wrap: FlexWrap::Wrap,
+                row_gap: VAL_SPACE_2,
+                ..default()
+            })
+            .with_children(|row| {
+                small_button(
+                    row,
+                    SettingsButton::ExportData,
+                    "Export data",
+                    "Write settings, stats, achievements and progress to one backup file"
+                        .to_string(),
+                    button_font.clone(),
+                );
+                small_button(
+                    row,
+                    SettingsButton::ImportData,
+                    "Import data",
+                    "Restore all saves from the backup file (replaces current data)".to_string(),
+                    button_font.clone(),
+                );
+            });
+            col.spawn((
+                Text::new(format!(
+                    "Backup file: {}",
+                    solitaire_data::data_bundle_path()
+                        .map_or_else(|| "unavailable".to_string(), |p| p.display().to_string())
+                )),
+                caption_font,
+                TextColor(TEXT_SECONDARY),
+            ));
+        });
+}
+
+/// Phase M (sync transparency): renders what the most recent sync merge
+/// did — a clean-merge caption, or one line per conflicting field with
+/// both values, so the player can see exactly which numbers were
+/// reconciled and how.
+fn spawn_sync_merge_summary(
+    body: &mut ChildSpawnerCommands,
+    conflict_log: Option<&crate::resources::SyncConflictLog>,
+    font_res: Option<&FontResource>,
+) {
+    let Some(summary) = conflict_log.and_then(|log| log.0.as_ref()) else {
+        return;
+    };
+    let caption_font = TextFont {
+        font: font_res.map(|f| f.0.clone()).unwrap_or_default(),
+        font_size: TYPE_CAPTION,
+        ..default()
+    };
+    let when = summary.at.format("%H:%M UTC");
+    if summary.conflicts.is_empty() {
+        body.spawn((
+            SyncMergeSummaryText,
+            Text::new(format!("Last merge at {when}: no conflicts")),
+            caption_font,
+            TextColor(TEXT_SECONDARY),
+        ));
+        return;
+    }
+    let n = summary.conflicts.len();
+    let plural = if n == 1 { "conflict" } else { "conflicts" };
+    body.spawn((
+        SyncMergeSummaryText,
+        Text::new(format!(
+            "Last merge at {when}: {n} {plural} — kept newer values"
+        )),
+        caption_font.clone(),
+        TextColor(TEXT_SECONDARY),
+    ));
+    for c in &summary.conflicts {
+        body.spawn((
+            Text::new(format!(
+                "  {} — this device: {} / server: {}",
+                c.field, c.local_value, c.remote_value
+            )),
+            caption_font.clone(),
+            TextColor(TEXT_SECONDARY),
+        ));
+    }
 }

 /// Section divider — small lavender label inside the scrollable body.
@@ -9,8 +9,10 @@ use crate::font_plugin::FontResource;
 use crate::progress_plugin::ProgressResource;
 use crate::resources::{SettingsScrollPos, SyncStatus, SyncStatusResource};
 use crate::theme::ThemeThumbnailCache;
+use crate::ui_glass::{GlassSurface, glass_decorations};
 use crate::ui_modal::ModalScrim;
 use crate::ui_theme::{BORDER_SUBTLE_HC, HighContrastBackground, HighContrastBorder};
+use bevy::ui::{BackgroundGradient, BorderGradient};

 /// Spawns the Settings panel when `SettingsScreen` becomes `true`;
 /// despawns it when it becomes `false`.
@@ -30,6 +32,7 @@ pub(super) fn sync_settings_panel_visibility(
    theme_registry: Option<Res<crate::theme::ThemeRegistry>>,
    theme_thumbs: Option<Res<ThemeThumbnailCache>>,
    card_images: Option<Res<crate::card_plugin::CardImageSet>>,
+    conflict_log: Option<Res<crate::resources::SyncConflictLog>>,
 ) {
    if !screen.is_changed() {
        return;
@@ -45,6 +48,7 @@ pub(super) fn sync_settings_panel_visibility(
                theme_registry.as_deref(),
                theme_thumbs.as_deref(),
                card_images.as_deref(),
+                conflict_log.as_deref(),
                scroll_pos.0,
                active_tab.0,
            );
@@ -74,6 +78,7 @@ fn build_panel(
    theme_registry: Option<&crate::theme::ThemeRegistry>,
    theme_thumbs: Option<&ThemeThumbnailCache>,
    card_images: Option<&crate::card_plugin::CardImageSet>,
+    conflict_log: Option<&crate::resources::SyncConflictLog>,
    scroll_offset: f32,
    active_tab: SettingsTab,
 ) {
@@ -123,6 +128,7 @@ fn build_panel(
        scroll_offset,
        font_res,
        theme_overrides_back,
+        conflict_log,
        active_tab,
    );
 }
@@ -143,6 +149,7 @@ pub(super) fn rebuild_panel_on_tab_change(
    theme_registry: Option<Res<crate::theme::ThemeRegistry>>,
    theme_thumbs: Option<Res<ThemeThumbnailCache>>,
    card_images: Option<Res<crate::card_plugin::CardImageSet>>,
+    conflict_log: Option<Res<crate::resources::SyncConflictLog>>,
 ) {
    if !active_tab.is_changed() || active_tab.is_added() {
        return;
@@ -165,6 +172,7 @@ pub(super) fn rebuild_panel_on_tab_change(
        theme_registry.as_deref(),
        theme_thumbs.as_deref(),
        card_images.as_deref(),
+        conflict_log.as_deref(),
        0.0,
        active_tab.0,
    );
@@ -330,6 +338,41 @@ pub(super) fn update_reduce_motion_text(
    }
 }

+pub(super) fn update_reduce_transparency_text(
+    settings: Res<SettingsResource>,
+    mut text_nodes: Query<&mut Text, With<ReduceTransparencyText>>,
+) {
+    if !settings.is_changed() {
+        return;
+    }
+    for mut text in &mut text_nodes {
+        **text = on_off_label(settings.0.reduce_transparency_mode);
+    }
+}
+
+/// Retargets every [`GlassSurface`]'s sheen + rim gradients when the
+/// reduce-transparency or high-contrast toggles change. Runs on
+/// `SettingsResource` change and on newly added surfaces (so glass
+/// spawned after startup picks up an already-active toggle). Parallel to
+/// [`update_high_contrast_borders`]: same trigger, different components.
+pub(super) fn update_glass_surfaces(
+    settings: Res<SettingsResource>,
+    mut surfaces: Query<(&mut BackgroundGradient, &mut BorderGradient), With<GlassSurface>>,
+    added: Query<(), Added<GlassSurface>>,
+) {
+    if !settings.is_changed() && added.is_empty() {
+        return;
+    }
+    let (sheen, rim) = glass_decorations(
+        settings.0.reduce_transparency_mode,
+        settings.0.high_contrast_mode,
+    );
+    for (mut s, mut r) in &mut surfaces {
+        *s = sheen.clone();
+        *r = rim.clone();
+    }
+}
+
 pub(super) fn update_touch_input_mode_text(
    settings: Res<SettingsResource>,
    mut text_nodes: Query<&mut Text, With<TouchInputModeText>>,
@@ -515,6 +558,58 @@ pub(super) fn touch_input_mode_label(mode: &solitaire_data::settings::TouchInput
    }
 }

+/// The four UI-scale steps the settings row cycles through (Phase K).
+pub(super) const UI_SCALE_STEPS: [f32; 4] = [0.9, 1.0, 1.15, 1.3];
+
+/// The next UI-scale step after `current`, wrapping 130 % → 90 %. A
+/// hand-edited value between steps advances to the first step larger
+/// than it, so the cycle always makes visible progress.
+pub(super) fn next_ui_scale(current: f32) -> f32 {
+    for step in UI_SCALE_STEPS {
+        if step > current + 0.001 {
+            return step;
+        }
+    }
+    UI_SCALE_STEPS[0]
+}
+
+/// Display string for the UI-scale row, e.g. `"115%"`.
+pub(super) fn ui_scale_label(scale: f32) -> String {
+    format!("{:.0}%", scale * 100.0)
+}
+
+/// Refreshes the live UI-scale value text whenever settings change.
+pub(super) fn update_ui_scale_text(
+    settings: Res<SettingsResource>,
+    mut text_nodes: Query<&mut Text, With<UiScaleText>>,
+) {
+    if !settings.is_changed() {
+        return;
+    }
+    for mut text in &mut text_nodes {
+        **text = ui_scale_label(settings.0.ui_scale);
+    }
+}
+
+/// Applies `Settings::ui_scale` to the live [`bevy::ui::UiScale`]
+/// resource — at startup (first change tick) and whenever the setting
+/// changes. Absent under `MinimalPlugins` (no `bevy_ui`), hence the
+/// `Option`; the table is unaffected either way (`compute_layout`
+/// owns world-space sizing, not UI scale).
+pub(super) fn sync_ui_scale_resource(
+    settings: Res<SettingsResource>,
+    ui_scale: Option<ResMut<UiScale>>,
+) {
+    let Some(mut ui_scale) = ui_scale else { return };
+    if !settings.is_changed() {
+        return;
+    }
+    let target = settings.0.ui_scale;
+    if (ui_scale.0 - target).abs() > f32::EPSILON {
+        ui_scale.0 = target;
+    }
+}
+
 /// Display string for the "Smart window size" toggle. The argument
 /// is the *enabled* state (i.e. the inverse of the underlying
 /// `disable_smart_default_size` field) so reading the label gives
@@ -99,7 +99,18 @@ impl Plugin for SplashPlugin {
    fn build(&self, app: &mut App) {
        app.add_systems(Startup, spawn_splash).add_systems(
            Update,
-            (dismiss_splash_on_input, advance_splash, pulse_splash_cursor).chain(),
+            // Splash text/fade writers touch UI entities only — they join
+            // the UiTextFx club (disjoint from board/anim sets) and, for
+            // the reduce-motion read in the pulse, the screen-plugin
+            // settings club. Disjoint from the HUD button painters for the
+            // same entity-domain reason (#143).
+            (dismiss_splash_on_input, advance_splash, pulse_splash_cursor)
+                .chain()
+                .in_set(crate::ui_theme::UiTextFx)
+                .ambiguous_with(crate::ui_theme::UiTextFx)
+                .ambiguous_with(crate::hud_plugin::HudButtons)
+                .in_set(crate::settings_plugin::SettingsAccess)
+                .ambiguous_with(crate::settings_plugin::SettingsAccess),
        );
    }
 }
@@ -30,7 +30,7 @@ use crate::ui_modal::{ButtonVariant, ModalButton, spawn_modal_button};
 use crate::ui_theme::{
    ACCENT_PRIMARY, BG_ELEVATED_HI, BORDER_SUBTLE, HighContrastBorder, RADIUS_SM, STATE_INFO,
    STATE_WARNING, STREAK_MILESTONES, TEXT_PRIMARY, TEXT_SECONDARY, TYPE_BODY, TYPE_BODY_LG,
-    TYPE_CAPTION, TYPE_HEADLINE, VAL_SPACE_1, VAL_SPACE_2, VAL_SPACE_3, VAL_SPACE_4,
+    TYPE_HEADLINE, VAL_SPACE_1, VAL_SPACE_2, VAL_SPACE_3, VAL_SPACE_4,
 };

 /// Bevy resource wrapping the current stats.
@@ -46,6 +46,14 @@ pub struct StatsStoragePath(pub Option<PathBuf>);
 #[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
 pub struct StatsUpdate;

+/// Set holding the abandon-recorder (`update_stats_on_new_game`). It must
+/// read the outgoing game's `move_count` before any mode-start handler or
+/// `GameMutation` clobbers the game state — mode plugins order their reset
+/// handlers `.after(AbandonRecord)` via `crate::game_plugin::ModeStart`
+/// (#143).
+#[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct AbandonRecord;
+
 /// Marker component on the stats overlay root node.
 #[derive(Component, Debug)]
 pub struct StatsScreen;
@@ -205,10 +213,34 @@ impl Plugin for StatsPlugin {
            // constraints (win_summary_plugin: cache_win_data.before(StatsUpdate)),
            // and a system cannot be both inside a set and individually before a
            // set-level ordering constraint.
-            .add_systems(Update, update_stats_on_new_game.before(GameMutation))
            .add_systems(
                Update,
-                update_stats_on_win.after(GameMutation).in_set(StatsUpdate),
+                update_stats_on_new_game
+                    .in_set(AbandonRecord)
+                    .before(GameMutation)
+                    // Reads the shared new-game request stream via its own
+                    // cursor — append order is irrelevant, so it joins the
+                    // self-ambiguous writer club (NewGameRequestWriters must
+                    // not carry set-level edges; see its doc). The explicit
+                    // edges pin it after the pause/settings/selection
+                    // mutators and the pre-mutation game-state spine it
+                    // reads `move_count` from (#143).
+                    .in_set(crate::game_plugin::NewGameRequestWriters)
+                    .ambiguous_with(crate::game_plugin::NewGameRequestWriters)
+                    .after(crate::game_plugin::PreMutation)
+                    .after(crate::pause_plugin::PauseMutation)
+                    .after(crate::settings_plugin::SettingsMutation)
+                    .after(crate::selection_plugin::SelectionKeySet),
+            )
+            .add_systems(
+                Update,
+                update_stats_on_win
+                    .after(GameMutation)
+                    .in_set(StatsUpdate)
+                    // Also emits toasts (streak milestones) — join the
+                    // self-ambiguous writer club (#143).
+                    .in_set(crate::game_plugin::InfoToastWriters)
+                    .ambiguous_with(crate::game_plugin::InfoToastWriters),
            )
            .add_systems(
                Update,
@@ -216,29 +248,69 @@ impl Plugin for StatsPlugin {
                // the NewGameRequestEvent it emits is not visible to
                // update_stats_on_new_game in the same frame — otherwise
                // record_abandoned() fires twice on every forfeit (#21).
+                // It drains the ForfeitEvent the pause/forfeit modal chain
+                // emits, and shares the new-game request stream with the
+                // other writers (#143).
                handle_forfeit
                    .before(GameMutation)
-                    .before(update_stats_on_new_game),
+                    .before(update_stats_on_new_game)
+                    .after(crate::pause_plugin::PauseMutation)
+                    .after(crate::selection_plugin::SelectionKeySet)
+                    .in_set(crate::game_plugin::NewGameRequestWriters)
+                    .ambiguous_with(crate::game_plugin::NewGameRequestWriters),
            )
            // Open/close/tab handling moved to `you_hub_plugin`
            // (Phase E) — this plugin now owns body content, replay
            // selector behavior, and scroll.
-            .add_systems(Update, refresh_replay_history_on_win.after(GameMutation))
-            .add_systems(Update, handle_watch_replay_button)
-            .add_systems(Update, handle_copy_share_link_button)
+            //
+            // Stats overlay UI: one deterministic chain — every member
+            // touches the replay-selector state or the overlay's nodes, and
+            // handle_watch_replay_button resets the live game, so the chain
+            // sits between GameMutation and the auto-complete driver on the
+            // game-state timeline (#143). The toast-emitting members join
+            // the self-ambiguous InfoToastWriters set so the toast pipeline
+            // (AnimFx) drains them this frame.
            .add_systems(
                Update,
                (
+                    refresh_replay_history_on_win,
                    handle_replay_selector_buttons,
-                    repaint_replay_selector_caption,
-                    repaint_replay_selector_detail,
+                    // Marker-filtered Text repaints — disjoint from the
+                    // HUD text painters (UiTextFx club, #143).
+                    repaint_replay_selector_caption
+                        .in_set(crate::ui_theme::UiTextFx)
+                        .ambiguous_with(crate::ui_theme::UiTextFx),
+                    repaint_replay_selector_detail
+                        .in_set(crate::ui_theme::UiTextFx)
+                        .ambiguous_with(crate::ui_theme::UiTextFx),
+                    handle_watch_replay_button
+                        .in_set(crate::game_plugin::InfoToastWriters)
+                        .ambiguous_with(crate::game_plugin::InfoToastWriters),
+                    handle_copy_share_link_button
+                        .in_set(crate::game_plugin::InfoToastWriters)
+                        .ambiguous_with(crate::game_plugin::InfoToastWriters),
                )
-                    .chain(),
+                    .chain()
+                    .after(GameMutation)
+                    // The overlay repaints read this frame's settled stats,
+                    // progress, and achievement evaluation (level line,
+                    // streak).
+                    .after(StatsUpdate)
+                    .after(crate::progress_plugin::ProgressUpdate)
+                    .after(crate::achievement_plugin::AchievementEval)
+                    .before(crate::auto_complete_plugin::AutoComplete),
            )
-            .add_systems(Update, scroll_stats_panel)
            .add_systems(
                Update,
-                crate::ui_modal::touch_scroll_panel::<StatsScrollable>,
+                scroll_stats_panel
+                    .in_set(crate::ui_modal::PanelScroll)
+                    .ambiguous_with(crate::ui_modal::PanelScroll),
+            )
+            .add_systems(
+                Update,
+                crate::ui_modal::touch_scroll_panel::<StatsScrollable>
+                    .in_set(crate::ui_modal::PanelScroll)
+                    .ambiguous_with(crate::ui_modal::PanelScroll),
            );
    }
 }
@@ -719,25 +791,17 @@ pub(crate) fn spawn_stats_body(
            },
        ))
        .with_children(|body| {
-            // First-launch caption — sits above the grid as gentle nudge so
+            // First-launch empty state (Phase L) — sits above the grid so
            // the wall of em-dashes reads as "nothing to track yet" rather
            // than as broken state.
            if is_first_launch {
-                body.spawn((
-                    Text::new("Play a game to start tracking stats."),
-                    TextFont {
-                        font_size: TYPE_CAPTION,
-                        ..default()
-                    },
-                    TextColor(TEXT_SECONDARY),
-                    Node {
-                        margin: UiRect {
-                            bottom: VAL_SPACE_2,
-                            ..default()
-                        },
-                        ..default()
-                    },
-                ));
+                crate::ui_modal::spawn_empty_state(
+                    body,
+                    "\u{2663}",
+                    "Play a game to start tracking stats.",
+                    None,
+                    font_res,
+                );
            }

            // --- primary stat cells grid ---
@@ -893,6 +957,20 @@ pub(crate) fn spawn_replays_body(
    selected_index: usize,
    font_res: Option<&FontResource>,
 ) {
+    // Standard empty state (Phase L) — the selector / Watch / Copy
+    // controls only spawn when there is something to select, so their
+    // handlers all no-op via their existing empty-query paths.
+    if replays.is_empty() {
+        crate::ui_modal::spawn_empty_state(
+            card,
+            "\u{2666}",
+            "No replays yet.",
+            Some("Every win records a replay here automatically."),
+            font_res,
+        );
+        return;
+    }
+
    let font_handle = font_res.map(|f| f.0.clone()).unwrap_or_default();
    let font_row = TextFont {
        font: font_handle,
@@ -1939,7 +2017,11 @@ mod tests {
            time_seconds,
            0,
            date,
-            vec![],
+            solitaire_core::SessionRecording::from_instructions_unchecked(
+                1,
+                solitaire_core::DrawStockConfig::DrawOne,
+                [],
+            ),
        );
        r.share_url = share_url;
        r
@@ -22,16 +22,19 @@ use solitaire_data::{
    AchievementRecord, PlayerProgress, Replay, StatsSnapshot, SyncError, SyncProvider,
    save_achievements_to, save_progress_to, save_replay_history_to, save_stats_to,
 };
-use solitaire_sync::{SyncPayload, SyncResponse, merge};
+use solitaire_sync::{SyncPayload, merge};

 use crate::achievement_plugin::{AchievementsResource, AchievementsStoragePath};
 use crate::events::{
-    GameWonEvent, ManualSyncRequestEvent, SyncCompleteEvent, SyncConfigureRequestEvent,
+    GameWonEvent, InfoToastEvent, ManualSyncRequestEvent, SyncConfigureRequestEvent,
    WarningToastEvent,
 };
 use crate::game_plugin::RecordingReplay;
 use crate::progress_plugin::{ProgressResource, ProgressStoragePath};
-use crate::resources::{GameStateResource, SyncStatus, SyncStatusResource, TokioRuntimeResource};
+use crate::resources::{
+    GameStateResource, SyncConflictLog, SyncMergeSummary, SyncStatus, SyncStatusResource,
+    TokioRuntimeResource,
+};
 use crate::stats_plugin::{
    LatestReplayPath, ReplayHistoryResource, StatsResource, StatsStoragePath,
 };
@@ -107,10 +110,13 @@ impl Plugin for SyncPlugin {
            .init_resource::<PullTaskResult>()
            .init_resource::<PullTask>()
            .init_resource::<PendingReplayUpload>()
+            .init_resource::<SyncConflictLog>()
            .add_message::<ManualSyncRequestEvent>()
-            .add_message::<SyncCompleteEvent>()
            .add_message::<SyncConfigureRequestEvent>()
-            .add_message::<WarningToastEvent>();
+            .add_message::<WarningToastEvent>()
+            // Idempotent — GamePlugin also registers it; re-register so the
+            // conflict-summary toast works under MinimalPlugins tests.
+            .add_message::<InfoToastEvent>();

        // Build the shared Tokio runtime; disable all network sync if the OS
        // refuses to create threads (resource-limited environments, sandboxed
@@ -198,9 +204,10 @@ fn poll_pull_result(
    achievements_path: Res<AchievementsStoragePath>,
    mut progress: ResMut<ProgressResource>,
    progress_path: Res<ProgressStoragePath>,
-    mut complete_writer: MessageWriter<SyncCompleteEvent>,
    mut configure_sync: MessageWriter<SyncConfigureRequestEvent>,
    mut warning_toast: MessageWriter<WarningToastEvent>,
+    mut conflict_log: ResMut<SyncConflictLog>,
+    mut info_toast: MessageWriter<InfoToastEvent>,
 ) {
    let Some(task) = task_res.0.as_mut() else {
        return;
@@ -215,6 +222,20 @@ fn poll_pull_result(
            let local = build_payload(&stats.0, &achievements.0, &progress.0);
            let (merged, conflicts) = merge(&local, &remote);

+            // Phase M (sync transparency): keep the conflict details for
+            // the Account tab and summarise non-clean merges in a toast.
+            if !conflicts.is_empty() {
+                let n = conflicts.len();
+                let plural = if n == 1 { "conflict" } else { "conflicts" };
+                info_toast.write(InfoToastEvent(format!(
+                    "Synced — {n} {plural}, kept newer values"
+                )));
+            }
+            conflict_log.0 = Some(SyncMergeSummary {
+                at: Utc::now(),
+                conflicts,
+            });
+
            // Persist merged state atomically.
            if let Some(p) = &stats_path.0
                && let Err(e) = save_stats_to(p, &merged.stats)
@@ -233,17 +254,10 @@ fn poll_pull_result(
            }

            // Update in-world resources.
-            let now = Utc::now();
-            stats.0 = merged.stats.clone();
-            achievements.0 = merged.achievements.clone();
-            progress.0 = merged.progress.clone();
-            status.0 = SyncStatus::LastSynced(now);
-
-            complete_writer.write(SyncCompleteEvent(Ok(SyncResponse {
-                merged,
-                server_time: now,
-                conflicts,
-            })));
+            stats.0 = merged.stats;
+            achievements.0 = merged.achievements;
+            progress.0 = merged.progress;
+            status.0 = SyncStatus::LastSynced(Utc::now());
        }
        Err(SyncError::UnsupportedPlatform) => {
            // No backend configured — not an error, just leave status as Idle.
@@ -266,8 +280,7 @@ fn poll_pull_result(
            if matches!(e, SyncError::Auth(_)) {
                configure_sync.write(SyncConfigureRequestEvent);
            }
-            status.0 = SyncStatus::Error(msg.clone());
-            complete_writer.write(SyncCompleteEvent(Err(msg)));
+            status.0 = SyncStatus::Error(msg);
        }
    }
 }
@@ -346,7 +359,11 @@ fn push_replay_on_win(
            ev.time_seconds,
            ev.score,
            Utc::now().date_naive(),
-            recording.moves.clone(),
+            // The live session is the authoritative recording; it
+            // serialises via the upstream card_game serializers so web
+            // playback rebuilds the exact deal instead of re-dealing
+            // the seed.
+            game.0.recording(),
        );
        let provider = provider.0.clone();
        let rt = rt.0.clone();
@@ -632,7 +649,11 @@ mod tests {
            60,
            500,
            chrono::NaiveDate::from_ymd_opt(2026, 5, 6).expect("valid date"),
-            vec![],
+            solitaire_core::SessionRecording::from_instructions_unchecked(
+                7,
+                DrawStockConfig::DrawOne,
+                [],
+            ),
        );
        let history = ReplayHistory {
            schema_version: solitaire_data::REPLAY_HISTORY_SCHEMA_VERSION,
@@ -112,7 +112,12 @@ impl Plugin for TablePlugin {
                    // paint pipeline — markers and cards share Sprite/
                    // Transform access (#143).
                    (
-                        apply_theme_on_settings_change,
+                        // Drains SettingsChangedEvent via cursor — a home
+                        // deal-option edit (post-mutation SettingsAccess
+                        // writer) surfacing one frame later repaints one
+                        // frame later, which is invisible (#143).
+                        apply_theme_on_settings_change
+                            .ambiguous_with(crate::settings_plugin::SettingsAccess),
                        apply_hint_pile_highlight,
                        tick_hint_pile_highlights,
                        sync_pile_marker_visibility.after(GameMutation),
@@ -14,6 +14,9 @@
 //! filesystem-based; the plugin is gated out on wasm32 alongside
 //! `SyncPlugin`.

+use std::collections::HashMap;
+
+use bevy::asset::RenderAssetUsages;
 use bevy::prelude::*;
 use bevy::tasks::{AsyncComputeTaskPool, Task, futures_lite::future};
 use thiserror::Error;
@@ -29,8 +32,8 @@ use crate::resources::TokioRuntimeResource;
 use crate::settings_plugin::{SettingsPanel, SettingsResource};
 use crate::theme::{ImportError, ThemeRegistry, import_theme, refresh_registry};
 use crate::ui_modal::{
-    ButtonVariant, ModalScrim, ScrimDismissible, spawn_modal, spawn_modal_actions,
-    spawn_modal_button, spawn_modal_header,
+    ButtonVariant, ModalScrim, ScrimDismissible, spawn_empty_state, spawn_modal,
+    spawn_modal_actions, spawn_modal_button, spawn_modal_header,
 };
 use crate::ui_theme::{
    BORDER_SUBTLE, TEXT_PRIMARY, TEXT_SECONDARY, TYPE_BODY, TYPE_CAPTION, VAL_SPACE_2, VAL_SPACE_3,
@@ -105,6 +108,21 @@ struct InstallTask(Option<(String, Task<InstallResult>)>);
 #[derive(Resource, Default)]
 struct StoreBaseUrl(Option<String>);

+/// Decoded preview thumbnails by theme id (Phase H). Session-lifetime:
+/// previews survive closing and reopening the store, so a revisit
+/// renders instantly without refetching.
+#[derive(Resource, Default)]
+struct PreviewCache(HashMap<String, Handle<Image>>);
+
+/// One in-flight preview download: raw PNG bytes or the fetch error.
+type PreviewFetch = Task<Result<Vec<u8>, ThemeStoreError>>;
+
+/// In-flight preview downloads, one per catalog entry that advertises
+/// a `preview_url` not already in [`PreviewCache`]. `String` is the
+/// theme id the bytes belong to.
+#[derive(Resource, Default)]
+struct PreviewTasks(Vec<(String, PreviewFetch)>);
+
 // ---------------------------------------------------------------------------
 // Plugin
 // ---------------------------------------------------------------------------
@@ -118,6 +136,8 @@ impl Plugin for ThemeStorePlugin {
            .init_resource::<CatalogTask>()
            .init_resource::<InstallTask>()
            .init_resource::<StoreBaseUrl>()
+            .init_resource::<PreviewCache>()
+            .init_resource::<PreviewTasks>()
            // Esc-close reads keyboard input; register defensively so
            // the plugin works under MinimalPlugins in tests.
            .init_resource::<ButtonInput<KeyCode>>()
@@ -129,6 +149,7 @@ impl Plugin for ThemeStorePlugin {
                (
                    handle_open_request,
                    poll_catalog_task,
+                    poll_preview_tasks,
                    handle_install_buttons,
                    poll_install_task,
                    handle_close_button,
@@ -176,6 +197,7 @@ fn handle_open_request(
    mut catalog_task: ResMut<CatalogTask>,
    mut store_base: ResMut<StoreBaseUrl>,
    mut warning_toast: MessageWriter<WarningToastEvent>,
+    previews: Res<PreviewCache>,
    mut commands: Commands,
    font_res: Option<Res<FontResource>>,
 ) {
@@ -207,16 +229,28 @@ fn handle_open_request(
        rt.block_on(async { ThemeStoreClient::new(base_url).fetch_catalog().await })
    }));

-    spawn_store_modal(&mut commands, &catalog_state, None, font_res.as_deref());
+    spawn_store_modal(
+        &mut commands,
+        &catalog_state,
+        None,
+        &previews,
+        font_res.as_deref(),
+    );
 }

-/// Polls the catalog fetch; on completion updates [`CatalogState`] and
+/// Polls the catalog fetch; on completion updates [`CatalogState`],
+/// kicks off preview downloads for entries not yet in the cache, and
 /// rebuilds the modal if it is still open.
+#[allow(clippy::too_many_arguments)]
 fn poll_catalog_task(
    mut catalog_task: ResMut<CatalogTask>,
    mut catalog_state: ResMut<CatalogState>,
    screens: Query<Entity, With<ThemeStoreScreen>>,
    registry: Option<Res<ThemeRegistry>>,
+    rt: Option<Res<TokioRuntimeResource>>,
+    store_base: Res<StoreBaseUrl>,
+    previews: Res<PreviewCache>,
+    mut preview_tasks: ResMut<PreviewTasks>,
    mut commands: Commands,
    font_res: Option<Res<FontResource>>,
 ) {
@@ -229,7 +263,29 @@ fn poll_catalog_task(
    catalog_task.0 = None;

    *catalog_state = match result {
-        Ok(entries) => CatalogState::Loaded(entries),
+        Ok(entries) => {
+            // Fetch previews for anything new. Decorative — failures
+            // just leave the row text-only, so errors only log.
+            if let (Some(rt), Some(base_url)) = (rt.as_ref(), store_base.0.as_deref()) {
+                for entry in entries
+                    .iter()
+                    .filter(|e| e.preview_url.is_some() && !previews.0.contains_key(&e.id))
+                {
+                    let rt = rt.0.clone();
+                    let base_url = base_url.to_owned();
+                    let entry = entry.clone();
+                    preview_tasks.0.push((
+                        entry.id.clone(),
+                        AsyncComputeTaskPool::get().spawn(async move {
+                            rt.block_on(async {
+                                ThemeStoreClient::new(base_url).fetch_preview(&entry).await
+                            })
+                        }),
+                    ));
+                }
+            }
+            CatalogState::Loaded(entries)
+        }
        Err(e) => {
            warn!("theme store: catalog fetch failed: {e}");
            CatalogState::Error(e.to_string())
@@ -241,10 +297,69 @@ fn poll_catalog_task(
        &mut commands,
        &catalog_state,
        registry.as_deref(),
+        &previews,
        font_res.as_deref(),
    );
 }

+/// Polls in-flight preview downloads. Each finished PNG is decoded into
+/// an [`Image`] asset and cached by theme id; the open modal rebuilds
+/// once per frame that added at least one preview, so thumbnails pop in
+/// as they arrive. Failures log and leave the row text-only. Skipped
+/// entirely when `Assets<Image>` is absent (`MinimalPlugins` tests).
+#[allow(clippy::too_many_arguments)]
+fn poll_preview_tasks(
+    mut preview_tasks: ResMut<PreviewTasks>,
+    mut previews: ResMut<PreviewCache>,
+    images: Option<ResMut<Assets<Image>>>,
+    catalog_state: Res<CatalogState>,
+    screens: Query<Entity, With<ThemeStoreScreen>>,
+    registry: Option<Res<ThemeRegistry>>,
+    mut commands: Commands,
+    font_res: Option<Res<FontResource>>,
+) {
+    if preview_tasks.0.is_empty() {
+        return;
+    }
+    let Some(mut images) = images else {
+        return;
+    };
+
+    let mut added = false;
+    preview_tasks.0.retain_mut(|(id, task)| {
+        let Some(result) = future::block_on(future::poll_once(task)) else {
+            return true; // still downloading
+        };
+        match result {
+            Ok(bytes) => match image::load_from_memory(&bytes) {
+                Ok(dyn_img) => {
+                    let handle = images.add(Image::from_dynamic(
+                        dyn_img,
+                        true,
+                        RenderAssetUsages::RENDER_WORLD,
+                    ));
+                    previews.0.insert(id.clone(), handle);
+                    added = true;
+                }
+                Err(e) => warn!("theme store: preview for '{id}' failed to decode: {e}"),
+            },
+            Err(e) => warn!("theme store: preview fetch for '{id}' failed: {e}"),
+        }
+        false
+    });
+
+    if added {
+        rebuild_open_modal(
+            &screens,
+            &mut commands,
+            &catalog_state,
+            registry.as_deref(),
+            &previews,
+            font_res.as_deref(),
+        );
+    }
+}
+
 /// Starts a download + import task when an Install button is pressed.
 /// One install at a time; repeat clicks while busy are ignored.
 fn handle_install_buttons(
@@ -308,6 +423,7 @@ fn poll_install_task(
    screens: Query<Entity, With<ThemeStoreScreen>>,
    mut info_toast: MessageWriter<InfoToastEvent>,
    mut warning_toast: MessageWriter<WarningToastEvent>,
+    previews: Res<PreviewCache>,
    mut commands: Commands,
    font_res: Option<Res<FontResource>>,
 ) {
@@ -343,6 +459,7 @@ fn poll_install_task(
        &mut commands,
        &catalog_state,
        registry.as_deref(),
+        &previews,
        font_res.as_deref(),
    );
 }
@@ -378,11 +495,12 @@ fn rebuild_open_modal(
    commands: &mut Commands,
    catalog_state: &CatalogState,
    registry: Option<&ThemeRegistry>,
+    previews: &PreviewCache,
    font_res: Option<&FontResource>,
 ) {
    for entity in screens {
        commands.entity(entity).despawn();
-        spawn_store_modal(commands, catalog_state, registry, font_res);
+        spawn_store_modal(commands, catalog_state, registry, previews, font_res);
    }
 }

@@ -391,6 +509,7 @@ fn spawn_store_modal(
    commands: &mut Commands,
    catalog_state: &CatalogState,
    registry: Option<&ThemeRegistry>,
+    previews: &PreviewCache,
    font_res: Option<&FontResource>,
 ) {
    let body_font = TextFont {
@@ -409,31 +528,45 @@ fn spawn_store_modal(

        match catalog_state {
            CatalogState::Idle | CatalogState::Loading => {
-                card.spawn((
-                    Text::new("Loading catalog…"),
-                    body_font.clone(),
-                    TextColor(TEXT_SECONDARY),
-                ));
+                spawn_empty_state(
+                    card,
+                    "\u{21BB}",
+                    "Loading the catalog\u{2026}",
+                    None,
+                    font_res,
+                );
            }
            CatalogState::Error(msg) => {
-                card.spawn((
-                    Text::new(format!("Could not load the catalog: {msg}")),
-                    body_font.clone(),
-                    TextColor(TEXT_SECONDARY),
-                ));
+                spawn_empty_state(
+                    card,
+                    "!",
+                    "Couldn't load the catalog.",
+                    Some(msg.as_str()),
+                    font_res,
+                );
            }
            CatalogState::Loaded(entries) if entries.is_empty() => {
-                card.spawn((
-                    Text::new("The server has no themes yet."),
-                    body_font.clone(),
-                    TextColor(TEXT_SECONDARY),
-                ));
+                spawn_empty_state(
+                    card,
+                    "#",
+                    "The server has no themes yet.",
+                    Some("Themes dropped into the server's theme_store folder appear here."),
+                    font_res,
+                );
            }
            CatalogState::Loaded(entries) => {
                for entry in entries {
                    let installed =
                        registry.is_some_and(|registry| registry.find(&entry.id).is_some());
-                    spawn_store_row(card, entry, installed, &body_font, &caption_font, font_res);
+                    spawn_store_row(
+                        card,
+                        entry,
+                        installed,
+                        previews.0.get(&entry.id),
+                        &body_font,
+                        &caption_font,
+                        font_res,
+                    );
                }
            }
        }
@@ -452,12 +585,20 @@ fn spawn_store_modal(
    commands.entity(scrim).insert(ScrimDismissible);
 }

-/// One catalog row: name + author/size caption on the left, Install
-/// button (or "Installed" caption) on the right.
+/// Height of a row's preview thumbnail in logical pixels; the width
+/// follows the theme's own `card_aspect` so a preview is never
+/// stretched.
+const PREVIEW_THUMB_HEIGHT_PX: f32 = 72.0;
+
+/// One catalog row: preview thumbnail (when downloaded) + name +
+/// author/size caption on the left, Install button (or "Installed"
+/// caption) on the right.
+#[allow(clippy::too_many_arguments)]
 fn spawn_store_row(
    parent: &mut ChildSpawnerCommands,
    entry: &ThemeCatalogEntry,
    installed: bool,
+    preview: Option<&Handle<Image>>,
    body_font: &TextFont,
    caption_font: &TextFont,
    font_res: Option<&FontResource>,
@@ -477,25 +618,45 @@ fn spawn_store_row(
        ))
        .with_children(|row| {
            row.spawn(Node {
-                flex_direction: FlexDirection::Column,
-                row_gap: VAL_SPACE_2,
+                flex_direction: FlexDirection::Row,
+                align_items: AlignItems::Center,
+                column_gap: VAL_SPACE_3,
                ..default()
            })
-            .with_children(|col| {
-                col.spawn((
-                    Text::new(entry.name.clone()),
-                    body_font.clone(),
-                    TextColor(TEXT_PRIMARY),
-                ));
-                col.spawn((
-                    Text::new(format!(
-                        "by {} — {} KB",
-                        entry.author,
-                        entry.size_bytes.div_ceil(1024)
-                    )),
-                    caption_font.clone(),
-                    TextColor(TEXT_SECONDARY),
-                ));
+            .with_children(|left| {
+                if let Some(handle) = preview {
+                    let (aw, ah) = entry.card_aspect;
+                    let width = PREVIEW_THUMB_HEIGHT_PX * aw.max(1) as f32 / ah.max(1) as f32;
+                    left.spawn((
+                        ImageNode::new(handle.clone()),
+                        Node {
+                            width: Val::Px(width),
+                            height: Val::Px(PREVIEW_THUMB_HEIGHT_PX),
+                            ..default()
+                        },
+                    ));
+                }
+                left.spawn(Node {
+                    flex_direction: FlexDirection::Column,
+                    row_gap: VAL_SPACE_2,
+                    ..default()
+                })
+                .with_children(|col| {
+                    col.spawn((
+                        Text::new(entry.name.clone()),
+                        body_font.clone(),
+                        TextColor(TEXT_PRIMARY),
+                    ));
+                    col.spawn((
+                        Text::new(format!(
+                            "by {} — {} KB",
+                            entry.author,
+                            entry.size_bytes.div_ceil(1024)
+                        )),
+                        caption_font.clone(),
+                        TextColor(TEXT_SECONDARY),
+                    ));
+                });
            });
            if installed {
                row.spawn((
@@ -661,4 +822,85 @@ mod tests {
        ));
        assert_eq!(screen_count(&mut app), 1);
    }
+
+    // -----------------------------------------------------------------------
+    // Phase H part 2: preview thumbnails
+    // -----------------------------------------------------------------------
+
+    fn catalog_entry(id: &str, preview: bool) -> ThemeCatalogEntry {
+        ThemeCatalogEntry {
+            id: id.into(),
+            name: id.into(),
+            author: "Test".into(),
+            version: "1.0.0".into(),
+            card_aspect: (2, 3),
+            size_bytes: 1024,
+            sha256: "00".into(),
+            download_url: format!("/api/themes/{id}/download"),
+            preview_url: preview.then(|| format!("/api/themes/{id}/preview")),
+        }
+    }
+
+    /// A row whose theme id is in the [`PreviewCache`] renders an
+    /// `ImageNode` thumbnail; a row without one stays text-only.
+    #[test]
+    fn loaded_row_shows_preview_thumbnail_only_when_cached() {
+        let mut app = headless_app();
+        let cached = catalog_entry("with-preview", true);
+        let uncached = catalog_entry("without-preview", false);
+
+        let mut cache = PreviewCache::default();
+        cache
+            .0
+            .insert(cached.id.clone(), Handle::<Image>::default());
+        let state = CatalogState::Loaded(vec![cached, uncached]);
+
+        {
+            let world = app.world_mut();
+            let mut commands = world.commands();
+            spawn_store_modal(&mut commands, &state, None, &cache, None);
+        }
+        app.update();
+
+        let thumbs = app
+            .world_mut()
+            .query::<&ImageNode>()
+            .iter(app.world())
+            .count();
+        assert_eq!(
+            thumbs, 1,
+            "exactly the cached entry must render a preview thumbnail"
+        );
+    }
+
+    /// The thumbnail width follows the theme's own card aspect so a
+    /// preview never renders stretched.
+    #[test]
+    fn preview_thumbnail_width_follows_card_aspect() {
+        let mut app = headless_app();
+        let mut entry = catalog_entry("wide", true);
+        entry.card_aspect = (1, 1); // square theme art
+        let mut cache = PreviewCache::default();
+        cache.0.insert(entry.id.clone(), Handle::<Image>::default());
+        let state = CatalogState::Loaded(vec![entry]);
+
+        {
+            let world = app.world_mut();
+            let mut commands = world.commands();
+            spawn_store_modal(&mut commands, &state, None, &cache, None);
+        }
+        app.update();
+
+        let node = app
+            .world_mut()
+            .query_filtered::<&Node, With<ImageNode>>()
+            .single(app.world())
+            .expect("thumbnail node must exist");
+        assert_eq!(node.height, Val::Px(PREVIEW_THUMB_HEIGHT_PX));
+        assert_eq!(
+            node.width,
+            Val::Px(PREVIEW_THUMB_HEIGHT_PX),
+            "a 1:1 aspect must yield a square thumbnail"
+        );
+    }
 }
@@ -109,13 +109,41 @@ impl Plugin for TimeAttackPlugin {
            .add_message::<NewGameRequestEvent>()
            .add_message::<StartTimeAttackRequestEvent>()
            .add_message::<InfoToastEvent>()
+            // ModeStart places it between the stats abandon-recorder and
+            // GameMutation; it shares the new-game request/toast streams
+            // with the other writers (#143).
            .add_systems(
                Update,
-                handle_start_time_attack_request.before(GameMutation),
+                handle_start_time_attack_request
+                    .in_set(crate::game_plugin::ModeStart)
+                    .in_set(crate::game_plugin::NewGameRequestWriters)
+                    .ambiguous_with(crate::game_plugin::NewGameRequestWriters)
+                    .in_set(crate::game_plugin::InfoToastWriters)
+                    .ambiguous_with(crate::game_plugin::InfoToastWriters),
+            )
+            // One post-mutation chain for the TimeAttackResource writers:
+            // clock tick, win auto-deal, then the debounced disk save.
+            // The start handler (ModeStart, pre-mutation) is ordered
+            // against all three transitively. auto_deal's new-game request
+            // is drained wholesale next frame, so it joins the writer club
+            // (#143). PausedResource is settled: PauseMutation < GameMutation.
+            .add_systems(
+                Update,
+                (
+                    advance_time_attack,
+                    auto_deal_on_time_attack_win
+                        .in_set(crate::game_plugin::NewGameRequestWriters)
+                        .ambiguous_with(crate::game_plugin::NewGameRequestWriters),
+                    auto_save_time_attack_session,
+                )
+                    .chain()
+                    .after(GameMutation)
+                    // The HUD clock (after AutoComplete) and the ended-toast
+                    // handler (AnimFx) read what this chain writes — settle
+                    // it before both (#143).
+                    .before(crate::auto_complete_plugin::AutoComplete)
+                    .before(crate::animation_plugin::AnimFx),
            )
-            .add_systems(Update, advance_time_attack)
-            .add_systems(Update, auto_deal_on_time_attack_win.after(GameMutation))
-            .add_systems(Update, auto_save_time_attack_session)
            .add_systems(Last, save_time_attack_session_on_exit);
    }
 }
@@ -100,7 +100,11 @@ impl Plugin for TouchSelectionPlugin {
                update_touch_selection_highlight,
            )
                .chain()
-                .after(GameMutation),
+                .after(GameMutation)
+                // Selection cleanup and highlight placement settle before
+                // the board painters repaint (and before resync's synthetic
+                // StateChanged / fan-frac's layout write land) (#143).
+                .before(crate::card_plugin::BoardVisuals),
        );
    }
 }
@@ -0,0 +1,281 @@
+//! "Liquid glass" material for floating UI surfaces.
+//!
+//! Produces the translucent, light-catching treatment used by the floating
+//! touch tab bar (`hud_plugin::tab_bar`): a semi-transparent fill with a
+//! vertical sheen, a specular rim highlight around the border, and a soft
+//! drop shadow underneath. The table shows through the fill *sharp* — Bevy's
+//! UI pipeline has no backdrop-blur concept, so this module approximates
+//! frosted glass with layered gradients instead of sampling what's behind
+//! the node. That keeps it a plain `bevy_ui` bundle: no custom shaders, no
+//! extra render passes, and identical behaviour on desktop, Android, and
+//! WebGL2.
+//!
+//! # Swapping the treatment
+//!
+//! Layout code depends only on [`glass_surface`] and [`GLASS_BORDER_PX`].
+//! A future real-refraction material (e.g. a `UiMaterial` sampling a blurred
+//! render target) can replace this module's internals without touching any
+//! caller — that boundary is the reason this file exists separately from
+//! `hud_plugin/tab_bar.rs`.
+//!
+//! # Departure from the Terminal design system
+//!
+//! `ui_theme` documents HUD chrome as opaque "status-line" panels. The glass
+//! bar is a deliberate, user-approved exception for the floating touch tab
+//! bar only; do not reuse this material for modals or the top HUD band
+//! without a matching design decision.
+
+use bevy::prelude::*;
+use bevy::ui::{
+    BackgroundGradient, BorderGradient, BoxShadow, ColorStop, LinearGradient, ShadowStyle,
+};
+
+use crate::ui_theme::{BG_ELEVATED, BORDER_SUBTLE, BORDER_SUBTLE_HC};
+
+/// Border width every glass surface must reserve in its `Node::border` so
+/// the rim gradient has a strip to paint into.
+pub const GLASS_BORDER_PX: f32 = 1.0;
+
+/// Marker on every node that received [`glass_surface`]. The settings
+/// plugin's `update_glass_surfaces` retargets these when the player
+/// toggles reduce-transparency or high-contrast, swapping the gradients
+/// in place via [`glass_decorations`].
+#[derive(Component, Debug)]
+pub struct GlassSurface;
+
+/// Base fill at the *bottom* of the glass sheet — near-black at ~62%
+/// opacity so the felt and cards remain visible through the bar while
+/// keeping icon/label contrast comfortable.
+const GLASS_FILL_BOTTOM: Color = Color::srgba(0.055, 0.055, 0.063, 0.62);
+
+/// Fill at the *top* of the sheet — the same glass lifted towards white,
+/// reading as the curved surface catching overhead light.
+const GLASS_FILL_TOP: Color = Color::srgba(0.20, 0.21, 0.23, 0.66);
+
+/// Rim highlight at the top edge — the bright specular line where a real
+/// glass pill would catch the light source.
+const GLASS_RIM_TOP: Color = Color::srgba(1.0, 1.0, 1.0, 0.38);
+
+/// Rim at the midpoint — almost gone, so the highlight reads as a glint
+/// rather than a drawn outline.
+const GLASS_RIM_MID: Color = Color::srgba(1.0, 1.0, 1.0, 0.06);
+
+/// Rim at the bottom edge — a faint secondary catch-light, as on the
+/// underside of a curved surface above a bright table.
+const GLASS_RIM_BOTTOM: Color = Color::srgba(1.0, 1.0, 1.0, 0.16);
+
+/// Drop shadow under the floating surface.
+const GLASS_SHADOW: Color = Color::srgba(0.0, 0.0, 0.0, 0.35);
+
+/// High-contrast fill — same glass, far less see-through, so text and
+/// icons keep contrast over any card art. Per `design-system.md`
+/// §Accessibility the HC toggle trades aesthetics for legibility.
+const GLASS_FILL_TOP_HC: Color = Color::srgba(0.20, 0.21, 0.23, 0.90);
+/// High-contrast fill at the bottom of the sheet.
+const GLASS_FILL_BOTTOM_HC: Color = Color::srgba(0.055, 0.055, 0.063, 0.88);
+
+/// High-contrast rim at the top edge — matches the luminance of
+/// `BORDER_SUBTLE_HC` so the bar's outline reads as strongly as every
+/// other HC-boosted border.
+const GLASS_RIM_TOP_HC: Color = Color::srgba(1.0, 1.0, 1.0, 0.75);
+/// High-contrast rim at the midpoint.
+const GLASS_RIM_MID_HC: Color = Color::srgba(1.0, 1.0, 1.0, 0.35);
+/// High-contrast rim at the bottom edge.
+const GLASS_RIM_BOTTOM_HC: Color = Color::srgba(1.0, 1.0, 1.0, 0.50);
+
+/// Visual components for a floating glass surface.
+///
+/// The caller owns the `Node` and must set two fields for the material to
+/// render correctly:
+/// - `border: UiRect::all(Val::Px(GLASS_BORDER_PX))` — the rim gradient
+///   paints into the border strip and is invisible without it.
+/// - `border_radius` — half the node height for a fully-round pill.
+///
+/// Everything here is fragment-shader work inside Bevy's stock UI pipeline,
+/// so it is safe on WebGL2 and adds no per-frame cost beyond ordinary nodes.
+pub fn glass_surface() -> impl Bundle {
+    let (sheen, rim) = glass_decorations(false, false);
+    (
+        GlassSurface,
+        sheen,
+        rim,
+        // Soft shadow underneath sells the "floating above the table" read.
+        BoxShadow(vec![ShadowStyle {
+            color: GLASS_SHADOW,
+            x_offset: Val::Px(0.0),
+            y_offset: Val::Px(6.0),
+            spread_radius: Val::Px(0.0),
+            blur_radius: Val::Px(16.0),
+        }]),
+    )
+}
+
+/// The sheen + rim pair for the requested accessibility state. The
+/// settings plugin overwrites every [`GlassSurface`]'s components with
+/// these when the relevant toggles change.
+///
+/// - Default: translucent fill with a top-lit sheen and a specular rim.
+/// - `high_contrast`: same shape, near-opaque fill, and a rim boosted to
+///   `BORDER_SUBTLE_HC` luminance so the outline stays legible.
+/// - `reduce_transparency`: flat opaque `BG_ELEVATED` fill and a flat
+///   border — no see-through at all. Combined with `high_contrast` the
+///   flat border brightens to `BORDER_SUBTLE_HC`.
+pub fn glass_decorations(
+    reduce_transparency: bool,
+    high_contrast: bool,
+) -> (BackgroundGradient, BorderGradient) {
+    if reduce_transparency {
+        // "Gradients" with a single stop render as flat fills — reusing the
+        // same component types means the settings toggle swaps values, not
+        // component sets.
+        let border = if high_contrast {
+            BORDER_SUBTLE_HC
+        } else {
+            BORDER_SUBTLE
+        };
+        return (
+            BackgroundGradient(vec![
+                LinearGradient::new(
+                    LinearGradient::TO_BOTTOM,
+                    vec![ColorStop::new(BG_ELEVATED, Val::Percent(0.0))],
+                )
+                .into(),
+            ]),
+            BorderGradient(vec![
+                LinearGradient::new(
+                    LinearGradient::TO_BOTTOM,
+                    vec![ColorStop::new(border, Val::Percent(0.0))],
+                )
+                .into(),
+            ]),
+        );
+    }
+
+    let (fill_top, fill_bottom, rim_top, rim_mid, rim_bottom) = if high_contrast {
+        (
+            GLASS_FILL_TOP_HC,
+            GLASS_FILL_BOTTOM_HC,
+            GLASS_RIM_TOP_HC,
+            GLASS_RIM_MID_HC,
+            GLASS_RIM_BOTTOM_HC,
+        )
+    } else {
+        (
+            GLASS_FILL_TOP,
+            GLASS_FILL_BOTTOM,
+            GLASS_RIM_TOP,
+            GLASS_RIM_MID,
+            GLASS_RIM_BOTTOM,
+        )
+    };
+    (
+        // Sheen: one top-to-bottom linear gradient carries both the fill and
+        // the lighting so there is a single source of truth for the surface
+        // colour (a separate `BackgroundColor` would just be painted over).
+        BackgroundGradient(vec![
+            LinearGradient::new(
+                LinearGradient::TO_BOTTOM,
+                vec![
+                    ColorStop::new(fill_top, Val::Percent(0.0)),
+                    ColorStop::new(fill_bottom, Val::Percent(60.0)),
+                ],
+            )
+            .into(),
+        ]),
+        // Specular rim: bright at the top edge, fading out through the
+        // sides, with a faint return at the bottom.
+        BorderGradient(vec![
+            LinearGradient::new(
+                LinearGradient::TO_BOTTOM,
+                vec![
+                    ColorStop::new(rim_top, Val::Percent(0.0)),
+                    ColorStop::new(rim_mid, Val::Percent(55.0)),
+                    ColorStop::new(rim_bottom, Val::Percent(100.0)),
+                ],
+            )
+            .into(),
+        ]),
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bevy::ui::Gradient;
+
+    /// The bundle must insert all three visual components — a regression
+    /// here (e.g. a refactor dropping the rim) would silently flatten the
+    /// glass into a plain translucent box.
+    #[test]
+    fn glass_surface_inserts_sheen_rim_and_shadow() {
+        let mut world = World::new();
+        let e = world.spawn(glass_surface()).id();
+        assert!(world.get::<BackgroundGradient>(e).is_some());
+        assert!(world.get::<BorderGradient>(e).is_some());
+        assert!(world.get::<BoxShadow>(e).is_some());
+    }
+
+    /// The fill must stay translucent (that is the whole point of glass) but
+    /// opaque enough that text keeps contrast over busy card art.
+    #[test]
+    fn glass_fill_alpha_stays_in_readable_band() {
+        for fill in [GLASS_FILL_TOP, GLASS_FILL_BOTTOM] {
+            let a = fill.alpha();
+            assert!(
+                (0.4..=0.85).contains(&a),
+                "glass fill alpha {a} outside readable 0.4–0.85 band"
+            );
+        }
+    }
+
+    /// The rim gradient must actually glint: strictly brightest at the top,
+    /// dimmest in the middle.
+    #[test]
+    fn rim_highlight_peaks_at_top() {
+        assert!(GLASS_RIM_TOP.alpha() > GLASS_RIM_BOTTOM.alpha());
+        assert!(GLASS_RIM_BOTTOM.alpha() > GLASS_RIM_MID.alpha());
+        assert!(GLASS_RIM_TOP_HC.alpha() > GLASS_RIM_BOTTOM_HC.alpha());
+        assert!(GLASS_RIM_BOTTOM_HC.alpha() > GLASS_RIM_MID_HC.alpha());
+    }
+
+    /// Reduce-transparency must produce fully opaque fills — the entire
+    /// point of the toggle is that nothing shows through.
+    #[test]
+    fn reduce_transparency_is_fully_opaque() {
+        for high_contrast in [false, true] {
+            let (sheen, _) = glass_decorations(true, high_contrast);
+            for gradient in &sheen.0 {
+                let Gradient::Linear(linear) = gradient else {
+                    panic!("reduce-transparency sheen must stay linear");
+                };
+                for stop in &linear.stops {
+                    assert_eq!(
+                        stop.color.alpha(),
+                        1.0,
+                        "opaque variant leaked translucency (hc={high_contrast})"
+                    );
+                }
+            }
+        }
+    }
+
+    /// High-contrast glass must be meaningfully less transparent than the
+    /// default, and its rim meaningfully brighter — otherwise the toggle
+    /// does nothing perceptible on this surface.
+    #[test]
+    fn high_contrast_boosts_fill_and_rim() {
+        assert!(GLASS_FILL_TOP_HC.alpha() >= GLASS_FILL_TOP.alpha() + 0.15);
+        assert!(GLASS_FILL_BOTTOM_HC.alpha() >= GLASS_FILL_BOTTOM.alpha() + 0.15);
+        assert!(GLASS_RIM_TOP_HC.alpha() >= GLASS_RIM_TOP.alpha() + 0.25);
+    }
+
+    /// `glass_surface()` must carry the marker the settings applier
+    /// retargets — without it the accessibility toggles silently skip
+    /// the bar.
+    #[test]
+    fn glass_surface_carries_retarget_marker() {
+        let mut world = World::new();
+        let e = world.spawn(glass_surface()).id();
+        assert!(world.get::<GlassSurface>(e).is_some());
+    }
+}
@@ -60,9 +60,9 @@ use crate::settings_plugin::SettingsResource;
 use crate::ui_theme::{
    ACCENT_PRIMARY, ACCENT_PRIMARY_HOVER, ACCENT_SECONDARY, BG_BASE, BG_ELEVATED, BG_ELEVATED_HI,
    BG_ELEVATED_PRESSED, BG_ELEVATED_TOP, BORDER_STRONG, BORDER_SUBTLE, HighContrastBorder,
-    MOTION_MODAL_SECS, RADIUS_LG, RADIUS_MD, RADIUS_SM, SCRIM, STATE_SUCCESS, TEXT_PRIMARY,
-    TEXT_SECONDARY, TYPE_BODY_LG, TYPE_CAPTION, TYPE_HEADLINE, VAL_SPACE_2, VAL_SPACE_3,
-    VAL_SPACE_4, VAL_SPACE_5, scaled_duration,
+    MOTION_MODAL_SECS, RADIUS_LG, RADIUS_MD, RADIUS_SM, SCRIM, STATE_SUCCESS, TEXT_DISABLED,
+    TEXT_PRIMARY, TEXT_SECONDARY, TYPE_BODY, TYPE_BODY_LG, TYPE_CAPTION, TYPE_DISPLAY,
+    TYPE_HEADLINE, VAL_SPACE_2, VAL_SPACE_3, VAL_SPACE_4, VAL_SPACE_5, scaled_duration,
 };

 // ---------------------------------------------------------------------------
@@ -178,6 +178,32 @@ pub fn spawn_modal<M: Component, F>(
    z_panel: i32,
    build_card: F,
 ) -> Entity
+where
+    F: FnOnce(&mut ChildSpawnerCommands),
+{
+    spawn_modal_sized(
+        commands,
+        plugin_marker,
+        z_panel,
+        MODAL_CARD_MAX_WIDTH,
+        build_card,
+    )
+}
+
+/// Default maximum card width in logical pixels — every [`spawn_modal`]
+/// caller gets this. Surfaces that lay out side-by-side panes (e.g. the
+/// two-pane Home on wide viewports) can raise it via [`spawn_modal_sized`].
+pub const MODAL_CARD_MAX_WIDTH: f32 = 720.0;
+
+/// [`spawn_modal`] with an explicit card `max_width`. Behaviour is
+/// otherwise identical — same scrim, enter animation, and card chrome.
+pub fn spawn_modal_sized<M: Component, F>(
+    commands: &mut Commands,
+    plugin_marker: M,
+    z_panel: i32,
+    max_width: f32,
+    build_card: F,
+) -> Entity
 where
    F: FnOnce(&mut ChildSpawnerCommands),
 {
@@ -235,7 +261,7 @@ where
                    padding: UiRect::all(VAL_SPACE_5),
                    border: UiRect::all(Val::Px(1.0)),
                    border_radius: BorderRadius::all(Val::Px(RADIUS_LG)),
-                    max_width: Val::Px(720.0),
+                    max_width: Val::Px(max_width),
                    align_items: AlignItems::Stretch,
                    ..default()
                },
@@ -302,6 +328,80 @@ pub fn spawn_modal_body_text(
    parent.spawn((ModalBody, Text::new(text.into()), font, TextColor(color)));
 }

+/// Standard empty / loading / error surface (Phase L): a large glyph,
+/// a headline, and an optional secondary detail line, centred in the
+/// available space. Every async or possibly-empty surface (leaderboard,
+/// replays, theme store, first-launch stats) renders through this so
+/// "nothing here yet" reads identically everywhere.
+///
+/// A next-step action is composition, not configuration: spawn a
+/// [`spawn_modal_button`] (or any control) in the same parent right
+/// after this call.
+///
+/// `glyph` MUST come from FiraMono-covered ranges — card suits
+/// (U+2660–2666), Arrows (U+2190–21FF), or ASCII. The Geometric Shapes
+/// block renders as tofu on Android (§10 / §11).
+pub fn spawn_empty_state(
+    parent: &mut ChildSpawnerCommands,
+    glyph: &str,
+    headline: &str,
+    detail: Option<&str>,
+    font_res: Option<&FontResource>,
+) {
+    let font_handle = font_res.map(|f| f.0.clone()).unwrap_or_default();
+    let font_glyph = TextFont {
+        font: font_handle.clone(),
+        font_size: TYPE_DISPLAY,
+        ..default()
+    };
+    let font_headline = TextFont {
+        font: font_handle.clone(),
+        font_size: TYPE_BODY_LG,
+        ..default()
+    };
+    let font_detail = TextFont {
+        font: font_handle,
+        font_size: TYPE_BODY,
+        ..default()
+    };
+
+    parent
+        .spawn((
+            EmptyStateBlock,
+            Node {
+                flex_direction: FlexDirection::Column,
+                align_items: AlignItems::Center,
+                row_gap: VAL_SPACE_2,
+                padding: UiRect::axes(VAL_SPACE_3, VAL_SPACE_5),
+                width: Val::Percent(100.0),
+                ..default()
+            },
+        ))
+        .with_children(|block| {
+            block.spawn((
+                Text::new(glyph.to_string()),
+                font_glyph,
+                TextColor(TEXT_DISABLED),
+            ));
+            block.spawn((
+                Text::new(headline.to_string()),
+                font_headline,
+                TextColor(TEXT_PRIMARY),
+            ));
+            if let Some(detail) = detail {
+                block.spawn((
+                    Text::new(detail.to_string()),
+                    font_detail,
+                    TextColor(TEXT_SECONDARY),
+                ));
+            }
+        });
+}
+
+/// Marker on every [`spawn_empty_state`] block, mostly for tests.
+#[derive(Component, Debug)]
+pub struct EmptyStateBlock;
+
 /// Spawns the bottom actions row — flex-row with primary right-aligned.
 /// The closure populates the row's buttons via `spawn_modal_button`.
 ///
@@ -446,6 +546,15 @@ pub fn spawn_tab_chip<M: Component>(
 // Generic touch-scroll helper
 // ---------------------------------------------------------------------------

+/// Self-ambiguous writer set for the per-modal scroll systems (mouse-wheel
+/// and touch variants). Every member writes `ScrollPosition`, but each
+/// targets only its own modal's scrollable body via a marker component, and
+/// the modal-stacking guard means at most one such panel exists at a time —
+/// the writes are disjoint by design, so members declare
+/// `.in_set(PanelScroll).ambiguous_with(PanelScroll)` (#143).
+#[derive(bevy::ecs::schedule::SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct PanelScroll;
+
 /// Scrolls any `Overflow::scroll_y()` panel marked with `M` via single-finger
 /// touch pan. Add this as a system for each scrollable modal panel:
 ///
@@ -740,7 +849,11 @@ impl Plugin for UiModalPlugin {
                .in_set(crate::ui_theme::UiTextFx)
                .ambiguous_with(crate::ui_theme::UiTextFx)
                .ambiguous_with(crate::card_plugin::BoardVisuals)
-                .ambiguous_with(crate::hud_plugin::HudButtons),
+                .ambiguous_with(crate::hud_plugin::HudButtons)
+                // Reads only the anim-speed settings field — disjoint from
+                // the screen-plugin club's writes (#143).
+                .in_set(crate::settings_plugin::SettingsAccess)
+                .ambiguous_with(crate::settings_plugin::SettingsAccess),
        );
        // Click-outside-to-dismiss is independent of the open
        // animation chain — it reads `just_pressed(Left)` and runs
@@ -1158,4 +1271,62 @@ mod tests {
            "exactly one of the two stacked dismissible modals should remain"
        );
    }
+
+    // -----------------------------------------------------------------------
+    // Phase L: standard empty state
+    // -----------------------------------------------------------------------
+
+    /// The helper spawns glyph + headline (+ detail when given) under one
+    /// marked block, so every empty surface renders identically.
+    #[test]
+    fn empty_state_spawns_expected_structure() {
+        let mut app = App::new();
+        app.add_plugins(MinimalPlugins);
+        {
+            let world = app.world_mut();
+            let mut commands = world.commands();
+            commands.spawn(Node::default()).with_children(|parent| {
+                spawn_empty_state(
+                    parent,
+                    "\u{2660}",
+                    "Nothing here.",
+                    Some("Do the thing."),
+                    None,
+                );
+                spawn_empty_state(parent, "!", "No detail variant.", None, None);
+            });
+        }
+        app.update();
+
+        let blocks = app
+            .world_mut()
+            .query_filtered::<Entity, With<EmptyStateBlock>>()
+            .iter(app.world())
+            .count();
+        assert_eq!(blocks, 2, "each call spawns exactly one marked block");
+
+        let texts: Vec<String> = app
+            .world_mut()
+            .query::<&Text>()
+            .iter(app.world())
+            .map(|t| t.0.clone())
+            .collect();
+        for expected in [
+            "\u{2660}",
+            "Nothing here.",
+            "Do the thing.",
+            "!",
+            "No detail variant.",
+        ] {
+            assert!(
+                texts.iter().any(|t| t == expected),
+                "missing text node {expected:?}; got {texts:?}"
+            );
+        }
+        assert_eq!(
+            texts.len(),
+            5,
+            "the detail-less variant must not spawn a detail node"
+        );
+    }
 }
@@ -93,7 +93,23 @@ impl Plugin for UiTooltipPlugin {
    fn build(&self, app: &mut App) {
        app.init_resource::<TooltipState>()
            .add_systems(Startup, spawn_tooltip_overlay)
-            .add_systems(Update, (track_tooltip_hover, show_or_hide_tooltip).chain());
+            // The tooltip pair only touches the tooltip overlay entity and
+            // reads settings for the enable flag — chrome-disjoint from the
+            // other UiTextFx members, and a settings read that may lag a
+            // frame joins the SettingsAccess club (#143).
+            .add_systems(
+                Update,
+                (track_tooltip_hover, show_or_hide_tooltip)
+                    .chain()
+                    .in_set(crate::ui_theme::UiTextFx)
+                    .ambiguous_with(crate::ui_theme::UiTextFx)
+                    .in_set(crate::settings_plugin::SettingsAccess)
+                    .ambiguous_with(crate::settings_plugin::SettingsAccess)
+                    // The tooltip node is neither a board entity nor a pile
+                    // marker; the visibility writes can't collide (#143).
+                    .ambiguous_with(crate::card_plugin::BoardVisuals)
+                    .ambiguous_with(crate::table_plugin::MarkerVisuals),
+            );
    }
 }

@@ -10,8 +10,8 @@ use solitaire_data::{
 };

 use crate::events::{GameWonEvent, XpAwardedEvent};
-use crate::game_plugin::GameMutation;
-use crate::progress_plugin::{LevelUpEvent, ProgressResource, ProgressStoragePath, ProgressUpdate};
+
+use crate::progress_plugin::{LevelUpEvent, ProgressResource, ProgressStoragePath};
 use crate::resources::GameStateResource;

 /// Fired when the player has just completed a weekly goal.
@@ -33,11 +33,11 @@ impl Plugin for WeeklyGoalsPlugin {
            .add_systems(Startup, roll_weekly_goals_on_startup)
            // Run after GameMutation (so GameWonEvent is available) and
            // ProgressUpdate (so we don't fight ProgressPlugin's add_xp).
+            // Ordering comes from the mode-completion chain configured in
+            // progress_plugin (#143).
            .add_systems(
                Update,
-                evaluate_weekly_goals
-                    .after(GameMutation)
-                    .after(ProgressUpdate),
+                evaluate_weekly_goals.in_set(crate::progress_plugin::WeeklyGoalsEval),
            );
    }
 }
@@ -0,0 +1,527 @@
+//! One-shot "What's new" card on the first launch after an update
+//! (Phase I of the 2026-07 UI redesign).
+//!
+//! ObtainX updates install silently, so shipped features go unnoticed —
+//! nobody found the theme store on their own. On the first launch where
+//! the running release differs from `Settings::last_seen_whats_new`,
+//! this plugin shows a single dismissible card summarising the latest
+//! changelog section, then records the version so the card never
+//! repeats. Fresh installs never see it: onboarding completion stamps
+//! the current version silently, so the card only ever describes an
+//! *upgrade*.
+//!
+//! # Launch beat
+//!
+//! Splash → (first run only: onboarding) → **what's new** → Home →
+//! table. `spawn_home_on_launch` waits on [`WhatsNewPending`] the same
+//! way it waits for the onboarding modal.
+//!
+//! # Version source
+//!
+//! The embedded `CHANGELOG.md`'s topmost release section provides both
+//! the card's content and the "current version" for change detection —
+//! one source of truth, no build-time version plumbing. (The APK
+//! `versionName` comes from the release tag at package time and never
+//! reaches Rust; the workspace `Cargo.toml` version is static.)
+
+use bevy::input::ButtonInput;
+use bevy::prelude::*;
+use solitaire_data::save_settings_to;
+
+use crate::font_plugin::FontResource;
+use crate::onboarding_plugin::OnboardingScreen;
+use crate::settings_plugin::{SettingsResource, SettingsStoragePath};
+use crate::ui_modal::{
+    ButtonVariant, ModalScrim, spawn_modal, spawn_modal_actions, spawn_modal_button,
+    spawn_modal_header,
+};
+use crate::ui_theme::{
+    TEXT_PRIMARY, TEXT_SECONDARY, TYPE_BODY, TYPE_CAPTION, VAL_SPACE_1, VAL_SPACE_2, Z_MODAL_PANEL,
+};
+
+/// The changelog ships inside the binary — small, changes only at
+/// release cadence, and the card must work offline (§4.2).
+const CHANGELOG: &str = include_str!("../../CHANGELOG.md");
+
+/// Most bullets shown on the card; a giant release stays skimmable.
+const MAX_CARD_BULLETS: usize = 8;
+
+/// Marker on the What's-new modal's scrim root.
+#[derive(Component, Debug)]
+pub struct WhatsNewScreen;
+
+/// Marker on the card's "Got it" button.
+#[derive(Component, Debug)]
+struct WhatsNewCloseButton;
+
+/// `true` until this plugin has made its launch-beat decision — either
+/// the card was shown and dismissed, or there was nothing to show.
+/// `spawn_home_on_launch` waits on this so the card gets the beat
+/// before Home.
+#[derive(Resource, Debug)]
+pub struct WhatsNewPending(pub bool);
+
+impl Default for WhatsNewPending {
+    fn default() -> Self {
+        Self(true)
+    }
+}
+
+/// One display line of the card.
+#[derive(Debug, PartialEq, Eq)]
+enum NoteLine {
+    /// A `###` section heading ("Added", "Fixed", …).
+    Heading(String),
+    /// The lead sentence of one changelog bullet.
+    Bullet(String),
+}
+
+/// The changelog's topmost release section, reduced to card content.
+#[derive(Debug)]
+struct ReleaseNotes {
+    /// Version string without the `v` prefix, e.g. `"0.46.0"`.
+    version: String,
+    lines: Vec<NoteLine>,
+}
+
+/// The version of the topmost changelog release — the engine's notion
+/// of "the running release". Empty only if the changelog is malformed.
+pub fn current_release_version() -> String {
+    parse_latest_release(CHANGELOG).map_or_else(String::new, |notes| notes.version)
+}
+
+/// Parses the first `## [x.y.z]` section of `changelog` into card
+/// content. `## [Unreleased]` is skipped; `### Internal` subsections
+/// are dropped (players don't care about CI); each bullet is reduced
+/// to its lead sentence with markdown emphasis stripped.
+fn parse_latest_release(changelog: &str) -> Option<ReleaseNotes> {
+    let mut lines_iter = changelog.lines();
+    let mut version = None;
+    for line in lines_iter.by_ref() {
+        if let Some(rest) = line.strip_prefix("## [") {
+            let (v, _) = rest.split_once(']')?;
+            if v.eq_ignore_ascii_case("Unreleased") {
+                continue;
+            }
+            version = Some(v.to_string());
+            break;
+        }
+    }
+    let version = version?;
+
+    let mut lines = Vec::new();
+    let mut skipping_section = false;
+    let mut current_bullet: Option<String> = None;
+
+    let flush = |bullet: &mut Option<String>, lines: &mut Vec<NoteLine>| {
+        if let Some(text) = bullet.take() {
+            lines.push(NoteLine::Bullet(lead_sentence(&text)));
+        }
+    };
+
+    for line in lines_iter {
+        if line.starts_with("## [") {
+            break; // next (older) release section
+        }
+        if let Some(heading) = line.strip_prefix("### ") {
+            flush(&mut current_bullet, &mut lines);
+            skipping_section = heading.trim().eq_ignore_ascii_case("internal");
+            if !skipping_section {
+                lines.push(NoteLine::Heading(heading.trim().to_string()));
+            }
+            continue;
+        }
+        if skipping_section {
+            continue;
+        }
+        if let Some(rest) = line.strip_prefix("- ") {
+            flush(&mut current_bullet, &mut lines);
+            current_bullet = Some(rest.trim().to_string());
+        } else if current_bullet.is_some() && !line.trim().is_empty() {
+            // Wrapped continuation of the current bullet.
+            if let Some(bullet) = current_bullet.as_mut() {
+                bullet.push(' ');
+                bullet.push_str(line.trim());
+            }
+        }
+    }
+    flush(&mut current_bullet, &mut lines);
+
+    Some(ReleaseNotes { version, lines })
+}
+
+/// Strips markdown emphasis / code ticks and truncates to the first
+/// sentence — changelog bullets lead with a bold summary sentence, and
+/// that is exactly the card-sized version.
+fn lead_sentence(bullet: &str) -> String {
+    let stripped: String = bullet.replace("**", "").replace('`', "");
+    // Trailing "(#123)" references never survive the sentence cut, but
+    // guard against a bullet that is only a reference.
+    let end = stripped.find(". ").map_or(stripped.len(), |i| i + 1);
+    stripped[..end].trim().trim_end_matches('.').to_string()
+}
+
+/// Registers the launch-gate spawn system and the dismiss handlers.
+pub struct WhatsNewPlugin;
+
+impl Plugin for WhatsNewPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<WhatsNewPending>()
+            .init_resource::<ButtonInput<KeyCode>>()
+            .add_systems(
+                Update,
+                (maybe_spawn_whats_new, handle_whats_new_close).chain(),
+            );
+    }
+}
+
+/// Shows the card once the launch surface is clear, or stands down when
+/// there is nothing to show. See the module docs for the exact beat.
+///
+/// The seen-version stamp persists on *spawn*, not dismissal — if the
+/// app dies with the card open the player has still seen it once, and
+/// the card must never nag.
+#[allow(clippy::too_many_arguments)]
+fn maybe_spawn_whats_new(
+    mut commands: Commands,
+    mut pending: ResMut<WhatsNewPending>,
+    splash: Query<(), With<crate::splash_plugin::SplashRoot>>,
+    onboarding: Query<(), With<OnboardingScreen>>,
+    restore_prompts: Query<(), With<crate::game_plugin::RestorePromptScreen>>,
+    pending_restore: Option<Res<crate::game_plugin::PendingRestoredGame>>,
+    other_scrims: Query<(), With<ModalScrim>>,
+    mut settings: Option<ResMut<SettingsResource>>,
+    storage_path: Option<Res<SettingsStoragePath>>,
+    font_res: Option<Res<FontResource>>,
+    screens: Query<(), With<WhatsNewScreen>>,
+) {
+    if !pending.0 {
+        return;
+    }
+    if !screens.is_empty() {
+        // Card already open — the seen-version stamp landed on spawn,
+        // so without this guard the next frame would read "already
+        // seen" and release the beat under the open card.
+        return;
+    }
+    if !splash.is_empty()
+        || !onboarding.is_empty()
+        || !restore_prompts.is_empty()
+        || pending_restore.as_ref().is_some_and(|p| p.0.is_some())
+    {
+        return;
+    }
+    let Some(settings) = settings.as_mut() else {
+        // Headless / no settings wired: nothing to compare against.
+        pending.0 = false;
+        return;
+    };
+    if !settings.0.first_run_complete {
+        // Fresh install mid-onboarding — completion stamps the version
+        // itself (see `complete_onboarding`), which resolves this gate
+        // on a later frame without ever showing the card.
+        return;
+    }
+    let Some(notes) = parse_latest_release(CHANGELOG) else {
+        pending.0 = false;
+        return;
+    };
+    if settings.0.last_seen_whats_new == notes.version {
+        pending.0 = false;
+        return;
+    }
+    if !other_scrims.is_empty() {
+        // Another modal owns the beat right now; try again next frame.
+        return;
+    }
+
+    spawn_whats_new_card(&mut commands, &notes, font_res.as_deref());
+
+    settings.0.last_seen_whats_new = notes.version.clone();
+    if let Some(p) = storage_path
+        && let Some(path) = p.0.as_deref()
+        && let Err(e) = save_settings_to(path, &settings.0)
+    {
+        warn!("whats-new: failed to persist seen version: {e}");
+    }
+    // `pending` stays true until dismissal so Home keeps waiting.
+}
+
+/// Dismisses the card on "Got it" or Esc and releases the launch beat.
+fn handle_whats_new_close(
+    mut commands: Commands,
+    keys: Option<Res<ButtonInput<KeyCode>>>,
+    buttons: Query<&Interaction, (With<WhatsNewCloseButton>, Changed<Interaction>)>,
+    screens: Query<Entity, With<WhatsNewScreen>>,
+    other_scrims: Query<(), (With<ModalScrim>, Without<WhatsNewScreen>)>,
+    mut pending: ResMut<WhatsNewPending>,
+) {
+    if screens.is_empty() {
+        return;
+    }
+    let click = buttons.iter().any(|i| *i == Interaction::Pressed);
+    let esc = keys.is_some_and(|k| k.just_pressed(KeyCode::Escape)) && other_scrims.is_empty();
+    if !click && !esc {
+        return;
+    }
+    for entity in &screens {
+        commands.entity(entity).despawn();
+    }
+    pending.0 = false;
+}
+
+/// Spawns the card: header with the version, the parsed changelog
+/// lines, and a "Got it" action.
+fn spawn_whats_new_card(
+    commands: &mut Commands,
+    notes: &ReleaseNotes,
+    font_res: Option<&FontResource>,
+) {
+    let font_handle = font_res.map(|f| f.0.clone()).unwrap_or_default();
+    let font_heading = TextFont {
+        font: font_handle.clone(),
+        font_size: TYPE_CAPTION,
+        ..default()
+    };
+    let font_bullet = TextFont {
+        font: font_handle,
+        font_size: TYPE_BODY,
+        ..default()
+    };
+
+    // Deliberately NOT ScrimDismissible: scrim-tap despawns without
+    // running the close handler, which would leave the launch beat
+    // held and Home never spawning. Esc and "Got it" both release it.
+    let title = format!("What's new in v{}", notes.version);
+    spawn_modal(commands, WhatsNewScreen, Z_MODAL_PANEL, |card| {
+        spawn_modal_header(card, &title, font_res);
+
+        card.spawn(Node {
+            flex_direction: FlexDirection::Column,
+            row_gap: VAL_SPACE_2,
+            width: Val::Percent(100.0),
+            max_height: Val::Vh(60.0),
+            overflow: Overflow::scroll_y(),
+            ..default()
+        })
+        .with_children(|body| {
+            let mut bullets_shown = 0usize;
+            for line in &notes.lines {
+                match line {
+                    NoteLine::Heading(heading) => {
+                        body.spawn((
+                            Text::new(heading.clone()),
+                            font_heading.clone(),
+                            TextColor(TEXT_SECONDARY),
+                            Node {
+                                margin: UiRect::top(VAL_SPACE_1),
+                                ..default()
+                            },
+                        ));
+                    }
+                    NoteLine::Bullet(text) => {
+                        if bullets_shown >= MAX_CARD_BULLETS {
+                            continue;
+                        }
+                        bullets_shown += 1;
+                        body.spawn((
+                            Text::new(format!("\u{2022} {text}")),
+                            font_bullet.clone(),
+                            TextColor(TEXT_PRIMARY),
+                        ));
+                    }
+                }
+            }
+        });
+
+        spawn_modal_actions(card, |actions| {
+            spawn_modal_button(
+                actions,
+                WhatsNewCloseButton,
+                "Got it",
+                None,
+                ButtonVariant::Primary,
+                font_res,
+            );
+        });
+    });
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use solitaire_data::Settings;
+
+    const SAMPLE: &str = "# Changelog\n\n## [Unreleased]\n\n## [0.46.0] — 2026-07-13\n\n\
+### Added\n\n- **Theme-store previews.** The store modal now shows each theme's\n  \
+preview image next to its name. (#179)\n- **Hint ghost preview.** You see the move. (#179)\n\n\
+### Internal\n\n- **CI is faster.** Nobody cares in-game. (#176)\n\n\
+### Fixed\n\n- **Touch onboarding copy.** No more left-click. (#178)\n\n\
+## [0.45.0] — 2026-07-13\n\n### Added\n\n- Old stuff.\n";
+
+    #[test]
+    fn parses_top_section_version_and_skips_unreleased() {
+        let notes = parse_latest_release(SAMPLE).expect("sample must parse");
+        assert_eq!(notes.version, "0.46.0");
+    }
+
+    #[test]
+    fn drops_internal_sections_and_older_releases() {
+        let notes = parse_latest_release(SAMPLE).expect("sample must parse");
+        let headings: Vec<&str> = notes
+            .lines
+            .iter()
+            .filter_map(|l| match l {
+                NoteLine::Heading(h) => Some(h.as_str()),
+                _ => None,
+            })
+            .collect();
+        assert_eq!(headings, vec!["Added", "Fixed"]);
+        assert!(
+            !notes
+                .lines
+                .iter()
+                .any(|l| matches!(l, NoteLine::Bullet(b) if b.contains("CI is faster"))),
+            "Internal bullets must not reach the card"
+        );
+        assert!(
+            !notes
+                .lines
+                .iter()
+                .any(|l| matches!(l, NoteLine::Bullet(b) if b.contains("Old stuff"))),
+            "older release sections must not bleed in"
+        );
+    }
+
+    #[test]
+    fn bullets_reduce_to_their_lead_sentence() {
+        let notes = parse_latest_release(SAMPLE).expect("sample must parse");
+        assert!(
+            notes
+                .lines
+                .contains(&NoteLine::Bullet("Theme-store previews".to_string()))
+        );
+        assert!(
+            notes
+                .lines
+                .contains(&NoteLine::Bullet("Hint ghost preview".to_string()))
+        );
+    }
+
+    #[test]
+    fn embedded_changelog_parses_to_a_nonempty_version() {
+        let version = current_release_version();
+        assert!(
+            !version.is_empty(),
+            "the real CHANGELOG.md must yield a version"
+        );
+        assert!(
+            version.chars().next().is_some_and(|c| c.is_ascii_digit()),
+            "version must be bare (no v prefix): {version}"
+        );
+    }
+
+    fn app_with(settings: Settings) -> App {
+        let mut app = App::new();
+        app.add_plugins(MinimalPlugins).add_plugins(WhatsNewPlugin);
+        app.insert_resource(SettingsResource(settings));
+        app.update();
+        app
+    }
+
+    fn card_count(app: &mut App) -> usize {
+        app.world_mut()
+            .query::<&WhatsNewScreen>()
+            .iter(app.world())
+            .count()
+    }
+
+    #[test]
+    fn upgrade_shows_card_and_stamps_version() {
+        let mut app = app_with(Settings {
+            first_run_complete: true,
+            last_seen_whats_new: "0.1.0".into(),
+            ..Settings::default()
+        });
+        app.update();
+
+        assert_eq!(card_count(&mut app), 1, "an upgrade must show the card");
+        assert_eq!(
+            app.world()
+                .resource::<SettingsResource>()
+                .0
+                .last_seen_whats_new,
+            current_release_version(),
+            "the seen version must stamp on spawn"
+        );
+        assert!(
+            app.world().resource::<WhatsNewPending>().0,
+            "the launch beat stays held until dismissal"
+        );
+    }
+
+    #[test]
+    fn seen_version_shows_nothing_and_releases_the_beat() {
+        let mut app = app_with(Settings {
+            first_run_complete: true,
+            last_seen_whats_new: current_release_version(),
+            ..Settings::default()
+        });
+        app.update();
+
+        assert_eq!(card_count(&mut app), 0);
+        assert!(
+            !app.world().resource::<WhatsNewPending>().0,
+            "nothing to show must release the launch beat"
+        );
+    }
+
+    #[test]
+    fn fresh_install_waits_for_onboarding_and_never_shows() {
+        let mut app = app_with(Settings {
+            first_run_complete: false,
+            ..Settings::default()
+        });
+        app.update();
+        assert_eq!(card_count(&mut app), 0);
+        assert!(
+            app.world().resource::<WhatsNewPending>().0,
+            "mid-onboarding the beat stays held"
+        );
+
+        // Onboarding completion stamps the version (mirrored from
+        // complete_onboarding) — afterwards the card must stand down.
+        {
+            let mut settings = app.world_mut().resource_mut::<SettingsResource>();
+            settings.0.first_run_complete = true;
+            settings.0.last_seen_whats_new = current_release_version();
+        }
+        app.update();
+        assert_eq!(card_count(&mut app), 0, "fresh installs never see the card");
+        assert!(!app.world().resource::<WhatsNewPending>().0);
+    }
+
+    #[test]
+    fn got_it_dismisses_and_releases_the_beat() {
+        let mut app = app_with(Settings {
+            first_run_complete: true,
+            ..Settings::default()
+        });
+        app.update();
+        assert_eq!(card_count(&mut app), 1);
+
+        let button = app
+            .world_mut()
+            .query_filtered::<Entity, With<WhatsNewCloseButton>>()
+            .single(app.world())
+            .expect("Got it button must exist");
+        app.world_mut()
+            .entity_mut(button)
+            .insert(Interaction::Pressed);
+        app.update();
+        app.update();
+
+        assert_eq!(card_count(&mut app), 0, "Got it must dismiss the card");
+        assert!(!app.world().resource::<WhatsNewPending>().0);
+    }
+}
@@ -18,7 +18,7 @@
 //! shake duration elapses.

 use bevy::prelude::*;
-use solitaire_core::game_state::GameMode;
+use solitaire_core::game_state::{GameMode, GameState};
 use solitaire_core::scoring::compute_time_bonus;
 use solitaire_data::AnimSpeed;

@@ -93,6 +93,40 @@ pub struct WinSummaryPending {
    /// score-breakdown reveal can format the mode-multiplier row
    /// (e.g. `Zen ×0.0`, `Classic ×1.0`).
    pub mode: GameMode,
+    /// Per-move-type recap of the winning game, e.g.
+    /// `"21 to foundation · 14 tableau moves · 9 flips · 1 recycle"`.
+    /// Built from the upstream session counters at win time; empty when
+    /// every counter is zero (synthesised test wins).
+    pub move_detail: String,
+}
+
+/// Formats the per-move-type recap line for the win modal from the
+/// upstream session counters. Zero-valued components are omitted so the
+/// line stays short; returns an empty string when nothing was counted
+/// (only possible for synthesised test wins).
+fn build_move_detail(game: &GameState) -> String {
+    let mut parts: Vec<String> = Vec::new();
+    let foundation = game.move_to_foundation_count();
+    if foundation > 0 {
+        parts.push(format!("{foundation} to foundation"));
+    }
+    let tableau = game.move_to_tableau_count();
+    if tableau > 0 {
+        parts.push(format!("{tableau} tableau moves"));
+    }
+    let flips = game.flip_up_count();
+    if flips > 0 {
+        parts.push(format!("{flips} flips"));
+    }
+    let recycles = game.recycle_count();
+    if recycles > 0 {
+        parts.push(format!("{recycles} recycles"));
+    }
+    let returns = game.move_from_foundation_count();
+    if returns > 0 {
+        parts.push(format!("{returns} foundation returns"));
+    }
+    parts.join(" \u{00B7} ")
 }

 /// Builds a human-readable XP breakdown string for the win modal.
@@ -232,20 +266,54 @@ impl Plugin for WinSummaryPlugin {
            // the player's old personal-best values before `StatsPlugin` overwrites them.
            .add_systems(
                Update,
-                cache_win_data.after(GameMutation).before(StatsUpdate),
+                cache_win_data
+                    .after(GameMutation)
+                    .before(StatsUpdate)
+                    // Must also read pre-award progress (old level for the
+                    // level-up row) and emits the personal-best toast.
+                    .before(crate::progress_plugin::ProgressUpdate)
+                    .in_set(crate::game_plugin::InfoToastWriters)
+                    .ambiguous_with(crate::game_plugin::InfoToastWriters),
            )
            .add_systems(
                Update,
+                // One deterministic chain, late on the frame: after AnimFx
+                // so the unlock/XP event streams it drains are settled by
+                // both achievement evaluators (win + replay-completion run
+                // before AnimFx). Members join the request/toast writer
+                // clubs they append to; the camera shake and the score
+                // reveal touch entity domains disjoint from the card/HUD
+                // painters (#143).
                (
-                    collect_session_achievements,
-                    spawn_win_summary_after_delay,
-                    handle_win_summary_buttons,
+                    collect_session_achievements
+                        .in_set(crate::game_plugin::NewGameRequestWriters)
+                        .ambiguous_with(crate::game_plugin::NewGameRequestWriters),
+                    spawn_win_summary_after_delay
+                        .in_set(crate::settings_plugin::SettingsAccess)
+                        .ambiguous_with(crate::settings_plugin::SettingsAccess),
+                    handle_win_summary_buttons
+                        .in_set(crate::game_plugin::NewGameRequestWriters)
+                        .ambiguous_with(crate::game_plugin::NewGameRequestWriters)
+                        .in_set(crate::game_plugin::InfoToastWriters)
+                        .ambiguous_with(crate::game_plugin::InfoToastWriters),
                    close_overlay_on_watch_replay,
-                    handle_win_summary_keyboard,
-                    apply_screen_shake,
-                    reveal_score_breakdown,
+                    handle_win_summary_keyboard
+                        .in_set(crate::game_plugin::NewGameRequestWriters)
+                        .ambiguous_with(crate::game_plugin::NewGameRequestWriters)
+                        .before(crate::ui_focus::FocusKeys),
+                    apply_screen_shake
+                        .ambiguous_with(crate::feedback_anim_plugin::FeedbackFx)
+                        // Shakes the camera; hint ghosts are their own
+                        // entity domain (#143).
+                        .ambiguous_with(crate::feedback_anim_plugin::HintGhostFx)
+                        .ambiguous_with(crate::ui_theme::UiTextFx),
+                    reveal_score_breakdown
+                        .in_set(crate::ui_theme::UiTextFx)
+                        .ambiguous_with(crate::ui_theme::UiTextFx),
                )
-                    .after(GameMutation),
+                    .chain()
+                    .after(GameMutation)
+                    .after(crate::animation_plugin::AnimFx),
            );
    }
 }
@@ -492,6 +560,7 @@ fn cache_win_data(
        pending.challenge_level = challenge_level;
        pending.undo_count = game.0.undo_count();
        pending.mode = game.0.mode;
+        pending.move_detail = build_move_detail(&game.0);

        if is_new_record {
            toast.write(InfoToastEvent("New Record!".to_string()));
@@ -913,6 +982,18 @@ fn spawn_overlay(
                    ));
                }

+                // Move-type recap (same quiet styling as the XP breakdown)
+                if !pending.move_detail.is_empty() {
+                    card.spawn((
+                        Text::new(pending.move_detail.clone()),
+                        TextFont {
+                            font_size: 15.0,
+                            ..default()
+                        },
+                        TextColor(TEXT_SECONDARY),
+                    ));
+                }
+
                // Achievements unlocked this game — at most 3 shown explicitly;
                // excess is summarised with "...and N more".
                if !session.names.is_empty() {
@@ -1288,6 +1369,49 @@ mod tests {
        assert_eq!(p.mode, GameMode::Classic);
    }

+    #[test]
+    fn build_move_detail_fresh_game_is_empty() {
+        let game = GameState::new(42, solitaire_core::DrawStockConfig::DrawOne);
+        assert!(
+            build_move_detail(&game).is_empty(),
+            "no moves yet, so the recap line must be empty"
+        );
+    }
+
+    #[test]
+    fn build_move_detail_reports_played_move_types() {
+        use solitaire_core::KlondikeInstruction;
+        // Drive a real deal forward so the upstream counters accumulate:
+        // prefer foundation moves, then anything else, drawing as needed.
+        let mut game = GameState::new(42, solitaire_core::DrawStockConfig::DrawOne);
+        for _ in 0..80 {
+            let instructions = game.possible_instructions();
+            let next = instructions
+                .iter()
+                .copied()
+                .find(|i| matches!(i, KlondikeInstruction::DstFoundation(_)))
+                .or_else(|| instructions.into_iter().next());
+            match next {
+                Some(i) => {
+                    let _ = game.apply_instruction(i);
+                }
+                None => break,
+            }
+            if game.move_to_foundation_count() > 0 && game.move_to_tableau_count() > 0 {
+                break;
+            }
+        }
+        let detail = build_move_detail(&game);
+        assert!(
+            detail.contains("to foundation"),
+            "seed 42 reaches a foundation move within 80 plies; got: {detail}"
+        );
+        assert!(
+            !detail.contains("0 "),
+            "zero-valued components must be omitted; got: {detail}"
+        );
+    }
+
    #[test]
    fn build_xp_detail_slow_win_with_undo() {
        // 300s >= 120s → no speed bonus; undo used → no no-undo bonus.
@@ -1,3 +1,72 @@
+# --- WASM build stage ---
+# Builds solitaire_server/web/pkg/ (replay viewer + Bevy canvas app) from
+# source. The artifacts are not committed to the repo (issue #156); this
+# stage is their single source of truth for deployment.
+FROM rust:1.95-slim AS wasm-builder
+
+WORKDIR /build
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    curl \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN rustup target add wasm32-unknown-unknown
+
+# Pinned wasm toolchain — keep versions in sync with
+# .gitea/workflows/web-e2e.yml and build_wasm.sh prerequisites.
+RUN curl -sSL https://github.com/rustwasm/wasm-bindgen/releases/download/0.2.120/wasm-bindgen-0.2.120-x86_64-unknown-linux-musl.tar.gz \
+      | tar xz -C /opt \
+    && ln -s /opt/wasm-bindgen-0.2.120-x86_64-unknown-linux-musl/wasm-bindgen /usr/local/bin/wasm-bindgen \
+    && curl -sSL https://github.com/rustwasm/wasm-pack/releases/download/v0.14.0/wasm-pack-v0.14.0-x86_64-unknown-linux-musl.tar.gz \
+      | tar xz -C /opt \
+    && ln -s /opt/wasm-pack-v0.14.0-x86_64-unknown-linux-musl/wasm-pack /usr/local/bin/wasm-pack \
+    && curl -sSL https://github.com/WebAssembly/binaryen/releases/download/version_130/binaryen-version_130-x86_64-linux.tar.gz \
+      | tar xz -C /opt \
+    && ln -s /opt/binaryen-version_130/bin/wasm-opt /usr/local/bin/wasm-opt
+
+# Manifests first so the dependency-fetch layer caches across source changes
+# (same pattern as the server build stage below).
+COPY .cargo/config.toml            ./.cargo/config.toml
+COPY Cargo.toml Cargo.lock ./
+COPY solitaire_core/Cargo.toml     ./solitaire_core/Cargo.toml
+COPY solitaire_sync/Cargo.toml     ./solitaire_sync/Cargo.toml
+COPY solitaire_data/Cargo.toml     ./solitaire_data/Cargo.toml
+COPY solitaire_engine/Cargo.toml   ./solitaire_engine/Cargo.toml
+COPY solitaire_server/Cargo.toml   ./solitaire_server/Cargo.toml
+COPY solitaire_app/Cargo.toml      ./solitaire_app/Cargo.toml
+COPY solitaire_assetgen/Cargo.toml ./solitaire_assetgen/Cargo.toml
+COPY solitaire_wasm/Cargo.toml     ./solitaire_wasm/Cargo.toml
+COPY solitaire_web/Cargo.toml      ./solitaire_web/Cargo.toml
+
+RUN for crate in solitaire_core solitaire_sync solitaire_data solitaire_engine \
+        solitaire_server solitaire_app solitaire_assetgen solitaire_wasm solitaire_web; do \
+      mkdir -p $crate/src && echo "pub fn _stub() {}" > $crate/src/lib.rs; \
+    done && \
+    echo "fn main() {}" > solitaire_server/src/main.rs && \
+    echo "fn main() {}" > solitaire_app/src/main.rs && \
+    echo "fn main() {}" > solitaire_assetgen/src/main.rs
+
+RUN cargo fetch --locked
+
+# Real source for the wasm-feeding crates. Whole crate directories (not just
+# src/) because solitaire_engine embeds theme/audio/font assets at compile
+# time from its own assets/ and the workspace assets/.
+COPY build_wasm.sh ./
+# whats_new_plugin embeds the changelog at compile time
+# (include_str!("../../CHANGELOG.md")) — omit it and the engine build
+# fails inside this stage while full-checkout builds stay green.
+COPY CHANGELOG.md ./
+COPY solitaire_core   ./solitaire_core
+COPY solitaire_sync   ./solitaire_sync
+COPY solitaire_data   ./solitaire_data
+COPY solitaire_engine ./solitaire_engine
+COPY solitaire_wasm   ./solitaire_wasm
+COPY solitaire_web    ./solitaire_web
+COPY assets           ./assets
+
+RUN ./build_wasm.sh
+
 # --- Build stage ---
 FROM rust:1.95-slim AS builder

@@ -67,6 +136,8 @@ COPY --from=builder /build/target/release/solitaire_server ./server
 #   /app/assets                →  /assets route
 # Card themes (dark + classic) are embedded in the binary; no theme files needed here.
 COPY solitaire_server/web ./solitaire_server/web
+# The wasm bundles are never in the repo — they come from the wasm-builder stage.
+COPY --from=wasm-builder /build/solitaire_server/web/pkg ./solitaire_server/web/pkg
 COPY assets ./assets

 ENV SERVER_PORT=8080
@@ -206,7 +206,9 @@ async function main() {
                    invariant_ok: !!snap?.invariants?.state_ok,
                    history_len: Array.isArray(snap?.move_history) ? snap.move_history.length : null,
                    replay_payload_present: payload !== null,
-                    replay_moves_len: Array.isArray(payload?.moves) ? payload.moves.length : 0,
+                    replay_moves_len: Array.isArray(payload?.recording?.instructions)
+                        ? payload.recording.instructions.length
+                        : 0,
                };
            }, { stepCap: maxSteps, policyName: policy, maxVisits: maxVisitsPerState });

@@ -69,9 +69,9 @@ test("draw-mode toggle affects replay payload draw_mode", async ({ page }) => {

    const payload = await page.evaluate(() => window.__FERROUS_DEBUG__.replayPayload());
    expect(payload.draw_mode).toBe("DrawThree");
-    expect(payload.schema_version).toBe(2);
-    expect(Array.isArray(payload.moves)).toBeTruthy();
-    expect(payload.moves.length).toBeGreaterThan(0);
+    expect(payload.schema_version).toBe(4);
+    expect(Array.isArray(payload.recording?.instructions)).toBeTruthy();
+    expect(payload.recording.instructions.length).toBeGreaterThan(0);
 });

 test("autonomous play keeps invariants stable across seed batch", async ({ page }) => {
@@ -47,7 +47,7 @@ test("debug failure report contains replay diagnostics", async ({ page }) => {
    expect(report.invariants).toBeTruthy();
 });

-test("replay payload builder exports schema-v2 moves", async ({ page }) => {
+test("replay payload builder exports a schema-v4 recording", async ({ page }) => {
    await page.goto("/play-classic?seed=42");
    await page.waitForFunction(() => typeof window.__FERROUS_DEBUG__ === "object");

@@ -57,10 +57,14 @@ test("replay payload builder exports schema-v2 moves", async ({ page }) => {
        .poll(async () => await page.evaluate(() => window.__FERROUS_DEBUG__.replayPayload() !== null))
        .toBe(true);
    const payload = await page.evaluate(() => window.__FERROUS_DEBUG__.replayPayload());
-    expect(payload.schema_version).toBe(2);
+    // Schema v4: the wasm layer assembles the whole payload; the deal is
+    // embedded in `recording` and moves live at recording.instructions.
+    expect(payload.schema_version).toBe(4);
    expect(payload.draw_mode).toMatch(/Draw(One|Three)/);
    expect(payload.mode).toBe("Classic");
-    expect(Array.isArray(payload.moves)).toBeTruthy();
-    expect(payload.moves.length).toBeGreaterThan(0);
-    expect(payload.win_move_index).toBe(payload.moves.length - 1);
+    expect(payload.recording).toBeTruthy();
+    expect(payload.recording.initial_state).toBeTruthy();
+    expect(Array.isArray(payload.recording.instructions)).toBeTruthy();
+    expect(payload.recording.instructions.length).toBeGreaterThan(0);
+    expect(payload.win_move_index).toBe(payload.recording.instructions.length - 1);
 });
@@ -31,17 +31,37 @@ use crate::{AppState, error::AppError, middleware::AuthenticatedUser};
 const KNOWN_MODES: &[&str] = &["Classic", "Zen", "TimeAttack", "Challenge", "Difficulty"];
 const KNOWN_DRAW_MODES: &[&str] = &["DrawOne", "DrawThree"];

-fn validate_header(h: &ReplayHeader) -> Result<(), AppError> {
+/// Extract the mode label from the client's serde representation.
+///
+/// Unit `GameMode` variants serialise as plain strings (`"Classic"`),
+/// but data-carrying variants serialise as single-key objects
+/// (`{"Difficulty": "Easy"}`) — a plain-`String` field rejected those
+/// uploads with a 400 even though `"Difficulty"` sits in `KNOWN_MODES`.
+fn mode_label(mode: &serde_json::Value) -> Result<String, AppError> {
+    if let Some(s) = mode.as_str() {
+        return Ok(s.to_string());
+    }
+    if let Some(obj) = mode.as_object()
+        && obj.len() == 1
+        && let Some(key) = obj.keys().next()
+    {
+        return Ok(key.clone());
+    }
+    Err(AppError::BadRequest(format!(
+        "invalid mode '{mode}'; expected a mode string or single-variant object"
+    )))
+}
+
+fn validate_header(h: &ReplayHeader, mode: &str) -> Result<(), AppError> {
    if !KNOWN_DRAW_MODES.contains(&h.draw_mode.as_str()) {
        return Err(AppError::BadRequest(format!(
            "invalid draw_mode '{}'; expected one of {:?}",
            h.draw_mode, KNOWN_DRAW_MODES
        )));
    }
-    if !KNOWN_MODES.contains(&h.mode.as_str()) {
+    if !KNOWN_MODES.contains(&mode) {
        return Err(AppError::BadRequest(format!(
-            "invalid mode '{}'; expected one of {:?}",
-            h.mode, KNOWN_MODES
+            "invalid mode '{mode}'; expected one of {KNOWN_MODES:?}"
        )));
    }
    if h.time_seconds <= 0 || h.time_seconds > 86_400 {
@@ -72,7 +92,11 @@ fn validate_header(h: &ReplayHeader) -> Result<(), AppError> {
 struct ReplayHeader {
    seed: u64,
    draw_mode: String,
-    mode: String,
+    /// Kept as raw JSON: unit variants arrive as strings, data-carrying
+    /// variants (`GameMode::Difficulty(level)`) as single-key objects.
+    /// [`mode_label`] projects both onto the label stored in the `mode`
+    /// column.
+    mode: serde_json::Value,
    time_seconds: i64,
    final_score: i64,
    recorded_at: String,
@@ -126,7 +150,8 @@ pub async fn upload(
    let header: ReplayHeader = serde_json::from_value(payload.clone())
        .map_err(|e| AppError::BadRequest(format!("replay JSON missing fields: {e}")))?;

-    validate_header(&header)?;
+    let mode = mode_label(&header.mode)?;
+    validate_header(&header, &mode)?;

    let id = Uuid::new_v4().to_string();
    let received_at = Utc::now().to_rfc3339();
@@ -144,7 +169,7 @@ pub async fn upload(
        user.user_id,
        seed_i64,
        header.draw_mode,
-        header.mode,
+        mode,
        header.time_seconds,
        header.final_score,
        header.recorded_at,
@@ -158,7 +183,7 @@ pub async fn upload(
    // beats their existing best. Only classic mode counts for the leaderboard.
    // Use `received_at` (server-computed) rather than `header.recorded_at`
    // (client-supplied) so clients cannot spoof the timestamp.
-    if header.mode == "Classic" {
+    if mode == "Classic" {
        sqlx::query!(
            r#"UPDATE leaderboard
               SET best_score      = ?,
@@ -445,33 +445,30 @@ function showWin(s) {
    submitReplay(s);
 }

-function buildReplayPayload(s) {
-    if (!game || !s) return null;
-    let moves;
+function buildReplayPayload() {
+    if (!game) return null;
+    // The wasm side assembles the entire schema-v4 payload (including the
+    // session recording and the u64 seed, which JS numbers can't hold);
+    // JS only supplies the wall-clock time and today's date.
    try {
-        moves = game.replay_moves();
-        if (!Array.isArray(moves) || moves.length === 0) return null;
+        const json = game.replay_export(
+            Math.max(1, elapsedSecs),
+            new Date().toISOString().slice(0, 10),
+        );
+        const payload = JSON.parse(json);
+        if (!Array.isArray(payload?.recording?.instructions)
+            || payload.recording.instructions.length === 0) return null;
+        return payload;
    } catch (e) {
        console.warn("fs: replay export failed", e);
        return null;
    }
-    return {
-        schema_version: 2,
-        seed: Math.round(game.seed()),
-        draw_mode: drawThree ? "DrawThree" : "DrawOne",
-        mode: "Classic",
-        time_seconds: Math.max(1, elapsedSecs),
-        final_score: s.score,
-        recorded_at: new Date().toISOString().slice(0, 10),
-        moves,
-        win_move_index: moves.length - 1,
-    };
 }

 async function submitReplay(s) {
    const token = localStorage.getItem('fs_token');
    if (!token || !game) return;
-    const payload = buildReplayPayload(s);
+    const payload = buildReplayPayload();
    if (!payload) return;
    try {
        await fetch('/api/replays', {
@@ -1029,7 +1026,7 @@ window.__FERROUS_DEBUG__ = {
    },
    replayPayload() {
        if (!game) return null;
-        return buildReplayPayload(snap ?? game.state());
+        return buildReplayPayload();
    },
    runAutoplay(options) {
        return runDebugAutoplay(options);
@@ -1,595 +0,0 @@
-/**
- * Browser-side replay state machine. Owns a live `GameState` and the
- * replay's move list; each `step()` applies the next move.
- */
-export class ReplayPlayer {
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        ReplayPlayerFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_replayplayer_free(ptr, 0);
-    }
-    /**
-     * Returns `true` once every move has been applied.
-     * @returns {boolean}
-     */
-    is_finished() {
-        const ret = wasm.replayplayer_is_finished(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Construct from a raw replay JSON string.
-     * @param {string} replay_json
-     */
-    constructor(replay_json) {
-        const ptr0 = passStringToWasm0(replay_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.replayplayer_new(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        this.__wbg_ptr = ret[0];
-        ReplayPlayerFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * Snapshot the current `GameState` as a JS object (see `StateSnapshot`).
-     *
-     * Throws a JS string exception on serialisation failure (should never
-     * occur in practice — `StateSnapshot` contains only primitive types).
-     * @returns {any}
-     */
-    state() {
-        const ret = wasm.replayplayer_state(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * Apply the next move; returns the post-step snapshot, or `null`
-     * once the move list is exhausted.
-     *
-     * Returns `null` (not an exception) when the replay is finished.
-     * Throws `"replay_desync"` when the next recorded move is illegal for
-     * the current state, and logs the underlying core error to the JS console.
-     * Throws a JS string exception on serialisation failure.
-     * @returns {any}
-     */
-    step() {
-        const ret = wasm.replayplayer_step(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * 0-indexed position of the next move to apply.
-     * @returns {number}
-     */
-    step_idx() {
-        const ret = wasm.replayplayer_step_idx(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Total number of moves the replay contains.
-     * @returns {number}
-     */
-    total_steps() {
-        const ret = wasm.replayplayer_total_steps(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-}
-if (Symbol.dispose) ReplayPlayer.prototype[Symbol.dispose] = ReplayPlayer.prototype.free;
-
-/**
- * Interactive Klondike game backed by the real `solitaire_core` rules engine.
- *
- * Construct with `new(seed, draw_three)`, then call `draw()`, `move_cards()`,
- * `undo()`, `auto_complete_step()` to advance the game. `state()` returns the
- * full pile snapshot at any time without mutating state.
- */
-export class SolitaireGame {
-    static __wrap(ptr) {
-        const obj = Object.create(SolitaireGame.prototype);
-        obj.__wbg_ptr = ptr;
-        SolitaireGameFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        SolitaireGameFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_solitairegame_free(ptr, 0);
-    }
-    /**
-     * Apply one auto-complete move (only valid when `is_auto_completable`).
-     *
-     * If no card can go directly to a foundation this step, advances the
-     * waste by calling `draw()` so the next step can try again. Returns the
-     * post-move snapshot, or `null` when no progress is possible.
-     * @returns {any}
-     */
-    auto_complete_step() {
-        const ret = wasm.solitairegame_auto_complete_step(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Applies the legal move currently at `index` from `debug_legal_moves()`.
-     * @param {number} index
-     * @returns {any}
-     */
-    debug_apply_legal_move(index) {
-        const ret = wasm.solitairegame_debug_apply_legal_move(this.__wbg_ptr, index);
-        return ret;
-    }
-    /**
-     * Applies one debug move encoded as JSON.
-     *
-     * JSON must match [`DebugMove`], for example:
-     * `{"kind":"move","from":"tableau-0","to":"foundation-1","count":1}` or
-     * `{"kind":"stock_click"}`.
-     * @param {string} move_json
-     * @returns {any}
-     */
-    debug_apply_move_json(move_json) {
-        const ptr0 = passStringToWasm0(move_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.solitairegame_debug_apply_move_json(this.__wbg_ptr, ptr0, len0);
-        return ret;
-    }
-    /**
-     * Returns all currently-legal debug moves as a JS array.
-     *
-     * Includes [`DebugMove::StockClick`] when stock interaction is legal.
-     * @returns {any}
-     */
-    debug_legal_moves() {
-        const ret = wasm.solitairegame_debug_legal_moves(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * Returns deterministic instruction history for the current game.
-     *
-     * Together with `seed()` and `draw_mode`, this history is replayable.
-     * @returns {any}
-     */
-    debug_move_history() {
-        const ret = wasm.solitairegame_debug_move_history(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * Returns a comprehensive debug snapshot for automated verification.
-     * @returns {any}
-     */
-    debug_snapshot() {
-        const ret = wasm.solitairegame_debug_snapshot(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * Draw from stock to waste (or recycle waste → stock when stock is empty).
-     * Returns `{ok, error?, snapshot?}`.
-     * @returns {any}
-     */
-    draw() {
-        const ret = wasm.solitairegame_draw(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Restore a game from a JSON string previously produced by [`SolitaireGame::serialize`].
-     *
-     * Returns an error string if the JSON is malformed or describes a state
-     * that can't be deserialised (e.g. from a future schema version).
-     * @param {string} json
-     * @returns {SolitaireGame}
-     */
-    static from_saved(json) {
-        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.solitairegame_from_saved(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return SolitaireGame.__wrap(ret[0]);
-    }
-    /**
-     * Move `count` cards from pile `from` to pile `to`.
-     *
-     * Pile names: `"stock"`, `"waste"`, `"foundation-0"` .. `"foundation-3"`,
-     * `"tableau-0"` .. `"tableau-6"`.
-     *
-     * Returns `{ok, error?, snapshot?}`.
-     * @param {string} from
-     * @param {string} to
-     * @param {number} count
-     * @returns {any}
-     */
-    move_cards(from, to, count) {
-        const ptr0 = passStringToWasm0(from, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(to, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.solitairegame_move_cards(this.__wbg_ptr, ptr0, len0, ptr1, len1, count);
-        return ret;
-    }
-    /**
-     * Create a new DrawOne or DrawThree Classic game from the given seed.
-     *
-     * `seed` is a JS `number` (f64); values up to 2^53 are represented exactly.
-     * Pass `Date.now()` or a random integer from JS for variety.
-     * @param {number} seed
-     * @param {boolean} draw_three
-     */
-    constructor(seed, draw_three) {
-        const ret = wasm.solitairegame_new(seed, draw_three);
-        this.__wbg_ptr = ret;
-        SolitaireGameFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * Returns replay moves encoded in the `solitaire_data::Replay` wire format
-     * — a list of upstream [`KlondikeInstruction`]s.
-     *
-     * This is the deterministic instruction history; together with `seed()`
-     * and the draw mode it replays cleanly via `apply_instruction`.
-     * @returns {any}
-     */
-    replay_moves() {
-        const ret = wasm.solitairegame_replay_moves(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * The seed used to deal this game.
-     * @returns {number}
-     */
-    seed() {
-        const ret = wasm.solitairegame_seed(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Serialise the full game state as a JSON string for `localStorage`.
-     *
-     * Use [`SolitaireGame::from_saved`] to restore it. The returned string is
-     * opaque — callers should treat it as a blob and store/restore it verbatim.
-     * @returns {string}
-     */
-    serialize() {
-        let deferred2_0;
-        let deferred2_1;
-        try {
-            const ret = wasm.solitairegame_serialize(this.__wbg_ptr);
-            var ptr1 = ret[0];
-            var len1 = ret[1];
-            if (ret[3]) {
-                ptr1 = 0; len1 = 0;
-                throw takeFromExternrefTable0(ret[2]);
-            }
-            deferred2_0 = ptr1;
-            deferred2_1 = len1;
-            return getStringFromWasm0(ptr1, len1);
-        } finally {
-            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
-        }
-    }
-    /**
-     * Full pile snapshot as a JS object.
-     *
-     * Throws a JS string exception on serialisation failure.
-     * @returns {any}
-     */
-    state() {
-        const ret = wasm.solitairegame_state(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * Undo the last move. Returns `{ok, error?, snapshot?}`.
-     * @returns {any}
-     */
-    undo() {
-        const ret = wasm.solitairegame_undo(this.__wbg_ptr);
-        return ret;
-    }
-}
-if (Symbol.dispose) SolitaireGame.prototype[Symbol.dispose] = SolitaireGame.prototype.free;
-function __wbg_get_imports() {
-    const import0 = {
-        __proto__: null,
-        __wbg_Error_3639a60ed15f87e7: function(arg0, arg1) {
-            const ret = Error(getStringFromWasm0(arg0, arg1));
-            return ret;
-        },
-        __wbg_String_8564e559799eccda: function(arg0, arg1) {
-            const ret = String(arg1);
-            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len1 = WASM_VECTOR_LEN;
-            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-        },
-        __wbg___wbindgen_throw_9c75d47bf9e7731e: function(arg0, arg1) {
-            throw new Error(getStringFromWasm0(arg0, arg1));
-        },
-        __wbg_error_48655ee7e4756f8b: function(arg0) {
-            console.error(arg0);
-        },
-        __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
-            let deferred0_0;
-            let deferred0_1;
-            try {
-                deferred0_0 = arg0;
-                deferred0_1 = arg1;
-                console.error(getStringFromWasm0(arg0, arg1));
-            } finally {
-                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
-            }
-        },
-        __wbg_new_227d7c05414eb861: function() {
-            const ret = new Error();
-            return ret;
-        },
-        __wbg_new_2fad8ca02fd00684: function() {
-            const ret = new Object();
-            return ret;
-        },
-        __wbg_new_3baa8d9866155c79: function() {
-            const ret = new Array();
-            return ret;
-        },
-        __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
-            arg0[arg1] = arg2;
-        },
-        __wbg_set_f614f6a0608d1d1d: function(arg0, arg1, arg2) {
-            arg0[arg1 >>> 0] = arg2;
-        },
-        __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
-            const ret = arg1.stack;
-            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len1 = WASM_VECTOR_LEN;
-            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-        },
-        __wbindgen_cast_0000000000000001: function(arg0) {
-            // Cast intrinsic for `F64 -> Externref`.
-            const ret = arg0;
-            return ret;
-        },
-        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Ref(String) -> Externref`.
-            const ret = getStringFromWasm0(arg0, arg1);
-            return ret;
-        },
-        __wbindgen_cast_0000000000000003: function(arg0) {
-            // Cast intrinsic for `U64 -> Externref`.
-            const ret = BigInt.asUintN(64, arg0);
-            return ret;
-        },
-        __wbindgen_init_externref_table: function() {
-            const table = wasm.__wbindgen_externrefs;
-            const offset = table.grow(4);
-            table.set(0, undefined);
-            table.set(offset + 0, undefined);
-            table.set(offset + 1, null);
-            table.set(offset + 2, true);
-            table.set(offset + 3, false);
-        },
-    };
-    return {
-        __proto__: null,
-        "./solitaire_wasm_bg.js": import0,
-    };
-}
-
-const ReplayPlayerFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_replayplayer_free(ptr, 1));
-const SolitaireGameFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_solitairegame_free(ptr, 1));
-
-let cachedDataViewMemory0 = null;
-function getDataViewMemory0() {
-    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
-        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
-    }
-    return cachedDataViewMemory0;
-}
-
-function getStringFromWasm0(ptr, len) {
-    return decodeText(ptr >>> 0, len);
-}
-
-let cachedUint8ArrayMemory0 = null;
-function getUint8ArrayMemory0() {
-    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
-        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8ArrayMemory0;
-}
-
-function passStringToWasm0(arg, malloc, realloc) {
-    if (realloc === undefined) {
-        const buf = cachedTextEncoder.encode(arg);
-        const ptr = malloc(buf.length, 1) >>> 0;
-        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
-        WASM_VECTOR_LEN = buf.length;
-        return ptr;
-    }
-
-    let len = arg.length;
-    let ptr = malloc(len, 1) >>> 0;
-
-    const mem = getUint8ArrayMemory0();
-
-    let offset = 0;
-
-    for (; offset < len; offset++) {
-        const code = arg.charCodeAt(offset);
-        if (code > 0x7F) break;
-        mem[ptr + offset] = code;
-    }
-    if (offset !== len) {
-        if (offset !== 0) {
-            arg = arg.slice(offset);
-        }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
-        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
-        const ret = cachedTextEncoder.encodeInto(arg, view);
-
-        offset += ret.written;
-        ptr = realloc(ptr, len, offset, 1) >>> 0;
-    }
-
-    WASM_VECTOR_LEN = offset;
-    return ptr;
-}
-
-function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_externrefs.get(idx);
-    wasm.__externref_table_dealloc(idx);
-    return value;
-}
-
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-cachedTextDecoder.decode();
-const MAX_SAFARI_DECODE_BYTES = 2146435072;
-let numBytesDecoded = 0;
-function decodeText(ptr, len) {
-    numBytesDecoded += len;
-    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
-        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-        cachedTextDecoder.decode();
-        numBytesDecoded = len;
-    }
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
-}
-
-const cachedTextEncoder = new TextEncoder();
-
-if (!('encodeInto' in cachedTextEncoder)) {
-    cachedTextEncoder.encodeInto = function (arg, view) {
-        const buf = cachedTextEncoder.encode(arg);
-        view.set(buf);
-        return {
-            read: arg.length,
-            written: buf.length
-        };
-    };
-}
-
-let WASM_VECTOR_LEN = 0;
-
-let wasmModule, wasmInstance, wasm;
-function __wbg_finalize_init(instance, module) {
-    wasmInstance = instance;
-    wasm = instance.exports;
-    wasmModule = module;
-    cachedDataViewMemory0 = null;
-    cachedUint8ArrayMemory0 = null;
-    wasm.__wbindgen_start();
-    return wasm;
-}
-
-async function __wbg_load(module, imports) {
-    if (typeof Response === 'function' && module instanceof Response) {
-        if (typeof WebAssembly.instantiateStreaming === 'function') {
-            try {
-                return await WebAssembly.instantiateStreaming(module, imports);
-            } catch (e) {
-                const validResponse = module.ok && expectedResponseType(module.type);
-
-                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
-                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
-
-                } else { throw e; }
-            }
-        }
-
-        const bytes = await module.arrayBuffer();
-        return await WebAssembly.instantiate(bytes, imports);
-    } else {
-        const instance = await WebAssembly.instantiate(module, imports);
-
-        if (instance instanceof WebAssembly.Instance) {
-            return { instance, module };
-        } else {
-            return instance;
-        }
-    }
-
-    function expectedResponseType(type) {
-        switch (type) {
-            case 'basic': case 'cors': case 'default': return true;
-        }
-        return false;
-    }
-}
-
-function initSync(module) {
-    if (wasm !== undefined) return wasm;
-
-
-    if (module !== undefined) {
-        if (Object.getPrototypeOf(module) === Object.prototype) {
-            ({module} = module)
-        } else {
-            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
-        }
-    }
-
-    const imports = __wbg_get_imports();
-    if (!(module instanceof WebAssembly.Module)) {
-        module = new WebAssembly.Module(module);
-    }
-    const instance = new WebAssembly.Instance(module, imports);
-    return __wbg_finalize_init(instance, module);
-}
-
-async function __wbg_init(module_or_path) {
-    if (wasm !== undefined) return wasm;
-
-
-    if (module_or_path !== undefined) {
-        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
-            ({module_or_path} = module_or_path)
-        } else {
-            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
-        }
-    }
-
-    if (module_or_path === undefined) {
-        module_or_path = new URL('solitaire_wasm_bg.wasm', import.meta.url);
-    }
-    const imports = __wbg_get_imports();
-
-    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
-        module_or_path = fetch(module_or_path);
-    }
-
-    const { instance, module } = await __wbg_load(await module_or_path, imports);
-
-    return __wbg_finalize_init(instance, module);
-}
-
-export { initSync, __wbg_init as default };
@@ -159,16 +159,17 @@

            function buildReplayPayload() {
                if (!game) return null;
+                // Schema v4: the wasm side assembles the full payload,
+                // including the session recording and the u64 seed.
                try {
-                    const moves = game.replay_moves();
-                    if (!Array.isArray(moves) || moves.length === 0) return null;
-                    return {
-                        schema_version: 2,
-                        seed: Math.round(game.seed()),
-                        draw_mode: game.debug_snapshot()?.draw_mode ?? "DrawOne",
-                        mode: "Classic",
-                        moves,
-                    };
+                    const json = game.replay_export(
+                        1,
+                        new Date().toISOString().slice(0, 10),
+                    );
+                    const payload = JSON.parse(json);
+                    if (!Array.isArray(payload?.recording?.instructions)
+                        || payload.recording.instructions.length === 0) return null;
+                    return payload;
                } catch { return null; }
            }

@@ -121,7 +121,18 @@ function resetPlayer() {
        playInterval = null;
        btnPlay.textContent = "▶ Play";
    }
-    player = new ReplayPlayer(replayJson);
+    // Old replays (schema < 4) are rejected by the wasm player with a
+    // descriptive error — surface it instead of leaving a dead board.
+    try {
+        player = new ReplayPlayer(replayJson);
+    } catch (e) {
+        captionEl.textContent = `Cannot play this replay: ${e}`;
+        btnStep.disabled = true;
+        btnPlay.disabled = true;
+        btnPrev.disabled = true;
+        btnRestart.disabled = true;
+        return;
+    }
    btnPrev.disabled = true;
    btnRestart.disabled = true;
    btnStep.disabled = false;
@@ -304,10 +315,9 @@ btnPlay.addEventListener("click", () => {
    }, STEP_INTERVAL_MS);
 });

-/// Step the player back one move. Re-creates the ReplayPlayer and fast-
-/// forwards to (step_idx - 1) without rendering intermediate frames, then
-/// renders once so the CSS transition animates each card to its previous
-/// position.
+/// Step the player back one move via the wasm-side seek (rewinds to the
+/// recorded deal and fast-forwards internally), then renders once so the
+/// CSS transition animates each card to its previous position.
 function stepBack() {
    if (!player || player.step_idx() === 0) return;
    if (playInterval) {
@@ -315,12 +325,7 @@ function stepBack() {
        playInterval = null;
        btnPlay.textContent = "▶ Play";
    }
-    const target = player.step_idx() - 1;
-    player = new ReplayPlayer(replayJson);
-    for (let i = 0; i < target; i++) {
-        player.step();
-    }
-    render(player.state());
+    render(player.seek(player.step_idx() - 1));
    btnPrev.disabled = player.step_idx() === 0;
    btnRestart.disabled = player.step_idx() === 0;
    btnStep.disabled = false;
--- a/Show More
+++ b/Show More