0.0.1-rc.2

Cargo.toml

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

VERSION

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

deltas/0.0.1/rc.2.md

@@ -0,0 +1,108 @@
+<!-- file: deltas/0.0.1/rc.2.md -->
+<!-- version: 1 -->
+
+# Delta 0.0.1-rc.2 — candidate finale sur politique `Cargo.lock` stabilisée
+
+## Base requise
+
+État `0.0.1-rc.1.fix.1` committé et poussé après application du history :
+
+```text
+history/0.0.1/rc.1.fix.1.md = PASS
+```
+
+La version devient :
+
+```text
+0.0.1-rc.2
+```
+
+## Objet
+
+Exécuter une release candidate complète sur l'état final de la fondation après retrait de `Cargo.lock` du repository.
+
+Aucune fonctionnalité n'est ajoutée.
+
+## Politique lockfile à conserver
+
+```text
+Cargo.lock
+  présent localement
+  généré par Cargo
+  ignoré par Git
+  non suivi
+
+Web/knowledge-template-lab/package-lock.json
+  versionné
+  non ignoré
+```
+
+`rc.2` ne fournit pas `Cargo.lock` dans son delta.
+
+## Fichiers remplacés
+
+```text
+VERSION
+Cargo.toml
+docs/plans/001-V0_0_1_FOUNDATION_PLAN.md
+docs/validation/001-VALIDATION_MATRIX.md
+```
+
+## Fichier ajouté
+
+```text
+deltas/0.0.1/rc.2.md
+```
+
+Aucun fichier n'est supprimé.
+
+Aucun fichier sous `crates/` ou `Web/` n'est modifié.
+
+## Histories attendus
+
+La gate doit retrouver les seize histories antérieurs :
+
+```text
+alpha.1             FAIL
+alpha.1.fix.1       PASS
+alpha.2             PASS
+alpha.3             FAIL
+alpha.3.fix.1       FAIL
+alpha.3.fix.2       FAIL
+alpha.3.fix.3       PASS
+alpha.4             FAIL
+alpha.4.fix.1       FAIL
+alpha.4.fix.2       PASS
+alpha.5             FAIL
+alpha.5.fix.1       FAIL
+alpha.5.fix.2       PASS
+beta.1              PASS
+rc.1                FAIL
+rc.1.fix.1          PASS
+```
+
+Pendant la gate, `rc.2` est la seule tranche courante sans history.
+
+## Gate
+
+La candidate finale rejoue l'intégralité des preuves documentaires, Rust, Web, manifest et HTTP.
+
+Elle doit également vérifier avant et après Cargo :
+
+```text
+Cargo.lock existe localement
+Cargo.lock est ignoré
+Cargo.lock n'est pas suivi
+```
+
+## Transition
+
+Si `rc.2` est `PASS`, la seule transition autorisée est :
+
+```text
+0.0.1-rel.1
+```
+
+`rel.1` effectue la promotion stable et sa propre gate pré-tag. Le tag et le rapport post-tag restent postérieurs à cette promotion.
+
+Ne pas committe `rc.2` avant production de son history à partir des résultats opérateur.

docs/plans/001-V0_0_1_FOUNDATION_PLAN.md

@@ -1,5 +1,5 @@
 <!-- file: docs/plans/001-V0_0_1_FOUNDATION_PLAN.md -->
-<!-- version: 16 -->
+<!-- version: 17 -->
 
 # Plan 0.0.1 — fondation SaseDev Knowledge
 
@@ -269,6 +269,22 @@ La gate opérateur de `rc.1` reste **FAIL** à cause d'une assertion de gate inc
 
 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.
 
