0.0.1-rc.1.fix.1

.gitignore

@@ -1,5 +1,5 @@
 # file: .gitignore
-# version: 2
+# version: 3
 
 # Logs
 /logs/
@@ -38,7 +38,8 @@ __pycache__/
 .mypy_cache/
 .ruff_cache/
 
-# Rust/Cargo outputs
+# Rust/Cargo generated state and outputs
+/Cargo.lock
 /target/
 
 # JavaScript/frontend dependencies and transient outputs

CHANGELOG.md

@@ -1,5 +1,5 @@
 <!-- file: CHANGELOG.md -->
-<!-- version: 10 -->
+<!-- version: 11 -->
 
 # Changelog SaseDev Knowledge
 
@@ -14,7 +14,7 @@ Ce fichier décrit les changements utiles des releases publiées. Les détails d
 - fixe les frontières PGR / HOWTO / snippet / project-local ;
 - adopte la préférence Eclipse UTF-8 versionnée prévue par PGR ;
 - cadre une surface d'administration protégée propre à chaque application Web sans figer encore ses URL ni son modèle détaillé d'autorisation ;
-- instancie le workspace Rust/Cargo strict avec une première crate de domaine et une politique explicite de `Cargo.lock` versionné ;
+- instancie le workspace Rust/Cargo strict avec une première crate de domaine et une politique explicite de `Cargo.lock` local, généré par Cargo et ignoré par Git ;
 - introduit les premiers contrats provider-neutral de source, Git et synchronisation sans dépendance à une forge ni à PostgreSQL ;
 - active les audits Rust PGR de structure et de façade au moment où des API publiques réelles apparaissent ;
 - sélectionne localement `unit_tests/` hors de `src/` pour tous les tests unitaires Rust, avec `tests/` réservé aux tests d'intégration Cargo ;

Cargo.toml

@@ -1,5 +1,5 @@
 # file: Cargo.toml
-# version: 13
+# version: 14
 
 [workspace]
 resolver = "3"
@@ -14,7 +14,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.0.1-rc.1"
+version = "0.0.1-rc.1.fix.1"
 edition = "2024"
 publish = false
 repository = "https://git.sasedev.com/Sasedev/sasedev-knowledge"

RULES.md

@@ -1,5 +1,5 @@
 <!-- file: RULES.md -->
-<!-- version: 8 -->
+<!-- version: 9 -->
 
 # Règles SaseDev Knowledge
 
