🛸 genesis : papiers + specs Palier 0 + modèles 3D + vérif physique

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

specs/adressage-generatif-triplet-v0.md

@@ -0,0 +1,138 @@
+# LE TRIPLET — spec v0 de l'Adressage Génératif
+
+> Le format éternel commun à la **position**, au **DM** et à la **réplication**.
+> Ce qu'on gèle ici, c'est la primitive `C2` du paper *L'Adressage Génératif* (§2.2, P0) et
+> le protocole *XI0N-résidu* de *fractales-de-reel* (§7) : une seule donnée, trois usages.
+>
+> J0bot · Juillet 2026 · AGPL-3.0 · **spec — v0** · `adressage-generatif-triplet-v0`
+> Convention : `[POSÉ]` = gelé/décidé · `[HYPOTHÈSE]` = attendu mais non prouvé dans le repo.
+
+## 0. Ce que ce document gèle
+
+Une donnée n'est pas un contenu qu'on garde, c'est une **adresse** dans un espace génératif : un
+point qu'on retrouve. La spec v0 fige le format de cette adresse — le **triplet** — et les trois
+opérations dessus (LIRE, ÉCRIRE, ALIGNEMENT). Le triplet ne change plus en grandissant : c'est le
+« connecteur logiciel » de XERB0XI0N, l'équivalent du CFC matériel. Tout le reste (les générateurs,
+la navigation, le réseau) se construit *au-dessus* et peut évoluer ; le triplet, non.
+
+## 1. La donnée — le triplet `[POSÉ]`
+
+```
+triplet = ( hash_générateur , coordonnées , hash_résidu )
+          └─ BLAKE3, 32 o ─┘ └─ opaque ──┘ └─ BLAKE3, 32 o ─┘
+```
+
+Trois champs, tous de taille bornée. **Le triplet est pure adresse** : il ne contient aucun octet de
+contenu, seulement des références vérifiables.
+
+- **hash_générateur** — BLAKE3 d'un **générateur** : un programme pur, déterministe, sandboxé
+  (module WASM, `C0`). Il se résout dans le store adressé par contenu (`C1`, modèle Git/BLAKE3) en un
+  module exécutable. Le générateur est un **bien commun** : répliqué gratuitement, amorti sur toutes
+  les données qui le citent.
+- **coordonnées** — localisent la donnée *dans* ce générateur : seed, `x/y/z/t`, index Hilbert 4D du
+  Cubion, clé, temps. Minuscule, une par donnée. Le format interne des coordonnées est propre au
+  domaine du générateur ; le triplet les traite comme opaques.
+- **hash_résidu** — BLAKE3 du **résidu** : l'écart, au bit près, entre ce que le générateur prédit
+  et ce que le réel a fait. Se résout dans le store en un bloc d'octets (éventuellement vide). Le
+  résidu est la **seule part qui exige du stockage** — l'unité de réel, le Tsoin.
+
+Cas dégénérés `[POSÉ]` (rétrocompatibilité éternelle) : générateur = identité ⇒ résidu = la donnée
+entière (stockage classique) ; résidu = vide ⇒ pure structure (génération procédurale). Le réel est
+entre les deux, facturé à hauteur de sa surprise.
+
+## 2. Les trois opérations `[POSÉ]`
+
+Soit `G = store[hash_générateur]`, `R = store[hash_résidu]`.
+
+- **LIRE** — `donnée = G(coordonnées) ⊕ R`.
+  `⊕` est l'opérateur de recombinaison bit-exact du domaine (le cas dégénéré est un XOR / une somme).
+  On régénère la prédiction et on y applique l'écart. Déterministe, bit pour bit, sur toute machine,
+  à toute époque. *Complet en adresses, paresseux en calcul* : déplier coûte du calcul (profondeur de
+  Bennett, §3), c'est le prix assumé.
+- **ÉCRIRE** — choisir un générateur `G`, calculer `R = donnée ⊖ G(coordonnées)`, **ne garder que
+  `R`**. Écrire, c'est ne conserver que l'écart au prédictible. Asymétrie assumée : lire est rapide,
+  bien écrire est lent (trouver un bon `G` est coûteux, §3) ⇒ encodage différé + ré-encodage
+  rétroactif quand un meilleur générateur apparaît (le système comprime son propre passé).
+- **ALIGNEMENT** — deux nœuds partagent un générateur **ssi `hash_générateur` est égal des deux
+  côtés**. C'est une égalité de hash, **décidable au bit** — pas une synchronisation floue. Deux
+  triplets qui citent le même générateur ne diffèrent que par `(coordonnées, hash_résidu)` : on
+  **diffe des adresses au lieu de transporter des blobs**. C'est le levier de tout le reste.
+
+## 3. Les garde-fous honnêtes `[POSÉ]`
+
+Sans eux, la promesse ment. Aucun n'est contournable.
+
+1. **Le mur de Kolmogorov.** Le résidu d'un vrai aléatoire est **incompressible** : il coûte son
+   poids plein, toujours. « Tout dans un kilo-octet » est faux. Le système *catalogue* cette borne
+   au lieu de la cacher ; la part de réel-pur ne devient jamais gratuite.
+2. **Le meilleur générateur est non-calculable.** `K(x)` n'est pas calculable ; la recherche
+   universelle de Levin trouve l'optimum mais en temps exponentiel. On ne publie **jamais l'optimum** —
+   on publie des **majorants nommés** (un panel de compresseurs identifiés, BIONLIB en est un) et une
+   grandeur honnête : **`certitude = 1 − L_min / L_baseline`**, qui monte à chaque raffinement sans
+   jamais atteindre 1. « Envoyer en fractale de réel » est aussi bon que le meilleur générateur connu
+   du domaine, ni plus.
+3. **Coût de dépliage (Bennett).** Un générateur court peut demander un temps de calcul énorme.
+   Le triplet troque de la bande passante/du stockage contre du calcul chez le lecteur — bon échange
+   sur un lien lent et lointain, pas toujours en local.
+4. **Générateurs appris ≠ bit-exacts → opt-in au bord, jamais dans le format éternel.** Les codecs
+   neuronaux (COIN/COIN++) et les floats non reproductibles entre architectures sont un **slot
+   opt-in**, activable *au bord* d'un domaine, jamais dans le triplet gelé. Le cœur reste bit-exact
+   (IFS entier, WASM de référence, quantization entière). Un générateur qui ne redonne pas le même bit
+   partout ne peut pas porter un `hash_générateur` du format éternel.
+5. **GPG non-optionnel.** Le résidu est la seule part irréductible et sensible ; il est **toujours**
+   chiffré GPG au repos et en transit. Les générateurs, communs et publics, ne le sont pas.
+6. **Opt-in & droit au silence.** Rien n'est capturé ni régénéré sans consentement explicite. Une
+   donnée peut ne jamais être écrite. **Ne pas nuire** gouverne le format autant que le code.
+
+## 4. Les trois applications — une donnée, trois usages
+
+- **Position.** Une trajectoire GPS brute répète des blobs lat/long quasi identiques. En triplet :
+  générateur = modèle de mouvement (vitesse ~constante, chemin prédictible) ; coordonnées = index
+  temps ; résidu = l'**écart** à la position prédite. On ne stocke que la surprise du déplacement.
+  La coordonnée *est* la position ; le blob répété disparaît.
+- **DM entre amis.** Deux amis qui partagent le même `hash_générateur` (leur contexte commun : langue,
+  historique, modèle partagé) n'échangent que `(coordonnées, résidu)` — le résidu étant **l'écart au
+  prédictible**. Le récepteur régénère le reste. C'est `K(x | générateur) ≪ K(x)` : le message
+  s'effondre à sa seule surprise. L'ALIGNEMENT par hash rend « on partage bien le même générateur »
+  décidable, pas espéré.
+- **Réplication.** Entre deux boxions/nœuds, on ne **transmet et ne chiffre (GPG) que les résidus** ;
+  les générateurs sont des **communs gratuits**, déjà des deux côtés (règle 50/50 : le réseau protège
+  exactement l'irréductible). Mars↔Terre n'échangent que ce que l'autre ne pouvait pas prédire.
+
+Le fil commun : dans les trois cas, ce qui voyage/se garde n'est jamais l'instant, c'est **l'écart
+entre l'instant et ce que l'autre bout savait déjà en prédire.** Position, DM et réplication sont la
+même opération à trois échelles.
+
+## 5. Ce que ça débloque concrètement dans le repo
+
+- **Manifeste de réplication diff-only.** Aujourd'hui `/replicate` pousse un **bundle complet signé**
+  (les deux bouts ne partagent pas encore le générateur). Le triplet transforme ça en réplication
+  **diff-only** : le manifeste devient une liste de triplets ; quand `hash_générateur` est déjà
+  présent chez le récepteur (ALIGNEMENT), on ne transmet que `(coordonnées, hash_résidu)` + le résidu
+  chiffré GPG. C'est *XI0N-résidu* (§7 de *fractales-de-reel*) — une page de protocole, pas une techno
+  à inventer, testable dès aujourd'hui en logiciel sur le xion (deux nœuds fédérés, gain mesuré comme
+  le 882× : octets du résidu vs octets de l'instant déplié).
+- **Bion network.** Un bion *est* un tsoin : il ne stocke pas sa sortie, il stocke son générateur
+  (référence/recette) et se rejoue. C'est le triplet descendu au niveau primitive
+  (`timer-tsoin = {ms}`, `son-tsoin = {source, id, position}`). Le format v0 donne à un bion runtime
+  (WASM, ex. `json_str`) et à un bion web (`timer-bion`) **le même identifiant** (`hash_générateur`),
+  donc un ploxion-écran peut référencer un bion partagé au lieu de le recopier : la flotte passe de N
+  monolithes à un alphabet de bions + une nuée de specs. Le triplet est le contrat qui rend un bion
+  citable, partageable et rejouable à travers les deux mondes.
+- **Contrat jOSPresence.** La présence live (curseurs, post-its LWW, collab) n'a pas besoin d'émettre
+  l'état : un émetteur et un récepteur qui partagent le `hash_générateur` d'un modèle de présence
+  n'échangent que `(coordonnées, résidu)` sur le PL0XI0N Bus, et le récepteur régénère. Le format v0
+  fige le paquet que jOSPresence met sur le bus — l'écart, chiffré, aligné par hash — au lieu d'un
+  blob d'état répété.
+
+---
+
+*Reste à faire (P1 du paper) : le codec aller-retour `image → triplet → image` bit-pour-bit, mesuré
+vs PNG/JPEG, qui prouve `⊕` sur un vrai média. La navigation Hilbert (`C5`, zoom = descente Merkle)
+consomme ce même format.*
+
+*Décisions encore ouvertes (héritées de §12 du paper) : nom canonique du composant · sémantique de
+**merge** des résidus (deux écarts concurrents sur le même point) · périmètre exact du gel v1.*
+
+*Ne pas nuire. On ne transmet jamais du réel — seulement de la surprise sur fond de structure commune.*
+*AGPL-3.0 · Juillet 2026 · adressage-generatif-triplet-v0*

specs/cubion-docking-standard-v0.md

@@ -0,0 +1,150 @@
+# CUBION DOCKING STANDARD — spec v0 de l'amarrage universel du space-cubion
+
+> La face du space-cubion est le **connecteur éternel** de la matière, comme le triplet est le
+> connecteur éternel de la donnée (@ref{adressage-generatif-triplet-v0}) et le CFC RS-485/π le
+> connecteur de face du Cubion terrestre (@ref{cubion:3}). Ce qu'on gèle ici : la géométrie des
+> six faces, ce qui traverse une face, et le cycle de vie **mount = amarrage / unmount = fork**.
+>
+> J0bot · Août 2026 · AGPL-3.0 · **spec — v0** · `cubion-docking-standard-v0` · 🛸
+> Convention : `[POSÉ]` = gelé/décidé · `[HYPOTHÈSE]` = attendu mais non prouvé.
+> Régimes : RÉEL (physique établie) · PRÉSENT (ingénierie 2026 plausible) · TURFU (spéculatif).
+>
+> **Vocabulaire** : « cubion » a DEUX sens dans XERB0XI0N. Le sens logiciel (une composition de
+> ploxions, `config/cubions.php`) et le sens vaisseau (**space-cubion**, ce document,
+> `config/cubions_vaisseau.php`). Les deux coexistent ; le registre est séparé. Décision RS-7, 11.08.
+
+## 0. Ce que ce document gèle
+
+Un space-cubion est un ploxion physique (@ref{space-cubion:2}) : une brique autonome qui s'agrège
+par contrat et se sépare proprement. Ce standard fige l'interface qui rend ce contrat mécanique :
+**six faces identiques, androgynes, éternellement rétrocompatibles**. Tout le reste du vaisseau
+(propulsion, habitat, matériaux) peut évoluer librement ; la face, non. C'est le même dogme que le
+triplet : le connecteur ne change plus en grandissant, sinon la forkabilité meurt avec la première
+génération incompatible. Un space-cubion de l'an 3000 doit pouvoir s'amarrer à un space-cubion
+d'aujourd'hui — la **rétrocompatibilité éternelle** n'est pas une préférence d'ingénierie, c'est la
+condition de survie du droit de partir.
+
+## 1. Géométrie : six faces identiques androgynes `[POSÉ]`
+
+- **Arête nominale 4 m = 2⁸ bions.** Le Bion fait 16 mm (2⁴ mm) ; 2⁸ bions = 4 096 mm. On dit
+  « 4 m » ; la cote exacte gelée est **4,096 m** — la chaîne base-2 du Bion au vaisseau ne se
+  brise jamais (@ref{space-cubion:8.1}). Volume ~69 m³, dont ~35–45 m³ habitables.
+- **Les 6 faces sont identiques.** Pas de face « avant », pas de mâle/femelle : toute face de tout
+  space-cubion s'amarre à toute face de tout autre. Symétrie de rotation 90° : quatre orientations
+  d'amarrage valides par face, l'agrégat pave ℤ³ sans contrainte d'attitude.
+- **Androgyne = extension d'un standard RÉEL.** L'International Docking System Standard (IDSS,
+  publié par le Multilateral Coordination Board de l'ISS, IDD rev. E, héritier des mécanismes
+  androgynes APAS-89/95 ; implémenté par le NASA Docking System et le Crew Dragon) prouve depuis
+  des années que le docking androgyne any-to-any **vole**. Le CDS reprend l'architecture IDSS
+  (anneau de soft capture + verrouillage hard capture + tunnel pressurisé Ø ≥ 800 mm) et l'étend
+  sur trois points que l'IDSS ne couvre pas : cadre carré pleine-face (au lieu d'un port
+  circulaire sur une coque), **transfert de fluides obligatoire**, et handshake logiciel signé (§3).
+- **Une face = un cadre 4 m**, comportant :
+  1. le **passage pressurisé** central (Ø ≥ 800 mm, héritage IDSS, écoutilles des deux côtés) ;
+  2. la **structure** : reprise des efforts d'accélération et de couple à travers l'agrégat
+     (l'agrégat est UNE structure, pas un chapelet) ;
+  3. les **connecteurs périphériques** : puissance · données · fluides (§2).
+
+## 2. Ce qui traverse une face `[POSÉ]` sur la liste, `[HYPOTHÈSE]` sur les dimensionnements
+
+| Bus | Contenu | Héritage |
+|---|---|---|
+| ⚡ puissance | bus continu partagé, chaque cubion source ou puits | umbilicaux IDSS |
+| ⇄ données | le CFC spatial : successeur du cubionlink RS-485, magic number π (@ref{cubion:3}) + lien optique haut débit | cubionlink |
+| 💧 fluides | eau, air, ergols — transfert et égalisation | ravitaillement ISS |
+| ♨ **caloduc** | interface thermique inter-cubion — **OBLIGATOIRE**, non négociable | boucles diphasiques |
+
+**Pourquoi le caloduc est obligatoire : la 2e loi carré-cube, thermique** (RÉEL,
+@ref{space-cubion:15}). Dans un agrégat, la puissance dissipée croît avec le volume (∝ r³) mais la
+surface qui rayonne croît avec la surface (∝ r²). Pour un agrégat sphérique de rayon r à puissance
+volumique q_v uniforme, le flux que la croûte doit évacuer vaut q_v·r/3 ; avec une capacité
+radiative surfacique q_s, la profondeur thermique maximale est :
+
+r_therm = 3·q_s / q_v
+
+Ordre de grandeur honnête : un space-cubion qui dissipe ~10 kW dans ~64 m³ donne q_v ≈ 150 W/m³ ;
+un radiateur corps-noir à 300 K rayonne q_s ≈ 460 W/m². D'où r_therm ≈ 9 m — **à peine deux
+cubions de profondeur**. Sans réseau thermique traversant les faces, tout agrégat 3×3×3 cuit son
+noyau. La conclusion architecturale est la même que pour la propulsion : **la croûte est le
+radiateur du noyau**, exactement comme elle est son moteur (@ref{space-cubion:4}). Le caloduc
+inter-cubion est donc du même rang que la structure : une face sans interface thermique n'est pas
+conforme CDS. (Les radiateurs déployables de croûte et les températures de boucle sont
+`[HYPOTHÈSE]` de dimensionnement, pas de principe.)
+
+## 3. mount = amarrage : le handshake `[POSÉ]`
+
+Le space-cubion est un ploxion : son cycle de vie est contractuel. `mount` se déroule en cinq
+temps, et **l'ordre est gelé** — le logiciel avant l'ouverture, toujours :
+
+1. **Approche + soft capture** — amortissement, alignement (mécanique pure).
+2. **Hard capture** — verrouillage structurel, vérification d'étanchéité.
+3. **Handshake logiciel** (sur le CFC, avant toute ouverture) :
+   - échange et vérification mutuelle des **identités GPG** (le space-cubion porte la clé de son
+     propriétaire — l'identité est physique, comme le bion personnel, @ref{cubion:3}) ;
+   - échange des **vector clocks** et premier merge des logs (@ref{xion-relativiste-v0}) ;
+   - **ALIGNEMENT au sens du triplet** : comparaison des `hash_générateur` — tout ce qui est déjà
+     commun ne sera jamais retransmis ; seuls les résidus voyagent, chiffrés GPG
+     (@ref{adressage-generatif-triplet-v0:2}).
+4. **Négociation de ressources** — raccordement puissance, données, fluides ; le nouvel arrivant
+   **rejoint le réseau caloduc** (sa charge thermique est ré-routée vers la croûte courante).
+5. **Ouverture du passage** — l'amarrage est complet ; l'agrégat a grandi d'un cubion.
+
+Un amarrage dont le handshake logiciel échoue reste en mode **quai** : capture mécanique, zéro
+fusion d'état, zéro ouverture. On peut se tenir sans se faire confiance.
+
+## 4. unmount = fork : la séparation propre `[POSÉ]`
+
+`unmount` est un **droit unilatéral** — c'est la définition du space-cubion comme unité de
+consentement (@ref{space-cubion:2}). La séquence gelée :
+
+1. **Déclaration de fork** — aucun accord de l'agrégat requis ; un préavis, oui (le temps de la
+   séquence, pas un droit de veto).
+2. **Merge final** — dernier échange de logs ; les deux historiques repartent chacun avec le VC de
+   l'autre. Divergence = branche, au sens git (@ref{xion-relativiste-v0:4}).
+3. **Découplage ressources** — purge des lignes de fluides, isolation du bus de puissance,
+   **ré-autonomie thermique AVANT séparation** (le partant redéploie ses propres radiateurs ; on ne
+   largue jamais un cubion qui va cuire).
+4. **Droit au silence** — le partant libère toutes les ressources qu'il occupait dans l'agrégat et
+   peut cesser d'émettre. Rien de lui n'est retenu, rien ne lui est réclamé.
+5. **Séparation mécanique + delta-v de départ.**
+
+**Invariant de consentement** (RÉEL, formule @ref{space-cubion:2}) : à tout instant, chaque
+space-cubion maintient
+
+Δv_réserve ≥ v_esc(plus gros agrégat consenti) = r·√(8πGρ/3)
+
+Repères : r = 100 m, ρ = 2 000 → v_esc ≈ 0,11 m/s (le fork est gratuit) ; r = 100 km, ρ = 2 500 →
+≈ 0,12 km/s ; agrégat lunaire → ≈ 2,37 km/s. **S'amarrer à plus gros que sa réserve, c'est
+renoncer de fait au droit de partir** : le contrat de mount vérifie cet invariant au handshake
+(étape 3) et refuse — ou dégrade en mode quai — si la réserve du candidat est insuffisante. Le
+droit de partir se dimensionne, il ne se décrète pas.
+
+## 5. Rétrocompatibilité éternelle `[POSÉ]` — le dogme
+
+- La géométrie de face (cadre 4,096 m, passage Ø 800 mm, position des connecteurs) ne change
+  **jamais**. Les évolutions passent par des capacités *négociées au handshake* (étape 4), jamais
+  par une rupture d'interface — le modèle est le triplet : le format est gelé, les générateurs
+  au-dessus évoluent.
+- Toute version future du CDS doit s'amarrer à un cubion v0 en mode dégradé au minimum
+  (structure + passage + caloduc). Le caloduc fait partie du socle éternel, pas des options.
+- Un agrégat mixte multi-générations est le cas **nominal**, pas l'exception : c'est l'anatomie
+  géologique du vaisseau-mère (@ref{space-cubion:4}) — chaque couche une époque, toutes amarrées.
+
+## 6. Ce qui reste à prototyper `[HYPOTHÈSE]`
+
+- Le mécanisme de capture pleine-face carré (l'IDSS est circulaire sur coque ; le cadre carré
+  structurel est une extension non volée à ce jour) — Palier 0 : deux prototypes s'amarrent, se
+  séparent proprement et mergent leurs logs (@ref{space-cubion:14}).
+- Dimensionnement du réseau caloduc (fluide, températures de boucle, radiateurs de croûte
+  déployables/rétractables au fil des mounts).
+- Transfert d'ergols cryogéniques par la face (l'égalisation eau/air est acquise à l'échelle ISS ;
+  le cryo inter-modules ne l'est pas).
+- Le surcoût massique du cube pressurisé vs cylindre (+20–40 %) : prix assumé du pavage, à
+  mesurer sur prototype.
+- Reprise des efforts à 1 g d'accélération soutenue à travers N faces empilées (l'ISS n'accélère
+  pas ; un agrégat qui pousse, si).
+
+---
+
+*Ne pas nuire. Le standard n'existe que pour une chose : que partir reste toujours possible.*
+*AGPL-3.0 · Août 2026 · cubion-docking-standard-v0*

