Registre des ADRs d’Air

Document fondateur — Version 3.42 (2026-07-13 — ADR-093 couche transport SSH-2 d’air-sshd (phase 1 d’ADR-074, directive BDFL v1/v2 intégrée) : topologie de crates figée — cœur sans-IO air-ssh-proto ([ADR-091], invariant v1↔v2, réutilisé verbatim en v2) + pilote air-sshd scindé (pilote d’octets swappable SshByteStream sur air-async en v1 / stack « ssh » d’air-network en v2 ; couche service invariante) + facilité partagée air-service (trait ServiceHost). v1 lancé par systemd (socket-activation + sd_notify, a minima), v2 par air-launchd. air-sshd publie ses événements de session sur AirCom (pub-sub §7 + objet-service interrogeable list_sessions, inc.7) → air-com dépendance v1. Algos moderne only (curve25519-sha256/ssh-ed25519/chacha20-poly1305@openssh.com/aes256-gcm@openssh.com AEAD, pas de downgrade) ; crypto air-crypto ([ADR-034], aléa injecté) ; conf binaire air-config ([ADR-073], + conf par-utilisateur HomeDirectory en phase 2). Cible wire-compat OpenSSH. 2 ADR compagnons v2 (air-launchd ; stack « ssh » air-network). 4 incréments T.1–T.4. Précédent : ADR-092 air-async.) Document fondateur — Version 3.41 (2026-07-11 — ADR-092 air-async : découpage réacteur/exécuteur : la runloop io_uring d’ADR-038 se scinde en réacteur air-uring (couche 1) + exécuteur air-async (couche 2) — contrainte check-layers (couche 2 ↛ couche 0) ; air-async remplace air-event (ADR-038 amendé) ; modèle owned-buffer déjà en couche 0 ; squelette prouvé host. Précédent : ADR-091 motif réseau sans-IO.) Version 3.40 (2026-07-11 — ADR-091 motif réseau sans-IO obligatoire : rend normative la §2 de reseau-architecture-crates-fr.md — tout crate réseau maison = cœur pur sans-IO (anatomie canonique à 9 composants : Framer/Codec/StateMachine/Handshaker/Flow/Mux/Timer/Session/Ext, 8 purs, fuzzés/testés en isolation) + pilote I/O mince ; seul motif testant la pile indépendamment ; neutre sync/async, composable, zéro-C sauf exception TLS ADR-042. Précédent : ADR-090 binding couche 1→std.) Version 3.39 (2026-07-11 — ADR-090 binding couche 1 dans std par rustc-dep-of-std : découplage plutôt que fork, sans descellement couche 0 (mesuré : build-config seul) ; discipline air-base-core jamais air-base-lib ; exceptions 80 % (icu4x/RustCrypto) hors fermeture std ; frontière no_std = relation à std ; industrialisation par vagues. Met en œuvre ADR-088. Précédent : ADR-089 réservation SecurityManager ; ADR-088 pivot std sur Air safe sans libc C ; jalon M5 [ADR-076/086/087] ; Managers [ADR-077].)

Rôle

ADR — Architecture Decision Record (enregistrement de décision d’architecture). Document court et daté qui consigne une décision structurante : son contexte, la décision prise, et ses conséquences. Les ADRs sont numérotés, immuables une fois acceptés (sauf RFC), et font autorité (cf. CLAUDE.md).

Les ADRs (Architecture Decision Records) consignent les décisions structurantes prises pour Air. À partir de la version 2.0 du registre, chaque ADR vit dans son propre fichier afin de faciliter l’édition, la revue, et la future évolution via le mécanisme RFC public (cf. ADR-015). Ce document est l’index pointant vers ces fichiers.

Le registre se décompose en trois groupes :

• ADRs fondateurs (001 à 017) — instruits avant le démarrage de la phase 0. Constituent le socle architectural et organisationnel d’Air.
• ADR fondateur instruit en phase de design (018) — modèle d’imagerie, ajouté en phase pré-ouverture publique selon la politique d’édition directe.
• ADRs phase 0 (019 à 025) — instruits pendant les sessions de spécification de la couche 0, du runtime async, et de l’infrastructure (workflow dépendances, builds reproductibles). Acceptés et appliqués.
• ADRs post-phase 0 (à partir de 026) — instruits pour préciser les contrats structurants des couches hautes (couche 4 air-ui/air-tui, puis couche 5 air-base), au-delà du périmètre phase 0.

Tous ces ADRs sont immuables après ouverture publique sauf erreur factuelle ou clarification mineure ; toute évolution structurante passera alors par un nouveau RFC amendant explicitement.

Index des ADRs

ADRs fondateurs et de design pré-phase 0

ADRs phase 0 (sessions de spécification couche 0 et runtime async)

ADRs post-phase 0 (couches hautes)

Documents fondateurs apparentés

• Vision : ../vision/vision-fr.md (FR) / ../vision/vision-en.md (EN)
• Charte (5 principes de valeurs) : ../charte/charte-fr.md (FR) / ../charte/charter-en.md (EN)
• Principes d’ingénierie (9 principes méthodologiques) : ../principes-ingenierie/principes-ingenierie-fr.md (FR) / ../principes-ingenierie/engineering-principles-en.md (EN)
• Macro-architecture des 6 couches : ../architecture/macro-architecture-fr.md
• Vue d’ensemble du projet : ../../README.md

ADRs futurs identifiés (à instruire ultérieurement)

• Stratégie de logging et observabilité au-delà de journald.
• Stratégie de mise à jour atomique du système (vers Modèle B de distribution).
• App Store Air (présentation Flathub + .airapp).
• Protocole privé AirCom entre air-wm et apps natives (rich content, animations, capture vectorielle scene-graph).
• Politique d’accès des agents IA à l’arbre sémantique et aux captures vectorielles (dans la continuité de air.accessibility.observer d’ADR-017 et des conséquences d’ADR-018).
• Services système couche 5 (screencapture, appearance, share, firewalld, power, printd/bluetooth/nfc, prefs, keychain) — actuellement référencés à titre prospectif dans ../architecture/macro-architecture-fr.md ; leurs numéros définitifs seront assignés au moment de leur instruction (numéros ≥ 029 ; 027 est pris par la documentation polyglotte, 028 par la soundness io_uring).
• Cas spécifiques émergeant de l’implémentation.

Historique

• v3.41 — Ajout d’ADR-092 (« air-async : découpage réacteur (couche 1) / exécuteur (couche 2) de la runloop io_uring »). Accepté (décision BDFL 2026-07-11). Raffine et renomme ADR-038 : la runloop se scinde en air-uring (couche 1, réacteur safe sur io_uring) + air-async (couche 2, exécuteur) — forcé par check-layers (couche 2 ↛ couche 0). air-async remplace air-event. Modèle owned-buffer déjà en couche 0. Squelette prouvé host, check-layers vert. Companion ADR-038/091/022/028/044. Propagation air-event→air-async (specs/macro-archi) en suivi doc.

• v3.40 — Ajout d’ADR-091 (« Motif d’architecture réseau sans-IO : anatomie canonique à 9 composants, obligatoire »). Accepté (décision BDFL 2026-07-11). Rend normative la §2 de la note reseau-architecture-crates-fr.md : tout crate réseau maison = cœur sans-IO pur (9 composants uniformes, 8 purs, fuzzés/testés en isolation) + pilote I/O mince. Seul motif testant la pile réseau indépendamment (surface hostile n°1 fuzzée sans réseau). Neutre sync/async (ADR-038), composable, zéro-C sauf exception TLS étroite (ADR-042). Prérequis de la couche 2 — gravé avant air-async/air-sshd. Le reste de la note (protocoles/priorités) reste exploratoire. Companion ADR-019/024/038/042/043.

