v0.2.14-rel.001

CHANGELOG.md

@@ -1,8 +1,24 @@
 <!-- file: CHANGELOG.md -->
-<!-- version: 16 -->
+<!-- version: 18 -->
 
 # Changelog KSP
 
+## 0.2.14 — Program API foundation — 2026-08-28
+
+`0.2.14` introduit `ksp-program-api` comme première API publique extensible du domaine Program, volontairement limitée au décodage d’instructions et indépendante des runtimes supérieurs. La façade réexporte les contrats Core/Interface nécessaires puis possède `ProgramInstructionRecognition` (`NoMatch`, `ProgramMatch`, `ExactMatch`), `ProgramInstructionDecodeOutcome<Decoded>` (`Decoded`, `Unsupported`) et le trait `ProgramInstructionDecoder: Send + Sync`. L’output `Decoded` reste possédé par l’implémentation et ne reçoit aucun bound implicite `Debug`, `Clone`, `Send` ou `Sync`; les erreurs réelles restent dans le `Result` Core. Les Program IDs sont des `Pubkey` opaques : une implémentation externe peut prendre en charge un programme absent du registry Core sans enum centrale fermée, `Any`, JSON, descriptor global ni registry runtime.
+
+Le graphe normal final reste strictement `ksp-program-api -> ksp-core-lib + ksp-interface-lib`, Interface dépendant elle-même de Core. Aucun `ksp-program-lib`, codec, serde, logging, réseau, filesystem, environnement, Store, Materializer, Wallet, Config ou Tauri n’entre dans cette foundation. Les canaris public API, implémentation externe, dependency firewall, release completeness et hardening couvrent notamment l’inventaire exact de dix exports crate-root, les trois modules de production, un Program Pubkey non enregistré, l’input Interface maximal de 255 accounts / 10 240 bytes, l’absence d’echo automatique d’un payload hostile et l’absence de claim `dyn` hétérogène. `pre.005-fix.001` corrige uniquement un faux positif cross-crate du scanner Logging provoqué par le motif de test recherché, sans changement fonctionnel. Les gates `pre.006` et `pre.007` passent ensuite audits Rust/Markdown, `cargo check`, Clippy, les 18 tests Program API, ownership Logging et le workspace complet avant la réconciliation documentaire finale.
+
+`prompts/020-V0_3_1_START_PROMPT.md` ouvre `0.3.1 — Store RAW foundation` exclusivement depuis le tag stable `v0.2.14`. Le gate `pre.001` exige également l’archive historique `khadhroony-bot3_v0.5.3-pre.005-fix010.zip` afin d’auditer l’ancien `ks-store`, ses migrations PostgreSQL et ses contrats N1/N2/N3 sous une matrice `REPRENDRE / REDESSINER / REPORTER / REJETER`. L’archive reste une source historique uniquement : `0.3.1` doit créer `ksp-store-api` et `ksp-store-lib` avec PostgreSQL de référence et persistence **RAW seulement**, sans aspirer les contrats CORE/DECODE/SPECIALIZED, les jobs/workers, l’Interface `0.3.2` ni la configuration produit.
+
+## 0.2.13 — Interface / wire foundation — 2026-08-28
+
+`0.2.13` introduit `ksp-interface-lib` comme première façade wire officielle KSP, volontairement passive et Program-facing. La surface stable réexporte le `Pubkey` canonique de Core, ajoute `ProgramAccountMeta` et `ProgramInstruction` à champs privés avec accessors explicites, conserve l’ordre et les doublons des account metas, accepte les Program Pubkeys opaques et borne l’admission à **255 account metas** et **10 240 octets** de data. Les deux bornes sont des limites d’admission Interface et ne prétendent pas garantir à elles seules le fit d’une transaction Solana top-level. Les erreurs réutilisent le contrat Core `Error/Result` avec uniquement `field`, `actual_len` et `maximum_len`, tandis que le `Debug` de l’instruction n’expose que `program_id`, `account_count` et `data_len`.
+
+La dependency direction finale reste strictement `ksp-interface-lib -> ksp-core-lib -> solana-pubkey`. Aucun `serde`, codec générique (`borsh`, `wincode`, `bincode`), `solana-instruction`, runtime réseau ou logging n’est ajouté à cette foundation. Les canaris public API, consumer externe, dependency firewall et release completeness verrouillent les six exports crate-root, les quatre modules de production, l’absence de narrowing/codec caché, le transfert des `Vec` admis sans réallocation interne et la non-répétition de matériel hostile dans les erreurs. `pre.005-fix.001` corrige uniquement un faux positif du scanner Logging provoqué par le littéral de test `tracing::`, sans changement de production ni de dépendance. Les gates `pre.006` et `pre.007` passent ensuite audits Rust/Markdown, `cargo check`, Clippy, tests Interface, ownership Logging, workspace complet et graphes Cargo avant la réconciliation documentaire finale.
+
+`prompts/019-V0_2_14_START_PROMPT.md` ouvre `0.2.14 — Program API foundation` exclusivement depuis le tag stable `v0.2.13`. Le gate `pre.001` de cette prochaine release exige aussi l’archive historique `khadhroony-bot3_v0.5.3-pre.005-fix010.zip` afin d’auditer les anciens contrats decoder/executor sous une matrice `REPRENDRE / REDESSINER / REPORTER / REJETER`, sans faire de kbot3 une autorité architecturale ni recréer son monolithe `ks-lib`.
+
 ## 0.2.12 — SOL Prices Desk + projection prix Wallet — 2026-08-27
 
 `0.2.12` ajoute `ksp-app-solprices-desk`, troisième Desk Tauri spécialisé de KSP, comme HID strictement provider-neutral au-dessus de `ksp-offchain-transport-lib`. Son composite dédié sélectionne `std.logging` et `std.offchain_transport`; la vue Prices expose l’inventaire des huit providers SOL/USD, disponibilité, sémantique, auth, prix exact sous forme de chaîne, timestamps provider/KSP distincts et retry deadline sans inventer de fraîcheur. Les refresh manuel individuel, sélectionné et global passent exclusivement par `MarketPriceService`; les batchs sont bornés à `1..=64`, les états `in_flight` restent backend-owned et aucun polling, scheduler, fallback, moyenne ou prix canonique n’est introduit dans le Desk. Le frontend conserve l’absence de réseau/persistence navigateur et journalise les interactions sans prix, credential, URL, header ou payload provider.

Cargo.toml

@@ -1,12 +1,12 @@
 # file: Cargo.toml
-# version: 302
+# version: 322
 
 [workspace]
 resolver = "3"
-members = ["crates/ksp-app-config-desk", "crates/ksp-app-solprices-desk", "crates/ksp-app-wallet-desk", "crates/ksp-config-lib", "crates/ksp-core-lib", "crates/ksp-logging-lib", "crates/ksp-offchain-transport-lib", "crates/ksp-onchain-transport-lib", "crates/ksp-wallet-lib"]
+members = ["crates/ksp-app-config-desk", "crates/ksp-app-solprices-desk", "crates/ksp-app-wallet-desk", "crates/ksp-config-lib", "crates/ksp-core-lib", "crates/ksp-interface-lib", "crates/ksp-logging-lib", "crates/ksp-offchain-transport-lib", "crates/ksp-onchain-transport-lib", "crates/ksp-program-api", "crates/ksp-wallet-lib"]
 
 [workspace.package]
-version = "0.2.12"
+version = "0.2.14"
 edition = "2024"
 license = "MIT"
 repository = "https://git.sasedev.com/Sasedev/khadhroony-solana-project"

ROADMAP.md

@@ -1,5 +1,5 @@
 <!-- file: ROADMAP.md -->
-<!-- version: 90 -->
+<!-- version: 92 -->
 
 # Roadmap KSP
 
@@ -57,8 +57,8 @@ Le roadmap décrit les objectifs à atteindre et les grandes étapes prévues. U
 - [X] `0.2.10` — OrbitFlare Yellowstone gRPC stable : profil Config V3 Devnet, License Key injectée comme metadata secrète `x-token`, smoke live `Subscribe -> Slot + Ping` validé deux fois, sans modification du moteur N1/N2 ni heartbeat provider.
 - [X] `0.2.11` — Off-chain price transport stable : `ksp-offchain-transport-lib` expose SOL/USD via huit adapters REST `reqwest` sans SDK provider, décimal exact, sémantiques/provenance explicites, registry/availability/rate limits et refresh single/many/all génériques ; Config `std.offchain_transport` construit le service sans dépendance inverse, DexScreener reste lié à une paire explicite sans discovery, aucun consensus/fallback automatique n’est introduit, et le smoke live keyless final passe 7/7 après correction CoinMarketCap V2.
 - [X] `0.2.12` — SOL Prices Desk + projection prix Wallet stables : HID provider-neutral avec refresh row/selected/all et batch `1..=64`, observations/timestamps exacts sans polling/consensus, puis refresh balance Wallet enrichi d’une moyenne SOL/USD consumer-owned et d’un équivalent USD exact best-effort ; smoke live de composition, workspace complet et bundles Tauri Linux validés.
-- [ ] `0.2.13` — Introduire la première surface de `ksp-interface-lib`, façade wire KSP publique et passive utilisable par les implémentations officielles et externes ; `pre.001` doit confronter l’architecture actuelle aux contrats utiles de l’ancien `khadhroony-bot3` sans recréer son monolithe `ks-lib`, et séparer explicitement données wire, comportement Program et implémentations.
-- [ ] `0.2.14` — Introduire `ksp-program-api` comme premier contrat Program extensible, sans imposer encore `ksp-program-lib` complet ; les traits de reconnaissance/decode/build et autres comportements ne doivent pas être aspirés prématurément dans `ksp-interface-lib`.
+- [X] `0.2.13` — Interface / wire foundation stable : `ksp-interface-lib` expose `Pubkey`, `ProgramAccountMeta` et `ProgramInstruction` passifs, admission bornée à 255 account metas / 10 240 bytes, erreurs et `Debug` sans payload hostile, façade crate-root et consumer externe canaris ; graphe strict `Interface -> Core`, sans serde/codec générique, `solana-instruction`, réseau ni logging runtime.
+- [X] `0.2.14` — Program API foundation stable : `ksp-program-api` expose une surface instruction-only ouverte avec `ProgramInstructionRecognition`, `ProgramInstructionDecodeOutcome<Decoded>` et `ProgramInstructionDecoder`; implémentation externe avec Program Pubkey opaque validée, 10 exports crate-root / 3 modules de production verrouillés, graphe strict Core + Interface, sans registry/runtime/serde/codec/Store/Materializer/Execution. Le prompt `0.3.1` prépare Store RAW-only.
 
 ### TODO/IDEAS — providers Yellowstone non planifiés
 

crates/ksp-interface-lib/Cargo.toml

@@ -0,0 +1,14 @@
+# file: crates/ksp-interface-lib/Cargo.toml
+# version: 1
+
+[package]
+name = "ksp-interface-lib"
+version.workspace = true
+edition.workspace = true
+repository.workspace = true
+
+[dependencies]
+ksp-core-lib = { path = "../ksp-core-lib" }
+
+[lints]
+workspace = true

crates/ksp-interface-lib/README.md

@@ -0,0 +1,131 @@
+<!-- file: crates/ksp-interface-lib/README.md -->
+<!-- version: 2 -->
+
+# ksp-interface-lib
+
+`ksp-interface-lib` est la façade wire officielle KSP destinée aux contrats passifs partagés par les implémentations Program Solana officielles ou externes. La crate expose uniquement des structures de représentation/admission ; elle ne possède ni transport, ni exécution, ni persistence, ni comportement métier Program.
+
+## Ownership
+
+La crate réutilise les primitives fondamentales déjà possédées par `ksp-core-lib` :
+
+```text
+Pubkey
+Error / ErrorCode / Result
+Program IDs fondamentaux
+```
+
+`Pubkey` est réexporté depuis le crate-root Interface afin qu'un consumer wire n'introduise aucun wrapper d'identité parallèle. Les Program IDs restent possédés et répertoriés par Core.
+
+La dependency direction candidate `0.2.13` reste strictement :
+
+```text
+ksp-interface-lib
+└── ksp-core-lib
+    └── solana-pubkey
+```
+
+## Surface publique `0.2.13`
+
+La façade crate-root expose exactement :
+
+```text
+Pubkey
+ProgramAccountMeta
+MAX_PROGRAM_INSTRUCTION_ACCOUNTS
+ProgramInstruction
+MAX_PROGRAM_INSTRUCTION_DATA_LEN
+ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED
+```
+
+Aucun module interne n'est public.
+
+### `ProgramAccountMeta`
+
+`ProgramAccountMeta` représente un compte ordonné d'une instruction avec :
+
+```text
+pubkey
+is_signer
+is_writable
+```
+
+Les champs restent privés. Les constructeurs publics sont `readonly(pubkey, is_signer)` et `writable(pubkey, is_signer)`, complétés par les accessors `pubkey()`, `is_signer()` et `is_writable()`.
+
+La structure n'applique aucune sémantique spécifique à un programme et n'exige pas que la `Pubkey` appartienne au registry des Program IDs Core.
+
+### `ProgramInstruction`
+
+`ProgramInstruction` représente un contrat passif borné :
+
+```text
+program_id
+accounts: Vec<ProgramAccountMeta>
+data: Vec<u8>
+```
+
+`ProgramInstruction::try_new` consomme directement les deux `Vec`, conserve l'ordre et les doublons des accounts et préserve les octets opaques de `data` sans décodage.
+
+Les cas vides sont valides et une `program_id` inconnue du registry KSP reste admissible.
+
+## Bornes d'admission
+
+Interface applique deux limites locales :
+
+| Limite                             | Valeur   |
+|------------------------------------|----------|
+| `MAX_PROGRAM_INSTRUCTION_ACCOUNTS` | `255`    |
+| `MAX_PROGRAM_INSTRUCTION_DATA_LEN` | `10_240` |
+
+Ces valeurs sont des **bornes d'admission Interface**. Elles ne constituent pas une garantie qu'une instruction donnée tient dans toutes les contraintes d'une transaction Solana top-level. La limite CPI de comptes uniques n'est notamment pas transformée en règle artificielle sur la liste d'account metas.
+
+Un dépassement utilise le code commun :
+
+```text
+interface.program_instruction_limit_exceeded
+```
+
+Le contexte d'erreur est limité aux métadonnées sûres `field`, `actual_len` et `maximum_len`. Aucun payload arbitraire ni account meta hostile n'est recopié dans l'erreur.
+
+Le `Debug` de `ProgramInstruction` est volontairement borné : il affiche `program_id`, `account_count` et `data_len`, jamais les accounts complets ni les octets du payload.
+
+## Codecs et runtime
+
+La foundation `0.2.13` n'ajoute aucun codec par réflexe :
+
+```text
+serde / serde_json        absents
+borsh                     absent
+wincode                   absent
+bincode                   absent
+solana-instruction        absent
+```
+
+Des codecs/layouts/discriminants spécifiques pourront être ajoutés ultérieurement uniquement lorsqu'un vertical Program réel en démontre le besoin et que leur ownership wire appartient bien à Interface.
+
+La crate ne produit aucun événement runtime. Elle ne dépend donc pas de `ksp-logging-lib` et ne possède ni `constants.rs` ni `TRACING_TARGET`. Si un futur comportement Interface exige réellement du logging, le runtime devra passer par la façade Logging KSP plutôt que par une dépendance directe à Tracing.
+
+## Frontières
+
+`ksp-interface-lib` ne possède pas :
+
+```text
+RPC / WebSocket / gRPC
+provider DTOs Transport
+wallet / signature
+Config / environnement
+persistence / Store
+Program decoding / recognition / proofs
+execution policy / signers
+transaction replay / CPI path / runtime logs
+lifecycle réseau
+```
+
+La foundation Program API est reportée à `0.2.14`. Les wires génériques d'acquisition/CORE restent reportés à `0.3.2+`.
+
+## Références
+
+- [Usage public](USAGE.md)
+- [Plan `0.2.13`](../../docs/plans/020-V0_2_13_INTERFACE_PLAN.md)
+- [Validation `0.2.13`](../../docs/validation/016-V0_2_13_INTERFACE.md)
+- [Architecture Wire + Program](../../docs/architecture/006-WIRE_AND_PROGRAM.md)

crates/ksp-interface-lib/USAGE.md

@@ -0,0 +1,122 @@
+<!-- file: crates/ksp-interface-lib/USAGE.md -->
+<!-- version: 2 -->
+
+# Usage de ksp-interface-lib
+
+Cette page décrit la façade publique matérialisée par `0.2.13`. Les modules internes ne font pas partie du contrat consommable : utiliser uniquement les exports du crate-root.
+
+## Construire des account metas
+
+```rust
+let readonly_account = ksp_interface_lib::Pubkey::new_from_array([1_u8; 32]);
+let writable_account = ksp_interface_lib::Pubkey::new_from_array([2_u8; 32]);
+
+let readonly = ksp_interface_lib::ProgramAccountMeta::readonly(readonly_account, true);
+let writable = ksp_interface_lib::ProgramAccountMeta::writable(writable_account, false);
+
+assert_eq!(readonly.pubkey(), &readonly_account);
+assert!(readonly.is_signer());
+assert!(!readonly.is_writable());
+
+assert_eq!(writable.pubkey(), &writable_account);
+assert!(!writable.is_signer());
+assert!(writable.is_writable());
+```
+
+`readonly`/`writable` décrivent uniquement les flags wire de l'account meta. Interface ne valide pas l'identité du compte contre un registry Program.
+
+## Construire une instruction passive
+
+```rust
+let program_id = ksp_interface_lib::Pubkey::new_from_array([3_u8; 32]);
+let account_id = ksp_interface_lib::Pubkey::new_from_array([4_u8; 32]);
+
+let account = ksp_interface_lib::ProgramAccountMeta::writable(account_id, true);
+let result = ksp_interface_lib::ProgramInstruction::try_new(
+    program_id,
+    std::vec![account, account],
+    std::vec![7_u8, 8, 9],
+);
+
+match result {
+    std::result::Result::Ok(instruction) => {
+        assert_eq!(instruction.program_id(), &program_id);
+        assert_eq!(instruction.accounts(), &[account, account]);
+        assert_eq!(instruction.data(), &[7_u8, 8, 9]);
+    }
+    std::result::Result::Err(error) => {
+        eprintln!("{error}");
+    }
+}
+```
+
+L'ordre et les doublons des accounts sont conservés. Les octets `data` restent opaques : `ProgramInstruction` ne les sérialise, désérialise ni interprète.
+
+Les `Vec` fournis à `try_new` sont consommés par la structure après validation des bornes ; aucun clone ou reformatage interne n'est requis par le contrat actuel.
+
+## Bornes
+
+Les limites publiques sont :
+
+```rust
+assert_eq!(ksp_interface_lib::MAX_PROGRAM_INSTRUCTION_ACCOUNTS, 255);
+assert_eq!(ksp_interface_lib::MAX_PROGRAM_INSTRUCTION_DATA_LEN, 10_240);
+```
+
+`255` account metas et `10_240` bytes de data sont admis. `256` account metas ou `10_241` bytes sont refusés par `try_new` avant création d'un `ProgramInstruction` valide.
+
+Ces limites sont des bornes locales Interface et ne promettent pas qu'une instruction admise respecte à elle seule toutes les contraintes de taille/account-set d'une transaction Solana complète.
+
+## Observer une erreur de limite
+
+Le code public est :
+
+```rust
+assert_eq!(
+    ksp_interface_lib::ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED.domain(),
+    "interface",
+);
+assert_eq!(
+    ksp_interface_lib::ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED.code(),
+    "program_instruction_limit_exceeded",
+);
+```
+
+Une erreur de dépassement expose uniquement un contexte structurel sûr :
+
+```text
+field
+actual_len
+maximum_len
+```
+
+Le contenu du payload et les account metas arbitraires ne sont pas projetés dans le diagnostic.
+
+## Debug borné
+
+Le `Debug` de `ProgramInstruction` contient uniquement :
+
+```text
+program_id
+account_count
+data_len
+```
+
+Il ne faut donc pas attendre de ce rendu une sérialisation wire ou un dump du payload.
+
+## Dépendances à ne pas ajouter côté consumer
+
+Un consumer de la façade Interface n'a pas besoin d'ajouter un SDK Program Solana uniquement pour reconstruire `ProgramInstruction`. La crate utilise le `Pubkey` canonique partagé avec Core et conserve son propre contrat passif.
+
+La foundation ne fournit volontairement pas :
+
+```text
+serde générique
+Borsh / Wincode générique
+solana-instruction interop automatique
+transport réseau
+Program decoder/preparer
+signing/execution
+```
+
+Ces surfaces doivent être introduites dans leur owner respectif lorsqu'un cas réel le justifie, pas comme dépendances implicites d'un consumer Interface.

crates/ksp-interface-lib/src/error.rs

@@ -0,0 +1,6 @@
+// file: crates/ksp-interface-lib/src/error.rs
+// version: 1
+
+/// Error code used when a bounded passive Program instruction contract exceeds one of its Interface-owned admission limits.
+pub const ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED: ksp_core_lib::ErrorCode =
+    ksp_core_lib::ErrorCode::new("interface", "program_instruction_limit_exceeded");

crates/ksp-interface-lib/src/lib.rs

@@ -0,0 +1,30 @@
+// file: crates/ksp-interface-lib/src/lib.rs
+// version: 3
+
+#![warn(missing_docs)]
+#![deny(unreachable_pub)]
+#![forbid(unsafe_code)]
+
+//! Passive wire contracts shared by KSP Program implementations.
+//!
+//! The foundation reuses the canonical Solana [`Pubkey`] owned by
+//! `ksp-core-lib` and exposes only bounded, passive Program-facing structures.
+//! Runtime, transport, persistence and Program behavior remain outside this
+//! crate.
+
+mod error;
+mod program_account_meta;
+mod program_instruction;
+
+/// Error code used when an Interface-owned Program instruction admission limit is exceeded.
+pub use self::error::ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED;
+/// Maximum number of account metas admitted by one passive Program instruction contract.
+pub use self::program_account_meta::MAX_PROGRAM_INSTRUCTION_ACCOUNTS;
+/// Passive account metadata attached to one Program instruction.
+pub use self::program_account_meta::ProgramAccountMeta;
+/// Maximum opaque data payload admitted by one passive Program instruction contract.
+pub use self::program_instruction::MAX_PROGRAM_INSTRUCTION_DATA_LEN;
+/// Passive, bounded Program instruction wire contract.
+pub use self::program_instruction::ProgramInstruction;
+/// Canonical Solana account address primitive owned by `ksp-core-lib`.
+pub use ksp_core_lib::Pubkey;

crates/ksp-interface-lib/src/program_account_meta.rs

@@ -0,0 +1,52 @@
+// file: crates/ksp-interface-lib/src/program_account_meta.rs
+// version: 1
+
+/// Maximum number of account metas admitted by one passive Program instruction contract.
+pub const MAX_PROGRAM_INSTRUCTION_ACCOUNTS: usize = 255;
+
+/// Passive account metadata attached to one Program instruction.
+///
+/// Account metas preserve the caller-provided Solana account identity and the
+/// signer/writable flags without applying Program-specific semantics.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ProgramAccountMeta {
+    pubkey: crate::Pubkey,
+    is_signer: bool,
+    is_writable: bool,
+}
+
+impl ProgramAccountMeta {
+    /// Creates one read-only account meta.
+    #[must_use]
+    pub const fn readonly(pubkey: crate::Pubkey, is_signer: bool) -> Self {
+        return Self { pubkey, is_signer, is_writable: false };
+    }
+
+    /// Creates one writable account meta.
+    #[must_use]
+    pub const fn writable(pubkey: crate::Pubkey, is_signer: bool) -> Self {
+        return Self { pubkey, is_signer, is_writable: true };
+    }
+
+    /// Returns whether this account must sign the containing instruction.
+    #[must_use]
+    pub const fn is_signer(&self) -> bool {
+        return self.is_signer;
+    }
+
+    /// Returns whether this account may be written by the containing instruction.
+    #[must_use]
+    pub const fn is_writable(&self) -> bool {
+        return self.is_writable;
+    }
+
+    /// Returns the canonical account address.
+    #[must_use]
+    pub const fn pubkey(&self) -> &crate::Pubkey {
+        return &self.pubkey;
+    }
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/program_account_meta.rs"]
+mod tests;

crates/ksp-interface-lib/src/program_instruction.rs

@@ -0,0 +1,81 @@
+// file: crates/ksp-interface-lib/src/program_instruction.rs
+// version: 1
+
+/// Maximum opaque data payload admitted by one passive Program instruction contract.
+pub const MAX_PROGRAM_INSTRUCTION_DATA_LEN: usize = 10 * 1024;
+
+/// Passive, bounded Program instruction wire contract.
+///
+/// The instruction preserves the caller-provided Program identity, ordered
+/// account metas and opaque data bytes without applying Program-specific
+/// semantics. Construction enforces only the Interface-owned admission bounds.
+pub struct ProgramInstruction {
+    program_id: crate::Pubkey,
+    accounts: std::vec::Vec<crate::ProgramAccountMeta>,
+    data: std::vec::Vec<u8>,
+}
+
+impl ProgramInstruction {
+    /// Creates one passive Program instruction after enforcing Interface admission bounds.
+    ///
+    /// The provided vectors are consumed directly. Their account order and duplicates
+    /// are preserved exactly when construction succeeds.
+    pub fn try_new(program_id: crate::Pubkey, accounts: std::vec::Vec<crate::ProgramAccountMeta>, data: std::vec::Vec<u8>) -> ksp_core_lib::Result<Self> {
+        if accounts.len() > crate::MAX_PROGRAM_INSTRUCTION_ACCOUNTS {
+            return std::result::Result::Err(
+                ksp_core_lib::Error::new(
+                    crate::ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED,
+                    "Program instruction account count exceeds the Interface admission limit",
+                )
+                .with_context("field", "accounts")
+                .with_context("actual_len", accounts.len().to_string())
+                .with_context("maximum_len", crate::MAX_PROGRAM_INSTRUCTION_ACCOUNTS.to_string()),
+            );
+        }
+        if data.len() > crate::MAX_PROGRAM_INSTRUCTION_DATA_LEN {
+            return std::result::Result::Err(
+                ksp_core_lib::Error::new(
+                    crate::ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED,
+                    "Program instruction data length exceeds the Interface admission limit",
+                )
+                .with_context("field", "data")
+                .with_context("actual_len", data.len().to_string())
+                .with_context("maximum_len", crate::MAX_PROGRAM_INSTRUCTION_DATA_LEN.to_string()),
+            );
+        }
+        return std::result::Result::Ok(Self { program_id, accounts, data });
+    }
+
+    /// Returns the ordered account metas exactly as admitted at construction.
+    #[must_use]
+    pub fn accounts(&self) -> &[crate::ProgramAccountMeta] {
+        return self.accounts.as_slice();
+    }
+
+    /// Returns the opaque Program instruction data bytes.
+    #[must_use]
+    pub fn data(&self) -> &[u8] {
+        return self.data.as_slice();
+    }
+
+    /// Returns the Program identity.
+    #[must_use]
+    pub const fn program_id(&self) -> &crate::Pubkey {
+        return &self.program_id;
+    }
+}
+
+impl std::fmt::Debug for ProgramInstruction {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        return formatter
+            .debug_struct("ProgramInstruction")
+            .field("program_id", &self.program_id)
+            .field("account_count", &self.accounts.len())
+            .field("data_len", &self.data.len())
+            .finish();
+    }
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/program_instruction.rs"]
+mod tests;

crates/ksp-interface-lib/tests/dependency_boundary.rs

@@ -0,0 +1,131 @@
+// file: crates/ksp-interface-lib/tests/dependency_boundary.rs
+// version: 5
+
+//! Dependency and passive-surface canaries for the Interface foundation.
+
+#[test]
+fn pre_002_manifest_has_exact_core_only_runtime_dependency() {
+    let manifest = include_str!("../Cargo.toml");
+    let dependencies_tail = manifest.split("[dependencies]").nth(1);
+    assert!(dependencies_tail.is_some(), "Interface dependencies section must exist");
+    let dependencies_tail = match dependencies_tail {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let dependencies = match dependencies_tail.split("[lints]").next() {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    assert_eq!(manifest_dependency_names(dependencies), std::vec!["ksp-core-lib"]);
+    for forbidden in [
+        "ksp-config-lib",
+        "ksp-logging-lib",
+        "ksp-offchain-transport-lib",
+        "ksp-onchain-transport-lib",
+        "ksp-program-api",
+        "ksp-program-lib",
+        "ksp-store-api",
+        "ksp-store-lib",
+        "ksp-wallet-lib",
+        "borsh",
+        "bincode",
+        "reqwest",
+        "serde",
+        "serde_json",
+        "solana-instruction",
+        "tauri",
+        "tokio",
+        "tonic",
+        "tracing",
+        "wincode",
+    ] {
+        assert!(!dependencies.contains(forbidden), "forbidden Interface dependency detected: {forbidden}");
+    }
+    return;
+}
+
+#[test]
+fn pre_005_surface_remains_passive_without_codecs_or_runtime_logging() {
+    let crate_root = include_str!("../src/lib.rs");
+    assert!(crate_root.contains("ProgramAccountMeta"));
+    assert!(crate_root.contains("MAX_PROGRAM_INSTRUCTION_ACCOUNTS"));
+    assert!(crate_root.contains("ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED"));
+    assert!(crate_root.contains("ProgramInstruction"));
+    assert!(crate_root.contains("MAX_PROGRAM_INSTRUCTION_DATA_LEN"));
+    assert!(!crate_root.contains("TRACING_TARGET"));
+    assert!(!crate_root.contains("ksp_logging_lib"));
+    assert!(!std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src/constants.rs").exists());
+    let instruction_source = include_str!("../src/program_instruction.rs");
+    for forbidden in ["serde", "borsh", "bincode", "wincode", "solana_instruction", "ksp_logging_lib", "TRACING_TARGET"] {
+        assert!(!instruction_source.contains(forbidden), "forbidden Interface surface detected: {forbidden}");
+    }
+    return;
+}
+
+fn manifest_dependency_names(section: &str) -> std::vec::Vec<&str> {
+    let mut names = std::vec::Vec::new();
+    for line in section.lines() {
+        let content = match line.split('#').next() {
+            std::option::Option::Some(value) => value.trim(),
+            std::option::Option::None => continue,
+        };
+        if content.is_empty() {
+            continue;
+        }
+        let name = match content.split('=').next() {
+            std::option::Option::Some(value) => value.trim().trim_end_matches(".workspace"),
+            std::option::Option::None => continue,
+        };
+        if !name.is_empty() {
+            names.push(name);
+        }
+    }
+    names.sort_unstable();
+    return names;
+}
+
+#[test]
+fn pre_005_all_production_sources_preserve_the_dependency_firewall() {
+    let production_sources = [
+        include_str!("../src/error.rs"),
+        include_str!("../src/lib.rs"),
+        include_str!("../src/program_account_meta.rs"),
+        include_str!("../src/program_instruction.rs"),
+    ];
+    for source in production_sources {
+        for forbidden in [
+            "borsh::",
+            "bincode::",
+            "ksp_config_lib::",
+            "ksp_logging_lib::",
+            "ksp_offchain_transport_lib::",
+            "ksp_onchain_transport_lib::",
+            "ksp_program_api::",
+            "ksp_program_lib::",
+            "ksp_store_api::",
+            "ksp_store_lib::",
+            "ksp_wallet_lib::",
+            "reqwest::",
+            "serde::",
+            "serde_json::",
+            "solana_instruction::",
+            "tauri::",
+            "tokio::",
+            "tonic::",
+            concat!("tracing", "::"),
+            "wincode::",
+        ] {
+            assert!(!source.contains(forbidden), "forbidden production dependency path detected: {forbidden}");
+        }
+    }
+    return;
+}
+
+#[test]
+fn pre_005_instruction_source_has_no_narrowing_cast_or_hidden_codec_entry_point() {
+    let instruction_source = include_str!("../src/program_instruction.rs");
+    for forbidden in [" as u8", " as u16", " as u32", " as u64", "serialize", "deserialize", "encode", "decode"] {
+        assert!(!instruction_source.contains(forbidden), "forbidden instruction implementation pattern detected: {forbidden}");
+    }
+    return;
+}

crates/ksp-interface-lib/tests/external_consumer.rs

@@ -0,0 +1,27 @@
+// file: crates/ksp-interface-lib/tests/external_consumer.rs
+// version: 1
+
+//! Downstream-style consumer canary for the public Interface facade.
+
+fn consume_instruction(instruction: ksp_interface_lib::ProgramInstruction) -> (ksp_interface_lib::Pubkey, usize, usize) {
+    return (*instruction.program_id(), instruction.accounts().len(), instruction.data().len());
+}
+
+#[test]
+fn pre_005_external_consumer_uses_only_the_crate_root_facade() {
+    let program_id = ksp_interface_lib::Pubkey::new_from_array([0xA1_u8; 32]);
+    let account_id = ksp_interface_lib::Pubkey::new_from_array([0xA2_u8; 32]);
+    let readonly = ksp_interface_lib::ProgramAccountMeta::readonly(account_id, true);
+    let writable = ksp_interface_lib::ProgramAccountMeta::writable(account_id, false);
+    let instruction = ksp_interface_lib::ProgramInstruction::try_new(program_id, std::vec![readonly, writable, readonly], std::vec![7_u8, 8, 9]);
+    assert!(instruction.is_ok());
+    let instruction = match instruction {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    assert_eq!(consume_instruction(instruction), (program_id, 3, 3));
+    assert_eq!(ksp_interface_lib::MAX_PROGRAM_INSTRUCTION_ACCOUNTS, 255);
+    assert_eq!(ksp_interface_lib::MAX_PROGRAM_INSTRUCTION_DATA_LEN, 10_240);
+    assert_eq!(ksp_interface_lib::ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED.domain(), "interface");
+    return;
+}

crates/ksp-interface-lib/tests/public_api.rs

@@ -0,0 +1,79 @@
+// file: crates/ksp-interface-lib/tests/public_api.rs
+// version: 4
+
+//! Integration canaries for the public `ksp-interface-lib` foundation.
+
+fn consume_pubkey(pubkey: ksp_interface_lib::Pubkey) -> [u8; 32] {
+    return pubkey.to_bytes();
+}
+
+#[test]
+fn public_pre_002_pubkey_contract_is_available_from_crate_root() {
+    let pubkey = ksp_interface_lib::Pubkey::default();
+    assert_eq!(consume_pubkey(pubkey), [0_u8; 32]);
+    return;
+}
+
+#[test]
+fn public_pre_003_account_meta_and_limit_contracts_are_available_from_crate_root() {
+    let pubkey = ksp_interface_lib::Pubkey::new_from_array([3_u8; 32]);
+    let readonly = ksp_interface_lib::ProgramAccountMeta::readonly(pubkey, true);
+    let writable = ksp_interface_lib::ProgramAccountMeta::writable(pubkey, false);
+    assert_eq!(readonly.pubkey(), &pubkey);
+    assert!(readonly.is_signer());
+    assert!(!readonly.is_writable());
+    assert_eq!(writable.pubkey(), &pubkey);
+    assert!(!writable.is_signer());
+    assert!(writable.is_writable());
+    assert_eq!(ksp_interface_lib::MAX_PROGRAM_INSTRUCTION_ACCOUNTS, 255);
+    return;
+}
+
+#[test]
+fn public_pre_003_interface_error_code_is_stable_and_core_owned() {
+    let code: ksp_core_lib::ErrorCode = ksp_interface_lib::ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED;
+    assert_eq!(code.domain(), "interface");
+    assert_eq!(code.code(), "program_instruction_limit_exceeded");
+    return;
+}
+
+#[test]
+fn public_pre_004_program_instruction_contract_is_available_from_crate_root() {
+    let program_id = ksp_interface_lib::Pubkey::new_from_array([4_u8; 32]);
+    let account = ksp_interface_lib::ProgramAccountMeta::readonly(ksp_interface_lib::Pubkey::new_from_array([5_u8; 32]), true);
+    let instruction = ksp_interface_lib::ProgramInstruction::try_new(program_id, std::vec![account], std::vec![1_u8, 2, 3]);
+    assert!(instruction.is_ok());
+    let instruction = match instruction {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    assert_eq!(instruction.program_id(), &program_id);
+    assert_eq!(instruction.accounts(), &[account]);
+    assert_eq!(instruction.data(), &[1_u8, 2, 3]);
+    assert_eq!(ksp_interface_lib::MAX_PROGRAM_INSTRUCTION_DATA_LEN, 10_240);
+    return;
+}
+
+#[test]
+fn public_pre_005_limit_error_is_observable_without_private_module_access() {
+    let program_id = ksp_interface_lib::Pubkey::new_from_array([0xC1_u8; 32]);
+    let rejected = ksp_interface_lib::ProgramInstruction::try_new(
+        program_id,
+        std::vec::Vec::new(),
+        std::vec![0xC2_u8; ksp_interface_lib::MAX_PROGRAM_INSTRUCTION_DATA_LEN + 1],
+    );
+    assert!(rejected.is_err());
+    let error = match rejected {
+        std::result::Result::Err(value) => value,
+        std::result::Result::Ok(_) => return,
+    };
+    assert_eq!(error.code(), ksp_interface_lib::ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED);
+    assert_eq!(error.context().len(), 3);
+    assert_eq!(error.context()[0].key(), "field");
+    assert_eq!(error.context()[0].value(), "data");
+    assert_eq!(error.context()[1].key(), "actual_len");
+    assert_eq!(error.context()[1].value(), "10241");
+    assert_eq!(error.context()[2].key(), "maximum_len");
+    assert_eq!(error.context()[2].value(), "10240");
+    return;
+}

crates/ksp-interface-lib/tests/release_completeness.rs

@@ -0,0 +1,75 @@
+// file: crates/ksp-interface-lib/tests/release_completeness.rs
+// version: 1
+
+//! Release-level completeness canaries for the `0.2.13` Interface foundation.
+
+#[test]
+fn pre_005_exact_crate_root_export_inventory_is_stable() {
+    let crate_root = include_str!("../src/lib.rs");
+    let mut actual = std::vec::Vec::new();
+    for line in crate_root.lines() {
+        let trimmed = line.trim();
+        if trimmed.starts_with("pub use ") {
+            actual.push(trimmed);
+        }
+    }
+    actual.sort_unstable();
+    let mut expected = std::vec![
+        "pub use self::error::ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED;",
+        "pub use self::program_account_meta::MAX_PROGRAM_INSTRUCTION_ACCOUNTS;",
+        "pub use self::program_account_meta::ProgramAccountMeta;",
+        "pub use self::program_instruction::MAX_PROGRAM_INSTRUCTION_DATA_LEN;",
+        "pub use self::program_instruction::ProgramInstruction;",
+        "pub use ksp_core_lib::Pubkey;",
+    ];
+    expected.sort_unstable();
+    assert_eq!(actual, expected);
+    assert!(!crate_root.contains("pub mod "));
+    return;
+}
+
+#[test]
+fn pre_005_production_module_inventory_contains_no_second_wire_domain() -> std::io::Result<()> {
+    let source_root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src");
+    let entries = match std::fs::read_dir(source_root) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let mut names = std::vec::Vec::new();
+    for entry in entries {
+        let entry = match entry {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let file_type = match entry.file_type() {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        if !file_type.is_file() {
+            continue;
+        }
+        let name = match entry.file_name().into_string() {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(_) => continue,
+        };
+        if name.ends_with(".rs") {
+            names.push(name);
+        }
+    }
+    names.sort_unstable();
+    assert_eq!(names, std::vec!["error.rs", "lib.rs", "program_account_meta.rs", "program_instruction.rs"]);
+    return std::result::Result::Ok(());
+}
+
+#[test]
+fn pre_005_foundation_has_one_error_code_and_two_bounded_passive_types() {
+    assert_eq!(ksp_interface_lib::ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED.domain(), "interface");
+    assert_eq!(ksp_interface_lib::ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED.code(), "program_instruction_limit_exceeded");
+    assert_eq!(ksp_interface_lib::MAX_PROGRAM_INSTRUCTION_ACCOUNTS, 255);
+    assert_eq!(ksp_interface_lib::MAX_PROGRAM_INSTRUCTION_DATA_LEN, 10_240);
+    let program_id = ksp_interface_lib::Pubkey::new_from_array([0xB1_u8; 32]);
+    let account = ksp_interface_lib::ProgramAccountMeta::readonly(ksp_interface_lib::Pubkey::new_from_array([0xB2_u8; 32]), false);
+    let instruction = ksp_interface_lib::ProgramInstruction::try_new(program_id, std::vec![account], std::vec![0xB3_u8]);
+    assert!(instruction.is_ok());
+    return;
+}

crates/ksp-interface-lib/unit_tests/program_account_meta.rs

@@ -0,0 +1,31 @@
+// file: crates/ksp-interface-lib/unit_tests/program_account_meta.rs
+// version: 1
+
+#[test]
+fn readonly_and_writable_constructors_preserve_identity_signer_and_writable_flags() {
+    let readonly_pubkey = crate::Pubkey::new_from_array([7_u8; 32]);
+    let writable_pubkey = crate::Pubkey::new_from_array([9_u8; 32]);
+    let readonly = crate::ProgramAccountMeta::readonly(readonly_pubkey, true);
+    assert_eq!(readonly.pubkey(), &readonly_pubkey);
+    assert!(readonly.is_signer());
+    assert!(!readonly.is_writable());
+    let writable = crate::ProgramAccountMeta::writable(writable_pubkey, false);
+    assert_eq!(writable.pubkey(), &writable_pubkey);
+    assert!(!writable.is_signer());
+    assert!(writable.is_writable());
+    return;
+}
+
+#[test]
+fn account_meta_accepts_opaque_pubkeys_without_program_registry_validation() {
+    let opaque_pubkey = crate::Pubkey::new_from_array([0xA5_u8; 32]);
+    let meta = crate::ProgramAccountMeta::readonly(opaque_pubkey, false);
+    assert_eq!(meta.pubkey(), &opaque_pubkey);
+    return;
+}
+
+#[test]
+fn account_limit_constant_matches_the_interface_admission_contract() {
+    assert_eq!(crate::MAX_PROGRAM_INSTRUCTION_ACCOUNTS, 255);
+    return;
+}

crates/ksp-interface-lib/unit_tests/program_instruction.rs

@@ -0,0 +1,162 @@
+// file: crates/ksp-interface-lib/unit_tests/program_instruction.rs
+// version: 2
+
+fn meta(byte: u8, writable: bool) -> crate::ProgramAccountMeta {
+    let pubkey = crate::Pubkey::new_from_array([byte; 32]);
+    if writable {
+        return crate::ProgramAccountMeta::writable(pubkey, false);
+    }
+    return crate::ProgramAccountMeta::readonly(pubkey, false);
+}
+
+#[test]
+fn instruction_accepts_empty_accounts_and_data_with_opaque_program_id() {
+    let program_id = crate::Pubkey::new_from_array([0xD3_u8; 32]);
+    let instruction = crate::ProgramInstruction::try_new(program_id, std::vec::Vec::new(), std::vec::Vec::new());
+    assert!(instruction.is_ok());
+    let instruction = match instruction {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    assert_eq!(instruction.program_id(), &program_id);
+    assert!(instruction.accounts().is_empty());
+    assert!(instruction.data().is_empty());
+    return;
+}
+
+#[test]
+fn instruction_preserves_account_order_duplicates_and_opaque_data() {
+    let program_id = crate::Pubkey::new_from_array([0x41_u8; 32]);
+    let first = meta(1, false);
+    let duplicate = meta(2, true);
+    let accounts = std::vec![first, duplicate, first];
+    let data = std::vec![0_u8, 1, 2, 0xFF];
+    let instruction = crate::ProgramInstruction::try_new(program_id, accounts, data.clone());
+    assert!(instruction.is_ok());
+    let instruction = match instruction {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    assert_eq!(instruction.accounts(), &[first, duplicate, first]);
+    assert_eq!(instruction.data(), data.as_slice());
+    return;
+}
+
+#[test]
+fn instruction_accepts_account_limit_and_rejects_one_above_it() {
+    let program_id = crate::Pubkey::new_from_array([0x51_u8; 32]);
+    let account = meta(7, false);
+    let accepted = crate::ProgramInstruction::try_new(program_id, std::vec![account; crate::MAX_PROGRAM_INSTRUCTION_ACCOUNTS], std::vec::Vec::new());
+    assert!(accepted.is_ok());
+    let rejected = crate::ProgramInstruction::try_new(program_id, std::vec![account; crate::MAX_PROGRAM_INSTRUCTION_ACCOUNTS + 1], std::vec::Vec::new());
+    assert!(rejected.is_err());
+    let error = match rejected {
+        std::result::Result::Err(value) => value,
+        std::result::Result::Ok(_) => return,
+    };
+    assert_eq!(error.code(), crate::ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED);
+    assert_eq!(error.message(), "Program instruction account count exceeds the Interface admission limit");
+    assert_eq!(error.context().len(), 3);
+    assert_eq!(error.context()[0].key(), "field");
+    assert_eq!(error.context()[0].value(), "accounts");
+    assert_eq!(error.context()[1].key(), "actual_len");
+    assert_eq!(error.context()[1].value(), "256");
+    assert_eq!(error.context()[2].key(), "maximum_len");
+    assert_eq!(error.context()[2].value(), "255");
+    return;
+}
+
+#[test]
+fn instruction_accepts_data_limit_and_rejects_one_byte_above_it() {
+    let program_id = crate::Pubkey::new_from_array([0x61_u8; 32]);
+    let accepted = crate::ProgramInstruction::try_new(program_id, std::vec::Vec::new(), std::vec![0xA5_u8; crate::MAX_PROGRAM_INSTRUCTION_DATA_LEN]);
+    assert!(accepted.is_ok());
+    let rejected = crate::ProgramInstruction::try_new(program_id, std::vec::Vec::new(), std::vec![0x5A_u8; crate::MAX_PROGRAM_INSTRUCTION_DATA_LEN + 1]);
+    assert!(rejected.is_err());
+    let error = match rejected {
+        std::result::Result::Err(value) => value,
+        std::result::Result::Ok(_) => return,
+    };
+    assert_eq!(error.code(), crate::ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED);
+    assert_eq!(error.message(), "Program instruction data length exceeds the Interface admission limit");
+    assert_eq!(error.context().len(), 3);
+    assert_eq!(error.context()[0].value(), "data");
+    assert_eq!(error.context()[1].value(), "10241");
+    assert_eq!(error.context()[2].value(), "10240");
+    return;
+}
+
+#[test]
+fn instruction_debug_is_bounded_and_omits_accounts_and_payload_bytes() {
+    let program_id = crate::Pubkey::new_from_array([0x71_u8; 32]);
+    let payload = b"PAYLOAD_SENTINEL_NEVER_RENDER".to_vec();
+    let instruction = crate::ProgramInstruction::try_new(program_id, std::vec![meta(8, false), meta(9, true)], payload);
+    assert!(instruction.is_ok());
+    let instruction = match instruction {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let rendered = std::format!("{instruction:?}");
+    assert!(rendered.contains("ProgramInstruction"));
+    assert!(rendered.contains("account_count: 2"));
+    assert!(rendered.contains("data_len: 29"));
+    assert!(!rendered.contains("PAYLOAD_SENTINEL_NEVER_RENDER"));
+    assert!(!rendered.contains("is_signer"));
+    assert!(!rendered.contains("is_writable"));
+    return;
+}
+
+#[test]
+fn instruction_preserves_owned_vector_allocations_without_internal_reallocation() {
+    let program_id = crate::Pubkey::new_from_array([0x81_u8; 32]);
+    let accounts = std::vec![meta(10, false), meta(11, true), meta(12, false)];
+    let accounts_ptr = accounts.as_ptr();
+    let data = std::vec![0x10_u8, 0x20, 0x30, 0x40];
+    let data_ptr = data.as_ptr();
+    let instruction = crate::ProgramInstruction::try_new(program_id, accounts, data);
+    assert!(instruction.is_ok());
+    let instruction = match instruction {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    assert_eq!(instruction.accounts().as_ptr(), accounts_ptr);
+    assert_eq!(instruction.data().as_ptr(), data_ptr);
+    return;
+}
+
+#[test]
+fn instruction_limit_errors_do_not_echo_hostile_payload_or_account_material() {
+    let program_id = crate::Pubkey::new_from_array([0x91_u8; 32]);
+    let hostile_marker = b"HOSTILE_INTERFACE_PAYLOAD_SENTINEL";
+    let mut hostile_data = hostile_marker.to_vec();
+    hostile_data.resize(crate::MAX_PROGRAM_INSTRUCTION_DATA_LEN + 1, 0xA5_u8);
+    let data_error = crate::ProgramInstruction::try_new(program_id, std::vec::Vec::new(), hostile_data);
+    assert!(data_error.is_err());
+    let data_error = match data_error {
+        std::result::Result::Err(value) => value,
+        std::result::Result::Ok(_) => return,
+    };
+    let data_display = std::format!("{data_error}");
+    let data_debug = std::format!("{data_error:?}");
+    assert!(!data_display.contains("HOSTILE_INTERFACE_PAYLOAD_SENTINEL"));
+    assert!(!data_debug.contains("HOSTILE_INTERFACE_PAYLOAD_SENTINEL"));
+    for context in data_error.context() {
+        assert!(!context.value().contains("HOSTILE_INTERFACE_PAYLOAD_SENTINEL"));
+    }
+    let hostile_account = meta(0xE1, true);
+    let hostile_account_debug = std::format!("{hostile_account:?}");
+    let account_error =
+        crate::ProgramInstruction::try_new(program_id, std::vec![hostile_account; crate::MAX_PROGRAM_INSTRUCTION_ACCOUNTS + 1], std::vec::Vec::new());
+    assert!(account_error.is_err());
+    let account_error = match account_error {
+        std::result::Result::Err(value) => value,
+        std::result::Result::Ok(_) => return,
+    };
+    let account_debug = std::format!("{account_error:?}");
+    assert!(!account_debug.contains(hostile_account_debug.as_str()));
+    assert_eq!(account_error.context().len(), 3);
+    assert_eq!(account_error.context()[0].value(), "accounts");
+    assert_eq!(account_error.context()[1].value(), "256");
+    assert_eq!(account_error.context()[2].value(), "255");
+    return;
+}

crates/ksp-program-api/Cargo.toml

@@ -0,0 +1,15 @@
+# file: crates/ksp-program-api/Cargo.toml
+# version: 1
+
+[package]
+name = "ksp-program-api"
+version.workspace = true
+edition.workspace = true
+repository.workspace = true
+
+[dependencies]
+ksp-core-lib = { path = "../ksp-core-lib" }
+ksp-interface-lib = { path = "../ksp-interface-lib" }
+
+[lints]
+workspace = true

crates/ksp-program-api/README.md

@@ -0,0 +1,156 @@
+<!-- file: crates/ksp-program-api/README.md -->
+<!-- version: 4 -->
+
+# ksp-program-api
+
+`ksp-program-api` est la façade publique ouverte du domaine Program KSP. Elle porte uniquement les contrats communs nécessaires aux implémentations Program officielles futures comme aux crates externes ; elle ne possède aucun decoder concret, registry runtime, payload canonique DECODE ni logique d'exécution.
+
+La surface candidate de `0.2.14` est volontairement **instruction-only** et reste indépendante des couches runtime supérieures.
+
+## Ownership
+
+Le graphe normal est limité à :
+
+```text
+ksp-program-api
+├── ksp-core-lib
+└── ksp-interface-lib
+    └── ksp-core-lib
+```
+
+Core reste propriétaire de :
+
+```text
+Error
+ErrorCode
+ErrorContext
+Result
+Pubkey
+```
+
+Interface reste propriétaire de :
+
+```text
+ProgramAccountMeta
+ProgramInstruction
+```
+
+Program API possède :
+
+```text
+ProgramInstructionRecognition
+ProgramInstructionDecodeOutcome<Decoded>
+ProgramInstructionDecoder
+```
+
+`ksp-program-api` réexporte toute sa surface consommable depuis son crate-root. Aucun module interne n'est public.
+
+## Surface publique candidate
+
+L'inventaire crate-root de `0.2.14` contient exactement :
+
+```text
+Error
+ErrorCode
+ErrorContext
+Result
+Pubkey
+ProgramAccountMeta
+ProgramInstruction
+ProgramInstructionRecognition
+ProgramInstructionDecodeOutcome<Decoded>
+ProgramInstructionDecoder
+```
+
+Les canaris de release completeness verrouillent cet inventaire ainsi que les trois fichiers/modules Rust de production de la crate.
+
+## Recognition
+
+`ProgramInstructionRecognition` est `#[non_exhaustive]` :
+
+```text
+NoMatch       l'implémentation ne revendique pas l'instruction
+ProgramMatch  le Program correspond, sans reconnaissance instruction-local exacte
+ExactMatch    l'implémentation affirme un match instruction-local exact
+```
+
+La reconnaissance ne porte aucun score, priorité, proof, confidence, discriminator textuel ni inventaire central de Programs. `ExactMatch` reste une affirmation de l'implémentation, pas une preuve indépendante produite par KSP.
+
+## Decode outcome
+
+`ProgramInstructionDecodeOutcome<Decoded>` est `#[non_exhaustive]` :
+
+```text
+Decoded(Decoded)  valeur typée possédée par l'implémentation
+Unsupported       instruction reconnue mais non supportée par cette capability
+```
+
+Les échecs réels utilisent le `Result` Core. Il n'existe aucune variante parallèle `Failed` ou `Ignored`.
+
+Le `Debug` de l'outcome n'impose pas `Decoded: Debug` et n'affiche jamais la valeur `Decoded`.
+
+## Decoder instruction-only
+
+`ProgramInstructionDecoder` est un trait ouvert `Send + Sync` :
+
+```text
+type Decoded
+program_ids(&self) -> &[Pubkey]
+recognize(&self, &ProgramInstruction) -> ProgramInstructionRecognition
+decode(&self, &ProgramInstruction) -> Result<ProgramInstructionDecodeOutcome<Self::Decoded>>
+```
+
+`Decoded` ne reçoit aucun bound implicite supplémentaire : une implémentation reste propriétaire de son type de sortie concret. Le trait ne fournit aucun default method et ne promet pas de composition `dyn` hétérogène.
+
+`program_ids()` expose des `Pubkey` opaques ; une implémentation externe peut prendre en charge un Program ID absent du registry Core. Aucun enum central, `Any`, JSON ou descriptor global n'est nécessaire.
+
+`program_ids` et `recognize` servent à la sélection explicite. `decode` consomme par référence une `ProgramInstruction` déjà admise/bornée par Interface et déjà sélectionnée pour le decoder.
+
+## Hardening validé
+
+La candidate verrouille notamment :
+
+```text
+Program Pubkey non enregistré                       accepté
+input Interface maximal                             255 accounts + 10_240 bytes accepté à la frontière decoder
+payload hostile                                     aucun echo automatique ajouté par Program API
+Debug outcome                                       valeur Decoded jamais rendue
+associated Decoded                                   aucun Debug/Clone/Send/Sync imposé
+closed-world Program enum                            absent
+registry / descriptors / priority                    absents
+ProgramExecutionPreparer                             absent
+serde / JSON / Any / codecs                          absents
+logging / runtime / filesystem / environment / I/O  absents
+```
+
+Une implémentation tierce reste responsable du contenu des erreurs qu'elle construit explicitement. `ksp-program-api` garantit seulement qu'il n'ajoute aucun canal parallèle ni copie automatique du payload d'entrée.
+
+## Frontières
+
+La foundation `0.2.14` ne contient pas :
+
+```text
+ksp-program-lib
+registry runtime
+identity/version/coverage de decoder
+payload canonique D3
+ProgramAccountDecoder
+ProgramEventDecoder
+ProgramReturnDataDecoder
+ProgramExecutionPreparer
+serde / serde_json
+borsh / wincode / bincode
+solana-instruction
+network / async runtime
+logging / tracing
+Wallet / Transport / Store / Materializer / Config / Tauri
+```
+
+Ces surfaces restent reportées jusqu'aux vertical slices qui démontreront leurs contrats réels. En particulier, les codecs wire officiels restent possédés par `ksp-interface-lib` et ne sont introduits qu'en présence d'un protocole réel.
+
+## Références
+
+- [Usage public](USAGE.md)
+- [Plan `0.2.14`](../../docs/plans/021-V0_2_14_PROGRAM_API_PLAN.md)
+- [Validation `0.2.14`](../../docs/validation/017-V0_2_14_PROGRAM_API.md)
+- [Architecture Wire + Program](../../docs/architecture/006-WIRE_AND_PROGRAM.md)

crates/ksp-program-api/USAGE.md

@@ -0,0 +1,166 @@
+<!-- file: crates/ksp-program-api/USAGE.md -->
+<!-- version: 4 -->
+
+# Usage de ksp-program-api
+
+Cette page décrit la surface publique candidate de `0.2.14`. Utiliser uniquement les exports du crate-root ; aucun module interne ne fait partie du contrat consommable.
+
+## Construire un input Program avec la façade
+
+```rust
+let program_id = ksp_program_api::Pubkey::new_from_array([1_u8; 32]);
+let account_id = ksp_program_api::Pubkey::new_from_array([2_u8; 32]);
+let account = ksp_program_api::ProgramAccountMeta::readonly(account_id, true);
+
+let instruction = ksp_program_api::ProgramInstruction::try_new(
+    program_id,
+    std::vec![account],
+    std::vec![0x01_u8, 0x02, 0x03],
+);
+
+assert!(instruction.is_ok());
+```
+
+`Pubkey`, `ProgramAccountMeta` et `ProgramInstruction` conservent leur ownership Core/Interface. Les bornes `255` account metas et `10_240` bytes de data sont appliquées par Interface avant l'entrée dans le decoder.
+
+## Implémenter un decoder externe
+
+Le type décodé reste entièrement possédé par la crate d'implémentation :
+
+```rust
+struct ExternalDecodedInstruction {
+    opcode: u8,
+}
+
+struct ExternalDecoder {
+    program_ids: [ksp_program_api::Pubkey; 1],
+}
+
+impl ksp_program_api::ProgramInstructionDecoder for ExternalDecoder {
+    type Decoded = ExternalDecodedInstruction;
+
+    fn program_ids(&self) -> &[ksp_program_api::Pubkey] {
+        return &self.program_ids;
+    }
+
+    fn recognize(
+        &self,
+        instruction: &ksp_program_api::ProgramInstruction,
+    ) -> ksp_program_api::ProgramInstructionRecognition {
+        if instruction.program_id() != &self.program_ids[0] {
+            return ksp_program_api::ProgramInstructionRecognition::NoMatch;
+        }
+
+        if instruction.data().first() == std::option::Option::Some(&0x2A_u8) {
+            return ksp_program_api::ProgramInstructionRecognition::ExactMatch;
+        }
+
+        return ksp_program_api::ProgramInstructionRecognition::ProgramMatch;
+    }
+
+    fn decode(
+        &self,
+        instruction: &ksp_program_api::ProgramInstruction,
+    ) -> ksp_program_api::Result<ksp_program_api::ProgramInstructionDecodeOutcome<Self::Decoded>> {
+        let opcode = match instruction.data().first() {
+            std::option::Option::Some(value) if *value == 0x2A_u8 => *value,
+            _ => {
+                return std::result::Result::Ok(
+                    ksp_program_api::ProgramInstructionDecodeOutcome::Unsupported,
+                );
+            }
+        };
+
+        return std::result::Result::Ok(
+            ksp_program_api::ProgramInstructionDecodeOutcome::Decoded(
+                ExternalDecodedInstruction { opcode },
+            ),
+        );
+    }
+}
+```
+
+Aucun `ksp-program-lib`, enum centrale, `Any`, JSON ou codec n'est nécessaire. Le Program ID peut être un `Pubkey` opaque non enregistré par Core.
+
+## Sélection explicite
+
+La sélection reste distincte du décodage :
+
+```rust
+let recognition = ksp_program_api::ProgramInstructionDecoder::recognize(
+    &decoder,
+    &instruction,
+);
+
+match recognition {
+    ksp_program_api::ProgramInstructionRecognition::NoMatch => {}
+    ksp_program_api::ProgramInstructionRecognition::ProgramMatch => {}
+    ksp_program_api::ProgramInstructionRecognition::ExactMatch => {}
+    _ => {}
+}
+```
+
+L'enum est `#[non_exhaustive]`. `ExactMatch` exprime l'affirmation du decoder. `decode` n'est pas un substitut à `recognize` : il traite une instruction déjà sélectionnée pour cette implémentation.
+
+## Outcome et erreur
+
+```rust
+let outcome = ksp_program_api::ProgramInstructionDecoder::decode(
+    &decoder,
+    &instruction,
+)?;
+
+match outcome {
+    ksp_program_api::ProgramInstructionDecodeOutcome::Decoded(value) => {
+        let _opcode = value.opcode;
+    }
+    ksp_program_api::ProgramInstructionDecodeOutcome::Unsupported => {}
+    _ => {}
+}
+```
+
+Une erreur réelle est un `Err(ksp_program_api::Error)`. `Unsupported` n'est pas une deuxième forme d'erreur : il indique qu'une instruction reconnue n'est volontairement pas décodée par cette capability.
+
+Program API ne recopie automatiquement ni le payload de l'instruction ni les account metas dans l'erreur. Une implémentation externe reste responsable des messages/contextes qu'elle construit explicitement.
+
+## Output sans bounds implicites
+
+L'associated type `Decoded` n'impose pas `Debug`, `Clone`, `Send` ou `Sync`. Les supertraits `Send + Sync` s'appliquent au decoder lui-même, pas à la valeur décodée :
+
+```rust
+struct LocalDecoded(std::rc::Rc<std::cell::Cell<u8>>);
+```
+
+Un decoder peut utiliser ce type comme `Decoded` tant que son propre état satisfait `Send + Sync`.
+
+## Debug sûr
+
+`ProgramInstructionDecodeOutcome<Decoded>` possède un `Debug` volontairement opaque :
+
+```rust
+struct SecretDecoded;
+
+let outcome = ksp_program_api::ProgramInstructionDecodeOutcome::Decoded(SecretDecoded);
+assert_eq!(std::format!("{outcome:?}"), "Decoded");
+```
+
+`SecretDecoded` n'a pas besoin d'implémenter `Debug` et sa valeur n'est jamais rendue par l'outcome.
+
+## Ce qui n'est pas simulé côté consumer
+
+Il n'existe dans `0.2.14` aucun :
+
+```text
+registry de decoders
+composition dyn hétérogène
+identity/version/coverage descriptor
+priority/conflict policy
+payload canonique D3
+ProgramAccountDecoder / Event / ReturnData
+ProgramExecutionPreparer
+execution policy
+serde / JSON / codec
+logging / runtime réseau
+```
+
+Ces surfaces ne doivent pas être recréées localement comme si elles faisaient déjà partie du contrat commun. Elles attendent les vertical slices qui justifieront leurs invariants réels.

crates/ksp-program-api/src/lib.rs

@@ -0,0 +1,37 @@
+// file: crates/ksp-program-api/src/lib.rs
+// version: 3
+
+#![warn(missing_docs)]
+#![deny(unreachable_pub)]
+#![forbid(unsafe_code)]
+
+//! Open Program contracts shared by KSP and external Program implementations.
+//!
+//! The foundation exposes Core/Interface types plus the minimal instruction
+//! recognition/decode vocabulary and the instruction decoder trait. Registries,
+//! codecs, runtime logging and execution preparation remain outside this
+//! foundation until their ownership is justified.
+
+mod program_instruction_decode;
+mod program_instruction_decoder;
+
+/// Result of a successful Program instruction decode attempt.
+pub use self::program_instruction_decode::ProgramInstructionDecodeOutcome;
+/// Recognition strength reported by one Program instruction implementation.
+pub use self::program_instruction_decode::ProgramInstructionRecognition;
+/// Open contract implemented by one Program instruction decoder.
+pub use self::program_instruction_decoder::ProgramInstructionDecoder;
+/// Common KSP error type used by Program-facing contracts.
+pub use ksp_core_lib::Error;
+/// Stable structured code identifying a KSP error category and condition.
+pub use ksp_core_lib::ErrorCode;
+/// Structured contextual field attached to a KSP error.
+pub use ksp_core_lib::ErrorContext;
+/// Canonical Solana account address primitive owned by `ksp-core-lib`.
+pub use ksp_core_lib::Pubkey;
+/// Common KSP result alias using [`Error`].
+pub use ksp_core_lib::Result;
+/// Passive account metadata attached to one Program instruction.
+pub use ksp_interface_lib::ProgramAccountMeta;
+/// Passive, bounded Program instruction wire contract.
+pub use ksp_interface_lib::ProgramInstruction;

crates/ksp-program-api/src/program_instruction_decode.rs

@@ -0,0 +1,50 @@
+// file: crates/ksp-program-api/src/program_instruction_decode.rs
+// version: 1
+
+/// Recognition strength reported by one Program instruction implementation.
+///
+/// Recognition is intentionally instruction-local. It does not encode registry
+/// priority, a persisted proof, a textual discriminator or a global Program
+/// kind. [`Self::ExactMatch`] is an assertion made by the implementation for
+/// the current instruction, while [`Self::ProgramMatch`] only establishes the
+/// Program-level match.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[non_exhaustive]
+pub enum ProgramInstructionRecognition {
+    /// The implementation does not claim the instruction.
+    NoMatch,
+    /// The Program or Program family matches, but the instruction is not proven exact.
+    ProgramMatch,
+    /// The implementation claims an exact instruction-local match.
+    ExactMatch,
+}
+
+/// Result of a successful Program instruction decode attempt.
+///
+/// Decode failures are represented by the surrounding KSP [`crate::Result`],
+/// not by a parallel failure variant. `Unsupported` is reserved for a known
+/// Program instruction that the implementation deliberately does not decode.
+///
+/// The custom [`std::fmt::Debug`] implementation never formats the `Decoded`
+/// value, so external decoded payloads are not exposed accidentally through
+/// generic diagnostics.
+#[non_exhaustive]
+pub enum ProgramInstructionDecodeOutcome<Decoded> {
+    /// The instruction was decoded into the implementation-owned output type.
+    Decoded(Decoded),
+    /// The instruction is known but unsupported by this decode capability.
+    Unsupported,
+}
+
+impl<Decoded> std::fmt::Debug for ProgramInstructionDecodeOutcome<Decoded> {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Decoded(_) => return formatter.write_str("Decoded"),
+            Self::Unsupported => return formatter.write_str("Unsupported"),
+        }
+    }
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/program_instruction_decode.rs"]
+mod tests;

crates/ksp-program-api/src/program_instruction_decoder.rs

@@ -0,0 +1,28 @@
+// file: crates/ksp-program-api/src/program_instruction_decoder.rs
+// version: 1
+
+/// Open contract implemented by one Program instruction decoder.
+///
+/// The decoder owns its concrete [`Self::Decoded`] type. No central Program
+/// enum, erased `Any` payload or serialization contract is required. Program
+/// identifiers remain opaque [`crate::Pubkey`] values and do not need to be
+/// registered by Core.
+///
+/// Candidate selection is explicit: callers use [`Self::program_ids`] and
+/// [`Self::recognize`] before invoking [`Self::decode`]. `decode` therefore
+/// reports only a successful typed value, an intentional unsupported state, or
+/// a KSP [`crate::Result`] error. The trait defines no default methods and does
+/// not promise heterogeneous runtime object composition.
+pub trait ProgramInstructionDecoder: Send + Sync {
+    /// Concrete decoded instruction type owned by the implementation.
+    type Decoded;
+
+    /// Returns the opaque Program identifiers claimed by this decoder.
+    fn program_ids(&self) -> &[crate::Pubkey];
+
+    /// Reports how strongly this decoder recognizes one bounded instruction.
+    fn recognize(&self, instruction: &crate::ProgramInstruction) -> crate::ProgramInstructionRecognition;
+
+    /// Decodes one instruction already selected for this decoder.
+    fn decode(&self, instruction: &crate::ProgramInstruction) -> crate::Result<crate::ProgramInstructionDecodeOutcome<Self::Decoded>>;
+}

crates/ksp-program-api/tests/dependency_boundary.rs

@@ -0,0 +1,105 @@
+// file: crates/ksp-program-api/tests/dependency_boundary.rs
+// version: 3
+
+//! Dependency and declarative-surface canaries for the Program API foundation.
+
+#[test]
+fn pre_002_manifest_has_exact_core_and_interface_runtime_dependencies() {
+    let manifest = include_str!("../Cargo.toml");
+    let dependencies_tail = manifest.split("[dependencies]").nth(1);
+    assert!(dependencies_tail.is_some(), "Program API dependencies section must exist");
+    let dependencies_tail = match dependencies_tail {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let dependencies = match dependencies_tail.split("[lints]").next() {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    assert_eq!(manifest_dependency_names(dependencies), std::vec!["ksp-core-lib", "ksp-interface-lib"]);
+    for forbidden in [
+        "ksp-config-lib",
+        "ksp-logging-lib",
+        "ksp-materializer-api",
+        "ksp-materializer-lib",
+        "ksp-offchain-transport-lib",
+        "ksp-onchain-transport-lib",
+        "ksp-program-lib",
+        "ksp-store-api",
+        "ksp-store-lib",
+        "ksp-wallet-lib",
+        "borsh",
+        "bincode",
+        "reqwest",
+        "serde",
+        "serde_json",
+        "solana-instruction",
+        "tauri",
+        "tokio",
+        "tonic",
+        "tracing",
+        "wincode",
+    ] {
+        assert!(!dependencies.contains(forbidden), "forbidden Program API dependency detected: {forbidden}");
+    }
+    return;
+}
+
+#[test]
+fn pre_004_crate_root_adds_decoder_without_runtime_surface() {
+    let crate_root = include_str!("../src/lib.rs");
+    for required in [
+        "ProgramInstructionDecodeOutcome",
+        "ProgramInstructionDecoder",
+        "ProgramInstructionRecognition",
+        "Error",
+        "ErrorCode",
+        "ErrorContext",
+        "Pubkey",
+        "Result",
+        "ProgramAccountMeta",
+        "ProgramInstruction",
+    ] {
+        assert!(crate_root.contains(required), "required Program API facade export missing: {required}");
+    }
+    for forbidden in ["pub mod ", "ProgramExecutionPreparer", "TRACING_TARGET", "ksp_logging_lib", "serde", "Any"] {
+        assert!(!crate_root.contains(forbidden), "forbidden pre.004 Program API surface detected: {forbidden}");
+    }
+    let decoder_source = include_str!("../src/program_instruction_decoder.rs");
+    assert!(decoder_source.contains("pub trait ProgramInstructionDecoder: Send + Sync"));
+    assert!(decoder_source.contains("type Decoded;"));
+    assert!(decoder_source.contains("fn program_ids(&self) -> &[crate::Pubkey];"));
+    assert!(decoder_source.contains("fn recognize(&self, instruction: &crate::ProgramInstruction)"));
+    assert!(decoder_source.contains("crate::Result<crate::ProgramInstructionDecodeOutcome<Self::Decoded>>"));
+    assert!(!decoder_source.contains("ProgramExecutionPreparer"));
+    assert!(!decoder_source.contains("serde"));
+    assert!(!decoder_source.contains("std::any::Any"));
+    let outcome_source = include_str!("../src/program_instruction_decode.rs");
+    for forbidden in ["Ignored", "Failed", "serde", "Any"] {
+        assert!(!outcome_source.contains(forbidden), "forbidden recognition/outcome concept detected: {forbidden}");
+    }
+    assert!(!std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src/constants.rs").exists());
+    return;
+}
+
+fn manifest_dependency_names(section: &str) -> std::vec::Vec<&str> {
+    let mut names = std::vec::Vec::new();
+    for line in section.lines() {
+        let content = match line.split('#').next() {
+            std::option::Option::Some(value) => value.trim(),
+            std::option::Option::None => continue,
+        };
+        if content.is_empty() {
+            continue;
+        }
+        let name = match content.split('=').next() {
+            std::option::Option::Some(value) => value.trim().trim_end_matches(".workspace"),
+            std::option::Option::None => continue,
+        };
+        if !name.is_empty() {
+            names.push(name);
+        }
+    }
+    names.sort_unstable();
+    return names;
+}

crates/ksp-program-api/tests/external_implementation.rs

@@ -0,0 +1,115 @@
+// file: crates/ksp-program-api/tests/external_implementation.rs
+// version: 1
+
+//! Downstream-style implementation canary for the open Program decoder contract.
+
+const EXTERNAL_PROGRAM_ID_BYTES: [u8; 32] = [0xE7_u8; 32];
+const FOREIGN_PROGRAM_ID_BYTES: [u8; 32] = [0xE8_u8; 32];
+const SUPPORTED_OPCODE: u8 = 0x2A_u8;
+
+struct ExternalDecodedInstruction {
+    opcode: u8,
+}
+
+struct ExternalProgramDecoder {
+    program_ids: [ksp_program_api::Pubkey; 1],
+}
+
+impl ExternalProgramDecoder {
+    fn new() -> Self {
+        return Self { program_ids: [ksp_program_api::Pubkey::new_from_array(EXTERNAL_PROGRAM_ID_BYTES)] };
+    }
+}
+
+impl ksp_program_api::ProgramInstructionDecoder for ExternalProgramDecoder {
+    type Decoded = ExternalDecodedInstruction;
+
+    fn program_ids(&self) -> &[ksp_program_api::Pubkey] {
+        return &self.program_ids;
+    }
+
+    fn recognize(&self, instruction: &ksp_program_api::ProgramInstruction) -> ksp_program_api::ProgramInstructionRecognition {
+        if instruction.program_id() != &self.program_ids[0] {
+            return ksp_program_api::ProgramInstructionRecognition::NoMatch;
+        }
+        if instruction.data().first() == std::option::Option::Some(&SUPPORTED_OPCODE) {
+            return ksp_program_api::ProgramInstructionRecognition::ExactMatch;
+        }
+        return ksp_program_api::ProgramInstructionRecognition::ProgramMatch;
+    }
+
+    fn decode(
+        &self,
+        instruction: &ksp_program_api::ProgramInstruction,
+    ) -> ksp_program_api::Result<ksp_program_api::ProgramInstructionDecodeOutcome<Self::Decoded>> {
+        if instruction.program_id() != &self.program_ids[0] {
+            return std::result::Result::Ok(ksp_program_api::ProgramInstructionDecodeOutcome::Unsupported);
+        }
+        let opcode = match instruction.data().first() {
+            std::option::Option::Some(value) if *value == SUPPORTED_OPCODE => *value,
+            _ => return std::result::Result::Ok(ksp_program_api::ProgramInstructionDecodeOutcome::Unsupported),
+        };
+        return std::result::Result::Ok(ksp_program_api::ProgramInstructionDecodeOutcome::Decoded(ExternalDecodedInstruction { opcode }));
+    }
+}
+
+fn assert_send_sync<T: Send + Sync>(_value: &T) {
+    return;
+}
+
+#[test]
+fn pre_004_external_decoder_uses_unregistered_pubkey_and_implementation_owned_output() {
+    let decoder = ExternalProgramDecoder::new();
+    assert_send_sync(&decoder);
+    let external_program_id = ksp_program_api::Pubkey::new_from_array(EXTERNAL_PROGRAM_ID_BYTES);
+    assert!(ksp_core_lib::find_program_pubkey(&external_program_id).is_none());
+    assert_eq!(ksp_program_api::ProgramInstructionDecoder::program_ids(&decoder), &[external_program_id]);
+    let exact = ksp_program_api::ProgramInstruction::try_new(external_program_id, std::vec![], std::vec![SUPPORTED_OPCODE]);
+    assert!(exact.is_ok());
+    let exact = match exact {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    assert_eq!(ksp_program_api::ProgramInstructionDecoder::recognize(&decoder, &exact), ksp_program_api::ProgramInstructionRecognition::ExactMatch);
+    let outcome = ksp_program_api::ProgramInstructionDecoder::decode(&decoder, &exact);
+    assert!(outcome.is_ok());
+    let outcome = match outcome {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let decoded = match outcome {
+        ksp_program_api::ProgramInstructionDecodeOutcome::Decoded(value) => value,
+        _ => return,
+    };
+    assert_eq!(decoded.opcode, SUPPORTED_OPCODE);
+    return;
+}
+
+#[test]
+fn pre_004_external_decoder_distinguishes_program_match_unsupported_and_no_match() {
+    let decoder = ExternalProgramDecoder::new();
+    let external_program_id = ksp_program_api::Pubkey::new_from_array(EXTERNAL_PROGRAM_ID_BYTES);
+    let program_only = ksp_program_api::ProgramInstruction::try_new(external_program_id, std::vec![], std::vec![0x11_u8]);
+    assert!(program_only.is_ok());
+    let program_only = match program_only {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    assert_eq!(ksp_program_api::ProgramInstructionDecoder::recognize(&decoder, &program_only), ksp_program_api::ProgramInstructionRecognition::ProgramMatch);
+    let unsupported = ksp_program_api::ProgramInstructionDecoder::decode(&decoder, &program_only);
+    assert!(unsupported.is_ok());
+    let unsupported = match unsupported {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    assert!(matches!(unsupported, ksp_program_api::ProgramInstructionDecodeOutcome::Unsupported));
+    let foreign_program_id = ksp_program_api::Pubkey::new_from_array(FOREIGN_PROGRAM_ID_BYTES);
+    let foreign = ksp_program_api::ProgramInstruction::try_new(foreign_program_id, std::vec![], std::vec![SUPPORTED_OPCODE]);
+    assert!(foreign.is_ok());
+    let foreign = match foreign {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    assert_eq!(ksp_program_api::ProgramInstructionDecoder::recognize(&decoder, &foreign), ksp_program_api::ProgramInstructionRecognition::NoMatch);
+    return;
+}

crates/ksp-program-api/tests/public_api.rs

@@ -0,0 +1,77 @@
+// file: crates/ksp-program-api/tests/public_api.rs
+// version: 3
+
+//! Integration canaries for the public `ksp-program-api` foundation.
+
+fn consume_result(value: ksp_program_api::Result<ksp_program_api::Pubkey>) -> ksp_program_api::Result<ksp_program_api::Pubkey> {
+    return value;
+}
+
+#[test]
+fn public_pre_002_core_and_interface_facade_is_available_from_crate_root() {
+    let program_id = ksp_program_api::Pubkey::new_from_array([0xA1_u8; 32]);
+    let account_id = ksp_program_api::Pubkey::new_from_array([0xA2_u8; 32]);
+    let account = ksp_program_api::ProgramAccountMeta::readonly(account_id, true);
+    let instruction = ksp_program_api::ProgramInstruction::try_new(program_id, std::vec![account], std::vec![0xA3_u8]);
+    assert!(instruction.is_ok());
+    let forwarded = consume_result(std::result::Result::Ok(program_id));
+    assert!(forwarded.is_ok());
+    let error_code_type: std::option::Option<ksp_program_api::ErrorCode> = std::option::Option::None;
+    let error_context_type: std::option::Option<ksp_program_api::ErrorContext> = std::option::Option::None;
+    let error_type: std::option::Option<ksp_program_api::Error> = std::option::Option::None;
+    assert!(error_code_type.is_none());
+    assert!(error_context_type.is_none());
+    assert!(error_type.is_none());
+    return;
+}
+
+#[test]
+fn public_pre_002_scaffold_does_not_require_private_modules() {
+    let source = include_str!("../src/lib.rs");
+    assert!(!source.contains("pub mod "));
+    return;
+}
+
+#[test]
+fn public_pre_003_recognition_and_decode_outcome_are_available_from_crate_root() {
+    let recognition = ksp_program_api::ProgramInstructionRecognition::ProgramMatch;
+    assert_eq!(std::format!("{recognition:?}"), "ProgramMatch");
+    let decoded = ksp_program_api::ProgramInstructionDecodeOutcome::Decoded(31_u16);
+    assert_eq!(std::format!("{decoded:?}"), "Decoded");
+    let decoded_value = match decoded {
+        ksp_program_api::ProgramInstructionDecodeOutcome::Decoded(value) => value,
+        _ => 0_u16,
+    };
+    assert_eq!(decoded_value, 31_u16);
+    let unsupported = ksp_program_api::ProgramInstructionDecodeOutcome::<u16>::Unsupported;
+    assert_eq!(std::format!("{unsupported:?}"), "Unsupported");
+    return;
+}
+
+#[test]
+fn public_pre_004_instruction_decoder_trait_is_available_from_crate_root() {
+    let decoder = NeverInstantiatedDecoder;
+    assert!(ksp_program_api::ProgramInstructionDecoder::program_ids(&decoder).is_empty());
+    return;
+}
+
+struct NeverInstantiatedDecoder;
+
+impl ksp_program_api::ProgramInstructionDecoder for NeverInstantiatedDecoder {
+    type Decoded = u8;
+
+    fn program_ids(&self) -> &[ksp_program_api::Pubkey] {
+        return &[];
+    }
+
+    fn recognize(&self, _instruction: &ksp_program_api::ProgramInstruction) -> ksp_program_api::ProgramInstructionRecognition {
+        return ksp_program_api::ProgramInstructionRecognition::NoMatch;
+    }
+
+    fn decode(
+        &self,
+        _instruction: &ksp_program_api::ProgramInstruction,
+    ) -> ksp_program_api::Result<ksp_program_api::ProgramInstructionDecodeOutcome<Self::Decoded>> {
+        return std::result::Result::Ok(ksp_program_api::ProgramInstructionDecodeOutcome::Unsupported);
+    }
+}

crates/ksp-program-api/tests/release_completeness.rs

@@ -0,0 +1,128 @@
+// file: crates/ksp-program-api/tests/release_completeness.rs
+// version: 2
+
+//! Release-level completeness canaries for the `0.2.14` Program API foundation.
+
+#[test]
+fn pre_005_exact_crate_root_export_inventory_is_stable() {
+    let crate_root = include_str!("../src/lib.rs");
+    let mut actual = std::vec::Vec::new();
+    for line in crate_root.lines() {
+        let trimmed = line.trim();
+        if trimmed.starts_with("pub use ") {
+            actual.push(trimmed);
+        }
+    }
+    actual.sort_unstable();
+    let mut expected = std::vec![
+        "pub use self::program_instruction_decode::ProgramInstructionDecodeOutcome;",
+        "pub use self::program_instruction_decode::ProgramInstructionRecognition;",
+        "pub use self::program_instruction_decoder::ProgramInstructionDecoder;",
+        "pub use ksp_core_lib::Error;",
+        "pub use ksp_core_lib::ErrorCode;",
+        "pub use ksp_core_lib::ErrorContext;",
+        "pub use ksp_core_lib::Pubkey;",
+        "pub use ksp_core_lib::Result;",
+        "pub use ksp_interface_lib::ProgramAccountMeta;",
+        "pub use ksp_interface_lib::ProgramInstruction;",
+    ];
+    expected.sort_unstable();
+    assert_eq!(actual, expected);
+    assert!(!crate_root.contains("pub mod "));
+    return;
+}
+
+#[test]
+fn pre_005_production_module_inventory_is_instruction_only() -> std::io::Result<()> {
+    let source_root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src");
+    let entries = match std::fs::read_dir(source_root) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let mut names = std::vec::Vec::new();
+    for entry in entries {
+        let entry = match entry {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let file_type = match entry.file_type() {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        if !file_type.is_file() {
+            continue;
+        }
+        let name = match entry.file_name().into_string() {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(_) => continue,
+        };
+        if name.ends_with(".rs") {
+            names.push(name);
+        }
+    }
+    names.sort_unstable();
+    assert_eq!(names, std::vec!["lib.rs", "program_instruction_decode.rs", "program_instruction_decoder.rs"]);
+    return std::result::Result::Ok(());
+}
+
+#[test]
+fn pre_005_public_enum_and_trait_inventory_remains_open_world() {
+    let sources = [include_str!("../src/lib.rs"), include_str!("../src/program_instruction_decode.rs"), include_str!("../src/program_instruction_decoder.rs")];
+    let mut public_enums = std::vec::Vec::new();
+    let mut public_traits = std::vec::Vec::new();
+    for source in sources {
+        for line in source.lines() {
+            let trimmed = line.trim();
+            if trimmed.starts_with("pub enum ") {
+                public_enums.push(trimmed);
+            }
+            if trimmed.starts_with("pub trait ") {
+                public_traits.push(trimmed);
+            }
+        }
+    }
+    public_enums.sort_unstable();
+    public_traits.sort_unstable();
+    assert_eq!(public_enums, std::vec!["pub enum ProgramInstructionDecodeOutcome<Decoded> {", "pub enum ProgramInstructionRecognition {"]);
+    assert_eq!(public_traits, std::vec!["pub trait ProgramInstructionDecoder: Send + Sync {"]);
+    let decode_source = include_str!("../src/program_instruction_decode.rs");
+    assert!(decode_source.contains("#[non_exhaustive]\npub enum ProgramInstructionRecognition"));
+    assert!(decode_source.contains("#[non_exhaustive]\npub enum ProgramInstructionDecodeOutcome<Decoded>"));
+    return;
+}
+
+#[test]
+fn pre_005_production_sources_have_no_registry_preparer_codec_or_runtime_creep() {
+    let direct_tracing_path = ["tracing", "::"].concat();
+    let sources = [include_str!("../src/lib.rs"), include_str!("../src/program_instruction_decode.rs"), include_str!("../src/program_instruction_decoder.rs")];
+    for source in sources {
+        for forbidden in [
+            "pub enum ProgramKind",
+            "pub struct ProgramRegistry",
+            "pub trait ProgramAccountDecoder",
+            "pub trait ProgramEventDecoder",
+            "pub trait ProgramReturnDataDecoder",
+            "pub trait ProgramExecutionPreparer",
+            "std::any::Any",
+            "serde::",
+            "serde_json::",
+            "borsh::",
+            "bincode::",
+            "wincode::",
+            "ksp_logging_lib::",
+            "reqwest::",
+            "tokio::",
+            "tonic::",
+            "tauri::",
+            "std::env::",
+            "std::fs::",
+            "std::net::",
+            "dyn ProgramInstructionDecoder",
+            "dyn crate::ProgramInstructionDecoder",
+        ] {
+            assert!(!source.contains(forbidden), "forbidden Program API production surface detected: {forbidden}");
+        }
+        assert!(!source.contains(direct_tracing_path.as_str()), "forbidden Program API production direct tracing path detected");
+    }
+    return;
+}

crates/ksp-program-api/tests/security_hardening.rs

@@ -0,0 +1,156 @@
+// file: crates/ksp-program-api/tests/security_hardening.rs
+// version: 1
+
+//! Adversarial and bound-safety canaries for the Program API foundation.
+
+const HOSTILE_MARKER: &str = "PROGRAM-SECRET-CANARY";
+const MALFORMED_OPCODE: u8 = 0xFF_u8;
+const PROGRAM_ID_BYTES: [u8; 32] = [0xD1_u8; 32];
+
+struct BoundsObserved {
+    account_count: usize,
+    data_len: usize,
+}
+
+struct BoundedDecoder {
+    program_ids: [ksp_program_api::Pubkey; 1],
+}
+
+impl BoundedDecoder {
+    fn new() -> Self {
+        return Self { program_ids: [ksp_program_api::Pubkey::new_from_array(PROGRAM_ID_BYTES)] };
+    }
+}
+
+impl ksp_program_api::ProgramInstructionDecoder for BoundedDecoder {
+    type Decoded = BoundsObserved;
+
+    fn program_ids(&self) -> &[ksp_program_api::Pubkey] {
+        return &self.program_ids;
+    }
+
+    fn recognize(&self, instruction: &ksp_program_api::ProgramInstruction) -> ksp_program_api::ProgramInstructionRecognition {
+        if instruction.program_id() == &self.program_ids[0] {
+            return ksp_program_api::ProgramInstructionRecognition::ExactMatch;
+        }
+        return ksp_program_api::ProgramInstructionRecognition::NoMatch;
+    }
+
+    fn decode(
+        &self,
+        instruction: &ksp_program_api::ProgramInstruction,
+    ) -> ksp_program_api::Result<ksp_program_api::ProgramInstructionDecodeOutcome<Self::Decoded>> {
+        if instruction.data().first() == std::option::Option::Some(&MALFORMED_OPCODE) {
+            return std::result::Result::Err(ksp_program_api::Error::new(
+                ksp_program_api::ErrorCode::new("program_test", "malformed_instruction"),
+                "malformed external Program instruction",
+            ));
+        }
+        return std::result::Result::Ok(ksp_program_api::ProgramInstructionDecodeOutcome::Decoded(BoundsObserved {
+            account_count: instruction.accounts().len(),
+            data_len: instruction.data().len(),
+        }));
+    }
+}
+
+struct BoundlessDecoded {
+    marker: std::rc::Rc<std::cell::Cell<u8>>,
+}
+
+struct BoundlessOutputDecoder;
+
+impl ksp_program_api::ProgramInstructionDecoder for BoundlessOutputDecoder {
+    type Decoded = BoundlessDecoded;
+
+    fn program_ids(&self) -> &[ksp_program_api::Pubkey] {
+        return &[];
+    }
+
+    fn recognize(&self, _instruction: &ksp_program_api::ProgramInstruction) -> ksp_program_api::ProgramInstructionRecognition {
+        return ksp_program_api::ProgramInstructionRecognition::NoMatch;
+    }
+
+    fn decode(
+        &self,
+        _instruction: &ksp_program_api::ProgramInstruction,
+    ) -> ksp_program_api::Result<ksp_program_api::ProgramInstructionDecodeOutcome<Self::Decoded>> {
+        return std::result::Result::Ok(ksp_program_api::ProgramInstructionDecodeOutcome::Decoded(BoundlessDecoded {
+            marker: std::rc::Rc::new(std::cell::Cell::new(0x5A_u8)),
+        }));
+    }
+}
+
+#[test]
+fn pre_005_max_interface_instruction_crosses_decoder_boundary_without_new_contract() {
+    let decoder = BoundedDecoder::new();
+    let account = ksp_program_api::ProgramAccountMeta::readonly(ksp_program_api::Pubkey::new_from_array([0xD2_u8; 32]), false);
+    let accounts = std::vec![account; ksp_interface_lib::MAX_PROGRAM_INSTRUCTION_ACCOUNTS];
+    let data = std::vec![0x5A_u8; ksp_interface_lib::MAX_PROGRAM_INSTRUCTION_DATA_LEN];
+    let instruction = ksp_program_api::ProgramInstruction::try_new(decoder.program_ids[0], accounts, data);
+    assert!(instruction.is_ok());
+    let instruction = match instruction {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let outcome = ksp_program_api::ProgramInstructionDecoder::decode(&decoder, &instruction);
+    assert!(outcome.is_ok());
+    let outcome = match outcome {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let observed = match outcome {
+        ksp_program_api::ProgramInstructionDecodeOutcome::Decoded(value) => value,
+        _ => return,
+    };
+    assert_eq!(observed.account_count, ksp_interface_lib::MAX_PROGRAM_INSTRUCTION_ACCOUNTS);
+    assert_eq!(observed.data_len, ksp_interface_lib::MAX_PROGRAM_INSTRUCTION_DATA_LEN);
+    return;
+}
+
+#[test]
+fn pre_005_malformed_payload_error_path_does_not_gain_automatic_payload_echo() {
+    let decoder = BoundedDecoder::new();
+    let mut payload = std::vec![MALFORMED_OPCODE];
+    payload.extend_from_slice(HOSTILE_MARKER.as_bytes());
+    let instruction = ksp_program_api::ProgramInstruction::try_new(decoder.program_ids[0], std::vec![], payload);
+    assert!(instruction.is_ok());
+    let instruction = match instruction {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let outcome = ksp_program_api::ProgramInstructionDecoder::decode(&decoder, &instruction);
+    assert!(outcome.is_err());
+    let error = match outcome {
+        std::result::Result::Err(value) => value,
+        std::result::Result::Ok(_) => return,
+    };
+    assert_eq!(error.code().domain(), "program_test");
+    assert_eq!(error.code().code(), "malformed_instruction");
+    assert!(!std::format!("{error}").contains(HOSTILE_MARKER));
+    assert!(!std::format!("{error:?}").contains(HOSTILE_MARKER));
+    return;
+}
+
+#[test]
+fn pre_005_associated_decoded_type_keeps_no_implicit_debug_clone_send_or_sync_bound() {
+    let decoder = BoundlessOutputDecoder;
+    let instruction = ksp_program_api::ProgramInstruction::try_new(ksp_program_api::Pubkey::new_from_array([0xD3_u8; 32]), std::vec![], std::vec![]);
+    assert!(instruction.is_ok());
+    let instruction = match instruction {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let outcome = ksp_program_api::ProgramInstructionDecoder::decode(&decoder, &instruction);
+    assert!(outcome.is_ok());
+    let outcome = match outcome {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    assert_eq!(std::format!("{outcome:?}"), "Decoded");
+    let decoded = match outcome {
+        ksp_program_api::ProgramInstructionDecodeOutcome::Decoded(value) => value,
+        _ => return,
+    };
+    assert_eq!(decoded.marker.get(), 0x5A_u8);
+    return;
+}

crates/ksp-program-api/unit_tests/program_instruction_decode.rs

@@ -0,0 +1,41 @@
+// file: crates/ksp-program-api/unit_tests/program_instruction_decode.rs
+// version: 1
+
+#[test]
+fn recognition_variants_are_distinct_and_payload_free() {
+    assert_ne!(crate::ProgramInstructionRecognition::NoMatch, crate::ProgramInstructionRecognition::ProgramMatch);
+    assert_ne!(crate::ProgramInstructionRecognition::ProgramMatch, crate::ProgramInstructionRecognition::ExactMatch);
+    assert_eq!(std::format!("{:?}", crate::ProgramInstructionRecognition::NoMatch), "NoMatch");
+    assert_eq!(std::format!("{:?}", crate::ProgramInstructionRecognition::ProgramMatch), "ProgramMatch");
+    assert_eq!(std::format!("{:?}", crate::ProgramInstructionRecognition::ExactMatch), "ExactMatch");
+    return;
+}
+
+#[test]
+fn decode_outcome_preserves_decoded_value_and_unsupported_state() {
+    let decoded = crate::ProgramInstructionDecodeOutcome::Decoded(17_u64);
+    let decoded_value = match decoded {
+        crate::ProgramInstructionDecodeOutcome::Decoded(value) => value,
+        crate::ProgramInstructionDecodeOutcome::Unsupported => 0_u64,
+    };
+    assert_eq!(decoded_value, 17_u64);
+    let unsupported = crate::ProgramInstructionDecodeOutcome::<u64>::Unsupported;
+    assert!(matches!(unsupported, crate::ProgramInstructionDecodeOutcome::Unsupported));
+    return;
+}
+
+#[test]
+fn decode_outcome_debug_never_requires_or_renders_decoded_debug() {
+    struct ExternalDecoded {
+        secret_marker: u8,
+    }
+    let decoded = crate::ProgramInstructionDecodeOutcome::Decoded(ExternalDecoded { secret_marker: 0xA7_u8 });
+    assert_eq!(std::format!("{decoded:?}"), "Decoded");
+    let secret_marker = match decoded {
+        crate::ProgramInstructionDecodeOutcome::Decoded(value) => value.secret_marker,
+        crate::ProgramInstructionDecodeOutcome::Unsupported => 0_u8,
+    };
+    assert_eq!(secret_marker, 0xA7_u8);
+    assert_eq!(std::format!("{:?}", crate::ProgramInstructionDecodeOutcome::<ExternalDecoded>::Unsupported), "Unsupported");
+    return;
+}

deltas/0.2.13/pre.001.md

@@ -0,0 +1,276 @@
+<!-- file: deltas/0.2.13/pre.001.md -->
+<!-- version: 1 -->
+
+# Delta `0.2.13-pre.001` — audit/sizing Interface / wire foundation
+
+## 1. Base requise
+
+```text
+v0.2.12
+```
+
+Archive opérateur utilisée : `khadhroony-solana-project-v0.2.12.zip`, annoncée comme issue du tag Gitea stable.
+
+Vérifications d'identité :
+
+```text
+workspace.package.version = 0.2.12             PASS à l'entrée
+deltas/0.2.12/rel.001.md                       présent
+prompts/018-V0_2_13_START_PROMPT.md             présent
+crates/ksp-interface-lib                        absent
+crates/ksp-program-api                          absent
+.git                                            absent de l'archive
+```
+
+Le tag stable n'est donc pas revérifiable localement par Git. L'archive opérateur, le delta stable et la preuve opérateur fournie constituent l'autorité de reprise.
+
+## 2. Objectif
+
+Exécuter le gate obligatoire `pre.001` sans ouvrir encore la crate : relire règles/architecture, auditer Core/Transport, auditer l'héritage kbot3, vérifier les candidates externes actuelles, décider le premier lot wire, fixer ownership/bornes/threat model/dependency graph/tests, produire plan/validation et recalibrer la release.
+
+## 3. Décisions prises
+
+```text
+crate cible                          ksp-interface-lib
+premier lot                         ProgramAccountMeta + ProgramInstruction
+orientation                         Program-facing passive
+Pubkey                              ksp-core-lib::Pubkey, aucun wrapper parallèle
+Program IDs fondamentaux            restent ksp-core-lib
+account metas                       ordre + doublons préservés
+borne account metas                 255
+borne instruction data              10_240 octets
+fields                              privés pour préserver les invariants
+serde                               OUT pour la foundation
+borsh/bincode/wincode               OUT sans protocole concret
+solana-instruction                  référence normative, pas dépendance runtime
+solana-loader-v3-interface          reporté au vertical loader-v3 réel
+Transport DTO refactor              OUT
+Program traits/decode/recognition   0.2.14, OUT de Interface
+replay/CPI/logs/return-data/Core     0.3.2+, OUT de 0.2.13
+nouvelle dépendance externe         aucune
+network/logging runtime             aucun
+```
+
+Les plafonds 255/10 KiB sont des bornes d'admission Interface dérivées des limites runtime Solana actuelles. Ils ne garantissent pas qu'une instruction donnée rentre dans une transaction top-level complète ; l'assembly transactionnel reste hors scope.
+
+## 4. Héritage kbot3
+
+Archive auditée : `khadhroony-bot3_v0.5.3-pre.005-fix010.zip`.
+
+Verdict synthétique :
+
+```text
+REPRENDRE   ordered account meta; instruction program_id/accounts/data
+REDESSINER  wrappers String Pubkey/ProgramId; payload non borné
+REPORTER    decoder traits; recognition/proofs; replay/CPI/logs/return data;
+            canonical transaction; prepared execution/signers/policies
+REJETER     monolithe ks-lib; JSON/version/hash génériques par réflexe;
+            operation_code dans le contrat d'instruction passive
+```
+
+Aucun code kbot3 n'est porté par ce delta.
+
+## 5. Audit externe ciblé
+
+État observé le 27 août 2026 :
+
+```text
+solana-instruction 3.5.0
+  Instruction = program_id: Pubkey + Vec<AccountMeta> + Vec<u8>
+  solana-pubkey ^4.3.0
+  serde/borsh/bincode/wincode optionnels
+  licence Anza SDK Apache-2.0
+
+solana-program 4.1.0
+  MAX_CPI_INSTRUCTION_ACCOUNTS = 255
+  MAX_CPI_INSTRUCTION_DATA_LEN = 10 * 1024
+  MAX_CPI_ACCOUNT_INFOS = 128 (unique account infos; non appliqué aux metas)
+
+solana-loader-v3-interface 8.1.1
+  compatible avec solana-instruction ^3.5.0 / solana-pubkey ^4.3.0 observés
+  hors premier lot
+```
+
+Aucune nouvelle dépendance n'est justifiée par `pre.001`.
+
+## 6. Fichiers ajoutés
+
+```text
+docs/plans/020-V0_2_13_INTERFACE_PLAN.md
+docs/validation/016-V0_2_13_INTERFACE.md
+deltas/0.2.13/pre.001.md
+```
+
+## 7. Fichiers modifiés
+
+```text
+Cargo.toml
+docs/000-README.md
+docs/plans/000-README.md
+docs/validation/000-README.md
+```
+
+`workspace.package.version` passe à `0.2.13-pre.1` conformément au workflow des prereleases non-fix.
+
+## 8. Fichiers supprimés
+
+```text
+aucun
+```
+
+## 9. Fichiers volontairement inchangés
+
+```text
+ROADMAP.md
+CHANGELOG.md
+prompts/018-V0_2_13_START_PROMPT.md
+docs/plans/002-FUNCTIONAL_RELEASE_SEQUENCE.md
+docs/architecture/**
+crates/**
+config/**
+.env.example
+```
+
+La roadmap/séquence/architecture possèdent déjà les frontières `0.2.13` / `0.2.14` / `0.3.2`. `pre.001` les confronte à la base réelle dans le nouveau plan sans les réécrire par duplication. `ROADMAP.md` et `CHANGELOG.md` restent hors du couloir de cette tranche.
+
+## 10. Audit interne exécuté
+
+Points confirmés :
+
+```text
+Core réexporte Pubkey et possède les Program IDs fondamentaux
+Core possède Error/Result communs
+Transport possède encore les projections HTTP/WS/Yellowstone concrètes
+aucun besoin de déplacer ces DTOs vers Interface en 0.2.13
+Interface ne doit pas dépendre de Program/Transport/Store/Wallet/Config
+Program API pourra dépendre de Core + Interface en 0.2.14
+wires d'acquisition/CORE génériques restent réservés à 0.3.2+
+workspace n'a pas solana-instruction/borsh/wincode comme besoin Interface actuel
+```
+
+## 11. Threat model et tests décidés
+
+```text
+accounts 255                            accepté
+accounts 256                            refusé
+data 10_240                             accepté
+data 10_241                             refusé
+empty accounts/data                     accepté
+ordre + doublons                        préservés
+unknown Program Pubkey                  accepté
+Debug instruction                       résumé borné
+payload hostile dans Debug/Error        absent
+serde hostile                           éliminé par absence de serde
+malformed/discriminant                  N/A tant qu'aucun codec n'est retenu
+panic/unwrap/expect/?                    audits/lints KSP
+network smoke                            non requis
+public API / external consumer          requis
+cargo tree / dependency firewall        requis dès scaffold
+```
+
+## 12. Validations exécutées dans le sandbox
+
+Avant modification, sur l'archive stable extraite :
+
+```text
+python3 scripts/audit_rust_workspace_rules.py                  PASS
+python3 scripts/audit_markdown_tables.py ... deltas/0.2.13    PASS
+```
+
+La preuve opérateur fournie sur le checkout stable `0.2.12` établit :
+
+```text
+cargo fmt --all                           PASS
+Rust rules audit                         PASS
+Markdown table audit                     PASS
+cargo check --workspace                  PASS
+cargo clippy --workspace --all-targets   PASS
+cargo test --workspace                   PASS
+```
+
+Après génération du présent overlay :
+
+```text
+python3 scripts/audit_rust_workspace_rules.py                  PASS
+  General Rust rule audit                                     clean
+  Rust export completeness audit                              0 candidate(s)
+  KSP workspace Rust rule audit                               clean
+python3 scripts/audit_markdown_tables.py ... deltas/0.2.13    PASS
+  tables / files                                               160 / 111
+```
+
+## 13. Validations non exécutées dans ce sandbox
+
+```text
+cargo fmt --all
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test --workspace
+cargo tree -p ksp-interface-lib --edges normal
+cargo tree --duplicates
+```
+
+Cause : executable `cargo` absent du sandbox de préparation. `ksp-interface-lib` n'existe pas encore par contrat de `pre.001`, donc les graphes propres à la crate commenceront avec `pre.002`.
+
+Aucune commande non exécutée localement n'est déclarée PASS.
+
+## 14. Forecast souple recalibré
+
+### pre.001 — audit + héritage + frontières + sizing
+
+**Statut : livré par le présent delta.**
+
+### pre.002 — scaffold `ksp-interface-lib` + façade + firewall
+
+**Statut : prévu.**
+
+### pre.003 — `ProgramAccountMeta` + bornes communes
+
+**Statut : prévu.**
+
+### pre.004 — `ProgramInstruction` passif borné
+
+**Statut : prévu.**
+
+### pre.005 — adversarial + consumer externe + API/dependency hardening
+
+**Statut : prévu.**
+
+### pre.006 — gate technique final
+
+**Statut : prévu.**
+
+### pre.007 — réconciliation documentaire finale
+
+**Statut : prévu.**
+
+### pre.008 — préparation de publication minimale
+
+**Statut : prévu.**
+
+### rel.001 — publication stable
+
+**Statut : prévu.**
+
+Le second lot wire optionnel du forecast initial est supprimé : aucun second domaine ne justifie une tranche dans cette foundation. Le scope reste compatible avec une release/session.
+
+## 15. Questions ouvertes
+
+Aucune question bloquante pour `pre.002`.
+
+Les noms exacts des codes d'erreur et le détail final des accessors peuvent encore être ajustés dans `pre.003`/`pre.004` sans rouvrir l'ownership, les bornes ou le scope de release.
+
+## 16. Validation opérateur après application
+
+Exécuter :
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.2.13
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test --workspace
+```
+
+`pre.002` ne commence qu'après retour du gate appliqué.

deltas/0.2.13/pre.002.md

@@ -0,0 +1,205 @@
+<!-- file: deltas/0.2.13/pre.002.md -->
+<!-- version: 1 -->
+
+# Delta `0.2.13-pre.002` — scaffold `ksp-interface-lib`
+
+## 1. Base requise
+
+Cette tranche s'applique exclusivement sur :
+
+```text
+v0.2.12
++ 0.2.13-pre.001
+```
+
+Le gate opérateur fourni pour `pre.001` est intégralement vert : `cargo fmt --all`, audits Rust/Markdown, `cargo check --workspace`, Clippy workspace et `cargo test --workspace` passent.
+
+La version workspace passe de :
+
+```text
+0.2.13-pre.1
+```
+
+à :
+
+```text
+0.2.13-pre.2
+```
+
+## 2. Objectif
+
+Créer uniquement le scaffold de `ksp-interface-lib` et verrouiller sa frontière avant les types wire fonctionnels.
+
+La tranche matérialise :
+
+```text
+nouveau membre workspace ksp-interface-lib
+manifest avec ksp-core-lib comme seule dépendance normale
+façade crate-root explicite
+réexport contrôlé de ksp_core_lib::Pubkey
+README/USAGE initiaux
+canari public API minimal
+canari dependency firewall
+```
+
+Elle ne matérialise pas encore :
+
+```text
+ProgramAccountMeta
+ProgramInstruction
+bornes instruction
+codes d'erreur Interface
+serde / serde_json
+borsh / bincode / wincode
+solana-instruction
+network/runtime
+Program behavior
+```
+
+## 3. Décision Logging
+
+`0.2.13` reste une foundation de contrats passifs. Aucun comportement runtime n'est actuellement prévu dans `ksp-interface-lib`, donc aucun événement/span n'a besoin d'être émis.
+
+En conséquence, la tranche maintient explicitement absents :
+
+```text
+ksp-logging-lib
+src/constants.rs
+TRACING_TARGET
+tracing direct
+```
+
+Cette absence est volontaire et couverte par le canari de dépendances. Si un comportement runtime réel apparaît dans une future évolution d'Interface, l'instrumentation devra être ajoutée via `ksp-logging-lib`; `DEP-LOG-010` imposera alors un `pub(crate) const TRACING_TARGET: &str` possédé par `src/constants.rs`.
+
+Les futures validations de bornes de `pre.003`/`pre.004` doivent retourner des erreurs structurées ; elles ne justifient pas à elles seules des logs runtime.
+
+## 4. Surface publique de scaffold
+
+La seule primitive publique nouvellement exposée est :
+
+```rust
+pub use ksp_core_lib::Pubkey;
+```
+
+Ce réexport confirme l'ownership décidé : Interface n'introduit aucun wrapper `ProgramId`/`Pubkey` parallèle et utilisera la primitive Core dans ses futurs contrats wire.
+
+La façade ne contient aucun `pub mod`. Les types d'instruction restent absents pour éviter d'avancer `pre.003`/`pre.004`.
+
+## 5. Dependency firewall
+
+Le manifest membre possède exactement :
+
+```text
+[dependencies]
+ksp-core-lib = { path = "../ksp-core-lib" }
+```
+
+Le canari `tests/dependency_boundary.rs` vérifie notamment l'absence de :
+
+```text
+ksp-logging-lib
+ksp-program-*
+ksp-*-transport-lib
+ksp-config-lib
+ksp-store-*
+ksp-wallet-lib
+serde / serde_json
+borsh / bincode / wincode
+solana-instruction
+reqwest / tokio / tonic / tauri / tracing
+```
+
+Il verrouille aussi l'absence de `src/constants.rs` et `TRACING_TARGET` tant que la crate reste passive.
+
+## 6. Tests ajoutés
+
+`tests/public_api.rs` vérifie que le `Pubkey` canonique est consommable uniquement depuis le crate-root Interface.
+
+`tests/dependency_boundary.rs` vérifie :
+
+```text
+dépendance normale exacte = ksp-core-lib
+absence des dépendances interdites
+absence de ProgramAccountMeta/ProgramInstruction en pre.002
+absence de surface Logging runtime
+```
+
+Aucun unit test métier n'est ajouté : aucune primitive fonctionnelle n'existe encore.
+
+## 7. Fichiers ajoutés
+
+```text
+crates/ksp-interface-lib/Cargo.toml
+crates/ksp-interface-lib/README.md
+crates/ksp-interface-lib/USAGE.md
+crates/ksp-interface-lib/src/lib.rs
+crates/ksp-interface-lib/tests/dependency_boundary.rs
+crates/ksp-interface-lib/tests/public_api.rs
+deltas/0.2.13/pre.002.md
+```
+
+## 8. Fichiers modifiés
+
+```text
+Cargo.toml
+docs/plans/020-V0_2_13_INTERFACE_PLAN.md
+docs/validation/016-V0_2_13_INTERFACE.md
+```
+
+## 9. Fichiers volontairement inchangés
+
+```text
+README.md
+ROADMAP.md
+CHANGELOG.md
+.env.example
+docs/architecture/**
+docs/rules/**
+crates/ksp-core-lib/**
+crates/ksp-logging-lib/**
+crates/ksp-onchain-transport-lib/**
+crates/ksp-offchain-transport-lib/**
+crates/ksp-config-lib/**
+crates/ksp-wallet-lib/**
+crates/ksp-app-*/**
+prompts/**
+```
+
+Aucune architecture durable n'est rouverte : le graphe `Interface -> Core`, avec Logging uniquement lorsqu'un runtime logging réel existe, est déjà documenté.
+
+## 10. Validations de génération
+
+Les audits Python sont rejoués sur l'arbre matérialisé avant livraison. Le sandbox de génération ne fournit pas `cargo`, `rustc` ou `rustfmt`; aucun PASS Cargo nouveau n'est donc revendiqué localement.
+
+## 11. Gate opérateur attendu
+
+Après application :
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.2.13
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test -p ksp-interface-lib
+cargo test --workspace
+cargo tree -p ksp-interface-lib --edges normal
+cargo tree --duplicates
+```
+
+Le `cargo tree -p ksp-interface-lib --edges normal` doit montrer Core comme unique dépendance KSP directe et ne doit pas révéler de codec/runtime ajouté par Interface.
+
+Une correction découverte par ce gate reste un `0.2.13-pre.002-fix.NNN` et n'avance pas `pre.003`.
+
+## 12. Suite
+
+Après gate vert, `pre.003` pourra matérialiser uniquement :
+
+```text
+ProgramAccountMeta
+constante de borne account metas
+modèle d'erreur Interface minimal nécessaire
+unit/public canaries correspondants
+```
+
+`ProgramInstruction`, sa data bound et son Debug résumé restent réservés à `pre.004`.

deltas/0.2.13/pre.003.md

@@ -0,0 +1,272 @@
+<!-- file: deltas/0.2.13/pre.003.md -->
+<!-- version: 1 -->
+
+# Delta `0.2.13-pre.003` — `ProgramAccountMeta` + borne accounts
+
+## 1. Base requise
+
+Cette tranche s'applique exclusivement sur :
+
+```text
+v0.2.12
++ 0.2.13-pre.001
++ 0.2.13-pre.002
+```
+
+Le gate opérateur fourni pour `pre.002` est intégralement vert :
+
+```text
+cargo fmt --all                                      PASS
+python3 scripts/audit_rust_workspace_rules.py        PASS
+python3 scripts/audit_markdown_tables.py ...         PASS
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-interface-lib                      PASS
+cargo test --workspace                               PASS
+cargo tree -p ksp-interface-lib --edges normal       inspecté
+cargo tree --duplicates                              inspecté
+```
+
+Le graphe ciblé confirme :
+
+```text
+ksp-interface-lib
+└── ksp-core-lib
+    └── solana-pubkey 4.3.0
+```
+
+Aucune dépendance codec/runtime n'est introduite par Interface et les doublons workspace observés sont préexistants à cette crate.
+
+La version workspace passe de :
+
+```text
+0.2.13-pre.2
+```
+
+à :
+
+```text
+0.2.13-pre.3
+```
+
+## 2. Objectif
+
+Matérialiser uniquement la primitive passive représentant un account meta d'instruction Program, figer la borne publique du nombre d'account metas et introduire le code d'erreur Interface minimal nécessaire à la future admission de `ProgramInstruction`.
+
+La tranche ajoute :
+
+```text
+ProgramAccountMeta
+MAX_PROGRAM_INSTRUCTION_ACCOUNTS = 255
+ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED
+unit tests de la primitive
+public API canaries correspondants
+```
+
+Elle n'ajoute pas encore :
+
+```text
+ProgramInstruction
+MAX_PROGRAM_INSTRUCTION_DATA_LEN
+enforcement de collection 255/256
+data payload
+Debug résumé d'instruction
+serde / serde_json
+borsh / bincode / wincode
+solana-instruction
+logging/runtime
+Program behavior
+```
+
+## 3. `ProgramAccountMeta`
+
+La primitive possède trois champs privés :
+
+```text
+Pubkey
+is_signer
+is_writable
+```
+
+Les constructeurs publics sont :
+
+```text
+ProgramAccountMeta::readonly(pubkey, is_signer)
+ProgramAccountMeta::writable(pubkey, is_signer)
+```
+
+Les accessors publics sont :
+
+```text
+pubkey()
+is_signer()
+is_writable()
+```
+
+Le type reste strictement passif :
+
+- aucune validation de registry Program n'est appliquée au `Pubkey` ;
+- aucune policy signer/writable n'est inventée ;
+- aucune sérialisation ou conversion vers `solana-instruction::AccountMeta` n'est ajoutée ;
+- les champs privés empêchent une dérive future de représentation sans passer par l'API possédée par Interface.
+
+## 4. Borne accounts
+
+La façade expose :
+
+```rust
+pub const MAX_PROGRAM_INSTRUCTION_ACCOUNTS: usize = 255;
+```
+
+Cette constante fixe le plafond d'admission retenu par le plan `0.2.13`.
+
+`pre.003` ne crée volontairement aucune collection artificielle autour de `ProgramAccountMeta` uniquement pour tester `255/256`. L'enforcement concret sera réalisé dans `ProgramInstruction::try_new` à `pre.004`, lorsque la collection existera réellement.
+
+La borne data `10_240` reste également réservée à `pre.004` avec le payload qu'elle protège.
+
+## 5. Modèle d'erreur minimal
+
+Interface continue d'utiliser `ksp_core_lib::Error`, `ErrorCode` et `Result`; aucun second type d'erreur n'est introduit.
+
+La seule catégorie matérialisée est :
+
+```text
+interface.program_instruction_limit_exceeded
+```
+
+via :
+
+```text
+ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED
+```
+
+Le code `invalid_program_instruction` n'est pas ajouté : aucun invariant de forme distinct des bornes n'existe encore dans la foundation. Le créer uniquement par symétrie serait prématuré.
+
+À `pre.004`, les erreurs de borne devront limiter leur contexte aux longueurs et plafonds sûrs ; aucun payload ni compte arbitraire ne devra être copié dans les diagnostics.
+
+## 6. Logging
+
+La décision de `pre.002` reste inchangée. Interface est toujours une crate de contrats passifs et n'émet aucun événement/span runtime.
+
+Restent donc absents :
+
+```text
+ksp-logging-lib
+src/constants.rs
+TRACING_TARGET
+tracing direct
+```
+
+## 7. Tests
+
+Les unit tests de `ProgramAccountMeta` couvrent :
+
+```text
+readonly -> identité/signature conservées, writable=false
+writable -> identité/signature conservées, writable=true
+Pubkey opaque/non registry accepté
+MAX_PROGRAM_INSTRUCTION_ACCOUNTS == 255
+```
+
+`tests/public_api.rs` prouve depuis le crate-root :
+
+```text
+construction readonly/writable
+accessors publics
+borne accounts publique
+code d'erreur stable et typé par ksp_core_lib::ErrorCode
+```
+
+`tests/dependency_boundary.rs` conserve le firewall `pre.002` et vérifie désormais que :
+
+```text
+ProgramAccountMeta est présent
+MAX_PROGRAM_INSTRUCTION_ACCOUNTS est présent
+ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED est présent
+ProgramInstruction reste absent
+logging/runtime restent absents
+```
+
+## 8. Fichiers ajoutés
+
+```text
+crates/ksp-interface-lib/src/error.rs
+crates/ksp-interface-lib/src/program_account_meta.rs
+crates/ksp-interface-lib/unit_tests/program_account_meta.rs
+deltas/0.2.13/pre.003.md
+```
+
+## 9. Fichiers modifiés
+
+```text
+Cargo.toml
+crates/ksp-interface-lib/src/lib.rs
+crates/ksp-interface-lib/tests/dependency_boundary.rs
+crates/ksp-interface-lib/tests/public_api.rs
+docs/plans/020-V0_2_13_INTERFACE_PLAN.md
+docs/validation/016-V0_2_13_INTERFACE.md
+```
+
+## 10. Fichiers volontairement inchangés
+
+```text
+README.md
+ROADMAP.md
+CHANGELOG.md
+.env.example
+crates/ksp-interface-lib/Cargo.toml
+crates/ksp-interface-lib/README.md
+crates/ksp-interface-lib/USAGE.md
+docs/architecture/**
+docs/rules/**
+crates/ksp-core-lib/**
+crates/ksp-logging-lib/**
+crates/ksp-onchain-transport-lib/**
+crates/ksp-offchain-transport-lib/**
+crates/ksp-config-lib/**
+crates/ksp-wallet-lib/**
+crates/ksp-app-*/**
+prompts/**
+```
+
+README/USAGE restent dans leur lane de réconciliation finale `pre.007`; aucune documentation durable hors plan/validation n'est rouverte pour cette petite tranche fonctionnelle.
+
+## 11. Validations de génération
+
+Les audits Python sont rejoués sur l'arbre matérialisé avant livraison. Le sandbox de génération ne fournit pas `cargo`, `rustc` ou `rustfmt`; aucun nouveau PASS Cargo n'est donc revendiqué localement.
+
+## 12. Gate opérateur attendu
+
+Après application :
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.2.13
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test -p ksp-interface-lib
+cargo test --workspace
+cargo tree -p ksp-interface-lib --edges normal
+cargo tree --duplicates
+```
+
+Une correction découverte par ce gate reste un `0.2.13-pre.003-fix.NNN` et n'avance pas `pre.004`.
+
+## 13. Suite
+
+Après gate vert, `pre.004` pourra matérialiser uniquement :
+
+```text
+ProgramInstruction { program_id, accounts, data }
+MAX_PROGRAM_INSTRUCTION_DATA_LEN = 10_240
+try_new borné
+accessors
+Debug résumé sans payload
+acceptation 0/255 accounts et 0/10_240 data
+rejet 256 accounts et 10_241 data
+ordre et doublons conservés
+contextes d'erreur sûrs
+```
+
+Aucun serde/codec ou comportement Program ne doit être ajouté dans cette tranche suivante.

deltas/0.2.13/pre.004.md

@@ -0,0 +1,295 @@
+<!-- file: deltas/0.2.13/pre.004.md -->
+<!-- version: 1 -->
+
+# Delta `0.2.13-pre.004` — `ProgramInstruction` passif borné
+
+## 1. Base requise
+
+Cette tranche s'applique exclusivement sur :
+
+```text
+v0.2.12
++ 0.2.13-pre.001
++ 0.2.13-pre.002
++ 0.2.13-pre.003
+```
+
+La preuve opérateur fournie pour `pre.003` confirme :
+
+```text
+cargo fmt --all                                      PASS
+python3 scripts/audit_rust_workspace_rules.py        PASS
+python3 scripts/audit_markdown_tables.py ...         PASS
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-interface-lib                      PASS
+cargo tree -p ksp-interface-lib --edges normal       inspecté
+cargo tree --duplicates                              inspecté
+```
+
+`cargo test --workspace` n'apparaît pas dans cette preuve opérateur. La présente préparation n'en invente donc pas le résultat ; ce test devra être rejoué avec le gate de `pre.004` avant de déclarer la continuité workspace complète.
+
+Le graphe ciblé reste strictement :
+
+```text
+ksp-interface-lib
+└── ksp-core-lib
+    └── solana-pubkey 4.3.0
+```
+
+La version workspace passe de :
+
+```text
+0.2.13-pre.3
+```
+
+à :
+
+```text
+0.2.13-pre.4
+```
+
+## 2. Objectif
+
+Matérialiser le second type du premier lot wire générique décidé en `pre.001` : une instruction Program passive `{ program_id, accounts, data }`, bornée à l'admission et sans comportement Program.
+
+La tranche ajoute :
+
+```text
+ProgramInstruction
+MAX_PROGRAM_INSTRUCTION_DATA_LEN = 10_240
+ProgramInstruction::try_new(...)
+accessors program_id/accounts/data
+Debug résumé
+unit/public canaries de limites, ordre et doublons
+```
+
+Elle n'ajoute pas :
+
+```text
+serde / serde_json
+borsh / bincode / wincode
+solana-instruction
+codec ou discriminant Program spécifique
+Program API / Program behavior
+Transport / Store / Config / Wallet
+ksp-logging-lib / constants.rs / TRACING_TARGET
+runtime réseau
+```
+
+## 3. `ProgramInstruction`
+
+Le type possède trois champs privés :
+
+```text
+program_id : Pubkey
+accounts   : Vec<ProgramAccountMeta>
+data       : Vec<u8>
+```
+
+Le constructeur public est :
+
+```text
+ProgramInstruction::try_new(program_id, accounts, data)
+    -> ksp_core_lib::Result<ProgramInstruction>
+```
+
+Les accessors publics sont :
+
+```text
+program_id() -> &Pubkey
+accounts()   -> &[ProgramAccountMeta]
+data()       -> &[u8]
+```
+
+La construction consomme directement les `Vec` fournis. Aucun clone interne, conversion vers `solana-instruction` ou sérialisation n'est ajouté.
+
+## 4. Bornes d'admission
+
+Les deux plafonds sont désormais matérialisés :
+
+```text
+MAX_PROGRAM_INSTRUCTION_ACCOUNTS = 255
+MAX_PROGRAM_INSTRUCTION_DATA_LEN = 10_240
+```
+
+`try_new` vérifie en `usize` :
+
+```text
+accounts.len() <= 255
+data.len()     <= 10_240
+```
+
+Canaris exacts :
+
+```text
+255 accounts       accepté
+256 accounts       refusé
+10_240 octets data accepté
+10_241 octets data refusé
+```
+
+Ces valeurs restent des bornes d'admission Interface fondées sur les plafonds Solana CPI audités en `pre.001`. Elles ne garantissent pas qu'une instruction rentre dans une transaction top-level complète.
+
+## 5. Sémantique passive
+
+Restent valides :
+
+```text
+accounts vides
+data vide
+Program Pubkey inconnu du registry Core
+doublons d'accounts
+ordre arbitraire des account metas
+payload opaque quelconque sous la borne
+```
+
+Interface n'ajoute aucune politique signer/writable, aucun lookup de Program ID, aucune déduplication et aucune interprétation du payload.
+
+## 6. Erreurs
+
+Les deux violations de borne réutilisent :
+
+```text
+interface.program_instruction_limit_exceeded
+```
+
+via `ksp_core_lib::Error/Result`.
+
+Le contexte d'erreur est limité à :
+
+```text
+field
+actual_len
+maximum_len
+```
+
+Aucun octet `data`, aucun account arbitraire et aucun payload externe n'est copié dans l'erreur.
+
+Le code conceptuel `invalid_program_instruction` reste absent : la foundation ne possède toujours aucun invariant de forme distinct des deux limites.
+
+## 7. Debug borné
+
+`ProgramInstruction` n'utilise pas un `derive(Debug)` qui imprimerait les deux `Vec`.
+
+Son `Debug` manuel expose uniquement :
+
+```text
+program_id
+account_count
+data_len
+```
+
+Les account metas et le payload sont volontairement absents du rendu.
+
+## 8. Logging
+
+La décision de `pre.002` reste inchangée : cette crate est passive.
+
+Restent absents :
+
+```text
+ksp-logging-lib
+src/constants.rs
+TRACING_TARGET
+tracing direct
+```
+
+Une erreur de validation de borne est une valeur retournée au caller, pas un événement runtime à logger depuis Interface.
+
+## 9. Tests
+
+Les unit tests de `ProgramInstruction` couvrent :
+
+```text
+accounts/data vides acceptés
+Program Pubkey opaque accepté
+ordre et doublons préservés
+payload opaque préservé
+255 / 256 accounts
+10_240 / 10_241 octets data
+code/message/contexte d'erreur sûr
+Debug résumé sans payload ni account flags
+```
+
+`tests/public_api.rs` ajoute un canari de consommation crate-root de `ProgramInstruction` et de `MAX_PROGRAM_INSTRUCTION_DATA_LEN`.
+
+`tests/dependency_boundary.rs` est avancé à `pre.004` et confirme toujours :
+
+```text
+ksp-core-lib seule dépendance normale
+aucun serde/borsh/bincode/wincode
+aucun solana-instruction
+aucun logging/runtime
+ProgramInstruction présent via façade explicite
+```
+
+## 10. Fichiers ajoutés
+
+```text
+crates/ksp-interface-lib/src/program_instruction.rs
+crates/ksp-interface-lib/unit_tests/program_instruction.rs
+deltas/0.2.13/pre.004.md
+```
+
+## 11. Fichiers modifiés
+
+```text
+Cargo.toml
+crates/ksp-interface-lib/src/lib.rs
+crates/ksp-interface-lib/tests/dependency_boundary.rs
+crates/ksp-interface-lib/tests/public_api.rs
+docs/plans/020-V0_2_13_INTERFACE_PLAN.md
+docs/validation/016-V0_2_13_INTERFACE.md
+```
+
+## 12. Fichiers volontairement inchangés
+
+```text
+README.md
+ROADMAP.md
+CHANGELOG.md
+.env.example
+crates/ksp-interface-lib/Cargo.toml
+crates/ksp-interface-lib/README.md
+crates/ksp-interface-lib/USAGE.md
+crates/ksp-interface-lib/src/error.rs
+crates/ksp-interface-lib/src/program_account_meta.rs
+crates/ksp-interface-lib/unit_tests/program_account_meta.rs
+docs/architecture/**
+prompts/**
+config/**
+```
+
+## 13. Gate attendu
+
+Après application de l'overlay :
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.2.13
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test -p ksp-interface-lib
+cargo test --workspace
+cargo tree -p ksp-interface-lib --edges normal
+cargo tree --duplicates
+```
+
+Le `cargo test --workspace` est particulièrement requis ici puisqu'il n'était pas présent dans la preuve opérateur fournie pour `pre.003`.
+
+## 14. Suite autorisée
+
+Après gate vert, `pre.005` doit rester une tranche de hardening :
+
+```text
+cas adversariaux complémentaires
+consumer externe
+surface crate-root
+firewall source/manifest
+graphes Cargo
+canari de complétude du premier lot
+```
+
+Aucun second domaine wire, codec générique ou comportement Program ne doit être ajouté opportunément.

deltas/0.2.13/pre.005-fix.001.md

@@ -0,0 +1,137 @@
+<!-- file: deltas/0.2.13/pre.005-fix.001.md -->
+<!-- version: 1 -->
+
+# Delta `0.2.13-pre.005-fix.001` — faux positif du scanner Logging
+
+## 1. Déclencheur
+
+Le gate opérateur de `pre.005` confirme :
+
+```text
+cargo fmt --all                                      PASS
+python3 scripts/audit_rust_workspace_rules.py        PASS / clean
+python3 scripts/audit_markdown_tables.py ...         PASS / clean
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-interface-lib                      PASS
+cargo test --workspace                               FAIL
+cargo tree -p ksp-interface-lib --edges normal       Core-only confirmé
+cargo tree --duplicates                              fourni
+```
+
+Le test ciblé Interface est entièrement vert :
+
+```text
+unit tests                         10/10
+manifest/source firewall           4/4
+external consumer                  1/1
+public API                         5/5
+release completeness               3/3
+```
+
+Le workspace échoue uniquement ici :
+
+```text
+ksp-logging-lib/tests/ownership.rs
+workspace_crates_do_not_bypass_ksp_logging_facade
+```
+
+avec :
+
+```text
+crates/ksp-interface-lib/tests/dependency_boundary.rs bypasses ksp-logging-lib via tracing
+```
+
+## 2. Cause exacte
+
+Le scanner Logging recherche le chemin littéral :
+
+```text
+tracing::
+```
+
+sur le texte brut de tous les fichiers Rust des crates KSP, tests compris.
+
+Le hardening `pre.005` a ajouté ce même littéral dans `tests/dependency_boundary.rs` comme **pattern interdit à rechercher dans les sources de production**. Il ne s'agit donc ni d'un import, ni d'un appel runtime, ni d'une dépendance Interface vers Tracing : le scanner transversal détecte simplement la donnée de son canari voisin.
+
+Le graphe Cargo opérateur confirme toujours :
+
+```text
+ksp-interface-lib
+└── ksp-core-lib
+    └── solana-pubkey 4.3.0
+```
+
+## 3. Correction
+
+Le firewall Interface conserve strictement la même vérification, mais le token est écrit sans matérialiser `tracing::` contigu dans le source du test :
+
+```rust
+concat!("tracing", "::")
+```
+
+La valeur produite à la compilation reste exactement `tracing::`. Le test Interface continue donc d'échouer si un module de production utilise directement ce chemin.
+
+Aucun `allow`, aucune exclusion de fichier et aucun affaiblissement du scanner Logging ne sont introduits.
+
+## 4. Version
+
+Le fix modifie un test Rust ; la version workspace devient :
+
+```text
+0.2.13-pre.5.fix.1
+```
+
+Commit attendu après validation :
+
+```text
+v0.2.13-pre.005-fix.001
+```
+
+Aucun tag prerelease.
+
+## 5. Frontières
+
+Inchangés :
+
+```text
+crates/ksp-interface-lib/src/**
+crates/ksp-interface-lib/Cargo.toml
+surface publique Interface
+ProgramAccountMeta
+ProgramInstruction
+bornes 255 / 10_240
+Error/Result Core
+ksp-logging-lib absent d'Interface
+constants.rs absent
+TRACING_TARGET absent
+serde/borsh/bincode/wincode absents
+solana-instruction absent
+```
+
+## 6. Fichiers modifiés
+
+```text
+Cargo.toml
+crates/ksp-interface-lib/tests/dependency_boundary.rs
+docs/plans/020-V0_2_13_INTERFACE_PLAN.md
+docs/validation/016-V0_2_13_INTERFACE.md
+deltas/0.2.13/pre.005-fix.001.md
+```
+
+## 7. Gate opérateur
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.2.13
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test -p ksp-interface-lib
+cargo test -p ksp-logging-lib --test ownership
+cargo test --workspace
+cargo tree -p ksp-interface-lib --edges normal
+cargo tree --duplicates
+```
+
+`pre.006` reste interdit tant que ce gate n'est pas intégralement vert.

deltas/0.2.13/pre.005.md

@@ -0,0 +1,213 @@
+<!-- file: deltas/0.2.13/pre.005.md -->
+<!-- version: 1 -->
+
+# Delta `0.2.13-pre.005` — hardening adversarial + consumer externe + complétude
+
+## 1. Base requise
+
+Cette tranche s'applique exclusivement sur :
+
+```text
+v0.2.12
++ 0.2.13-pre.001
++ 0.2.13-pre.002
++ 0.2.13-pre.003
++ 0.2.13-pre.004
+```
+
+Le gate opérateur fourni pour `pre.004` est intégralement vert :
+
+```text
+cargo fmt --all                                      PASS
+python3 scripts/audit_rust_workspace_rules.py        PASS
+python3 scripts/audit_markdown_tables.py ...         PASS
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-interface-lib                      PASS
+cargo test --workspace                               PASS
+cargo tree -p ksp-interface-lib --edges normal       inspecté
+cargo tree --duplicates                              inspecté
+```
+
+Le graphe ciblé reste strictement :
+
+```text
+ksp-interface-lib
+└── ksp-core-lib
+    └── solana-pubkey 4.3.0
+```
+
+La version workspace passe de :
+
+```text
+0.2.13-pre.4
+```
+
+à :
+
+```text
+0.2.13-pre.5
+```
+
+## 2. Objectif
+
+Fermer le hardening du premier lot wire générique sans ajouter de capacité fonctionnelle ni de second domaine wire.
+
+La tranche ajoute uniquement des preuves :
+
+```text
+consumer externe crate-root
+inventaire exact de complétude release
+firewall source/manifest renforcé
+absence de narrowing/codec caché
+transfert sans réallocation des Vec admis
+absence de contenu hostile dans les erreurs de limite
+public API boundary canary
+```
+
+Aucun fichier `src/` de production n'est modifié.
+
+## 3. Consumer externe
+
+`tests/external_consumer.rs` constitue le canari downstream. Comme tout integration test Rust, il est compilé comme un crate distinct de la bibliothèque et utilise exclusivement :
+
+```text
+ksp_interface_lib::Pubkey
+ksp_interface_lib::ProgramAccountMeta
+ksp_interface_lib::ProgramInstruction
+ksp_interface_lib::MAX_PROGRAM_INSTRUCTION_ACCOUNTS
+ksp_interface_lib::MAX_PROGRAM_INSTRUCTION_DATA_LEN
+ksp_interface_lib::ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED
+```
+
+Aucun chemin vers un module privé n'est requis.
+
+## 4. Complétude de release
+
+`tests/release_completeness.rs` verrouille exactement les six exports crate-root retenus pour `0.2.13` et refuse une façade `pub mod`.
+
+Il verrouille également l'inventaire des fichiers Rust de production :
+
+```text
+error.rs
+lib.rs
+program_account_meta.rs
+program_instruction.rs
+```
+
+Ce canari rend explicite qu'un second lot wire, un codec générique, un runtime ou un nouveau domaine ne peut pas être ajouté silencieusement dans cette release.
+
+## 5. Hardening adversarial
+
+Les unit tests de `ProgramInstruction` sont renforcés sur deux propriétés.
+
+Premièrement, les pointeurs des `Vec<ProgramAccountMeta>` et `Vec<u8>` sont capturés avant `try_new` puis comparés aux slices exposés après construction. Le canari prouve que l'implémentation courante transfère les allocations admises sans clone/réallocation interne.
+
+Deuxièmement, les deux branches d'erreur de limite sont confrontées à du matériel hostile : payload avec marqueur explicite et account meta arbitraire. Les rendus/contextes d'erreur doivent rester bornés aux champs sûrs déjà définis :
+
+```text
+field
+actual_len
+maximum_len
+```
+
+Aucun payload ni account meta n'est recopié dans l'erreur.
+
+## 6. Dependency/API firewall
+
+`tests/dependency_boundary.rs` conserve l'exigence manifeste :
+
+```text
+ksp-core-lib = seule dépendance normale
+```
+
+et étend le scan à tous les fichiers Rust de production pour interdire les chemins directs vers :
+
+```text
+Program/Store/Transport/Config/Wallet
+serde/serde_json
+borsh/bincode/wincode
+solana-instruction
+reqwest/tokio/tonic/tauri
+tracing/ksp-logging-lib
+```
+
+Un canari dédié refuse également les casts étroits et les points d'entrée génériques `serialize/deserialize/encode/decode` dans `program_instruction.rs`.
+
+## 7. Public API
+
+`tests/public_api.rs` ajoute un test de rejet `10_241` bytes depuis un consumer externe au module privé et vérifie que le caller reçoit le code Core commun ainsi que les trois contextes sûrs attendus.
+
+Aucune nouvelle API publique n'est créée par `pre.005`.
+
+## 8. Logging et codecs
+
+La décision reste inchangée : Interface est passive.
+
+Toujours absents :
+
+```text
+ksp-logging-lib
+constants.rs
+TRACING_TARGET
+tracing direct
+serde
+borsh
+bincode
+wincode
+solana-instruction
+```
+
+## 9. Fichiers ajoutés
+
+```text
+crates/ksp-interface-lib/tests/external_consumer.rs
+crates/ksp-interface-lib/tests/release_completeness.rs
+deltas/0.2.13/pre.005.md
+```
+
+## 10. Fichiers modifiés
+
+```text
+Cargo.toml
+crates/ksp-interface-lib/tests/dependency_boundary.rs
+crates/ksp-interface-lib/tests/public_api.rs
+crates/ksp-interface-lib/unit_tests/program_instruction.rs
+docs/plans/020-V0_2_13_INTERFACE_PLAN.md
+docs/validation/016-V0_2_13_INTERFACE.md
+```
+
+## 11. Fichiers volontairement inchangés
+
+```text
+README.md
+ROADMAP.md
+CHANGELOG.md
+.env.example
+crates/ksp-interface-lib/Cargo.toml
+crates/ksp-interface-lib/README.md
+crates/ksp-interface-lib/USAGE.md
+crates/ksp-interface-lib/src/**
+crates/ksp-interface-lib/unit_tests/program_account_meta.rs
+docs/architecture/**
+prompts/**
+config/**
+```
+
+## 12. Gate attendu
+
+Après application de l'overlay :
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.2.13
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test -p ksp-interface-lib
+cargo test --workspace
+cargo tree -p ksp-interface-lib --edges normal
+cargo tree --duplicates
+```
+
+Si ce gate est vert, `pre.006` doit rester un gate technique final sans nouveau développement fonctionnel.

deltas/0.2.13/pre.006.md

@@ -0,0 +1,141 @@
+<!-- file: deltas/0.2.13/pre.006.md -->
+<!-- version: 1 -->
+
+# Delta `0.2.13-pre.006` — gate technique final Interface
+
+## 1. Base requise
+
+Cette tranche s'applique exclusivement après `0.2.13-pre.005-fix.001`.
+
+Le gate opérateur du fix est intégralement vert :
+
+```text
+cargo fmt --all                                      PASS
+python3 scripts/audit_rust_workspace_rules.py        PASS / clean
+python3 scripts/audit_markdown_tables.py ...         PASS / clean
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-interface-lib                      PASS
+cargo test -p ksp-logging-lib --test ownership       PASS
+cargo test --workspace                               PASS
+cargo tree -p ksp-interface-lib --edges normal       Core-only confirmé
+cargo tree --duplicates                              inspecté
+```
+
+Le faux positif `tracing::` de `pre.005` est donc fermé sans changement de production ni de dépendances.
+
+## 2. Objectif
+
+Préparer le gate technique final de `0.2.13` sans rouvrir la surface fonctionnelle.
+
+Aucun nouveau type wire, aucun codec, aucun test métier, aucune dépendance et aucun comportement runtime ne sont ajoutés. Les canaris existants suffisent déjà à vérifier :
+
+```text
+ProgramAccountMeta
+ProgramInstruction
+bornes 255 / 10_240
+ordre et doublons
+Pubkey opaque
+Debug borné
+erreurs sans payload hostile
+consumer externe
+façade crate-root
+inventaire exact de production
+firewall source / manifest
+Core-only dependency graph
+```
+
+## 3. Décision de tranche
+
+`pre.006` reste un gate pur. Ajouter un nouveau test uniquement pour matérialiser le numéro de prerelease augmenterait la surface de changement sans renforcer une propriété non couverte. La tranche modifie donc seulement la version workspace, le plan, la validation et le présent delta.
+
+## 4. Version
+
+La prerelease non-fix synchronise la version Cargo conformément à `VER-ID-009` :
+
+```text
+0.2.13-pre.5.fix.1
+→
+0.2.13-pre.6
+```
+
+Commit attendu après validation :
+
+```text
+v0.2.13-pre.006
+```
+
+Aucun tag prerelease.
+
+## 5. Fichiers ajoutés
+
+```text
+deltas/0.2.13/pre.006.md
+```
+
+## 6. Fichiers modifiés
+
+```text
+Cargo.toml
+docs/plans/020-V0_2_13_INTERFACE_PLAN.md
+docs/validation/016-V0_2_13_INTERFACE.md
+```
+
+## 7. Fichiers supprimés
+
+Aucun.
+
+## 8. Surface explicitement inchangée
+
+```text
+crates/ksp-interface-lib/src/**
+crates/ksp-interface-lib/tests/**
+crates/ksp-interface-lib/unit_tests/**
+crates/ksp-interface-lib/Cargo.toml
+crates/ksp-interface-lib/README.md
+crates/ksp-interface-lib/USAGE.md
+CHANGELOG.md
+ROADMAP.md
+prompts/**
+architectures / règles
+```
+
+La réconciliation README/USAGE et des documents durables reste réservée à `pre.007`. La préparation du prompt suivant, du CHANGELOG et du ROADMAP reste réservée à `pre.008`.
+
+## 9. Validations exécutées à la génération
+
+```text
+python3 scripts/audit_rust_workspace_rules.py        PASS / clean
+python3 scripts/audit_markdown_tables.py ...         PASS / clean (162 tables, 119 files)
+contrôle du diff                                     PASS / 3 modifiés + 1 ajouté
+```
+
+Aucun `cargo` n'est disponible dans l'environnement de génération ; aucun PASS Cargo local n'est revendiqué.
+
+## 10. Gate opérateur
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.2.13
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test -p ksp-interface-lib
+cargo test -p ksp-logging-lib --test ownership
+cargo test --workspace
+cargo tree -p ksp-interface-lib --edges normal
+cargo tree --duplicates
+```
+
+## 11. Décisions prises
+
+- le scope fonctionnel `0.2.13` est figé ;
+- aucun codec générique n'est introduit ;
+- Interface reste passive et sans logging runtime ;
+- `ksp-core-lib` reste l'unique dépendance normale directe ;
+- aucun smoke réseau n'est pertinent pour cette crate wire pure ;
+- `pre.007` ne commence qu'après gate `pre.006` intégralement vert.
+
+## 12. Questions ouvertes
+
+Aucune question technique bloquante pour `0.2.13`. La seule étape suivante après gate vert est la réconciliation documentaire finale.

deltas/0.2.13/pre.007.md

@@ -0,0 +1,192 @@
+<!-- file: deltas/0.2.13/pre.007.md -->
+<!-- version: 1 -->
+
+# Delta `0.2.13-pre.007` — réconciliation documentaire finale Interface
+
+## 1. Base
+
+```text
+0.2.13-pre.006
+```
+
+Le gate opérateur de `pre.006`, exécuté le **28 août 2026**, est intégralement vert :
+
+```text
+cargo fmt --all                                      PASS
+audits Rust / export completeness / workspace        PASS
+audit Markdown                                       PASS — 162 tables / 119 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-interface-lib                      PASS
+cargo test -p ksp-logging-lib --test ownership       PASS
+cargo test --workspace                               PASS
+cargo tree -p ksp-interface-lib --edges normal       Core-only confirmé
+cargo tree --duplicates                              inspecté
+```
+
+La lane technique est donc fermée avant cette tranche.
+
+## 2. Objectif
+
+`pre.007` est exclusivement le couloir de réconciliation documentaire finale de `0.2.13`. Aucun fichier Rust, test, manifest de crate, dépendance, codec ou comportement n'est modifié.
+
+La tranche transforme les README/USAGE initiaux d'Interface en références durables et aligne plan, validation, séquence fonctionnelle et index documentaires sur la surface réellement validée.
+
+## 3. Version technique
+
+```text
+0.2.13-pre.6
+->
+0.2.13-pre.7
+```
+
+Le bump est mécanique pour une prerelease non-fix. Aucun autre manifest/version applicative n'est synchronisé artificiellement.
+
+## 4. Surface finale candidate documentée
+
+```text
+Pubkey                                          réexport Core
+ProgramAccountMeta                              passif, champs privés
+ProgramInstruction                              passif, champs privés
+MAX_PROGRAM_INSTRUCTION_ACCOUNTS                255
+MAX_PROGRAM_INSTRUCTION_DATA_LEN                10_240
+ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED   interface.program_instruction_limit_exceeded
+```
+
+Les propriétés réconciliées sont :
+
+```text
+accounts ordonnés                               préservés
+doublons accounts                               préservés
+accounts/data vides                             acceptés
+Program Pubkey hors registry                    accepté
+Vec accounts/data                               consommés sans reformatage interne
+Debug ProgramInstruction                       program_id/account_count/data_len uniquement
+erreur de borne                                 field/actual_len/maximum_len uniquement
+```
+
+Les limites `255` et `10_240` restent explicitement des bornes d'admission Interface et non une garantie complète de fit transaction Solana top-level.
+
+## 5. Dependency firewall final
+
+Le graphe normal confirmé par l'opérateur reste :
+
+```text
+ksp-interface-lib
+└── ksp-core-lib
+    └── solana-pubkey
+```
+
+La foundation ne dépend pas de :
+
+```text
+serde / serde_json
+borsh / wincode / bincode
+solana-instruction
+Transport / Config / Store / Wallet / Program
+reqwest / tonic / tokio / Tauri
+ksp-logging-lib / tracing runtime
+```
+
+L'absence de runtime logging est volontaire : la surface actuelle est purement passive.
+
+## 6. Références durables réconciliées
+
+```text
+crates/ksp-interface-lib/README.md
+crates/ksp-interface-lib/USAGE.md
+docs/000-README.md
+docs/plans/000-README.md
+docs/plans/002-FUNCTIONAL_RELEASE_SEQUENCE.md
+docs/plans/020-V0_2_13_INTERFACE_PLAN.md
+docs/validation/000-README.md
+docs/validation/016-V0_2_13_INTERFACE.md
+```
+
+Le README Interface fixe l'ownership, la surface publique, les bornes, le modèle d'erreur, le Debug borné, le graphe et les frontières de responsabilité.
+
+`USAGE.md` documente l'usage crate-root de `ProgramAccountMeta` et `ProgramInstruction`, les accessors, les limites et l'observation des erreurs sans accès aux modules privés.
+
+La séquence fonctionnelle enregistre le contenu effectivement livré par `0.2.13`, tout en maintenant :
+
+```text
+0.2.14   Program API foundation
+0.3.2+   wires génériques acquisition/CORE
+```
+
+## 7. Fichiers ajoutés/modifiés
+
+Ajouté :
+
+```text
+deltas/0.2.13/pre.007.md
+```
+
+Modifiés :
+
+```text
+Cargo.toml
+crates/ksp-interface-lib/README.md
+crates/ksp-interface-lib/USAGE.md
+docs/000-README.md
+docs/plans/000-README.md
+docs/plans/002-FUNCTIONAL_RELEASE_SEQUENCE.md
+docs/plans/020-V0_2_13_INTERFACE_PLAN.md
+docs/validation/000-README.md
+docs/validation/016-V0_2_13_INTERFACE.md
+```
+
+Aucun fichier supprimé.
+
+## 8. Surfaces volontairement inchangées
+
+Cette tranche ne touche pas :
+
+```text
+crates/ksp-interface-lib/src/**
+crates/ksp-interface-lib/tests/**
+crates/ksp-interface-lib/unit_tests/**
+crates/ksp-interface-lib/Cargo.toml
+docs/architecture/**
+CHANGELOG.md
+ROADMAP.md
+prompts/**
+```
+
+Les architectures existantes sont déjà compatibles avec la foundation réellement livrée et ne nécessitent aucune réécriture de clôture.
+
+## 9. Gate opérateur
+
+La tranche étant documentaire hors bump workspace, le gate demandé reste déterministe :
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.2.13
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test -p ksp-interface-lib
+cargo test --workspace
+```
+
+Aucun smoke réseau/live ni nouveau `cargo tree` n'est requis si l'overlay est appliqué exactement : ces preuves appartiennent à la lane technique fermée par `pre.006`.
+
+## 10. Suite
+
+Si le gate est vert :
+
+```text
+0.2.13-pre.008 — préparation minimale de publication
+```
+
+`pre.008` reste limitée à :
+
+```text
+Cargo.toml
+CHANGELOG.md
+ROADMAP.md
+prompts/019-V0_2_14_START_PROMPT.md
+deltas/0.2.13/pre.008.md
+```
+
+Aucun code, test, README/USAGE, plan, validation ou architecture ne doit être rouvert dans cette lane de publication minimale sauf défaut réel découvert au gate.

deltas/0.2.13/pre.008.md

@@ -0,0 +1,233 @@
+<!-- file: deltas/0.2.13/pre.008.md -->
+<!-- version: 1 -->
+
+# Delta `0.2.13-pre.008` — préparation minimale de publication
+
+## 1. Base
+
+```text
+0.2.13-pre.007
+```
+
+Le gate opérateur de `pre.007`, exécuté le **28 août 2026**, est intégralement vert :
+
+```text
+cargo fmt --all                                      PASS
+audits Rust / export completeness / workspace        PASS
+audit Markdown                                       PASS — 164 tables / 120 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-interface-lib                      PASS
+cargo test --workspace                               PASS
+```
+
+La réconciliation documentaire finale est donc fermée avant cette tranche.
+
+## 2. Objectif
+
+`pre.008` est exclusivement la lane minimale de préparation de publication de `0.2.13` imposée par `VER-LIFECYCLE-003` et `PROMPT_STRUCTURE.md`.
+
+Elle ne rouvre aucun code, test, README/USAGE, plan, validation, architecture, règle ou configuration.
+
+Elle :
+
+```text
+bump la prerelease Cargo vers pre.8
+prépare l'entrée CHANGELOG stable 0.2.13
+synchronise le statut global ROADMAP
+ajoute le prompt autonome 0.2.14
+trace cette préparation dans le delta
+```
+
+## 3. Version technique
+
+```text
+0.2.13-pre.7
+->
+0.2.13-pre.8
+```
+
+Le bump est mécanique pour une prerelease non-fix.
+
+## 4. Changelog / Roadmap
+
+`CHANGELOG.md` prépare l'entrée stable :
+
+```text
+0.2.13 — Interface / wire foundation — 2026-08-28
+```
+
+Le résumé conserve les faits de clôture réellement prouvés :
+
+```text
+ProgramAccountMeta + ProgramInstruction passifs
+255 account metas / 10_240 bytes
+Error/Debug sans payload hostile
+graphe Interface -> Core uniquement
+aucun serde/codec générique/solana-instruction/network/logging
+canaris public API / external consumer / dependency firewall / completeness
+pre.005-fix.001 limité au faux positif scanner Logging
+gates techniques et documentaires finaux verts
+```
+
+`ROADMAP.md` marque `0.2.13` comme terminé et maintient `0.2.14` comme prochaine release active.
+
+## 5. Prompt `0.2.14`
+
+Ajout :
+
+```text
+prompts/019-V0_2_14_START_PROMPT.md
+```
+
+Le prompt ouvre :
+
+```text
+0.2.14 — Program API foundation
+```
+
+exclusivement depuis :
+
+```text
+v0.2.13
+```
+
+Le démarrage exige explicitement **deux archives** :
+
+```text
+archive opérateur KSP v0.2.13
+khadhroony-bot3_v0.5.3-pre.005-fix010.zip
+```
+
+Ordre d'autorité fixé :
+
+```text
+v0.2.13 + règles/architecture KSP  autorité actuelle
+kbot3 historique                   audit/héritage uniquement
+```
+
+L'archive kbot3 est obligatoire pour le gate `pre.001` afin d'auditer réellement les anciens contrats :
+
+```text
+ks-lib/src/decoder/api/contracts.rs
+ks-lib/src/decoder/api/decoder.rs
+ks-lib/src/model/decoded.rs
+ks-lib/src/model/replay.rs
+ks-lib/src/model/solana.rs
+ks-lib/src/executor/api/execution.rs
+ks-lib/src/executor/api/executor.rs
+```
+
+Le prompt impose la matrice :
+
+```text
+REPRENDRE
+REDESSINER
+REPORTER
+REJETER
+```
+
+et protège notamment les frontières :
+
+```text
+Core       = Pubkey / Program IDs / Error
+Interface  = wire passif
+Program API = comportements/contracts extensibles
+Program Lib = implémentations officielles futures
+CORE futur = replay/context transaction/CPI/logs/return data/balance deltas
+Execution futur = policy/wallet/network/simulation/send/confirmation
+```
+
+La prévision souple initiale réserve distinctement audit/sizing, scaffold, contracts, hardening, gate technique, réconciliation documentaire et préparation de publication.
+
+## 6. Fichiers ajoutés/modifiés
+
+Ajoutés :
+
+```text
+prompts/019-V0_2_14_START_PROMPT.md
+deltas/0.2.13/pre.008.md
+```
+
+Modifiés :
+
+```text
+Cargo.toml
+CHANGELOG.md
+ROADMAP.md
+```
+
+Aucun fichier supprimé.
+
+## 7. Surfaces volontairement inchangées
+
+Cette tranche ne touche pas :
+
+```text
+README.md
+RULES.md
+.env.example
+config/**
+crates/**
+docs/**
+prompts/001..018
+```
+
+En particulier :
+
+```text
+crates/ksp-interface-lib/src/**
+crates/ksp-interface-lib/tests/**
+crates/ksp-interface-lib/unit_tests/**
+crates/ksp-interface-lib/README.md
+crates/ksp-interface-lib/USAGE.md
+docs/plans/020-V0_2_13_INTERFACE_PLAN.md
+docs/validation/016-V0_2_13_INTERFACE.md
+docs/architecture/**
+```
+
+## 8. Validations de préparation
+
+À exécuter dans l'environnement de préparation :
+
+```text
+audit Rust workspace
+audit Markdown
+contrôle exact du payload overlay
+contrôle des versions/file headers
+```
+
+Aucun résultat Cargo nouveau n'est revendiqué tant qu'il n'a pas été exécuté par l'opérateur sur `pre.008`.
+
+## 9. Gate opérateur
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.2.13
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test -p ksp-interface-lib
+cargo test --workspace
+```
+
+Aucun smoke réseau/live ni nouveau graphe Cargo n'est requis puisque cette lane ne modifie ni code ni dépendances.
+
+## 10. Suite
+
+Si le gate est vert :
+
+```text
+0.2.13-rel.001
+```
+
+La release finale effectue uniquement la mécanique de publication stable :
+
+```text
+workspace.package.version = 0.2.13
+delta rel.001
+commit de publication
+tag stable v0.2.13 après validation opérateur
+```
+
+`rel.001` ne doit contenir aucun rattrapage fonctionnel ou documentaire.

deltas/0.2.13/rel.001.md

@@ -0,0 +1,285 @@
+<!-- file: deltas/0.2.13/rel.001.md -->
+<!-- version: 1 -->
+
+# Delta `0.2.13-rel.001` — publication stable Interface / wire foundation
+
+## 1. Base requise
+
+Base directe attendue :
+
+```text
+0.2.13-pre.008
+workspace.package.version = 0.2.13-pre.8
+```
+
+Commit attendu pour cette livraison :
+
+```text
+v0.2.13-rel.001
+```
+
+Tag stable attendu après validation :
+
+```text
+v0.2.13
+```
+
+## 2. Responsabilité de `rel.001`
+
+Cette livraison effectue uniquement la mécanique de publication stable définie par le cycle KSP et `VER-LIFECYCLE-012`.
+
+Elle :
+
+- passe `workspace.package.version` de `0.2.13-pre.8` à `0.2.13` ;
+- ajoute le présent delta `rel.001` ;
+- ne corrige ni code, ni test, ni manifest de crate, ni README/USAGE, ni plan/validation, ni architecture/règle, ni prompt, ni `CHANGELOG.md`, ni `ROADMAP.md`.
+
+Tout défaut appartenant à un couloir antérieur doit renvoyer vers une prerelease appropriée ; `rel.001` n'est jamais une tranche de rattrapage.
+
+## 3. Preuves acquises avant publication
+
+Le gate opérateur du gate technique final `0.2.13-pre.006`, exécuté le **28 août 2026**, a validé :
+
+```text
+cargo fmt --all                                      PASS
+python3 scripts/audit_rust_workspace_rules.py        PASS
+  General Rust rule audit                            clean
+  Rust export completeness audit                     0 candidate(s)
+  KSP workspace Rust rule audit                      clean
+python3 scripts/audit_markdown_tables.py             PASS
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-interface-lib                      PASS
+cargo test -p ksp-logging-lib --test ownership       PASS
+cargo test --workspace                               PASS
+cargo tree -p ksp-interface-lib --edges normal       PASS / inspecté
+cargo tree --duplicates                              PASS / inspecté
+```
+
+Le graphe ciblé est resté strictement :
+
+```text
+ksp-interface-lib
+└── ksp-core-lib
+    └── solana-pubkey
+```
+
+Le gate opérateur de la réconciliation documentaire `0.2.13-pre.007`, exécuté le **28 août 2026**, a ensuite validé :
+
+```text
+cargo fmt --all                                      PASS
+python3 scripts/audit_rust_workspace_rules.py        PASS
+  General Rust rule audit                            clean
+  Rust export completeness audit                     0 candidate(s)
+  KSP workspace Rust rule audit                      clean
+python3 scripts/audit_markdown_tables.py             PASS — 164 tables / 120 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-interface-lib                      PASS
+cargo test --workspace                               PASS
+```
+
+Enfin, le gate opérateur de la préparation minimale de publication `0.2.13-pre.008`, exécuté le **28 août 2026**, a validé :
+
+```text
+cargo fmt --all                                      PASS
+python3 scripts/audit_rust_workspace_rules.py        PASS
+  General Rust rule audit                            clean
+  Rust export completeness audit                     0 candidate(s)
+  KSP workspace Rust rule audit                      clean
+python3 scripts/audit_markdown_tables.py             PASS — 164 tables / 122 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-interface-lib                      PASS
+cargo test --workspace                               PASS
+```
+
+`pre.008` n'a rouvert aucun code, test, README/USAGE, plan, validation ou architecture. Elle a préparé uniquement `Cargo.toml`, `CHANGELOG.md`, `ROADMAP.md`, le prompt suivant et son delta.
+
+## 4. Version stable publiée
+
+La version Cargo devient :
+
+```text
+workspace.package.version = 0.2.13
+```
+
+La release stable publiée est :
+
+```text
+0.2.13 — Interface / wire foundation
+```
+
+La surface stable comprend :
+
+```text
+Pubkey canonique réexporté depuis ksp-core-lib
+ProgramAccountMeta passif à champs privés
+ProgramInstruction passif à champs privés
+MAX_PROGRAM_INSTRUCTION_ACCOUNTS = 255
+MAX_PROGRAM_INSTRUCTION_DATA_LEN = 10_240
+ordre et doublons des account metas conservés
+Program Pubkeys opaques acceptés
+Error/Result Core pour les violations de bornes
+contextes d'erreur limités à field / actual_len / maximum_len
+Debug borné sans account material ni payload data
+six exports crate-root exacts
+quatre modules Rust de production exacts
+consumer externe canari
+firewall de dépendances canari
+release completeness canari
+```
+
+La dependency direction stable reste :
+
+```text
+ksp-interface-lib
+    -> ksp-core-lib
+        -> solana-pubkey
+```
+
+Sont volontairement absents de cette foundation :
+
+```text
+serde / serde_json
+borsh / wincode / bincode
+solana-instruction
+ksp-logging-lib / tracing runtime Interface
+reqwest / tonic / tokio / réseau
+Program API / Program Lib
+Store / Config / Wallet / Tauri
+```
+
+## 5. Fichiers ajoutés
+
+```text
+deltas/0.2.13/rel.001.md
+```
+
+## 6. Fichiers modifiés
+
+```text
+Cargo.toml
+```
+
+## 7. Fichiers supprimés
+
+```text
+aucun
+```
+
+## 8. Validations exécutées pour préparer le delta
+
+Contrôles statiques de l'overlay :
+
+```text
+Cargo.toml                         version 0.2.13
+Cargo.toml                         header version 312
+payload rel.001                    2 fichiers exactement
+CHANGELOG.md                       non rouvert
+ROADMAP.md                         non rouvert
+prompt 019                         non rouvert
+README/USAGE                       non rouverts
+plan / validation                  non rouverts
+code / tests                       non rouverts
+aucun fichier de rattrapage        présent
+```
+
+La préparation de l'archive ne rejoue aucun test Cargo dans l'environnement de génération. Le gate stable final reste à exécuter après application du delta et avant commit/tag.
+
+## 9. Validations non exécutées pendant la préparation
+
+Ne sont volontairement pas rejoués pour construire l'overlay :
+
+```text
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test -p ksp-interface-lib
+cargo test --workspace
+cargo tree -p ksp-interface-lib --edges normal
+cargo tree --duplicates
+smokes réseau/live
+```
+
+Le changement est limité au signal de version Cargo et au présent delta ; ces contrôles doivent uniquement être rejoués dans le gate stable défini ci-dessous lorsque requis.
+
+## 10. Validation stable après application
+
+Exécuter avant publication :
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.2.13
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test --workspace
+```
+
+Aucun smoke réseau/live ni nouveau graphe Cargo n'est requis : `rel.001` ne modifie ni runtime, ni code métier, ni dépendances.
+
+## 11. Décisions de publication
+
+Aucune nouvelle décision fonctionnelle ou architecturale n'est introduite par `rel.001`.
+
+La publication confirme uniquement que :
+
+1. `0.2.13-pre.008` est la candidate directe de la release stable ;
+2. les lanes technique, documentaire et préparation de publication sont closes ;
+3. `CHANGELOG.md`, `ROADMAP.md` et `prompts/019-V0_2_14_START_PROMPT.md` restent inchangés dans `rel.001` ;
+4. `ksp-interface-lib` reste une façade wire passive et Core-only ;
+5. `ksp-program-api` reste réservé à `0.2.14` et ne doit pas être rétro-injecté dans Interface ;
+6. l'archive historique `khadhroony-bot3_v0.5.3-pre.005-fix010.zip` reste obligatoire pour l'audit `0.2.14-pre.001`, mais n'est pas une autorité architecturale ;
+7. la prochaine release s'ouvre exclusivement depuis le tag stable `v0.2.13`.
+
+## 12. Questions ouvertes
+
+Aucune question ouverte ne bloque la publication de `0.2.13`.
+
+Les choix exacts concernant les contrats extensibles de `ksp-program-api`, les outcomes/proofs et l'héritage éventuel de concepts kbot3 appartiennent à l'audit/sizing de `0.2.14-pre.001` et ne constituent pas une dette bloquante de `0.2.13`.
+
+## 13. Commit et tag stable
+
+Après succès du gate stable :
+
+```text
+commit : v0.2.13-rel.001
+tag    : v0.2.13
+```
+
+Aucun tag intermédiaire `rel.001` n'est requis.
+
+Commandes Git typiques :
+
+```bash
+git add Cargo.toml deltas/0.2.13/rel.001.md
+git commit -m "v0.2.13-rel.001"
+git tag v0.2.13
+git push
+git push origin v0.2.13
+```
+
+Après le tag, produire l'archive opérateur stable KSP `v0.2.13` qui servira de première autorité à la session suivante.
+
+## 14. Suite
+
+Après publication du tag stable `v0.2.13`, ouvrir :
+
+```text
+0.2.14-pre.001 — Program API foundation
+```
+
+avec :
+
+```text
+prompts/019-V0_2_14_START_PROMPT.md
+```
+
+Le démarrage de `0.2.14-pre.001` exige les deux archives prévues par le prompt :
+
+```text
+archive opérateur KSP correspondant exactement à v0.2.13
+khadhroony-bot3_v0.5.3-pre.005-fix010.zip
+```
+
+L'audit kbot3 doit être réellement rejoué avant toute implémentation lourde de `ksp-program-api`.

deltas/0.2.14/pre.001.md

@@ -0,0 +1,201 @@
+<!-- file: deltas/0.2.14/pre.001.md -->
+<!-- version: 1 -->
+
+# Delta `0.2.14-pre.001` — audit Program API, héritage kbot3 et sizing
+
+## 1. Base requise
+
+Base directe attendue :
+
+```text
+v0.2.13
+workspace.package.version = 0.2.13
+```
+
+Sources obligatoires réellement disponibles à l'ouverture :
+
+```text
+archive opérateur khadhroony-solana-project-v0.2.13.zip
+archive historique khadhroony-bot3_v0.5.3-pre.005-fix010.zip
+```
+
+La metadata Git n'est pas incluse dans l'archive opérateur; le tag `v0.2.13` ne peut donc pas être interrogé localement. La version Cargo, `deltas/0.2.13/rel.001.md`, le prompt 019 et la surface Interface publiée concordent avec la base stable attendue.
+
+Commit attendu :
+
+```text
+v0.2.14-pre.001
+```
+
+## 2. Objectif
+
+Ouvrir `0.2.14 — Program API foundation` uniquement par le gate prévu :
+
+```text
+lecture règles + architecture
+audit Core + Interface stables
+audit historique kbot3 réel
+matrice d'héritage
+ownership
+API candidate
+threat/API model
+dependency graph
+stratégie de tests
+sizing et prévision souple recalibrée
+```
+
+Aucun scaffold `ksp-program-api`, decoder concret, registry runtime ou execution preparer n'est ajouté dans cette livraison.
+
+## 3. Décisions principales
+
+Le scope est réduit à une foundation instruction-only :
+
+```text
+ProgramInstructionRecognition
+ProgramInstructionDecodeOutcome<Decoded>
+ProgramInstructionDecoder avec associated output
+```
+
+Le candidat trait utilise :
+
+```text
+&ProgramInstruction
+&[Pubkey]
+ksp_core_lib::Result
+Send + Sync
+```
+
+L'output concret appartient à l'implémentation externe ou au futur `ksp-program-lib`.
+
+Sont explicitement reportés :
+
+```text
+payload canonique D3
+registry runtime hétérogène
+identity/version/coverage génériques
+diagnostics/proofs Program dédiés
+ProgramAccountDecoder / Event / ReturnData
+ProgramExecutionPreparer
+```
+
+Le design n'ajoute aucune dépendance externe et ne requiert donc aucun audit web/Solana supplémentaire en `pre.001`.
+
+## 4. Héritage kbot3
+
+L'archive historique a été réellement extraite et les contrats prioritaires ont été relus.
+
+Conclusions :
+
+```text
+REPRENDRE    séparation recognition/decode, trait instruction, Send+Sync, préparation pure conceptuelle
+REDESSINER   recognition, outcomes, execution capability/prepared plan
+REPORTER     identity/version, coverage, diagnostics, proofs, replay context, decoded event, registry, preparer
+REJETER      Program IDs/Pubkeys String, generic JSON payload, generic protocol monolith, executor, policy dans Program, ks-lib monolithique
+```
+
+Les decoders Solana Core, SPL Token et SPL Token-2022 confirment que l'ancien trait contextualisé dépendait réellement de signature/slot/path/transaction status/hash et JSON. Ces champs appartiennent aux futures couches CORE/DECODE et ne sont pas reconstruits dans Program API.
+
+## 5. Sizing recalibré
+
+Prévision active :
+
+```text
+pre.001 audit/design/sizing
+pre.002 scaffold + facade + dependency firewall
+pre.003 recognition + outcome
+pre.004 decoder trait + external implementation
+pre.005 adversarial/API hardening + completeness
+pre.006 gate technique final
+pre.007 réconciliation documentaire
+pre.008 préparation de publication minimale
+rel.001 publication stable
+```
+
+Registry, canonical payload et execution preparation ne sont plus des tranches de `0.2.14`.
+
+## 6. Fichiers ajoutés
+
+```text
+docs/plans/021-V0_2_14_PROGRAM_API_PLAN.md
+docs/validation/017-V0_2_14_PROGRAM_API.md
+deltas/0.2.14/pre.001.md
+```
+
+## 7. Fichiers modifiés
+
+```text
+Cargo.toml
+docs/plans/000-README.md
+docs/validation/000-README.md
+```
+
+## 8. Fichiers supprimés
+
+```text
+aucun
+```
+
+## 9. Version Cargo
+
+La prerelease non-fix synchronise :
+
+```text
+workspace.package.version = 0.2.14-pre.1
+```
+
+Aucune crate Program n'existe encore; le changement Cargo sert uniquement à identifier la tranche `pre.001` conformément au workflow.
+
+## 10. Validations exécutées pendant la préparation
+
+Le journal opérateur fourni à l'ouverture sur la base stable `v0.2.13` montre un baseline complet vert avant application de ce delta, notamment audits Rust/Markdown, `cargo check --workspace`, Clippy, tests ciblés des crates et `cargo test --workspace`. Cette preuve de base ne remplace pas le gate après application.
+
+Dans l'environnement de génération du présent overlay, les contrôles statiques suivants ont été réellement exécutés après modification :
+
+```text
+python3 scripts/audit_rust_workspace_rules.py
+  General Rust rule audit: clean
+  Rust export completeness audit: 0 candidate(s)
+  KSP workspace Rust rule audit: clean
+
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.2.14
+  Markdown table audit: clean (170 tables, 116 files)
+```
+
+`cargo` n'est pas installé dans l'environnement de génération utilisé pour préparer l'archive. Les commandes Cargo de validation après application n'ont donc pas été rejouées ici et ne sont pas déclarées PASS.
+
+## 11. Validations non requises dans cette tranche
+
+```text
+cargo test -p ksp-program-api     crate encore absente
+cargo tree -p ksp-program-api     crate encore absente
+smokes réseau/live                hors scope d'une API déclarative
+```
+
+## 12. Questions ouvertes
+
+Aucune question ne bloque le passage à `pre.002`.
+
+Les sujets suivants restent ouverts volontairement pour des releases ultérieures, pas pour compléter `0.2.14` :
+
+```text
+canonical DECODE/D3 payload
+runtime registry / conflict policy / erased composition
+processor identity/version durable
+coverage descriptors
+contextual proofs/diagnostics
+ProgramExecutionPreparer exact
+```
+
+## 13. Application et validation opérateur
+
+Après application de l'overlay :
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.2.14
+cargo check --workspace
+cargo clippy --workspace --all-targets
+```
+
+Aucun développement fonctionnel Program ne doit être ajouté à ce delta.

deltas/0.2.14/pre.002.md

@@ -0,0 +1,235 @@
+<!-- file: deltas/0.2.14/pre.002.md -->
+<!-- version: 1 -->
+
+# Delta `0.2.14-pre.002` — scaffold `ksp-program-api` + façade + firewall
+
+## 1. Base requise
+
+Cette tranche s'applique exclusivement sur :
+
+```text
+v0.2.13
++ 0.2.14-pre.001
+```
+
+Le gate opérateur fourni pour `pre.001` est vert :
+
+```text
+cargo fmt --all                                      PASS
+python3 scripts/audit_rust_workspace_rules.py        PASS
+python3 scripts/audit_markdown_tables.py ...         PASS — 170 tables / 116 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS sans warning
+```
+
+La version workspace passe de :
+
+```text
+0.2.14-pre.1
+```
+
+à :
+
+```text
+0.2.14-pre.2
+```
+
+Commit attendu :
+
+```text
+v0.2.14-pre.002
+```
+
+## 2. Objectif
+
+Matérialiser uniquement le scaffold de `ksp-program-api` et verrouiller sa façade/dependency firewall avant toute capability de décodage.
+
+La tranche ajoute :
+
+```text
+nouveau membre workspace ksp-program-api
+manifest Core + Interface uniquement
+façade crate-root explicite
+réexports Core retenus
+réexports Interface retenus
+README/USAGE initiaux
+canari public API
+canari dependency firewall
+```
+
+Elle n'ajoute pas :
+
+```text
+ProgramInstructionRecognition
+ProgramInstructionDecodeOutcome
+ProgramInstructionDecoder
+ProgramExecutionPreparer
+registry runtime
+identity/version/coverage
+payload canonique D3
+serde / JSON / Any
+codec
+runtime logging
+network / async runtime
+```
+
+## 3. Façade publique de scaffold
+
+Le crate-root réexporte explicitement :
+
+```text
+ksp-core-lib
+  Error
+  ErrorCode
+  ErrorContext
+  Result
+  Pubkey
+
+ksp-interface-lib
+  ProgramAccountMeta
+  ProgramInstruction
+```
+
+Ces réexports ne changent pas l'ownership des types. Ils fournissent la façade retenue par le plan afin qu'une future implémentation externe puisse dépendre du contrat Program sans reconstruire les types Core/Interface ni accéder à leurs modules privés.
+
+Aucun `pub mod` n'est exposé.
+
+## 4. Dependency firewall
+
+Le manifest membre possède exactement :
+
+```text
+[dependencies]
+ksp-core-lib
+ksp-interface-lib
+```
+
+Le canari `tests/dependency_boundary.rs` verrouille notamment l'absence de :
+
+```text
+ksp-program-lib
+ksp-logging-lib
+Transport / Config / Wallet / Store / Materializer
+serde / serde_json
+borsh / bincode / wincode
+solana-instruction
+reqwest / tokio / tonic / tauri / tracing
+```
+
+Il verrouille aussi l'absence de `src/constants.rs`, `TRACING_TARGET`, recognition/outcome/decoder/preparer et de module public pendant `pre.002`.
+
+## 5. Logging
+
+La crate reste une API déclarative sans comportement runtime. Aucun span/event n'est émis et aucun logging n'est nécessaire.
+
+Restent donc volontairement absents :
+
+```text
+ksp-logging-lib
+src/constants.rs
+TRACING_TARGET
+tracing direct
+```
+
+Si une future surface Program comportementale nécessite réellement une instrumentation, elle devra respecter les règles Logging KSP dans la crate qui possède ce comportement. Le scaffold API ne doit pas tirer un runtime logging par anticipation.
+
+## 6. Tests ajoutés
+
+`tests/public_api.rs` vérifie que la façade crate-root permet de construire `Pubkey`, `ProgramAccountMeta` et `ProgramInstruction`, et que les types d'erreur Core sont adressables sans module privé.
+
+`tests/dependency_boundary.rs` vérifie :
+
+```text
+dépendances normales exactes = Core + Interface
+absence des dépendances interdites
+absence de pub mod
+absence des contrats réservés à pre.003/pre.004
+absence de logging/runtime/codec
+```
+
+Aucun unit test métier n'est ajouté : la crate ne possède encore aucun comportement propre.
+
+## 7. Fichiers ajoutés
+
+```text
+crates/ksp-program-api/Cargo.toml
+crates/ksp-program-api/README.md
+crates/ksp-program-api/USAGE.md
+crates/ksp-program-api/src/lib.rs
+crates/ksp-program-api/tests/dependency_boundary.rs
+crates/ksp-program-api/tests/public_api.rs
+deltas/0.2.14/pre.002.md
+```
+
+## 8. Fichiers modifiés
+
+```text
+Cargo.toml
+docs/plans/021-V0_2_14_PROGRAM_API_PLAN.md
+docs/validation/017-V0_2_14_PROGRAM_API.md
+```
+
+## 9. Fichiers volontairement inchangés
+
+```text
+README.md
+RULES.md
+ROADMAP.md
+CHANGELOG.md
+docs/architecture/**
+docs/rules/**
+crates/ksp-core-lib/**
+crates/ksp-interface-lib/**
+crates/ksp-logging-lib/**
+crates/ksp-*-transport-lib/**
+crates/ksp-config-lib/**
+crates/ksp-wallet-lib/**
+crates/ksp-app-*/**
+prompts/**
+```
+
+Aucune architecture durable n'est rouverte : la direction `Program API -> Core + Interface` est déjà normative.
+
+## 10. Validations de génération
+
+Les audits Python sont rejoués sur l'arbre matérialisé avant livraison. L'environnement de génération ne fournit pas `cargo`, `rustc` ou `rustfmt`; aucun PASS Cargo nouveau n'est revendiqué localement.
+
+## 11. Gate opérateur attendu
+
+Après application :
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.2.14
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test -p ksp-program-api
+cargo test --workspace
+cargo tree -p ksp-program-api --edges normal
+cargo tree --duplicates
+```
+
+Le graphe normal doit confirmer :
+
+```text
+ksp-program-api
+├── ksp-core-lib
+└── ksp-interface-lib
+    └── ksp-core-lib
+```
+
+Une correction découverte par ce gate reste un `0.2.14-pre.002-fix.NNN` et n'avance pas `pre.003`.
+
+## 12. Suite
+
+Après gate vert, `pre.003` pourra matérialiser uniquement :
+
+```text
+ProgramInstructionRecognition
+ProgramInstructionDecodeOutcome<Decoded>
+invariants / Debug sûr associés
+unit/public canaries correspondants
+```
+
+`ProgramInstructionDecoder` et l'implémentation externe restent réservés à `pre.004`.

deltas/0.2.14/pre.003.md

@@ -0,0 +1,285 @@
+<!-- file: deltas/0.2.14/pre.003.md -->
+<!-- version: 1 -->
+
+# Delta `0.2.14-pre.003` — recognition + outcome minimal
+
+## 1. Base requise
+
+Cette tranche s'applique exclusivement sur :
+
+```text
+v0.2.13
++ 0.2.14-pre.001
++ 0.2.14-pre.002
+```
+
+Le gate opérateur fourni pour `pre.002` est intégralement vert :
+
+```text
+cargo fmt --all                                      PASS
+python3 scripts/audit_rust_workspace_rules.py        PASS
+python3 scripts/audit_markdown_tables.py ...         PASS — 170 tables / 119 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-program-api                        PASS
+cargo test --workspace                               PASS
+cargo tree -p ksp-program-api --edges normal         PASS — Core + Interface uniquement
+cargo tree --duplicates                              exécuté
+```
+
+La version workspace passe de :
+
+```text
+0.2.14-pre.2
+```
+
+à :
+
+```text
+0.2.14-pre.3
+```
+
+Commit attendu :
+
+```text
+v0.2.14-pre.003
+```
+
+## 2. Objectif
+
+Matérialiser uniquement le vocabulaire minimal nécessaire au futur decoder d'instruction :
+
+```text
+ProgramInstructionRecognition
+ProgramInstructionDecodeOutcome<Decoded>
+```
+
+La tranche ne crée toujours aucun comportement de décodage, registry ou contrat d'exécution.
+
+## 3. Recognition
+
+`ProgramInstructionRecognition` est public depuis le crate-root, `#[non_exhaustive]` et possède exactement :
+
+```text
+NoMatch
+ProgramMatch
+ExactMatch
+```
+
+Sémantique :
+
+```text
+NoMatch       l'implémentation ne revendique pas l'instruction
+ProgramMatch  le Program ou la famille correspond sans preuve instruction-locale exacte
+ExactMatch    l'implémentation affirme un match instruction-local exact
+```
+
+Aucun score, priorité, confidence, proof, surface code ou discriminator textuel n'est introduit.
+
+## 4. Decode outcome
+
+`ProgramInstructionDecodeOutcome<Decoded>` est public depuis le crate-root, `#[non_exhaustive]` et possède exactement :
+
+```text
+Decoded(Decoded)
+Unsupported
+```
+
+La valeur `Decoded` reste possédée par l'implémentation future. Il n'existe aucun `Any`, JSON, payload D3 ou enum centrale pour l'effacer.
+
+`Failed` est volontairement absent : le futur `ProgramInstructionDecoder::decode` retournera le `Result` Core. Une erreur réelle sera donc `Err`, sans deuxième canal de failure.
+
+`Ignored` reste absent : une capability de décodage doit produire une valeur, déclarer l'instruction connue mais unsupported, ou échouer.
+
+## 5. Debug sûr
+
+`ProgramInstructionRecognition` ne transporte aucun payload.
+
+`ProgramInstructionDecodeOutcome<Decoded>` possède une implémentation `Debug` manuelle :
+
+```text
+Decoded(_)    -> "Decoded"
+Unsupported   -> "Unsupported"
+```
+
+Cette implémentation :
+
+```text
+n'impose pas Decoded: Debug
+ne formate jamais la valeur Decoded
+ne copie aucun payload externe
+reste bornée à un nom de variante fixe
+```
+
+Le test unitaire utilise volontairement un type externe sans implémentation `Debug` pour prouver cette propriété à la compilation.
+
+## 6. Structure et façade
+
+Un seul module privé est ajouté :
+
+```text
+src/program_instruction_decode.rs
+```
+
+Le crate-root réexporte :
+
+```text
+ProgramInstructionRecognition
+ProgramInstructionDecodeOutcome
+```
+
+Aucun `pub mod` n'est introduit. Les réexports Core/Interface de `pre.002` restent inchangés.
+
+## 7. Dependency firewall
+
+Le manifest de `ksp-program-api` est inchangé :
+
+```text
+ksp-core-lib
+ksp-interface-lib
+```
+
+Restent interdits et absents :
+
+```text
+ksp-program-lib
+ksp-logging-lib
+Transport / Config / Wallet / Store / Materializer
+serde / serde_json
+borsh / bincode / wincode
+solana-instruction
+reqwest / tokio / tonic / tauri / tracing
+```
+
+Aucun `constants.rs` ou `TRACING_TARGET` n'est justifié pour ces types déclaratifs.
+
+## 8. Tests
+
+### Unit
+
+`unit_tests/program_instruction_decode.rs` vérifie :
+
+```text
+variants Recognition distincts
+Debug Recognition exact et payload-free
+Decoded conserve sa valeur
+Unsupported reste distinct
+Debug outcome sans Decoded: Debug
+Debug outcome ne rend pas la valeur externe
+```
+
+### Public API
+
+`tests/public_api.rs` ajoute un canari `pre.003` consommant uniquement :
+
+```text
+ksp_program_api::ProgramInstructionRecognition
+ksp_program_api::ProgramInstructionDecodeOutcome
+```
+
+### Boundary
+
+`tests/dependency_boundary.rs` est avancé pour autoriser uniquement recognition/outcome tout en maintenant l'absence de trait decoder, preparer, logging, serde et module public.
+
+## 9. Fichiers ajoutés
+
+```text
+crates/ksp-program-api/src/program_instruction_decode.rs
+crates/ksp-program-api/unit_tests/program_instruction_decode.rs
+deltas/0.2.14/pre.003.md
+```
+
+## 10. Fichiers modifiés
+
+```text
+Cargo.toml
+crates/ksp-program-api/README.md
+crates/ksp-program-api/USAGE.md
+crates/ksp-program-api/src/lib.rs
+crates/ksp-program-api/tests/dependency_boundary.rs
+crates/ksp-program-api/tests/public_api.rs
+docs/plans/021-V0_2_14_PROGRAM_API_PLAN.md
+docs/validation/017-V0_2_14_PROGRAM_API.md
+```
+
+## 11. Fichiers volontairement inchangés
+
+```text
+crates/ksp-program-api/Cargo.toml
+README.md
+RULES.md
+ROADMAP.md
+CHANGELOG.md
+docs/architecture/**
+docs/rules/**
+crates/ksp-core-lib/**
+crates/ksp-interface-lib/**
+crates/ksp-logging-lib/**
+crates/ksp-*-transport-lib/**
+crates/ksp-config-lib/**
+crates/ksp-wallet-lib/**
+crates/ksp-app-*/**
+prompts/**
+```
+
+## 12. Scope négatif maintenu
+
+Cette tranche n'introduit pas :
+
+```text
+ProgramInstructionDecoder
+program_ids(...)
+recognize(...) sur un trait
+decode(...) sur un trait
+associated output contract du trait
+external implementation fixture
+registry runtime
+identity/version/coverage
+ProgramAccountDecoder / Event / ReturnData
+payload canonique D3
+ProgramExecutionPreparer
+```
+
+Ces éléments ne doivent pas être anticipés dans un fix de `pre.003`.
+
+## 13. Gate opérateur attendu
+
+Après application :
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.2.14
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test -p ksp-program-api
+cargo test --workspace
+cargo tree -p ksp-program-api --edges normal
+cargo tree --duplicates
+```
+
+Le graphe normal doit rester :
+
+```text
+ksp-program-api
+├── ksp-core-lib
+└── ksp-interface-lib
+    └── ksp-core-lib
+```
+
+Une correction découverte par ce gate reste un `0.2.14-pre.003-fix.NNN` et n'avance pas `pre.004`.
+
+## 14. Suite
+
+Après gate vert, `pre.004` pourra introduire uniquement :
+
+```text
+ProgramInstructionDecoder: Send + Sync
+associated type Decoded
+program_ids(&self) -> &[Pubkey]
+recognize(&self, &ProgramInstruction)
+decode(&self, &ProgramInstruction) -> Result<ProgramInstructionDecodeOutcome<Self::Decoded>>
+external implementation canary avec Pubkey non enregistré
+```
+
+Registry runtime, payload canonique D3 et `ProgramExecutionPreparer` resteront hors scope.

deltas/0.2.14/pre.004.md

@@ -0,0 +1,264 @@
+<!-- file: deltas/0.2.14/pre.004.md -->
+<!-- version: 1 -->
+
+# Delta `0.2.14-pre.004` — decoder instruction-only + implémentation externe
+
+## 1. Base requise
+
+Cette tranche s'applique exclusivement sur :
+
+```text
+v0.2.13
++ 0.2.14-pre.001
++ 0.2.14-pre.002
++ 0.2.14-pre.003
+```
+
+Le gate opérateur fourni pour `pre.003` est intégralement vert :
+
+```text
+cargo fmt --all                                      PASS
+python3 scripts/audit_rust_workspace_rules.py        PASS
+python3 scripts/audit_markdown_tables.py ...         PASS — 171 tables / 120 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-program-api                        PASS — 8 tests Rust
+cargo test --workspace                               PASS
+cargo tree -p ksp-program-api --edges normal         PASS — Core + Interface uniquement
+cargo tree --duplicates                              exécuté
+```
+
+La version workspace passe de :
+
+```text
+0.2.14-pre.3
+```
+
+à :
+
+```text
+0.2.14-pre.4
+```
+
+Commit attendu :
+
+```text
+v0.2.14-pre.004
+```
+
+## 2. Objectif
+
+Matérialiser le contrat instruction-only ouvert retenu par `pre.001` :
+
+```text
+ProgramInstructionDecoder: Send + Sync
+associated type Decoded
+program_ids(&self) -> &[Pubkey]
+recognize(&self, &ProgramInstruction) -> ProgramInstructionRecognition
+decode(&self, &ProgramInstruction) -> Result<ProgramInstructionDecodeOutcome<Self::Decoded>>
+```
+
+Puis prouver qu'une crate consommatrice séparée peut l'implémenter avec son propre type décodé et un Program `Pubkey` absent du registry Core.
+
+## 3. Trait `ProgramInstructionDecoder`
+
+Le trait est défini dans un module privé et réexporté depuis le crate-root.
+
+Propriétés :
+
+```text
+Send + Sync                              requis sur l'implémentation
+Decoded                                  associated type sans bound imposé
+program_ids                              slice de Pubkey opaques
+recognize                                sélection instruction-local explicite
+decode                                   Result Core + outcome générique
+méthodes par défaut                      aucune
+registry / object composition            aucune promesse
+```
+
+`decode` est destiné à une instruction déjà sélectionnée via `program_ids` / `recognize`; il ne remplace pas le signal de reconnaissance.
+
+## 4. Open-world Program IDs
+
+Aucun `ProgramKind`, enum centrale ou validation contre le registry Core n'est introduit.
+
+Le canari externe utilise :
+
+```text
+Pubkey::new_from_array([0xE7; 32])
+```
+
+et vérifie explicitement :
+
+```text
+ksp_core_lib::find_program_pubkey(&external_program_id) == None
+```
+
+Cette consultation du registry est limitée au test négatif. `ksp-program-api` ne réexporte pas `find_program_pubkey` et le decoder externe n'a besoin que de la façade Program API pour son implémentation.
+
+## 5. Associated output externe
+
+Le test d'intégration définit hors du code de production :
+
+```text
+ExternalDecodedInstruction
+ExternalProgramDecoder
+```
+
+`ExternalProgramDecoder` implémente le trait et produit :
+
+```text
+ExactMatch    pour l'opcode supporté
+ProgramMatch  pour le Program connu avec opcode non supporté
+NoMatch       pour un autre Program
+Decoded(...)  pour l'opcode supporté
+Unsupported   pour le Program connu mais non supporté
+```
+
+Aucun `Any`, JSON, serde, codec ou enum centrale n'intervient dans le transport du type décodé.
+
+## 6. Dependency firewall
+
+Le manifest de `ksp-program-api` reste inchangé :
+
+```text
+ksp-core-lib
+ksp-interface-lib
+```
+
+Toujours absents :
+
+```text
+ksp-program-lib
+ksp-logging-lib
+Transport / Config / Wallet / Store / Materializer
+serde / serde_json
+borsh / bincode / wincode
+solana-instruction
+reqwest / tokio / tonic / tauri / tracing
+```
+
+## 7. Tests
+
+### Public API
+
+`tests/public_api.rs` prouve que le trait est implémentable depuis la façade crate-root sans module privé.
+
+### External implementation
+
+`tests/external_implementation.rs` est compilé par Cargo comme crate d'intégration séparée et vérifie :
+
+```text
+Send + Sync de l'implémentation
+associated output tiers
+Program Pubkey non enregistré
+program_ids
+NoMatch / ProgramMatch / ExactMatch
+Decoded / Unsupported
+absence de ksp-program-lib
+```
+
+### Boundary
+
+`tests/dependency_boundary.rs` avance l'inventaire autorisé jusqu'au trait et maintient l'absence de preparer, logging, serde, `Any` et module public.
+
+## 8. Fichiers ajoutés
+
+```text
+crates/ksp-program-api/src/program_instruction_decoder.rs
+crates/ksp-program-api/tests/external_implementation.rs
+deltas/0.2.14/pre.004.md
+```
+
+## 9. Fichiers modifiés
+
+```text
+Cargo.toml
+crates/ksp-program-api/README.md
+crates/ksp-program-api/USAGE.md
+crates/ksp-program-api/src/lib.rs
+crates/ksp-program-api/tests/dependency_boundary.rs
+crates/ksp-program-api/tests/public_api.rs
+docs/plans/021-V0_2_14_PROGRAM_API_PLAN.md
+docs/validation/017-V0_2_14_PROGRAM_API.md
+```
+
+## 10. Fichiers volontairement inchangés
+
+```text
+crates/ksp-program-api/Cargo.toml
+README.md
+RULES.md
+ROADMAP.md
+CHANGELOG.md
+docs/architecture/**
+docs/rules/**
+crates/ksp-core-lib/**
+crates/ksp-interface-lib/**
+crates/ksp-logging-lib/**
+crates/ksp-*-transport-lib/**
+crates/ksp-config-lib/**
+crates/ksp-wallet-lib/**
+crates/ksp-app-*/**
+prompts/**
+```
+
+## 11. Scope négatif maintenu
+
+Cette tranche n'introduit pas :
+
+```text
+runtime decoder registry
+Vec<Box<dyn ProgramInstructionDecoder>>
+object-safety promise
+identity/version/coverage descriptor
+priority/conflict policy
+ProgramAccountDecoder / Event / ReturnData
+payload canonique D3
+serde / JSON / Any
+proof/confidence contextuels
+ProgramExecutionPreparer
+ExecutionPolicy / Execution
+```
+
+## 12. Gate opérateur attendu
+
+Après application :
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.2.14
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test -p ksp-program-api
+cargo test --workspace
+cargo tree -p ksp-program-api --edges normal
+cargo tree --duplicates
+```
+
+Le graphe normal doit rester :
+
+```text
+ksp-program-api
+├── ksp-core-lib
+└── ksp-interface-lib
+    └── ksp-core-lib
+```
+
+Une correction découverte par ce gate reste un `0.2.14-pre.004-fix.NNN` et n'avance pas `pre.005`.
+
+## 13. Suite
+
+Après gate vert, `pre.005` doit rester une tranche de hardening/API completeness :
+
+```text
+bounds et sécurité Debug/error
+inventaire exact des exports publics
+absence de closed-world Program enum
+absence de serde/codec/logging/runtime
+scope négatif registry/preparer/payload D3
+test de complétude release
+```
+
+Aucun nouveau contrat fonctionnel n'est prévu dans `pre.005`.

deltas/0.2.14/pre.005-fix.001.md

@@ -0,0 +1,128 @@
+<!-- file: deltas/0.2.14/pre.005-fix.001.md -->
+<!-- version: 1 -->
+
+# Delta `0.2.14-pre.005-fix.001` — faux positif du canari logging
+
+## 1. Base requise
+
+Ce correctif s'applique exclusivement après :
+
+```text
+0.2.14-pre.005
+```
+
+Le gate opérateur du 28 août 2026 confirme :
+
+```text
+cargo fmt --all                                      PASS
+audit Rust général / exports / workspace             PASS
+audit Markdown                                       PASS — 173 tables / 122 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-program-api                        PASS — 18 tests Rust
+cargo test --workspace                               FAIL — ksp-logging-lib/tests/ownership.rs
+```
+
+L'unique échec observé est :
+
+```text
+crates/ksp-program-api/tests/release_completeness.rs bypasses ksp-logging-lib via tracing
+```
+
+## 2. Diagnostic
+
+`release_completeness.rs` doit vérifier que les sources de production Program API ne contiennent aucun chemin direct vers tracing. Le canari écrivait cependant lui-même ce chemin sous forme de chaîne littérale dans sa liste de motifs interdits.
+
+Le scanner workspace de `ksp-logging-lib/tests/ownership.rs` inspecte tous les fichiers Rust des autres crates, tests d'intégration compris, et recherche textuellement ce chemin. Il classait donc le motif de test lui-même comme un bypass alors qu'aucune dépendance, importation ou utilisation de tracing n'existe dans `ksp-program-api`.
+
+Le graphe normal observé reste :
+
+```text
+ksp-program-api
+├── ksp-core-lib
+└── ksp-interface-lib
+    └── ksp-core-lib
+```
+
+## 3. Correction
+
+Le canari conserve exactement la même interdiction sur les sources de production, mais construit désormais le motif recherché à partir de deux fragments. Son propre fichier ne contient donc plus le chemin direct littéral que le scanner logging doit légitimement refuser.
+
+Aucune règle logging n'est contournée ou affaiblie. Le scanner de `ksp-logging-lib` reste inchangé.
+
+Comme un fichier `.rs` est modifié, `VER-ID-007` et `VER-ID-010` imposent :
+
+```text
+workspace.package.version = 0.2.14-pre.5.fix.1
+```
+
+La livraison est :
+
+```text
+0.2.14-pre.005-fix.001
+```
+
+## 4. Fichiers modifiés
+
+```text
+Cargo.toml
+crates/ksp-program-api/tests/release_completeness.rs
+```
+
+## 5. Fichier ajouté
+
+```text
+deltas/0.2.14/pre.005-fix.001.md
+```
+
+## 6. Fichiers volontairement inchangés
+
+```text
+crates/ksp-program-api/src/**
+crates/ksp-program-api/Cargo.toml
+crates/ksp-program-api/tests/security_hardening.rs
+crates/ksp-logging-lib/**
+docs/plans/**
+docs/validation/**
+README.md
+ROADMAP.md
+CHANGELOG.md
+prompts/**
+```
+
+## 7. Scope négatif
+
+Ce fix n'ajoute aucun :
+
+```text
+contrat Program
+trait ou type public
+dependency
+logging runtime
+registry
+descriptor
+codec
+payload D3
+preparer
+```
+
+## 8. Validations de génération
+
+Les audits statiques disponibles dans l'environnement de génération doivent rester propres. Cargo n'y est pas disponible ; aucun PASS Cargo n'est revendiqué par ce delta.
+
+## 9. Gate opérateur attendu
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.2.14
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test -p ksp-program-api
+cargo test -p ksp-logging-lib --test ownership
+cargo test --workspace
+cargo tree -p ksp-program-api --edges normal
+cargo tree --duplicates
+```
+
+Si ce gate est vert, `pre.005` est considéré corrigé et `pre.006` peut ouvrir le gate technique final sans développement fonctionnel.

deltas/0.2.14/pre.005.md

@@ -0,0 +1,217 @@
+<!-- file: deltas/0.2.14/pre.005.md -->
+<!-- version: 1 -->
+
+# Delta `0.2.14-pre.005` — adversarial/API hardening + completeness
+
+## 1. Base requise
+
+Cette tranche s'applique exclusivement sur :
+
+```text
+v0.2.13
++ 0.2.14-pre.001
++ 0.2.14-pre.002
++ 0.2.14-pre.003
++ 0.2.14-pre.004
+```
+
+Le gate opérateur fourni pour `pre.004` est intégralement vert :
+
+```text
+cargo fmt --all                                      PASS
+python3 scripts/audit_rust_workspace_rules.py        PASS
+python3 scripts/audit_markdown_tables.py ...         PASS — 172 tables / 121 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-program-api                        PASS — 11 tests Rust
+cargo test --workspace                               PASS
+cargo tree -p ksp-program-api --edges normal         PASS — Core + Interface uniquement
+cargo tree --duplicates                              exécuté
+```
+
+La version workspace passe de :
+
+```text
+0.2.14-pre.4
+```
+
+à :
+
+```text
+0.2.14-pre.5
+```
+
+Commit attendu :
+
+```text
+v0.2.14-pre.005
+```
+
+## 2. Objectif
+
+Fermer la surface Program API déjà matérialisée sans ajouter de contrat fonctionnel :
+
+```text
+bounds et sécurité Debug/error
+inventaire exact des exports publics
+inventaire exact des modules de production
+absence de closed-world Program enum
+absence de registry/descriptors/preparer/payload D3
+absence de serde/codec/logging/runtime
+associated output sans bound implicite
+```
+
+## 3. Release completeness
+
+Le nouveau `tests/release_completeness.rs` verrouille :
+
+```text
+10 réexports crate-root exacts
+aucun pub mod
+3 fichiers Rust de production exacts
+2 enums publics exacts, tous deux non_exhaustive
+1 trait public exact : ProgramInstructionDecoder
+aucun ProgramKind / registry / autre famille decoder / preparer
+aucun Any / serde / codec / logging / réseau / IO runtime
+aucun dyn ProgramInstructionDecoder ou registry hétérogène anticipé
+```
+
+La surface publique reste donc ouverte par `Pubkey` et associated output, pas par un inventaire central fermé.
+
+## 4. Hardening adversarial
+
+Le nouveau `tests/security_hardening.rs` couvre trois propriétés.
+
+### Input Interface maximal
+
+Une instruction au maximum déjà admis par Interface :
+
+```text
+255 account metas
+10 240 bytes de data
+```
+
+traverse `ProgramInstructionDecoder::decode` par référence et le decoder observe les tailles exactes. Program API n'introduit aucun second bound ni nouveau type d'input.
+
+### Payload hostile et erreur Core
+
+Un decoder de test reçoit un payload contenant un marqueur hostile puis retourne un `ksp_program_api::Error` sûr. Le contrat Program API ne copie automatiquement ni l'instruction ni ses bytes dans l'erreur, son `Display` ou son `Debug`.
+
+L'hygiène des messages/contextes qu'une implémentation tierce construit volontairement reste la responsabilité de cette implémentation ; Program API n'ajoute aucun canal `Failed` parallèle susceptible de dupliquer le payload.
+
+### Associated output sans bound implicite
+
+Un second decoder de test utilise un output contenant `Rc<Cell<u8>>`. Ce type n'implémente donc pas `Send`/`Sync` et aucun `Debug`/`Clone` n'est dérivé. La compilation prouve que `type Decoded` reste sans bound implicite ; le `Debug` de l'outcome demeure `Decoded` sans rendre la valeur.
+
+## 5. Dependency/runtime firewall
+
+Le manifest de production reste inchangé :
+
+```text
+ksp-core-lib
+ksp-interface-lib
+```
+
+Les canaris refusent toujours :
+
+```text
+ksp-program-lib
+ksp-logging-lib
+Config / Transport / Wallet / Store / Materializer
+serde / serde_json / Any
+borsh / bincode / wincode
+reqwest / tokio / tonic / tauri / tracing
+std::env / std::fs / std::net dans la production Program API
+```
+
+## 6. Fichiers ajoutés
+
+```text
+crates/ksp-program-api/tests/release_completeness.rs
+crates/ksp-program-api/tests/security_hardening.rs
+deltas/0.2.14/pre.005.md
+```
+
+## 7. Fichiers modifiés
+
+```text
+Cargo.toml
+docs/plans/021-V0_2_14_PROGRAM_API_PLAN.md
+docs/validation/017-V0_2_14_PROGRAM_API.md
+```
+
+## 8. Fichiers volontairement inchangés
+
+```text
+crates/ksp-program-api/Cargo.toml
+crates/ksp-program-api/src/**
+crates/ksp-program-api/README.md
+crates/ksp-program-api/USAGE.md
+crates/ksp-program-api/tests/dependency_boundary.rs
+crates/ksp-program-api/tests/external_implementation.rs
+crates/ksp-program-api/tests/public_api.rs
+README.md
+RULES.md
+ROADMAP.md
+CHANGELOG.md
+docs/architecture/**
+docs/rules/**
+crates/ksp-core-lib/**
+crates/ksp-interface-lib/**
+crates/ksp-logging-lib/**
+crates/ksp-*-transport-lib/**
+crates/ksp-config-lib/**
+crates/ksp-wallet-lib/**
+crates/ksp-app-*/**
+prompts/**
+```
+
+## 9. Scope négatif maintenu
+
+Cette tranche n'introduit pas :
+
+```text
+nouveau type ou trait de production
+runtime decoder registry
+Vec<Box<dyn ProgramInstructionDecoder>>
+object-safety heterogeneous promise
+identity/version/coverage descriptor
+priority/conflict policy
+ProgramAccountDecoder / Event / ReturnData
+payload canonique D3
+serde / JSON / Any
+proof/confidence contextuels
+ProgramExecutionPreparer
+ExecutionPolicy / Execution
+```
+
+## 10. Gate opérateur attendu
+
+Après application :
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.2.14
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test -p ksp-program-api
+cargo test --workspace
+cargo tree -p ksp-program-api --edges normal
+cargo tree --duplicates
+```
+
+Le graphe normal doit rester :
+
+```text
+ksp-program-api
+├── ksp-core-lib
+└── ksp-interface-lib
+    └── ksp-core-lib
+```
+
+Une correction découverte par ce gate reste un `0.2.14-pre.005-fix.NNN` et n'avance pas `pre.006`.
+
+## 11. Suite
+
+Après gate vert, `pre.006` est un **gate technique final sans développement fonctionnel**. Il ne doit ajouter ni contrat, ni decoder officiel, ni registry, ni preparer.

deltas/0.2.14/pre.006.md

@@ -0,0 +1,147 @@
+<!-- file: deltas/0.2.14/pre.006.md -->
+<!-- version: 1 -->
+
+# Delta `0.2.14-pre.006` — gate technique final Program API
+
+## 1. Base requise
+
+Cette tranche s'applique exclusivement après `0.2.14-pre.005-fix.001`.
+
+Le gate opérateur du fix est intégralement vert :
+
+```text
+cargo fmt --all                                      PASS
+python3 scripts/audit_rust_workspace_rules.py        PASS / clean
+python3 scripts/audit_markdown_tables.py ...         PASS / clean — 173 tables / 123 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-program-api                        PASS — 18 tests Rust
+cargo test -p ksp-logging-lib --test ownership       PASS — 2/2
+cargo test --workspace                               PASS
+cargo tree -p ksp-program-api --edges normal         Core + Interface uniquement
+cargo tree --duplicates                              inspecté
+```
+
+Le faux positif logging de `pre.005` est donc fermé sans changement de production ni de dépendances.
+
+## 2. Objectif
+
+Préparer le gate technique final de `0.2.14` sans rouvrir la surface fonctionnelle.
+
+Aucun nouveau type, trait, test métier, registry, codec, runtime ou comportement n'est ajouté. Les canaris existants couvrent déjà :
+
+```text
+ProgramInstructionRecognition
+ProgramInstructionDecodeOutcome<Decoded>
+ProgramInstructionDecoder: Send + Sync
+associated Decoded sans bounds implicites
+extension externe avec Pubkey non enregistré
+NoMatch / ProgramMatch / ExactMatch
+Decoded / Unsupported / Err Core
+input Interface maximal 255 comptes / 10 240 bytes
+Debug outcome opaque
+façade crate-root exacte
+inventaire de production exact
+absence de ProgramKind / registry / preparer / payload D3
+absence de serde / JSON / Any / codecs
+absence de logging runtime / IO
+firewall Core + Interface
+```
+
+## 3. Décision de tranche
+
+`pre.006` reste un gate pur. Ajouter un nouveau test uniquement pour matérialiser le numéro de prerelease augmenterait la surface de changement sans renforcer une propriété non couverte.
+
+La tranche modifie donc seulement la version workspace, le plan, la validation et le présent delta.
+
+## 4. Version
+
+La prerelease non-fix synchronise la version Cargo conformément à `VER-ID-009` :
+
+```text
+0.2.14-pre.5.fix.1
+→
+0.2.14-pre.6
+```
+
+Commit attendu après validation :
+
+```text
+v0.2.14-pre.006
+```
+
+Aucun tag prerelease.
+
+## 5. Fichier ajouté
+
+```text
+deltas/0.2.14/pre.006.md
+```
+
+## 6. Fichiers modifiés
+
+```text
+Cargo.toml
+docs/plans/021-V0_2_14_PROGRAM_API_PLAN.md
+docs/validation/017-V0_2_14_PROGRAM_API.md
+```
+
+## 7. Fichiers supprimés
+
+Aucun.
+
+## 8. Surface explicitement inchangée
+
+```text
+crates/ksp-program-api/src/**
+crates/ksp-program-api/tests/**
+crates/ksp-program-api/unit_tests/**
+crates/ksp-program-api/Cargo.toml
+crates/ksp-program-api/README.md
+crates/ksp-program-api/USAGE.md
+CHANGELOG.md
+ROADMAP.md
+prompts/**
+architectures / règles
+```
+
+La réconciliation README/USAGE et des documents durables reste réservée à `pre.007`. La préparation du prompt suivant, du CHANGELOG et du ROADMAP reste réservée à `pre.008`.
+
+## 9. Validations exécutées à la génération
+
+```text
+python3 scripts/audit_rust_workspace_rules.py        PASS / clean
+python3 scripts/audit_markdown_tables.py ...         PASS / clean — 174 tables / 124 fichiers
+contrôle du diff                                     PASS / 3 modifiés + 1 ajouté
+```
+
+Aucun `cargo` n'est disponible dans l'environnement de génération ; aucun PASS Cargo local n'est revendiqué.
+
+## 10. Gate opérateur
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.2.14
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test -p ksp-program-api
+cargo test -p ksp-logging-lib --test ownership
+cargo test --workspace
+cargo tree -p ksp-program-api --edges normal
+cargo tree --duplicates
+```
+
+## 11. Décisions prises
+
+- le scope fonctionnel `0.2.14` est figé ;
+- aucun nouveau contrat Program n'est introduit ;
+- aucun registry, payload D3 ou `ProgramExecutionPreparer` n'est anticipé ;
+- Program API reste déclarative et sans logging runtime ;
+- Core + Interface restent les seules dépendances normales ;
+- aucun smoke réseau n'est pertinent pour cette crate instruction-only sans I/O ;
+- `pre.007` ne commence qu'après gate `pre.006` intégralement vert.
+
+## 12. Questions ouvertes
+
+Aucune question technique bloquante pour `0.2.14`. Après gate vert, la seule étape suivante est la réconciliation documentaire finale.

deltas/0.2.14/pre.007.md

@@ -0,0 +1,194 @@
+<!-- file: deltas/0.2.14/pre.007.md -->
+<!-- version: 1 -->
+
+# Delta `0.2.14-pre.007` — réconciliation documentaire finale Program API
+
+## 1. Base
+
+```text
+0.2.14-pre.006
+```
+
+Le gate opérateur de `pre.006`, exécuté le **28 août 2026**, est intégralement vert :
+
+```text
+cargo fmt --all                                      PASS
+audits Rust / export completeness / workspace        PASS
+audit Markdown                                       PASS — 174 tables / 124 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-program-api                        PASS — 18 tests Rust
+cargo test -p ksp-logging-lib --test ownership       PASS — 2/2
+cargo test --workspace                               PASS
+cargo tree -p ksp-program-api --edges normal         PASS — Core + Interface uniquement
+cargo tree --duplicates                              inspecté
+```
+
+La lane technique est donc fermée avant cette tranche.
+
+## 2. Objectif
+
+`pre.007` est exclusivement le couloir de réconciliation documentaire finale de `0.2.14` défini par `VER-LIFECYCLE-006`.
+
+Aucun fichier Rust, test, manifest de crate, dépendance, codec, runtime ou comportement n'est modifié. La tranche transforme les README/USAGE initiaux de Program API en références durables et aligne plan, validation, séquence fonctionnelle et index documentaires sur la surface réellement validée.
+
+## 3. Version technique
+
+```text
+0.2.14-pre.6
+->
+0.2.14-pre.7
+```
+
+Le bump est mécanique pour une prerelease non-fix. Aucun autre manifest/version applicative n'est synchronisé artificiellement.
+
+Commit/tag prerelease attendu :
+
+```text
+v0.2.14-pre.007
+```
+
+## 4. Surface finale candidate documentée
+
+```text
+ProgramInstructionRecognition
+  NoMatch / ProgramMatch / ExactMatch
+
+ProgramInstructionDecodeOutcome<Decoded>
+  Decoded(Decoded) / Unsupported
+
+ProgramInstructionDecoder: Send + Sync
+  type Decoded
+  program_ids(&self) -> &[Pubkey]
+  recognize(&self, &ProgramInstruction) -> ProgramInstructionRecognition
+  decode(&self, &ProgramInstruction) -> Result<ProgramInstructionDecodeOutcome<Self::Decoded>>
+```
+
+La façade crate-root conserve exactement 10 exports et trois modules/fichiers Rust de production. Le type `Decoded` reste possédé par l'implémentation et sans bound implicite `Debug/Clone/Send/Sync`.
+
+## 5. Open-world et hardening final
+
+Les références durables enregistrent les preuves acquises :
+
+```text
+Program Pubkey non enregistré                       accepté
+external implementation canary                      PASS
+input Interface maximal                             255 accounts + 10_240 bytes
+payload hostile                                     aucun echo automatique ajouté par Program API
+Debug outcome                                       valeur Decoded non rendue
+closed-world Program enum                            absent
+registry / descriptor / priority                     absents
+ProgramExecutionPreparer                             absent
+serde / JSON / Any / codecs                          absents
+logging / runtime / filesystem / environment / I/O  absents
+```
+
+Une implémentation tierce reste responsable du contenu des erreurs qu'elle produit explicitement ; Program API n'ajoute aucun canal parallèle ni copie automatique du payload hostile.
+
+## 6. Dependency firewall final
+
+Le graphe normal confirmé par l'opérateur reste :
+
+```text
+ksp-program-api
+├── ksp-core-lib
+│   └── solana-pubkey
+└── ksp-interface-lib
+    └── ksp-core-lib
+```
+
+Aucun `ksp-program-lib`, runtime, codec, serde, logging, Transport, Store, Wallet, Materializer, Config ou Tauri n'est introduit.
+
+## 7. Références durables réconciliées
+
+```text
+crates/ksp-program-api/README.md
+crates/ksp-program-api/USAGE.md
+docs/000-README.md
+docs/plans/000-README.md
+docs/plans/002-FUNCTIONAL_RELEASE_SEQUENCE.md
+docs/plans/021-V0_2_14_PROGRAM_API_PLAN.md
+docs/validation/000-README.md
+docs/validation/017-V0_2_14_PROGRAM_API.md
+```
+
+Le README fixe l'ownership, l'inventaire public exact, les semantics Recognition/Outcome, le trait externe, le hardening et les frontières. `USAGE.md` documente uniquement la façade crate-root, l'implémentation externe, la sélection explicite, le decode outcome, les erreurs et le Debug sûr.
+
+La séquence fonctionnelle enregistre le contenu effectivement livré par `0.2.14` et maintient les reports de `ksp-program-lib`, du payload D3, du registry runtime, des autres familles de decoder et du preparer jusqu'aux vertical slices réels.
+
+## 8. Fichiers ajoutés/modifiés
+
+Ajouté :
+
+```text
+deltas/0.2.14/pre.007.md
+```
+
+Modifiés :
+
+```text
+Cargo.toml
+crates/ksp-program-api/README.md
+crates/ksp-program-api/USAGE.md
+docs/000-README.md
+docs/plans/000-README.md
+docs/plans/002-FUNCTIONAL_RELEASE_SEQUENCE.md
+docs/plans/021-V0_2_14_PROGRAM_API_PLAN.md
+docs/validation/000-README.md
+docs/validation/017-V0_2_14_PROGRAM_API.md
+```
+
+Aucun fichier supprimé.
+
+## 9. Surfaces volontairement inchangées
+
+Cette tranche ne touche pas :
+
+```text
+crates/ksp-program-api/src/**
+crates/ksp-program-api/tests/**
+crates/ksp-program-api/Cargo.toml
+docs/architecture/**
+CHANGELOG.md
+ROADMAP.md
+prompts/**
+```
+
+L'architecture durable `006-WIRE_AND_PROGRAM.md` reste compatible avec la foundation réellement livrée : ses registry/preparer/autres familles sont des surfaces futures explicitement non matérialisées par `0.2.14`.
+
+## 10. Gate opérateur
+
+La tranche étant documentaire hors bump workspace, le gate demandé reste déterministe :
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.2.14
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test -p ksp-program-api
+cargo test -p ksp-logging-lib --test ownership
+cargo test --workspace
+```
+
+Aucun smoke réseau/live ni nouveau `cargo tree` n'est requis si l'overlay est appliqué exactement : ces preuves appartiennent à la lane technique fermée par `pre.006`.
+
+## 11. Suite
+
+Si le gate est vert :
+
+```text
+0.2.14-pre.008 — préparation minimale de publication
+```
+
+`pre.008` reste limitée à :
+
+```text
+Cargo.toml
+CHANGELOG.md
+ROADMAP.md
+prompt de démarrage 0.3.1
+deltas/0.2.14/pre.008.md
+```
+
+Aucun code, test, README/USAGE, plan, validation ou architecture ne doit être rouvert dans cette lane de publication minimale sauf défaut réel découvert au gate.

deltas/0.2.14/pre.008.md

@@ -0,0 +1,259 @@
+<!-- file: deltas/0.2.14/pre.008.md -->
+<!-- version: 1 -->
+
+# Delta `0.2.14-pre.008` — préparation de publication et prompt `0.3.1`
+
+## 1. Base requise
+
+```text
+0.2.14-pre.007
+workspace.package.version = 0.2.14-pre.7
+```
+
+Le gate opérateur de `pre.007` fourni le 28 août 2026 est intégralement vert :
+
+```text
+cargo fmt --all                                      PASS
+audit Rust général / exports / workspace             PASS
+audit Markdown                                       PASS — 175 tables / 125 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-program-api                        PASS — 18 tests Rust
+cargo test -p ksp-logging-lib --test ownership       PASS — 2 tests
+cargo test --workspace                               PASS
+```
+
+Les tests live/bench explicitement `ignored` restent volontairement hors de ce gate documentaire.
+
+`pre.007` a fermé la réconciliation durable de `ksp-program-api`, des indexes, du plan et de la validation sans rouvrir `CHANGELOG.md`, `ROADMAP.md` ni le prompt suivant.
+
+## 2. Objectif
+
+Dernière prerelease avant `rel.001`, strictement limitée à la préparation de publication :
+
+- ajouter l'entrée préparatoire stable `0.2.14` dans `CHANGELOG.md` ;
+- fermer `0.2.14` dans `ROADMAP.md` ;
+- produire `prompts/020-V0_3_1_START_PROMPT.md` ;
+- bump mécanique de la version workspace vers `0.2.14-pre.8` ;
+- ne rouvrir aucun code, test, README/USAGE, plan, validation, architecture ou règle normative.
+
+## 3. Version Cargo
+
+Publication non-fix de prerelease :
+
+```text
+0.2.14-pre.7
+-> 0.2.14-pre.8
+```
+
+Aucune crate membre ne redéfinit localement la version.
+
+## 4. Changelog / Roadmap
+
+`CHANGELOG.md` résume la surface stable candidate `0.2.14` :
+
+```text
+ksp-program-api instruction-only
+ProgramInstructionRecognition
+ProgramInstructionDecodeOutcome<Decoded>
+ProgramInstructionDecoder: Send + Sync
+10 exports crate-root / 3 modules de production
+implémentation externe avec Program Pubkey opaque
+Core + Interface uniquement
+aucun registry/runtime/serde/codec/Store/Materializer/Execution
+18 tests Program API au gate final
+```
+
+`ROADMAP.md` passe `0.2.14` à `[X]` et conserve `0.3.1` comme prochaine release ouverte :
+
+```text
+ksp-store-api + ksp-store-lib
+PostgreSQL de référence
+RAW seulement
+```
+
+## 5. Prompt `0.3.1`
+
+Le nouveau prompt a été confronté à :
+
+```text
+docs/rules/PROMPT_STRUCTURE.md
+docs/rules/VERSION_WORKFLOW.md
+docs/rules/FILE_CONTRACTS.md
+docs/rules/RULES_KSP.md
+docs/rules/RULES_DEPENDENCIES.md
+
+docs/architecture/002-LAYERS_AND_DEPENDENCIES.md
+docs/architecture/003-COMPONENT_CONTRACTS.md
+docs/architecture/004-COMPONENT_INVENTORY.md
+docs/architecture/005-DEPENDENCY_GRAPH.md
+docs/architecture/008-DATA_MATERIALIZATION_AND_STORE.md
+docs/architecture/009-ACQUISITION_WORKERS_AND_JOBS.md
+
+prompts/018-V0_2_13_START_PROMPT.md
+prompts/019-V0_2_14_START_PROMPT.md
+```
+
+L'archive historique suivante a également été reconnue pour déterminer si elle devait être requise dans la prochaine session :
+
+```text
+khadhroony-bot3_v0.5.3-pre.005-fix010.zip
+```
+
+Elle contient notamment :
+
+```text
+ks-store/**
+ks-store/migrations/postgres/**
+config/store.config.json
+config/schemas/store.config.schema.json
+ks-config/src/store.rs
+docs/architecture/STORAGE_ARCHITECTURE.md
+docs/guides/POSTGRES_STORAGE.md
+docs/plans/V0_5_3_KS_STORE_NORMALIZATION_PLAN.md
+```
+
+Conclusion : **l'archive est obligatoire pour `0.3.1-pre.001`**, mais seulement comme source historique à classer sous :
+
+```text
+REPRENDRE / REDESSINER / REPORTER / REJETER
+```
+
+L'ancien `ks-store` couvre RAW + CORE + DECODE/materialization et ne doit donc pas être recopié dans `0.3.1`.
+
+Le prompt protège explicitement les frontières :
+
+```text
+0.3.1  Store API + PostgreSQL RAW-only
+0.3.2  wires génériques Interface acquisition/CORE
+0.3.3  Job API + backfill RAW
+0.3.4  application backfill/inspection RAW
+plus tard CORE -> DECODE -> SPECIALIZED
+```
+
+Il impose en `pre.001` :
+
+```text
+audit base stable
+audit kbot3 Store
+audit PostgreSQL + dépendance Rust candidate avec sources actuelles
+inventaire RAW minimal
+ownership API/impl/composition
+dependency graph
+API backend-agnostic candidate
+schema PostgreSQL RAW candidate
+migration strategy
+threat model
+PostgreSQL integration strategy
+sizing + prévision souple recalibrée
+```
+
+## 6. Prévision souple intégrée au prompt
+
+La prévision initiale réserve distinctement :
+
+```text
+pre.001  audit/sizing
+pre.002  scaffold API + lib
+pre.003  contrats RAW
+pre.004  Store API + backend externe canari
+pre.005  PostgreSQL runtime foundation
+pre.006  schema/migrations RAW
+pre.007  writes/idempotence/atomicité
+pre.008  reads/pagination/notification si retenue
+pre.009  hardening/completeness
+pre.010  gate PostgreSQL réel
+pre.011  réconciliation documentaire
+pre.012  préparation de publication
+rel.001  publication stable
+```
+
+Cette prévision reste souple et doit être recalibrée par `0.3.1-pre.001` selon le scope RAW réel.
+
+## 7. Fichiers ajoutés
+
+```text
+prompts/020-V0_3_1_START_PROMPT.md
+deltas/0.2.14/pre.008.md
+```
+
+## 8. Fichiers modifiés
+
+```text
+Cargo.toml
+CHANGELOG.md
+ROADMAP.md
+```
+
+## 9. Fichiers supprimés
+
+Aucun.
+
+## 10. Surfaces explicitement non rouvertes
+
+```text
+README.md
+RULES.md
+.env.example
+config/**
+crates/**
+docs/**
+prompts/001..019
+```
+
+En particulier :
+
+```text
+crates/ksp-program-api/**
+docs/plans/021-V0_2_14_PROGRAM_API_PLAN.md
+docs/validation/017-V0_2_14_PROGRAM_API.md
+docs/architecture/**
+```
+
+## 11. Validations de préparation
+
+À exécuter sur l'arbre reconstruit :
+
+```text
+audit Rust workspace
+audit Markdown
+contrôle exact du payload overlay
+contrôle des versions/file headers
+contrôle qu'aucun fichier hors lane n'est modifié
+```
+
+Aucun résultat Cargo nouveau n'est revendiqué par la génération de ce delta.
+
+## 12. Gate opérateur
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.2.14
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test -p ksp-program-api
+cargo test -p ksp-logging-lib --test ownership
+cargo test --workspace
+```
+
+Aucun smoke réseau/live ni nouveau graphe Cargo n'est requis : cette lane ne modifie ni code, ni dépendance, ni runtime.
+
+## 13. Étape suivante
+
+Si le gate reste vert :
+
+```text
+0.2.14-rel.001
+```
+
+La publication stable devra être strictement mécanique :
+
+```text
+workspace.package.version = 0.2.14
+delta deltas/0.2.14/rel.001.md
+commit de publication
+tag stable v0.2.14 après validation opérateur
+```
+
+`rel.001` ne doit modifier ni `CHANGELOG.md`, ni `ROADMAP.md`, ni le prompt `0.3.1`, sauf anomalie découverte qui renverrait d'abord vers une prerelease dédiée conformément au workflow.

deltas/0.2.14/rel.001.md

@@ -0,0 +1,307 @@
+<!-- file: deltas/0.2.14/rel.001.md -->
+<!-- version: 1 -->
+
+# Delta `0.2.14-rel.001` — publication stable Program API foundation
+
+## 1. Base requise
+
+Base directe attendue :
+
+```text
+0.2.14-pre.008
+workspace.package.version = 0.2.14-pre.8
+```
+
+Commit attendu pour cette livraison :
+
+```text
+v0.2.14-rel.001
+```
+
+Tag stable attendu après validation :
+
+```text
+v0.2.14
+```
+
+## 2. Responsabilité de `rel.001`
+
+Cette livraison effectue uniquement la mécanique de publication stable définie par le cycle KSP et `VER-LIFECYCLE-012`.
+
+Elle :
+
+- passe `workspace.package.version` de `0.2.14-pre.8` à `0.2.14` ;
+- ajoute le présent delta `rel.001` ;
+- ne corrige ni code, ni test, ni manifest de crate, ni README/USAGE, ni plan/validation, ni architecture/règle, ni prompt, ni `CHANGELOG.md`, ni `ROADMAP.md`.
+
+Tout défaut appartenant à un couloir antérieur doit renvoyer vers une prerelease appropriée ; `rel.001` n'est jamais une tranche de rattrapage.
+
+## 3. Preuves acquises avant publication
+
+Le gate opérateur du gate technique final `0.2.14-pre.006`, exécuté le **28 août 2026**, a validé :
+
+```text
+cargo fmt --all                                      PASS
+python3 scripts/audit_rust_workspace_rules.py        PASS
+  General Rust rule audit                            clean
+  Rust export completeness audit                     0 candidate(s)
+  KSP workspace Rust rule audit                      clean
+python3 scripts/audit_markdown_tables.py             PASS — 174 tables / 124 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-program-api                        PASS — 18 tests Rust
+cargo test -p ksp-logging-lib --test ownership       PASS — 2 tests
+cargo test --workspace                               PASS
+cargo tree -p ksp-program-api --edges normal         PASS / inspecté
+cargo tree --duplicates                              PASS / inspecté
+```
+
+Le graphe normal ciblé est resté strictement :
+
+```text
+ksp-program-api
+├── ksp-core-lib
+│   └── solana-pubkey
+└── ksp-interface-lib
+    └── ksp-core-lib
+```
+
+Le gate opérateur de la réconciliation documentaire `0.2.14-pre.007`, exécuté le **28 août 2026**, a ensuite validé :
+
+```text
+cargo fmt --all                                      PASS
+python3 scripts/audit_rust_workspace_rules.py        PASS
+  General Rust rule audit                            clean
+  Rust export completeness audit                     0 candidate(s)
+  KSP workspace Rust rule audit                      clean
+python3 scripts/audit_markdown_tables.py             PASS — 175 tables / 125 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-program-api                        PASS — 18 tests Rust
+cargo test -p ksp-logging-lib --test ownership       PASS
+cargo test --workspace                               PASS
+```
+
+Enfin, le gate opérateur de la préparation minimale de publication `0.2.14-pre.008`, exécuté le **28 août 2026**, a validé :
+
+```text
+cargo fmt --all                                      PASS
+python3 scripts/audit_rust_workspace_rules.py        PASS
+  General Rust rule audit                            clean
+  Rust export completeness audit                     0 candidate(s)
+  KSP workspace Rust rule audit                      clean
+python3 scripts/audit_markdown_tables.py             PASS — 175 tables / 127 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-program-api                        PASS — 18 tests Rust
+cargo test -p ksp-logging-lib --test ownership       PASS
+cargo test --workspace                               PASS
+```
+
+`pre.008` n'a rouvert aucun code, test, README/USAGE, plan, validation ou architecture. Elle a préparé uniquement `Cargo.toml`, `CHANGELOG.md`, `ROADMAP.md`, le prompt suivant et son delta.
+
+Le seul incident technique de la release, le faux positif cross-crate du scanner Logging observé en `pre.005`, a été corrigé dans `pre.005-fix.001` sans changement fonctionnel ; son gate ciblé puis le workspace complet sont passés avant l'ouverture de `pre.006`.
+
+## 4. Version stable publiée
+
+La version Cargo devient :
+
+```text
+workspace.package.version = 0.2.14
+```
+
+La release stable publiée est :
+
+```text
+0.2.14 — Program API foundation
+```
+
+La surface stable comprend :
+
+```text
+ksp-program-api
+ProgramInstructionRecognition
+  NoMatch
+  ProgramMatch
+  ExactMatch
+ProgramInstructionDecodeOutcome<Decoded>
+  Decoded(Decoded)
+  Unsupported
+ProgramInstructionDecoder: Send + Sync
+  associated type Decoded
+  program_ids(&self) -> &[Pubkey]
+  recognize(&self, &ProgramInstruction) -> ProgramInstructionRecognition
+  decode(&self, &ProgramInstruction) -> Result<ProgramInstructionDecodeOutcome<Self::Decoded>>
+10 exports crate-root exacts
+3 modules/fichiers Rust de production exacts
+Program Pubkey opaque non enregistré supporté
+output Decoded possédé par l'implémentation externe
+aucun bound implicite Debug / Clone / Send / Sync sur Decoded
+```
+
+La dependency direction stable reste :
+
+```text
+ksp-program-api
+    -> ksp-core-lib
+    -> ksp-interface-lib
+        -> ksp-core-lib
+```
+
+Sont volontairement absents de cette foundation :
+
+```text
+ksp-program-lib
+registry runtime / dyn registry
+ProgramKind / descriptor global
+identity / version / coverage
+proofs / diagnostics de replay
+ProgramAccountDecoder
+ProgramEventDecoder
+ProgramReturnDataDecoder
+ProgramExecutionPreparer
+payload canonique D3
+serde / serde_json / Any
+borsh / wincode / bincode
+ksp-logging-lib / tracing runtime
+réseau / filesystem / environnement
+Store / Materializer / Wallet / Config / Tauri
+```
+
+`ProgramInstructionRecognition::ExactMatch` reste une assertion de reconnaissance du decoder et non une preuve indépendante. Les erreurs réelles restent transportées par le `Result` Core ; `Unsupported` représente un état de décodage non supporté et non une erreur artificielle.
+
+## 5. Fichiers ajoutés
+
+```text
+deltas/0.2.14/rel.001.md
+```
+
+## 6. Fichiers modifiés
+
+```text
+Cargo.toml
+```
+
+## 7. Fichiers supprimés
+
+```text
+aucun
+```
+
+## 8. Validations exécutées pour préparer le delta
+
+Contrôles statiques de l'overlay :
+
+```text
+Cargo.toml                         version 0.2.14
+Cargo.toml                         header version 322
+payload rel.001                    2 fichiers exactement
+CHANGELOG.md                       non rouvert
+ROADMAP.md                         non rouvert
+prompt 020                         non rouvert
+README/USAGE                       non rouverts
+plan / validation                  non rouverts
+code / tests                       non rouverts
+aucun fichier de rattrapage        présent
+```
+
+La préparation de l'archive ne rejoue aucun test Cargo dans l'environnement de génération. Le gate stable final reste à exécuter après application du delta et avant commit/tag.
+
+## 9. Validations non exécutées pendant la préparation
+
+Ne sont volontairement pas rejoués pour construire l'overlay :
+
+```text
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test -p ksp-program-api
+cargo test -p ksp-logging-lib --test ownership
+cargo test --workspace
+cargo tree -p ksp-program-api --edges normal
+cargo tree --duplicates
+smokes réseau/live
+```
+
+Le changement est limité au signal de version Cargo et au présent delta ; ces contrôles doivent uniquement être rejoués dans le gate stable défini ci-dessous lorsque requis.
+
+## 10. Validation stable après application
+
+Exécuter avant publication :
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.2.14
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test --workspace
+```
+
+Aucun smoke réseau/live ni nouveau graphe Cargo n'est requis : `rel.001` ne modifie ni runtime, ni code métier, ni dépendances.
+
+## 11. Décisions de publication
+
+Aucune nouvelle décision fonctionnelle ou architecturale n'est introduite par `rel.001`.
+
+La publication confirme uniquement que :
+
+1. `0.2.14-pre.008` est la candidate directe de la release stable ;
+2. les lanes technique, documentaire et préparation de publication sont closes ;
+3. `CHANGELOG.md`, `ROADMAP.md` et `prompts/020-V0_3_1_START_PROMPT.md` restent inchangés dans `rel.001` ;
+4. `ksp-program-api` reste instruction-only et sans runtime `ksp-program-lib` ;
+5. l'output typé reste possédé par l'implémentation et aucun registry hétérogène n'est promis par la foundation ;
+6. l'archive historique `khadhroony-bot3_v0.5.3-pre.005-fix010.zip` est obligatoire pour l'audit `0.3.1-pre.001`, mais reste une source historique non normative ;
+7. `0.3.1` ouvre `ksp-store-api` + `ksp-store-lib` avec PostgreSQL de référence et persistence RAW-only ;
+8. la prochaine release s'ouvre exclusivement depuis le tag stable `v0.2.14`.
+
+## 12. Questions ouvertes
+
+Aucune question ouverte ne bloque la publication de `0.2.14`.
+
+Les choix de registry/runtime Program, payload canonique D3, decoders account/event/return-data et préparation d'exécution restent explicitement reportés. Ils ne constituent pas une dette bloquante de cette foundation et ne doivent pas être réintroduits pendant la publication stable.
+
+Le détail du modèle RAW, de l'API backend-agnostic Store, du schéma PostgreSQL et des migrations appartient à l'audit/sizing de `0.3.1-pre.001`.
+
+## 13. Commit et tag stable
+
+Après succès du gate stable :
+
+```text
+commit : v0.2.14-rel.001
+tag    : v0.2.14
+```
+
+Aucun tag intermédiaire `rel.001` n'est requis.
+
+Commandes Git typiques :
+
+```bash
+git add Cargo.toml deltas/0.2.14/rel.001.md
+git commit -m "v0.2.14-rel.001"
+git tag v0.2.14
+git push
+git push origin v0.2.14
+```
+
+## 14. Suite
+
+Après publication du tag stable `v0.2.14`, ouvrir :
+
+```text
+0.3.1-pre.001 — Store RAW foundation
+```
+
+avec :
+
+```text
+prompts/020-V0_3_1_START_PROMPT.md
+```
+
+La session suivante doit recevoir :
+
+```text
+archive opérateur exacte de v0.2.14
+khadhroony-bot3_v0.5.3-pre.005-fix010.zip
+```
+
+`0.3.1-pre.001` reste une tranche d'audit/brainstorming/sizing avant toute implémentation lourde ; elle doit auditer l'ancien `ks-store` et PostgreSQL actuel, définir le minimum RAW réellement replayable, choisir le modèle API/backend extensible et préserver les reports `0.3.2`/`0.3.3`/`0.3.4` ainsi que CORE/DECODE/SPECIALIZED.

docs/plans/000-README.md

@@ -1,5 +1,5 @@
 <!-- file: docs/plans/000-README.md -->
-<!-- version: 63 -->
+<!-- version: 67 -->
 
 # Plans KSP
 
@@ -27,7 +27,9 @@ Un plan décrit le périmètre, les décisions déjà acquises, les questions ou
 - [`016-V0_2_9_YELLOWSTONE_GRPC_PLAN.md`](016-V0_2_9_YELLOWSTONE_GRPC_PLAN.md) — plan historique clôturé de la release stable `0.2.9 — Yellowstone gRPC standard/provider-neutral`, publiée par `rel.001`; il fixe le moteur N1, le standard N2, Config V3, le replay prudent et la validation PublicNode Mainnet/Testnet.
 - [`017-V0_2_10_ORBITFLARE_YELLOWSTONE_GRPC_PLAN.md`](017-V0_2_10_ORBITFLARE_YELLOWSTONE_GRPC_PLAN.md) — plan historique clôturé de la release stable `0.2.10 — OrbitFlare Yellowstone gRPC`; il conserve le Devnet gRPC gratuit, N1/N2 immuables, la License Key `x-token` et le smoke final `Slot + Ping`.
 - [`018-V0_2_11_OFFCHAIN_PRICE_TRANSPORT_PLAN.md`](018-V0_2_11_OFFCHAIN_PRICE_TRANSPORT_PLAN.md) — plan historique clôturé de `0.2.11 — Off-chain price transport`; SOL/USD V1, huit providers REST sans SDK, registry/availability/rate limits Off-chain et Config `std.offchain_transport`.
-- [`019-V0_2_12_SOL_PRICES_DESK_PLAN.md`](019-V0_2_12_SOL_PRICES_DESK_PLAN.md) — plan actif de `0.2.12 — SOL Prices Desk + intégration prix Wallet Desk`; il fixe le gabarit 1434/1435, le composite Config, les DTO/commands provider-neutral, le threat model et la trajectoire d’intégration Wallet.
+- [`019-V0_2_12_SOL_PRICES_DESK_PLAN.md`](019-V0_2_12_SOL_PRICES_DESK_PLAN.md) — plan historique clôturé de `0.2.12 — SOL Prices Desk + intégration prix Wallet Desk`; il conserve le gabarit 1434/1435, le composite Config, les DTO/commands provider-neutral, l’intégration Wallet minimale et les gates live/build finaux.
+- [`020-V0_2_13_INTERFACE_PLAN.md`](020-V0_2_13_INTERFACE_PLAN.md) — plan candidat réconcilié de `0.2.13 — Interface / wire foundation`; il fixe la surface finale `ProgramAccountMeta` + `ProgramInstruction`, les bornes `255` / `10_240`, le firewall Interface -> Core, les canaris de complétude/consumer externe et la frontière avec Program API/RAW/CORE.
+- [`021-V0_2_14_PROGRAM_API_PLAN.md`](021-V0_2_14_PROGRAM_API_PLAN.md) — plan candidat réconcilié de `0.2.14 — Program API foundation`; il fixe la façade instruction-only ouverte, les enums Recognition/Outcome, `ProgramInstructionDecoder`, l'output associé possédé par l'implémentation, le canari externe avec Program Pubkey non enregistré, le firewall Core/Interface et le report du payload canonique D3, du registry runtime et de `ProgramExecutionPreparer`.
 
 Le `pre.001` de chaque release fonctionnelle peut introduire son propre plan détaillé lorsque la release s'ouvre.
 

docs/plans/002-FUNCTIONAL_RELEASE_SEQUENCE.md

@@ -1,5 +1,5 @@
 <!-- file: docs/plans/002-FUNCTIONAL_RELEASE_SEQUENCE.md -->
-<!-- version: 93 -->
+<!-- version: 95 -->
 
 # Séquence des releases fonctionnelles KSP
 
@@ -520,15 +520,37 @@ Metadata HTTP/IPFS/Arweave viendra au premier besoin Metadata réel. SOL/EUR et
 
 ### `0.2.13` — Interface foundation
 
-`ksp-interface-lib` devient la façade wire officielle et expose une API publique wire utilisable par les implementations officielles et externes.
+`ksp-interface-lib` matérialise la première façade wire officielle KSP, volontairement passive et Program-facing. La surface candidate stable réexporte le `Pubkey` canonique de Core et expose `ProgramAccountMeta` ainsi que `ProgramInstruction` avec champs privés, accessors explicites et admission bornée à `255` account metas et `10_240` bytes de data. L'ordre et les doublons sont conservés, les Program Pubkeys opaques restent acceptés et les diagnostics ne recopient ni payload ni account material arbitraire.
 
-Aucune `ksp-interface-api` séparée n'est retenue pour l'instant.
+La dependency direction reste strictement `Interface -> Core`; aucun serde/codec générique, `solana-instruction`, runtime réseau ou logging n'est introduit. La façade crate-root est verrouillée par canaris public API, consumer externe, release completeness et dependency firewall. [`../../crates/ksp-interface-lib/README.md`](../../crates/ksp-interface-lib/README.md) et [`../../crates/ksp-interface-lib/USAGE.md`](../../crates/ksp-interface-lib/USAGE.md) deviennent les références durables de cette foundation. Le gate technique final `pre.006` est vert avant réconciliation documentaire.
+
+Aucune `ksp-interface-api` séparée n'est retenue pour l'instant. Les codecs/layouts spécifiques restent conditionnés à un vertical réel, tandis que les wires génériques d'acquisition/CORE restent reportés à `0.3.2+`.
 
 ### `0.2.14` — Program API foundation
 
-Introduire `ksp-program-api`, sans suffixe `-lib`, comme contrat d'extension Program.
+`ksp-program-api`, sans suffixe `-lib`, matérialise la première façade publique ouverte du domaine Program. La candidate reste volontairement instruction-only et dépend uniquement de Core + Interface.
 
-`ksp-program-lib` et les vertical slices réels arrivent plus tard.
+La surface commune est :
+
+```text
+ProgramInstructionRecognition
+  NoMatch / ProgramMatch / ExactMatch
+
+ProgramInstructionDecodeOutcome<Decoded>
+  Decoded(Decoded) / Unsupported
+
+ProgramInstructionDecoder: Send + Sync
+  type Decoded
+  program_ids(&self) -> &[Pubkey]
+  recognize(&self, &ProgramInstruction) -> ProgramInstructionRecognition
+  decode(&self, &ProgramInstruction) -> Result<ProgramInstructionDecodeOutcome<Self::Decoded>>
+```
+
+L'output concret reste possédé par l'implémentation et ne reçoit aucun bound implicite `Debug/Clone/Send/Sync`. Une crate externe peut implémenter le trait pour un Program Pubkey absent du registry Core ; aucun enum central de Programs, `Any`, JSON, registry runtime ou descriptor global n'est requis.
+
+Le hardening final verrouille l'inventaire crate-root exact, le passage d'une `ProgramInstruction` Interface maximale par référence, l'absence d'echo automatique de payload hostile, l'absence de default methods et le firewall `Program API -> Core + Interface`. `pre.006` ferme le gate technique avec audits/check/Clippy/tests workspace et graphe Cargo verts. [`../../crates/ksp-program-api/README.md`](../../crates/ksp-program-api/README.md) et [`../../crates/ksp-program-api/USAGE.md`](../../crates/ksp-program-api/USAGE.md) deviennent les références durables de la candidate.
+
+Restent explicitement reportés : `ksp-program-lib`, payload canonique D3, registry runtime, identity/version/coverage génériques, autres familles de decoder et `ProgramExecutionPreparer`. Ils seront introduits uniquement par les vertical slices qui démontreront leurs contrats réels.
 
 ## Architecture durable : RAW -> CORE -> DECODE -> SPECIALIZED
 

docs/plans/020-V0_2_13_INTERFACE_PLAN.md

@@ -0,0 +1,672 @@
+<!-- file: docs/plans/020-V0_2_13_INTERFACE_PLAN.md -->
+<!-- version: 8 -->
+
+# Plan `0.2.13` — Interface / wire foundation
+
+## 1. Base, autorité et nature de `pre.001`
+
+La release est ouverte exclusivement depuis l'archive opérateur `khadhroony-solana-project-v0.2.12.zip`, annoncée comme issue du tag stable `v0.2.12`. L'archive fournie ne contient pas de metadata `.git`; `git describe` n'est donc pas vérifiable dans le sandbox. Les marqueurs internes sont cohérents :
+
+```text
+workspace.package.version = 0.2.12
+prompts/018-V0_2_13_START_PROMPT.md présent
+deltas/0.2.12/rel.001.md présent
+crates/ksp-interface-lib absent
+crates/ksp-program-api absent
+```
+
+Le log opérateur joint à la reprise établit sur la base stable :
+
+```text
+cargo fmt --all                                      PASS
+python3 scripts/audit_rust_workspace_rules.py        PASS
+python3 scripts/audit_markdown_tables.py ...         PASS
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test --workspace                               PASS
+```
+
+Dans le sandbox de préparation, `cargo` n'est pas installé. Les audits Python de la base ont été rejoués et sont propres ; aucune commande Cargo non exécutée localement n'est déclarée PASS.
+
+`0.2.13-pre.001` reste un gate de lecture/audit/sizing. Il ne crée pas encore `ksp-interface-lib` et ne porte aucun code de l'ancien dépôt.
+
+## 2. Décision de scope
+
+Le minimum retenu pour `0.2.13` est une foundation **Program-facing passive** :
+
+```text
+ProgramAccountMeta
+ProgramInstruction
+bornes locales explicites sur account metas et data
+façade crate-root explicite
+Error/Result communs via ksp-core-lib
+aucun serde/codec générique ajouté sans protocole réel
+aucun comportement Program
+```
+
+Cette surface correspond à la forme fondamentale d'une invocation Solana : identité du programme, comptes ordonnés avec flags signer/writable, puis octets opaques. Elle prépare directement la future construction d'instructions de `ksp-program-api` sans absorber le modèle d'acquisition/replay qui appartient à `0.3.2+`.
+
+Le scope est volontairement réduit par rapport au forecast initial : `0.2.13` ne crée ni modèle canonique de transaction, ni replay input, ni logs/return-data génériques, ni CPI path, ni discriminant spécifique d'un programme tant qu'aucun vertical slice officiel ne le justifie.
+
+## 3. Règles et architecture confrontées à la base réelle
+
+Sources internes relues avant décision :
+
+```text
+RULES.md
+docs/000-README.md
+docs/rules/RULES_GENERAL.md
+docs/rules/RULES_KSP.md
+docs/rules/RULES_RUST.md
+docs/rules/RULES_DEPENDENCIES.md
+docs/rules/RULES_DOCUMENTATION.md
+docs/rules/FILE_CONTRACTS.md
+docs/rules/VERSION_WORKFLOW.md
+docs/rules/PROMPT_STRUCTURE.md
+docs/architecture/000-README.md
+docs/architecture/001-PROJECT_OBJECTIVES.md
+docs/architecture/002-LAYERS_AND_DEPENDENCIES.md
+docs/architecture/003-COMPONENT_CONTRACTS.md
+docs/architecture/004-COMPONENT_INVENTORY.md
+docs/architecture/005-DEPENDENCY_GRAPH.md
+docs/architecture/006-WIRE_AND_PROGRAM.md
+docs/architecture/007-EXECUTION_AND_POLICY.md
+docs/architecture/008-DATA_MATERIALIZATION_AND_STORE.md
+docs/architecture/009-ACQUISITION_WORKERS_AND_JOBS.md
+docs/architecture/010-APPS_SERVICES_SCENARIOS_AND_CONTROL.md
+docs/plans/002-FUNCTIONAL_RELEASE_SEQUENCE.md
+ROADMAP.md
+```
+
+Les contraintes structurantes sont confirmées :
+
+```text
+Core possède Pubkey, Error/Result et les Program IDs fondamentaux
+Interface possède/reexporte de manière contrôlée les contrats wire officiels
+Program API pourra dépendre de Core + Interface, jamais l'inverse
+Transport reste propriétaire des DTOs RPC/WS/gRPC et ne dépend pas d'Interface
+RAW/CORE n'exige aucun decoder Program
+0.3.2 étendra Interface pour les wires génériques d'acquisition/CORE
+pas de pub mod ; exports explicites depuis crate root
+pas de dépendance externe sans usage réel
+```
+
+## 4. Inventaire interne stable pertinent
+
+### 4.1 Core
+
+| Surface stable                   | Owner actuel   | Visibilité/consumer                           | Décision `0.2.13`                                                   |
+|----------------------------------|----------------|-----------------------------------------------|---------------------------------------------------------------------|
+| `Pubkey`                         | `ksp-core-lib` | public crate-root; consommé dans le workspace | réutiliser directement; aucun wrapper Interface                     |
+| `Error` / `ErrorCode` / `Result` | `ksp-core-lib` | public crate-root; contrat commun             | réutiliser pour les erreurs de bornes Interface                     |
+| 18 Program IDs + registry/filter | `ksp-core-lib` | public crate-root                             | laisser Core; Interface ne duplique pas les identités fondamentales |
+
+Les anciens wrappers textuels `MdProgramId` / `MdPubkey` de kbot3 n'apportent donc aucune valeur à la frontière KSP actuelle : un `Pubkey` typé existe déjà et doit rester l'identité fondamentale.
+
+### 4.2 Transport
+
+| Type/famille observée                                    | Owner actuel            | Sémantique réelle                                      | Décision          |
+|----------------------------------------------------------|-------------------------|--------------------------------------------------------|-------------------|
+| `SolanaEncodedTransaction`                               | On-chain Transport HTTP | projection JSON-RPC encodée                            | laisser Transport |
+| `SolanaConfirmedTransaction` / `SolanaBlockTransaction`  | On-chain Transport HTTP | réponse RPC avec états wire/metadata provider          | laisser Transport |
+| `SolanaWireField<T>`                                     | On-chain Transport HTTP | distinction omitted/null/value propre aux réponses RPC | laisser Transport |
+| `YellowstoneCompiledInstruction`                         | On-chain Transport gRPC | projection protobuf Yellowstone                        | laisser Transport |
+| `YellowstoneInnerInstructions` / `YellowstoneReturnData` | On-chain Transport gRPC | metadata d'update Geyser                               | laisser Transport |
+| `YellowstoneTransactionError` / `...Meta`                | On-chain Transport gRPC | sémantique provider/protobuf                           | laisser Transport |
+
+Ces DTOs peuvent ressembler à de futurs objets génériques, mais ils représentent aujourd'hui des formes de transport concrètes. `0.2.13` ne les déplace pas et ne force aucune dépendance `Transport -> Interface`.
+
+### 4.3 Dépendances workspace
+
+La base possède déjà notamment :
+
+```text
+solana-pubkey = ^4.3, default-features = false
+serde = ^1.0
+serde_json = ^1.0
+```
+
+Aucun `solana-instruction`, `borsh`, `wincode` ou crate d'interface Program n'est actuellement nécessaire au nouveau lot. Le graphe cible initial reste donc `Interface -> Core` uniquement.
+
+## 5. Audit d'héritage `khadhroony-bot3`
+
+Archive auditée : `khadhroony-bot3_v0.5.3-pre.005-fix010.zip`.
+
+Familles inspectées :
+
+```text
+ks-lib/src/model/solana.rs
+ks-lib/src/model/canonical_transaction.rs
+ks-lib/src/model/replay.rs
+ks-lib/src/decoder/api/contracts.rs
+ks-lib/src/executor/api/execution.rs
+familles decoder/* wire pertinentes comme points de comparaison uniquement
+```
+
+La matrice suivante porte sur les **concepts**, pas sur un portage de code :
+
+| Concept kbot3                                                | Verdict    | Cible KSP                        | Raison                                                                         |
+|--------------------------------------------------------------|------------|----------------------------------|--------------------------------------------------------------------------------|
+| account `{ pubkey, is_signer, is_writable }` ordonné         | REPRENDRE  | Interface `0.2.13`               | forme passive fondamentale d'une instruction; retirer le naming execution      |
+| instruction `{ program_id, accounts, data }`                 | REPRENDRE  | Interface `0.2.13`               | forme officielle minimale; retirer `operation_code` et toute policy            |
+| `MdPubkey` / `MdProgramId` en `String`                       | REDESSINER | Core                             | remplacer par `ksp_core_lib::Pubkey` déjà possédé par Core                     |
+| payload `Vec<u8>` non borné                                  | REDESSINER | Interface `0.2.13`               | ajouter admission bornée et Debug résumé                                       |
+| `DcApiInstructionDecoder` + recognition/outcomes/proofs      | REPORTER   | Program API `0.2.14`             | comportement de reconnaissance/decode, interdit dans Interface                 |
+| `MdInstructionPath` / parent / stack height                  | REPORTER   | Interface/CORE `0.3.2+`          | contexte d'acquisition/replay, pas nécessaire au builder Program minimal       |
+| logs / return data / tx failure / balance changes génériques | REPORTER   | Interface/CORE `0.3.2+`          | faits d'exécution/acquisition; ne pas préfigurer CORE                          |
+| `MdCanonicalTransaction` + canonical JSON/hash               | REPORTER   | CORE series après `0.3.2`        | modèle source-neutral large à redéfinir avec Store/CORE réels                  |
+| `MdCoreInstructionReplayInput`                               | REPORTER   | CORE/replay après RAW            | contrat transversal trop large, dépend de données encore non possédées         |
+| Prepared plan, signers, fee payer, policies                  | REPORTER   | Program API/Execution ultérieurs | responsabilité d'orchestration/exécution, pas wire passif                      |
+| monolithe `ks-lib` + générations d'API coexistantes          | REJETER    | aucune                           | ownership flou et couplage vertical/horizontal à ne pas reproduire             |
+| version/hash/JSON génériques par réflexe                     | REJETER    | aucune dans `0.2.13`             | aucun contrat sérialisé ne justifie une enveloppe/version générique maintenant |
+
+Anti-patterns à ne pas reproduire :
+
+```text
+wrappers Pubkey/ProgramId textuels alors qu'une primitive typée existe
+serde dérivé sur tous les contrats sans frontière de sérialisation réelle
+JSON Value comme échappatoire pour des formes structurelles futures
+contrat replay géant utilisé comme point de rencontre de toutes les couches
+operation_code/policy/signers mêlés à l'instruction passive
+traits decoder dans la même crate que les wires
+```
+
+## 6. Audit externe actuel — 27 août 2026
+
+L'audit externe est limité aux candidates réellement proches du lot retenu.
+
+| Candidate                    | Version actuelle observée | Contrat / graphe                                                                                                           | Décision                                                                       |
+|------------------------------|---------------------------|----------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------|
+| `solana-instruction`         | 3.5.0                     | `Instruction { program_id: Pubkey, accounts: Vec<AccountMeta>, data: Vec<u8> }`; `solana-pubkey ^4.3.0`; codecs optionnels | référence normative; pas de dépendance runtime `0.2.13`                        |
+| `solana-program` syscalls    | 4.1.0                     | `MAX_CPI_INSTRUCTION_ACCOUNTS = 255`; data `10 KiB`; account infos uniques `128`                                           | source normative des plafonds d'admission initiaux; pas de dépendance          |
+| `solana-loader-v3-interface` | 8.1.1                     | interface officielle; dépend `solana-instruction ^3.5.0` + `solana-pubkey ^4.3.0`; wincode optionnel                       | compatible en apparence mais hors premier lot; réauditer au vertical loader-v3 |
+
+Sources primaires/current utilisées :
+
+```text
+https://docs.rs/solana-instruction/3.5.0/solana_instruction/struct.Instruction.html
+https://docs.rs/solana-program/4.1.0/solana_program/syscalls/index.html
+https://docs.rs/solana-loader-v3-interface/8.1.1/solana_loader_v3_interface/
+https://github.com/anza-xyz/solana-sdk
+```
+
+`solana-instruction` 3.5.0 est Apache-2.0 via le workspace Anza. Ses features `serde`, `borsh`, `bincode` et `wincode` sont optionnelles. La génération `solana-pubkey ^4.3.0` est cohérente avec la base KSP.
+
+La dépendance directe n'est néanmoins pas retenue maintenant : ses champs `Vec` publics ne permettent pas à KSP de garantir les bornes d'admission sur sa propre API, et aucun interop runtime ne requiert encore de convertir vers ce type. `DEP-KSP-005` impose de ne pas ajouter une dépendance seulement pour refléter une forme triviale que KSP doit de toute façon borner.
+
+## 7. Matrice de frontières
+
+| Concept/type                                                | Owner cible    | 0.2.13 ? | 0.2.14 ?         | 0.3.2+ ?               | Autorité / raison                             |
+|-------------------------------------------------------------|----------------|----------|------------------|------------------------|-----------------------------------------------|
+| `Pubkey`                                                    | Core           | reuse    | reuse            | reuse                  | primitive fondamentale KSP déjà stable        |
+| Program IDs fondamentaux                                    | Core           | reuse    | reuse            | reuse                  | registry Core déjà stable                     |
+| account meta d'instruction                                  | Interface      | OUI      | consume          | reuse                  | forme Solana officielle passive               |
+| instruction Program passive                                 | Interface      | OUI      | consume          | reuse                  | minimum nécessaire au futur preparer          |
+| codec/discriminant Program spécifique                       | Interface      | NON      | si vertical réel | selon besoin           | aucun protocole concret dans foundation       |
+| instruction path / CPI ancestry                             | Interface/CORE | NON      | NON requis       | OUI                    | fait structurel d'acquisition/normalisation   |
+| logs / return data / tx failure / balance deltas génériques | Interface/CORE | NON      | NON requis       | OUI                    | surface RAW/CORE future                       |
+| DTOs RPC/WS/Yellowstone existants                           | Transport      | laisser  | laisser          | adapter plus tard      | projection transport concrète                 |
+| decoder identity/recognition/decode                         | Program API    | NON      | OUI audit        | consume CORE plus tard | comportement extensible Program               |
+| implémentations officielles de programmes                   | Program Lib    | NON      | NON              | plus tard              | vertical slices distincts                     |
+| RAW persistence                                             | Store          | NON      | NON              | `0.3.1`                | architecture RAW                              |
+| transaction/replay canonique générique                      | CORE           | NON      | NON              | après `0.3.2`          | doit être défini avec acquisition/Store réels |
+
+## 8. Surface API proposée
+
+Les noms restent ajustables jusqu'à implémentation, mais le contrat conceptuel est fermé :
+
+```rust
+pub use ksp_core_lib::Pubkey;
+
+pub const MAX_PROGRAM_INSTRUCTION_ACCOUNTS: usize = 255;
+pub const MAX_PROGRAM_INSTRUCTION_DATA_LEN: usize = 10 * 1024;
+
+pub struct ProgramAccountMeta { /* private */ }
+pub struct ProgramInstruction { /* private */ }
+```
+
+Façade visée :
+
+```text
+ProgramAccountMeta::writable(pubkey, is_signer)
+ProgramAccountMeta::readonly(pubkey, is_signer)
+ProgramAccountMeta::{pubkey,is_signer,is_writable}
+
+ProgramInstruction::try_new(program_id, accounts, data) -> ksp_core_lib::Result<Self>
+ProgramInstruction::{program_id,accounts,data}
+```
+
+Décisions de contrat :
+
+- `Pubkey` est consommé via Core ; aucun `ProgramId` wrapper supplémentaire ;
+- les comptes gardent exactement leur ordre et les doublons restent permis ;
+- comptes vides et data vide restent valides ;
+- aucune validation sémantique de Program ID, signer ou writable au-delà de la forme passive ;
+- les champs restent privés afin d'empêcher la construction d'un état hors bornes ;
+- la construction valide les longueurs sans cloner les vecteurs fournis ;
+- `Debug` de `ProgramInstruction` doit résumer `program_id`, `account_count` et `data_len`, sans imprimer tout le payload ;
+- pas de `serde::{Serialize, Deserialize}` dans la foundation : aucune persistence/IPC/wire sérialisée générique ne l'exige, et une dérive `Deserialize` naïve affaiblirait le gate de taille avant allocation ;
+- aucun `borsh`, `bincode` ou `wincode` générique : les codecs arrivent avec un vrai protocole Program dans Interface ;
+- pas de `format_version` artificiel tant qu'aucun format sérialisé KSP n'est défini.
+
+### 8.1 Bornes
+
+Les bornes initiales suivent les plafonds runtime Solana actuels :
+
+```text
+account metas d'une instruction <= 255
+data d'une instruction          <= 10_240 octets
+```
+
+Elles sont des **bornes d'admission Interface**, pas la promesse qu'une instruction seule rentrera dans toute transaction top-level. Les contraintes de message/transaction, comptes uniques, fee payer, blockhash et assembly appartiennent aux couches d'exécution ultérieures.
+
+### 8.2 Erreurs
+
+Le crate n'introduit pas un second type d'erreur. Les violations de borne utilisent `ksp_core_lib::Error/Result` avec codes Interface stables et contexte sûr limité aux longueurs/plafonds. Aucun octet du payload, compte arbitraire ou valeur externe n'est copié dans les diagnostics.
+
+Les codes exacts seront matérialisés avec la première primitive ; deux catégories suffisent conceptuellement :
+
+```text
+invalid_program_instruction
+program_instruction_limit_exceeded
+```
+
+Si la première implémentation démontre qu'une seule catégorie bornée suffit, ne pas créer la seconde par symétrie.
+
+## 9. Threat / robustness model
+
+| Risque                              | Décision                                             | Canari prévu                                         |
+|-------------------------------------|------------------------------------------------------|------------------------------------------------------|
+| data surdimensionnée                | refus avant stockage/copie supplémentaire            | `10_240` accepté; `10_241` refusé                    |
+| collection accounts surdimensionnée | refus déterministe                                   | `255` accepté; `256` refusé                          |
+| conversion/index overflow           | aucun cast étroit en foundation; comparer en `usize` | borne 255 + absence de casts unchecked               |
+| ordre/doublons accounts             | préserver exactement; ne pas dédupliquer             | ordre et doublon round-trip structurel via accessors |
+| wire malformé                       | N/A : aucun decoder/codec dans le lot                | aucun faux test; réouvrir au premier codec réel      |
+| enum/discriminant inconnu           | N/A : aucun discriminant dans le lot                 | réouvrir au vertical Program                         |
+| structures imbriquées pathologiques | N/A au-delà des deux Vec plates                      | bornes accounts/data suffisent pour ce lot           |
+| Debug volumineux                    | Debug résumé                                         | payload sentinelle absent du rendu Debug             |
+| allocation/copie excessive          | `try_new` consomme les Vec; pas de clone interne     | canari structure/API + revue source                  |
+| serde hostile                       | serde absent                                         | dependency/public API canary                         |
+| panic/unwrap/expect/?               | interdits par règles/lints                           | audit Rust + Clippy workspace                        |
+| Program ID inconnu                  | accepté : Pubkey opaque typé                         | canari avec Pubkey non registry                      |
+
+## 10. Dependency graph cible et firewall
+
+Cible de `0.2.13` :
+
+```text
+ksp-interface-lib
+    -> ksp-core-lib
+        -> solana-pubkey ^4.3
+```
+
+Interdictions :
+
+```text
+ksp-interface-lib -X-> ksp-program-api
+ksp-interface-lib -X-> ksp-program-lib
+ksp-interface-lib -X-> ksp-onchain-transport-lib
+ksp-interface-lib -X-> ksp-offchain-transport-lib
+ksp-interface-lib -X-> ksp-config-lib
+ksp-interface-lib -X-> ksp-store-*
+ksp-interface-lib -X-> ksp-wallet-lib
+ksp-interface-lib -X-> Tauri
+ksp-interface-lib -X-> reqwest/tonic/tokio/network
+```
+
+Aucun logging runtime n'est attendu dans une crate de contrats passifs. `ksp-logging-lib` reste absent sauf comportement futur démontré.
+
+Validation Cargo prévue dès le scaffold :
+
+```bash
+cargo tree -p ksp-interface-lib --edges normal
+cargo tree --duplicates
+```
+
+Comme aucune nouvelle dépendance externe n'est retenue au gate, aucun doublon codec/Solana ne doit être créé par `pre.002`.
+
+## 11. Stratégie de tests
+
+### Tests unitaires privés
+
+Sous `unit_tests/` rattachés aux modules privés :
+
+```text
+constructeurs account meta writable/readonly
+bornes comptes 255/256
+bornes data 10_240/10_241
+empty accounts/data acceptés
+ordre et doublons préservés
+Pubkey inconnu accepté
+Debug borné et payload absent
+erreurs sans bytes ni valeur hostile
+```
+
+### Tests d'intégration `tests/`
+
+```text
+public_api.rs             consommation uniquement via crate-root
+external_consumer.rs      petit consumer/crate canary si le pattern workspace le permet
+dependency_boundary.rs    manifest/source firewall et absence de serde/codecs/network
+release_completeness.rs   inventaire exact de la surface 0.2.13 retenue
+```
+
+Aucun smoke réseau n'est requis. Aucun round-trip binaire/JSON n'est inventé sans codec réel.
+
+## 12. Hors scope explicite
+
+```text
+ksp-program-api et tout trait decoder/preparer
+ksp-program-lib
+codec Program spécifique sans vertical réel
+system/token/loader/metaplex instruction families
+PDA seeds sans protocole concret
+transaction/message/compiled instruction génériques d'acquisition
+replay input / instruction path / CPI tree
+logs / return data / transaction errors / balances génériques
+Store/persistence
+Transport refactor ou dépendance vers Interface
+Wallet/Tauri/Config
+serde/JSON canonical/hash
+execution policy, signer selection, blockhash, simulation, send
+```
+
+## 13. Prévision souple recalibrée
+
+Le scope réduit permet de supprimer le second lot wire optionnel du forecast initial et de garder des tranches compatibles avec le budget KSP de 15–20 minutes de travail effectif.
+
+### pre.001 — audit + héritage + frontières + sizing
+
+**Statut : réalisé ; gate opérateur `pre.001` intégralement PASS.**
+
+Relire les règles/architectures, auditer Core/Transport, classer kbot3, auditer les candidates externes, retenir la surface instruction passive, fixer bornes/firewall/threat model/tests et créer plan/validation.
+
+### pre.002 — scaffold `ksp-interface-lib` + façade + firewall
+
+**Statut : réalisé ; gate opérateur intégralement PASS.**
+
+Créer la crate, l'ajouter au workspace, poser `lib.rs` avec exports explicites, lints, README/USAGE initiaux et canaris manifest/firewall. Dépendance normale unique : `ksp-core-lib`.
+
+### pre.003 — `ProgramAccountMeta` + bornes communes
+
+**Statut : réalisé ; fmt/audits/check/Clippy/tests Interface PASS, `cargo test --workspace` non fourni dans la preuve opérateur.**
+
+Matérialiser la primitive de compte ordonné, la borne accounts, le modèle d'erreur Interface minimal et les unit/public canaries associés. `ProgramInstruction` et la borne data restent réservés à `pre.004`.
+
+### pre.004 — `ProgramInstruction` passif borné
+
+**Statut : réalisé ; gate opérateur intégralement PASS.**
+
+Ajouter l'instruction `{ program_id, accounts, data }`, constructeur validé, accessors, Debug résumé et canaris d'ordre/doublons/limites. Aucun serde/codec ou comportement Program.
+
+### pre.005 — adversarial + consumer externe + API/dependency hardening
+
+**Statut : réalisé ; `pre.005-fix.001` validé, gate opérateur intégralement PASS.**
+
+Fermer les cas limites, surface crate-root, consumer externe, firewall source/manifest et graphes Cargo. Ne pas ajouter un second domaine wire opportuniste.
+
+### pre.006 — gate technique final
+
+**Statut : réalisé ; gate opérateur intégralement PASS.**
+
+Workspace complet, canaris de complétude/public API/dependencies, ownership Logging, `cargo tree` et audit final du scope exact sont validés. Aucun README/USAGE final ni préparation de publication n'a été mélangé à cette tranche.
+
+### pre.007 — réconciliation documentaire finale
+
+**Statut : réalisé ; gate opérateur documentaire à confirmer.**
+
+README/USAGE Interface, plan, validation, séquence fonctionnelle et index documentaires réellement affectés sont réconciliés. `CHANGELOG.md`, `ROADMAP.md` et le prompt suivant restent réservés à `pre.008`.
+
+### pre.008 — préparation de publication minimale
+
+**Statut : prévu**
+
+Préparer uniquement `prompts/019-V0_2_14_START_PROMPT.md`, `CHANGELOG.md`, `ROADMAP.md`, le bump prerelease mécanique et le delta. Aucun code/test/README/USAGE/plan/validation/architecture ne doit être rouvert.
+
+### rel.001 — publication stable
+
+**Statut : prévu**
+
+Passer `workspace.package.version` à `0.2.13`, rejouer le gate stable requis, publier le commit `v0.2.13-rel.001` puis le tag stable `v0.2.13`.
+
+## 14. Sizing et critère session
+
+| Tranche | Charge relative  | Motif du découpage               |
+|---------|------------------|----------------------------------|
+| pre.002 | petite           | scaffold + firewall uniquement   |
+| pre.003 | petite           | une primitive + bornes/erreurs   |
+| pre.004 | petite à moyenne | instruction + hardening local    |
+| pre.005 | moyenne          | consumer + adversarial + graphes |
+| pre.006 | gate             | aucun développement fonctionnel  |
+| pre.007 | documentation    | réconciliation séparée           |
+| pre.008 | publication prep | payload minimal séparé           |
+
+Le scope paraît clôturable dans une release/session sans sacrifier les lanes de sortie. Si `pre.003` ou `pre.004` révèle qu'une dépendance/codec spécifique est indispensable, le gate doit être rouvert avant d'étendre le scope ; il ne faut pas réactiver automatiquement `pre.005` comme second lot wire.
+
+## 15. Gate `0.2.13-pre.001`
+
+À la sortie préparée :
+
+```text
+base stable / prompt / rel                                 confirmé
+règles et architecture obligatoires                        relues
+Core / Transport                                            inventoriés
+archive kbot3                                               auditée
+matrice REPRENDRE/REDESSINER/REPORTER/REJETER              produite
+0.2.13 / 0.2.14 / 0.3.2                                    séparés
+premier lot                                                 ProgramAccountMeta + ProgramInstruction
+nouvelle dépendance externe                                 aucune
+threat model / tests / dependency graph                     définis
+plan + validation                                           créés
+implementation Program                                      absente
+```
+
+## 16. Gate attendu pour `pre.003`
+
+`pre.002` matérialise le scaffold strict décidé par le gate précédent :
+
+```text
+nouvelle crate membre ksp-interface-lib
+Cargo dépend uniquement de ksp-core-lib
+lints workspace hérités
+crate root explicite sans pub mod
+Pubkey réexporté depuis Core
+README/USAGE initiaux
+canari public API minimal
+canari dependency firewall
+aucun ProgramAccountMeta/ProgramInstruction fonctionnel
+aucun ksp-logging-lib / constants.rs / TRACING_TARGET
+```
+
+`pre.003` peut commencer après application du delta et gate opérateur vert. Sa responsabilité reste limitée à `ProgramAccountMeta`, aux bornes communes et au modèle d'erreur Interface minimal ; `ProgramInstruction` reste réservé à `pre.004`.
+
+## 17. État préparé `pre.003`
+
+`pre.003` matérialise uniquement la primitive de compte et les contrats nécessaires à la future admission de `ProgramInstruction` :
+
+```text
+ProgramAccountMeta                              présent
+fields                                         privés
+constructeurs                                  readonly / writable
+accessors                                      pubkey / is_signer / is_writable
+Pubkey                                         Core réutilisé
+MAX_PROGRAM_INSTRUCTION_ACCOUNTS               255
+ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED  interface.program_instruction_limit_exceeded
+ProgramInstruction                             absent par contrat
+MAX_PROGRAM_INSTRUCTION_DATA_LEN               absent jusqu'à pre.004
+serde / borsh / bincode / wincode              absents
+ksp-logging-lib / constants.rs / TRACING_TARGET absents
+```
+
+La constante `255` ferme le contrat public de borne accounts mais son enforcement `255/256` appartient au constructeur de `ProgramInstruction` de `pre.004`; `ProgramAccountMeta` représente un seul compte et n'invente donc pas une collection artificielle uniquement pour tester cette limite.
+
+Une seule catégorie d'erreur Interface est introduite. `invalid_program_instruction` reste absent : aucun invariant de forme distinct des limites n'est encore matérialisé et le créer par symétrie serait prématuré. Les futures erreurs de borne doivent utiliser `ksp_core_lib::Error/Result` et ne projeter que des longueurs/plafonds sûrs.
+
+La preuve opérateur fournie pour `pre.003` confirme fmt, audits, `cargo check`, Clippy, tests ciblés Interface et graphes Cargo. `cargo test --workspace` n'apparaît pas dans cette preuve ; il doit donc être rejoué au gate de `pre.004` avant de déclarer la continuité workspace complète.
+
+## 18. État préparé `pre.004`
+
+`pre.004` matérialise le second et dernier type du premier lot wire générique retenu :
+
+```text
+ProgramInstruction                              présent
+fields                                          privés
+program_id                                      Pubkey Core
+accounts                                        Vec<ProgramAccountMeta> consommé
+data                                            Vec<u8> opaque consommé
+MAX_PROGRAM_INSTRUCTION_ACCOUNTS                255
+MAX_PROGRAM_INSTRUCTION_DATA_LEN                10_240
+try_new                                         bornes accounts puis data
+accounts 255 / 256                              accepté / refusé
+data 10_240 / 10_241                            accepté / refusé
+accounts/data vides                             acceptés
+ordre/doublons                                  préservés
+Program Pubkey non registry                     accepté
+Debug                                           program_id/account_count/data_len uniquement
+serde / borsh / bincode / wincode               absents
+solana-instruction                              absent
+ksp-logging-lib / constants.rs / TRACING_TARGET absents
+```
+
+`ProgramInstruction::try_new` consomme les deux `Vec` fournis et compare leurs longueurs en `usize` avant stockage dans l'objet. La foundation n'ajoute aucun clone, cast étroit ou allocation de conversion. Une allocation éventuellement déjà réalisée par l'appelant pour construire le `Vec` reste naturellement hors du contrôle de l'API.
+
+Les deux limites utilisent le code commun `interface.program_instruction_limit_exceeded`. Le contexte d'erreur est volontairement réduit à `field`, `actual_len` et `maximum_len`; aucune donnée du payload ni aucun account arbitraire n'est recopié dans le diagnostic.
+
+Le `Debug` manuel n'imprime ni la collection accounts ni les octets `data`. Il expose uniquement l'identité publique du programme et les deux longueurs structurelles utiles au diagnostic.
+
+Le gate opérateur `pre.004` confirme désormais fmt, audits Rust/Markdown, `cargo check --workspace`, Clippy, tests ciblés Interface, `cargo test --workspace` et les deux graphes Cargo. Le passage à `pre.005` se concentre donc exclusivement sur les canaris adversariaux/consumer externe/API/dependency hardening, sans ajouter un second domaine wire.
+
+## 19. État préparé `pre.005`
+
+`pre.005` n'ajoute aucun code de production et ferme uniquement les preuves de consommation, complétude et résistance adversariale autour de la surface déjà matérialisée :
+
+```text
+production src modifié                              non
+nouveau domaine wire                               non
+external consumer integration crate                présent
+release completeness inventory                     présent
+façade crate-root exacte                           6 exports contrôlés
+modules de production                              4 fichiers exacts
+Vec accounts/data                                  transfert sans réallocation interne testé
+payload hostile dans erreur                        absent attendu
+account material hostile dans erreur               absent attendu
+narrowing casts                                    absents par source canary
+codec encode/decode générique                      absent par source canary
+manifest dependency                                ksp-core-lib uniquement
+source dependency firewall                         renforcé sur tous les modules production
+```
+
+Le canari `tests/external_consumer.rs` est volontairement un test d'intégration Rust séparé : Cargo le compile comme un crate consommateur externe de la bibliothèque. Il n'utilise que la façade `ksp_interface_lib::*` accessible depuis le crate-root et n'exige donc ni fixture workspace artificielle ni invocation Cargo imbriquée.
+
+`tests/release_completeness.rs` verrouille l'inventaire exact de la foundation `0.2.13` :
+
+```text
+ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED
+MAX_PROGRAM_INSTRUCTION_ACCOUNTS
+ProgramAccountMeta
+MAX_PROGRAM_INSTRUCTION_DATA_LEN
+ProgramInstruction
+Pubkey
+```
+
+Il verrouille également l'absence de `pub mod` et l'inventaire exact des quatre fichiers Rust de production. Ajouter une seconde famille wire dans `0.2.13` ferait ainsi échouer explicitement le canari de complétude au lieu d'élargir silencieusement la release.
+
+Le hardening unitaire vérifie enfin que les allocations des `Vec` admis sont transférées telles quelles dans `ProgramInstruction` et que les erreurs de dépassement ne recopient ni marqueur hostile de payload ni représentation arbitraire d'account meta. Ces tests renforcent le contrat de construction sans changer l'API publique.
+
+Après validation opérateur de `pre.005`, `pre.006` doit rester un gate technique pur sans nouveau développement fonctionnel.
+
+## 20. Correctif préparé `pre.005-fix.001`
+
+Le gate opérateur `pre.005` confirme les preuves suivantes :
+
+```text
+fmt / audits Rust / Markdown                     PASS
+cargo check --workspace                          PASS
+cargo clippy --workspace --all-targets           PASS
+cargo test -p ksp-interface-lib                  PASS
+external consumer                                PASS
+release completeness                             PASS
+hardening adversarial                            PASS
+cargo test --workspace                           FAIL cross-crate canary Logging
+cargo tree Interface                             Core-only confirmé
+```
+
+L'échec workspace ne révèle aucun bypass runtime d'Interface. Le scanner `ksp-logging-lib/tests/ownership.rs` recherche littéralement le chemin source `tracing::` dans tous les fichiers Rust des crates KSP, tests compris. Le firewall `ksp-interface-lib/tests/dependency_boundary.rs` contenait cette chaîne comme **valeur de test interdite**, ce qui déclenchait le scanner Logging sur le canari lui-même.
+
+Le fix conserve exactement la même interdiction mais construit le token de recherche sans faire apparaître le chemin littéral dans le source du test :
+
+```rust
+concat!("tracing", "::")
+```
+
+Le test Interface continue donc de refuser un chemin direct vers Tracing dans les sources de production, tandis que le scanner Logging ne confond plus la donnée du canari avec un usage runtime réel.
+
+Aucun fichier `src/` de production, aucune dépendance, aucune API publique, aucune borne et aucune décision de logging ne sont modifiés. La version technique devient `0.2.13-pre.5.fix.1` parce que le fix touche un test Rust.
+
+Le gate opérateur du fix est désormais intégralement vert : fmt, audits Rust/Markdown, `cargo check --workspace`, Clippy, tests Interface, canari Logging ciblé, `cargo test --workspace` et graphes Cargo sont tous validés/inspectés. Le faux positif est donc fermé sans élargissement du scope.
+
+## 21. Gate technique final validé `pre.006`
+
+`pre.006` n'a ajouté aucun code, aucun test et aucune dépendance. Le gate opérateur du **28 août 2026** ferme la lane technique avec les preuves suivantes :
+
+```text
+cargo fmt --all                                      PASS
+audits Rust / export completeness / workspace        PASS
+audit Markdown                                       PASS — 162 tables / 119 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-interface-lib                      PASS
+cargo test -p ksp-logging-lib --test ownership       PASS
+cargo test --workspace                               PASS
+cargo tree -p ksp-interface-lib --edges normal       Core-only confirmé
+cargo tree --duplicates                              inspecté
+```
+
+La surface technique finale avant documentation reste donc :
+
+```text
+workspace.package.version                         0.2.13-pre.6
+production Interface                              inchangée
+tests Interface                                   inchangés
+surface crate-root                                6 exports exacts
+modules production                                4 fichiers exacts
+dépendance normale Interface                      ksp-core-lib uniquement
+codec / serde / solana-instruction                absents
+ksp-logging-lib / tracing runtime Interface       absents
+network/live smoke                                N/A pour foundation wire pure
+```
+
+Le gate `pre.006` autorise la réconciliation documentaire finale sans réouverture technique.
+
+## 22. Réconciliation documentaire finale `pre.007`
+
+`pre.007` ne modifie aucun fichier Rust, test, manifest de crate, dépendance ou comportement. La version workspace avance mécaniquement à `0.2.13-pre.7` conformément au workflow de prerelease non-fix.
+
+Les références durables sont réconciliées autour du contrat réellement livré :
+
+```text
+crates/ksp-interface-lib/README.md
+crates/ksp-interface-lib/USAGE.md
+docs/000-README.md
+docs/plans/000-README.md
+docs/plans/002-FUNCTIONAL_RELEASE_SEQUENCE.md
+docs/plans/020-V0_2_13_INTERFACE_PLAN.md
+docs/validation/000-README.md
+docs/validation/016-V0_2_13_INTERFACE.md
+```
+
+Le README Interface fixe l'ownership, la surface crate-root exacte, les deux bornes d'admission, le modèle d'erreur sûr, le Debug borné, le graphe `Interface -> Core`, l'absence de codecs/logging/runtime et les frontières avec Program API/Transport/Store. `USAGE.md` documente les constructeurs `readonly`/`writable`, `ProgramInstruction::try_new`, les accessors, les bornes et l'observation des erreurs sans dépendre des modules privés.
+
+La séquence fonctionnelle précise désormais le contenu réellement livré par `0.2.13` et maintient les reports : Program API en `0.2.14`, wires génériques acquisition/CORE en `0.3.2+`. Les index plan/validation passent du statut actif au statut candidat réconcilié sans annoncer prématurément la release stable.
+
+La tranche ne touche explicitement pas :
+
+```text
+CHANGELOG.md
+ROADMAP.md
+prompts/019-V0_2_14_START_PROMPT.md
+architecture
+code/tests/manifests de crate
+```
+
+Ces surfaces appartiennent à `pre.008` pour la préparation minimale de publication, sauf découverte d'un défaut réel imposant une nouvelle tranche corrective.

docs/plans/021-V0_2_14_PROGRAM_API_PLAN.md

@@ -0,0 +1,801 @@
+<!-- file: docs/plans/021-V0_2_14_PROGRAM_API_PLAN.md -->
+<!-- version: 7 -->
+
+# Plan `0.2.14` — Program API foundation
+
+## 1. Statut et base
+
+Ce plan est établi par `0.2.14-pre.001` à partir de la release stable `v0.2.13` et de l'archive historique obligatoire `khadhroony-bot3_v0.5.3-pre.005-fix010.zip`.
+
+La base KSP vérifiée à l'ouverture est :
+
+```text
+workspace.package.version = 0.2.13
+deltas/0.2.13/rel.001.md présent
+prompts/019-V0_2_14_START_PROMPT.md présent
+ksp-interface-lib présent
+ksp-program-api absent
+ksp-program-lib absent
+```
+
+L'archive opérateur ne contient pas de metadata Git exploitable ; le tag `v0.2.13` ne peut donc pas être revérifié localement. L'identité stable est établie par la version Cargo, le delta `rel.001`, le prompt suivant et la surface Interface publiée. Aucun écart bloquant n'a été trouvé entre la base réelle et le prompt.
+
+Après application de `pre.001`, la version Cargo cible est :
+
+```text
+0.2.14-pre.1
+```
+
+## 2. Mission recalibrée
+
+`0.2.14` introduit `ksp-program-api` comme première crate publique extensible du domaine Program.
+
+Le scope est volontairement réduit à une **foundation de décodage d'instruction typée** :
+
+```text
+Core
+  -> Pubkey + Error/Result
+
+Interface
+  -> ProgramAccountMeta + ProgramInstruction
+
+Program API
+  -> reconnaissance instruction-local
+  -> outcome de décodage minimal
+  -> trait ProgramInstructionDecoder ouvert
+  -> output associé possédé par l'implémentation
+```
+
+La release ne crée pas :
+
+```text
+payload canonique D3
+registry runtime hétérogène
+identity/version runtime de decoder
+coverage matrix générique
+ProgramAccountDecoder
+ProgramEventDecoder
+ProgramReturnDataDecoder
+ProgramExecutionPreparer
+ksp-program-lib
+```
+
+Ce réduction évite de figer des contrats appartenant aux futures couches CORE, DECODE, Materializer, Store ou Execution.
+
+## 3. Sources KSP relues
+
+Le gate `pre.001` a relu les sources prescrites par le prompt :
+
+```text
+RULES.md
+docs/000-README.md
+docs/rules/RULES_GENERAL.md
+docs/rules/RULES_KSP.md
+docs/rules/RULES_RUST.md
+docs/rules/RULES_DEPENDENCIES.md
+docs/rules/RULES_DOCUMENTATION.md
+docs/rules/FILE_CONTRACTS.md
+docs/rules/VERSION_WORKFLOW.md
+docs/rules/PROMPT_STRUCTURE.md
+
+docs/architecture/000-README.md
+docs/architecture/001-PROJECT_OBJECTIVES.md
+docs/architecture/002-LAYERS_AND_DEPENDENCIES.md
+docs/architecture/003-COMPONENT_CONTRACTS.md
+docs/architecture/004-COMPONENT_INVENTORY.md
+docs/architecture/005-DEPENDENCY_GRAPH.md
+docs/architecture/006-WIRE_AND_PROGRAM.md
+docs/architecture/007-EXECUTION_AND_POLICY.md
+docs/architecture/008-DATA_MATERIALIZATION_AND_STORE.md
+docs/architecture/009-ACQUISITION_WORKERS_AND_JOBS.md
+docs/architecture/010-APPS_SERVICES_SCENARIOS_AND_CONTROL.md
+```
+
+Les règles structurantes sont notamment `KSP-NAME-002..003`, `KSP-API-001..007`, `KSP-PROGRAM-001..006`, `DEP-LOG-005`, `DEP-PROGRAM-001..004`, `DEP-WIRE-001..007`, `DEP-PIPE-007..008`, `DEP-SOL-001..006`, `DEP-PROTO-001..005` et `DEP-CARGO-001..007`.
+
+Le résultat normatif est sans ambiguïté : `ksp-program-api` porte des contrats ouverts, reste principalement déclaratif, doit être implémentable depuis une crate externe, utilise les types KSP existants et ne dépend pas des couches runtime supérieures.
+
+## 4. Inventaire KSP actuel
+
+### 4.1 Core
+
+`ksp-core-lib` fournit déjà :
+
+```text
+Error
+ErrorCode
+ErrorContext
+Result
+Pubkey
+registry KSP des Program IDs fondamentaux
+```
+
+Le registry Core est un inventaire KSP de Program IDs fondamentaux. Il n'est pas un registry d'implémentations Program et ne doit pas devenir un closed-world gate : un decoder externe peut viser un `Pubkey` absent de ce registry.
+
+### 4.2 Interface
+
+La surface stable `0.2.13` fournit exactement :
+
+```text
+Pubkey
+ProgramAccountMeta
+ProgramInstruction
+MAX_PROGRAM_INSTRUCTION_ACCOUNTS = 255
+MAX_PROGRAM_INSTRUCTION_DATA_LEN = 10_240
+ERROR_CODE_PROGRAM_INSTRUCTION_LIMIT_EXCEEDED
+```
+
+`ProgramInstruction` apporte déjà l'input minimal nécessaire au premier decoder :
+
+```text
+program_id: Pubkey
+accounts: ordered bounded ProgramAccountMeta slice
+data: bounded opaque byte slice
+```
+
+Les comptes conservent ordre et doublons. Les Program IDs sont opaques. Le `Debug` de l'instruction ne copie ni accounts ni bytes. Il n'existe donc aucune lacune Interface à combler pour le scope instruction-only.
+
+### 4.3 Pipeline futur
+
+La frontière durable reste :
+
+```text
+RAW -> CORE -> DECODE -> SPECIALIZED
+```
+
+`RAW -> CORE` ne dépend pas de Program. Le futur `CORE -> DECODE` pourra fournir une instruction Interface accompagnée d'un contexte CORE séparé lorsque ce contexte existera. `0.2.14` ne crée pas ce contexte par anticipation.
+
+## 5. Audit historique kbot3
+
+### 5.1 Fichiers audités
+
+Les contrats et usages historiques ont été relus dans :
+
+```text
+ks-lib/src/decoder/api/contracts.rs
+ks-lib/src/decoder/api/decoder.rs
+ks-lib/src/decoder/api.rs
+ks-lib/src/model/decoded.rs
+ks-lib/src/model/replay.rs
+ks-lib/src/model/solana.rs
+ks-lib/src/executor/api/execution.rs
+ks-lib/src/executor/api/executor.rs
+ks-lib/src/executor/api.rs
+ks-lib/src/decoder/solana/core/decoder.rs
+ks-lib/src/decoder/spl/token/decoder.rs
+ks-lib/src/decoder/spl/token_2022/decoder.rs
+ks-lib/src/lib.rs
+ks-lib/Cargo.toml
+ks-lib/README.md
+ks-lib/USAGE.md
+docs/OPERATION_NAMING_CONVENTION.md
+docs/IDL_AUDIT.md
+docs/IDL_TO_KB_LIB_NOMENCLATURE.md
+docs/architecture/ARCHITECTURE.md
+docs/architecture/CRATE_MAP.md
+docs/architecture/PIPELINE_ARCHITECTURE.md
+```
+
+Les trois decoders concrets montrent que l'ancien `DcApiInstructionDecoder` était réellement utilisé pour `identity`, `surfaces`, `coverage`, `recognize` puis `decode`, mais contre un input contextualisé contenant signature, slot, instruction path, transaction failure, hashes, logs, balance changes et JSON. Ces dépendances contextuelles ne sont pas présentes dans la foundation KSP actuelle.
+
+`ks-lib` regroupait en outre modèles, decoders, executors et materializers avec un graphe comprenant codecs, serde/JSON, interfaces Solana et tracing. Cette ownership monolithique est incompatible avec les frontières KSP actuelles.
+
+### 5.2 Matrice d'héritage
+
+| Concept historique                | Observation réelle kbot3                                             | Décision   | Application KSP `0.2.14`                                                                                          |
+|-----------------------------------|----------------------------------------------------------------------|------------|-------------------------------------------------------------------------------------------------------------------|
+| `DcApiDecoderIdentity`            | nom et version alloués en `String`                                   | REPORTER   | aucune identity runtime tant qu'aucun registry ou replay persistant ne la consomme                                |
+| `DcApiDecoderSurface`             | Program ID textuel, surface code et priorité                         | REDESSINER | Program IDs typés; surface code et priorité reportés avec le registry                                             |
+| `DcApiDecoderCoverageDeclaration` | matrice sérialisable instruction/event/discriminator                 | REPORTER   | couverture machine-readable reportée au premier besoin d'inventaire/runtime                                       |
+| `DcApiDecoderRecognition`         | compatible, exact, priority et codes textuels                        | REPRENDRE  | reconnaissance conservée mais réduite à trois niveaux sans priorité ni strings                                    |
+| `DcApiDecoderOutcomeStatus`       | `Decoded`, `Ignored`, `Unsupported`, `Failed`                        | REDESSINER | `Decoded(T)` ou `Unsupported`; `Failed` devient `Err`, `Ignored` n'est pas justifié pour un decoder d'instruction |
+| `DcApiDecoderDiagnostic`          | code, message et retriable sérialisables                             | REPORTER   | `ksp_core_lib::Error/Result` suffit à la foundation; diagnostic Program dédié reporté                             |
+| `DcApiDecoderProof`               | preuve et confidence, dont logs/balances/heuristique                 | REPORTER   | aucun proof sans contexte CORE réel; l'exactitude de recognition reste une assertion du decoder                   |
+| `DcApiInstructionDecoder`         | trait `Send + Sync` avec identity, coverage, recognize, decode       | REPRENDRE  | trait instruction-only conservé, input remplacé par `ProgramInstruction`, output devient associated type          |
+| `DcApiProtocolDecoder`            | trait générique parallèle avec support `No/Maybe/Yes`                | REJETER    | pas de second trait monolithique; les capabilities restent séparées par trait                                     |
+| `MdCoreInstructionReplayInput`    | input JSON riche de transaction/CPI/logs/balances                    | REPORTER   | futur CORE; aucune reconstruction en `0.2.14`                                                                     |
+| `MdDecodedProtocolEvent`          | identité événement liée à signature, slot, path et strings protocole | REPORTER   | futur contrat DECODE/Materializer; absent de la foundation                                                        |
+| `MdProgramId` / `MdPubkey`        | wrappers `String`                                                    | REJETER    | `ksp_core_lib::Pubkey` reste canonique                                                                            |
+| `MdInstructionPath`               | path CPI textuel                                                     | REPORTER   | futur CORE; absent de `ProgramInstruction`                                                                        |
+| `ExApiExecutionRequest`           | operation code + `payload_json` générique                            | REJETER    | ne pas créer de JSON générique pour masquer un contrat d'intent non conçu                                         |
+| `ExApiExecutionCapability`        | supported/unsupported avec strings                                   | REDESSINER | concept utile pour un futur preparer, mais aucun contrat execution en `0.2.14`                                    |
+| `ExApiPreparedExecutionPlan`      | instructions, signers, policy, spend et metadata                     | REDESSINER | séparer plus tard préparation technique et policy; réutiliser `ProgramInstruction` pour le wire                   |
+| `ExApiInstructionExecutor`        | support + plan générique JSON                                        | REJETER    | concept `ProgramExecutor` abandonné                                                                               |
+| `ExApiTypedInstructionExecutor`   | associated `Intent` et build pur d'un plan                           | REPRENDRE  | idée de préparation pure conservée conceptuellement pour futur `ProgramExecutionPreparer`                         |
+| policy intégrée au plan           | cluster, simulation, spend, blockhash, post-validation               | REJETER    | owner futur `ksp-execution-policy-api` / `ksp-execution-lib`                                                      |
+| `ks-lib` monolithique             | decoder + executor + materializer + model + codecs                   | REJETER    | frontières `Interface`, `Program API`, futurs `Program Lib`, `Materializer`, `Execution` séparées                 |
+
+## 6. Matrice d'ownership
+
+| Concept                            | Owner                                        | Décision `0.2.14`                          |
+|------------------------------------|----------------------------------------------|--------------------------------------------|
+| `Pubkey`                           | `ksp-core-lib`                               | réutilisé; jamais dupliqué                 |
+| Program IDs fondamentaux KSP       | `ksp-core-lib`                               | inchangés; non exhaustifs du monde externe |
+| `ProgramAccountMeta`               | `ksp-interface-lib`                          | réutilisé                                  |
+| `ProgramInstruction`               | `ksp-interface-lib`                          | input du premier decoder                   |
+| bornes wire instruction            | `ksp-interface-lib`                          | inchangées                                 |
+| recognition instruction-local      | `ksp-program-api`                            | introduite                                 |
+| capability decoder instruction     | `ksp-program-api`                            | introduite                                 |
+| output décodé protocolaire concret | extension externe ou futur `ksp-program-lib` | associated type de l'implémentation        |
+| payload canonique DECODE/D3        | future frontière DECODE/Materializer/Store   | reporté                                    |
+| decoder officiel                   | futur `ksp-program-lib`                      | hors scope                                 |
+| contexte transaction/CPI/logs      | future couche CORE                           | reporté                                    |
+| registry runtime d'implémentations | future composition Program/DECODE            | reporté                                    |
+| wire codec officiel                | `ksp-interface-lib`                          | hors Program API                           |
+| execution preparation              | `ksp-program-api` futur                      | reporté de cette release                   |
+| execution policy                   | futur `ksp-execution-policy-api`             | hors scope                                 |
+| signature/simulation/send/confirm  | futur `ksp-execution-lib` + Wallet/Transport | hors scope                                 |
+| persistence/materialization        | futurs Store/Materializer                    | hors scope                                 |
+
+## 7. API candidate retenue
+
+Le design cible à matérialiser dans les tranches suivantes est volontairement petit.
+
+### 7.1 Façade héritée
+
+`ksp-program-api` dépendra de Core et Interface et pourra réexporter explicitement depuis son crate root les types nécessaires à une implémentation externe sans module privé :
+
+```rust
+pub use ksp_core_lib::{Error, ErrorCode, ErrorContext, Pubkey, Result};
+pub use ksp_interface_lib::{ProgramAccountMeta, ProgramInstruction};
+```
+
+Ces réexports ne changent pas l'ownership : Error/Pubkey restent Core-owned et les structures wire restent Interface-owned.
+
+Les constantes d'admission Interface ne sont pas réexportées par défaut : l'input reçu a déjà franchi ces bornes et Program API ne les possède pas.
+
+### 7.2 Recognition
+
+Candidat retenu :
+
+```rust
+#[non_exhaustive]
+pub enum ProgramInstructionRecognition {
+    NoMatch,
+    ProgramMatch,
+    ExactMatch,
+}
+```
+
+Sémantique :
+
+```text
+NoMatch       l'implémentation ne revendique pas cette instruction
+ProgramMatch  le Program ID ou la famille est reconnue, mais l'entrée n'est pas prouvée exacte
+ExactMatch    l'implémentation affirme une reconnaissance instruction-locale exacte
+```
+
+Aucun score flottant, confidence, priority, surface code ou discriminator textuel n'entre dans la foundation.
+
+Alternatives rejetées :
+
+```text
+bool                    trop pauvre pour distinguer Program-only et exact
+No / Maybe / Yes        sémantique moins explicite et héritée du generic protocol decoder
+priority                inutile sans registry conflict policy
+entry code String       crée un contrat textuel non consommé
+proof enum              dépend en partie du futur contexte CORE
+```
+
+### 7.3 Outcome
+
+Candidat retenu :
+
+```rust
+#[non_exhaustive]
+pub enum ProgramInstructionDecodeOutcome<Decoded> {
+    Decoded(Decoded),
+    Unsupported,
+}
+```
+
+`decode` retourne un `ksp_core_lib::Result`. Un échec de validation/décodage est donc `Err`, pas un doublon `Failed` dans l'outcome.
+
+`Ignored` n'est pas retenu : pour une capability qui décode une instruction en une valeur typée, une entrée connue doit soit produire la valeur, soit être unsupported, soit échouer. Une politique de filtrage ou de matérialisation n'appartient pas à ce contrat.
+
+Le `Debug` de cet outcome, s'il est exposé, devra être borné et ne pas rendre automatiquement le contenu `Decoded`.
+
+### 7.4 Decoder instruction
+
+Candidat retenu :
+
+```rust
+pub trait ProgramInstructionDecoder: Send + Sync {
+    type Decoded;
+
+    fn program_ids(&self) -> &[Pubkey];
+
+    fn recognize(
+        &self,
+        instruction: &ProgramInstruction,
+    ) -> ProgramInstructionRecognition;
+
+    fn decode(
+        &self,
+        instruction: &ProgramInstruction,
+    ) -> Result<ProgramInstructionDecodeOutcome<Self::Decoded>>;
+}
+```
+
+Propriétés recherchées :
+
+```text
+input entièrement KSP-owned et déjà borné
+Program IDs typés
+aucun serde/JSON/codec
+aucun contexte transactionnel inventé
+aucun I/O
+aucun default method
+Send + Sync sur l'implémentation
+output concret possédé par la crate externe
+```
+
+Le `program_ids()` peut contenir un `Pubkey` absent du registry Core. Il sert uniquement à déclarer la portée Program de l'implémentation; il n'introduit aucun enum central.
+
+### 7.5 Associated output et composition
+
+L'associated type est retenu précisément parce que `0.2.14` ne possède pas encore le payload canonique D3.
+
+Une extension peut définir :
+
+```text
+ExternalDecodedInstruction
+```
+
+sans forcer KSP à utiliser `Any`, JSON ou une enum centrale.
+
+Conséquence assumée : le trait n'est **pas** une promesse de registry hétérogène `dyn ProgramInstructionDecoder` sans fixer `Decoded`. `0.2.14` ne crée donc aucun registry runtime et n'annonce aucun object-safe erased decoder.
+
+Quand la frontière DECODE/D3 réelle existera, KSP pourra introduire un contrat séparé de composition/erasure ou un envelope canonique réellement justifié, sans transformer cette foundation typée en faux format persistant.
+
+## 8. Décisions sur les questions ouvertes du prompt
+
+### Capability initiale
+
+Retenu :
+
+```text
+instruction decoder uniquement
+```
+
+`ProgramAccountDecoder` est reporté : aucun input account Program-facing stable n'existe encore dans Interface/CORE.
+
+### Input
+
+Retenu :
+
+```text
+&ProgramInstruction
+```
+
+Aucun signature, slot, CPI path, logs, return data, balance delta ou transaction error n'est ajouté.
+
+### Identity / descriptors / coverage
+
+Reportés. Le trait lui-même représente la capability; `program_ids()` suffit au besoin immédiat. Nom/version d'implémentation et coverage matrix ne sont pas consommés par la foundation.
+
+### Payload ouvert
+
+Retenu : output associé à l'implémentation. Aucun payload canonique commun n'est créé.
+
+### Proof / confidence
+
+Reportés. `ExactMatch` est une assertion instruction-locale du decoder, pas une preuve persistée. Logs, balance deltas et audit contextuel appartiennent à CORE/DECODE ultérieur.
+
+### Diagnostics
+
+Aucun diagnostic Program dédié. `Error/Result` Core suffit à la foundation. Les erreurs d'une extension doivent rester bornées et ne pas recopier le payload hostile.
+
+### Registry
+
+Reporté. `0.2.14` prouve l'extension par une crate externe, pas par un `Vec<Box<dyn ...>>` runtime.
+
+### Object safety
+
+Aucun gate object-safety n'est requis pour la surface retenue puisque le registry hétérogène est explicitement hors scope. Le trait reste `Send + Sync`, mais son associated output est intentionnellement typé.
+
+### `ProgramExecutionPreparer`
+
+Reporté au premier vertical slice qui possède un intent technique réel. L'ancien bot démontre qu'un preparer pur est utile, mais son ancien plan mélangeait encore policy, wallet/signers, blockhash, simulation et post-replay.
+
+### Logging
+
+Aucun `ksp-logging-lib`, `tracing`, `constants.rs` ou `TRACING_TARGET` dans l'API déclarative.
+
+### Sérialisation
+
+Aucun `serde` ou `serde_json`.
+
+## 9. Dependency graph cible
+
+Le graphe normal final visé est :
+
+```text
+ksp-program-api
+├── ksp-core-lib
+│   └── solana-pubkey
+└── ksp-interface-lib
+    └── ksp-core-lib
+```
+
+Dépendances de production interdites pour cette release :
+
+```text
+ksp-program-lib
+ksp-onchain-transport-lib
+ksp-offchain-transport-lib
+ksp-config-lib
+ksp-wallet-lib
+ksp-store-api
+ksp-store-lib
+ksp-materializer-api
+ksp-materializer-lib
+ksp-logging-lib
+serde
+serde_json
+borsh
+wincode
+bincode
+solana-instruction
+reqwest
+tokio
+tonic
+tauri
+tracing
+```
+
+Aucune nouvelle dépendance externe n'est nécessaire. L'audit externe ciblé de `pre.001` est donc `N/A` : le design ne dépend d'aucune nouvelle sémantique Solana, crate protocolaire ou registry dyn actuel.
+
+## 10. Threat / API model
+
+| Risque                            | Traitement de la foundation                                                                                           |
+|-----------------------------------|-----------------------------------------------------------------------------------------------------------------------|
+| payload hostile                   | input data déjà borné par Interface à `10_240` bytes; aucun Debug Program ne doit recopier ces bytes                  |
+| account vector hostile            | input déjà borné à `255` metas; ordre et doublons restent visibles au decoder                                         |
+| Program Pubkey inconnu            | accepté; aucun lookup Core obligatoire                                                                                |
+| closed-world enum                 | interdit; aucun `ProgramKind` central                                                                                 |
+| implémentation externe incorrecte | trait in-process non sandboxé; KSP ne prétend pas contenir un code tiers arbitraire                                   |
+| panic externe                     | aucun default method Program; un panic d'une implémentation tierce reste un défaut de cette implémentation            |
+| false `ExactMatch`                | assertion du decoder; pas de proof contextuel inventé; futures compositions peuvent auditer les conflits              |
+| strings non bornées               | aucun nouveau String dans l'API candidate                                                                             |
+| Debug leak                        | Recognition sans payload; outcome ne doit pas rendre automatiquement `Decoded`; input Interface a déjà un Debug borné |
+| status incohérent                 | `Failed` supprimé au profit de `Err`; outcome minimal réduit les combinaisons invalides                               |
+| priority ambiguity                | aucun priority sans registry; les conflits sont reportés au contrat de composition futur                              |
+| registry conflicts                | registry absent de la release                                                                                         |
+| object-safety impossible          | aucune promesse de dyn hétérogène; associated output assumé                                                           |
+| accidental serialization          | aucune dépendance/derive serde                                                                                        |
+| network/policy creep              | aucune dépendance runtime et aucun client/wallet/context réseau dans les signatures                                   |
+
+## 11. Stratégie de tests
+
+### Unit tests
+
+Prévoir :
+
+```text
+Recognition variants distincts
+outcome Decoded / Unsupported
+Debug outcome borné si implémenté
+unknown Program Pubkey
+empty/max-boundary ProgramInstruction déjà garanti par Interface et réutilisé sans recopie
+```
+
+### Public API
+
+Le canari `tests/public_api.rs` devra utiliser uniquement les exports crate-root de `ksp-program-api`.
+
+### External implementation
+
+Un test d'intégration doit construire une crate consommatrice séparée qui :
+
+```text
+dépend uniquement de ksp-program-api pour le contrat Program
+implémente ProgramInstructionDecoder
+définit son propre type ExternalDecodedInstruction
+utilise un Pubkey opaque absent du registry Core
+reconnaît et décode une instruction
+n'accède à aucun module privé
+ne dépend pas de ksp-program-lib
+```
+
+La technique exacte de crate fixture temporaire sera choisie lors de la tranche d'implémentation, sans ajouter de dépendance runtime.
+
+### Dependency firewall
+
+Canaris manifest/source pour interdire les dépendances listées en section 9.
+
+### Release completeness
+
+Verrouiller la surface décidée, l'absence de registry/preparer/payload canonique et l'absence de `pub mod`.
+
+### Aucun smoke réseau
+
+Aucun HTTP/WS/gRPC/live smoke n'est pertinent pour une API in-memory déclarative.
+
+## 12. Sizing
+
+Le scope initial du prompt contenait decoder, descriptors, registry, payload ouvert et possiblement execution preparation. L'audit montre que stabiliser ces surfaces ensemble obligerait à anticiper D3 et Execution.
+
+Le gate réduit donc la release à :
+
+```text
+crate + facade + firewall
+recognition + outcome minimal
+decoder instruction avec associated output
+external implementation canary
+hardening/completeness
+gate technique
+documentation
+publication
+```
+
+Ce périmètre reste compatible avec une release clôturable dans une session et avec des tranches intermédiaires bornées.
+
+## 13. Prévision souple recalibrée
+
+### `pre.001` — Audit KSP + kbot3 + API model + sizing
+
+**Statut : réalisé ; gate opérateur intégralement PASS.**
+
+Baseline, règles/architecture, héritage, ownership, API candidate, dependency graph, threat model, tests et scope réduit. Aucun code Program.
+
+### `pre.002` — Scaffold `ksp-program-api` + façade + firewall
+
+**Statut : réalisé ; gate opérateur intégralement PASS.**
+
+La crate est membre du workspace avec exactement `ksp-core-lib` et `ksp-interface-lib` comme dépendances normales. Le crate-root réexporte `Error`, `ErrorCode`, `ErrorContext`, `Result`, `Pubkey`, `ProgramAccountMeta` et `ProgramInstruction`. README/USAGE initiaux et canaris `public_api` / `dependency_boundary` sont présents.
+
+Aucun trait decoder, recognition, outcome, registry, codec, runtime logging ou execution preparer n'est avancé.
+
+### `pre.003` — Recognition + outcome minimal
+
+**Statut : réalisé ; gate opérateur intégralement PASS.**
+
+`ProgramInstructionRecognition` et `ProgramInstructionDecodeOutcome<Decoded>` sont ajoutés dans un module privé puis réexportés depuis le crate-root. Les deux enums sont `#[non_exhaustive]`. Le `Debug` de l'outcome est manuel, ne requiert pas `Decoded: Debug` et n'affiche jamais la valeur décodée. Aucun descriptor, registry ou trait decoder n'est avancé.
+
+### `pre.004` — `ProgramInstructionDecoder` + external implementation
+
+**Statut : réalisé ; gate opérateur intégralement PASS.**
+
+Le trait `ProgramInstructionDecoder: Send + Sync` expose l'associated type `Decoded`, `program_ids`, `recognize` et `decode`. Un test d'intégration downstream-style l'implémente avec un type décodé tiers et un `Pubkey` explicitement absent du registry Core. L'implémentation ne requiert ni `ksp-program-lib`, ni enum centrale, ni `Any`, JSON ou codec.
+
+### `pre.005` — Adversarial/API hardening + completeness
+
+**Statut : réalisé ; `pre.005-fix.001` validé, gate opérateur intégralement PASS.**
+
+Deux canaris de fermeture sont ajoutés : `release_completeness.rs` verrouille l'inventaire exact des exports/modules et l'absence de surface closed-world/runtime ; `security_hardening.rs` couvre input Interface maximal, erreur sûre sur payload hostile et associated output sans bound implicite. Aucun contrat fonctionnel n'est ajouté.
+
+### `pre.006` — Gate technique final
+
+**Statut : matérialisé ; gate opérateur à confirmer.**
+
+Aucun développement fonctionnel. Audits Rust/Markdown, check, Clippy, `cargo test -p ksp-program-api`, ownership Logging ciblé, workspace complet et graphes Cargo. Aucun README/USAGE final ni préparation de publication n’est mélangé à cette tranche.
+
+### `pre.007` — Réconciliation documentaire finale
+
+README/USAGE, plan, validation, index et références durables réellement concernées. Aucun `CHANGELOG.md`, `ROADMAP.md` ou prompt suivant.
+
+### `pre.008` — Préparation de publication minimale
+
+Uniquement `Cargo.toml`, `CHANGELOG.md`, `ROADMAP.md`, prompt `0.3.1` et delta `pre.008`.
+
+### `rel.001` — Publication stable
+
+Mécanique de publication uniquement.
+
+La numérotation reste souple : une anomalie peut insérer une tranche dédiée, mais les couloirs `gate technique -> réconciliation documentaire -> publication minimale` restent séparés.
+
+## 13.1 État préparé après `pre.002`
+
+Le scaffold strict attendu pour ouvrir `pre.003` est :
+
+```text
+ksp-program-api                         membre workspace
+normal dependencies                    ksp-core-lib + ksp-interface-lib uniquement
+crate-root facade                      Core/Interface réexportés explicitement
+public modules                         aucun
+ProgramInstructionRecognition          absent par contrat pre.002
+ProgramInstructionDecodeOutcome        absent par contrat pre.002
+ProgramInstructionDecoder              absent par contrat pre.002
+ProgramExecutionPreparer               absent
+serde / JSON / codecs                  absents
+ksp-logging-lib / tracing              absents
+README / USAGE                         initiaux
+public API canary                      présent
+dependency firewall canary             présent
+```
+
+`pre.003` reste limité à `ProgramInstructionRecognition` et `ProgramInstructionDecodeOutcome<Decoded>` avec leur sémantique et leur Debug sûr. Le trait decoder reste réservé à `pre.004`.
+
+## 13.2 État préparé après `pre.003`
+
+Le gate opérateur `pre.002` fourni le 28 août 2026 est intégralement vert : audits Rust/Markdown, check, Clippy, tests de `ksp-program-api`, workspace complet et graphes Cargo ont été exécutés. Le graphe normal ciblé reste exactement `Core + Interface`.
+
+La tranche `pre.003` matérialise :
+
+```text
+ProgramInstructionRecognition            NoMatch / ProgramMatch / ExactMatch
+ProgramInstructionDecodeOutcome<T>       Decoded(T) / Unsupported
+non_exhaustive                            oui sur les deux enums
+Debug recognition                        payload-free par construction
+Debug outcome                            opaque, sans bound T: Debug
+Failed / Ignored                         absents
+priority / confidence / proof            absents de la surface
+ProgramInstructionDecoder                absent par contrat pre.003
+registry / canonical payload / preparer  absents
+normal dependencies                      inchangées : Core + Interface
+```
+
+Les tests unitaires vérifient notamment qu'un type décodé externe dépourvu de `Debug` peut être contenu et formaté via l'outcome sans exposer sa valeur. Le gate opérateur `pre.003` fourni le 28 août 2026 est intégralement vert et autorise `pre.004`.
+
+## 13.3 État préparé après `pre.004`
+
+La tranche matérialise exactement :
+
+```text
+ProgramInstructionDecoder                 public depuis le crate-root
+supertraits                               Send + Sync
+associated output                         type Decoded possédé par l'implémentation
+program_ids                               &[Pubkey] opaque/open-world
+recognize                                 &ProgramInstruction -> Recognition
+decode                                    &ProgramInstruction -> Result<Outcome<Self::Decoded>>
+default methods                           aucun
+external implementation canary            présent comme crate d'intégration séparée
+external decoded type                     défini hors code de production KSP
+external Program Pubkey                   explicitement absent du registry Core
+central Program enum / Any / JSON          absents
+registry dyn / descriptor / D3 payload     absents
+ProgramExecutionPreparer                  absent
+normal dependencies                       inchangées : Core + Interface
+```
+
+Le canari externe utilise uniquement la façade `ksp_program_api::*` pour l'implémentation du trait ; l'accès direct à `ksp_core_lib::find_program_pubkey` est limité à l'assertion de test prouvant que le Program choisi n'est pas enregistré. Aucune API de registry n'est réexportée par Program API.
+
+`pre.005` reste une tranche de hardening/completeness : elle ne doit pas élargir le contrat fonctionnel.
+
+## 13.4 État préparé après `pre.005`
+
+Le gate opérateur `pre.004` fourni le 28 août 2026 est intégralement vert : audits Rust/Markdown, check, Clippy, tests ciblés, workspace complet, canari externe et graphes Cargo passent.
+
+La tranche `pre.005` ajoute uniquement des preuves de fermeture :
+
+```text
+exact crate-root exports                 10 exports explicitement verrouillés
+production modules                       lib + decode vocabulary + decoder trait uniquement
+public enums                              Recognition + DecodeOutcome uniquement
+public traits                             ProgramInstructionDecoder uniquement
+closed-world Program enum                 absent
+registry / descriptors / preparer         absents
+serde / JSON / Any / codecs               absents
+logging / runtime / IO                     absents
+max Interface instruction                 consommable par référence
+malformed hostile payload                 Err Core sûr sans copie automatique du payload
+associated Decoded bounds                 aucun bound implicite ajouté
+dyn heterogeneous registry                aucune promesse
+normal dependencies                       inchangées : Core + Interface
+```
+
+`pre.006` reste un gate technique final sans développement fonctionnel.
+
+## 13.5 Gate opérateur `pre.005-fix.001` et ouverture de `pre.006`
+
+Le gate opérateur du 28 août 2026 ferme le correctif de `pre.005` :
+
+```text
+cargo fmt --all                                      PASS
+audit Rust général / exports / workspace             PASS
+audit Markdown                                       PASS — 173 tables / 123 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-program-api                        PASS — 18 tests Rust
+cargo test -p ksp-logging-lib --test ownership       PASS — 2 tests
+cargo test --workspace                               PASS
+cargo tree -p ksp-program-api --edges normal         PASS — Core + Interface uniquement
+cargo tree --duplicates                              exécuté, inventaire workspace observé
+```
+
+Le faux positif du canari logging est donc fermé sans changement de production ni de dépendances. Le scope fonctionnel `0.2.14` est figé avant `pre.006`.
+
+La tranche `pre.006` ne matérialise aucun nouveau code ou test : elle synchronise seulement la version workspace, le plan, la validation et son delta afin de rejouer le gate technique final sur la surface candidate déjà durcie.
+
+## 13.6 Gate technique final `pre.006` et réconciliation `pre.007`
+
+Le gate opérateur de `pre.006`, fourni le 28 août 2026, ferme intégralement la lane technique sans modification de production ni de tests :
+
+```text
+cargo fmt --all                                      PASS
+audits Rust / export completeness / workspace        PASS
+audit Markdown                                       PASS — 174 tables / 124 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-program-api                        PASS — 18 tests Rust
+cargo test -p ksp-logging-lib --test ownership       PASS — 2/2
+cargo test --workspace                               PASS
+cargo tree -p ksp-program-api --edges normal         PASS — Core + Interface uniquement
+cargo tree --duplicates                              inspecté
+```
+
+La surface technique candidate est donc figée :
+
+```text
+crate-root exports                     10 exacts
+production modules                     3 exacts
+public enums                           Recognition + DecodeOutcome uniquement
+public trait                           ProgramInstructionDecoder uniquement
+normal dependencies                    Core + Interface uniquement
+Program Pubkey hors registry           accepté par canari externe
+max Interface instruction              admise à la frontière decoder par référence
+registry / descriptors / preparer      absents
+serde / JSON / Any / codecs            absents
+logging / runtime / IO                 absents
+```
+
+`pre.007` ne rouvre aucun fichier Rust, test, manifest de crate, dépendance ou comportement. La version workspace avance mécaniquement à `0.2.14-pre.7` et les références durables suivantes sont réconciliées :
+
+```text
+crates/ksp-program-api/README.md
+crates/ksp-program-api/USAGE.md
+docs/000-README.md
+docs/plans/000-README.md
+docs/plans/002-FUNCTIONAL_RELEASE_SEQUENCE.md
+docs/plans/021-V0_2_14_PROGRAM_API_PLAN.md
+docs/validation/000-README.md
+docs/validation/017-V0_2_14_PROGRAM_API.md
+```
+
+La documentation finale fixe l'ownership, l'inventaire crate-root, les semantics Recognition/Outcome, le trait externe, les preuves open-world/adversariales et le dependency firewall. Les index passent au statut candidat réconcilié sans annoncer prématurément la release stable.
+
+Cette tranche ne touche explicitement pas `CHANGELOG.md`, `ROADMAP.md`, le prompt suivant, l'architecture ni les surfaces techniques. Ces responsabilités appartiennent à `pre.008`, sauf découverte d'un défaut documentaire réel imposant une nouvelle tranche de réconciliation.
+
+## 14. Hors périmètre confirmé
+
+```text
+ksp-program-lib
+decoder officiel Solana/SPL
+ProgramAccountDecoder / Event / ReturnData
+registry runtime
+priority/conflict policy
+descriptor identity/version/coverage
+payload canonique D3
+serde/JSON/Any
+proof/confidence contextuels
+CORE replay input
+Materializer / Store
+ProgramExecutionPreparer
+ExecutionPolicy / Execution
+Wallet / Transport / Config / Tauri
+IDL runtime / Anchor generic decoder
+```
+
+## 15. Critères de clôture
+
+La candidate satisfait les critères techniques et documentaires suivants avant préparation de publication :
+
+```text
+ksp-program-api existe
+le trait instruction-only est public et documenté
+une extension externe l'implémente avec un Pubkey non enregistré
+aucun enum central Program n'est requis
+aucun payload canonique prématuré n'est figé
+aucun registry/preparer n'est anticipé
+Core/Interface sont les seules dépendances KSP normales
+aucun runtime/codec/logging/serde n'est tiré
+public API / external implementation / dependency firewall / completeness passent
+cargo test -p ksp-program-api passe
+cargo test --workspace passe
+graphes Cargo inspectés
+documentation finale réconciliée
+```
+
+## 16. Suite
+
+Après `0.2.14`, la séquence active reste :
+
+```text
+0.3.1  ksp-store-api + ksp-store-lib, RAW only
+0.3.2  ksp-interface-lib, wires génériques acquisition/CORE
+0.3.3  ksp-job-api + backfill
+0.3.4  application backfill/RAW
+```
+
+Le payload DECODE, les materializers et la préparation d'exécution ne sont pas déplacés dans `0.3.1`; ils attendent les vertical slices qui démontreront leurs contrats réels.

docs/validation/000-README.md

@@ -1,5 +1,5 @@
 <!-- file: docs/validation/000-README.md -->
-<!-- version: 27 -->
+<!-- version: 31 -->
 
 # Validations KSP
 
@@ -23,4 +23,6 @@ Documents :
 - [`012-V0_2_9_YELLOWSTONE_GRPC.md`](012-V0_2_9_YELLOWSTONE_GRPC.md) — matrice finale de la release stable `0.2.9` : service Geyser courant, `Subscribe` standard, 7 unary, filtres/updates, dépendances/licence, replay/backpressure, Config V3 et smoke PublicNode Mainnet/Testnet.
 - [`013-V0_2_10_ORBITFLARE_YELLOWSTONE_GRPC.md`](013-V0_2_10_ORBITFLARE_YELLOWSTONE_GRPC.md) — matrice finale de la release stable `0.2.10` : Free Devnet, auth `x-token`, endpoint security, heartbeat standard, Config V3, smoke live `Slot + Ping` et invariant N1/N2 immuable.
 - [`014-V0_2_11_OFFCHAIN_PRICE_TRANSPORT.md`](014-V0_2_11_OFFCHAIN_PRICE_TRANSPORT.md) — matrice historique clôturée de `0.2.11` : SOL/USD multi-provider, numeric safety, rate limiting/availability, Config capability-aware et smoke keyless final `7/7`.
-- [`015-V0_2_12_SOL_PRICES_DESK.md`](015-V0_2_12_SOL_PRICES_DESK.md) — matrice active ouverte par `0.2.12-pre.001` : screen/features, DTO/commands, Config/composite, frontières provider-neutral, sécurité, Wallet integration, packaging Tauri et gates live/build.
+- [`015-V0_2_12_SOL_PRICES_DESK.md`](015-V0_2_12_SOL_PRICES_DESK.md) — matrice historique clôturée de `0.2.12` : screen/features, DTO/commands, Config/composite, frontières provider-neutral, sécurité, Wallet integration, packaging Tauri et gates live/build.
+- [`016-V0_2_13_INTERFACE.md`](016-V0_2_13_INTERFACE.md) — matrice candidate finale de `0.2.13` : ownership Interface/Core/Transport/Program, surface passive, bornes/adversarial, façade publique exacte, consumer externe, release completeness, dependency firewall et gate technique `pre.006` intégralement vert.
+- [`017-V0_2_14_PROGRAM_API.md`](017-V0_2_14_PROGRAM_API.md) — matrice candidate finale de `0.2.14 — Program API foundation` : façade instruction-only ouverte, Recognition/Outcome, trait externe, Program Pubkey non enregistré, hardening adversarial, release completeness, firewall Core/Interface et gate technique `pre.006` intégralement vert.

docs/validation/016-V0_2_13_INTERFACE.md

@@ -0,0 +1,371 @@
+<!-- file: docs/validation/016-V0_2_13_INTERFACE.md -->
+<!-- version: 8 -->
+
+# Validation `0.2.13` — Interface / wire foundation
+
+## 1. Objet
+
+Cette matrice est ouverte par `0.2.13-pre.001`. Elle suit la première surface de `ksp-interface-lib` et enregistre les critères de fermeture sans transformer Interface en Program API ou en modèle RAW/CORE générique.
+
+Scope retenu :
+
+```text
+ProgramAccountMeta
+ProgramInstruction
+Pubkey via ksp-core-lib
+bornes comptes/data
+aucun codec générique
+aucun comportement Program
+```
+
+## 2. Baseline stable
+
+| Contrat                    | Attendu                                        | Statut `pre.001`                         |
+|----------------------------|------------------------------------------------|------------------------------------------|
+| archive                    | `khadhroony-solana-project-v0.2.12.zip` stable | PASS marqueurs internes                  |
+| workspace version entrée   | `0.2.12`                                       | PASS                                     |
+| `deltas/0.2.12/rel.001.md` | présent                                        | PASS                                     |
+| prompt 018                 | présent                                        | PASS                                     |
+| `.git`                     | optionnel archive                              | ABSENT — tag non revérifiable localement |
+| `ksp-interface-lib` entrée | absent                                         | PASS                                     |
+| `ksp-program-api` entrée   | absent                                         | PASS                                     |
+| gate Cargo stable          | fmt/check/clippy/test                          | PASS preuve opérateur                    |
+| audits Python base         | Rust + Markdown                                | PASS sandbox                             |
+
+## 3. Lecture et ownership internes
+
+| Famille                           | Constat                                             | Décision                            |
+|-----------------------------------|-----------------------------------------------------|-------------------------------------|
+| Core `Pubkey`                     | public crate-root, `solana-pubkey ^4.3`             | réutiliser; aucun wrapper Interface |
+| Core Program IDs                  | 18 identités fondamentales + registry               | laisser Core                        |
+| Core Error/Result                 | contrat commun workspace                            | réutiliser pour Interface           |
+| HTTP transaction/block DTOs       | projections JSON-RPC Transport                      | laisser Transport                   |
+| Yellowstone instruction/meta DTOs | projections protobuf/Geyser                         | laisser Transport                   |
+| Architecture 006                  | Interface wire passive; Program comportement séparé | scope conforme                      |
+| Roadmap 0.3.2                     | wires génériques acquisition/CORE reportés          | ne pas anticiper                    |
+
+## 4. Héritage kbot3
+
+| Concept                                 | Verdict            | Preuve attendue dans KSP                   |
+|-----------------------------------------|--------------------|--------------------------------------------|
+| ordered account meta                    | REPRENDRE          | `ProgramAccountMeta` sans naming execution |
+| passive `{program_id, accounts, data}`  | REPRENDRE          | `ProgramInstruction` borné                 |
+| string Pubkey/ProgramId wrappers        | REDESSINER         | Core `Pubkey` directement                  |
+| unbounded payload                       | REDESSINER         | borne + Debug résumé                       |
+| decoder traits/recognition/proofs       | REPORTER 0.2.14    | absents d'Interface                        |
+| instruction path/CPI/replay context     | REPORTER 0.3.2+    | absents de 0.2.13                          |
+| canonical transaction/replay JSON model | REPORTER/redéfinir | aucun portage                              |
+| prepared execution policy/signers       | REPORTER           | absents d'Interface                        |
+| monolithic `ks-lib` organization        | REJETER            | crate ownership séparé                     |
+
+## 5. Audit externe courant
+
+| Référence                    | État observé 2026-08-27                                          | Décision de validation                                       |
+|------------------------------|------------------------------------------------------------------|--------------------------------------------------------------|
+| `solana-instruction`         | 3.5.0; `Pubkey ^4.3.0`; codecs optionnels                        | parité conceptuelle requise, dépendance non requise          |
+| Solana `Instruction`         | program_id + ordered AccountMeta + opaque bytes                  | forme cible exacte                                           |
+| Solana syscall bounds        | 255 account metas CPI; data 10 KiB; 128 unique account infos CPI | 255/10 KiB = admission Interface; 128 non appliqué aux metas |
+| `solana-loader-v3-interface` | 8.1.1; compatible générations observées                          | hors scope, réaudit au vertical réel                         |
+| licence Anza SDK             | Apache-2.0                                                       | compatible si future dépendance réellement retenue           |
+
+## 6. Matrice de frontière de release
+
+| Surface                           | Owner          | 0.2.13    | 0.2.14          | 0.3.2+         | Statut  |
+|-----------------------------------|----------------|-----------|-----------------|----------------|---------|
+| Pubkey / Program IDs fondamentaux | Core           | reuse     | reuse           | reuse          | FIXÉ    |
+| Program account meta              | Interface      | IMPLEMENT | consume         | reuse          | FIXÉ    |
+| Program instruction passive       | Interface      | IMPLEMENT | consume         | reuse          | FIXÉ    |
+| Program-specific codec/layout     | Interface      | OUT       | si besoin réel  | selon vertical | REPORTÉ |
+| decoder/preparer traits           | Program API    | OUT       | AUDIT/IMPLEMENT | consume        | REPORTÉ |
+| Transport provider DTOs           | Transport      | UNCHANGED | UNCHANGED       | adapter future | FIXÉ    |
+| generic acquisition/replay wire   | Interface/CORE | OUT       | OUT             | IMPLEMENT      | REPORTÉ |
+| RAW persistence                   | Store          | OUT       | OUT             | `0.3.1`+       | REPORTÉ |
+
+## 7. API publique cible
+
+| Contrat              | Attendu final `0.2.13`                                 | Statut       |
+|----------------------|--------------------------------------------------------|--------------|
+| crate                | `ksp-interface-lib` membre workspace                   | PASS pre.002 |
+| façade               | exports explicites crate-root; aucun `pub mod`         | PASS pre.002 |
+| Pubkey               | réexport/usage contrôlé de Core; pas de type parallèle | PASS pre.002 |
+| `ProgramAccountMeta` | private fields + writable/readonly + accessors         | PASS pre.003 |
+| `ProgramInstruction` | private fields + `try_new` + accessors                 | PASS pre.006 |
+| account bound        | constante publique `<= 255`; enforcement constructeur  | PASS pre.006 |
+| data bound           | `<= 10_240`                                            | PASS pre.006 |
+| serde                | absent                                                 | FIXÉ pre.001 |
+| generic codec        | absent                                                 | FIXÉ pre.001 |
+| Debug instruction    | résumé borné, pas payload complet                      | PASS pre.006 |
+| Error/Result         | Core commun + code Interface sûr minimal               | PASS pre.003 |
+
+## 8. Robustness/adversarial
+
+| Cas                          | Attendu                  | Gate                    |
+|------------------------------|--------------------------|-------------------------|
+| 0 account                    | accepté                  | unit                    |
+| 255 accounts                 | accepté                  | unit                    |
+| 256 accounts                 | refus avant état valide  | unit                    |
+| 0 data                       | accepté                  | unit                    |
+| 10_240 bytes                 | accepté                  | unit                    |
+| 10_241 bytes                 | refus                    | unit                    |
+| duplicate accounts           | ordre/doublons conservés | unit + public API       |
+| unknown Program Pubkey       | accepté                  | unit                    |
+| hostile data marker in Debug | absent du rendu          | unit                    |
+| hostile data marker in Error | absent du rendu/context  | unit                    |
+| unchecked narrowing cast     | absent                   | source audit/Clippy     |
+| malformed binary wire        | N/A sans codec           | ne pas inventer un test |
+| unknown discriminant         | N/A sans enum wire       | réouvrir au vertical    |
+| serde hostile allocation     | N/A serde absent         | dependency canary       |
+
+## 9. Dependency firewall
+
+| Dépendance depuis Interface         | Attendu final                          | Preuve                 |
+|-------------------------------------|----------------------------------------|------------------------|
+| `ksp-core-lib`                      | AUTORISÉ / requis                      | manifest + cargo tree  |
+| `ksp-program-api` / Program Lib     | INTERDIT                               | manifest/source canary |
+| On-chain / Off-chain Transport      | INTERDIT                               | manifest/source canary |
+| Config / Wallet / Store / Tauri     | INTERDIT                               | manifest/source canary |
+| reqwest / tonic / tokio / websocket | INTERDIT                               | cargo tree + manifest  |
+| serde / serde_json                  | ABSENT en foundation                   | manifest + cargo tree  |
+| borsh / bincode / wincode           | ABSENT en foundation                   | manifest + cargo tree  |
+| `solana-instruction`                | ABSENT tant qu'interop réel non requis | manifest + cargo tree  |
+
+Graphes attendus :
+
+```bash
+cargo tree -p ksp-interface-lib --edges normal
+cargo tree --duplicates
+```
+
+Si une nouvelle dépendance externe apparaît après `pre.001`, la présente matrice doit être rouverte avant acceptation.
+
+## 10. Tests de release
+
+| Famille                  | Attendu                                         | Statut       |
+|--------------------------|-------------------------------------------------|--------------|
+| unit tests privés        | account meta/borne puis instruction/adversarial | PASS pre.006 |
+| `tests/public_api.rs`    | consommation crate-root uniquement              | PASS pre.006 |
+| external consumer canary | surface utilisable hors modules privés          | PASS pre.006 |
+| dependency boundary      | firewall exact                                  | PASS pre.006 |
+| release completeness     | inventaire exact, aucun domaine supplémentaire  | PASS pre.006 |
+| round-trip codec         | aucun tant qu'aucun codec                       | N/A          |
+| network smoke            | aucun pour crate wire pure                      | N/A          |
+
+## 11. Gate technique final validé
+
+Le gate opérateur `0.2.13-pre.006` du **28 août 2026** ferme la lane technique :
+
+```text
+cargo fmt --all                                      PASS
+python3 scripts/audit_rust_workspace_rules.py        PASS
+python3 scripts/audit_markdown_tables.py ...         PASS — 162 tables / 119 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-interface-lib                      PASS
+cargo test -p ksp-logging-lib --test ownership       PASS
+cargo test --workspace                               PASS
+cargo tree -p ksp-interface-lib --edges normal       Core-only confirmé
+cargo tree --duplicates                              inspecté
+```
+
+Aucun smoke réseau/live n'est exigé : la crate reste une foundation wire pure sans I/O.
+
+## 12. État `pre.001`
+
+| Critère de sortie prompt                  | Statut                            |
+|-------------------------------------------|-----------------------------------|
+| sources internes obligatoires relues      | PASS                              |
+| base stable confirmée                     | PASS marqueurs + preuve opérateur |
+| Core/Transport inventoriés                | PASS                              |
+| architecture 006 confrontée à la base     | PASS                              |
+| archive kbot3 auditée                     | PASS                              |
+| matrice héritage                          | PASS                              |
+| frontière 0.2.13 / 0.2.14 / 0.3.2         | PASS                              |
+| premier lot exact décidé                  | PASS                              |
+| ownership types                           | PASS                              |
+| dépendances candidates auditables/bornées | PASS                              |
+| threat model                              | PASS                              |
+| test strategy                             | PASS                              |
+| dependency graph cible                    | PASS                              |
+| plan + validation                         | PASS                              |
+| forecast/sizing                           | PASS                              |
+| implémentation Program lourde             | ABSENTE                           |
+
+Le passage à `pre.002` est autorisé après application du delta et validation opérateur. Le statut des items d'implémentation reste volontairement `TODO` jusqu'aux tranches correspondantes.
+
+## 13. État préparé `pre.002`
+
+Le scaffold matérialisé conserve volontairement une surface minimale :
+
+```text
+workspace member                     PASS structurel
+normal dependency                    ksp-core-lib uniquement
+Pubkey                               réexport Core au crate-root
+public modules                       aucun
+ProgramAccountMeta                   absent par contrat pre.002
+ProgramInstruction                   absent par contrat pre.002
+serde / borsh / bincode / wincode    absents
+network/runtime dependencies          absentes
+ksp-logging-lib                      absent
+constants.rs / TRACING_TARGET        absents
+README / USAGE                       initiaux
+public API canary                    présent
+dependency firewall canary           présent
+```
+
+Le logging reste volontairement absent : la foundation `0.2.13` est passive et n'émet aucun événement/span runtime. Si une future surface comportementale démontre un besoin réel de logging, `ksp-logging-lib`, `src/constants.rs` et `TRACING_TARGET` devront être introduits ensemble conformément à `DEP-LOG-004` et `DEP-LOG-010`.
+
+Le passage à `pre.003` reste conditionné au gate opérateur complet sur l'overlay `pre.002`.
+
+## 14. État préparé `pre.003`
+
+| Critère                                             | Statut                                      |
+|-----------------------------------------------------|---------------------------------------------|
+| `ProgramAccountMeta` crate-root                     | PASS structurel                             |
+| champs privés                                       | PASS                                        |
+| constructeurs `readonly` / `writable`               | PASS                                        |
+| accessors identité/signer/writable                  | PASS                                        |
+| Pubkey opaque non registry                          | PASS unit                                   |
+| `MAX_PROGRAM_INSTRUCTION_ACCOUNTS == 255`           | PASS unit + public API                      |
+| enforcement collection `255/256`                    | PENDING `pre.004` avec `ProgramInstruction` |
+| code `interface.program_instruction_limit_exceeded` | PASS public API                             |
+| type d'erreur propre Interface                      | ABSENT, Core commun conservé                |
+| `ProgramInstruction`                                | ABSENT par contrat                          |
+| data bound                                          | PENDING `pre.004`                           |
+| serde/codecs                                        | ABSENTS                                     |
+| logging/runtime                                     | ABSENTS                                     |
+| dépendance normale                                  | `ksp-core-lib` uniquement                   |
+
+Le statut `PASS/PENDING` de la borne accounts signifie que la valeur publique est désormais figée à `255`, tandis que le rejet concret de `256` comptes sera testé lorsque la collection existera dans `ProgramInstruction`. Aucun faux wrapper de collection n'est créé dans `pre.003`.
+
+## 15. État préparé `pre.004`
+
+| Critère                                              | Statut                                       |
+|------------------------------------------------------|----------------------------------------------|
+| `ProgramInstruction` crate-root                      | PASS structurel                              |
+| champs privés                                        | PASS                                         |
+| constructeur `try_new`                               | PASS                                         |
+| accessors `program_id/accounts/data`                 | PASS                                         |
+| `MAX_PROGRAM_INSTRUCTION_DATA_LEN == 10_240`         | PASS unit + public API                       |
+| accounts `255` accepté / `256` refusé                | PASS unit                                    |
+| data `10_240` accepté / `10_241` refusé              | PASS unit                                    |
+| accounts/data vides                                  | PASS unit                                    |
+| ordre + doublons accounts                            | PASS unit                                    |
+| Program Pubkey opaque/non registry                   | PASS unit                                    |
+| erreur borne Core commune                            | PASS                                         |
+| contexte erreur limité aux longueurs/plafonds sûrs   | PASS unit                                    |
+| Debug résumé sans accounts/payload                   | PASS unit                                    |
+| serde/codecs                                         | ABSENTS                                      |
+| `solana-instruction`                                 | ABSENT                                       |
+| logging/runtime                                      | ABSENTS                                      |
+| dépendance normale                                   | `ksp-core-lib` uniquement                    |
+| `cargo test --workspace` sur preuve entrée `pre.003` | NON FOURNI — à rejouer au gate opérateur 004 |
+
+La tranche ferme ainsi le premier lot générique `{ program_id, accounts, data }` sans ajouter de codec ni de comportement Program. Le hardening `pre.005` doit porter sur l'usage externe, les cas adversariaux et le firewall, pas sur une nouvelle famille wire.
+
+## 16. État préparé `pre.005`
+
+Le gate opérateur `pre.004` est complet : fmt, audits Rust/Markdown, `cargo check --workspace`, Clippy, `cargo test -p ksp-interface-lib`, `cargo test --workspace` et graphes Cargo sont verts/inspectés.
+
+La tranche `pre.005` ajoute uniquement des canaris de hardening :
+
+```text
+external consumer crate                 présent via tests/external_consumer.rs
+release completeness                    présent via tests/release_completeness.rs
+crate-root exports exacts               vérifiés par source canary
+production module inventory exact       vérifié par filesystem canary
+source dependency firewall              étendu à tous les src production
+narrowing cast / encode/decode caché     interdits par source canary
+Vec accounts/data sans réallocation      vérifié par identité de pointeur
+payload hostile dans Error/Debug         absent attendu
+account material arbitraire dans Error   absent attendu
+nouveau type wire                         aucun
+nouvelle dépendance                       aucune
+codec/logging/runtime                     toujours absents
+```
+
+Les nouveaux tests sont **présents mais non déclarés PASS dans le sandbox**, qui ne dispose pas de Cargo. Leur statut final dépend du gate opérateur `pre.005`.
+
+Le consumer externe est un test d'intégration Rust, donc compilé par Cargo dans un crate distinct de `ksp-interface-lib`. Sa source ne consomme que les exports du crate-root ; les modules privés ne sont pas utilisés.
+
+Le canari de complétude impose exactement les exports publics retenus et exactement quatre modules/fichiers de production : `error.rs`, `lib.rs`, `program_account_meta.rs`, `program_instruction.rs`. Cette contrainte ferme explicitement le risque d'ajout opportuniste d'une seconde famille wire avant la release stable.
+
+## 17. Gate `pre.005` et correctif `pre.005-fix.001`
+
+Le gate ciblé Interface est intégralement vert :
+
+```text
+unit tests Interface                10/10 PASS
+manifest/source firewall            4/4 PASS
+external consumer                   1/1 PASS
+public API                           5/5 PASS
+release completeness                3/3 PASS
+doctests                            0 échec
+```
+
+Le workspace échoue ensuite dans le canari transversal Logging :
+
+```text
+ksp-logging-lib/tests/ownership.rs
+workspace_crates_do_not_bypass_ksp_logging_facade
+```
+
+Diagnostic confirmé : `tests/dependency_boundary.rs` contient le littéral `tracing::` uniquement comme pattern interdit. Le scanner Logging travaille sur le texte brut des `.rs` et interprète donc ce pattern de test comme un bypass réel. Le graphe Cargo Interface reste pourtant :
+
+```text
+ksp-interface-lib
+└── ksp-core-lib
+    └── solana-pubkey 4.3.0
+```
+
+`pre.005-fix.001` remplace uniquement ce littéral source par une construction compile-time équivalente `concat!("tracing", "::")`. La propriété testée reste identique ; seule l'interaction entre deux scanners est corrigée.
+
+Statut final du fix après gate opérateur :
+
+```text
+production src                            inchangé
+API publique                              inchangée
+dépendances                               inchangées
+logging runtime Interface                 toujours absent
+codec                                     toujours absent
+version technique                         0.2.13-pre.5.fix.1
+cargo test -p ksp-interface-lib           PASS
+cargo test -p ksp-logging-lib --test ownership PASS
+cargo test --workspace                    PASS
+cargo tree Interface                      Core-only confirmé
+```
+
+## 18. Gate technique final `pre.006`
+
+Le gate final a confirmé la surface complète sans nouvelle modification technique :
+
+```text
+unit Interface                                      10/10 PASS
+dependency boundary                                 4/4 PASS
+external consumer                                   1/1 PASS
+public API                                           5/5 PASS
+release completeness                                3/3 PASS
+ownership Logging                                   2/2 PASS
+workspace                                           PASS
+Cargo graph Interface                               ksp-core-lib uniquement
+```
+
+Les duplicates observés dans le workspace sont extérieurs au graphe normal d'Interface et ne proviennent d'aucune dépendance ajoutée par `0.2.13`.
+
+La validation technique de la release candidate est fermée.
+
+## 19. Réconciliation documentaire `pre.007`
+
+La documentation finale candidate est alignée sur les preuves techniques :
+
+| Référence durable                               | Statut `pre.007` | Contrat réconcilié                                                   |
+|-------------------------------------------------|------------------|----------------------------------------------------------------------|
+| `crates/ksp-interface-lib/README.md`            | PASS structurel  | ownership, surface finale, bornes, firewall, frontières              |
+| `crates/ksp-interface-lib/USAGE.md`             | PASS structurel  | usage crate-root, construction metas/instruction, erreurs et limites |
+| `docs/plans/002-FUNCTIONAL_RELEASE_SEQUENCE.md` | PASS structurel  | contenu réel `0.2.13` + reports `0.2.14` / `0.3.2+`                  |
+| `docs/plans/020-V0_2_13_INTERFACE_PLAN.md`      | PASS structurel  | gate `pre.006` fermé + lane documentaire finale                      |
+| `docs/validation/016-V0_2_13_INTERFACE.md`      | PASS structurel  | statuts finaux et preuves opérateur                                  |
+| index `docs/000`, plans et validation           | PASS structurel  | candidate réconciliée sans publication stable prématurée             |
+
+La tranche n'ajoute aucun code/test/codec/dépendance et ne modifie ni `CHANGELOG.md`, ni `ROADMAP.md`, ni le prompt `0.2.14`. Ces trois surfaces restent réservées à `pre.008`.
+
+Le gate opérateur de `pre.007` doit rester déterministe : audits, check, Clippy et workspace tests suffisent ; aucun smoke live ni nouveau `cargo tree` n'est requis si l'overlay documentaire est appliqué exactement.

docs/validation/017-V0_2_14_PROGRAM_API.md

@@ -0,0 +1,346 @@
+<!-- file: docs/validation/017-V0_2_14_PROGRAM_API.md -->
+<!-- version: 7 -->
+
+# Validation `0.2.14` — Program API foundation
+
+## 1. Objet
+
+Cette matrice, ouverte par `0.2.14-pre.001`, est réconciliée par `pre.007` après fermeture intégralement verte du gate technique `pre.006`. Elle conserve l'historique des preuves par tranche et la surface candidate finale.
+
+Le scope final reste une foundation instruction-only avec output associé à l'implémentation. Registry runtime, payload canonique D3 et `ProgramExecutionPreparer` sont explicitement reportés.
+
+## 2. Gate `pre.001`
+
+| Critère                    | Statut  | Preuve                                                                         |
+|----------------------------|---------|--------------------------------------------------------------------------------|
+| base stable `0.2.13`       | PASS    | Cargo `0.2.13`, `rel.001` et prompt 019 présents                               |
+| metadata Git/tag           | N/A     | archive opérateur sans metadata Git exploitable                                |
+| `ksp-interface-lib` stable | PASS    | surface et canaris `0.2.13` relus                                              |
+| `ksp-program-api` absent   | PASS    | aucun répertoire de crate sur la base                                          |
+| `ksp-program-lib` absent   | PASS    | aucun répertoire de crate sur la base                                          |
+| archive kbot3 disponible   | PASS    | archive historique réellement extraite et auditée                              |
+| règles Program/API relues  | PASS    | règles KSP/Dependencies/Workflow prescrites relues                             |
+| architecture durable relue | PASS    | `002` à `010`, avec `006-WIRE_AND_PROGRAM.md` central                          |
+| audit Core + Interface     | PASS    | input `ProgramInstruction` jugé suffisant pour instruction-only                |
+| matrice héritage kbot3     | PASS    | `REPRENDRE / REDESSINER / REPORTER / REJETER` dans le plan 021                 |
+| ownership matrix           | PASS    | Core/Interface/Program/CORE/Execution séparés dans le plan 021                 |
+| API candidate              | PASS    | recognition + generic outcome + associated-output decoder                      |
+| payload canonique          | REPORTÉ | aucune représentation D3 inventée en `0.2.14`                                  |
+| registry runtime           | REPORTÉ | aucune composition dyn hétérogène dans la release                              |
+| execution preparer         | REPORTÉ | attend un intent technique réel de vertical slice                              |
+| dependency graph           | PASS    | cible Core + Interface uniquement                                              |
+| threat/API model           | PASS    | payload, Debug, open-world, externe hostile, exactness et scope creep couverts |
+| stratégie de tests         | PASS    | unit/public/external/firewall/completeness, aucun live smoke                   |
+| sizing                     | PASS    | release réduite à decoder instruction-only et couloirs de fermeture séparés    |
+
+## 3. Décisions API à prouver par le code
+
+| Contrat                                    | Décision `pre.001`                                      | Gate futur                     |
+|--------------------------------------------|---------------------------------------------------------|--------------------------------|
+| `ProgramInstructionRecognition`            | `NoMatch / ProgramMatch / ExactMatch`, non exhaustif    | PASS `pre.003`                 |
+| `ProgramInstructionDecodeOutcome<Decoded>` | `Decoded(Decoded) / Unsupported`, non exhaustif         | PASS `pre.003`                 |
+| decoder failure                            | `ksp_core_lib::Result`, aucun statut `Failed` parallèle | `pre.003` / `pre.004`          |
+| `ProgramInstructionDecoder`                | `Send + Sync`, associated `Decoded`                     | PASS `pre.004`                 |
+| input                                      | `&ProgramInstruction`                                   | PASS `pre.004`                 |
+| Program IDs déclarés                       | `&[Pubkey]`, opaque et open-world                       | PASS `pre.004`                 |
+| output                                     | type concret de l'implémentation                        | PASS `pre.004`                 |
+| registry dyn                               | absent                                                  | completeness `pre.005`         |
+| identity/version/coverage                  | absents                                                 | completeness `pre.005`         |
+| Program Account/Event/ReturnData decoder   | absents                                                 | completeness `pre.005`         |
+| ProgramExecutionPreparer                   | absent                                                  | completeness `pre.005`         |
+| serde/JSON/codec                           | absents                                                 | firewall `pre.002` / `pre.005` |
+| runtime/logging                            | absents                                                 | firewall `pre.002` / `pre.005` |
+
+## 4. External implementation canary
+
+La preuve matérialisée en `pre.004` utilise une crate d'intégration consommatrice séparée et vérifie :
+
+```text
+implementation de ProgramInstructionDecoder
+associated output défini hors KSP
+Program Pubkey absent du registry Core
+construction de ProgramInstruction via la facade publique retenue
+recognition ProgramMatch ou ExactMatch déterministe
+decode vers Decoded(external value)
+aucun ksp-program-lib
+aucun module privé
+```
+
+Ce canari remplace toute affirmation documentaire non exécutable d'extensibilité. Son gate opérateur `pre.004` est confirmé intégralement vert.
+
+## 5. Dependency firewall cible
+
+Graphe normal attendu :
+
+```text
+ksp-program-api
+├── ksp-core-lib
+│   └── solana-pubkey
+└── ksp-interface-lib
+    └── ksp-core-lib
+```
+
+Interdits :
+
+```text
+Transport
+Store
+Wallet
+Materializer
+Config
+Tauri
+ksp-program-lib
+ksp-logging-lib
+serde / serde_json
+borsh / wincode / bincode
+solana-instruction
+reqwest / tokio / tonic
+tracing
+```
+
+## 6. Threat/API gates futurs
+
+| Gate                      | Attendu                                                                  | Statut initial |
+|---------------------------|--------------------------------------------------------------------------|----------------|
+| unknown Program Pubkey    | utilisable sans registry Core                                            | PASS `pre.004` |
+| max Interface input       | decoder consomme l'input déjà borné sans nouvelle allocation obligatoire | PASS `pre.005` |
+| malformed program payload | `Err` ou `Unsupported`; aucun echo n'est ajouté par le contrat           | PASS `pre.005` |
+| Debug recognition         | aucun payload                                                            | PASS           |
+| Debug outcome             | contenu `Decoded` non rendu automatiquement                              | PASS           |
+| default methods           | aucun default method susceptible de masquer panic/policy                 | PASS `pre.004` |
+| closed-world enum         | aucun inventaire central de Program kinds                                | PASS `pre.004` |
+| serde accidental          | aucune dependency/derive                                                 | PASS `pre.004` |
+| runtime creep             | aucun réseau, wallet, store, logging ou UI                               | PASS `pre.004` |
+| external output           | type tiers accepté sans `Any`/JSON central                               | PASS `pre.004` |
+| dyn claim                 | aucune assertion d'object-safety hétérogène dans cette release           | PASS `pre.004` |
+
+## 7. Gates de fermeture
+
+### Gate technique final
+
+Le gate technique dédié `pre.006` est fermé intégralement vert. Les commandes de référence étaient :
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.2.14
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test -p ksp-program-api
+cargo test -p ksp-logging-lib --test ownership
+cargo test --workspace
+cargo tree -p ksp-program-api --edges normal
+cargo tree --duplicates
+```
+
+### Réconciliation documentaire
+
+`pre.007` ferme :
+
+```text
+ksp-program-api README/USAGE
+plan 021
+validation 017
+indexes/références durables concernées
+```
+
+Sans `CHANGELOG.md`, `ROADMAP.md` ni prompt suivant.
+
+### Préparation de publication
+
+Doit rester limitée à :
+
+```text
+Cargo.toml
+CHANGELOG.md
+ROADMAP.md
+prompt de démarrage 0.3.1
+delta de la prerelease
+```
+
+## 8. Gate opérateur `pre.002`
+
+Le gate fourni le 28 août 2026 est intégralement vert :
+
+```text
+cargo fmt --all                                      PASS
+audit Rust général / exports / workspace             PASS
+audit Markdown                                       PASS — 170 tables / 119 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-program-api                        PASS — 4 tests d'intégration
+cargo test --workspace                               PASS
+cargo tree -p ksp-program-api --edges normal         PASS — Core + Interface uniquement
+cargo tree --duplicates                              exécuté, inventaire workspace observé
+```
+
+Ce gate autorise l'ouverture de `pre.003`.
+
+## 9. État préparé `pre.003`
+
+| Critère                              | Statut | Preuve                                                               |
+|--------------------------------------|--------|----------------------------------------------------------------------|
+| `ProgramInstructionRecognition`      | PASS   | enum non exhaustif `NoMatch / ProgramMatch / ExactMatch`             |
+| `ProgramInstructionDecodeOutcome<T>` | PASS   | enum non exhaustif `Decoded(T) / Unsupported`                        |
+| absence de `Failed` / `Ignored`      | PASS   | échec réservé au futur `Result`; aucun statut parallèle              |
+| Debug recognition                    | PASS   | enum sans payload; Debug dérivé                                      |
+| Debug outcome                        | PASS   | implémentation manuelle sans `T: Debug`, valeur `Decoded` non rendue |
+| dépendances normales                 | PASS   | manifest inchangé : `ksp-core-lib` + `ksp-interface-lib`             |
+| module public                        | PASS   | aucun `pub mod`; exports crate-root uniquement                       |
+| `ProgramInstructionDecoder`          | ABSENT | réservé à `pre.004`                                                  |
+| registry / descriptor / payload D3   | ABSENT | hors scope maintenu                                                  |
+| serde / codec / logging / runtime    | ABSENT | dependency firewall maintenu                                         |
+
+Le gate opérateur `pre.003` est confirmé intégralement vert : audits Rust/Markdown, check, Clippy, tests ciblés, workspace complet et graphes Cargo passent.
+
+## 10. Gate opérateur `pre.003`
+
+```text
+cargo fmt --all                                      PASS
+audit Rust général / exports / workspace             PASS
+audit Markdown                                       PASS — 171 tables / 120 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-program-api                        PASS — 8 tests Rust
+cargo test --workspace                               PASS
+cargo tree -p ksp-program-api --edges normal         PASS — Core + Interface uniquement
+cargo tree --duplicates                              exécuté, inventaire workspace observé
+```
+
+Ce gate autorise l'ouverture de `pre.004`.
+
+## 11. État préparé `pre.004`
+
+| Critère                            | Statut | Preuve                                                               |
+|------------------------------------|--------|----------------------------------------------------------------------|
+| `ProgramInstructionDecoder`        | PASS   | trait public `Send + Sync`                                           |
+| associated `Decoded`               | PASS   | type sans bound imposé, possédé par l'implémentation                 |
+| `program_ids`                      | PASS   | `&[Pubkey]`, aucune validation registry dans l'API                   |
+| `recognize`                        | PASS   | input `&ProgramInstruction`, outcome `ProgramInstructionRecognition` |
+| `decode`                           | PASS   | `Result<ProgramInstructionDecodeOutcome<Self::Decoded>>`             |
+| default methods                    | ABSENT | toutes les méthodes sont obligatoires                                |
+| external implementation canary     | PASS   | test d'intégration downstream-style séparé                           |
+| Program Pubkey non enregistré      | PASS   | assertion `ksp_core_lib::find_program_pubkey(...) == None`           |
+| output externe concret             | PASS   | `ExternalDecodedInstruction` défini dans le consumer canary          |
+| `ksp-program-lib`                  | ABSENT | aucune dépendance ni implémentation officielle                       |
+| registry / descriptor / payload D3 | ABSENT | hors scope maintenu                                                  |
+| serde / codec / logging / runtime  | ABSENT | dependency firewall inchangé                                         |
+
+Le canari d'implémentation consomme la façade `ksp_program_api` pour le trait, les types et les outcomes. Le registry Core n'est utilisé que par l'assertion de test négative et n'est pas réexporté par Program API. Le gate opérateur de `pre.004` est confirmé intégralement vert et autorise `pre.005`.
+
+## 12. Gate opérateur `pre.004`
+
+Le gate fourni le 28 août 2026 est intégralement vert :
+
+```text
+cargo fmt --all                                      PASS
+audit Rust général / exports / workspace             PASS
+audit Markdown                                       PASS — 172 tables / 121 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-program-api                        PASS — 11 tests Rust
+cargo test --workspace                               PASS
+cargo tree -p ksp-program-api --edges normal         PASS — Core + Interface uniquement
+cargo tree --duplicates                              exécuté, inventaire workspace observé
+```
+
+Ce gate autorise l'ouverture de `pre.005`.
+
+## 13. État préparé `pre.005`
+
+| Critère                              | Statut | Preuve                                                               |
+|--------------------------------------|--------|----------------------------------------------------------------------|
+| exact crate-root export inventory    | PASS   | test `release_completeness` sur les 10 réexports                     |
+| exact production module inventory    | PASS   | `lib.rs`, decode vocabulary et decoder trait uniquement              |
+| public enum inventory                | PASS   | Recognition + DecodeOutcome uniquement                               |
+| closed-world Program enum            | ABSENT | aucun `ProgramKind`/inventaire public central                        |
+| registry / descriptors               | ABSENT | aucune collection/runtime selection/identity-version-coverage        |
+| `ProgramExecutionPreparer`           | ABSENT | scope négatif maintenu                                               |
+| serde / JSON / Any / codecs          | ABSENT | manifest + source canaries                                           |
+| logging / runtime / IO               | ABSENT | aucune dépendance ou primitive runtime/FS/env/network                |
+| max Interface input                  | PASS   | 255 accounts + 10 240 bytes traversent le trait par référence        |
+| malformed hostile payload            | PASS   | `Result::Err` Core reste sûr sans echo automatique du payload        |
+| Debug outcome                        | PASS   | valeur décodée jamais formatée                                       |
+| associated `Decoded` implicit bounds | ABSENT | canari avec output `Rc<Cell<_>>`, donc non-`Send`/non-`Sync` accepté |
+| dyn heterogeneous claim              | ABSENT | aucun `dyn ProgramInstructionDecoder`/registry                       |
+| dépendances normales                 | PASS   | `ksp-core-lib` + `ksp-interface-lib` uniquement                      |
+
+La sécurité des messages/contextes produits volontairement par une implémentation tierce reste sa responsabilité ; `ksp-program-api` garantit seulement qu'il n'ajoute aucun canal parallèle ni copie automatique du payload hostile.
+
+Le gate opérateur de `pre.005` a révélé uniquement le faux positif cross-crate logging corrigé par `pre.005-fix.001`. Le gate du fix est désormais intégralement vert et autorise le gate technique final `pre.006`.
+
+## 14. Gate opérateur `pre.005-fix.001`
+
+Le gate fourni le 28 août 2026 est intégralement vert :
+
+```text
+cargo fmt --all                                      PASS
+audit Rust général / exports / workspace             PASS
+audit Markdown                                       PASS — 173 tables / 123 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-program-api                        PASS — 18 tests Rust
+cargo test -p ksp-logging-lib --test ownership       PASS — 2/2
+cargo test --workspace                               PASS
+cargo tree -p ksp-program-api --edges normal         PASS — Core + Interface uniquement
+cargo tree --duplicates                              inspecté
+```
+
+Le faux positif `tracing` du canari `release_completeness.rs` est fermé sans ajout de dépendance, sans modification de production et sans affaiblissement du scanner logging workspace.
+
+## 15. Gate technique final préparé `pre.006`
+
+`pre.006` ne modifie aucun fichier de production ni de test. Le gate final doit confirmer la candidate suivante sans élargissement :
+
+| Critère                              | Attendu `pre.006`                         |
+|--------------------------------------|-------------------------------------------|
+| API Program                          | exactement la surface fermée en `pre.005` |
+| tests `ksp-program-api`              | 18 tests Rust PASS                        |
+| ownership Logging                    | 2 tests PASS                              |
+| workspace                            | PASS                                      |
+| graphe normal `ksp-program-api`      | Core + Interface uniquement               |
+| registry / preparer / payload D3     | ABSENTS                                   |
+| serde / codec / logging runtime / IO | ABSENTS                                   |
+| README / USAGE                       | non réconciliés ici                       |
+| CHANGELOG / ROADMAP / prompt suivant | non modifiés                              |
+
+Aucun smoke réseau/live n'est requis : `ksp-program-api` reste une API déclarative instruction-only sans I/O.
+
+## 16. Gate technique final `pre.006`
+
+Le gate opérateur fourni le 28 août 2026 confirme la candidate technique complète :
+
+```text
+cargo fmt --all                                      PASS
+audits Rust / export completeness / workspace        PASS
+audit Markdown                                       PASS — 174 tables / 124 fichiers
+cargo check --workspace                              PASS
+cargo clippy --workspace --all-targets               PASS
+cargo test -p ksp-program-api                        PASS — 18 tests Rust
+cargo test -p ksp-logging-lib --test ownership       PASS — 2/2
+cargo test --workspace                               PASS
+cargo tree -p ksp-program-api --edges normal         PASS — Core + Interface uniquement
+cargo tree --duplicates                              inspecté
+```
+
+Les duplicates observés sont ceux du workspace global et ne proviennent d'aucune dépendance ajoutée par Program API. Aucun smoke live n'est applicable à cette foundation déclarative sans I/O.
+
+La validation technique de la release candidate est fermée.
+
+## 17. Réconciliation documentaire `pre.007`
+
+La documentation finale candidate est alignée sur les preuves techniques :
+
+| Référence durable                               | Statut `pre.007` | Contrat réconcilié                                                        |
+|-------------------------------------------------|------------------|---------------------------------------------------------------------------|
+| `crates/ksp-program-api/README.md`              | PASS structurel  | ownership, surface exacte, semantics, hardening, firewall et frontières   |
+| `crates/ksp-program-api/USAGE.md`               | PASS structurel  | usage crate-root, implémentation externe, sélection, outcome et Debug sûr |
+| `docs/plans/002-FUNCTIONAL_RELEASE_SEQUENCE.md` | PASS structurel  | contenu réel `0.2.14` + reports runtime/D3/preparer                       |
+| `docs/plans/021-V0_2_14_PROGRAM_API_PLAN.md`    | PASS structurel  | gate `pre.006` fermé + lane documentaire finale                           |
+| `docs/validation/017-V0_2_14_PROGRAM_API.md`    | PASS structurel  | statuts finaux et preuves opérateur                                       |
+| index `docs/000`, plans et validation           | PASS structurel  | candidate réconciliée sans publication stable prématurée                  |
+
+La tranche ne modifie aucun code/test/manifest de crate/dépendance et ne touche ni `CHANGELOG.md`, ni `ROADMAP.md`, ni le prompt `0.3.1`. Ces surfaces restent réservées à la préparation minimale de publication `pre.008`.
+
+Le gate opérateur de `pre.007` doit rester déterministe : audits, check, Clippy, tests ciblés Program/Logging et workspace suffisent ; aucun smoke live ni nouveau `cargo tree` n'est requis si l'overlay documentaire est appliqué exactement.
+