0.0.5-alpha.7.fix.1

VERSION

@@ -1 +1 @@
-0.0.5-alpha.7
+0.0.5-alpha.7.fix.1

deltas/0.0.5/alpha.7.fix.1.md

@@ -0,0 +1,186 @@
+<!-- file: deltas/0.0.5/alpha.7.fix.1.md -->
+<!-- version: 1 -->
+
+# Delta 0.0.5-alpha.7.fix.1 — contrats de suffixes, packaging Rust et tracing
+
+## Baseline et version
+
+Baseline attendue : commit opérateur complet de `0.0.5-alpha.7`, réalisé après application de `history/0.0.5/alpha.7.md` avec statut `FAIL`.
+
+Version après application :
+
+```text
+0.0.5-alpha.7.fix.1
+```
+
+## Motif
+
+La gate mécanique de `alpha.7` est propre, mais la revue fonctionnelle opérateur révèle que la nomenclature livrée reste trop descriptive. Dans les projets contrôlés, les suffixes doivent également porter un contrat architectural : `-api` désigne une frontière de contrats réellement justifiée, `-lib` une implémentation/fonctionnalité réutilisable, tandis que les exécutables restent normalement des packages distincts et minces.
+
+La relecture ciblée des corpus confirme plusieurs éléments réutilisables :
+
+- KSP distingue explicitement `ksp-<domain>-api` et `ksp-<role>-lib`, interdit une crate `*-api` créée uniquement par symétrie et garde les APIs purement déclaratives sans logging runtime ;
+- Games sépare explicitement la crate lib de jeu et ses launchers ;
+- KSP et Games convergent sur `tracing`, la composition du subscriber et une crate transverse de logging ;
+- les six hosts Tauri KSP et les deux hosts Tauri Games observés utilisent tous un package mixte lib/bin avec des noms de targets distincts.
+
+Une ancienne règle KSP préférait un package worker mixte lib/bin. Cette préférence n'est pas généralisée : la décision PGR actuelle est la séparation par défaut, Tauri restant l'exception framework explicitement reconnue.
+
+## Scope
+
+REPLACE :
+
+```text
+VERSION
+docs/plans/005-V0_0_5_RECONCILIATION_PLAN.md
+docs/rules/510-RUST_CARGO.md
+docs/rules/710-TAURI.md
+docs/skeletons/002-RUST_CARGO_WORKSPACE.md
+docs/studies/001-KSP_GAMES_RECONCILIATION.md
+docs/templates/002-CARGO_MANIFESTS.md
+```
+
+ADD :
+
+```text
+deltas/0.0.5/alpha.7.fix.1.md
+```
+
+DELETE : aucun.
+
+## Décisions
+
+Pour une nouvelle baseline Rust contrôlée :
+
+- `-api` signifie contrat extensible/passif ; une crate `-api` n'est créée que si une séparation réelle est justifiée par extension, backend, lifecycle, implémentations multiples ou implémentation externe ;
+- une crate `-api` purement déclarative reste normalement sans logging/tracing runtime ;
+- lorsqu'une seule implémentation est utile et qu'aucune frontière séparée n'apporte de valeur, une seule crate `-lib` est préférée ;
+- `-lib` signifie implémentation ou fonctionnalité réutilisable et ne contient normalement pas de cible binaire ;
+- hors exception explicite de framework/plateforme, une bibliothèque réutilisable et son exécutable sont des packages Cargo distincts ;
+- l'exécutable porte un rôle lisible lorsqu'il existe (`cli`, `desk`, `worker`, `job`, `server`, etc.), dépend des libs nécessaires et conserve `main.rs` comme couche de bootstrap/composition mince ;
+- Tauri reste l'exception framework actuelle au package séparé lib/bin ; son profil impose alors des noms de targets réellement distincts, y compris après normalisation Cargo `-` -> `_`.
+
+Pour les diagnostics :
+
+- `tracing` est le mécanisme recommandé pour les nouveaux projets Rust contrôlés ;
+- `log` reste acceptable comme bridge de compatibilité mais n'est pas la façade par défaut sans contrainte externe ;
+- lorsqu'un workspace possède plusieurs runtimes partageant subscriber, filtres, sinks ou lifecycle, une crate transverse de logging/tracing SHOULD centraliser cette responsabilité ;
+- `tracing-subscriber` et `tracing-appender` appartiennent normalement à cet owner de composition ;
+- une bibliothèque métier/technique peut émettre des événements mais ne configure pas silencieusement le subscriber global.
+
+## Hors scope
+
+Ce correctif ne traite toujours pas l'ordre des blocs, le regroupement par visibilité, l'espacement interne, l'ordre alphabétique des items ou les audits de forme : ces sujets restent réservés à `alpha.8`.
+
+Il ne crée aucun nouvel audit Python et ne transforme pas le profil Rust en catalogue exhaustif de suffixes. Les vocabulaires métier exacts restent locaux.
+
+## Validation opérateur
+
+Après application du history `FAIL` de `alpha.7`, commit/push de cette tranche, puis application du présent delta :
+
+```bash
+test "$(cat VERSION)" = '0.0.5-alpha.7.fix.1'
+test -f history/0.0.5/alpha.7.md
+test -f deltas/0.0.5/alpha.7.fix.1.md
+test ! -e history/0.0.5/alpha.7.fix.1.md
+
+grep -A2 '^## Statut$' history/0.0.5/alpha.7.md | grep -Fx 'FAIL'
+grep -Fx '<!-- version: 6 -->' docs/rules/510-RUST_CARGO.md
+grep -Fx '<!-- version: 5 -->' docs/rules/710-TAURI.md
+grep -Fx '<!-- version: 4 -->' docs/skeletons/002-RUST_CARGO_WORKSPACE.md
+grep -Fx '<!-- version: 3 -->' docs/templates/002-CARGO_MANIFESTS.md
+grep -Fx '<!-- version: 9 -->' docs/studies/001-KSP_GAMES_RECONCILIATION.md
+grep -Fx '<!-- version: 10 -->' docs/plans/005-V0_0_5_RECONCILIATION_PLAN.md
+
+python3 -B -m unittest discover -s tests -v
+
+python3 -B scripts/audit_markdown_headers.py \
+    README.md RULES.md ROADMAP.md CHANGELOG.md docs deltas history prompts
+python3 -B scripts/audit_markdown_tables.py \
+    README.md RULES.md ROADMAP.md CHANGELOG.md docs deltas history prompts
+python3 -B scripts/audit_markdown_links.py \
+    README.md RULES.md ROADMAP.md CHANGELOG.md docs deltas history prompts
+
+python3 -B - <<'PY'
+from pathlib import Path
+import re
+
+history = Path("history/0.0.5/alpha.7.md").read_text(encoding="utf-8")
+assert re.search(r"## Statut\s+FAIL\s", history)
+
+rules = Path("docs/rules/510-RUST_CARGO.md").read_text(encoding="utf-8")
+for phrase in (
+    "### Les suffixes portent un contrat architectural",
+    "Une crate `-api` MUST NOT être créée uniquement pour obtenir une paire de noms symétrique.",
+    "Lorsqu'une seule implémentation est réellement prévue",
+    "### Séparation bibliothèques / exécutables",
+    "Tauri constitue l'exception framework actuellement reconnue par PGR",
+    "## Diagnostics structurés et ownership du logging",
+    "`tracing` est le mécanisme recommandé",
+    "SHOULD NOT installer silencieusement un subscriber global",
+):
+    assert phrase in rules, phrase
+
+tauri = Path("docs/rules/710-TAURI.md").read_text(encoding="utf-8")
+for phrase in (
+    "le package mixte `lib + bin` constitue l'exception framework explicite",
+    "leurs noms MUST être distincts même après la normalisation Cargo usuelle des tirets en underscores",
+    "project_feature_desk_lib",
+    "Un plugin Tauri de tracing sert alors d'adapter",
+):
+    assert phrase in tauri, phrase
+
+skeleton = Path("docs/skeletons/002-RUST_CARGO_WORKSPACE.md").read_text(encoding="utf-8")
+for phrase in (
+    "les frontières `-api` / `-lib` réellement justifiées",
+    "Les exécutables sont des packages distincts des bibliothèques",
+    "crate transverse de logging/tracing",
+):
+    assert phrase in skeleton, phrase
+
+template = Path("docs/templates/002-CARGO_MANIFESTS.md").read_text(encoding="utf-8")
+assert "une bibliothèque réutilisable et son exécutable sont normalement deux packages Cargo distincts" in template
+assert "Tauri est une exception framework" in template
+
+study = Path("docs/studies/001-KSP_GAMES_RECONCILIATION.md").read_text(encoding="utf-8")
+for phrase in (
+    "#### Correction `alpha.7.fix.1` — suffixes, packaging et tracing",
+    "KSP-WORKER-014",
+    "les `6` hosts Tauri KSP `0.3.16` et les `2` hosts Tauri Games `0.3.5`",
+    "PGR retient donc `tracing` par défaut",
+):
+    assert phrase in study, phrase
+
+plan = Path("docs/plans/005-V0_0_5_RECONCILIATION_PLAN.md").read_text(encoding="utf-8")
+assert "`alpha.7.fix.1` complète donc la tranche" in plan
+assert "### alpha.8 — formatage Rust structurel et audits monotâches" in plan
+
+print("0.0.5 alpha.7.fix.1 crate contract audit: clean (api/lib semantics, binary split, tracing owner, Tauri exception)")
+PY
+
+git diff --check
+
+git add VERSION \
+    docs/plans/005-V0_0_5_RECONCILIATION_PLAN.md \
+    docs/rules/510-RUST_CARGO.md docs/rules/710-TAURI.md \
+    docs/skeletons/002-RUST_CARGO_WORKSPACE.md \
+    docs/studies/001-KSP_GAMES_RECONCILIATION.md \
+    docs/templates/002-CARGO_MANIFESTS.md \
+    deltas/0.0.5/alpha.7.fix.1.md
+
+git diff --cached --check
+git status --short
+```
+
+La sortie Git attendue avant ajout du history est exactement :
+
+```text
+M  VERSION
+A  deltas/0.0.5/alpha.7.fix.1.md
+M  docs/plans/005-V0_0_5_RECONCILIATION_PLAN.md
+M  docs/rules/510-RUST_CARGO.md
+M  docs/rules/710-TAURI.md
+M  docs/skeletons/002-RUST_CARGO_WORKSPACE.md
+M  docs/studies/001-KSP_GAMES_RECONCILIATION.md
+M  docs/templates/002-CARGO_MANIFESTS.md
+```

