0.3.0-0-pre.1

Cargo.toml

@@ -1,5 +1,5 @@
 # file: Cargo.toml
-# version: 57
+# version: 58
 
 [workspace]
 resolver = "3"
@@ -19,7 +19,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.2.0"
+version = "0.3.0-0-pre.1"
 edition = "2024"
 license = "MIT"
 repository = "https://git.sasedev.com/Sasedev/games"

README.md

@@ -1,5 +1,5 @@
 <!-- file: README.md -->
-<!-- version: 25 -->
+<!-- version: 26 -->
 
 # games.sasedev
 
@@ -23,9 +23,9 @@ Workspace expérimental puis productif pour des jeux multiplateformes principale
 
 ## Baseline
 
-Version stable de référence : `0.1.0`.
+Version stable de référence : `0.2.0`.
 
-Version candidate en cours de conception : `0.2.0`.
+Version de développement : `0.3.0-0-pre.1`.
 
 Les deux premiers jeux sont des POC structurels : `game-reflex-poc` et `game-snake-poc`. Ils existent d'abord pour valider les frontières du workspace, le moteur, les assets et le packaging multiplateforme.
 

ROADMAP.md

@@ -1,5 +1,5 @@
 <!-- file: ROADMAP.md -->
-<!-- version: 19 -->
+<!-- version: 20 -->
 
 # Roadmap
 
