diff --git a/Cargo.toml b/Cargo.toml
index 84d6668..b7b5851 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,12 +1,12 @@
 # file: Cargo.toml
-# version: 257
+# version: 258
 
 [workspace]
 resolver = "3"
 members = ["crates/ksp-app-config-desk", "crates/ksp-app-wallet-desk", "crates/ksp-config-lib", "crates/ksp-core-lib", "crates/ksp-logging-lib", "crates/ksp-onchain-transport-lib", "crates/ksp-wallet-lib"]
 
 [workspace.package]
-version = "0.2.9-pre.13.fix.3"
+version = "0.2.9-pre.13.fix.4"
 edition = "2024"
 license = "MIT"
 repository = "https://git.sasedev.com/Sasedev/khadhroony-solana-project"
diff --git a/crates/ksp-onchain-transport-lib/tests/yellowstone_publicnode_smoke.rs b/crates/ksp-onchain-transport-lib/tests/yellowstone_publicnode_smoke.rs
index ee12ae1..92362fe 100644
--- a/crates/ksp-onchain-transport-lib/tests/yellowstone_publicnode_smoke.rs
+++ b/crates/ksp-onchain-transport-lib/tests/yellowstone_publicnode_smoke.rs
@@ -1,5 +1,5 @@
 // file: crates/ksp-onchain-transport-lib/tests/yellowstone_publicnode_smoke.rs
-// version: 4
+// version: 5
 
 //! Opt-in live PublicNode Mainnet/Testnet smokes for authenticated provider-neutral Yellowstone gRPC Subscribe.
 
@@ -14,7 +14,10 @@ static PUBLICNODE_X_TOKENS: std::sync::OnceLock<PublicNodeTokens> = std::sync::O
 
 fn read_token_line(label: &str) -> std::string::String {
     let mut token = std::string::String::new();
-    std::io::stdin().read_line(&mut token).expect("PublicNode x-token must be readable from smoke stdin");
+    match std::io::stdin().read_line(&mut token) {
+        std::result::Result::Ok(_) => {},
+        std::result::Result::Err(error) => panic!("PublicNode {label} x-token must be readable from smoke stdin: {error}"),
+    }
     let token = token.trim().to_owned();
     assert!(!token.is_empty(), "PublicNode {label} x-token provided on smoke stdin must not be empty");
     return token;
@@ -58,7 +61,10 @@ fn publicnode_endpoint(
         url,
         session,
     );
-    let metadata = ksp_onchain_transport_lib::YellowstoneGrpcMetadataEntry::secret("x-token", x_token)?;
+    let metadata = match ksp_onchain_transport_lib::YellowstoneGrpcMetadataEntry::secret("x-token", x_token) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
     return endpoint.with_metadata(vec![metadata]);
 }
 
@@ -68,35 +74,61 @@ fn slot_request() -> ksp_core_lib::Result<ksp_onchain_transport_lib::Yellowstone
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(error) => return std::result::Result::Err(error),
     };
-    request.insert_slot_filter(name, ksp_onchain_transport_lib::YellowstoneSubscribeSlotFilter::new())?;
+    match request.insert_slot_filter(name, ksp_onchain_transport_lib::YellowstoneSubscribeSlotFilter::new()) {
+        std::result::Result::Ok(()) => {},
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    }
     return std::result::Result::Ok(request);
 }
 
 async fn assert_publicnode_slot_stream(name: &str, cluster: &str, url: &str, x_token: &str) {
-    let endpoint = publicnode_endpoint(name, cluster, url, x_token).expect("programmatic PublicNode Yellowstone settings must accept secret x-token metadata");
+    let endpoint = match publicnode_endpoint(name, cluster, url, x_token) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => panic!("programmatic PublicNode Yellowstone settings must accept secret x-token metadata: {error:?}"),
+    };
     let endpoint_debug = format!("{endpoint:?}");
     assert!(!endpoint_debug.contains(x_token), "PublicNode x-token must not appear in endpoint Debug");
-    let channel = ksp_onchain_transport_lib::YellowstoneGrpcChannel::connect(&endpoint).await.expect("PublicNode Yellowstone TLS connection must succeed");
+    let channel = match ksp_onchain_transport_lib::YellowstoneGrpcChannel::connect(&endpoint).await {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => panic!("PublicNode Yellowstone TLS connection must succeed: {error:?}"),
+    };
     assert_eq!(channel.endpoint_name(), name);
     assert_eq!(channel.provider().as_str(), "publicnode");
     assert_eq!(channel.cluster().as_str(), cluster);
