fix(engine): cancel stale win-cascade CardAnimation on new-game; refresh Android corner label text on resize (closes #6, closes #7)

Issue #7 — new game during win cascade:
sync_cards now stores each in-flight CardAnimation's end position instead of
a plain bool. Before calling update_card_entity, the end position is compared
against the game-state target. If they differ by more than 2 px (stale cascade
scatter vs. new-game dealt position) the CardAnimation is removed immediately
so the card slides to its correct dealt position. Drag-rejection tweens are
unaffected because their end equals the card's current game-state position.

Issue #6 — Android stale corner label text:
AndroidCornerLabel now carries the label string as AndroidCornerLabel(String).
resize_android_corner_labels refreshes Text2d content from the stored value
alongside the existing font-size and transform updates, closing the narrow
race where a layout change could display a previous card's rank/suit.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.claude-flow/.gitignore

@@ -0,0 +1,7 @@
+# Claude Flow runtime files
+data/
+logs/
+sessions/
+neural/
+*.log
+*.tmp

.claude-flow/CAPABILITIES.md

@@ -0,0 +1,403 @@
+# RuFlo V3 - Complete Capabilities Reference
+> Generated: 2026-05-19T00:18:20.864Z
+> Full documentation: https://github.com/ruvnet/claude-flow
+
+## 📋 Table of Contents
+
+1. [Overview](#overview)
+2. [Swarm Orchestration](#swarm-orchestration)
+3. [Available Agents (60+)](#available-agents)
+4. [CLI Commands (26 Commands, 140+ Subcommands)](#cli-commands)
+5. [Hooks System (27 Hooks + 12 Workers)](#hooks-system)
+6. [Memory & Intelligence (RuVector)](#memory--intelligence)
+7. [Hive-Mind Consensus](#hive-mind-consensus)
+8. [Performance Targets](#performance-targets)
+9. [Integration Ecosystem](#integration-ecosystem)
+
+---
+
+## Overview
+
+RuFlo V3 is a domain-driven design architecture for multi-agent AI coordination with:
+
+- **15-Agent Swarm Coordination** with hierarchical and mesh topologies
+- **HNSW Vector Search** - 150x-12,500x faster pattern retrieval
+- **SONA Neural Learning** - Self-optimizing with <0.05ms adaptation
+- **Byzantine Fault Tolerance** - Queen-led consensus mechanisms
+- **MCP Server Integration** - Model Context Protocol support
+
+### Current Configuration
+| Setting | Value |
+|---------|-------|
+| Topology | hierarchical-mesh |
+| Max Agents | 15 |
+| Memory Backend | hybrid |
+| HNSW Indexing | Enabled |
+| Neural Learning | Enabled |
+| LearningBridge | Enabled (SONA + ReasoningBank) |
+| Knowledge Graph | Enabled (PageRank + Communities) |
+| Agent Scopes | Enabled (project/local/user) |
+
+---
+
+## Swarm Orchestration
+
+### Topologies
+| Topology | Description | Best For |
+|----------|-------------|----------|
+| `hierarchical` | Queen controls workers directly | Anti-drift, tight control |
+| `mesh` | Fully connected peer network | Distributed tasks |
+| `hierarchical-mesh` | V3 hybrid (recommended) | 10+ agents |
+| `ring` | Circular communication | Sequential workflows |
+| `star` | Central coordinator | Simple coordination |
+| `adaptive` | Dynamic based on load | Variable workloads |
+
+### Strategies
+- `balanced` - Even distribution across agents
+- `specialized` - Clear roles, no overlap (anti-drift)
+- `adaptive` - Dynamic task routing
+
+### Quick Commands
+```bash
+# Initialize swarm
+npx @claude-flow/cli@latest swarm init --topology hierarchical --max-agents 8 --strategy specialized
+
+# Check status
+npx @claude-flow/cli@latest swarm status
+
+# Monitor activity
+npx @claude-flow/cli@latest swarm monitor
+```
+
+---
+
+## Available Agents
+
+### Core Development (5)
+`coder`, `reviewer`, `tester`, `planner`, `researcher`
+
+### V3 Specialized (4)
+`security-architect`, `security-auditor`, `memory-specialist`, `performance-engineer`
+
+### Swarm Coordination (5)
+`hierarchical-coordinator`, `mesh-coordinator`, `adaptive-coordinator`, `collective-intelligence-coordinator`, `swarm-memory-manager`
+
+### Consensus & Distributed (7)
+`byzantine-coordinator`, `raft-manager`, `gossip-coordinator`, `consensus-builder`, `crdt-synchronizer`, `quorum-manager`, `security-manager`
+
+### Performance & Optimization (5)
+`perf-analyzer`, `performance-benchmarker`, `task-orchestrator`, `memory-coordinator`, `smart-agent`
+
+### GitHub & Repository (9)
+`github-modes`, `pr-manager`, `code-review-swarm`, `issue-tracker`, `release-manager`, `workflow-automation`, `project-board-sync`, `repo-architect`, `multi-repo-swarm`
+
+### SPARC Methodology (6)
+`sparc-coord`, `sparc-coder`, `specification`, `pseudocode`, `architecture`, `refinement`
+
+### Specialized Development (8)
+`backend-dev`, `mobile-dev`, `ml-developer`, `cicd-engineer`, `api-docs`, `system-architect`, `code-analyzer`, `base-template-generator`
+
+### Testing & Validation (2)
+`tdd-london-swarm`, `production-validator`
+
+### Agent Routing by Task
+| Task Type | Recommended Agents | Topology |
+|-----------|-------------------|----------|
+| Bug Fix | researcher, coder, tester | mesh |
+| New Feature | coordinator, architect, coder, tester, reviewer | hierarchical |
+| Refactoring | architect, coder, reviewer | mesh |
+| Performance | researcher, perf-engineer, coder | hierarchical |
+| Security | security-architect, auditor, reviewer | hierarchical |
+| Docs | researcher, api-docs | mesh |
+
+---
+
+## CLI Commands
+
+### Core Commands (12)
+| Command | Subcommands | Description |
+|---------|-------------|-------------|
+| `init` | 4 | Project initialization |
+| `agent` | 8 | Agent lifecycle management |
+| `swarm` | 6 | Multi-agent coordination |
+| `memory` | 11 | AgentDB with HNSW search |
+| `mcp` | 9 | MCP server management |
+| `task` | 6 | Task assignment |
+| `session` | 7 | Session persistence |
+| `config` | 7 | Configuration |
+| `status` | 3 | System monitoring |
+| `workflow` | 6 | Workflow templates |
+| `hooks` | 17 | Self-learning hooks |
+| `hive-mind` | 6 | Consensus coordination |
+
+### Advanced Commands (14)
+| Command | Subcommands | Description |
+|---------|-------------|-------------|
+| `daemon` | 5 | Background workers |
+| `neural` | 5 | Pattern training |
+| `security` | 6 | Security scanning |
+| `performance` | 5 | Profiling & benchmarks |
+| `providers` | 5 | AI provider config |
+| `plugins` | 5 | Plugin management |
+| `deployment` | 5 | Deploy management |
+| `embeddings` | 4 | Vector embeddings |
+| `claims` | 4 | Authorization |
+| `migrate` | 5 | V2→V3 migration |
+| `process` | 4 | Process management |
+| `doctor` | 1 | Health diagnostics |
+| `completions` | 4 | Shell completions |
+
+### Example Commands
+```bash
+# Initialize
+npx @claude-flow/cli@latest init --wizard
+
+# Spawn agent
+npx @claude-flow/cli@latest agent spawn -t coder --name my-coder
+
+# Memory operations
+npx @claude-flow/cli@latest memory store --key "pattern" --value "data" --namespace patterns
+npx @claude-flow/cli@latest memory search --query "authentication"
+
+# Diagnostics
+npx @claude-flow/cli@latest doctor --fix
+```
+
+---
+
+## Hooks System
+
+### 27 Available Hooks
+
+#### Core Hooks (6)
+| Hook | Description |
+|------|-------------|
+| `pre-edit` | Context before file edits |
+| `post-edit` | Record edit outcomes |
+| `pre-command` | Risk assessment |
+| `post-command` | Command metrics |
+| `pre-task` | Task start + agent suggestions |
+| `post-task` | Task completion learning |
+
+#### Session Hooks (4)
+| Hook | Description |
+|------|-------------|
+| `session-start` | Start/restore session |
+| `session-end` | Persist state |
+| `session-restore` | Restore previous |
+| `notify` | Cross-agent notifications |
+
+#### Intelligence Hooks (5)
+| Hook | Description |
+|------|-------------|
+| `route` | Optimal agent routing |
+| `explain` | Routing decisions |
+| `pretrain` | Bootstrap intelligence |
+| `build-agents` | Generate configs |
+| `transfer` | Pattern transfer |
+
+#### Coverage Hooks (3)
+| Hook | Description |
+|------|-------------|
+| `coverage-route` | Coverage-based routing |
+| `coverage-suggest` | Improvement suggestions |
+| `coverage-gaps` | Gap analysis |
+
+### 12 Background Workers
+| Worker | Priority | Purpose |
+|--------|----------|---------|
+| `ultralearn` | normal | Deep knowledge |
+| `optimize` | high | Performance |
+| `consolidate` | low | Memory consolidation |
+| `predict` | normal | Predictive preload |
+| `audit` | critical | Security |
+| `map` | normal | Codebase mapping |
+| `preload` | low | Resource preload |
+| `deepdive` | normal | Deep analysis |
+| `document` | normal | Auto-docs |
+| `refactor` | normal | Suggestions |
+| `benchmark` | normal | Benchmarking |
+| `testgaps` | normal | Coverage gaps |
+
+---
+
+## Memory & Intelligence
+
+### RuVector Intelligence System
+- **SONA**: Self-Optimizing Neural Architecture (<0.05ms)
+- **MoE**: Mixture of Experts routing
+- **HNSW**: 150x-12,500x faster search
+- **EWC++**: Prevents catastrophic forgetting
+- **Flash Attention**: 2.49x-7.47x speedup
+- **Int8 Quantization**: 3.92x memory reduction
+
+### 4-Step Intelligence Pipeline
+1. **RETRIEVE** - HNSW pattern search
+2. **JUDGE** - Success/failure verdicts
+3. **DISTILL** - LoRA learning extraction
+4. **CONSOLIDATE** - EWC++ preservation
+
+### Self-Learning Memory (ADR-049)
+
+| Component | Status | Description |
+|-----------|--------|-------------|
+| **LearningBridge** | ✅ Enabled | Connects insights to SONA/ReasoningBank neural pipeline |
+| **MemoryGraph** | ✅ Enabled | PageRank knowledge graph + community detection |
+| **AgentMemoryScope** | ✅ Enabled | 3-scope agent memory (project/local/user) |
+
+**LearningBridge** - Insights trigger learning trajectories. Confidence evolves: +0.03 on access, -0.005/hour decay. Consolidation runs the JUDGE/DISTILL/CONSOLIDATE pipeline.
+
+**MemoryGraph** - Builds a knowledge graph from entry references. PageRank identifies influential insights. Communities group related knowledge. Graph-aware ranking blends vector + structural scores.
+
+**AgentMemoryScope** - Maps Claude Code 3-scope directories:
+- `project`: `<gitRoot>/.claude/agent-memory/<agent>/`
+- `local`: `<gitRoot>/.claude/agent-memory-local/<agent>/`
+- `user`: `~/.claude/agent-memory/<agent>/`
+
+High-confidence insights (>0.8) can transfer between agents.
+
+### Memory Commands
+```bash
+# Store pattern
+npx @claude-flow/cli@latest memory store --key "name" --value "data" --namespace patterns
+
+# Semantic search
+npx @claude-flow/cli@latest memory search --query "authentication"
+
+# List entries
+npx @claude-flow/cli@latest memory list --namespace patterns
+
+# Initialize database
+npx @claude-flow/cli@latest memory init --force
+```
+
+---
+
+## Hive-Mind Consensus
+
+### Queen Types
+| Type | Role |
+|------|------|
+| Strategic Queen | Long-term planning |
+| Tactical Queen | Execution coordination |
+| Adaptive Queen | Dynamic optimization |
+
+### Worker Types (8)
+`researcher`, `coder`, `analyst`, `tester`, `architect`, `reviewer`, `optimizer`, `documenter`
+
+### Consensus Mechanisms
+| Mechanism | Fault Tolerance | Use Case |
+|-----------|-----------------|----------|
+| `byzantine` | f < n/3 faulty | Adversarial |
+| `raft` | f < n/2 failed | Leader-based |
+| `gossip` | Eventually consistent | Large scale |
+| `crdt` | Conflict-free | Distributed |
+| `quorum` | Configurable | Flexible |
+
+### Hive-Mind Commands
+```bash
+# Initialize
+npx @claude-flow/cli@latest hive-mind init --queen-type strategic
+
+# Status
+npx @claude-flow/cli@latest hive-mind status
+
+# Spawn workers
+npx @claude-flow/cli@latest hive-mind spawn --count 5 --type worker
+
+# Consensus
+npx @claude-flow/cli@latest hive-mind consensus --propose "task"
+```
+
+---
+
+## Performance Targets
+
+| Metric | Target | Status |
+|--------|--------|--------|
+| HNSW Search | 150x-12,500x faster | ✅ Implemented |
+| Memory Reduction | 50-75% | ✅ Implemented (3.92x) |
+| SONA Integration | Pattern learning | ✅ Implemented |
+| Flash Attention | 2.49x-7.47x | 🔄 In Progress |
+| MCP Response | <100ms | ✅ Achieved |
+| CLI Startup | <500ms | ✅ Achieved |
+| SONA Adaptation | <0.05ms | 🔄 In Progress |
+| Graph Build (1k) | <200ms | ✅ 2.78ms (71.9x headroom) |
+| PageRank (1k) | <100ms | ✅ 12.21ms (8.2x headroom) |
+| Insight Recording | <5ms/each | ✅ 0.12ms (41x headroom) |
+| Consolidation | <500ms | ✅ 0.26ms (1,955x headroom) |
+| Knowledge Transfer | <100ms | ✅ 1.25ms (80x headroom) |
+
+---
+
+## Integration Ecosystem
+
+### Integrated Packages
+| Package | Version | Purpose |
+|---------|---------|---------|
+| agentic-flow | 3.0.0-alpha.1 | Core coordination + ReasoningBank + Router |
+| agentdb | 3.0.0-alpha.10 | Vector database + 8 controllers |
+| @ruvector/attention | 0.1.3 | Flash attention |
+| @ruvector/sona | 0.1.5 | Neural learning |
+
+### Optional Integrations
+| Package | Command |
+|---------|---------|
+| ruv-swarm | `npx ruv-swarm mcp start` |
+| flow-nexus | `npx flow-nexus@latest mcp start` |
+| agentic-jujutsu | `npx agentic-jujutsu@latest` |
+
+### MCP Server Setup
+```bash
+# Add Ruflo MCP
+claude mcp add ruflo -- npx -y ruflo@latest
+
+# Optional servers
+claude mcp add ruv-swarm -- npx -y ruv-swarm mcp start
+claude mcp add flow-nexus -- npx -y flow-nexus@latest mcp start
+```
+
+---
+
+## Quick Reference
+
+### Essential Commands
+```bash
+# Setup
+npx ruflo@latest init --wizard
+npx ruflo@latest daemon start
+npx ruflo@latest doctor --fix
+
+# Swarm
+npx ruflo@latest swarm init --topology hierarchical --max-agents 8
+npx ruflo@latest swarm status
+
+# Agents
+npx ruflo@latest agent spawn -t coder
+npx ruflo@latest agent list
+
+# Memory
+npx ruflo@latest memory search --query "patterns"
+
+# Hooks
+npx ruflo@latest hooks pre-task --description "task"
+npx ruflo@latest hooks worker dispatch --trigger optimize
+```
+
+### File Structure
+```
+.claude-flow/
+├── config.yaml      # Runtime configuration
+├── CAPABILITIES.md  # This file
+├── data/            # Memory storage
+├── logs/            # Operation logs
+├── sessions/        # Session state
+├── hooks/           # Custom hooks
+├── agents/          # Agent configs
+└── workflows/       # Workflow templates
+```
+
+---
+
+**Full Documentation**: https://github.com/ruvnet/claude-flow
+**Issues**: https://github.com/ruvnet/claude-flow/issues

.claude-flow/config.yaml

@@ -0,0 +1,43 @@
+# RuFlo V3 Runtime Configuration
+# Generated: 2026-05-19T00:18:20.863Z
+
+version: "3.0.0"
+
+swarm:
+  topology: hierarchical-mesh
+  maxAgents: 15
+  autoScale: true
+  coordinationStrategy: consensus
+
+memory:
+  backend: hybrid
+  enableHNSW: true
+  persistPath: .claude-flow/data
+  cacheSize: 100
+  # ADR-049: Self-Learning Memory
+  learningBridge:
+    enabled: true
+    sonaMode: balanced
+    confidenceDecayRate: 0.005
+    accessBoostAmount: 0.03
+    consolidationThreshold: 10
+  memoryGraph:
+    enabled: true
+    pageRankDamping: 0.85
+    maxNodes: 5000
+    similarityThreshold: 0.8
+  agentScopes:
+    enabled: true
+    defaultScope: project
+
+neural:
+  enabled: true
+  modelPath: .claude-flow/neural
+
+hooks:
+  enabled: true
+  autoExecute: true
+
+mcp:
+  autoStart: false
+  port: 3000

.claude-flow/metrics/learning.json

@@ -0,0 +1,17 @@
+{
+  "initialized": "2026-05-19T00:18:20.864Z",
+  "routing": {
+    "accuracy": 0,
+    "decisions": 0
+  },
+  "patterns": {
+    "shortTerm": 0,
+    "longTerm": 0,
+    "quality": 0
+  },
+  "sessions": {
+    "total": 0,
+    "current": null
+  },
+  "_note": "Intelligence grows as you use Ruflo"
+}

.claude-flow/metrics/swarm-activity.json

@@ -0,0 +1,18 @@
+{
+  "timestamp": "2026-05-19T00:18:20.864Z",
+  "processes": {
+    "agentic_flow": 0,
+    "mcp_server": 0,
+    "estimated_agents": 0
+  },
+  "swarm": {
+    "active": false,
+    "agent_count": 0,
+    "coordination_active": false
+  },
+  "integration": {
+    "agentic_flow_active": false,
+    "mcp_active": false
+  },
+  "_initialized": true
+}

.claude-flow/metrics/v3-progress.json

@@ -0,0 +1,26 @@
+{
+  "version": "3.0.0",
+  "initialized": "2026-05-19T00:18:20.864Z",
+  "domains": {
+    "completed": 0,
+    "total": 5,
+    "status": "INITIALIZING"
+  },
+  "ddd": {
+    "progress": 0,
+    "modules": 0,
+    "totalFiles": 0,
+    "totalLines": 0
+  },
+  "swarm": {
+    "activeAgents": 0,
+    "maxAgents": 15,
+    "topology": "hierarchical-mesh"
+  },
+  "learning": {
+    "status": "READY",
+    "patternsLearned": 0,
+    "sessionsCompleted": 0
+  },
+  "_note": "Metrics will update as you use Ruflo. Run: npx ruflo@latest daemon start"
+}

.claude-flow/security/audit-status.json

@@ -0,0 +1,8 @@
+{
+  "initialized": "2026-05-19T00:18:20.864Z",
+  "status": "PENDING",
+  "cvesFixed": 0,
+  "totalCves": 3,
+  "lastScan": null,
+  "_note": "Run: npx @claude-flow/cli@latest security scan"
+}

.gitignore

@@ -8,6 +8,10 @@
 data/
 .claude/
 
+# ruflo runtime state
+agentdb.rvf
+agentdb.rvf.lock
+
 # IDE project files
 .idea/
 

.mcp.json

@@ -0,0 +1,22 @@
+{
+  "mcpServers": {
+    "ruflo": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "ruflo@latest",
+        "mcp",
+        "start"
+      ],
+      "env": {
+        "npm_config_update_notifier": "false",
+        "CLAUDE_FLOW_MODE": "v3",
+        "CLAUDE_FLOW_HOOKS_ENABLED": "true",
+        "CLAUDE_FLOW_TOPOLOGY": "hierarchical-mesh",
+        "CLAUDE_FLOW_MAX_AGENTS": "15",
+        "CLAUDE_FLOW_MEMORY_BACKEND": "hybrid"
+      },
+      "autoStart": false
+    }
+  }
+}

deploy/kustomization.yaml

@@ -20,4 +20,4 @@ resources:
 images:
 - name: solitaire-server
   newName: git.aleshym.co/funman300/solitaire-server
-  newTag: eb6c93fb
+  newTag: 83c40116

solitaire_engine/src/animation_plugin.rs

@@ -72,6 +72,17 @@ const TIME_ATTACK_TOAST_SECS: f32 = 5.0;
 const CHALLENGE_TOAST_SECS: f32 = 3.0;
 const VOLUME_TOAST_SECS: f32 = 1.4;
 
+/// Z added to a card's render depth while its `CardAnim` is in-flight.
+///
+/// Foundation and tableau cards share x,y during the slide (destination equals
+/// a slot that already holds a card). Without this lift the incoming card's
+/// bottom-right corner overlaps the stationary card's top-left, which the
+/// player perceives as a single card with mismatched rank/suit indices.
+///
+/// 50.0 sits comfortably above the highest pile depth (~1.04) and well below
+/// `DRAG_Z` (500), so a dragged card always renders above an animated one.
+const CARD_ANIM_Z_LIFT: f32 = 50.0;
+
 /// Per-card stagger interval for the win cascade at Normal speed (seconds).
 ///
 /// Sourced from `ui_theme::MOTION_CASCADE_STAGGER_SECS` so all motion timing
@@ -254,7 +265,11 @@ fn advance_card_anims(
         // shared `CardAnim` struct stays a simple linear-tween container — the
         // upgrade is one extra `sample_curve` call per advancing animation.
         let s = sample_curve(MotionCurve::SmoothSnap, t);
-        transform.translation = anim.start.lerp(anim.target, s);
+        let mut pos = anim.start.lerp(anim.target, s);
+        // Elevate z during transit so the moving card always renders in front
+        // of any card already resting at the destination position.
+        pos.z = anim.target.z + CARD_ANIM_Z_LIFT;
+        transform.translation = pos;
         if t >= 1.0 {
             transform.translation = anim.target;
             commands.entity(entity).remove::<CardAnim>();

solitaire_engine/src/card_plugin.rs

@@ -178,8 +178,8 @@ pub struct CardLabel;
 /// readable at phone scale. Only exists when `CardImageSet` is present
 /// (the fallback solid-colour path uses a plain `CardLabel` instead).
 #[cfg(target_os = "android")]
-#[derive(Component, Debug, Clone, Copy)]
+#[derive(Component, Debug, Clone)]
-struct AndroidCornerLabel;
+struct AndroidCornerLabel(pub String);
 
 /// Solid-colour background sprite behind [`AndroidCornerLabel`].
 ///
@@ -707,15 +707,20 @@ fn sync_cards(
             .map(|c| c.id)
     };
 
-    // Map card_id -> (Entity, current_translation, has_card_animation) for
+    // Map card_id -> (Entity, current_translation, anim_end) for in-place
-    // in-place updates. The `has_card_animation` flag lets `update_card_entity`
+    // updates.  `anim_end` is `Some(end_xy)` when a curve-based `CardAnimation`
-    // skip the snap/slide path on cards that are already being driven by a
+    // is currently driving the card (e.g. a drag-rejection return tween).
-    // curve-based `CardAnimation` tween (e.g. the drag-rejection return tween
+    //
-    // — see `input_plugin::end_drag`). Otherwise the StateChangedEvent that
+    // In the position loop below we compare `anim_end` against the new game-
-    // accompanies a rejection would race the tween and the card would jump.
+    // state target position to decide whether to honour or cancel the tween:
-    let mut existing: HashMap<u32, (Entity, Vec3, bool)> = HashMap::new();
+    //   • end ≈ target  → animation is still heading to the right place; let
+    //                      it finish (skip the snap/slide path).
+    //   • end ≠ target  → the game state has changed (e.g. a new game started
+    //                      while the win-cascade was mid-flight); cancel the
+    //                      stale `CardAnimation` and apply the new position.
+    let mut existing: HashMap<u32, (Entity, Vec3, Option<Vec2>)> = HashMap::new();
     for (entity, marker, transform, anim) in entities.iter() {
-        existing.insert(marker.card_id, (entity, transform.translation, anim.is_some()));
+        existing.insert(marker.card_id, (entity, transform.translation, anim.map(|a| a.end)));
     }
 
     let live_ids: HashSet<u32> = positions.iter().map(|(c, _, _)| c.id).collect();
@@ -732,7 +737,19 @@ fn sync_cards(
     // behind the incoming top card during the draw slide animation.
     for (card, position, z) in positions {
         let entity = match existing.get(&card.id) {
-            Some(&(entity, cur, has_anim)) => {
+            Some(&(entity, cur, anim_end)) => {
+                // If a CardAnimation is in flight, check whether its destination
+                // still matches the game-state target.  If the game moved the card
+                // elsewhere (e.g. new game started during a win-cascade scatter),
+                // cancel the stale tween so the card snaps/slides to its new home.
+                let has_anim = match anim_end {
+                    Some(end_xy) if (end_xy - position).length() > 2.0 => {
+                        commands.entity(entity).remove::<CardAnimation>();
+                        false
+                    }
+                    Some(_) => true,
+                    None => false,
+                };
                 update_card_entity(
                     &mut commands, entity, card, position, z, layout,
                     slide_secs, back_colour, color_blind, high_contrast, cur, has_anim, card_images, selected_back, font_handle,
@@ -1142,10 +1159,11 @@ fn add_android_corner_label(
     // Large rank+suit text drawn on top of the background. FiraMono must be
     // wired here explicitly — the suit glyphs (U+2660–U+2666) are not in
     // Bevy's built-in font and render as a coloured rectangle without it.
+    let label_text = mobile_label_for(card);
     parent.spawn((
-        AndroidCornerLabel,
+        AndroidCornerLabel(label_text.clone()),
         CardLabel,
-        Text2d::new(mobile_label_for(card)),
+        Text2d::new(label_text),
         TextFont {
             font: font_handle.cloned().unwrap_or_default(),
             font_size,
@@ -2089,7 +2107,7 @@ fn resize_cards_in_place(
 fn resize_android_corner_labels(
     layout: Res<LayoutResource>,
     card_images: Option<Res<CardImageSet>>,
-    mut text_query: Query<(&mut TextFont, &mut Transform), With<AndroidCornerLabel>>,
+    mut text_query: Query<(&AndroidCornerLabel, &mut Text2d, &mut TextFont, &mut Transform)>,
     mut bg_query: Query<
         (&mut Sprite, &mut Transform),
         (With<AndroidCornerBg>, Without<AndroidCornerLabel>),
@@ -2105,7 +2123,8 @@ fn resize_android_corner_labels(
     let text_x = -layout.0.card_size.x / 2.0 + inset;
     let text_y = layout.0.card_size.y / 2.0 - inset;
 
-    for (mut font, mut transform) in text_query.iter_mut() {
+    for (label, mut text2d, mut font, mut transform) in text_query.iter_mut() {
+        text2d.0 = label.0.clone();
         font.font_size = font_size;
         transform.translation.x = text_x;
         transform.translation.y = text_y;

solitaire_engine/src/leaderboard_plugin.rs

@@ -1159,9 +1159,23 @@ mod tests {
             .spawn(async { Err::<(), String>("network error".to_string()) });
         app.world_mut().resource_mut::<OptInTask>().0 = Some(failed_task);
 
-        // Allow the task to complete and be polled.
+        // Pump until the task is polled or a deadline elapses.  A fixed
-        for _ in 0..5 {
+        // update count is unreliable under parallel `cargo test --workspace`
+        // load — the AsyncComputeTaskPool background threads can be starved
+        // long enough that 5 updates finish before the task completes.
+        // Mirrors the deadline-loop pattern used in sync_plugin tests.
+        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
+        loop {
             app.update();
+            let msgs = app.world().resource::<Messages<WarningToastEvent>>();
+            let mut cursor = msgs.get_cursor();
+            if cursor.read(msgs).next().is_some() {
+                break;
+            }
+            if std::time::Instant::now() >= deadline {
+                break;
+            }
+            std::thread::yield_now();
         }
 
         let msgs = app.world().resource::<Messages<WarningToastEvent>>();
@@ -1183,8 +1197,19 @@ mod tests {
             .spawn(async { Err::<(), String>("network error".to_string()) });
         app.world_mut().resource_mut::<OptOutTask>().0 = Some(failed_task);
 
-        for _ in 0..5 {
+        // Deadline-bounded pump — see opt_in_error_fires_warning_toast for rationale.
+        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
+        loop {
             app.update();
+            let msgs = app.world().resource::<Messages<WarningToastEvent>>();
+            let mut cursor = msgs.get_cursor();
+            if cursor.read(msgs).next().is_some() {
+                break;
+            }
+            if std::time::Instant::now() >= deadline {
+                break;
+            }
+            std::thread::yield_now();
         }
 
         let msgs = app.world().resource::<Messages<WarningToastEvent>>();
@@ -1210,8 +1235,22 @@ mod tests {
         let ok_task = AsyncComputeTaskPool::get().spawn(async { Ok::<(), String>(()) });
         app.world_mut().resource_mut::<OptInTask>().0 = Some(ok_task);
 
-        for _ in 0..5 {
+        // Deadline-bounded pump — see opt_in_error_fires_warning_toast for rationale.
+        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
+        loop {
             app.update();
+            if app
+                .world()
+                .resource::<SettingsResource>()
+                .0
+                .leaderboard_opted_in
+            {
+                break;
+            }
+            if std::time::Instant::now() >= deadline {
+                break;
+            }
+            std::thread::yield_now();
         }
 
         assert!(
@@ -1237,8 +1276,22 @@ mod tests {
         let ok_task = AsyncComputeTaskPool::get().spawn(async { Ok::<(), String>(()) });
         app.world_mut().resource_mut::<OptOutTask>().0 = Some(ok_task);
 
-        for _ in 0..5 {
+        // Deadline-bounded pump — see opt_in_error_fires_warning_toast for rationale.
+        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
+        loop {
             app.update();
+            if !app
+                .world()
+                .resource::<SettingsResource>()
+                .0
+                .leaderboard_opted_in
+            {
+                break;
+            }
+            if std::time::Instant::now() >= deadline {
+                break;
+            }
+            std::thread::yield_now();
         }
 
         assert!(

solitaire_server/web/game.js

@@ -300,6 +300,7 @@ function render(s) {
     board.querySelectorAll(".card.drop-target").forEach(e => e.classList.remove("drop-target"));
 
     if (s.is_auto_completable && !s.is_won && !acTimer) {
+        stopTimer(); // freeze elapsed time at the moment the player's last move completes
         acTimer = setInterval(doAutoCompleteStep, 380);
     }
     if (s.is_won) {

solitaire_server/web/pkg/solitaire_wasm.js

@@ -40,20 +40,32 @@ export class ReplayPlayer {
     }
     /**
      * 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);
-        return ret;
+        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 a JS string exception on serialisation failure.
      * @returns {any}
      */
     step() {
         const ret = wasm.replayplayer_step(this.__wbg_ptr);
-        return ret;
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
      * 0-indexed position of the next move to apply.
@@ -157,11 +169,16 @@ export class SolitaireGame {
     }
     /**
      * 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);
-        return ret;
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
      * Undo the last move. Returns `{ok, error?, snapshot?}`.
@@ -180,6 +197,13 @@ function __wbg_get_imports() {
             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));
         },