diff --git a/Cargo.toml b/Cargo.toml
index 323f5a1..7a3d7b9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,12 +1,12 @@
 # file: Cargo.toml
-# version: 144
+# version: 145
 
 [workspace]
 resolver = "3"
 members = ["crates/ksp-app-config-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.5-pre.2.fix.1"
+version = "0.2.5-pre.2.fix.2"
 edition = "2024"
 license = "MIT"
 repository = "https://git.sasedev.com/Sasedev/khadhroony-solana-project"
diff --git a/crates/ksp-wallet-lib/tests/dependency_boundary.rs b/crates/ksp-wallet-lib/tests/dependency_boundary.rs
index 561a024..46f0f94 100644
--- a/crates/ksp-wallet-lib/tests/dependency_boundary.rs
+++ b/crates/ksp-wallet-lib/tests/dependency_boundary.rs
@@ -1,5 +1,5 @@
 // file: crates/ksp-wallet-lib/tests/dependency_boundary.rs
-// version: 1
+// version: 2
 
 //! Wallet-specific dependency and ownership canaries.
 
@@ -7,24 +7,37 @@ fn crate_root() -> std::path::PathBuf {
     return std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
 }
 
-fn rust_source_files(directory: &std::path::Path) -> std::vec::Vec<std::path::PathBuf> {
-    let entries = std::fs::read_dir(directory).expect("Wallet source directory must be readable during integration tests");
+fn rust_source_files(directory: &std::path::Path) -> std::io::Result<std::vec::Vec<std::path::PathBuf>> {
+    let entries = match std::fs::read_dir(directory) {
+        std::result::Result::Ok(entries) => entries,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
     let mut files = std::vec::Vec::new();
     for entry in entries {
-        let entry = entry.expect("Wallet source directory entry must be readable");
+        let entry = match entry {
+            std::result::Result::Ok(entry) => entry,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
         let path = entry.path();
         if path.is_dir() {
-            files.extend(rust_source_files(path.as_path()));
+            let nested_files = match rust_source_files(path.as_path()) {
+                std::result::Result::Ok(nested_files) => nested_files,
+                std::result::Result::Err(error) => return std::result::Result::Err(error),
+            };
+            files.extend(nested_files);
         } else if path.extension() == std::option::Option::Some(std::ffi::OsStr::new("rs")) {
             files.push(path);
         }
     }
-    return files;
+    return std::result::Result::Ok(files);
 }
 
 #[test]
-fn wallet_manifest_preserves_dependency_firewall() {
-    let manifest = std::fs::read_to_string(crate_root().join("Cargo.toml")).expect("Wallet manifest must be readable during integration tests");
+fn wallet_manifest_preserves_dependency_firewall() -> std::io::Result<()> {
+    let manifest = match std::fs::read_to_string(crate_root().join("Cargo.toml")) {
+        std::result::Result::Ok(manifest) => manifest,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
     assert!(manifest.contains("ksp-core-lib"));
     assert!(manifest.contains("ksp-logging-lib"));
     assert!(manifest.contains("zeroize.workspace = true"));
@@ -40,14 +53,21 @@ fn wallet_manifest_preserves_dependency_firewall() {
     ] {
         assert!(!manifest.contains(forbidden), "forbidden direct Wallet dependency detected: {forbidden}");
     }
+    return std::result::Result::Ok(());
 }
 
 #[test]
-fn wallet_sources_use_core_pubkey_logging_facade_and_no_environment() {
-    let source_files = rust_source_files(crate_root().join("src").as_path());
+fn wallet_sources_use_core_pubkey_logging_facade_and_no_environment() -> std::io::Result<()> {
+    let source_files = match rust_source_files(crate_root().join("src").as_path()) {
+        std::result::Result::Ok(source_files) => source_files,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
     let mut all_source = std::string::String::new();
     for source_file in source_files {
-        let source = std::fs::read_to_string(source_file.as_path()).expect("Wallet Rust source must be readable during integration tests");
+        let source = match std::fs::read_to_string(source_file.as_path()) {
+            std::result::Result::Ok(source) => source,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
         all_source.push_str(source.as_str());
     }
     assert!(all_source.contains("ksp_core_lib::Pubkey"));
@@ -56,4 +76,5 @@ fn wallet_sources_use_core_pubkey_logging_facade_and_no_environment() {
     assert!(!all_source.contains("solana_pubkey::"));
     assert!(!all_source.contains("std::env::"));
     assert!(!all_source.contains("tracing::"));
+    return std::result::Result::Ok(());
 }
diff --git a/deltas/0.2.5/pre.002-fix.002.md b/deltas/0.2.5/pre.002-fix.002.md
new file mode 100644
index 0000000..5d03844
--- /dev/null
+++ b/deltas/0.2.5/pre.002-fix.002.md
@@ -0,0 +1,132 @@
+<!-- file: deltas/0.2.5/pre.002-fix.002.md -->
+<!-- version: 1 -->
+
+# Delta `0.2.5-pre.002-fix.002` — conformité Clippy du canari de frontière Wallet
+
+## Base requise
+
+```text
+livraison : 0.2.5-pre.002-fix.001
+workspace.package.version = "0.2.5-pre.2.fix.1"
+```
+
+La base fonctionnelle reste l'archive Gitea opérateur `0.2.5-pre.002`, complétée par le delta `pre.002-fix.001` déjà appliqué. Aucun fichier historique n'est réécrit.
+
+## Motif
+
+La validation opérateur après `pre.002-fix.001` donne :
+
+```text
+cargo fmt --all                        OK
+cargo check --workspace                OK
+cargo clippy --workspace --all-targets ECHEC
+cargo test -p ksp-wallet-lib           OK
+```
+
+Clippy rejette deux appels à `expect()` dans le helper d'intégration `rust_source_files()` de `crates/ksp-wallet-lib/tests/dependency_boundary.rs` au titre de `clippy::expect_used`.
+
+`RUST-ERR-006` n'autorise `unwrap`/`expect` dans les tests que dans la limite permise par la configuration Clippy. `allow-expect-in-tests = true` couvre les fonctions `#[test]`, mais le helper concerné n'est pas lui-même une fonction `#[test]`. Pour rendre le canari robuste et homogène, le correctif retire en plus les autres `expect()` de ce fichier d'intégration au lieu de dépendre de cette exception locale.
+
+## Correction
+
+`rust_source_files()` retourne désormais :
+
+```text
+std::io::Result<Vec<PathBuf>>
+```
+
+et traite explicitement les erreurs de :
+
+```text
+read_dir
+lecture des DirectoryEntry
+récursion dans les sous-répertoires
+```
+
+sans :
+
+```text
+unwrap
+expect
+?
+allow local de lint
+```
+
+Les deux fonctions `#[test]` retournent elles-mêmes `std::io::Result<()>` et propagent explicitement les erreurs filesystem. Le fichier d'intégration ne contient donc plus aucun `unwrap()` ni `expect()`.
+
+Aucun comportement de `ksp-wallet-lib`, aucun contrat VIEW/OWNER, aucune dépendance et aucun format `.kspwallet` ne changent.
+
+## Version Cargo
+
+Le correctif modifie une source Rust participant au build de tests. Conformément à `VER-ID-007` et `VER-ID-010` :
+
+```text
+0.2.5-pre.2.fix.1 -> 0.2.5-pre.2.fix.2
+```
+
+## Fichiers modifiés
+
+```text
+Cargo.toml
+crates/ksp-wallet-lib/tests/dependency_boundary.rs
+```
+
+## Fichiers ajoutés
+
+```text
+deltas/0.2.5/pre.002-fix.002.md
+```
+
+## Fichiers supprimés
+
+Aucun.
+
+## Fichiers volontairement inchangés
+
+```text
+crates/ksp-wallet-lib/src/**
+deltas/0.2.5/pre.002.md
+deltas/0.2.5/pre.002-fix.001.md
+docs/**
+ROADMAP.md
+CHANGELOG.md
+```
+
+## Validations déjà exécutées par l'opérateur sur `pre.002-fix.001`
+
+- `cargo fmt --all` : OK ;
+- `cargo check --workspace` : OK ;
+- `cargo clippy --workspace --all-targets` : échec uniquement sur les deux `expect()` du helper `rust_source_files()` ;
+- `cargo test -p ksp-wallet-lib` : OK :
+  - 7 unit tests ;
+  - 2 dependency-boundary tests ;
+  - 4 public API tests ;
+  - 2 doctests `compile_fail`.
+
+## Validation attendue après application
+
+```bash
+cargo fmt --all
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test -p ksp-wallet-lib
+```
+
+À la clôture de la tranche Rust, `cargo test --workspace` reste également requis par `RUST` selon le checkpoint de session retenu.
+
+## Décisions
+
+- ne pas contourner `clippy::expect_used` par un `#[allow]` local ;
+- ne conserver aucun `unwrap()`/`expect()` dans ce canari d'intégration, même là où l'exception Clippy les aurait autorisés ;
+- ne pas utiliser `?`, également interdit par les lints workspace ;
+- ne pas élargir le périmètre fonctionnel de `pre.002`.
+
+## Questions ouvertes
+
+Aucune nouvelle question fonctionnelle introduite par ce correctif.
+
+## Commit attendu
+
+```text
+v0.2.5-pre.002-fix.002
+```