+La gate opérateur de `rc.1.fix.1` est **PASS** : `Cargo.lock` reste local/ignoré/non suivi, `package-lock.json` reste versionné et l'ensemble des audits Rust/Web/HTTP passe.
+
+### rc.2 — candidate finale sur politique stabilisée
+
+Rejouer une release candidate complète après le changement de politique `Cargo.lock`.
+
+`rc.2` ne modifie aucun code Rust, frontend, règle de produit, dépendance, roadmap, changelog candidat, étude ou prompt. Elle doit uniquement :
+
+- porter `VERSION = 0.0.1-rc.2` et la version workspace identique ;
+- confirmer que `Cargo.lock` reste présent localement, ignoré et absent de Git ;
+- confirmer que `package-lock.json` reste suivi ;
+- vérifier les seize histories antérieurs avec leurs statuts réels ;
+- confirmer que `rc.2` est le seul delta courant sans history pendant sa gate ;
+- rejouer la gate RC complète sur le scope final ;
+- autoriser `rel.1` uniquement après `PASS`.
+
 ### 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: 16 -->
+<!-- version: 17 -->
 
 # Matrice de validation Knowledge
 
@@ -458,3 +458,32 @@ Le fix RC doit prouver :
 - `git diff --cached --check` propre.
 
 Le fix `PASS` autorise la reprise de la release candidate vers `0.0.1-rc.2`.
+
+## Gate de `0.0.1-rc.2`
+
+La candidate finale doit prouver :
+
+- `VERSION = 0.0.1-rc.2` et version workspace identique ;
+- history `rc.1.fix.1` `PASS` committé avant application ;
+- aucun diff sous `crates/` ou `Web/` ;
+- `/Cargo.lock` toujours présent dans `.gitignore` ;
+- `Cargo.lock` présent localement, ignoré et absent de `git ls-files` ;
+- `package-lock.json` toujours suivi et non ignoré ;
+- exactement sept packages Cargo ;
+- seize histories antérieurs présents avec leurs statuts réels ;
+- `deltas/0.0.1/rc.2.md` présent et `history/0.0.1/rc.2.md` absent pendant la gate ;
+- `CHANGELOG.md` conserve `## 0.0.1 (candidate)` ;
+- `ROADMAP.md` conserve `0.0.1` planifié, `0.0.2` engagé et aucun `0.0.3` ;
+- prompt `002` toujours bloqué jusqu'au tag stable `v0.0.1` et au rapport post-tag `PASS` ;
+- aucune nouvelle fonctionnalité, dépendance ou décision de produit ;
+- audits Markdown headers/tables/links propres ;
+- hygiène texte globale propre ;
+- `cargo fmt --check`, audit de layout des tests et audits Rust propres ;
+- `cargo metadata`, `cargo check`, Clippy strict et tests workspace propres malgré le lockfile non suivi ;
+- les commandes Cargo ne réintroduisent pas `Cargo.lock` dans Git ;
+- `npm ci`, typecheck et build Web propres ;
+- manifest Vite parsable ;
+- smoke HTTP des trois launchers propre ;
+- staging final sans `Cargo.lock` et `git diff --cached --check` propre.
+
+Un `PASS` de `rc.2` autorise uniquement `0.0.1-rel.1`.

history/0.0.1/rc.2.md