@@ -26,11 +26,31 @@ Le détail historique des prereleases `0.1.0-*` reste dans `deltas/0.1.0/` et `h
 
 - (x) `0.2.0` — fixer la gouvernance documentaire, la nomenclature et le cycle de maturation des idées et décisions.
 - (x) `0.2.0` — inventorier et réserver les capabilities déjà justifiées sans les implémenter prématurément.
-- ( ) `0.2.0` — définir les couches, les dépendances autorisées et la frontière entre kernel, capability, plateforme, provider, système de jeu et service.
+- (x) `0.2.0` — définir les couches, les dépendances autorisées et la frontière entre kernel, capability, plateforme, provider, système de jeu et service.
-- ( ) `0.2.0` — établir la matrice plateformes et les archétypes de jeux utilisés pour challenger l'architecture.
+- (x) `0.2.0` — établir la matrice plateformes et les archétypes de jeux utilisés pour challenger l'architecture.
-- ( ) `0.2.0` — définir le modèle de composition statique, le manifest produit/jeu et l'architecture cible des crates.
+- (x) `0.2.0` — retenir la composition Rust statique comme direction de référence.
-- ( ) `0.2.0` — définir la trajectoire d'implémentation progressive des versions suivantes seulement après revue de la conception.
+- (d) `0.2.0` — figer un manifest produit/jeu et l'architecture physique définitive des crates → target TBD après observation des POC `0.3.x`.
+- (x) `0.2.0` — définir la trajectoire d'implémentation progressive `0.3.x` POC puis `0.4.x` Uroburas.
 - (x) `0.2.0` — consolider les études acceptées en architecture/règles durables, notamment ownership, réseau, Uroburas et POC, puis fermer les points encore candidats.
 - (x) `0.2.0` — formaliser la stratégie réseau : Actix Web pour le Web/API, asset delivery auto-hébergé H2/H3, WebSocket baseline et WebTransport/QUIC candidat.
 - (x) `0.2.0` — préparer une trajectoire `0.3.x` dédiée aux POC plateforme/réseau avec Snake comme jeu-sonde.
 - (x) `0.2.0` — préparer la trajectoire `0.4.x` Uroburas Mode 1 et le prompt de session associé après gel de la conception.
+
+## 0.3.0 — Baseline Snake + premier POC Web direct
+
+- ( ) `0.3.0` — nettoyer la baseline Snake sans introduire de logique Uroburas et maintenir le runner Desktop SDL3 fonctionnel.
+- ( ) `0.3.0` — produire une adaptation WASM dédiée à Snake sans déplacer le gameplay hors de `game-snake-poc`.
+- ( ) `0.3.0` — réaliser un POC navigateur direct Snake couvrant clavier, boutons directionnels tactiles, resize, lifecycle, logging, assets et provenance runtime.
+- ( ) `0.3.0` — utiliser uniquement Cargo, `wasm-bindgen` et Vite/npm pour le chemin de build Web ; aucun script Python ne pilote ce build.
+- ( ) `0.3.0` — documenter les duplications observées, les extractions réellement justifiées et les reports avant promotion RC.
+
+## Série 0.3.x — trajectoire actuelle après 0.3.0
+
+- ( ) `0.3.1` — second host Snake : Tauri Android, en réutilisant la baseline Web/WASM validée et en remplaçant toute orchestration Python du chemin touché.
+- ( ) `0.3.2` — Tauri Desktop + Snake et factorisation WebView uniquement lorsque deux consommateurs réels justifient l'extraction.
+- ( ) `0.3.3` — Android SDL natif multi-ABI avec Cargo/Gradle natifs, sans script Python de build.
+- ( ) `0.3.4` — API de transport realtime + WebSocket/tokio-tungstenite baseline, sans serveur Uroburas Mode 3.
+- ( ) `0.3.5` — POC WebTransport/QUIC sur le même protocole, avec comparaison mesurée et fallback WebSocket.
+- ( ) `0.3.6` — consolidation des POC plateforme/réseau et préparation de la baseline `0.4.x`.
+
+La numérotation `0.3.1+` reste révisable à partir des résultats réels ; les lignes ci-dessus décrivent le planning actuel, pas une obligation de créer des versions artificielles.

deltas/0.3.0/0-pre.1.md

@@ -0,0 +1,157 @@
+<!-- file: deltas/0.3.0/0-pre.1.md -->
+<!-- version: 1 -->
+
+# Delta 0.3.0-0-pre.1
+
+## Base
+
+Base déclarée : `0.2.0`.
+
+L'archive de base a été inspectée avant modification. Sa version workspace est `0.2.0`. L'archive ne contient pas `.git`, donc le tag réel et la propreté Git ne peuvent pas être vérifiés dans l'environnement de génération.
+
+## Objet
+
+Ouvrir `0.3.0` par le cadrage obligatoire : audit réel de la baseline, revue des règles, requirements Snake, graphe de dépendances, choix du premier POC, sizing corrigé et préparation des validations.
+
+Aucun gameplay, runtime SDL, Java/JNI, Tauri ou frontend existant n'est modifié dans cette tranche.
+
+## Version
+
+La version workspace passe de :
+
+```text
+0.2.0
+```
+
+à :
+
+```text
+0.3.0-0-pre.1
+```
+
+Les métadonnées Android restent à `0.2.0` dans cette tranche, car le chemin Android natif n'est ni modifié ni construit par le premier POC Web. Elles seront réévaluées dans la version qui réouvre effectivement ce produit Android.
+
+## Audit de baseline
+
+Les audits statiques officiels ont été exécutés avant modification et étaient propres :
+
+```text
+General Rust rule audit: clean
+Rust export completeness audit: 0 candidate(s)
+games.sasedev workspace audit: clean
+Markdown table audit: clean (4 table(s), 158 file(s))
+Distribution layout audit: clean (19 required path(s), 1 forbidden path(s) absent)
+```
+
+La revue manuelle a néanmoins détecté :
+
+- README encore positionné sur `0.1.0` stable / `0.2.0` candidate ;
+- quatre lignes `( )` sous la stable `0.2.0` dans ROADMAP, en violation de `DOC-RMAP-010` ;
+- la gate `audit_rust_workspace_rules.py` qui créait un cache Python `.pyc` pendant son exécution, alors qu’un audit doit rester en lecture seule ;
+- `CMD-RC-001` encore spécifique à `0.1.0` ;
+- contradiction entre `CMD-BUILD-002` (interdiction globale) et `CMD-BUILD-004` (remplacement progressif en `0.3.x`), alors que deux orchestrateurs Python historiques existent encore ;
+- `CMD-WEB-003` décrivant sans contexte le build Python Tauri/WASM historique ;
+- dépendances `engine-v1-platform-api` déclarées mais non utilisées par les crates de jeu ;
+- `RuntimeProvenance` défini mais non branché aux launchers ;
+- `game-assets-lib` encore sans consommateur runtime ;
+- deux orchestrateurs Python de build historiques à ne pas réutiliser dans les nouveaux POC.
+
+Les détails et le graphe complet sont documentés dans `docs/studies/023-V0_3_0_PLATFORM_POC_AUDIT.md`.
+
+## Corrections de règles et hygiène
+
+Cette tranche :
+
+- corrige le README de version ;
+- ferme correctement le scope `0.2.0` dans ROADMAP ;
+- distingue ce qui a été livré de ce qui est reporté ;
+- rend `CMD-RC-001` générique à la version courante ;
+- rend `CMD-BUILD-002` cohérente avec la migration `0.3.x` : les deux orchestrateurs Python historiques sont gelés jusqu’à réactivation de leur chemin, mais aucun nouveau chemin ne peut les reprendre ;
+- qualifie explicitement `scripts/build_reflex_tauri_wasm.py` de mécanisme historique non réutilisable comme orchestration `0.3.x` ;
+- renforce `audit_project_workspace_rules.py` pour détecter le scope `( )` restant sous une version stable présente dans CHANGELOG ;
+- fait exécuter les sous-audits de `audit_rust_workspace_rules.py` avec l’interpréteur courant et `-B`, afin que la gate standard reste effectivement en lecture seule malgré l’import effectué dans l’audit de complétude des exports.
+
+## Premier POC retenu
+
+Le premier host de `0.3.0` devient :
+
+```text
+Web navigateur direct + Snake
+```
+
+Tauri Android est reporté au second host, actuellement prévu en `0.3.1`.
+
+Le but est de valider d'abord la frontière Web/WASM et les capabilities directement observables sans cumuler simultanément la généralisation Snake/WASM et la complexité d'un host mobile Tauri.
+
+## Forecast corrigé
+
+```text
+0-pre.1  audit / règles / requirements / sizing
+0-pre.2  Snake portability baseline
+0-pre.3  adapter Snake WASM + build natif Web
+0-pre.4  navigateur direct end-to-end
+0-pre.5  seulement si un défaut réel est observé
+2-beta.1 validation large
+3-rc.1   candidate gelée
+0.3.0    release mécanique
+```
+
+Aucune alpha n'est créée par cérémonial. Elle reste possible si le volume réel de stabilisation le justifie.
+
+## Scope exclu de 0.3.0
+
+- Tauri Android ;
+- Tauri Desktop Snake ;
+- Android multi-ABI natif ;
+- réseau realtime ;
+- WebTransport/QUIC ;
+- Uroburas ;
+- ads, billing, auth et leaderboard ;
+- ECS ou nouveau moteur.
+
+## Suppressions
+
+Aucune suppression de fichier appartenant à la baseline `0.2.0` n'est nécessaire.
+
+## Validations exécutées dans l'environnement de génération
+
+Après constitution de l'état livré, les audits statiques suivants doivent être réexécutés et leur résultat est enregistré avant packaging :
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucun build/test/smoke n'est exécuté par le générateur, conformément à `CMD-GEN-007` et `CMD-BUILD-005`.
+
+## Validation utilisateur demandée
+
+Cette tranche ne modifie aucun source Rust/Java/TypeScript ni aucune configuration runtime. Elle ouvre toutefois une nouvelle version `0.3.0` et modifie le manifest workspace ; la gate utilisateur retient donc les audits statiques puis une gate Cargo workspace complète, conformément à la discipline des frontières de version :
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+
+cargo fmt --all -- --check
+cargo check --workspace
+cargo clippy --workspace --all-targets --all-features -- -D warnings
+cargo test --workspace --all-targets --all-features
+```
+
+Aucun build de distribution, smoke Desktop, Tauri ou Android n'est requis par `pre.1`, car aucun runtime ni packaging de ces hosts n'est modifié.
+
+La revue humaine doit confirmer :
+
+- le choix Web direct comme premier POC ;
+- le scope corrigé de `0.3.0` ;
+- le report de Tauri Android vers le second host ;
+- le sizing `pre.2` à `pre.4` ;
+- la fermeture correcte des lignes historiques `0.2.0`.
+
+## Suite après validation
+
+Si cette gate est propre et le cadrage accepté, passer automatiquement à `0.3.0-0-pre.2`.
+
+`pre.2` doit rester une tranche bornée de portabilité Snake et de nettoyage de dépendances ; elle ne doit pas commencer le frontend Web complet.