docs/plans/005-V0_0_5_RECONCILIATION_PLAN.md

@@ -1,5 +1,5 @@
 <!-- file: docs/plans/005-V0_0_5_RECONCILIATION_PLAN.md -->
-<!-- version: 9 -->
+<!-- version: 10 -->
 
 # Plan 0.0.5 — réconciliation réelle avec KSP et sasedev-games
 
@@ -116,6 +116,8 @@ La nomenclature des crates devient également explicite : préfixe projet/abrév
 
 Le skeleton Rust/Cargo et le guide de manifest reflètent ces choix. Aucun gros audit composite n'est importé ; le marqueur KSP spécifique des trait imports n'est pas généralisé et les contrôles déjà possédés par Clippy, rustc ou l'audit de façade restent chez leur owner.
 
+La gate mécanique `alpha.7` est propre, mais la revue fonctionnelle post-gate montre que cette première matérialisation ne donnait pas encore de contrat architectural aux suffixes. `alpha.7.fix.1` complète donc la tranche sans la replanifier : `-api` devient un vrai contrat extensible/passif et n'est jamais créé par symétrie ; `-lib` identifie l'implémentation réutilisable ; les exécutables sont des packages distincts et minces par défaut ; `tracing` et un owner de logging commun sont fortement recommandés dans les workspaces multi-runtime. L'ancienne préférence KSP pour un worker mixte lib/bin n'est pas généralisée. Tauri reste l'exception framework actuelle et impose des noms de targets lib/bin réellement distincts.
+
 ### alpha.8 — formatage Rust structurel et audits monotâches
 
 Réconcilier les règles KSP de blocs homogènes, visibilité, ordre alphabétique, espacement, modules et réexports avec les conventions plus légères de Games. Décider précisément ce qui appartient à `rustfmt`, aux audits PGR existants (`blank_lines`, `const_blocks`) ou à un nouvel audit monotâche justifié.