@@ -0,0 +1,164 @@
+<!-- file: history/0.0.1/rc.2.md -->
+<!-- version: 1 -->
+
+# History 0.0.1-rc.2 — candidate finale sur politique `Cargo.lock` stabilisée
+
+## Statut
+
+PASS
+
+La gate opérateur de `0.0.1-rc.2` exécutée le `2026-09-28` est propre.
+
+## Baseline opérateur
+
+`rc.1.fix.1` `PASS` a été historisé, committé et poussé avant application de `rc.2` :
+
+```text
+history/0.0.1/rc.1.fix.1.md = PASS
+commit       c9fee69
+message      0.0.1-rc.1.fix.1
+branch       master
+push         origin/master PASS
+status       clean après push
+```
+
+`Cargo.lock` est absent du repository à partir de ce commit tout en restant présent localement et ignoré.
+
+## Incident opérateur local récupéré
+
+Après application de `rc.2`, un commit local a été créé par erreur avec le message `0.0.1-rc.1.fix.1` :
+
+```text
+6ddb230
+```
+
+Ce commit n'a jamais été poussé : la tentative de push a été interrompue au prompt d'authentification.
+
+La situation a été vérifiée explicitement :
+
+```text
+HEAD          6ddb230
+origin/master c9fee69
+```
+
+puis récupérée avec :
+
+```text
+git reset --mixed origin/master
+```
+
+Après récupération :
+
+```text
+HEAD = c9fee69
+```
+
+et les cinq changements `rc.2` sont redevenus des modifications locales/non suivies. Aucun historique distant n'a été réécrit et aucun commit publié n'a été altéré.
+
+## Contrôles initiaux après récupération
+
+Les preuves suivantes passent :
+
+```text
+VERSION = 0.0.1-rc.2
+git diff --check                    PASS
+cargo fmt --all -- --check         PASS
+aucun diff sous crates/ ou Web/    PASS
+```
+
+La politique de lockfile reste correcte :
+
+```text
+Cargo.lock local                    présent
+Cargo.lock ignore                   actif
+Cargo.lock suivi par Git            non
+package-lock.json suivi             oui
+```
+
+## Audit d'intégration RC
+
+Après récupération du commit local erroné, l'audit corrigé passe :
+
+```text
+Knowledge 0.0.1-rc.2 integration audit: clean (16 prior histories)
+```
+
+Il confirme notamment les seize histories antérieurs, le changelog encore candidat, la roadmap avec `0.0.2` engagée sans `0.0.3` et le handoff `0.0.2` toujours conditionné au tag stable et au rapport post-tag `PASS`.
+
+## Markdown et hygiène texte
+
+Les audits PGR passent :
+
+```text
+Markdown header audit: clean (48 file(s))
+Markdown table audit: clean (4 table(s), 48 file(s))
+Markdown link audit: clean (28 local link(s), 48 file(s))
+Knowledge 0.0.1-rc.2 text hygiene: clean
+```
+
+## Rust
+
+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)
+```
+
+Les sept packages compilent en version `0.0.1-rc.2`. `cargo check`, Clippy strict et les tests workspace passent : `knowledge-domain-lib` 3, `knowledge-git-api` 1, `knowledge-sync-api` 1 et `knowledge-web-lib` 4 tests `PASS`.
+
+Après Cargo, `Cargo.lock` reste présent localement, ignoré et absent de Git.
+
+## Web et manifest
+
+Les commandes `npm ci`, `npm run typecheck` et `npm run build` passent. Le warning `@parcel/watcher@2.6.0` reste observable mais non approuvé et non bloquant.
+
+L'audit du manifest passe :
+
+```text
+Knowledge 0.0.1-rc.2 Vite manifest audit: clean
+JS  assets/assets/main-BMHcm6u9.js
+CSS assets/main-V0IwlRbh.css
+```
+
+## Smokes HTTP
+
+Après récupération du commit local erroné, les trois launchers passent explicitement :
+
+```text
+knowledge-pgr-server      smoke PASS
+knowledge-howtos-server   smoke PASS
+knowledge-snippets-server smoke PASS
+Knowledge 0.0.1-rc.2 HTTP smoke: clean
+```
+
+## Hygiène Git finale
+
+Les contrôles finaux passent. Le staging observé avant ajout du présent history est exactement :
+
+```text
+M  Cargo.toml
+M  VERSION
+A  deltas/0.0.1/rc.2.md
+M  docs/plans/001-V0_0_1_FOUNDATION_PLAN.md
+M  docs/validation/001-VALIDATION_MATRIX.md
+```
+
+## Décision
+
+`0.0.1-rc.2` est `PASS`.
+
+La candidate finale est validée sur la politique `Cargo.lock` définitive.
+
+La seule transition autorisée est :
+
+```text
+0.0.1-rel.1
+```
+
+`rel.1` doit rester une promotion stable mécanique et pré-tag. Le tag `v0.0.1` et le rapport post-tag ne doivent être créés qu'après un history `rel.1` réellement `PASS` et le commit stable `0.0.1`.