docs/rules/RULES_COMMANDS.md

@@ -1,5 +1,5 @@
 <!-- file: docs/rules/RULES_COMMANDS.md -->
-<!-- version: 9 -->
+<!-- version: 10 -->
 
 # Règles d'exécution des commandes
 
@@ -56,7 +56,7 @@
 
 - **CMD-WEB-001** — Aucun gestionnaire de paquets JavaScript ni build Web n'est exécuté tant qu'un frontend Web réel n'a pas été introduit dans le dépôt.
 - **CMD-WEB-002** — Lorsqu'une cible Web existe, ses commandes de build et test sont documentées avant d'être ajoutées aux gates.
-- **CMD-WEB-003** — Le POC Tauri/WASM utilise `scripts/build_reflex_tauri_wasm.py` pour WASM et Vite/TypeScript pour le frontend local ; aucun site distant n'est requis.
+- **CMD-WEB-003** — Le POC Tauri/WASM historique `0.1.0` utilise `scripts/build_reflex_tauri_wasm.py` ; ce script reste une référence de baseline mais ne doit pas être réutilisé comme orchestrateur par un POC `0.3.x`, conformément à `CMD-BUILD-004`.
 - **CMD-WEB-004** — Les fichiers produits par `wasm-bindgen` sont générés localement et ne sont pas commités.
 
 ## Git et fichiers générés
@@ -75,7 +75,7 @@
 
 ## RC et release
 