docs/rules/510-RUST_CARGO.md

@@ -1,5 +1,5 @@
 <!-- file: docs/rules/510-RUST_CARGO.md -->
-<!-- version: 5 -->
+<!-- version: 6 -->
 
 # Profil Rust / Cargo
 
@@ -68,6 +68,32 @@ Cette liste n'est ni exhaustive ni un vocabulaire imposé. Un suffixe ou classif
 
 Un projet historique MAY conserver un ordre local déjà stable, par exemple un rôle placé avant la responsabilité, si sa nomenclature est documentée et cohérente. PGR n'impose aucune campagne de renommage rétroactive uniquement pour adopter la grammaire recommandée.
 
+### Les suffixes portent un contrat architectural
+
+Dans un projet contrôlé, les classificateurs de nom ne sont pas décoratifs. Lorsqu'ils sont utilisés, ils décrivent une responsabilité que l'architecture et le graphe de dépendances doivent respecter.
+
+Une crate terminée par `-api` porte principalement des contrats réutilisables : traits, types, DTOs, identifiants et primitives nécessaires à des implémentations séparées. Elle SHOULD rester passive et sans runtime. Une crate `-api` purement déclarative MUST NOT dépendre d'une crate de logging/tracing uniquement pour satisfaire une convention transversale. Une instrumentation n'y est ajoutée que si la crate possède un comportement réel à observer.
+
+Une crate `-api` MUST NOT être créée uniquement pour obtenir une paire de noms symétrique. Elle est justifiée lorsqu'au moins une frontière réelle existe : implémentations multiples ou remplaçables, implémentation externe, backend injectable, lifecycle partagé ou contrat public dont l'implémentation doit pouvoir vivre dans une autre crate. Lorsqu'une seule implémentation est réellement prévue et qu'aucune frontière de contrat séparée n'apporte de valeur, une seule crate `-lib` est préférée.
+
+Une crate terminée par `-lib` porte une implémentation ou fonctionnalité réutilisable. Par défaut, elle est une crate bibliothèque sans cible binaire. Des familles comme `worker`, `job`, `store`, `transport` ou `scenario` MAY apparaître dans la responsabilité avant le suffixe `-lib` lorsqu'elles décrivent ce que la bibliothèque implémente ; le suffixe terminal `-lib` continue alors d'indiquer qu'il s'agit d'une unité réutilisable et non d'un launcher.
+
+### Séparation bibliothèques / exécutables
+
+Hors exception de framework ou plateforme explicitement documentée, un package contrôlé MUST NOT combiner une bibliothèque réutilisable et une cible binaire uniquement par commodité. La logique réutilisable appartient à une ou plusieurs crates `-lib`; l'exécutable appartient à un package distinct qui les consomme.
+
+Le nom d'un package exécutable SHOULD rendre visible son rôle de processus ou d'interface, par exemple `-cli`, `-desk`, `-worker`, `-job` ou `-server` lorsque ces termes décrivent réellement le launcher. Le binaire SHOULD rester une couche de composition mince : initialisation du processus, verrou/single-instance lorsque nécessaire, arguments CLI, wiring des bibliothèques, lifecycle et arrêt. La logique métier ou technique réutilisable ne doit pas être dupliquée dans `main.rs`.
+
+Tauri constitue l'exception framework actuellement reconnue par PGR à cette séparation par défaut : son profil peut demander un package mixte bibliothèque + binaire pour servir simultanément les entrées desktop/mobile. Cette exception est possédée par [`710-TAURI.md`](710-TAURI.md) et ne justifie pas de généraliser les packages mixtes aux workers, jobs ou autres exécutables. Toute autre exception mixte demande une règle locale et une raison technique identifiable.
+
+## Diagnostics structurés et ownership du logging
+
+Pour les nouveaux projets Rust contrôlés, `tracing` est le mécanisme recommandé de diagnostics structurés. La façade `log` MAY être conservée comme bridge de compatibilité lorsqu'une dépendance l'impose, mais elle SHOULD NOT devenir le mécanisme principal d'un nouveau projet lorsqu'aucune contrainte externe ne le requiert.
+
+Lorsqu'un workspace possède plusieurs crates runtime partageant les mêmes règles de diagnostics, il SHOULD centraliser la configuration de logging/tracing dans une crate transverse dédiée, typiquement `<project>-logging-lib` ou un nom équivalent conforme à la nomenclature locale. Dès que plusieurs exécutables ou bibliothèques ont besoin du même subscriber, des mêmes filtres/sinks ou du même lifecycle de guard, cet owner commun SHOULD remplacer les initialisations dupliquées. Un petit projet à exécutable unique n'est pas obligé de créer une crate dédiée sans valeur de réutilisation.
+
+Cette crate commune possède normalement la composition de `tracing-subscriber`, l'usage de `tracing-appender` lorsque nécessaire, les filtres/sinks/formats partagés et le lifecycle d'initialisation. Une bibliothèque métier ou technique MAY émettre des événements structurés, mais SHOULD NOT installer silencieusement un subscriber global. Les crates `-api` purement déclaratives restent normalement sans dépendance de logging.
+
 ## Manifests et dépendances Cargo
 
 Dans un workspace, une dépendance tierce réellement partagée par plusieurs crates SHOULD posséder sa contrainte de version canonique sous `[workspace.dependencies]`.