• v3.39 — Ajout d’ADR-090 (« Binding de la couche 1 dans std par rustc-dep-of-std : découplage plutôt que fork, sans descellement de la couche 0 »). Accepté (décision BDFL 2026-07-11). Met en œuvre ADR-088. Mesuré (incréments 0→3, branche feat/pal-safe-air-target) : binding par feature rustc-dep-of-std (build-config, no_std) — zéro source couche 0/1, pas de descellement ; le fardeau de fork (~71 naïf : 33 icu4x + 37 RustCrypto + bitflags) est accidentel, évité par découplage (imports → air-base-core, jamais air-base-lib ; AirRandom hors crypto), pas par fork. Exceptions 80 % hors fermeture std (niveau consommateur). Frontière no_std = relation à std. Industrialisation par vagues (0/1/2). Companion ADR-088/054/016/059/034/024.

• v3.38 — Ajout d’ADR-089 (« Réservation du SecurityManager : sécurité active per-process, couche 1 »). Accepté (décision BDFL 2026-07-10) — ADR de réservation (moteur = ADR ultérieur). Air secure-first : les Managers sensibles consultent un SecurityManager avant une op sensible → Allow/Deny + log de la raison ; PAS un daemon (goulot) mais per-process embarqué par libair ; décision locale, enforcement via kernel partagé (eBPF/cgroups/seccomp/Landlock) ; règles depuis la config binaire (ADR-073). Seam posé (interface + défaut permissif, câblé au fil de l’eau) ; moteur différé, aligné air-sshd. Companion ADR-032/077/073/074/088.

• v3.37 — Ajout d’ADR-088 (« std Rust sur Air safe : PAL custom sur la couche 1, sans libc C »). Accepté (décision BDFL 2026-07-10). Pivot d’objectif premier : la toolchain Rust dont la std repose uniquement sur Air, par un backend std::sys bindant la couche 1 Rust safe, sans lib C ni bindings C. Amende ADR-076 (abandonne l’option A « std sur libc C » comme état-cible ; M5 devient un marchepied de faisabilité), re-amende ADR-050 (cible target_os="air", plus « déguisée » en unix), raffine ADR-077 (AirProcessManager → AirTaskManager : task + thread group, fidèle au kernel), résorbe ADR-087 (raw_syscall disparaît). libair_c survit mais découplée de std. Instruit par la note d’étude etude-std-pal-air-safe-fr.md. Companion ADR-050/075/076/077/087/046.

• v3.36 — Jalon M5 atteint (2026-07-10) : std tourne sur la libc d’Air, zéro glibc, 2 arches. Ajout d’ADR-087 (« syscall générique (raw_syscall) : escape hatch temporaire À RETIRER pour le pal std »). Accepté (ratification BDFL 2026-07-09), explicitement temporaire : dernier symbole indéfini de M5, syscall(2) brut requis par le pal unix de std (futex/gettid), impl. via additif couche 0 raw_syscall + shim libc cible-only. Entorse assumée (ADR-021 conv. 3 + « libc binde couche 1 ») ⇒ exception consignée + action item amont équipe Rust. Re-sceau couche-0-v1.12 (délégation ADR-065). Companion ADR-076/021/077. Backfill de l’index du registre : réintégration des lignes ADR-062→068 et ADR-070→077 (dérive admise à v3.26, jamais résorbée). En-tête porté à v3.36.

• v3.35 — Ajout d’ADR-086 (« Introspection thread cible pour la face libc : TLS dynamique, bornes de pile, auxv »). Accepté (ratification BDFL 2026-07-09). Additif couche 1 débloquant 7 symboles std cible (pthread_key_*, pthread_self, pthread_getattr_np/attr_getstack/attr_getguardsize) : AirProcessManager::resource_limit (binde prlimit) + air-runtime::process_context (capture auxv + bornes de pile au bootstrap ; socle getauxval + détection de pile), TLS dynamique via #[thread_local] natif. Re-sceau couche-1-v1.9. Companion ADR-076/077/052/055.

• v3.34 — Ajout d’ADR-085 (« Descellement additif couche 0 cumulé pour la face libc — chantier B »). Accepté (ratification BDFL 2026-07-08, périmètre implémenté). Cumule en un ADR tout le manque couche 0 restant de la campagne libc/std : munmap_raw (mémoire), fchmod/fchown/futimens (fd), chroot, sched_[gs]etaffinity, pause, sigaltstack, sendfile ; ioctl résolu en dispatcher libc (ADR-021 préservé) ; getauxval/sysconf/strerror_r/ __tls_get_addr renvoyés à la couche 1 (descellée). Re-sceau couche-0-v1.11 posé. Companion ADR-051/070/071/076/077.

• v3.33 — Ajout d’ADR-084 (« Ratification air-url : couche 4 élargie (UI + fondation) + nom air-url »). Ratification BDFL. Tranche les deux points ouverts de la spec air-url (note api-reseau-strategie) : air-url (≈ URLSession — sessions/tâches/cache/cookies/WebSocket, sur air-http) est une commodité applicative de fondation, pas un mécanisme système ⇒ couche 4, dont le périmètre est élargi de « frameworks UI » à « frameworks développeur : UI + fondation » (amende la macro-architecture, modèle Foundation ⊕ UIKit d’Apple). Nom air-url (descriptif, vocabulaire Air, jamais « URLSession » ; air-web/air-fetch révisables sans rouvrir la couche). Alternatives rejetées : haut de couche 2 (mélange de registres), nouvelle couche dédiée (sur-ingénierie), nom copié d’Apple. Macro-archi (§couche 4) + spec air-url + INDEX/SUMMARY mis à jour. (Ratification pilotée par directive ; le nom reste ajustable par le BDFL.)

• v3.32 — Ajout d’ADR-083 (« Additifs couche 0 pour la plomberie réseau : TUN (TUNSETIFF) + adjtimex/clock_adjtime »). Délégation additive (ADR-065, neutre). Vérification sur le socle réel : la plupart des additifs couche 0 flagués par air-dhcp/air-ntp/air-wireguard existent déjà — clock_settime (step), SocketType::Raw + socket(domain, ty, protocol) générique (ICMPv6 brut), sockopt entier SO_BROADCAST (ADR-071). Seuls deux manquent réellement : adjtimex (slew — discipline fine que NTP préfère au saut brut) et TUN (/dev/net/tun + TUNSETIFF, ioctl dédié typé ADR-021 conv. 3, pour l’interface tunnel WireGuard). Types #[repr(C)] identiques 2 arches, Option<T>/EINTR/RAII FD ; privilèges (CAP_SYS_TIME/CAP_NET_ADMIN) appliqués par le kernel (wrapper neutre). ICMPv6 brut (SLAAC) + SO_BROADCAST = wrappers couche 1 (air-socket), pas de couche 0. Corrige les « Travail à reprendre » de air-dhcp/air-ntp/air-wireguard (sur-estimation). Tags couche-0-v1.x après barrière 2 arches. SUMMARY à jour.