-- **CMD-RC-001** — L'entrée en RC gèle le périmètre fonctionnel de `0.1.0` ; seuls les correctifs, la reproductibilité des builds, le packaging, la documentation de livraison et les défauts de release sont admis.
+- **CMD-RC-001** — L'entrée en RC gèle le périmètre fonctionnel de la version courante ; seuls les correctifs, la reproductibilité des builds, le packaging, la documentation de livraison et les défauts de release sont admis.
 - **CMD-RC-002** — La validation d'une RC exécute `cargo test --workspace --all-targets --all-features` en plus des audits, du check et de Clippy strict.
 - **CMD-RC-003** — Les deux runners Desktop natifs sont construits en `--release` et font l'objet d'un smoke sur les binaires de release.
 - **CMD-RC-004** — Le POC Tauri est construit uniquement via `cargo tauri build`; ses hooks possèdent toujours le build WASM et Vite/TypeScript.
@@ -92,7 +92,7 @@
 ## Outils de build et scripts d'audit
 
 - **CMD-BUILD-001** — Les scripts Python du dépôt sont autorisés pour les audits, audits complémentaires, validations et validations complémentaires.
-- **CMD-BUILD-002** — Un script Python ne pilote pas le build d'un produit, d'une plateforme ou d'un package distribué.
+- **CMD-BUILD-002** — À partir de `0.3.x`, aucun chemin de build nouveau ou modifié n’est piloté par Python. Les orchestrateurs historiques `scripts/build_reflex_tauri_wasm.py` et `scripts/build_android_rust.py` restent tolérés uniquement comme mécanismes gelés de la baseline `0.1.0` jusqu’à la tranche qui réactive leur chemin ; ils ne sont ni copiés, ni généralisés, ni utilisés pour un nouveau POC.
 - **CMD-BUILD-003** — Les builds utilisent l'outil natif approprié au périmètre : Cargo pour Rust, Gradle pour Android, Tauri CLI pour Tauri, ou l'outil officiellement retenu par la plateforme concernée.
 - **CMD-BUILD-004** — Les POC `0.3.x` doivent remplacer toute orchestration de build Python restante par des procédures explicites, reproductibles et testées avec les outils natifs.
 - **CMD-BUILD-005** — Les builds, tests unitaires, tests d'intégration et smoke tests de validation sont exécutés côté utilisateur ; les scripts d'audit peuvent vérifier statiquement leur préparation mais ne les simulent pas.

docs/studies/000-README.md

@@ -1,5 +1,5 @@
 <!-- file: docs/studies/000-README.md -->
-<!-- version: 8 -->
+<!-- version: 9 -->
 
 # Études
 
@@ -53,3 +53,7 @@ Ces documents étudient les POC à réaliser ; ils ne lancent encore aucune impl
 - [`020-UROBURAS_CRATE_DECOMPOSITION_STUDY.md`](020-UROBURAS_CRATE_DECOMPOSITION_STUDY.md) — proposition de familles de crates et dépendances sans monolithe jeu.
 - [`021-UROBURAS_SERVER_REFERENCE_STACK.md`](021-UROBURAS_SERVER_REFERENCE_STACK.md) — stack serveur de référence Actix/Tokio/tokio-tungstenite/Maud/Fluent/Lettre et gRPC/Tonic conditionnel.
 - [`022-UROBURAS_IMPLEMENTATION_DEPENDENCY_ORDER.md`](022-UROBURAS_IMPLEMENTATION_DEPENDENCY_ORDER.md) — ordre d'implémentation recommandé pour le Mode 1 avant les modes multijoueurs.
+
+## Étude de cadrage 0.3.0
+
+- [`023-V0_3_0_PLATFORM_POC_AUDIT.md`](023-V0_3_0_PLATFORM_POC_AUDIT.md) — audit réel de la baseline `0.2.0`, requirements Snake, graphe de dépendances, choix du premier POC et sizing corrigé de `0.3.0`.

docs/studies/023-V0_3_0_PLATFORM_POC_AUDIT.md