docs/rules/710-TAURI.md

@@ -1,5 +1,5 @@
 <!-- file: docs/rules/710-TAURI.md -->
-<!-- version: 4 -->
+<!-- version: 5 -->
 
 # Profil Tauri 2
 
@@ -72,14 +72,18 @@ Le host SHOULD être une crate Cargo mixte directement lisible, sans couche `src
 
 Un fichier comme `vite.config.ts` appartient également à la racine lorsque Vite est le bundler sélectionné. Un projet externe MAY conserver `src-tauri/` ou une autre organisation lorsque cette structure est imposée ou qu'une migration n'apporte pas de valeur suffisante.
 
-Dans le host Rust :
+Dans le host Rust, le package mixte `lib + bin` constitue l'exception framework explicite à la séparation générale définie par `510-RUST_CARGO.md`. Pour une nouvelle baseline Tauri contrôlée :
 
-- `src/lib.rs` SHOULD rester une façade de modules/réexports ;
+- le package SHOULD déclarer explicitement une cible bibliothèque et une cible binaire ;
-- `src/main.rs` SHOULD rester un launcher mince vers une fonction publique de la bibliothèque applicative ;
+- leurs noms MUST être distincts même après la normalisation Cargo usuelle des tirets en underscores ; un modèle valide est package/bin `project-feature-desk` et lib `project_feature_desk_lib` ;
+- `src/lib.rs` SHOULD rester une façade de modules/réexports et porter l'accès à la fonctionnalité applicative réutilisable ;
+- `src/main.rs` SHOULD rester un launcher mince vers une fonction publique de la bibliothèque applicative ; il MAY posséder le verrou/single-instance, les arguments strictement process et le bootstrap exécutable qui ne peut pas appartenir à la bibliothèque ;
 - `src/tauri.rs` SHOULD posséder l'assemblage Tauri et les wrappers `#[tauri::command]`, qui délèguent aux modules propriétaires plutôt que porter la logique métier ;
 - une fenêtre ou responsabilité UI non triviale SHOULD posséder un module cohérent, avec sous-modules si nécessaire ; les helpers réellement partagés entre plusieurs fenêtres/responsabilités SHOULD être déplacés dans des modules communs dédiés ;
 - un préfixe local comme `tw_` MAY être utilisé pour identifier les modules de fenêtres, mais PGR n'impose pas ce préfixe à tous les projets.
 