• v3.31 — Ajout d’ADR-082 (« Additifs crypto : AEAD à nonce explicite (record/packet) + BLAKE2s (WireGuard) + PBKDF2 (SASL/SCRAM) »). Proposé — ratification BDFL (surface crypto). Complète ADR-078/081. Révélé par air-wireguard/air-mail et une relecture des piles TLS/QUIC/SSH : (1) le point important — la façade AirAead v1 génère un nonce aléatoire préfixé, mais tous les protocoles de session (TLS 1.3 record §5.3, QUIC packet RFC 9001 §5.3, WireGuard, SSH aes-gcm) chiffrent avec un nonce déterministe IV⊕compteur, non préfixé → ajout de lowlevel::AirAeadExplicitNonce (backends aes-gcm/chacha20poly1305 déjà présents ; opt-in expert-only, contrat d’unicité de nonce documenté ; la façade à nonce géré reste le défaut applicatif). (2) blake2 (BLAKE2s hash/MAC-keyed/HMAC pour le handshake Noise de WireGuard — pur Rust ZÉRO-C, contrairement à blake3 qui tire cc). (3) pbkdf2 (PBKDF2-HMAC-SHA256 pour SCRAM-SHA-256 d’air-mail ; optionnel — OAUTHBEARER l’évite). Correction rétroactive : air-tls/air-quic/air-ssh/air-wireguard notent que la protection d’enregistrement/paquet passe par l’AEAD à nonce explicite. Pur Rust, zéro-C, KAT-gated. Section « Additifs planifiés » d’air-crypto étendue. SUMMARY + INDEX + EXCEPTIONS à jour.