@@ -0,0 +1,354 @@
+<!-- file: docs/studies/023-V0_3_0_PLATFORM_POC_AUDIT.md -->
+<!-- version: 1 -->
+
+# 0.3.0 — audit de baseline et cadrage du premier POC plateforme
+
+## Statut
+
+Étude de cadrage pour `0.3.0-0-pre.1`.
+
+Elle décrit l'état observé de la stable `0.2.0`, les requirements réellement nécessaires à Snake, le premier POC retenu et le sizing corrigé. Elle ne transforme pas encore les extractions candidates en architecture durable.
+
+## Base inspectée
+
+Base déclarée : tag stable `v0.2.0`, fourni sous forme d'archive `games-v0.2.0.zip`.
+
+L'intégrité ZIP est propre. L'archive ne contient pas `.git` : l'état du commit, le tag effectif et la propreté du working tree ne peuvent donc pas être vérifiés dans cet environnement.
+
+La version workspace observée avant modification est `0.2.0`.
+
+## Audits officiels exécutés sur la baseline
+
+Les audits en lecture seule suivants passent sur la baseline telle que livrée :
+
+```text
+General Rust rule audit: clean
+Rust export completeness audit: 0 candidate(s)
+games.sasedev workspace audit: clean
+Markdown table audit: clean (4 table(s), 158 file(s))
+Distribution layout audit: clean (19 required path(s), 1 forbidden path(s) absent)
+```
+
+Ces résultats valident uniquement les contrôles mécaniques réellement couverts par les scripts. La revue manuelle des règles a détecté des écarts supplémentaires.
+
+## Écarts de baseline détectés
+
+### README de version obsolète
+
+`README.md` annonce encore `0.1.0` comme stable et `0.2.0` comme candidate alors que l'archive est la stable `0.2.0`.
+
+Correction dans `0-pre.1` : afficher `0.2.0` comme stable de référence et `0.3.0-0-pre.1` comme version de développement.
+
+### ROADMAP stable non fermé
+
+`ROADMAP.md` conserve quatre lignes `( )` sous `0.2.0`. Cela contredit `DOC-RMAP-010`, qui interdit du scope encore planifié sous une version stable clôturée.
+
+La revue du contenu `0.2.0` montre que :
+
+- layering et dépendances ont été couverts par les études puis l'architecture consolidée ;
+- matrice plateforme et pressure tests ont été produits ;
+- la composition Rust statique a été retenue ;
+- le manifest produit/jeu et l'architecture physique définitive des crates ne sont volontairement pas figés ;
+- la trajectoire `0.3.x` puis `0.4.x` a été définie.
+
+Correction dans `0-pre.1` : fermer les lignes réellement livrées et marquer explicitement le manifest/shape physique définitif comme reporté.
+
+### Effet de bord de la gate d'audit Python
+
+Le ZIP `v0.2.0` ne contient aucun `__pycache__` ni fichier `.pyc`. En revanche, l'exécution de `scripts/audit_rust_workspace_rules.py` sur la baseline crée `scripts/__pycache__/audit_rust_general_rules.cpython-313.pyc` : `audit_rust_export_completeness.py` importe `audit_rust_general_rules.py` dans un sous-processus Python standard.
+
+Cela contredit l'intention de `CMD-GEN-006`, selon laquelle les audits sont des contrôles en lecture seule. Correction dans `0-pre.1` : le wrapper exécute désormais ses trois sous-audits avec l'interpréteur courant et `-B`, ce qui supprime cet effet de bord sans modifier les audits eux-mêmes. Une réexécution complète confirme qu'aucun cache Python n'est créé.
+
+### Règle RC encore spécifique à 0.1.0
+
+`CMD-RC-001` parle encore du gel fonctionnel de `0.1.0`. La règle est générale et doit viser la version courante.
+
+Correction dans `0-pre.1` : formulation générique.
+
+### Build Python historique et cohérence normative
+
+La revue des règles révèle une contradiction dans `0.2.0` : `CMD-BUILD-002` interdisait globalement qu’un script Python pilote un build, tandis que `CMD-BUILD-004` demandait précisément aux POC `0.3.x` de remplacer les orchestrateurs Python encore présents. La baseline conserve effectivement deux chemins historiques qui les utilisent.
+
+Deux scripts historiques pilotent encore des builds :
+
+- `scripts/build_reflex_tauri_wasm.py` ;
+- `scripts/build_android_rust.py`.
+
+Le premier est encore appelé par les hooks Tauri Reflex. Le second orchestre `cargo ndk`, l'extraction SDL3 depuis l'AAR et le staging `jniLibs`.
+
+Ils appartiennent à la baseline validée `0.1.0`, mais un POC `0.3.x` ne doit pas les reprendre comme mécanisme de build. `CMD-BUILD-002` est rendue cohérente avec cette migration : les deux orchestrateurs sont explicitement tolérés uniquement comme baseline gelée jusqu’à la réactivation du chemin concerné. `CMD-WEB-003` qualifie également le script Tauri/WASM comme historique. Les remplacements sont réalisés lorsque le chemin concerné devient actif : Web direct en `0.3.0`, Tauri Android/Desktop dans les versions correspondantes et Android natif multi-ABI dans sa tranche dédiée.
+
+## Contraintes de l'environnement courant
+
+L'environnement d'inspection dispose de :
+
+```text
+Python 3.13.5
+Node.js v22.16.0
+npm 10.9.2
+OpenJDK 21
+```
+
+Il ne dispose pas de :
+
+```text
+cargo
+rustc
+rustup
+gradle
+wasm-bindgen
+cargo-ndk
+Tauri CLI
+```
+
+L'archive ne contient pas de Gradle Wrapper et ne vend pas l'AAR SDL3, conformément à la baseline Android actuelle.
+
+Conséquence : seuls les audits statiques et inspections de fichiers sont exécutables ici. Les builds, tests et smokes restent à exécuter par l'utilisateur conformément à `CMD-BUILD-005`.
+
+## Inventaire Snake et hosts existants
+
+### Gameplay Snake
+
+`game-snake-poc` possède déjà :
+
+- un état déterministe indépendant de SDL, Android, Tauri et Web ;
+- des directions sémantiques `Left/Right/Up/Down` via `InputState` ;
+- une cadence de déplacement interne ;
+- collision mur/corps ;
+- score et nourriture ;
+- rendu sous forme de `EngineScene` normalisée.
+
+Le jeu ne consomme aucun symbole de `engine-v1-platform-api`, bien que cette dépendance soit encore déclarée dans son manifest. La même déclaration inutilisée existe dans `game-reflex-poc`. Cette dette est à nettoyer avant le premier adapter Web.
+
+### Desktop SDL3
+
+`engine-v1-sdl` fournit déjà :
+
+- fenêtre redimensionnable ;
+- clavier directionnel ;
+- pointeur normalisé ;
+- swipe tactile/souris ;
+- quit par fermeture, Escape et Back plateforme ;
+- rendu de rectangles normalisés ;
+- boucle fixed-step de 16 ms utilisée par les runners.
+
+Le runner Snake Desktop compose correctement gameplay, SDL, logging et capacité plateforme désactivée. Il reste la baseline de non-régression pour `0.3.0`.
+
+### Android SDL3 / Java / JNI
+
+La baseline possède :
+
+- `SaseGameActivity` commune dérivée de `SDLActivity` ;
+- un bridge JNI versionné ;
+- un `cdylib` Rust commun sélectionnant Reflex ou Snake par feature ;
+- tactile transporté par SDL3 ;
+- observation Back Android 16 non consommatrice ;
+- staging Gradle des assets ;
+- configuration NDK centralisée.
+
+Le chemin build Rust Android reste toutefois orchestré par Python et n'est pas réutilisé par le premier POC `0.3.0`.
+
+### Référence Tauri/WASM Reflex
+
+La référence Reflex valide déjà plusieurs conventions utiles :
+
+- crate WASM distincte de la crate Tauri ;
+- `lib.rs` Tauri limité à la façade/réexport ;
+- `tauri.rs` propriétaire de l'assemblage et des commandes ;
+- frontend Vite/TypeScript dans la crate Tauri ;
+- tracing frontend relayé vers Rust ;
+- canvas redimensionné selon le viewport et le device pixel ratio.
+
+Les APIs WASM et le frontend restent cependant Reflex-specific. Elles sont des références à adapter, pas du code générique à copier aveuglément.
+
+## Graphe de dépendances local observé
+
+```text
+engine-v1-common
+
+engine-v1-platform-api
+
+engine-v1-sdl
+    -> engine-v1-common
+
+game-snake-poc
+    -> engine-v1-common
+    -> engine-v1-platform-api    [déclarée, non utilisée]
+
+game-reflex-poc
+    -> engine-v1-common
+    -> engine-v1-platform-api    [déclarée, non utilisée]
+
+game-snake-poc-desktop
+    -> game-snake-poc
+    -> engine-v1-common
+    -> engine-v1-platform-api
+    -> engine-v1-sdl
+    -> game-logging-lib
+
+game-android-entrypoint
+    -> engine-v1-common
+    -> engine-v1-sdl
+    -> game-logging-lib
+    -> game-snake-poc / game-reflex-poc via features
+
+game-reflex-poc-wasm
+    -> engine-v1-common
+    -> game-reflex-poc
+
+game-reflex-poc-tauri Rust
+    -> engine-v1-platform-api
+    -> game-logging-lib
+
+frontend Reflex Tauri
+    -> bindings générés game-reflex-poc-wasm
+
+game-assets-lib
+    -> aucun consommateur runtime actuel
+```
+
+Le graphe confirme que gameplay Snake et host peuvent être séparés sans créer un nouveau moteur.
+
+## Requirements du premier POC Snake
+
+| Besoin                         | Baseline réelle                                                                     | Décision 0.3.0                                                                                         |
+|--------------------------------|-------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------|
+| Input clavier                  | SDL oui ; Web Snake absent                                                          | adapter clavier Web vers `GameAction`                                                                  |
+| Boutons directionnels tactiles | absent                                                                              | quatre contrôles virtuels Web vers `GameAction`                                                        |
+| Viewport / resize              | SDL oui ; Reflex Web oui                                                            | réutiliser le principe canvas responsive sans coupler Snake à Tauri                                    |
+| Lifecycle                      | quit minimal ; pas de lifecycle Web générique                                       | pause des ticks sur `visibilitychange`, reprise contrôlée, sortie/navigation host-specific             |
+| Runtime provenance             | type présent mais non consommé                                                      | instancier une provenance Browser/WASM et refléter le profil d'input réellement utilisé                |
+| Assets                         | sources + resolver/staging présents ; aucun runtime ne charge actuellement les JSON | valider le packaging/chargement de `common` et `game` dans le POC Web                                  |
+| Logging                        | tracing natif ; bridge Tauri Reflex                                                 | logging Web local distinct de Tauri, sans dupliquer la logique gameplay                                |
+| WASM bridge                    | Reflex-specific                                                                     | créer un adapter Snake dédié ; n'extraire un bridge générique qu'après duplication réellement observée |
+| Tauri bridge                   | Reflex Desktop uniquement                                                           | hors scope `0.3.0`                                                                                     |
+| Android packaging              | SDL/Java/JNI existant                                                               | hors scope `0.3.0`                                                                                     |
+| Multi-ABI                      | script historique supportant plusieurs ABI                                          | hors scope `0.3.0`, remplacement natif prévu plus tard                                                 |
+
+## Duplications et extractions candidates
+
+Duplications déjà visibles :
+
+- runners Desktop Reflex/Snake très proches ;
+- activities Android spécifiques volontairement minimales ;
+- future exposition de `EngineScene` en WASM susceptible de répéter l'adapter Reflex ;
+- shell frontend Canvas/input susceptible d'être commun au Web direct et à Tauri.
+
+Décision : ne pas extraire un runner générique, un bridge WASM générique ou un shell Web commun dans `pre.1`. Le premier second consommateur réel décide de l'extraction.
+
+## Choix du premier POC
+
+Le premier POC de `0.3.0` est :
+
+```text
+Web navigateur direct + Snake
+```
+
+Le choix initial Tauri Android est reporté au second host, actuellement `0.3.1`.
+
+Raisons :
+
+- le Web direct exerce déjà WASM, keyboard/touch, resize, lifecycle, assets et provenance ;
+- la référence Reflex fournit un précédent WASM/Canvas sans imposer Tauri ;
+- Tauri Android ajouterait simultanément un nouveau gameplay WASM, un nouveau host mobile Tauri, le lifecycle mobile, le packaging Android Tauri et les plugins ;
+- la baseline Web obtenue devient ensuite un point de comparaison et de réutilisation pour Tauri Android ;
+- ce découpage réduit le risque de créer trop tôt une abstraction Tauri/Web commune sur la seule base de Reflex.
+
+## Scope corrigé de 0.3.0
+
+Inclus :
+
+- correction des écarts de baseline détectés en `pre.1` ;
+- nettoyage host-neutral de Snake ;
+- maintien du runner Desktop SDL3 ;
+- adapter WASM Snake dédié ;
+- frontend Web direct Vite/TypeScript minimal ;
+- clavier + boutons directionnels tactiles ;
+- canvas responsive ;
+- lifecycle navigateur minimal ;
+- logging Web ;
+- chargement d'assets de preuve ;
+- provenance Browser/WASM ;
+- build Web avec outils natifs ;
+- audit de duplication et décisions d'extraction après POC.
+
+Exclus :
+
+- Tauri Android ;
+- Tauri Desktop Snake ;
+- remplacement du build Android natif multi-ABI ;
+- publicité, billing, auth ou leaderboard ;
+- réseau realtime ;
+- WebTransport/QUIC ;
+- logique Uroburas ;
+- ECS, physique ou nouveau moteur.
+
+## Sizing corrigé
+
+Le forecast initial est réduit et réordonné afin que `0.3.0` reste une version de session unique.
+
+### `0-pre.1` — audit, règles, requirements et sizing
+
+- audit complet de la baseline ;
+- correction des incohérences documentaires/règles détectées ;
+- choix Web direct ;
+- forecast corrigé ;
+- aucune implémentation gameplay/host lourde.
+
+### `0-pre.2` — Snake portability baseline
+
+- supprimer les dépendances de plateforme inutiles des crates jeu concernées ;
+- confirmer les actions sémantiques nécessaires à Snake ;
+- conserver Desktop SDL3 comme non-régression ;
+- préciser le contrat minimal attendu par l'adapter WASM.
+
+### `0-pre.3` — adapter Snake WASM + build natif Web
+
+- crate WASM Snake dédiée ;
+- exposition input/update/scene strictement nécessaire ;
+- procédure Cargo + `wasm-bindgen` reproductible sans Python ;
+- tests ciblés de l'adapter lorsqu'ils sont possibles hors navigateur.
+
+### `0-pre.4` — POC navigateur direct de bout en bout
+
+- frontend Vite/TypeScript ;
+- rendu Canvas ;
+- clavier ;
+- boutons tactiles ;
+- resize ;
+- visibility lifecycle ;
+- logging ;
+- assets ;
+- provenance ;
+- build et smoke navigateur réels côté utilisateur.
+
+### `0-pre.5` — uniquement si le POC révèle un défaut réel
+
+Cette tranche n'est pas créée artificiellement. Elle corrige une frontière, une duplication ou un bug observé.
+
+### `2-beta.1` — validation large du scope retenu
+
+Alpha n'est pas planifiée par défaut. Si `pre.4` est fonctionnellement complet, la beta valide le workspace affecté, le build Web de production et le smoke du POC.
+
+### `3-rc.1` — candidate gelée
+
+Documentation durable, commandes reproductibles, décisions d'extraction/report, ROADMAP et préparation de la version suivante. Aucun nouveau scope.
+
+### `0.3.0` — promotion mécanique
+
+Aucune nouvelle fonctionnalité.
+
+## Critères de sortie de 0.3.0
+
+`0.3.0` peut être clôturée lorsque :
+
+- Snake Desktop SDL3 reste fonctionnel ;
+- Snake fonctionne réellement dans un navigateur direct ;
+- clavier et boutons tactiles produisent les mêmes actions sémantiques ;
+- resize et visibility lifecycle ont été exercés ;
+- assets et provenance sont observables ;
+- le chemin Web ne dépend d'aucun script Python de build ;
+- les duplications avec Reflex/Tauri sont documentées ;
+- seules les abstractions prouvées nécessaires ont été extraites ;
+- les validations applicables ont été exécutées par l'utilisateur ;
+- aucune logique Uroburas ni réseau realtime n'a été introduite.