+Lorsque le workspace possède une crate de logging/tracing commune, le host Tauri l'utilise pour initialiser le runtime de diagnostics. Un plugin Tauri de tracing sert alors d'adapter à la frontière desktop/mobile ; il ne remplace pas l'owner Rust de `tracing-subscriber`, des sinks ou du lifecycle de logging.
+
 Lorsque le frontend sélectionné est TypeScript, les structures, énumérations et DTO Rust **possédés par le host** et partagés avec le frontend MUST utiliser TS-RS comme source de génération dans le profil strict, sauf incompatibilité technique explicitement documentée. Le contrat Rust reste la source de vérité ; les bindings générés ne sont pas modifiés manuellement et SHOULD rester hors Git lorsqu'ils sont entièrement reproductibles. Le skeleton MAY normaliser leur sortie sous `frontend/ts/bindings/`.
 
 Pour les projets contrôlés, `frontend/` est le répertoire recommandé pour les sources Web versionnées. Vite + TypeScript + Sass constitue la stack candidate par défaut et Bootstrap est la baseline de présentation privilégiée lorsque le projet a besoin d'un framework CSS généraliste. Tailwind CSS n'est pas interdit par le profil Tauri, mais il n'est pas le choix PGR par défaut et son adoption demande une décision explicite du projet. Ces choix restent possédés par le futur skeleton et les profils Web correspondants.

docs/skeletons/002-RUST_CARGO_WORKSPACE.md

@@ -1,5 +1,5 @@
 <!-- file: docs/skeletons/002-RUST_CARGO_WORKSPACE.md -->
-<!-- version: 3 -->
+<!-- version: 4 -->
 
 # Skeleton — Rust/Cargo workspace
 
@@ -72,8 +72,10 @@ Avant de considérer la specialization comme instanciée, résoudre explicitemen
 7. les niveaux de lints hérités, les éventuelles exceptions locales et tout besoin réel d'`unsafe` dans un scope étroit ;
 8. les paramètres `rustfmt.toml` et `clippy.toml` à conserver ou adapter ;
 9. l'emplacement des artefacts Cargo et l'identifiant unique utilisé dans `.cargo/config.toml` si cette politique externe au dépôt est retenue ;