-    let request = slot_request().expect("PublicNode Yellowstone slot request must be valid");
-    let mut session = channel.open_standard_subscribe(request).await.expect("PublicNode Yellowstone authenticated Subscribe must open");
-    let slot = tokio::time::timeout(std::time::Duration::from_secs(20), async {
+    let request = match slot_request() {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => panic!("PublicNode Yellowstone slot request must be valid: {error:?}"),
+    };
+    let mut session = match channel.open_standard_subscribe(request).await {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => panic!("PublicNode Yellowstone authenticated Subscribe must open: {error:?}"),
+    };
+    let slot_result = tokio::time::timeout(std::time::Duration::from_secs(20), async {
         loop {
-            match session.next_update().await.expect("PublicNode Yellowstone Subscribe update must decode") {
-                std::option::Option::Some(ksp_onchain_transport_lib::YellowstoneSubscribeUpdate::Slot(update)) => break update.slot(),
+            let next_update = match session.next_update().await {
+                std::result::Result::Ok(value) => value,
+                std::result::Result::Err(error) => panic!("PublicNode Yellowstone Subscribe update must decode: {error:?}"),
+            };
+            match next_update {
+                std::option::Option::Some(ksp_onchain_transport_lib::YellowstoneSubscribeUpdate::Slot(update)) => return update.slot(),
                 std::option::Option::Some(_) => {},
                 std::option::Option::None => panic!("PublicNode Yellowstone Subscribe ended before a slot update"),
             }
         }
     })
-    .await
-    .expect("PublicNode Yellowstone Subscribe must publish a slot update before the smoke deadline");
+    .await;
+    let slot = match slot_result {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => panic!("PublicNode Yellowstone Subscribe must publish a slot update before the smoke deadline: {error}"),
+    };
     assert!(slot > 0);
-    let close_result = tokio::time::timeout(std::time::Duration::from_secs(7), session.close())
-        .await
-        .expect("KSP Yellowstone Subscribe close must remain bounded beyond the configured five-second provider half-close deadline");
+    let close_timeout_result = tokio::time::timeout(std::time::Duration::from_secs(7), session.close()).await;
+    let close_result = match close_timeout_result {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => {
+            panic!("KSP Yellowstone Subscribe close must remain bounded beyond the configured five-second provider half-close deadline: {error}")
+        },
+    };
     match close_result {
         std::result::Result::Ok(()) => {},
         std::result::Result::Err(error) => {
@@ -107,6 +139,7 @@ async fn assert_publicnode_slot_stream(name: &str, cluster: &str, url: &str, x_t
             );
         },
     }
+    return;
 }
 
 #[tokio::test(flavor = "current_thread")]
diff --git a/deltas/0.2.9/pre.013-fix.004.md b/deltas/0.2.9/pre.013-fix.004.md
new file mode 100644
index 0000000..81df7f7
--- /dev/null
+++ b/deltas/0.2.9/pre.013-fix.004.md
@@ -0,0 +1,136 @@
+<!-- file: deltas/0.2.9/pre.013-fix.004.md -->
+<!-- version: 1 -->
+
+# Delta `0.2.9-pre.013-fix.004` — conformité Clippy du smoke PublicNode final
+
+## 1. Base
+
+```text
+0.2.9-pre.013-fix.003
+```
+
+Cette tranche reste strictement dans le couloir technique/live de fin de release. Elle ne modifie ni Config, ni README/USAGE, ni plan/validation, ni CHANGELOG/ROADMAP, ni le prompt de la release suivante.
+
+## 2. Motif opérateur
+
+La validation opérateur de `pre.013-fix.003` confirme le comportement live final du smoke PublicNode :
+
+```text
+Mainnet Subscribe + slot   PASS
+Testnet Subscribe + slot   PASS
+2 passed / 0 failed
+```
+
+Elle confirme aussi :
+
+```text
+cargo fmt --all                                      PASS
+python3 scripts/audit_rust_workspace_rules.py       clean / 0 export candidate / clean
+cargo check --workspace                              PASS
+cargo test -p ksp-config-lib                         113 unit + 5 ownership + 15 public API PASS
+cargo test -p ksp-onchain-transport-lib              383 unit + 49 public API + 43 completeness + 4 doctests PASS
+cargo test -p ksp-core-lib --test workspace_dependencies   3/3 PASS
+cargo test --workspace                               PASS
+cargo tree -p ksp-onchain-transport-lib              exécuté
+cargo tree -p ksp-onchain-transport-lib --duplicates exécuté
+cargo tree --duplicates                              exécuté
+```
+
+Le seul gate en échec est :
+
+```text
+cargo clippy --workspace --all-targets
+```
+
+Clippy relève onze violations localisées exclusivement dans `tests/yellowstone_publicnode_smoke.rs` : huit `clippy::expect_used`, deux `clippy::question_mark_used` et un `clippy::implicit_return`.
+
+Aucun défaut fonctionnel du moteur Yellowstone, de Config ou du live PublicNode n'est révélé par ce gate.
+
+## 3. Version technique
+
+`workspace.package.version` devient :
+
+```text
+0.2.9-pre.13.fix.4
+```
+
+## 4. Correction du smoke
+
+Le smoke conserve exactement le même contrat fonctionnel et opérateur que `fix.003` :
+
+- deux lignes de token sur stdin, Mainnet puis Testnet ;
+- metadata secrète `x-token` ;
+- ouverture TLS puis `Subscribe` ;
+- attente bornée d'un `YellowstoneSubscribeUpdate::Slot` ;
+- `slot > 0` obligatoire ;
+- fermeture gracieuse ou timeout KSP de half-close accepté uniquement après réception du slot ;
+- aucune lecture Config/env KSP depuis Transport ;
+- aucun secret dans URL, arguments ou diagnostics.
+
+Seule la forme Rust du harness est corrigée :
+
+- tous les `expect()` des helpers non annotés `#[test]` sont remplacés par des `match` explicites ;
+- les deux propagations `?` sont remplacées par des branches `Result::Err` explicites ;
+- la sortie du `async` d'attente de slot utilise `return update.slot()` ;
+- la borne externe de fermeture est contrôlée par `match` plutôt que `expect()` ;
+- aucun `#[allow(clippy::expect_used)]`, `#[allow(clippy::question_mark_used)]` ou `#[allow(clippy::implicit_return)]` n'est ajouté.
+
+Le runtime Transport n'est pas modifié.
+
+## 5. Inspection finale du graphe déjà exécutée
+
+Le graphe Transport communiqué par l'opérateur confirme la stack gRPC attendue :
+
+```text
+yellowstone-grpc-proto 12.6.0
+tonic                  0.14.6
+tonic-prost            0.14.6
+prost                   0.14.4
+prost-types             0.14.4
+```
+
+Aucun `yellowstone-grpc-client` n'est introduit comme seconde abstraction runtime. Les doublons signalés par Cargo concernent notamment les contextes build/runtime et des transitifs génériques ; le graphe communiqué ne montre pas de seconde version concurrente de `tonic` ou `prost` dans la stack Yellowstone Transport.
+
+## 6. Gate opérateur ciblé à rejouer
+
+Le correctif ne changeant que le harness live et la version Cargo, le gate minimal est :
+
+```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.9
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test -p ksp-onchain-transport-lib
+cargo test --workspace
+```
+
+Puis le smoke live final, avec les credentials déjà validés :
+
+```bash
+read -rsp 'PublicNode Mainnet Yellowstone x-token: ' PUBLICNODE_MAINNET_TOKEN
+echo
+read -rsp 'PublicNode Testnet Yellowstone x-token: ' PUBLICNODE_TESTNET_TOKEN
+echo
+printf '%s\n%s\n' "$PUBLICNODE_MAINNET_TOKEN" "$PUBLICNODE_TESTNET_TOKEN" \
+  | cargo test -p ksp-onchain-transport-lib --test yellowstone_publicnode_smoke -- --ignored --nocapture
+unset PUBLICNODE_MAINNET_TOKEN PUBLICNODE_TESTNET_TOKEN
+```
+
+Attendu :
+
+```text
+2 passed
+0 failed
+0 ignored
+```
+
+Les trois `cargo tree` n'ont pas besoin d'être rejoués si le payload appliqué correspond exactement à ce delta : aucune dépendance ni feature Cargo n'est modifiée.
+
+## 7. Fichiers modifiés/ajoutés
+
+```text
+Cargo.toml
+crates/ksp-onchain-transport-lib/tests/yellowstone_publicnode_smoke.rs
+deltas/0.2.9/pre.013-fix.004.md
+```