scripts/audit_project_workspace_rules.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # file: scripts/audit_project_workspace_rules.py
-# version: 5
+# version: 6
 
 """Audit mechanically verifiable games.sasedev workspace boundaries."""
 
@@ -92,6 +92,18 @@ def main() -> int:
     for java_path in sorted(root.rglob("*.java")):
         if not java_path.is_relative_to(root / "Android"):
             errors.append(f"GAME-ANDROID-001: Java source outside Android/: {java_path.relative_to(root).as_posix()}")
+
+    changelog_text = (root / "CHANGELOG.md").read_text(encoding="utf-8")
+    stable_versions = set(re.findall(r"^## ([0-9]+\.[0-9]+\.[0-9]+)(?: \u2014.*)?$", changelog_text, re.MULTILINE))
+    roadmap_text = (root / "ROADMAP.md").read_text(encoding="utf-8")
+    roadmap_sections = re.split(r"(?=^## )", roadmap_text, flags=re.MULTILINE)
+    for section in roadmap_sections:
+        heading = re.match(r"^## ([0-9]+\.[0-9]+\.[0-9]+)(?: \u2014.*)?$", section.splitlines()[0] if section.splitlines() else "")
+        if heading is None or heading.group(1) not in stable_versions:
+            continue
+        for line in section.splitlines()[1:]:
+            if line.startswith("- ( )"):
+                errors.append(f"DOC-RMAP-010: stable version {heading.group(1)} retains planned scope: {line}")
     if errors:
         for error in errors:
             print(error, file=sys.stderr)

scripts/audit_rust_workspace_rules.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # file: scripts/audit_rust_workspace_rules.py
-# version: 1
+# version: 2
 
 """Run all Rust normalization and games.sasedev workspace audits."""
 
@@ -20,9 +20,9 @@ def main() -> int:
     arguments = parser.parse_args()
     script_dir = pathlib.Path(__file__).resolve().parent
     commands = [
-        ["python3", str(script_dir / "audit_rust_general_rules.py"), "--root", arguments.root],
+        [sys.executable, "-B", str(script_dir / "audit_rust_general_rules.py"), "--root", arguments.root],
-        ["python3", str(script_dir / "audit_rust_export_completeness.py"), "--root", arguments.root],
+        [sys.executable, "-B", str(script_dir / "audit_rust_export_completeness.py"), "--root", arguments.root],
-        ["python3", str(script_dir / "audit_project_workspace_rules.py"), "--root", arguments.root],
+        [sys.executable, "-B", str(script_dir / "audit_project_workspace_rules.py"), "--root", arguments.root],
     ]
     for command in commands:
         completed = subprocess.run(command, check=False)