-10. les exceptions éventuelles au profil Rust strict ; pour une nouvelle baseline contrôlée, la façade crate-root et les chemins explicites sont sélectionnés par défaut, tandis que les audits de style supplémentaires restent décidés séparément ;
+10. les frontières `-api` / `-lib` réellement justifiées, les packages exécutables distincts de leurs bibliothèques et toute exception framework à cette séparation ;
-11. les validations Cargo réellement nécessaires au code et aux manifests créés.
+11. l'ownership du logging/tracing : simple exécutable local ou crate transverse commune lorsque plusieurs runtimes partagent subscriber, sinks ou policy ;
+12. les exceptions éventuelles au profil Rust strict ; pour une nouvelle baseline contrôlée, la façade crate-root et les chemins explicites sont sélectionnés par défaut, tandis que les audits de style supplémentaires restent décidés séparément ;
+13. les validations Cargo réellement nécessaires au code et aux manifests créés.
 
 Les valeurs `0.1.0`, `2024`, `project-name`, `project-core-lib`, les seuils Clippy et les chemins de build présents dans les templates sont des exemples ou baselines à revoir. Ils ne deviennent jamais des valeurs universelles par simple copie.
 
@@ -105,6 +107,10 @@ Pour chaque crate réellement nécessaire, utiliser `templates/rust-cargo/crates
 
 `project-core-lib` n'est pas un nom de crate imposé. Dans une nouvelle baseline contrôlée, remplacer `project` par le nom court/abréviation du projet et choisir une responsabilité puis un rôle/cible lisibles conformément à `510-RUST_CARGO.md`. Une crate bibliothèque, binaire ou spécialisée doit conserver le layout et les héritages qui correspondent à son rôle réel ; un suffixe n'est pas ajouté uniquement pour obtenir une symétrie artificielle.
 
+Avant de créer une paire `*-api` / `*-lib`, démontrer la frontière contractuelle qui justifie deux packages. Une implémentation unique sans extension/backend/lifecycle séparé reste normalement une seule crate `-lib`. À l'inverse, une vraie crate `-api` reste principalement déclarative et ne reçoit pas le runtime de logging du projet par automatisme.
+
+Les exécutables sont des packages distincts des bibliothèques qu'ils composent, sauf exception de framework sélectionnée. Leur `main.rs` reste mince. Si plusieurs crates runtime partagent la même configuration de diagnostics, prévoir une crate transverse de logging/tracing ; ne pas répliquer l'initialisation du subscriber dans chaque binaire ou bibliothèque.
+
 Lorsque le membre hérite de la politique commune, `version.workspace = true`, `edition.workspace = true`, `publish.workspace = true` et `[lints] workspace = true` restent cohérents. Une exception locale, notamment de lint ou de safety, doit suivre le contrat de `510-RUST_CARGO.md` et ne pas affaiblir silencieusement les autres membres.
 
 Le code source minimal requis par Cargo appartient au projet destinataire. PGR ne fournit pas de `src/lib.rs` ou `src/main.rs` universel, car leur contenu dépend du rôle réel de la crate.

docs/studies/001-KSP_GAMES_RECONCILIATION.md

@@ -1,5 +1,5 @@
 <!-- file: docs/studies/001-KSP_GAMES_RECONCILIATION.md -->
-<!-- version: 8 -->
+<!-- version: 9 -->
 
 # Étude de réconciliation PGR / KSP / sasedev-games
 
@@ -206,6 +206,18 @@ La nomenclature converge sur une propriété utile sans imposer les vocabulaires
 
 Les règles de blocs homogènes, visibilité, espacement et ordre alphabétique restent volontairement hors de cette décision et appartiennent à `alpha.8`.
 
+#### Correction `alpha.7.fix.1` — suffixes, packaging et tracing
+
+La gate mécanique de `alpha.7` passe, mais la revue fonctionnelle opérateur révèle que la première matérialisation traitait encore les suffixes comme de simples indications de lisibilité. Le corpus KSP contient pourtant un contrat plus fort : `KSP-NAME-001..003` distingue implémentation réutilisable `-lib` et contrat extensible `-api`, `KSP-API-007` interdit de créer une API par symétrie, et `002-LAYERS_AND_DEPENDENCIES.md` réserve le logging aux crates ayant réellement du comportement.
+
+La règle PGR devient donc sémantique : `-api` signifie frontière de contrat réellement justifiée et principalement passive ; `-lib` signifie implémentation/fonctionnalité réutilisable. Une implémentation unique sans besoin d'extension/backend/lifecycle ne crée pas artificiellement une paire `-api` / `-lib`. Les rôles `worker`, `job`, `store`, etc. peuvent faire partie du nom d'une bibliothèque, mais `-lib` continue d'indiquer qu'elle n'est pas le launcher.
+
+Sur le packaging, les deux corpus ne doivent pas être fusionnés mécaniquement. Games `GAME-WS-007` sépare explicitement la lib de jeu et son runner Desktop. KSP contient encore `KSP-WORKER-014`, qui préférait à terme un package worker mixte bibliothèque + binaire. Cette dernière préférence n'est **pas généralisée** : la clarification opérateur retient désormais la séparation package bibliothèque / package exécutable par défaut, les exécutables restant des couches de composition minces. Tauri est l'exception framework actuelle.
+
+Cette exception est elle-même fortement observée : les `6` hosts Tauri KSP `0.3.16` et les `2` hosts Tauri Games `0.3.5` déclarent une cible `lib` et une cible `bin` distinctes ; les libs utilisent un nom terminé par `_lib` tandis que le binaire conserve le nom applicatif. PGR exige donc, dans une nouvelle baseline Tauri contrôlée, des noms de targets distincts même après normalisation `-` → `_`. Le motif cross-platform exact à l'origine de cette convention n'est pas utilisé comme preuve normative ici ; le contrat observable et reproductible suffit.
+
+Le logging converge également fortement. KSP possède `ksp-logging-lib` comme façade/runtime commun et garde ses `*-api` déclaratives sans logging ; Games définit `tracing` comme mécanisme canonique, `tracing-subscriber` comme owner de composition, `tracing-appender` lorsque nécessaire et `game-logging-lib` comme crate transverse. PGR retient donc `tracing` par défaut et recommande une crate commune de logging dès que plusieurs runtimes partagent subscriber, sinks, filtres ou lifecycle ; la façade `log` reste seulement une compatibilité possible, pas le default d'une nouvelle baseline contrôlée.
+
 #### Politique de version Tauri/frontend réconciliée
 
 La baseline KSP `0.3.16` illustre le défaut de l'ancienne convention : les six `tauri.conf.json` n'ont pas de champ `version`, tandis que leurs `package.json` portent des versions historiques différentes (`0.2.6`, `0.2.12-pre.9`, `0.3.7`, `0.3.8` ou `0.3.15`) sans représenter uniformément la release courante. Games `0.3.5` suit la même famille de règles. Cette situation réduit les modifications mécaniques mais affaiblit la lisibilité des manifests.

docs/templates/002-CARGO_MANIFESTS.md

@@ -1,5 +1,5 @@
 <!-- file: docs/templates/002-CARGO_MANIFESTS.md -->
-<!-- version: 2 -->
+<!-- version: 3 -->
 
 # Modèles de manifests Cargo workspace et crate membre
 
@@ -27,7 +27,13 @@ Copier le membre vers `crates/<nom>/Cargo.toml`, adapter `name`, son chemin dans
 
 Le bloc `[dependencies]` vide se remplit selon les besoins de la crate. Pour une dépendance déjà déclarée sous `[workspace.dependencies]`, utiliser localement `nom = { workspace = true }`, avec `features = [...]` au besoin. Pour une dépendance strictement locale, choisir sa contrainte directement dans ce membre ; aucune liste tierce arbitraire n'est copiée par ce modèle.
 
-Une application binaire peut reprendre les mêmes héritages après adaptation du nom, du layout et de sa cible `src/main.rs` ; ne pas fabriquer un deuxième manifest quasi identique. Une crate à version ou politique de publication réellement indépendante doit déclarer ses valeurs locales et ne plus hériter ces champs par automatisme.
+Pour une nouvelle baseline contrôlée, une bibliothèque réutilisable et son exécutable sont normalement deux packages Cargo distincts. Le package binaire peut reprendre les mêmes héritages de workspace, mais son manifest est légitime parce qu'il exprime une frontière de packaging et de dépendances différente : il dépend des crates `-lib`, conserve un `main.rs` mince et porte un nom révélant son rôle (`-cli`, `-desk`, `-worker`, `-job`, `-server`, etc.) lorsque ce classificateur est réellement applicable. Ne pas fusionner `lib` + `bin` dans un seul package uniquement pour éviter un manifest membre supplémentaire.
+
+Une paire `*-api` / `*-lib` n'est créée que si un vrai contrat séparé le justifie. Une crate `-api` purement déclarative ne reçoit normalement ni subscriber global ni dépendance vers la crate de logging. Une crate `-lib` unique suffit lorsqu'il n'existe qu'une implémentation utile et aucune frontière d'extension/backend/lifecycle.
+
+Tauri est une exception framework documentée par [`710-TAURI.md`](../rules/710-TAURI.md) : son host peut être un package mixte `lib + bin`, mais les deux targets doivent alors posséder des noms distincts selon le contrat Tauri.
+
+Une crate à version ou politique de publication réellement indépendante doit déclarer ses valeurs locales et ne plus hériter ces champs par automatisme.
 
 ## Exception locale de lints
 

history/0.0.5/alpha.7.fix.1.md

@@ -0,0 +1,102 @@
+<!-- file: history/0.0.5/alpha.7.fix.1.md -->
+<!-- version: 1 -->
+
+# History 0.0.5-alpha.7.fix.1 — contrats de crates, packaging et tracing
+
+## Statut
+
+PASS
+
+La gate opérateur de `0.0.5-alpha.7.fix.1` exécutée le `2026-09-25` valide la correction fonctionnelle de `alpha.7` : les suffixes de crates portent désormais un contrat architectural explicite, les bibliothèques et exécutables sont séparés par défaut, l'ownership du logging/tracing est borné et Tauri reste l'exception framework documentée pour un package mixte `lib + bin`.
+
+Les tests, audits Markdown, contrôle structurel ciblé et contrôles Git sont propres. Aucun nouveau correctif `alpha.7` n'est requis.
+
+## Baseline et version
+
+La tranche part du commit opérateur de `0.0.5-alpha.7` :
+
+```text
+ac03b78  0.0.5-alpha.7
+```
+
+Le push vers `origin/master` a réussi avant l'application de `alpha.7.fix.1`.
+
+La version contrôlée après application du correctif est :
+
+```text
+0.0.5-alpha.7.fix.1
+```
+
+`history/0.0.5/alpha.7.md` est présent avec statut `FAIL`, `deltas/0.0.5/alpha.7.fix.1.md` est présent et `history/0.0.5/alpha.7.fix.1.md` était absent pendant la gate, conformément au workflow.
+
+## Validation opérateur observée
+
+L'opérateur a fourni les sorties du `2026-09-25` depuis `~/Projects/pgr`, à `15:07:31`–`15:08:03`.
+
+Les contrôles de révision ont confirmé :
+
+```text
+docs/rules/510-RUST_CARGO.md                    version 6
+docs/rules/710-TAURI.md                         version 5
+docs/skeletons/002-RUST_CARGO_WORKSPACE.md      version 4
+docs/templates/002-CARGO_MANIFESTS.md           version 3
+docs/studies/001-KSP_GAMES_RECONCILIATION.md    version 9
+docs/plans/005-V0_0_5_RECONCILIATION_PLAN.md    version 10
+```
+
+La suite Python globale a exécuté `37` tests, tous réussis :
+
+```text
+Ran 37 tests in 0.480s
+
+OK
+```
+
+Les audits documentaires sont propres :
+
+```text
+Markdown header audit: clean (156 file(s))
+Markdown table audit: clean (7 table(s), 156 file(s))
+Markdown link audit: clean (152 local link(s), 156 file(s))
+```
+
+Le contrôle structurel spécifique affiche :
+
+```text
+0.0.5 alpha.7.fix.1 crate contract audit: clean (api/lib semantics, binary split, tracing owner, Tauri exception)
+```
+
+`git diff --check` et `git diff --cached --check` n'ont produit aucun diagnostic.
+
+Le scope Git observé avant ajout du présent history est exactement :
+
+```text
+M  VERSION
+A  deltas/0.0.5/alpha.7.fix.1.md
+M  docs/plans/005-V0_0_5_RECONCILIATION_PLAN.md
+M  docs/rules/510-RUST_CARGO.md
+M  docs/rules/710-TAURI.md
+M  docs/skeletons/002-RUST_CARGO_WORKSPACE.md
+M  docs/studies/001-KSP_GAMES_RECONCILIATION.md
+M  docs/templates/002-CARGO_MANIFESTS.md
+```
+
+## Résultat
+
+Le profil Rust strict possède maintenant une nomenclature qui décrit réellement les frontières d'architecture : `-api` n'est pas créé par symétrie, `-lib` désigne une unité réutilisable, les launchers sont normalement des packages distincts, et les diagnostics structurés ont un owner transverse lorsque plusieurs runtimes partagent leur configuration.
+
+L'ancienne préférence KSP pour certains packages worker mixtes n'est pas généralisée. Tauri reste l'exception framework actuelle, avec des noms de targets `lib`/`bin` réellement distincts.
+
+Les règles de forme Rust restent volontairement hors de ce correctif et peuvent maintenant être traitées dans `alpha.8` sans rouvrir les contrats de crates.
+
+## Transition
+
+Appliquer le présent history puis committer et pousser `0.0.5-alpha.7.fix.1`.
+
+La tranche suivante est :
+
+```text
+0.0.5-alpha.8
+```
+
+Elle doit réconcilier le formatage Rust structurel KSP/Games, attribuer chaque propriété à `rustfmt`, aux audits PGR déjà existants ou à un audit monotâche justifié, sans importer l'ancien audit composite et sans commencer le skeleton Tauri réservé à `alpha.9`.