@@ -183,6 +183,24 @@ Les trois launchers MUST recevoir leur socket de bind par configuration (`KNOWLE
 
 ## Rust et crates
 
+### Politique `Cargo.lock`
+
+PGR `v0.1.1` exige une décision explicite de lockfile selon le type de produit et le besoin de reproductibilité ; il n'impose pas universellement le versionnement de `Cargo.lock`.
+
+Knowledge sélectionne localement la politique suivante :
+
+```text
+Cargo.lock  généré localement par Cargo
+Cargo.lock  ignoré par Git
+Cargo.lock  non versionné
+```
+
+Le fichier racine `Cargo.lock` MUST être ignoré et MUST NOT être suivi par Git. Les manifests Cargo et la documentation normative restent le contrat versionné des dépendances Rust.
+
+Cette décision ne s'applique pas au frontend npm : `Web/knowledge-template-lab/package-lock.json` reste versionné et `npm ci` demeure la preuve de restauration Web reproductible.
+
+### Layout des tests
+
 Knowledge sélectionne localement la convention `unit_tests/` séparée que PGR `0.1.1` autorise sans l'imposer globalement.
 
 Pour toutes les crates Rust de ce workspace :

VERSION

@@ -1 +1 @@
-0.0.1-rc.1
+0.0.1-rc.1.fix.1

deltas/0.0.1/rc.1.fix.1.md

@@ -0,0 +1,139 @@
+<!-- file: deltas/0.0.1/rc.1.fix.1.md -->
+<!-- version: 1 -->
+
+# Delta 0.0.1-rc.1.fix.1 — politique `Cargo.lock` et correction de gate RC
+
+## Base requise
+
+État `0.0.1-rc.1` committé et poussé après application du history :
+
+```text
+history/0.0.1/rc.1.md = FAIL
+```
+
+La version devient :
+
+```text
+0.0.1-rc.1.fix.1
+```
+
+## Causes
+
+Deux corrections sont regroupées avant la stable.
+
+### Gate RC incorrecte
+
+La gate `rc.1` utilisait :
+
+```text
+git diff --name-only
+```
+
+et exigeait que `deltas/0.0.1/rc.1.md` y apparaisse.
+
+Or Git n'inclut pas les fichiers non suivis dans cette commande. Le delta existait bien dans le workspace puis a été correctement ajouté au staging.
+
+Le fix contrôle désormais directement la présence des fichiers attendus et utilise les outils Git adaptés à leur état au lieu de confondre diff suivi et fichiers non suivis.
+
+### Politique `Cargo.lock`
+
+Knowledge abandonne la décision historique de versionner `Cargo.lock`.
+
+PGR `v0.1.1` demande une politique explicite adaptée au projet et n'impose pas universellement le versionnement du lockfile Rust.
+
+La politique finale de Knowledge devient :
+
+```text
+Cargo.lock  généré localement
+Cargo.lock  ignoré
+Cargo.lock  non suivi par Git
+```
+
+`package-lock.json` reste versionné pour le package Web npm.
+
+## Retrait du repository sans suppression locale
+
+Le manifest :
+
+```text
+manifests/0.0.1/rc.1.fix.1.delete.txt
+```
+
+possède :
+
+```text
+Cargo.lock
+```
+
+Cette suppression est une suppression **du repository**, pas du workspace local.
+
+Après extraction du delta, appliquer :
+
+```bash
+git rm --cached -- Cargo.lock
+```
+
+Ne pas utiliser `rm Cargo.lock`.
+
+La copie locale doit rester disponible pour Cargo et devient ignorée grâce à :
+
+```text
+/Cargo.lock
+```
+
+dans `.gitignore`.
+
+## Fichiers remplacés
+
+```text
+.gitignore
+VERSION
+Cargo.toml
+CHANGELOG.md
+RULES.md
+docs/architecture/001-PROJECT_PROFILE.md
+docs/architecture/002-KNOWLEDGE_ARCHITECTURE.md
+docs/plans/001-V0_0_1_FOUNDATION_PLAN.md
+docs/validation/001-VALIDATION_MATRIX.md
+```
+
+## Fichiers ajoutés
+
+```text
+deltas/0.0.1/rc.1.fix.1.md
+manifests/0.0.1/rc.1.fix.1.delete.txt
+```
+
+## Suppression repository
+
+```text
+Cargo.lock
+```
+
+Aucune autre suppression n'est autorisée.
+
+## Historique
+
+Les deltas et histories antérieurs qui indiquent `Cargo.lock` versionné ne sont pas réécrits : ils décrivent correctement l'état et la politique en vigueur lors de ces tranches.
+
+Les documents vivants sont réconciliés avec la politique finale.
+
+## Scope fonctionnel
+
+Aucun fichier sous `crates/` ou `Web/` n'est modifié.
+
+Aucune dépendance, route, API, comportement Actix/Maud/Vite ou fonctionnalité métier n'est ajoutée.
+
+## Transition
+
+Un `PASS` de ce fix ne promeut pas directement la stable.
+
+La candidate suivante est :
+
+```text
+0.0.1-rc.2
+```
+
+afin d'exécuter une RC propre sur la politique de lockfile finale avant `rel.1`.
+
+Ne pas committe `rc.1.fix.1` avant production de son history opérateur.

docs/architecture/001-PROJECT_PROFILE.md

@@ -1,5 +1,5 @@
 <!-- file: docs/architecture/001-PROJECT_PROFILE.md -->
-<!-- version: 8 -->
+<!-- version: 9 -->
 
 # Profil du projet Knowledge
 
@@ -69,7 +69,7 @@ Les profils Java/Maven/Gradle, Android et autres technologies absentes ne sont p
 | PostgreSQL                             | `KEEP-LOCAL`                      | une base logique partagée pour l'état transversal et les projections ; jamais vérité du contenu Git publié     |
 | Rust stable / édition 2024             | `ADOPT`                           | profil Rust/Cargo PGR                                                                                          |
 | Workspace Cargo                        | `ADOPT`                           | skeleton Rust/Cargo ; actif depuis `alpha.2`                                                                   |
-| `Cargo.lock`                           | `KEEP-LOCAL`                      | versionné : workspace applicatif déployable, résolution reproductible entre opérateur et livraisons            |
+| `Cargo.lock`                           | `KEEP-LOCAL`                      | généré localement et ignoré ; les manifests Cargo restent le contrat versionné                                 |
 | Actix Web                              | `KEEP-LOCAL`                      | trois launchers matérialisés en `alpha.5` et composition partagée dans `knowledge-web-lib`                     |
 | Maud                                   | `KEEP-LOCAL`                      | rendu SSR commun matérialisé dans `knowledge-web-lib` en `alpha.5`                                             |
 | TypeScript                             | `ADOPT`                           | conforme au owner `530` et à l'intention locale                                                                |

docs/architecture/002-KNOWLEDGE_ARCHITECTURE.md

@@ -1,5 +1,5 @@
 <!-- file: docs/architecture/002-KNOWLEDGE_ARCHITECTURE.md -->
-<!-- version: 8 -->
+<!-- version: 9 -->
 
 # Architecture de fondation Knowledge
 
@@ -36,7 +36,7 @@ Les deux crates `-api` sont justifiées par des implémentations réellement rem
 
 Les tests unitaires Rust sont désormais placés hors de `src/` sous `unit_tests/`, conformément à la convention locale Knowledge sélectionnée sur l'option permise par PGR.
 
-Le workspace est une application déployable à train de release unique ; `Cargo.lock` est donc versionné pour conserver la résolution effectivement vérifiée. Les artefacts Cargo sont dirigés hors du dépôt vers `../builds/sasedev-knowledge/target/`.
+Le workspace est une application déployable à train de release unique. Knowledge choisit néanmoins de conserver `Cargo.lock` comme état généré local et ignoré par Git ; les manifests Cargo portent le contrat versionné des dépendances. Les artefacts Cargo sont dirigés hors du dépôt vers `../builds/sasedev-knowledge/target/`.
 
 ## Vue de responsabilités
 

docs/plans/001-V0_0_1_FOUNDATION_PLAN.md

@@ -1,5 +1,5 @@
 <!-- file: docs/plans/001-V0_0_1_FOUNDATION_PLAN.md -->
-<!-- version: 15 -->
+<!-- version: 16 -->
 
 # Plan 0.0.1 — fondation SaseDev Knowledge
 
@@ -265,6 +265,10 @@ La RC ne modifie aucun code Rust, package Web, dépendance, roadmap, changelog c
 
 Un défaut fonctionnel important découvert en RC impose un retour de phase ou un REPLAN ; il ne doit pas être absorbé silencieusement dans la promotion stable.
 
+La gate opérateur de `rc.1` reste **FAIL** à cause d'une assertion de gate incorrecte : `git diff --name-only` ne liste pas le delta `rc.1.md` encore non suivi, bien qu'il soit présent et ensuite correctement stage.
+
+Avant la stable, une décision locale supplémentaire est prise : `Cargo.lock` ne sera plus versionné. `rc.1.fix.1` corrige donc la gate, ajoute `/Cargo.lock` au `.gitignore`, retire le lockfile de l'index sans supprimer sa copie locale et réconcilie les documents vivants. Les anciennes tranches continuent de documenter fidèlement la politique appliquée au moment où elles ont été exécutées.
+
 ### rel.1 — fermeture stable
 
 Exécuter la gate de release, produire le premier history `rel.N[/fix.M]` réellement `PASS`, matérialiser le commit produit `0.0.1`, publier le tag stable selon la politique Git retenue et effectuer la vérification post-tag requise.

docs/validation/001-VALIDATION_MATRIX.md

@@ -1,5 +1,5 @@
 <!-- file: docs/validation/001-VALIDATION_MATRIX.md -->
-<!-- version: 15 -->
+<!-- version: 16 -->
 
 # Matrice de validation Knowledge
 
@@ -430,3 +430,31 @@ La release candidate doit prouver :
 - `git diff --cached --check` propre.
 
 La RC `PASS` autorise uniquement la promotion mécanique `0.0.1-rel.1`.
+
+## Gate de `0.0.1-rc.1.fix.1`
+
+Le fix RC doit prouver :
+
+- `VERSION = 0.0.1-rc.1.fix.1` et version workspace identique ;
+- history `rc.1` `FAIL` committé avant application ;
+- `/Cargo.lock` présent dans `.gitignore` ;
+- `Cargo.lock` absent de l'index Git après `git rm --cached`, mais copie locale toujours présente ;
+- `git check-ignore -q Cargo.lock` `PASS` ;
+- `git ls-files --error-unmatch Cargo.lock` échoue ;
+- `package-lock.json` reste suivi et non ignoré ;
+- `RULES.md`, profil, architecture et changelog candidat décrivent tous la politique Cargo actuelle comme locale/non versionnée ;
+- aucune réécriture des deltas/histories antérieurs pour masquer l'ancienne politique ;
+- audit d'intégration corrigé : présence du delta fix contrôlée directement, sans exiger qu'un fichier non suivi apparaisse dans `git diff --name-only` ;
+- quinze histories antérieurs présents avec leurs statuts réels, dont `rc.1 = FAIL` ;
+- `deltas/0.0.1/rc.1.fix.1.md` présent et history du fix absent pendant la gate ;
+- aucun diff sous `crates/` ou `Web/` ;
+- audits Markdown et hygiène texte propres ;
+- `cargo fmt --check`, audits Rust, `cargo check`, Clippy strict et tests workspace propres ;
+- les commandes Cargo peuvent générer/mettre à jour le `Cargo.lock` local sans le remettre dans le staging ;
+- `npm ci`, typecheck et build Web propres ;
+- manifest Vite parsable ;
+- smoke HTTP des trois launchers propre ;
+- staging final contenant la suppression Git de `Cargo.lock` mais aucune réintroduction du fichier ;
+- `git diff --cached --check` propre.
+
+Le fix `PASS` autorise la reprise de la release candidate vers `0.0.1-rc.2`.

history/0.0.1/rc.1.fix.1.md

@@ -0,0 +1,211 @@
+<!-- file: history/0.0.1/rc.1.fix.1.md -->
+<!-- version: 1 -->
+
+# History 0.0.1-rc.1.fix.1 — politique `Cargo.lock` et correction de gate RC
+
+## Statut
+
+PASS
+
+La gate opérateur de `0.0.1-rc.1.fix.1` exécutée le `2026-09-28` est propre.
+
+## Baseline opérateur
+
+`rc.1` `FAIL` a été historisé, committé et poussé avant application du fix :
+
+```text
+history/0.0.1/rc.1.md = FAIL
+commit       df467bd
+message      0.0.1-rc.1
+branch       master
+push         origin/master PASS
+status       clean après push
+```
+
+Le push observé a avancé `origin/master` de `7c0048b` à `df467bd`.
+
+## Retrait de `Cargo.lock` du repository
+
+La suppression repository est appliquée avec :
+
+```text
+git rm --cached -- Cargo.lock
+```
+
+La copie locale reste présente.
+
+Les contrôles passent :
+
+```text
+test -f Cargo.lock                           PASS
+git check-ignore -q Cargo.lock               PASS
+git ls-files --error-unmatch Cargo.lock      échoue comme attendu
+```
+
+La politique finale Rust est donc :
+
+```text
+Cargo.lock  généré localement par Cargo
+Cargo.lock  ignoré par Git
+Cargo.lock  non versionné
+```
+
+Le lockfile npm reste au contraire versionné :
+
+```text
+Web/knowledge-template-lab/package-lock.json
+```
+
+et n'est pas ignoré.
+
+## Audit d'intégration
+
+La gate corrigée passe :
+
+```text
+Knowledge 0.0.1-rc.1.fix.1 integration audit: clean
+```
+
+Elle confirme notamment :
+
+- version workspace `0.0.1-rc.1.fix.1` ;
+- delta du fix présent ;
+- history du fix absent pendant sa propre gate ;
+- documents vivants réconciliés avec la politique `Cargo.lock` finale ;
+- quinze histories antérieurs présents avec leurs statuts réels ;
+- `rc.1 = FAIL`.
+
+## Markdown
+
+Les audits passent :
+
+```text
+Markdown header audit: clean (46 file(s))
+Markdown table audit: clean (4 table(s), 46 file(s))
+Markdown link audit: clean (28 local link(s), 46 file(s))
+```
+
+## Hygiène texte
+
+La preuve complémentaire passe :
+
+```text
+Knowledge 0.0.1-rc.1.fix.1 text hygiene: clean
+```
+
+Elle a été exécutée deux fois sans anomalie.
+
+## Rust
+
+`cargo metadata` fonctionne avec le `Cargo.lock` local ignoré.
+
+Les audits passent :
+
+```text
+Rust test-layout audit: clean (7 crate(s))
+Rust blank-line audit: clean (18 file(s))
+Rust item-spacing audit: clean (18 file(s))
+Rust module-order audit: clean (18 file(s))
+Rust trait-import-block audit: clean (18 file(s))
+Rust re-export-block audit: clean (18 file(s))
+Rust export completeness audit: 0 candidate(s) across 7 package(s)
+```
+
+`cargo check`, Clippy strict et les tests workspace passent.
+
+Résultats observés :
+
+```text
+knowledge-domain-lib : 3 PASS
+knowledge-git-api    : 1 PASS
+knowledge-sync-api   : 1 PASS
+knowledge-web-lib    : 4 PASS
+launchers            : 0 test chacun
+```
+
+Après ces commandes Cargo :
+
+```text
+Cargo.lock local      présent
+Cargo.lock Git        absent
+Cargo.lock ignore     actif
+```
+
+Aucune réintroduction dans l'index n'est observée.
+
+## Web
+
+Les commandes passent :
+
+```text
+npm ci
+npm run typecheck
+npm run build
+```
+
+npm observe toujours `@parcel/watcher@2.6.0` comme script d'installation non couvert par `allowScripts`. Aucune approbation automatique n'est effectuée.
+
+Les warnings Sass Bootstrap restent non bloquants.
+
+## Manifest Vite
+
+L'audit passe :
+
+```text
+Knowledge 0.0.1-rc.1.fix.1 Vite manifest audit: clean
+JS  assets/assets/main-BMHcm6u9.js
+CSS assets/main-V0IwlRbh.css
+```
+
+## Smokes HTTP
+
+Les trois launchers passent :
+
+```text
+knowledge-pgr-server      smoke PASS
+knowledge-howtos-server   smoke PASS
+knowledge-snippets-server smoke PASS
+Knowledge 0.0.1-rc.1.fix.1 HTTP smoke: clean
+```
+
+## Hygiène Git finale
+
+Après les dernières preuves :
+
+```text
+test -f Cargo.lock                           PASS
+git check-ignore -q Cargo.lock               PASS
+Cargo.lock absent de git ls-files            PASS
+git diff --cached --check                    PASS
+```
+
+Le staging final observé avant ajout du présent history est :
+
+```text
+M  .gitignore
+M  CHANGELOG.md
+D  Cargo.lock
+M  Cargo.toml
+M  RULES.md
+M  VERSION
+A  deltas/0.0.1/rc.1.fix.1.md
+M  docs/architecture/001-PROJECT_PROFILE.md
+M  docs/architecture/002-KNOWLEDGE_ARCHITECTURE.md
+M  docs/plans/001-V0_0_1_FOUNDATION_PLAN.md
+M  docs/validation/001-VALIDATION_MATRIX.md
+A  manifests/0.0.1/rc.1.fix.1.delete.txt
+```
+
+## Décision
+
+`0.0.1-rc.1.fix.1` est `PASS`.
+
+La politique de lockfile finale est stabilisée et aucune fonctionnalité runtime n'a été modifiée.
+
+La transition autorisée est :
+
+```text
+0.0.1-rc.2
+```
+
+`rc.2` doit être une release candidate complète et propre sur cet état final avant toute promotion `rel.1`.

manifests/0.0.1/rc.1.fix.1.delete.txt

@@ -0,0 +1 @@
+Cargo.lock