specs/xion-relativiste-v0.md

@@ -0,0 +1,157 @@
+# XION RELATIVISTE — spec v0 du protocole de réconciliation causale
+
+> Deux space-cubions qui se retrouvent ont vécu des durées propres différentes, et aucune montre
+> n'a raison contre l'autre (@ref{space-cubion:10}). Ce qu'on gèle ici : l'horloge logique de
+> chaque space-cubion, l'estampille causale de chaque tsoin, et la sémantique de merge — dont la
+> **décision RS-7 gelée** : le conflit est un **fork visible**, jamais un écrasement silencieux.
+>
+> J0bot · Août 2026 · AGPL-3.0 · **spec — v0** · `xion-relativiste-v0` · 🛸
+> Convention : `[POSÉ]` = gelé/décidé · `[HYPOTHÈSE]` = attendu mais non prouvé.
+> Régimes : RÉEL (physique/informatique établies) · PRÉSENT (à câbler dans le repo) · TURFU.
+
+## 0. Ce que ce document gèle
+
+La relativité interdit l'horloge universelle (relativité de la simultanéité, Einstein) ;
+l'informatique distribuée a résolu exactement ce problème en l'abandonnant : ce qui compte n'est
+pas le temps absolu mais l'**ordre causal** (Lamport, « Time, Clocks, and the Ordering of Events
+in a Distributed System », CACM 1978). Le XION relativiste applique cette solution au réseau des
+space-cubions : chaque événement est un tsoin estampillé d'un **vector clock**, le merge de deux
+historiques est un **CRDT**, le transport est **DTN** (aucune simultanéité supposée, aucune
+connexion permanente supposée). Tout est RÉEL au sens des régimes : chaque brique de ce protocole
+est de l'informatique éprouvée — la seule nouveauté est de la brancher sur un problème de
+physique. Le même mécanisme qui réconcilie deux forks d'une base réconcilie deux vaisseaux qui ont
+vécu des temps propres différents.
+
+## 1. L'horloge : le vector clock `[POSÉ]`
+
+Chaque space-cubion `i` maintient un **vector clock** VC_i (Fidge 1988, Mattern 1989) : une map
+`{id_cubion → compteur}` sur les cubions qu'il connaît. Règles gelées (les règles canoniques) :
+
+1. **Événement local** (tout tsoin émis) : VC_i[i] += 1.
+2. **Émission** : le tsoin part avec une copie du VC_i courant.
+3. **Réception/merge** : VC_i ← max composante-par-composante(VC_i, VC_reçu), puis VC_i[i] += 1.
+
+Ce que ça donne, et c'est tout ce qu'il faut (RÉEL) :
+
+- **happened-before décidable** : e₁ → e₂ ssi VC(e₁) < VC(e₂) (≤ partout, < quelque part).
+- **concurrence détectable** : e₁ ∥ e₂ ssi ni VC(e₁) ≤ VC(e₂) ni VC(e₂) ≤ VC(e₁). Deux tsoins
+  concurrents ont été émis dans des branches causalement disjointes — des lignes d'univers qui ne
+  se sont pas parlé. Le VC capture la **causalité complète**, pas une approximation.
+
+Aucun champ « temps absolu » ne participe aux décisions du protocole. Le temps propre (horloge de
+bord) reste enregistré à titre de témoin humain, jamais d'arbitre.
+
+## 2. Le tsoin estampillé `[POSÉ]`
+
+L'unité répliquée est le triplet gelé (@ref{adressage-generatif-triplet-v0:1}), enveloppé :
+
+```
+tsoin-relativiste = {
+  triplet   : ( hash_générateur , coordonnées , hash_résidu ),   // le format éternel, inchangé
+  vc        : { id_cubion → compteur },                          // l'estampille causale (§1)
+  auteur    : empreinte GPG,                                     // qui l'a émis
+  signature : GPG(triplet ‖ vc)                                  // intégrité + non-répudiation
+}
+```
+
+Le triplet lui-même **ne change pas** : le VC est une enveloppe de transport/merge, pas une
+modification du format éternel. Le résidu reste chiffré GPG au repos et en transit ; les
+générateurs restent des communs publics (@ref{adressage-generatif-triplet-v0:3}).
+
+## 3. L'ALIGNEMENT décide quoi diffuser `[POSÉ]`
+
+Au contact (amarrage §3 du CDS, ou simple passage radio), deux cubions comparent leurs
+`hash_générateur` : l'ALIGNEMENT du triplet est une égalité de hash, décidable au bit. Tout
+générateur commun ne sera jamais retransmis ; on ne diffuse que les tsoins dont le VC n'est pas
+déjà dominé par le VC du récepteur, et pour ceux-là uniquement `(coordonnées, hash_résidu, vc,
+signature)` + le résidu chiffré. C'est la réplication diff-only du triplet
+(@ref{adressage-generatif-triplet-v0:5}), avec le VC comme filtre anti-doublon : **on ne
+transporte que la surprise causalement neuve.**
+
+## 4. Le merge `[POSÉ]` — et la décision RS-7 gelée
+
+Le merge de deux historiques doit être **déterministe, commutatif, associatif, idempotent** — les
+propriétés CRDT (Shapiro, Preguiça, Baquero, Zawirski, « Conflict-free Replicated Data Types »,
+SSS 2011). Conséquence : l'ordre des retrouvailles ne compte pas, re-merger ne coûte rien, N
+cubions qui se retrouvent dans n'importe quel ordre convergent vers le même état. C'est la
+propriété qui rend l'essaim possible : aucun coordinateur, aucune session globale, jamais.
+
+Cas par cas :
+
+- **e₁ → e₂** (causalement ordonnés) : e₂ raffine e₁. Aucun conflit, le merge est l'union des
+  logs — l'histoire est simplement plus complète d'un côté.
+- **e₁ ∥ e₂ sur des points différents** : union, trivialement.
+- **e₁ ∥ e₂ sur le MÊME point** (même `hash_générateur` + mêmes `coordonnées`, résidus
+  différents) : c'est LE cas dur, la décision ouverte du triplet-v0 (« sémantique de merge des
+  résidus », @ref{adressage-generatif-triplet-v0}). **DÉCISION RS-7, GELÉE (11.08) :**
+
+> **Multi-Value Register : les DEUX branches sont conservées et exposées comme FORK VISIBLE.**
+> Jamais d'écrasement silencieux, jamais d'arbitrage automatique qui jette de l'information.
+> **Divergence = branche, retrouvaille = merge, conflit = fork visible — au sens git.**
+
+Le MV-Register est un CRDT spécifié (Shapiro et al. 2011 ; c'est la sémantique des « siblings »
+de Dynamo/Riak, DeCandia et al., SOSP 2007) : la valeur d'un point devient l'ensemble des versions
+concurrentes maximales, chacune avec son VC. La **résolution** d'un fork n'est jamais le fait du
+protocole : c'est un **nouveau tsoin**, émis par un humain ou une règle de domaine explicite, dont
+le VC domine toutes les branches — le fork se referme comme un merge commit, tracé, signé,
+event-sourcé. Deux équipages qui ont pris des décisions incompatibles pendant des années de
+désynchronisation relativiste retrouvent leurs deux histoires **intactes et côte à côte**, puis
+tranchent en connaissance. Le protocole garantit qu'aucune branche ne disparaît sans un acte
+explicite ; la gouvernance du choix reste politique, et c'est voulu (@ref{space-cubion:15}).
+
+## 5. Le transport : DTN / Bundle Protocol `[POSÉ]`
+
+Le réseau des space-cubions ne suppose **aucune simultanéité et aucune connectivité de bout en
+bout** — exactement le modèle du Delay-/Disruption-Tolerant Networking : architecture RFC 4838
+(Cerf et al., 2007), Bundle Protocol version 7 RFC 9171 (2022). Store-and-forward : chaque cubion
+porte les bundles qu'il ne peut pas encore livrer, et tout contact (amarrage, survol, relais
+laser @ref{space-cubion:11}) est une opportunité de livraison. Le DTN tourne déjà sur l'ISS —
+« tsoin over Bundle Protocol » est une phrase de câblage, pas un programme de recherche. Latence
+des heures, des années : indifférent — le VC ordonne, le bundle attend, le merge converge. Un
+tsoin est un bundle ; un amarrage est un contact à très haut débit ; un cubion en croisière est
+un nœud DTN qui muletise l'histoire de l'essaim.
+
+## 6. Chemin de migration : du LWW au VC/MVR
+
+**État réel du repo** : `StateReplicationController` (`app/Http/Controllers/StateReplicationController.php`)
+fait du **newer-wins par horloge murale** — chaque entrée KV porte un `savedAt` ISO8601, `cmpAt()`
+compare les instants, le plus récent gagne, et le cas « local plus récent » est déjà remonté dans
+un tableau `conflicts` (kept: local). C'est du LWW : déterministe et idempotent, oui, mais il
+**jette silencieusement une des deux écritures concurrentes** et fait confiance à des horloges
+murales que la relativité (et le simple clock-skew) désynchronise. La STRUCTURE pull/apply est
+bonne ; l'arbitre est le maillon à remplacer. Migration en quatre pas, chacun shippable :
+
+1. **Double-estampille** : chaque entrée gagne un champ `vc` à côté de `savedAt` (les nœuds sont
+   les boxions/cubions du registre). Aucun comportement ne change — on pose l'horloge.
+2. **VC d'abord, savedAt en secours** : `pull` compare les VC quand les deux entrées en ont un ;
+   dominance → apply/skip comme aujourd'hui. Sans VC des deux côtés, `cmpAt` reste l'arbitre
+   (rétrocompatibilité avec les nœuds non migrés — éternelle, comme il se doit).
+3. **MVR** : VC concurrents → **plus d'écrasement ni de kept-local** : l'entrée devient
+   multi-branches `{branches: [{data, vc, savedAt, auteur}, …]}`, le rapport de pull expose le
+   fork, l'UI le montre comme git montre deux branches.
+4. **Résolution = tsoin** : choisir/fusionner écrit une nouvelle valeur dont le VC domine toutes
+   les branches. Le fork se referme en merge tracé — jamais en oubli.
+
+## 7. Garde-fous honnêtes `[HYPOTHÈSE]`
+
+1. **Taille des VC.** Un VC croît avec le nombre de cubions rencontrés (O(n) par estampille). À
+   l'échelle de l'essaim (10⁶+ nœuds), il faudra de la compaction : deltas de VC, dotted version
+   vectors, ou VC hiérarchiques par agrégat (l'agrégat comme nœud composite). Non gelé — le
+   format §2 réserve la place, la stratégie reste ouverte.
+2. **GC des branches et des logs.** Un MVR n'oublie jamais tout seul : sans résolution, les forks
+   s'accumulent. Politique de rétention/archivage à définir — mais l'oubli sera toujours un acte
+   explicite (droit au silence), jamais un effet de bord.
+3. **Snapshots.** Rejouer un log de plusieurs années de croisière à chaque merge est absurde :
+   checkpoints d'état signés + log depuis le checkpoint. La profondeur de Bennett du triplet
+   s'applique ici aussi — déplier coûte du calcul, c'est le prix assumé.
+4. **Perf du merge à l'amarrage.** Le handshake du CDS (§3) borne le temps d'ouverture du
+   passage ; le merge complet peut continuer en tâche de fond après l'ouverture — l'ordre causal
+   le permet, à prouver en charge.
+5. **Sybil/identités.** Le VC fait confiance aux `id_cubion` ; la signature GPG de chaque tsoin
+   (§2) est la ligne de défense. Un cubion qui ment sur son VC signe son mensonge — détectable,
+   attribuable. L'audit systématique reste à spécifier.
+
+---
+
+*Ne pas nuire. Aucune montre n'a raison contre l'autre ; aucune branche ne meurt en silence.*
+*AGPL-3.0 · Août 2026 · xion-relativiste-v0*