• v3.30 — Ajout d’ADR-081 (« Additifs crypto air-quic/air-ssh : primitives bas niveau + RSA PKCS#1 v1.5 vérif. »). Proposé — ratification BDFL (surface crypto, comme ADR-078). Complète ADR-078 avec les additifs révélés par les specs QUIC/SSH (postérieures) : (1) module air_crypto::lowlevel — bloc AES single-block, keystream ChaCha20, Poly1305 one-shot (QUIC header protection RFC 9001 §5.4 + SSH chacha20-poly1305@openssh) ; crates aes/chacha20/poly1305 déjà transitives → promues directes ; opt-in expert-only, la façade AEAD à nonce géré reste le défaut (la construction reste en couche 2). (2) AirRsaPkcs1VerifyingKey — RSASSA-PKCS#1 v1.5 vérif. seule (SSH rsa-sha2-256/512), hors Marvin (opération publique ; chiffrement v1.5 toujours omis). (3) Kex PQ SSH = ML-KEM-768 réutilisé (mlkem768x25519-sha256, défaut OpenSSH ≥ 9.9) → aucun additif nouveau ; sntrup761 différé (pas de crate pure-Rust vettée). Pur Rust, zéro-C, KAT-gated (ADR-034). Corrige la spec air-ssh (PQ). Section « Additifs planifiés » ajoutée à air-crypto. SUMMARY + INDEX + EXCEPTIONS à jour.

• v3.29 — Ajout d’ADR-080 (« Additifs air-socket : multicast UDP typé + codec DNS étendu SRV/TXT/PTR — descellement additif couche-1-v1.x + couche-0-v1.12 »). Délégation additive (ADR-065, neutre non-sécurité). Révélé par la spec air-mdns (L2) : (1) multicast UDP — rejoindre un groupe = setsockopt(IP_ADD_MEMBERSHIP, ip_mreq), une option à structure que la couche 0 ne sait pas poser (ADR-071 = sockopts entiers seulement, limitation D-M4.1) → additif setsockopt_bytes (aucun nouveau syscall, variante à buffer du setsockopt déjà appelé) ; fonctions multicast dédiées typées sur AirUdpSocket (ADR-021 conv. 3). (2) Codec DNS — promu public sans-IO (codec de noms compressés borné/fuzzé existant) + types SRV/TXT/PTR (DNS-SD), plutôt que dupliqué dans air-mdns (surface de parsing hostile décodée une fois, règle 80 % ADR-024). Zéro-C, zéro unsafe. Tags couche-0-v1.12 puis couche-1-v1.x après barrière 2 arches. Section « Additifs planifiés » ajoutée à la spec air-socket. SUMMARY + INDEX à jour.

• v3.28 — Ajout d’ADR-079 (« air-netlink (couche 1) : transport netlink générique + descellement additif couche-0-v1.11 (AF_NETLINK/sockaddr_nl) »). Décision BDFL (2026-07-07) — option B, couche 1. La conscience du chemin d’air-network (L2, AirNetworkPathMonitor) exige rtnetlink (plan de contrôle : liens/adresses/routes) ; la couche 0 n’a qu’un socket NETLINK_KOBJECT_UEVENT spécifique (air-device). Trade-off tranché : crate air-netlink dédiée (responsabilité unique, transport réutilisable par path-monitor + WireGuard/DHCP + air-config routes + wifi nl80211 ; surface TLV hostile fuzzée une fois ; patron sans-IO 9-composants) plutôt qu’étendre air-device (rejeté : conflate deux protocoles netlink très différents, descellement lourd, dispersion). Placée couche 1 (pair d’air-socket ; révise la mention prospective « couche 2 » d’air-socket). Additif couche 0 modéré : SocketDomain::Netlink=16 + SocketAddrNetlink (sockaddr_nl), les syscalls génériques socket/bind/sendmsg/recvmsg étant déjà présents ⇒ aucun nouveau syscall. air-device inchangé (migration future possible, non requise). Spec docs/specs/layer-1/air-netlink.md. Tags couche-0-v1.11 puis couche-1-v1.x après barrière 2 arches. SUMMARY + INDEX à jour.

• v3.27 — Ajout d’ADR-078 (« Descellement additif couche-1-v1.7 : additifs crypto pour air-tls »). Proposé — ratification BDFL requise (surface crypto, hors délégation additive automatique d’ADR-065). Révélé par la contingence air-tls maison (ADR-042 §Contingence, spec docs/specs/layer-2/air-tls.md) et l’audit s2n-tls (docs/notes/audit-s2n-tls-fr.md) : le cœur v1 d’air-crypto (Ed25519/X25519/AES-256-GCM/ChaCha20) ne valide pas le WebPKI réel. Ajoute 5 primitives à air-crypto (scellée) — AES-128-GCM (MTI TLS 1.3), ECDSA + ECDH P-256/P-384 (RFC 6979 déterministe), RSA-PSS vérification seule, ML-KEM-768 hybride — via crates RustCrypto p256/p384/rsa/ml-kem (+ variante d’aes-gcm déjà présent), purement additives, pur Rust, zéro-C, no_std-strict, KAT-gated (ADR-034). Décisions de sécurité gravées : RSA vérif. seule (aucune opération privée RSA ⇒ hors Marvin RUSTSEC-2023-0071 ; PKCS#1 v1.5 chiffrement omis), ECDSA à nonce déterministe RFC 6979, ML-KEM en hybride X25519MLKEM768 only (sécurité ≥ max des deux). N’impacte pas la pile de production rustls + aws-lc-rs (ADR-042). Exceptions 80 % à nommer (EXCEPTIONS.md — déjà instruites). Tag couche-1-v1.7 après ratification BDFL + implémentation KAT-gated + barrière 2 arches. SUMMARY + INDEX à jour.

• v3.26 — Ajout d’ADR-069 (« Registre de handles fd-général (couche 1, air-handle) + moteur socket, façades PAL & libc »). Ratifié BDFL (2026-07-05). Déclenché par le jalon M4 réseau : la question « comment la libc socket se pose sur la couche 1 » a révélé un enjeu plus large — la cohérence de l’état des descripteurs entre Rust et C au sein d’un même processus (pas de « chemin Rust » vs « chemin C »). Décision : une crate air-handle (couche 1 basse, dont dépendent tous les producteurs de fd) porte un registre process-global unique (clé = vrai fd kernel, rendu au C pour l’interop) qui possède l’OwnedFd ; points de passage uniques (create/duplicate/close/set_fd/set_status) ; duplicateur unique modélisant l’alias (description partagée refcomptée) + éviction-sur-silent-close → cohérence dup2/fcntl(F_DUPFD/F_SETFL). Tous les objets fd de couche 1 (AirFile/pipes/AirTcpSocket/AirUdp/AirUnix*) re-domiciliés (API préservée) ; AirSocketEngine = couche de politique (couture de sécurité réseau + résolveur réutilisé) au-dessus du registre ; une impl, deux façades (objets PAL Rust + libc C). Alternatives rejetées : libc→couche 0 direct (pas de couture), registre socket-only (2 régimes), handle synthétique (casse poll/SCM_RIGHTS), libc sans état (= musl). Descellement additif couche 1 (re-sceau au lot 0). SUMMARY à jour. (Constat au passage : l’index du registre a dérivé — ADR-062→068 absents ; backfill à traiter hors périmètre de cette PR.)

• v3.25 — Ajout d’ADR-060 (« Descellement couche-0-vX : famille termios/tty ») et ADR-061 (« Architecture AirTerminal : modèle canonique + codecs — vision »). RFC de structure (ADR-015), par délégation d’autonomie BDFL (gravés pour revue a posteriori). ADR-060 : clore la libc exige termios (interface POSIX-1988 de discipline de ligne, terminal-agnostique) + isatty (pour stdio), absents de la couche 0 scellée → descellement additif (mécanique ADR-051), toute la famille en une passe : attributs/contrôle-ligne/winsize/PTY/session, en fonctions dédiées typées (ADR-021 conv. 3, jamais d’ioctl générique), sur le type Termios existant (branche feat/termios-couche0) ; Option<T>/EINTR-remonté/RAII/100 %. ADR-061 (vision, sans impl.) : issu d’une réflexion de fond — le PTY est un canal d’octets non typé où mouse/négociation sont greffés en séquences (kitty & co. faute d’autre canal) ; Air, possédant le stack, sépare terminal-texte (termios + ansi, borné, compat) et interaction riche (device/compositeur, AttachSurface). AirTerminal = tag + codec + modèle canonique ; discipline « Annoncer→Sélectionner→dégrader-sur-inconnu » (#[non_exhaustive]+Unknown+capnp) pour évoluer sans casser ; termcap = ncurses/couche 2 (hors libc), xterm-only. Portée de sceau : couche 1 n’exige que termios (L0, ADR-060) + mince air-terminal (codec ansi) ; le reste (codecs riches, air-codec-1, surfaces) = couche 2 différée. Registre/SUMMARY à jour.

• v3.24 — Ajout d’ADR-059 (« Stratégie i18n — Option V : Air utilise icu4x, pas de réimplémentation »). RFC de structure (ADR-015), ratifié BDFL en session sur décision data-backée, companion ADR-053 (affirmé : libc sur icu4x) + ADR-016 (exception i18n) + ADR-024 + ADR-050 (cible). Vérification empirique (sonde jetable, carbon) : la fermeture icu4x compile intégralement pour x86_64-unknown-linux-air (--release, 33 s) — 6 composants (normalizer/casemap/segmenter avec LSTM auto/collator/locale_core/calendar) + socle + calendrical_calculations/core_maths/libm. 2 conditions triviales : (1) default-features = false sur les icu_* (évite la feature std par défaut — cause du « mur std ») ; (2) build --release (évite un repli logging std::eprintln debug-only d’icu_provider). ⇒ réimplémenter le socle n’est PAS une nécessité (des mois pour reproduire ~15 crates ULP-correctes déjà no_std-cible). Décision Option V : Air utilise icu4x (extension exception ADR-016) + possède l’API air-string dual-face + le pipeline de données ; réécriture par composant seulement si justifiée. Rétrécit la roadmap §2.A (le « long pole » disparaît) en chantier no_std : air-base-lib #![no_std] + default-features=false, face C-ABI d’air-string, datagen différé. Abandonne le vendoring/port du socle. air-libm (ADR-057) reste surface math publique mais non requis par icu. Audit docs/notes/audit-icu4x-rust-pur-fr.md §9 tranché. Roadmap/registre/SUMMARY à jour.

• v3.23 — Ajout d’ADR-058 (« loom : activation du modèle de concurrence, outil de vérification test-only »). RFC de structure (ADR-015), par délégation d’autonomie BDFL pour ce lot (gravé pour revue a posteriori), companion ADR-030 (dépendances test-only) + ADR-021 (EINTR/boucle) + ADR-031 (couverture). Tranche l’attente de gouvernance signalée dans le Cargo.toml du workspace (« décision Principe 6 / ADR-024 en attente »). Décision : activer loom comme outil de modèle de concurrence, dépendance test-only tirée uniquement sous --cfg loom ([target.'cfg(loom)'.dependencies], hors graphe normal, jamais livrée) — pas une exception 80 % (ADR-024 vise la production ; loom est un outil de vérification comme proptest, donc pas dans EXCEPTIONS.md), licence MIT. Premier modèle : l’AirMutex d’air-thread (protocole futex à 3 états) via alias d’atomique commuté core/loom (même code exercé sous les deux) + shim de blocage (loom::thread::yield_now/no-op remplace futex_wait/futex_wake — loom ne modélise pas futex, mais la boucle relit l’état, ADR-021 §2). loom explore tous les entrelacements et prouve l’exclusion mutuelle (2 modèles : exclusion_mutuelle_deux_threads, try_lock_n_empiete_jamais — validés on carbon x86). Garde-fou : loom prouve la SÛRETÉ, pas la VIVACITÉ (réveil futex réel validé on-target). Tests réguliers gardés cfg(all(test, not(loom))). Attaque la source de la variance de couverture (#189, plancher 96→94). Invocation documentée ; job CI loom optionnel différé. Roadmap §3.1 (+ correction §2.B.1 : la migration futex d’air-thread était déjà faite via le passage no_std #182). Registre/SUMMARY à jour.

• v3.22 — Ajout d’ADR-057 (« libm Air (air-libm) : vendoring de libm (rust-lang) en surface math couche 1 »). RFC de structure (ADR-015), par délégation d’autonomie BDFL pour ce lot (gravé pour revue a posteriori), companion ADR-053 (libc/i18n sur icu4x) + ADR-024/ADR-016 (règle des 80 % / exceptions nommées). Décision (audit docs/notes/audit-icu4x-rust-pur-fr.md §3/§8) : le seul primitif système qui manque à la réimplémentation i18n/libc d’Air est une math flottante no_std — un libm (consommateurs incontournables : calendrical_calculations via icu_calendar, non contournable, + le modèle LSTM d’icu_segmenter, tous deux via core_maths→libm). On vendore la crate libm (rust-lang) comme exception nommée (modèle icu4x) — ni réécriture from-scratch (énorme, risque ULP) ni dépendance non nommée : libm est pur Rust no_std, zéro dépendance transitive, fusionné dans compiler-builtins (le libm que la std utilise pour wasm/no_std), licence MIT. Exposé via une crate couche 1 air-libm (#![no_std], pub use libm::*;) — frontière nommée, pinnée (=0.2.16), auditée. Aucun consommateur aujourd’hui : fondation posée pour la libc/i18n future (ADR-053). Couverture air-libm = 100 % (ré-export sans logique propre + tests de fumée à valeurs connues, tolérance epsilon). Preuve de build *-linux-air (crate-sonde jetable rt/). Back-fill : la rangée ADR-056 (absente du tableau d’index, omission de la PR air-alloc) est ajoutée par la même occasion. EXCEPTIONS/DEPENDENCIES/registre/SUMMARY/INDEX à jour.

• v3.21 — Ajout d’ADR-055 (« air-thread/air-process en #![no_std] : crate air-env + spawn ergonomique gardé per-cible »). RFC de structure (ADR-015), ratifié BDFL, companion ADR-048 (no_std couche 1) + ADR-052 (D7.3) + ADR-054. Constat (re-sonde de build *-linux-air post-ADR-054) : le 2ᵉ mur de la fermeture runtime est que air-thread/air-process ne sont pas #![no_std] et fuient std (air-process : std::ffi/std::os::unix/std::env::vars_os dans build_envp ; air-thread : thread.rs enrobe std::thread, délibérément — une closure arbitraire sur un thread Air sans TCB glibc serait unsound). Deux obstacles : air-process a besoin de l’environnement mais ne peut pas dépendre d’air-runtime (cycle air-runtime → air-process via exit_process) ; le spawn ergonomique Air-natif relève d’air-runtime (TCB/TLS) et d’un allocateur réel (boxer la closure), indisponible. Décision : (D1) nouvelle crate air-env (couche 1, no_std, zéro dépendance) porte l’environnement sous les deux ⇒ cycle évité ; (D2) air-process → #![no_std] (core/alloc::ffi, build_envp lit air_env) ; (D3) air-thread → #![no_std], thread.rs (spawn std) gardé #[cfg(not(target_env="air"))] — hôte seulement ; (D4) portée « compile ≠ run » : la fermeture compile no_std pour la cible (re-sonde), mais exécuter Command/spawn reste bloqué par l’allocateur AbortOnAlloc (chantier suivant). Couverture air-env = 100 %. Registre/SUMMARY/INDEX/DEPENDENCIES à jour.

• v3.20 — Ajout d’ADR-054 (« Scission d’air-base-lib : un cœur air-base-core sans i18n pour la fermeture runtime »). RFC de correction d’architecture (ADR-015), ratifié BDFL, companion ADR-052 (layering air-runtime) + ADR-053 (libc/icu4x). Constat empirique (sonde de build *-linux-air, étape 6) : air-memory/air-thread/air-process ne consomment d’air-base-lib qu’AirError (+ horloge monotone et AirPath pour deux d’entre eux) mais compilent tout l’i18n (icu_*), et le default d’icu tire std → le build no_std meurt sur extern crate std d’icu_provider, avant d’atteindre libm (donc libm hors du chemin critique de l’étape 6). Décision : extraire un cœur sans icu air-base-core (erreurs/id/chemins-octets/temps-monotone/encodages/log) ; air-base-lib garde l’i18n (AirString/AirLocale, AirDateTime/AirCalendar) + ré-exporte tout le cœur (compat — 7 consommateurs non-runtime + ABI C inchangés) ; le runtime bascule sur air-base-core (fermeture sans icu ni libm pour l’étape 6) ; air-process::Command prend args/env en octets (AirPath, execve=octets non garantis UTF-8, Principe 3). Rectifie l’en-tête erroné d’air-base-lib (« icu4x sans feature std » — faux : le default d’icu tire std). La mise en no_std d’icu4x lui-même (+libm) est déférée au chantier libc/i18n (ADR-053). Registre/SUMMARY/INDEX/DEPENDENCIES à jour.

• v3.19 — Ajout d’ADR-053 (« La libc Air s’appuie sur icu4x pour ctype/locale/i18n »). RFC (ADR-015), ratifié BDFL, companion ADR-046 (libc) + ADR-016 (i18n). Doctrine : la surface C de traitement de caractères/locales/i18n (isX/towX/strcoll/strxfrm/wcs* + extensions) repose sur icu4x (couche 1) → i18n correcte par défaut, le développeur C n’embarque plus icu4x, et là où POSIX est faible Air donne le standard Unicode (cf. ADR-046 D3/D5 : POSIX fonctionnel non conforme, kernel=bible). Mapping POSIX↔icu4x (mono-char/locale-globale ↔ chaîne/locale-explicite/sans-état : isX→icu_properties, casse simple 1→1 vs pleine niveau-chaîne, locale courante thread-local réconciliant le « zéro globale »), byte-level gardé rapide (icu4x seulement pour la correction i18n), écarts POSIX documentés (transparence). Précise/rend obsolète ADR-046 D7 : « libm exclu v1 » (icu4x exige libm : calendriers + LSTM) et « hors wide-char lourd » (le wcs* i18n EST la surface icu4x). Un socle icu4x couche 1, 3 consommateurs (libc C, futur std *-linux-air, pal). Constat (note docs/notes/audit-icu4x-rust-pur-fr.md) : Rust stdne repose **pas** non plus sur icu4x (mini-tables propres) → même bolt-on que C ; icu4x runtime = no_std calcul-pur (zéro syscall/horloge/thread) → seul manque Air =libm` no_std + petites crates utilitaires + pipeline de données CLDR/UCD. Renvois posés (bannières « obsolète ») dans ADR-046 (D7) + ADR-016 (extension) + macro-architecture (icu4x dès couche 1). Questions ouvertes : libm (réécrit vs vendoré), LSTM (oui/dico), datagen (réutiliser vs refaire).

• v3.18 — Amendement d’ADR-035 : 5ᵉ catégorie de couverture « TARGET-ONLY » (RFC ADR-015, companion ADR-052/049). Code dont la sémantique n’est correcte que sur *-linux-air (programmer le registre TLS, thread CLONE_SETTLS, relocations static-PIE, self-pointer TCB) → ni exécuté ni mesuré par le gate (*-linux-gnu, glibc — unsound, #151), prouvé par le selftest rt/ on-target (exit code, 2 arches : carbon x86 + raspi aarch64). Granularité fichier (--ignore-filename-regex, précédent _capnp.rs) : on retire --exclude air-runtime (mesure des modules host-testables env/args/reloc-parser/fork à 100 %) et on ignore les fichiers target-only (thread_control_block/thread_local_storage/thread/start + primitives air-thread + applier reloc). Distincte de STRUCTURAL/CHILD-EXIT/DEFERRED-TOOLING ; réversible (toolchain Air-native mesurant on-target). Anti-complaisance : réservé à l’insondable-sur-cible-du-gate, pas au « dur à tester ».

• v3.17 — Ajout d’ADR-052 (« air-rt est un objet couche 1 (AirRuntime), jamais un consommateur direct de la couche 0 »). RFC de correction d’architecture (ADR-015), ratifié BDFL. Constat : le crate rt/crates/air-rt (phase 2) appelle la couche 0 en direct (arch::set_fs, mem::mmap, process::clone_thread, futex, exit_group) — violation du layering (seule la couche 1 consomme la couche 0). Doctrine gravée : air-rt est un objet couche 1 (AirRuntime) composé de nouvelles briques couche 1 à créer — ThreadControlBlock, ThreadLocalStorage, outils de relocation (cible PIE/static-PIE, ADR-050) — et s’appuyant sur air-thread/air-mem/air-proc ; il ne dépend jamais de air-sys-syscall (la surface kernel) — air-sys-types (types transverses : AirError/Errno/Pid/Tid…, D6) reste autorisé à toutes les couches. Les wrappers de syscalls (dont set_fs d’ADR-051) restent en couche 0, mais leur consommateur devient un objet couche 1. Le crate rt/ ne garde que le point d’entrée ELF _start + la plomberie cible. Corrige ADR-049 D8 (tag obsolète + bannière) et reformule le « affaire d’air-rt » d’ADR-051 (note layering). Conséquence : la logique de runtime, devenue couche 1, retombe sous le 100 % couverture + barrière 2-arches (gain de rigueur vs carve-out rt/). macro-architecture (§Section 3 + tableau d’artefacts), rt/README.md/rt/DECISIONS.md, SUMMARY/INDEX à jour. Code à refactorer (suivi séparé).

• v3.16 — Ajout d’ADR-051 (« Descellement couche-0-v1.7 : 7 syscalls pour le runtime et la libc »). RFC d’extension d’une couche scellée (ADR-015), ratifié BDFL, livré en une seule PR (CI ARM longue → on minimise les cycles de gate). Ajoute, en un re-sceau unique (éviter les cycles répétés), 7 wrappers typés : arch_prctl (set_fs/get_fs, x86_64-only, nouvelle famille arch — débloque le TLS du thread principal x86 de la phase 2 *-linux-air ; aarch64 = tpidr_el0 en asm côté air-rt) + process set_tid_address/getcwd(octets)/umask/getppid(→Option<Pid>)/sched_yield/getrusage (+ types Rusage/RusageWho/Timeval). Conventions ADR-021 (fns dédiées, Option/newtypes). check-syscalls PASS vs uapi (2 arches), couvrable VIDE (2 exceptions STRUCTURAL/EFAULT-SAFE : bras Err de get_fs/getrusage), audit-exceptions cohérent (77). Reporté en couche-0-v1.8 (phase 5, OpenSSH) : termios/PTY/rt_sigaction/sigaltstack (+ décision ADR-020). SUMMARY/INDEX/specs (family-arch.md, family-process.md §7) à jour.

• v3.15 — Ajout d’ADR-050 (« Spécification de la cible *-linux-air (phase 1) ») et réconciliation du tableau avec les ADR-046→049 (acceptés/mergés mais jamais portés au registre). ADR-050 ouvre l’exécution du programme *-linux-air (ADR-049) : triple {x86_64,aarch64}-unknown-linux-air (env=air, 3ᵉ saveur de libc à côté de gnu/musl), llvm-target musl découplé du nom Rust (LLVM ignore air), cible statique panic=abort + has-thread-local, champs codegen repris verbatim de la base musl ; développement hors-arbre (rt/ : workspace+toolchain nightly séparés, -Z build-std core,alloc, -Z json-target-spec) exclu de la barrière stable (ADR-037) et de la couverture — carve-out de même nature que fuzz/ (esprit ADR-030) ; squelette air-rt (modules tcb/tls/start/env/spawn mappés sur D1–D9). Faisabilité prouvée 2 arches (core+alloc+air-rt compilent pour x86_64 ET aarch64). Stratégie ratifiée (ADR-049) : hors-arbre jusqu’à la démo phase 4, upstream Tier-3 après. Cible PIE/static-PIE affirmée (codegen PIC dès la phase 1, vérifié 2 arches ; ASLR préservé) ; seul l’_start auto-relocalisant (relocations R_*_RELATIVE) reste un livrable de phase 2 (avec asm TLS/spawn, 2 arches, // SAFETY:). Les rangées 046→049 sont ajoutées au tableau (back-fill) : ADR-046 (libc Air : périmètre/layering/provenance), ADR-047 (principes de construction libc), ADR-048 (descellement couche 0 std-free + futex, re-sceau v1.6), ADR-049 (runtime TCB/TLS, fondation *-linux-air).

• v3.14 — Ajout d’ADR-045 (« Modèle d’erreurs de l’ABI C »). Première passe ABI C (air-base-capi → libair-base.so) : erreurs in-band via AirStatus (#[repr(C)], AIR_OK=0, sur-ensemble d’AirErrorKind + NULL_ARGUMENT/BUFFER_TOO_SMALL), sans errno ni globale (fidèle au kernel, doctrine libc) ; message via air_status_message statique ; panic = "abort" (panic = bug Air → fail-fast, pas de catch_unwind/AIR_PANIC). Réalise « pas de globale libc / dit ce qu’elle fait » au niveau C. Spec : air-base-capi.md. Alternatives écartées : errno-style, objet AirError opaque dès T1, catch_unwind→AIR_PANIC.

• v3.13 — Ajout d’ADR-044 (« Extension couche 0 : famille poll / ppoll »). RFC d’extension d’une couche scellée (ADR-015) — ≠ complément additif Errno. Ajoute le wrapper ppoll (variante moderne : ns, timeout non muté, sigmask) + PollFd (emprunté +0, revents restitués, ADR-032) + promotion de PollEvents hors d’io_uring (ré-export, zéro rupture) ; conversion Duration→timespec défensive (clamp i64::MAX, jamais as). Débloque l’attente synchrone bornée/interruptible de air-process (wait_timeout/wait_until/wait_forever) sans io_uring (footgun de hang de l’incident fork #128). Re-sceau couche-0-v1.5 ; check-syscalls ppoll (271/73, 2 arches) ; gate barrière + CI ARM. Spec : family-poll.md ; consommateur : air-process.md §4.

• v3.12 — Amendement d’ADR-027 (addendum « doc ABI C »). Clôt le « Doxygen ou équivalent » : rendu = Doxygen (HTML + pages man) sur le header cbindgen committé (contrat ABI diffé en CI), versions pinnées (ADR-025), intégré au mdBook FR+EN. Grave l’exigence de contenu orientée dev C : guides obligatoires sur les obligations de l’appelant — mise en route/lien, modèle d’erreurs AirError, et surtout la propriété mémoire & cycle de vie (pour chaque type complexe : qui alloue/libère et avec quelle fonction ; retour possédé→libérer / emprunté→ne pas libérer ; arguments empruntés +0 ; chaînes/buffers/out-params ; refcompté retain/release ; secrets zeroize) + thread-safety par type + exemples C. Chaque pub extern "C" porte sa clause de propriété dans son commentaire /// (source unique → cbindgen → Doxygen). Mise en œuvre à la 1ʳᵉ passe ABI C (air-base-lib).

• v3.11 — Ajout d’ADR-043 (« Pile SSH »). Pendant d’ADR-042 mais calcul différent : pas d’option Rust mature (russh ≪ rustls), surface SSH bien plus grande (sshd = surface distante critique, classe regreSSHion), SSH hors chemin critique (applicatif couche 2+). Décision : court terme air-ssh différé, OpenSSH système en incubation (ADR-013) ; à terme air-ssh maison (memory-safe Rust, anatomie 9-composants, strict-kex anti-Terrapin, moderne-only, RustCrypto, homologation interop OpenSSH+RFCs, audit externe du sshd), PAS russh (immature pour un daemon distant ; gardé comme référence/base auditée possible) ; client (ssh/scp/sftp) avant serveur (sshd). Zéro exception C (maison+RustCrypto). Implémentation au cadrage réseau couche 2.

• v3.10 — Ajout d’ADR-042 (« Pile TLS : rustls + aws-lc-rs »). Après analyse explicite (frontière primitives/protocole ; classes de CVE TLS, sûreté mémoire dominante ; comparaison piles dont s2n-tls) : la pile TLS = rustls (protocole pur Rust, memory-safe, TLS 1.3) + aws-lc-rs (provider crypto AWS-LC : asm formellement vérifié, FIPS, maintenu) + rustls-webpki (X.509 pur Rust). Exception C NOMMÉE et ÉTROITE : le C ne concerne que les primitives (aws-lc-sys), jamais le protocole ni le parseur X.509 (memory-safe) ; ring reste banni. = la combinaison la plus sûre disponible (memory-safety + vérif formelle + 1.3 + maintenance financée). air-tls maison gardé en contingence (si rustls devient une faille/un passif de maintenance). deny.toml/EXCEPTIONS.md/check-c-surface + pinning toolchain C (ADR-025) appliqués à l’implémentation (pas avant). Corrige la note réseau (ligne air-tls).

• v3.9 — Ajout d’ADR-041 (« Coexistence /etc », companion d’ADR-033, détaille la règle 7 au-delà de systemd). Les fichiers /etc possédés par Air sont des projections générées par air-config, en lecture seule sélective (jamais globale — casserait passwd/ldconfig/installs ; même Silverblue/MicroOS gardent /etc inscriptible), air-config seul écrivain (swap atomique) ; mutables-runtime (resolv.conf, machine-id) redirigés vers /run ; /etc/systemd/system possédé par le backend systemd d’air-config (systemd lit, n’écrit pas ; start/stop/restart intacts). Garde-fou (root peut remonter rw), pas frontière de sécurité — celle-ci viendra avec air-launchd/Landlock. Génération = air-config (L1) ; protection (montage RO sélectif) = intégration OS (L5), réalisable avant air-launchd. Périmètre progressif ; bootstrap bidirectionnel (import /etc → source). Détail → spec air-config.

• v3.8 — Ajout d’ADR-040 (« Format de l’artefact binaire de configuration : Cap’n Proto », companion d’ADR-033). Tranche le format de l’artefact air-config : Cap’n Proto — pour la cohérence projet (AirCom encode déjà en Cap’n Proto, ADR-001 → un seul langage de schéma / codegen / dépendance à auditer, exception règle-des-80 % partagée) et le zéro-copie/mmap (ADR-033 §4, Principe 9, boot Pi). protobuf écarté (pas zéro-copie), FlatBuffers écarté (second écosystème superflu). Exception EXCEPTIONS.md pour capnp à acter avec AirCom ; placement air-config en crate dédiée (vs air-base-lib) à trancher au cadrage. Hors périmètre : backends d’émission /etc (coexistence libc/Unix, ADR-033 §7) → spec air-config. Amendé 2026-06-25 (addendum) : capnp runtime = zéro dépendance / pur Rust (propre), mais capnpc exige le binaire C++ capnp au build (vérifié empiriquement ; pas propre à Cap’n Proto — flatc/protoc aussi). Politique gravée : code généré committé (schémas .capnp versionnés ; mainteneur régénère le .rs au changement de schéma, le commite ; builds/CI pur-Rust + reproductibles sans tool C++). Vaut aussi pour AirCom (ADR-001).

• v3.7 — Ajout d’ADR-039 (« Nommage & placement du runtime et du modèle d’objet + ordonnancement », amende ADR-002, précise ADR-023/038). Le modèle d’objet C-ABI est renommé air-object (couche 2 ; libair-object.so) ; le runtime async garde air-runtime (couche 1, consomme io_uring directement), multi-crate air-runtime-core/io/time/signal/sync + façade ; air-event (couche 2) est la façade C-ABI par-dessus le runtime L1. Ordonnancement : exécuteur single-thread comme unité (empreinte minimale Pi 4B), scalable en thread-per-core shared-nothing (réutilise io_uring Temps 3e : RingPool/msg_ring/LockedIoUring/SqpollIoUring), sans work-stealing v1 ; CPU-bound déporté vers air-thread. Deux familles de synchro (bloquante std::sync / async runtime). Sweep macro-architecture (air-runtime→air-object du modèle d’objet) appliqué.

• v3.6 — Ajout d’ADR-038 (« Modèle d’exécution : runtime async natif io_uring, sans tokio, couches basses synchrones, pas d’epoll », amende ADR-023). Plus aucune dépendance tokio : air-event (couche 2) est le runloop async natif sur io_uring. Posture synchrone-first (couches 0/1 : wrappers bloquants + API sync avec seam as_fd()) + async opt-in (couche 2). Le synchrone est de première classe pour : init/sécurité (drop_privileges/seccomp/Landlock), outils one-shot/CLI, compute-bound (crypto/memory), embarqueurs avec leur propre boucle, RAII, poignées systemd. io_uring est le seul moteur de readiness+complétion — pas d’epoll (porte laissée ouverte par RFC si besoin réel mesuré ; ppoll plutôt qu’epoll pour un éventuel multiplex sync). Met à jour la macro-architecture (mentions « au-dessus de tokio » corrigées).

• v3.5 — Ajout d’ADR-037 (« CI ARM seule + validation x86 par barrière pré-merge », companion d’ADR-031/036). La CI GitHub ne tourne plus que sur le runner ARM (raspi-srv-2) ; l’x86 est validé hors CI par cargo xtask barrier sur speedy ET carbon avant chaque merge (mêmes contrôles et planchers 96/78 que l’ancien runner x86). speedy reste enregistré mais retiré des workflows (réactivation à l’ouverture publique) ; raspi-srv-2, lent, est réservé au seul rôle CI ARM. Invariant ADR-014 (x86_64 ET aarch64) préservé : ARM par CI, x86 par barrière pré-merge. Conséquences assumées : raspi-srv-2 devient le SPOF de la CI ; le gate x86 n’est plus imposé par GitHub (acceptable mono-mainteneur, ADR-031). Câblé dans .github/workflows/ci.yml + docs/CI.md.

• v3.4 — Ajout d’ADR-036 (« Filtrage par chemin de la re-vérification d’une couche scellée », companion d’ADR-031/035). La mesure de couverture (et le fuzz) de la couche 0 scellée ne se relance pas sur les PR qui ne la touchent pas ; re-vérification complète toujours garantie : (a) PR touchant couche 0 / toolchain / CI / politique, (b) merge vers main (main jamais non vérifié — dérive de toolchain bloquée au merge), (c) planifié hebdomadaire. Câblé dans .github/workflows/ci.yml (job changes par git diff, variable FULL). N’amende pas le standard 100 % de la couche 0 ; le tag couche-0-v1 reste la référence.

• v3.3 — Ajout d’ADR-035 (« Taxonomie des exceptions de couverture », companion d’ADR-031). Grave 4 catégories + 1 étiquette de dette pour docs/COVERAGE-EXCEPTIONS.md : STRUCTURAL (inatteignable par construction — absorbe EFAULT-SAFE et VALUE-UNREACHABLE permanente), PRIVILEGE, FEATURE-KERNEL, CHILD-EXIT (code exécuté dans un enfant forké mais profil LLVM non flushable — preuve par le code de sortie via waitid), et DEFERRED-TOOLING (branche réellement atteignable non encore outillée → à couvrir, jamais exemption permanente). Règle : les bras de code de test ne figurent pas au registre production (annexe). Invariant « couvrable VIDE ». N’amende pas ADR-031 ni le Principe 1. Appliqué immédiatement (055) : 3 candidates atteignables couvertes ⇒ DEFERRED-TOOLING vide.

• v3.2 — Ajout d’ADR-034 (« Discipline des dépendances cryptographiques », companion d’ADR-024). Grave la discipline des crates crypto auditées d’Air (exceptions structurantes à la règle des 80 %, comme icu4x) : exemption de vendoring (cohérence cryptographique + sécurité par adoption massive primant sur l’auto-hébergement), veille des trois upstreams (RustCrypto, dalek-cryptography, équipe BLAKE3), fast-lane sécurité (un bump correctif de sécurité passe malgré le pinning des builds reproductibles ADR-025), KAT-gating des montées de version (vecteurs de test connus rejouéss avant tout bump), et option Apache pour blake3 (dual CC0-1.0 OR Apache-2.0) dans deny.toml. air-crypto (couche 1) renvoie à cet ADR pour sa discipline de dépendances. Aucun amendement aux autres ADRs.

• v3.1 — Ajout d’ADR-033 (« Modèle de configuration : source typée, compilation validée, artefact binaire »). Source typée canonique → compilateur validant (barre couches 0/1, fuzzé) → artefact binaire reproductible schema-first (version + checksum) consommé par le runtime ; projections texte JSON/YAML/TOML en import/export ; sûreté par générations + switch atomique + rollback ; backends de compilation enfichables (joint d’indépendance — unit files systemd générés et validés pour V1). L’intégrité des binaires est explicitement renvoyée à un futur ADR. Aucun amendement aux autres ADRs. (NB : ADR-032 figure déjà au tableau ci-dessus — rattrapage du prompt non nécessaire.)

• v3.0 — Ajout d’ADR-032 (« Préservation des données confiées : zéro discard silencieux »). Règle transverse : une API Air ne discarde jamais une donnée confiée — restitution intégrale (tous les buffers), ressources reçues matérialisées (OwnedFd) et troncatures signalées, chemins d’erreur compris ; la consommation explicite par contrat (submit_close(OwnedFd)) reste permise. Émergé du Temps 2b io_uring (into_zero_copy_buffers). Aucun amendement aux autres ADRs.

• v1.0 — Registre consolidé initial regroupant les 17 ADRs fondateurs en un seul fichier.

• v2.0 — Restructuration en un fichier par ADR. Ce document devient un index. ADR-018 ajouté en phase de design. ADR-009 révisé (intégration de l’amendement déclaratif, anciennement envisagé sous le nom ADR-009-bis ; intégration directe conforme à la politique d’édition design-phase).

• v2.1 — Intégration des 6 ADRs phase 0 (ADR-019 à ADR-024). Renumérotation : la série phase 0 telle qu’instruite (018-erreurs, 019-signaux, 020-conventions, 021-io_uring, 022-runtime, 023-workflow-deps) est décalée de +1 pour résoudre le conflit avec l’ADR-018 fondateur « Modèle d’imagerie » déjà acté en v2.0. Réorganisation physique : tous les ADRs vivent désormais dans docs/adrs/, et l’ensemble de la documentation est restructurée selon le plan consigné dans ../INDEX.md.

• v2.2 — Ajout d’ADR-025 (« Stratégie de builds reproductibles »). Clôt la série de design phase 0. Aucun amendement aux ADRs antérieurs.

• v2.3 — Enrichissement substantiel d’ADR-001 (« IPC AirCom, refus de D-Bus comme transport principal »). Passage de 12 lignes à 197 lignes pour rendre la décision défendable face à des contributeurs venant de l’écosystème D-Bus traditionnel. La décision elle-même est inchangée ; seuls la pédagogie, la documentation des sources, et l’articulation avec les autres ADRs et principes Air sont développées. Aucun amendement aux autres ADRs.

• v2.4 — Ajout d’ADR-026 (« Contrat 1.0 d’air-tui ») pour cadrer le modèle d’interaction, les capacités, les dégradations acceptées, et le noyau de primitives de l’interface texte riche d’Air.

• v2.5 — Ajout d’ADR-027 (« Stratégie de documentation polyglotte — ABI C et bindings multi-langages »). Décide de générer la doc C/polyglotte depuis le code Rust (source unique de vérité), mise en œuvre différée à la couche 2. Ajout en tête d’une définition canonique du sigle ADR. Aucun amendement aux ADRs antérieurs.

• v2.6 — Ajout d’ADR-028 (« Soundness et téardown du module io_uring »). Grave les trois décisions S1 (slab pré-alloué, zéro alloc happy path), S2 (Drop quiescent + shutdown()), S3 (confinement par restrictions) émergées de la spécification détaillée du module io_uring. Complète ADR-022 sans modifier ses 10 décisions. Aucun amendement aux autres ADRs.

• v2.9 — Ajout d’ADR-031 (« Mesure de couverture en root sur les runners self-hosted »). Le job CI test-coverage mesure la couverture en root (sudo -n) pour que les tests d’intégration privilégiés (bpf()/CAP_BPF, uinput, perf, cgroup, bpffs) s’exécutent réellement sous instrumentation — ebpf, quasi-tout-privilégiée, est sinon plafonnée ~74 % non-root. Plancher inchangé (96 % lignes / 78 % branches). Prérequis : NOPASSWD sur les deux runners ; modèle de confiance dépôt privé / mono-mainteneur à revisiter avant l’ouverture publique. Aucun amendement aux autres ADRs.

• v2.8 — Ajout d’ADR-030 (« Périmètre de la règle des 80 % : production vs test-only »), companion d’ADR-024. Précise (sans amender ADR-024) que la règle des 80 % et le vendoring du Principe 6 visent les dépendances de production ([dependencies]) ; les deps dev/test-only, cfg-gated (loom), et la crate fuzz/ séparée en sont exemptées, mais restent soumises à deny.toml (licences, arbre transitif complet) et cargo audit. Débloque proptest/loom/cargo-fuzz pour les tests du module io_uring sans violer le Principe 6.

• v2.7 — Ajout d’ADR-029 (« Nommage de la surface publique »). Érige en règle, pour le nommage de l’API, la déclinaison du Principe 7 : surface conçue par Air = noms explicites sans abréviation (Zone 1) ; noms hérités d’une autorité consultable — ABI kernel, std Rust, termes POSIX — conservés verbatim (Zone 2). Test de décision et nuance des types miroir. Transverse à tout le framework. Aucun amendement aux autres ADRs.

Licence du document : MPL 2.0 Statut : Document fondateur. Édition directe autorisée en phase de design pré-ouverture publique ; après ouverture publique, l’ajout ou la modification d’un ADR passe par RFC.