diff --git a/Cargo.toml b/Cargo.toml
index 533f2c1..51cd123 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,12 +1,12 @@
 # file: Cargo.toml
-# version: 174
+# version: 175
 
 [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.6-pre.7.fix.2"
+version = "0.2.6-pre.8"
 edition = "2024"
 license = "MIT"
 repository = "https://git.sasedev.com/Sasedev/khadhroony-solana-project"
@@ -34,6 +34,7 @@ tempfile = { version = "^3.27" }
 chrono = { version = "^0.4", default-features = false }
 tauri = { version = "^2.11" }
 tauri-build = { version = "^2.6" }
+tauri-plugin-dialog = { version = "^2.7" }
 tauri-plugin-tracing = { version = "^0.3" }
 ts-rs = { version = "^12.0" }
 zeroize = { version = "^1.9" }
diff --git a/ROADMAP.md b/ROADMAP.md
index 9399381..6d5e981 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -1,5 +1,5 @@
 <!-- file: ROADMAP.md -->
-<!-- version: 72 -->
+<!-- version: 73 -->
 
 # Roadmap KSP
 
@@ -50,7 +50,7 @@ Le roadmap décrit les objectifs à atteindre et les grandes étapes prévues. U
 - [X] `0.2.3` — HTTP Transactions stable : 11/11 wrappers typés publiés, classification `8 Read / 2 WriteSubmission / 1 Simulation`, no-resend ambigu prouvé pour les write submissions, `KSP-TRANSPORT-007` réaudité conforme sur les 37 wrappers HTTP courants, graphes Cargo et deux smokes Devnet validés ; `0.2.4` reprend les 15 Blocks/Economics restants.
 - [X] `0.2.4` — HTTP Blocks + Economics stable : 15/15 wrappers `V0_2_4` publiés, surface typed complète à 52/52 méthodes courantes, 14/14 historiques conservées, réaudit SIMD/inventaire final et `KSP-TRANSPORT-007` global validés ; deux smokes Devnet passés avant publication.
 - [X] `0.2.5` — Wallet foundation stable : `.kspwallet` V1, VIEW/OWNER indépendants, Argon2id/XChaCha20-Poly1305, autorité Ed25519 OWNER, persistence no-clobber, signature, administration/rotations/révocation VIEW forte, import/export Solana CLI JSON + Base58, canaris adversariaux, interop externe et documentation durable publiés. La clôture `pre.010-fix.001`–`fix.003` ajoute `ed25519-dalek 3.0.0` direct, normalise le Rust workspace et installe l’audit structurel Python complémentaire à rustfmt/Clippy. `Pubkey` reste via `ksp-core-lib`, la keypair reste encapsulée dans Wallet et Config/Transport/ExecutionPolicy/Store/Tauri restent hors Wallet.
-- [ ] `0.2.6` — Introduire `ksp-app-wallet-desk` utilisant Config composite + Wallet + transport HTTP. `pre.001` fixe le sizing et le gabarit ; `pre.002` matérialise la crate Tauri et son shell splash/main avec Config + Logging bootstrap, ports `1432/1433`, Bootstrap, Font Awesome, DataTables/Select, SimpleBar, resize-observer-polyfill, TS-RS et bridge frontend Logging. `pre.003` matérialise `cfg.std.wallet`/`schema.std.wallet`, le composite `cfg.composite.ksp-app-wallet-desk`, `ResolvedWalletConfig`, `wallets_directory` global + `wallets_subdirectory` par profil et la préparation automatique des répertoires côté application avec logs debug/error. `pre.003-fix.001` corrige les premiers canaris Config et active la trace des interactions frontend sans valeur de contrôle. `pre.003-fix.002` corrige le scanner `.env.example` sur les fragments d’identifiants Rust, généralise `std.logging` avec les profils console-only, `file_info`, `superdev` et `supertrace`, et sélectionne temporairement `supertrace` dans le composite Wallet Desk. `pre.003-fix.003` corrige les canaris de ce changement : closures explicites compatibles avec `clippy::implicit_return` et distinction entre fragment KSP incorporé dans un identifiant et nom d’environnement concret suffixé. `pre.003-fix.004` corrige les cinq closures restantes du canari de composition Wallet Desk afin que `cargo clippy --workspace --all-targets` respecte intégralement `clippy::implicit_return`, sans modifier Config ni Logging. `pre.004` branche ensuite l’inventory réel `.kspwallet` sur le répertoire effectif Config : enumeration non récursive, extension exacte, fichiers réguliers uniquement, rejet des symlinks, inspection locked via `ksp-wallet-lib`, diagnostics sûrs par ligne, DataTable réel, refresh et sélection root-scoped revalidée côté Rust sans Pubkey/alias/notes. `pre.004-fix.001` limite les deux réexports crate-root internes utilisés uniquement par les unit tests à `#[cfg(test)]`, afin de fermer les warnings `unused_imports` observés par `cargo check`, Clippy, tests et `tauri dev` sans modifier le comportement d’inventory. `pre.005` ajoute la création native `create_wallet_file_v1`, le formulaire OWNER + VIEW optionnel et le premier `WalletSession` durable côté Rust : OWNER reste ouvert après création, sélection existante reste Locked, tandis que lock/deselect/refresh/changement de wallet détruisent le handle et purgent les projections protégées. `pre.005-fix.001` corrige le premier gate opérateur de cette tranche : `WalletOwner` est indirecté par `Box` dans `WalletSession::Owner` pour fermer `clippy::large_enum_variant`, et le canari `desktop_security` retrouve explicitement le début de `WalletCreateRequestDto` avant de vérifier que les passwords restent request-only. `pre.006` ajoute ensuite les unlock explicites VIEW/OWNER : saisie manuelle request-only, découverte des candidats `KSP_SECRET_WALLET_PASS_*` exclusivement via Config, ordre filename normalisé puis numérique puis nommé, tentative configurée uniquement sur action utilisateur, état transitoire `PrivilegedOperation` pendant Argon2 et projection frontend limitée au nombre de candidats sans nom/suffixe/valeur. `pre.006-fix.001` corrige uniquement les deux canaris statiques de sécurité : ils inspectent désormais les champs réels de `WalletAuthorizedDto` au lieu de considérer le mot `password` présent dans sa documentation de `configured_secret_candidate_count` comme une fuite de champ. `pre.007` ferme ensuite le MVP obligatoire : l'adapter Transport accepte un profil déjà sélectionné par composite avec provenance `Composite`, Wallet Desk construit `HttpTransportPool` au bootstrap, expose des diagnostics profile/cluster/provider sans URL, extrait la Pubkey uniquement d'une session VIEW/OWNER Rust, puis appelle le wrapper typé `getBalance` en `confirmed` et projette lamports exacts, SOL décimal, slot et `api_version`. Le frontend ne fournit ni Pubkey ni endpoint au refresh et toute balance est purgée lors du lock/deselect/changement de wallet. `pre.007-fix.001` corrige le canari d'intégration `config_composition` qui appelait le constructeur interne test-only `ConfigEnvironment::from_maps`; le test consomme désormais uniquement l'API publique `ConfigEnvironment::load`, comme le runtime Wallet Desk, sans modification du pool Transport ni du frontend. `pre.007-fix.002` corrige le diagnostic de ce même canari : l'assertion sur `ConfigEnvironment::load()` ne tente plus de formatter `Result<ConfigEnvironment, _>` avec `Debug`, trait volontairement absent de `ConfigEnvironment`; le contrat runtime reste inchangé. Les tranches suivantes ajoutent administration/import/export, avec une dernière tranche prévue pour README/USAGE/docs/validation, prompt `0.2.7` et build Tauri final.
+- [ ] `0.2.6` — Introduire `ksp-app-wallet-desk` utilisant Config composite + Wallet + transport HTTP. `pre.001` fixe le sizing et le gabarit ; `pre.002` matérialise la crate Tauri et son shell splash/main avec Config + Logging bootstrap, ports `1432/1433`, Bootstrap, Font Awesome, DataTables/Select, SimpleBar, resize-observer-polyfill, TS-RS et bridge frontend Logging. `pre.003` matérialise `cfg.std.wallet`/`schema.std.wallet`, le composite `cfg.composite.ksp-app-wallet-desk`, `ResolvedWalletConfig`, `wallets_directory` global + `wallets_subdirectory` par profil et la préparation automatique des répertoires côté application avec logs debug/error. `pre.003-fix.001` corrige les premiers canaris Config et active la trace des interactions frontend sans valeur de contrôle. `pre.003-fix.002` corrige le scanner `.env.example` sur les fragments d’identifiants Rust, généralise `std.logging` avec les profils console-only, `file_info`, `superdev` et `supertrace`, et sélectionne temporairement `supertrace` dans le composite Wallet Desk. `pre.003-fix.003` corrige les canaris de ce changement : closures explicites compatibles avec `clippy::implicit_return` et distinction entre fragment KSP incorporé dans un identifiant et nom d’environnement concret suffixé. `pre.003-fix.004` corrige les cinq closures restantes du canari de composition Wallet Desk afin que `cargo clippy --workspace --all-targets` respecte intégralement `clippy::implicit_return`, sans modifier Config ni Logging. `pre.004` branche ensuite l’inventory réel `.kspwallet` sur le répertoire effectif Config : enumeration non récursive, extension exacte, fichiers réguliers uniquement, rejet des symlinks, inspection locked via `ksp-wallet-lib`, diagnostics sûrs par ligne, DataTable réel, refresh et sélection root-scoped revalidée côté Rust sans Pubkey/alias/notes. `pre.004-fix.001` limite les deux réexports crate-root internes utilisés uniquement par les unit tests à `#[cfg(test)]`, afin de fermer les warnings `unused_imports` observés par `cargo check`, Clippy, tests et `tauri dev` sans modifier le comportement d’inventory. `pre.005` ajoute la création native `create_wallet_file_v1`, le formulaire OWNER + VIEW optionnel et le premier `WalletSession` durable côté Rust : OWNER reste ouvert après création, sélection existante reste Locked, tandis que lock/deselect/refresh/changement de wallet détruisent le handle et purgent les projections protégées. `pre.005-fix.001` corrige le premier gate opérateur de cette tranche : `WalletOwner` est indirecté par `Box` dans `WalletSession::Owner` pour fermer `clippy::large_enum_variant`, et le canari `desktop_security` retrouve explicitement le début de `WalletCreateRequestDto` avant de vérifier que les passwords restent request-only. `pre.006` ajoute ensuite les unlock explicites VIEW/OWNER : saisie manuelle request-only, découverte des candidats `KSP_SECRET_WALLET_PASS_*` exclusivement via Config, ordre filename normalisé puis numérique puis nommé, tentative configurée uniquement sur action utilisateur, état transitoire `PrivilegedOperation` pendant Argon2 et projection frontend limitée au nombre de candidats sans nom/suffixe/valeur. `pre.006-fix.001` corrige uniquement les deux canaris statiques de sécurité : ils inspectent désormais les champs réels de `WalletAuthorizedDto` au lieu de considérer le mot `password` présent dans sa documentation de `configured_secret_candidate_count` comme une fuite de champ. `pre.007` ferme ensuite le MVP obligatoire : l'adapter Transport accepte un profil déjà sélectionné par composite avec provenance `Composite`, Wallet Desk construit `HttpTransportPool` au bootstrap, expose des diagnostics profile/cluster/provider sans URL, extrait la Pubkey uniquement d'une session VIEW/OWNER Rust, puis appelle le wrapper typé `getBalance` en `confirmed` et projette lamports exacts, SOL décimal, slot et `api_version`. Le frontend ne fournit ni Pubkey ni endpoint au refresh et toute balance est purgée lors du lock/deselect/changement de wallet. `pre.007-fix.001` corrige le canari d'intégration `config_composition` qui appelait le constructeur interne test-only `ConfigEnvironment::from_maps`; le test consomme désormais uniquement l'API publique `ConfigEnvironment::load`, comme le runtime Wallet Desk, sans modification du pool Transport ni du frontend. `pre.007-fix.002` corrige le diagnostic de ce même canari : l'assertion sur `ConfigEnvironment::load()` ne tente plus de formatter `Result<ConfigEnvironment, _>` avec `Debug`, trait volontairement absent de `ConfigEnvironment`; le contrat runtime reste inchangé. Les tranches suivantes ajoutent administration/import/export, avec une dernière tranche prévue pour README/USAGE/docs/validation, prompt `0.2.7` et build Tauri final. `0.2.6-pre.008` ajoute ensuite l'import Solana CLI JSON/Base58 via un picker natif exclusivement Rust : `tauri-plugin-dialog` reste backend-only, aucun chemin source ni contenu secret ne traverse IPC, les octets sont lus avec une borne stricte puis conservés dans `Zeroizing<Vec<u8>>`, l'inspection ne projette que basename/format/Pubkey, et `import_wallet_transfer_v1` publie no-clobber sous la racine Config avec de nouveaux credentials OWNER/VIEW avant d'ouvrir la session OWNER.
 - [ ] `0.2.7` — Étendre `ksp-onchain-transport-lib` au WebSocket Solana standard complet ; permettre plusieurs sessions sur une même URL sans imposer encore un pool automatique complexe.
 - [ ] `0.2.8` — Ajouter Helius LaserStream WebSocket comme extension du moteur WebSocket standard, sans duplication de client.
 - [ ] `0.2.9` — Ajouter une première fondation Yellowstone gRPC standard/provider-neutral ; dimensionner la surface exacte à `pre.001` selon la documentation normative actuelle.
diff --git a/crates/ksp-app-wallet-desk/Cargo.toml b/crates/ksp-app-wallet-desk/Cargo.toml
index 7a14177..cb3d4d2 100644
--- a/crates/ksp-app-wallet-desk/Cargo.toml
+++ b/crates/ksp-app-wallet-desk/Cargo.toml
@@ -1,5 +1,5 @@
 # file: crates/ksp-app-wallet-desk/Cargo.toml
-# version: 3
+# version: 4
 
 [package]
 name = "ksp-app-wallet-desk"
@@ -31,9 +31,11 @@ ksp-onchain-transport-lib = { path = "../ksp-onchain-transport-lib" }
 ksp-wallet-lib = { path = "../ksp-wallet-lib" }
 serde = { workspace = true, features = ["derive"] }
 tauri.workspace = true
+tauri-plugin-dialog.workspace = true
 tauri-plugin-tracing.workspace = true
-tokio = { workspace = true, features = ["fs", "rt", "time"] }
+tokio = { workspace = true, features = ["fs", "io-util", "rt", "time"] }
 ts-rs.workspace = true
+zeroize.workspace = true
 
 [dev-dependencies]
 serde_json.workspace = true
diff --git a/crates/ksp-app-wallet-desk/frontend/main.html b/crates/ksp-app-wallet-desk/frontend/main.html
index fef5fc0..933d194 100644
--- a/crates/ksp-app-wallet-desk/frontend/main.html
+++ b/crates/ksp-app-wallet-desk/frontend/main.html
@@ -42,7 +42,7 @@
                             <h1 id="viewTitle" class="h3 mb-1">Dashboard</h1>
                             <p class="text-body-secondary mb-0">Identité autorisée et balance SOL via le Transport HTTP composite sont actives.</p>
                         </div>
-                        <span class="badge text-bg-secondary">0.2.6-pre.007</span>
+                        <span class="badge text-bg-secondary">0.2.6-pre.008</span>
                     </div>
                     <section data-view-panel="dashboard">
                         <div class="row g-3">
@@ -163,6 +163,71 @@
                                     Les passwords sont envoyés uniquement du frontend vers Rust pour l'opération courante. Ils ne sont jamais renvoyés par Rust ni journalisés.
                                 </div>
                             </div>
+                            <div class="col-12">
+                                <div class="card shadow-sm">
+                                    <div class="card-header fw-semibold">Importer un keypair Solana vers un wallet KSP</div>
+                                    <div class="card-body">
+                                        <div class="row g-3 mb-3">
+                                            <div class="col-md-5">
+                                                <label class="form-label" for="importTransferFormat">Format source</label>
+                                                <select id="importTransferFormat" class="form-select">
+                                                    <option value="solana_cli_json">Solana CLI JSON</option>
+                                                    <option value="solana_keypair_base58">Keypair Base58 complet</option>
+                                                </select>
+                                            </div>
+                                            <div class="col-md-7 d-flex align-items-end">
+                                                <button id="inspectImportSource" class="btn btn-outline-primary" type="button">
+                                                    <i class="fa-solid fa-folder-open me-2" aria-hidden="true"></i>Choisir et inspecter la source
+                                                </button>
+                                            </div>
+                                            <div class="col-12">
+                                                <div class="alert alert-secondary mb-0">
+                                                    <div><strong>Source :</strong> <span id="importSourceName">—</span></div>
+                                                    <div><strong>Format :</strong> <span id="importSourceFormat">—</span></div>
+                                                    <div><strong>Pubkey inspectée :</strong> <span id="importSourcePubkey" class="text-break">—</span></div>
+                                                    <div class="small text-body-secondary mt-2">Le chemin et le contenu secret restent exclusivement côté Rust. Le frontend ne reçoit que cette projection publique.</div>
+                                                </div>
+                                            </div>
+                                        </div>
+                                        <form id="importWalletForm" autocomplete="off">
+                                            <div class="row g-3">
+                                                <div class="col-md-6">
+                                                    <label class="form-label" for="importWalletFilename">Destination .kspwallet</label>
+                                                    <input id="importWalletFilename" class="form-control" type="text" value="imported-01.kspwallet" required spellcheck="false">
+                                                </div>
+                                                <div class="col-md-6">
+                                                    <label class="form-label" for="importWalletAlias">Alias interne optionnel</label>
+                                                    <input id="importWalletAlias" class="form-control" type="text" autocomplete="off">
+                                                </div>
+                                                <div class="col-md-6">
+                                                    <label class="form-label" for="importWalletOwnerPassword">Nouveau OWNER password</label>
+                                                    <input id="importWalletOwnerPassword" class="form-control" type="password" autocomplete="new-password" required>
+                                                </div>
+                                                <div class="col-md-6 d-flex align-items-end">
+                                                    <div class="form-check mb-2">
+                                                        <input id="importWalletEnableView" class="form-check-input" type="checkbox">
+                                                        <label class="form-check-label" for="importWalletEnableView">Créer aussi une capability VIEW</label>
+                                                    </div>
+                                                </div>
+                                                <div class="col-md-6">
+                                                    <label class="form-label" for="importWalletViewPassword">Nouveau VIEW password</label>
+                                                    <input id="importWalletViewPassword" class="form-control" type="password" autocomplete="new-password" disabled>
+                                                </div>
+                                                <div class="col-12">
+                                                    <label class="form-label" for="importWalletInitialNote">Note initiale optionnelle</label>
+                                                    <textarea id="importWalletInitialNote" class="form-control" rows="3" autocomplete="off"></textarea>
+                                                </div>
+                                                <div class="col-12 d-flex align-items-center gap-3">
+                                                    <button id="importWalletSubmit" class="btn btn-primary" type="submit" disabled>
+                                                        <i class="fa-solid fa-file-import me-2" aria-hidden="true"></i>Import wallet
+                                                    </button>
+                                                    <span id="importWalletStatus" class="text-body-secondary" role="status">Choisir une source.</span>
+                                                </div>
+                                            </div>
+                                        </form>
+                                    </div>
+                                </div>
+                            </div>
                         </div>
                     </section>
                     <section data-view-panel="details" hidden>
@@ -246,7 +311,7 @@
         </div>
     </main>
     <footer class="app-footer bg-dark text-white-50 d-flex align-items-center px-4">
-        <span>KSP Wallet Desk · authorized identity + getBalance pre.007</span>
+        <span>KSP Wallet Desk · native transfer import pre.008</span>
     </footer>
     <script type="module" src="./ts/main.ts"></script>
 </body>
diff --git a/crates/ksp-app-wallet-desk/frontend/ts/main.ts b/crates/ksp-app-wallet-desk/frontend/ts/main.ts
index ebac916..73d3fe1 100644
--- a/crates/ksp-app-wallet-desk/frontend/ts/main.ts
+++ b/crates/ksp-app-wallet-desk/frontend/ts/main.ts
@@ -1,5 +1,5 @@
 // file: crates/ksp-app-wallet-desk/frontend/ts/main.ts
-// version: 7
+// version: 8
 
 import "bootstrap";
 import DataTable from "datatables.net-bs5";
@@ -9,6 +9,10 @@ import "simplebar";
 import { getCurrentWindow } from "@tauri-apps/api/window";
 import type { WalletBalanceDto } from "./bindings/ksp_app_wallet_desk/wallet_balance/WalletBalanceDto.ts";
 import type { RuntimeStatusDto } from "./bindings/ksp_app_wallet_desk/dto_common/RuntimeStatusDto.ts";
+import type { WalletImportRequestDto } from "./bindings/ksp_app_wallet_desk/wallet_import/WalletImportRequestDto.ts";
+import type { WalletImportSourceRequestDto } from "./bindings/ksp_app_wallet_desk/wallet_import/WalletImportSourceRequestDto.ts";
+import type { WalletTransferFormatDto } from "./bindings/ksp_app_wallet_desk/wallet_import/WalletTransferFormatDto.ts";
+import type { WalletTransferInspectionDto } from "./bindings/ksp_app_wallet_desk/wallet_import/WalletTransferInspectionDto.ts";
 import type { LockedWalletDto } from "./bindings/ksp_app_wallet_desk/wallet_inventory/LockedWalletDto.ts";
 import type { WalletInventoryEntryDto } from "./bindings/ksp_app_wallet_desk/wallet_inventory/WalletInventoryEntryDto.ts";
 import type { WalletSelectionRequestDto } from "./bindings/ksp_app_wallet_desk/wallet_inventory/WalletSelectionRequestDto.ts";
@@ -40,6 +44,7 @@ let activeWalletId: string | null = null;
 let activeSessionState: ActiveSessionState = "no_selection";
 let activeViewEnabled = false;
 let configuredSecretCandidateCount = 0;
+let stagedImportSource: WalletTransferInspectionDto | null = null;
 
 function isViewId(value: string): value is ViewId {
     return value in viewTitles;
@@ -170,7 +175,7 @@ function initializeWalletTable(): void {
             zeroRecords: "Aucun wallet correspondant.",
         },
     });
-    frontendDebug("main", "Wallet inventory DataTable initialized", { phase: "pre.007-wallet-balance" });
+    frontendDebug("main", "Wallet inventory DataTable initialized", { phase: "pre.008-wallet-import" });
 }
 
 function renderWalletInventory(entries: WalletInventoryEntryDto[]): void {
@@ -230,6 +235,44 @@ function updateUnlockActions(): void {
     setText("#unlockSecretCandidateCount", configuredSecretCandidateCount.toString());
 }
 
+function importFormatLabel(format: WalletTransferFormatDto): string {
+    return format === "solana_cli_json" ? "Solana CLI JSON" : "Keypair Base58 complet";
+}
+
+function updateImportActions(): void {
+    const submit = document.querySelector<HTMLButtonElement>("#importWalletSubmit");
+    if (submit) {
+        submit.disabled = stagedImportSource === null;
+    }
+}
+
+function clearImportSourceProjection(): void {
+    stagedImportSource = null;
+    setText("#importSourceName", "—");
+    setText("#importSourceFormat", "—");
+    setText("#importSourcePubkey", "—");
+    updateImportActions();
+}
+
+function clearImportSensitiveInputs(): void {
+    const ownerPassword = document.querySelector<HTMLInputElement>("#importWalletOwnerPassword");
+    const viewPassword = document.querySelector<HTMLInputElement>("#importWalletViewPassword");
+    const alias = document.querySelector<HTMLInputElement>("#importWalletAlias");
+    const note = document.querySelector<HTMLTextAreaElement>("#importWalletInitialNote");
+    if (ownerPassword) {
+        ownerPassword.value = "";
+    }
+    if (viewPassword) {
+        viewPassword.value = "";
+    }
+    if (alias) {
+        alias.value = "";
+    }
+    if (note) {
+        note.value = "";
+    }
+}
+
 function clearCreateFormSensitiveInputs(): void {
     const ownerPassword = document.querySelector<HTMLInputElement>("#createWalletOwnerPassword");
     const viewPassword = document.querySelector<HTMLInputElement>("#createWalletViewPassword");
@@ -483,6 +526,129 @@ function bindCreateWalletForm(): void {
     frontendTrace("main", "Create Wallet form handlers installed");
 }
 
+function importRequestFromForm(): WalletImportRequestDto | null {
+    const filename = document.querySelector<HTMLInputElement>("#importWalletFilename");
+    const ownerPassword = document.querySelector<HTMLInputElement>("#importWalletOwnerPassword");
+    const enableView = document.querySelector<HTMLInputElement>("#importWalletEnableView");
+    const viewPassword = document.querySelector<HTMLInputElement>("#importWalletViewPassword");
+    const alias = document.querySelector<HTMLInputElement>("#importWalletAlias");
+    const note = document.querySelector<HTMLTextAreaElement>("#importWalletInitialNote");
+    if (!stagedImportSource || !filename || !ownerPassword || !enableView || !viewPassword || !alias || !note) {
+        return null;
+    }
+    const normalizedFilename = filename.value.trim();
+    if (!normalizedFilename.endsWith(".kspwallet") || normalizedFilename.length <= ".kspwallet".length || ownerPassword.value.length === 0) {
+        return null;
+    }
+    if (enableView.checked && viewPassword.value.length === 0) {
+        return null;
+    }
+    return {
+        alias: alias.value.length === 0 ? null : alias.value,
+        filename: normalizedFilename,
+        initialNote: note.value.length === 0 ? null : note.value,
+        ownerPassword: ownerPassword.value,
+        viewPassword: enableView.checked ? viewPassword.value : null,
+    };
+}
+
+async function inspectImportSource(): Promise<void> {
+    const formatControl = document.querySelector<HTMLSelectElement>("#importTransferFormat");
+    if (!formatControl) {
+        return;
+    }
+    const format = formatControl.value as WalletTransferFormatDto;
+    const request: WalletImportSourceRequestDto = { format };
+    clearImportSourceProjection();
+    setText("#importWalletStatus", "Sélection native de la source…");
+    frontendDebug("main", "Wallet import native picker requested", { format });
+    try {
+        const inspection = await invokeKsp<WalletTransferInspectionDto | null>("main", "inspect_import_source", { request });
+        if (!inspection) {
+            setText("#importWalletStatus", "Sélection annulée.");
+            frontendDebug("main", "Wallet import native picker cancelled", { format });
+            return;
+        }
+        stagedImportSource = inspection;
+        setText("#importSourceName", inspection.sourceName);
+        setText("#importSourceFormat", importFormatLabel(inspection.format));
+        setText("#importSourcePubkey", inspection.pubkey);
+        setText("#importWalletStatus", "Source validée. Saisir les nouveaux credentials KSP.");
+        updateImportActions();
+        frontendInfo("main", "Wallet transfer source inspected", { format: inspection.format });
+    } catch {
+        clearImportSourceProjection();
+        setText("#importWalletStatus", "Source invalide ou illisible. Consulter le diagnostic et les logs.");
+        frontendWarn("main", "Wallet transfer source inspection failed", { format });
+    }
+}
+
+function bindImportWalletForm(): void {
+    const form = document.querySelector<HTMLFormElement>("#importWalletForm");
+    const format = document.querySelector<HTMLSelectElement>("#importTransferFormat");
+    const pick = document.querySelector<HTMLButtonElement>("#inspectImportSource");
+    const enableView = document.querySelector<HTMLInputElement>("#importWalletEnableView");
+    const viewPassword = document.querySelector<HTMLInputElement>("#importWalletViewPassword");
+    if (format) {
+        format.addEventListener("change", () => {
+            clearImportSourceProjection();
+            setText("#importWalletStatus", "Format modifié ; choisir une nouvelle source.");
+            void invokeKsp<void>("main", "clear_import_source").catch(() => {
+                frontendWarn("main", "Backend staged Wallet import source clear failed");
+            });
+            frontendTrace("main", "Wallet import format changed", { format: format.value });
+        });
+    }
+    if (pick) {
+        pick.addEventListener("click", () => {
+            void inspectImportSource();
+        });
+    }
+    if (enableView && viewPassword) {
+        enableView.addEventListener("change", () => {
+            viewPassword.disabled = !enableView.checked;
+            if (!enableView.checked) {
+                viewPassword.value = "";
+            }
+            frontendTrace("main", "Import Wallet VIEW option changed", { enabled: enableView.checked });
+        });
+    }
+    if (!form) {
+        return;
+    }
+    form.addEventListener("submit", event => {
+        event.preventDefault();
+        const request = importRequestFromForm();
+        if (!request || !stagedImportSource) {
+            setText("#importWalletStatus", "Source/filename/passwords invalides ou incomplets.");
+            frontendWarn("main", "Import Wallet form validation rejected request");
+            return;
+        }
+        const requestedWalletId = request.filename;
+        const transferFormat = stagedImportSource.format;
+        const requestedViewEnabled = request.viewPassword !== null;
+        setText("#importWalletStatus", "Import en cours…");
+        frontendDebug("main", "Import Wallet request submitted", { transferFormat, viewEnabled: requestedViewEnabled, walletId: requestedWalletId });
+        clearSelectedWallet();
+        void invokeKsp<WalletAuthorizedDto>("main", "import_wallet", { request })
+            .then(async wallet => {
+                clearImportSensitiveInputs();
+                clearImportSourceProjection();
+                renderAuthorizedWallet(wallet);
+                setText("#importWalletStatus", "Wallet importé ; session OWNER ouverte.");
+                await loadWalletInventory("list_wallets", false);
+                activateView("dashboard", "user");
+            })
+            .catch(() => {
+                clearImportSensitiveInputs();
+                clearImportSourceProjection();
+                setText("#importWalletStatus", "Import impossible ; choisir à nouveau la source. Consulter le diagnostic et les logs.");
+                frontendWarn("main", "Import Wallet operation failed", { transferFormat, walletId: requestedWalletId });
+            });
+    });
+    frontendTrace("main", "Import Wallet form handlers installed");
+}
+
 function beginFrontendUnlock(capability: UnlockCapability, provider: "manual" | "configured"): string | null {
     if (activeSessionState !== "locked" || !activeWalletId) {
         return null;
@@ -658,7 +824,7 @@ function renderRuntimeStatus(status: RuntimeStatusDto): void {
     setText("#runtimeEffectiveWalletsDirectory", status.effectiveWalletsDirectory);
     setText("#runtimeWalletDirectoryCreated", status.effectiveWalletsDirectoryCreatedOnStartup ? "oui" : "non, déjà présent");
     setText("#runtimeShellPhase", status.shellPhase);
-    setText("#shellStatus", "Config/Transport résolus ; VIEW/OWNER et getBalance prêts.");
+    setText("#shellStatus", "Config/Transport résolus ; import natif, VIEW/OWNER et getBalance prêts.");
     frontendTrace("main", "Wallet Desk runtime status rendered", {
         compositeProfile: status.activeCompositeProfile,
         fallbackLoggingActive: status.fallbackLoggingActive,
@@ -706,6 +872,7 @@ async function initializeMain(): Promise<void> {
     bindNavigation();
     bindWalletTableSelection();
     bindCreateWalletForm();
+    bindImportWalletForm();
     bindUnlockActions();
     bindBalanceActions();
     bindShellActions();
diff --git a/crates/ksp-app-wallet-desk/package.json b/crates/ksp-app-wallet-desk/package.json
index 25ba1ca..3543dc2 100644
--- a/crates/ksp-app-wallet-desk/package.json
+++ b/crates/ksp-app-wallet-desk/package.json
@@ -1,7 +1,7 @@
 {
     "name": "ksp-app-wallet-desk",
     "private": true,
-    "version": "0.2.6-pre.7.fix.2",
+    "version": "0.2.6-pre.8",
     "type": "module",
     "scripts": {
         "dev": "vite",
diff --git a/crates/ksp-app-wallet-desk/src/app_state.rs b/crates/ksp-app-wallet-desk/src/app_state.rs
index 96cbdeb..53de722 100644
--- a/crates/ksp-app-wallet-desk/src/app_state.rs
+++ b/crates/ksp-app-wallet-desk/src/app_state.rs
@@ -1,5 +1,5 @@
 // file: crates/ksp-app-wallet-desk/src/app_state.rs
-// version: 8
+// version: 9
 
 //! Shared backend state owned by the Wallet Desk Tauri application.
 
@@ -11,6 +11,7 @@ pub(crate) struct AppState {
     splash_sequence_started: std::sync::atomic::AtomicBool,
     transport_runtime: crate::TransportRuntime,
     wallet_config_startup: crate::WalletConfigStartup,
+    wallet_import_source: std::sync::Mutex<std::option::Option<crate::PendingWalletImport>>,
     wallet_session: std::sync::Mutex<crate::WalletSession>,
 }
 
@@ -69,6 +70,7 @@ impl AppState {
             splash_sequence_started: std::sync::atomic::AtomicBool::new(false),
             transport_runtime,
             wallet_config_startup,
+            wallet_import_source: std::sync::Mutex::new(std::option::Option::None),
             wallet_session: std::sync::Mutex::new(crate::WalletSession::no_selection()),
         });
     }
@@ -124,7 +126,7 @@ impl AppState {
             effective_wallets_directory_created_on_startup: self.wallet_config_startup.effective_directory_created_on_startup(),
             fallback_logging_active: runtime.fallback_active,
             root_wallets_directory_created_on_startup: self.wallet_config_startup.root_directory_created_on_startup(),
-            shell_phase: "pre.007-wallet-balance".to_owned(),
+            shell_phase: "pre.008-wallet-import".to_owned(),
             startup_diagnostic: runtime.startup_diagnostic.clone(),
             transport_available_endpoint_count,
             transport_clusters: self.transport_runtime.clusters(),
@@ -220,6 +222,102 @@ impl AppState {
         return std::result::Result::Ok(dto);
     }
 
+    /// Replaces any previous native-picker transfer source with one newly validated bounded Rust-only source.
+    pub(crate) async fn stage_import_source(
+        &self,
+        source: std::path::PathBuf,
+        format: crate::WalletTransferFormatDto,
+    ) -> ksp_core_lib::Result<crate::WalletTransferInspectionDto> {
+        let staged = crate::stage_wallet_import_source(source, format).await;
+        let staged = match staged {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let dto = staged.safe_projection();
+        let slot = self.wallet_import_source.lock();
+        let mut slot = match slot {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(_) => return std::result::Result::Err(import_source_lock_error()),
+        };
+        let previous = std::mem::replace(&mut *slot, std::option::Option::Some(staged));
+        drop(previous);
+        ksp_logging_lib::info!(target: crate::TRACING_TARGET, domain = crate::TRACING_DOMAIN_WALLET_IMPORT, transfer_format = dto.format.code(), "Wallet transfer source inspected and staged in Rust-only memory");
+        return std::result::Result::Ok(dto);
+    }
+
+    /// Clears any staged external transfer source and zeroizes its bounded secret bytes.
+    pub(crate) fn clear_import_source(&self) -> ksp_core_lib::Result<()> {
+        let slot = self.wallet_import_source.lock();
+        let mut slot = match slot {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(_) => return std::result::Result::Err(import_source_lock_error()),
+        };
+        let previous = slot.take();
+        drop(previous);
+        return std::result::Result::Ok(());
+    }
+
+    /// Imports the staged Solana transfer bytes into a new root-scoped native Wallet and retains the returned OWNER handle only in Rust.
+    pub(crate) async fn import_wallet(&self, request: crate::WalletImportRequestDto) -> ksp_core_lib::Result<crate::WalletAuthorizedDto> {
+        let pending = {
+            let slot = self.wallet_import_source.lock();
+            let mut slot = match slot {
+                std::result::Result::Ok(value) => value,
+                std::result::Result::Err(_) => return std::result::Result::Err(import_source_lock_error()),
+            };
+            slot.take()
+        };
+        let pending = match pending {
+            std::option::Option::Some(value) => value,
+            std::option::Option::None => {
+                return std::result::Result::Err(ksp_core_lib::Error::new(
+                    crate::ERROR_CODE_WALLET_IMPORT_SOURCE_MISSING,
+                    "Wallet import requires one inspected native-picker transfer source",
+                ));
+            },
+        };
+        let deselected = self.deselect_wallet();
+        if let std::result::Result::Err(error) = deselected {
+            return std::result::Result::Err(error);
+        }
+        let crate::WalletImportRequestDto { alias, filename, initial_note, owner_password, view_password } = request;
+        let root = self.wallet_inventory_root().to_path_buf();
+        let destination = crate::new_wallet_destination(root.as_path(), filename.as_str());
+        let destination = match destination {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let view_enabled = view_password.is_some();
+        let owner_password = ksp_wallet_lib::OwnerPassword::new(owner_password);
+        let view_password = view_password.map(ksp_wallet_lib::ViewPassword::new);
+        let alias = normalize_optional_text(alias);
+        let note = normalize_optional_text(initial_note);
+        let note_texts = note.into_iter().collect::<std::vec::Vec<_>>();
+        let metadata = ksp_wallet_lib::WalletCreateMetadataV1::new(alias, note_texts);
+        let transfer_format = pending.wallet_format();
+        ksp_logging_lib::debug!(target: crate::TRACING_TARGET, domain = crate::TRACING_DOMAIN_WALLET_IMPORT, wallet_id = filename.as_str(), transfer_format = transfer_format.code(), view_enabled, "Wallet transfer import requested under effective Config root");
+        let imported =
+            ksp_wallet_lib::import_wallet_transfer_v1(destination.as_path(), pending.source_bytes(), transfer_format, owner_password, view_password, metadata)
+                .await;
+        let owner = match imported {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => {
+                ksp_logging_lib::warn!(target: crate::TRACING_TARGET, domain = crate::TRACING_DOMAIN_WALLET_IMPORT, wallet_id = filename.as_str(), transfer_format = transfer_format.code(), error_domain = error.code().domain(), error_code = error.code().code(), "Wallet transfer import failed");
+                return std::result::Result::Err(error);
+            },
+        };
+        let configured_secret_candidate_count = self.secret_candidate_count_or_zero(filename.as_str());
+        let dto = crate::owner_projection(filename.as_str(), view_enabled, configured_secret_candidate_count, &owner);
+        let session = self.wallet_session.lock();
+        let mut session = match session {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(_) => return std::result::Result::Err(session_lock_error()),
+        };
+        *session = crate::WalletSession::Owner { wallet_id: filename.clone(), path: destination, wallet: std::boxed::Box::new(owner) };
+        ksp_logging_lib::info!(target: crate::TRACING_TARGET, domain = crate::TRACING_DOMAIN_WALLET_IMPORT, wallet_id = filename.as_str(), transfer_format = transfer_format.code(), view_enabled, "Wallet transfer imported and OWNER session opened");
+        return std::result::Result::Ok(dto);
+    }
+
     /// Opens the selected locked Wallet with one manual VIEW password supplied frontend -> Rust.
     pub(crate) async fn unlock_wallet_view_manual(&self, request: crate::WalletUnlockRequestDto) -> ksp_core_lib::Result<crate::WalletAuthorizedDto> {
         let context = self.begin_unlock_operation(crate::WalletUnlockCapability::View);
@@ -656,6 +754,10 @@ fn normalize_optional_text(value: std::option::Option<String>) -> std::option::O
     });
 }
 
+fn import_source_lock_error() -> ksp_core_lib::Error {
+    return ksp_core_lib::Error::new(crate::ERROR_CODE_APP_STATE_LOCK_FAILED, "Wallet Desk staged import source lock is poisoned");
+}
+
 fn session_lock_error() -> ksp_core_lib::Error {
     return ksp_core_lib::Error::new(crate::ERROR_CODE_APP_STATE_LOCK_FAILED, "Wallet Desk Wallet session state lock is poisoned");
 }
diff --git a/crates/ksp-app-wallet-desk/src/constants.rs b/crates/ksp-app-wallet-desk/src/constants.rs
index dfdd9a7..55c3aac 100644
--- a/crates/ksp-app-wallet-desk/src/constants.rs
+++ b/crates/ksp-app-wallet-desk/src/constants.rs
@@ -1,5 +1,5 @@
 // file: crates/ksp-app-wallet-desk/src/constants.rs
-// version: 6
+// version: 7
 
 //! Logging targets, domains and composite component identifiers owned by Wallet Desk.
 
@@ -19,6 +19,8 @@ pub(crate) const TRACING_DOMAIN_SHELL: &str = "wallet.shell";
 pub(crate) const TRACING_DOMAIN_TRANSPORT: &str = "wallet.transport";
 /// Structured domain used while preparing Wallet filesystem roots.
 pub(crate) const TRACING_DOMAIN_WALLET_CONFIG: &str = "wallet.config";
+/// Structured domain used by native-picker Wallet transfer import operations.
+pub(crate) const TRACING_DOMAIN_WALLET_IMPORT: &str = "wallet.import";
 /// Structured domain used while enumerating and inspecting locked Wallet files.
 pub(crate) const TRACING_DOMAIN_WALLET_INVENTORY: &str = "wallet.inventory";
 /// Structured domain used by Config-owned Wallet password candidate operations.
diff --git a/crates/ksp-app-wallet-desk/src/errors.rs b/crates/ksp-app-wallet-desk/src/errors.rs
index b5e14ba..8e08143 100644
--- a/crates/ksp-app-wallet-desk/src/errors.rs
+++ b/crates/ksp-app-wallet-desk/src/errors.rs
@@ -1,5 +1,5 @@
 // file: crates/ksp-app-wallet-desk/src/errors.rs
-// version: 6
+// version: 7
 
 //! Application-local error codes for Wallet Desk composition and desktop runtime surfaces.
 
@@ -34,6 +34,10 @@ pub(crate) const ERROR_CODE_WALLET_DIRECTORY_INVALID: ksp_core_lib::ErrorCode =
 /// Wallet Desk could not inspect or create the configured Wallet directory tree.
 pub(crate) const ERROR_CODE_WALLET_DIRECTORY_PREPARE_FAILED: ksp_core_lib::ErrorCode =
     ksp_core_lib::ErrorCode::new("wallet_desk", "wallet_directory_prepare_failed");
+/// A native-picker Wallet transfer source is not a supported regular file or cannot be staged safely.
+pub(crate) const ERROR_CODE_WALLET_IMPORT_SOURCE_INVALID: ksp_core_lib::ErrorCode = ksp_core_lib::ErrorCode::new("wallet_desk", "wallet_import_source_invalid");
+/// Wallet import was requested without one previously inspected native-picker source.
+pub(crate) const ERROR_CODE_WALLET_IMPORT_SOURCE_MISSING: ksp_core_lib::ErrorCode = ksp_core_lib::ErrorCode::new("wallet_desk", "wallet_import_source_missing");
 /// Wallet Desk cannot enumerate or inspect its effective Wallet inventory directory.
 pub(crate) const ERROR_CODE_WALLET_INVENTORY_FAILED: ksp_core_lib::ErrorCode = ksp_core_lib::ErrorCode::new("wallet_desk", "wallet_inventory_failed");
 /// No effective Config-owned Wallet password candidate is available for the explicit configured-secret unlock action.
diff --git a/crates/ksp-app-wallet-desk/src/lib.rs b/crates/ksp-app-wallet-desk/src/lib.rs
index 696ebad..f69d421 100644
--- a/crates/ksp-app-wallet-desk/src/lib.rs
+++ b/crates/ksp-app-wallet-desk/src/lib.rs
@@ -1,5 +1,5 @@
 // file: crates/ksp-app-wallet-desk/src/lib.rs
-// version: 7
+// version: 8
 
 //! Tauri desktop application shell for KSP Wallet management and inspection.
 
@@ -21,6 +21,7 @@ mod tw_main;
 mod tw_splash;
 mod wallet_balance;
 mod wallet_config;
+mod wallet_import;
 mod wallet_inventory;
 mod wallet_secrets;
 mod wallet_session;
@@ -56,6 +57,8 @@ pub(crate) use self::constants::TRACING_DOMAIN_SHELL;
 pub(crate) use self::constants::TRACING_DOMAIN_TRANSPORT;
 /// Structured domain used while preparing Wallet filesystem roots.
 pub(crate) use self::constants::TRACING_DOMAIN_WALLET_CONFIG;
+/// Structured domain used by native-picker Wallet transfer import operations.
+pub(crate) use self::constants::TRACING_DOMAIN_WALLET_IMPORT;
 /// Structured domain used while enumerating and inspecting locked Wallet files.
 pub(crate) use self::constants::TRACING_DOMAIN_WALLET_INVENTORY;
 /// Structured domain used by Config-owned Wallet password candidate operations.
@@ -106,6 +109,10 @@ pub(crate) use self::errors::ERROR_CODE_WALLET_AUTHORIZATION_REQUIRED;
 pub(crate) use self::errors::ERROR_CODE_WALLET_DIRECTORY_INVALID;
 /// Wallet Desk could not inspect or create the configured Wallet directory tree.
 pub(crate) use self::errors::ERROR_CODE_WALLET_DIRECTORY_PREPARE_FAILED;
+/// Native-picker transfer source is invalid or cannot be staged.
+pub(crate) use self::errors::ERROR_CODE_WALLET_IMPORT_SOURCE_INVALID;
+/// Wallet import has no staged native-picker source.
+pub(crate) use self::errors::ERROR_CODE_WALLET_IMPORT_SOURCE_MISSING;
 /// Wallet inventory filesystem operation failed.
 pub(crate) use self::errors::ERROR_CODE_WALLET_INVENTORY_FAILED;
 /// No effective Config-owned Wallet password candidate is available.
@@ -146,6 +153,18 @@ pub(crate) use self::wallet_balance::format_lamports_as_sol;
 pub(crate) use self::wallet_config::WalletConfigStartup;
 /// Resolves the composite-selected Wallet Config and prepares its application-owned directory tree.
 pub(crate) use self::wallet_config::initialize_wallet_config;
+/// Rust-only staged import source containing bounded zeroizing transfer bytes.
+pub(crate) use self::wallet_import::PendingWalletImport;
+/// Import request whose new native Wallet credentials move frontend -> Rust only.
+pub(crate) use self::wallet_import::WalletImportRequestDto;
+/// Native picker request containing only the expected transfer format.
+pub(crate) use self::wallet_import::WalletImportSourceRequestDto;
+/// Safe transfer format DTO used by the import picker.
+pub(crate) use self::wallet_import::WalletTransferFormatDto;
+/// Safe inspection projection for one staged external transfer source.
+pub(crate) use self::wallet_import::WalletTransferInspectionDto;
+/// Loads and validates one native-picker import source into bounded zeroizing Rust memory.
+pub(crate) use self::wallet_import::stage_wallet_import_source;
 /// Safe locked Wallet projection returned after selection.
 pub(crate) use self::wallet_inventory::LockedWalletDto;
 /// Locked inspection outcome exposed by Wallet inventory rows in crate unit tests.
diff --git a/crates/ksp-app-wallet-desk/src/tauri.rs b/crates/ksp-app-wallet-desk/src/tauri.rs
index 2317778..ff13256 100644
--- a/crates/ksp-app-wallet-desk/src/tauri.rs
+++ b/crates/ksp-app-wallet-desk/src/tauri.rs
@@ -1,8 +1,10 @@
 // file: crates/ksp-app-wallet-desk/src/tauri.rs
-// version: 5
+// version: 6
 
 //! Tauri runtime assembly for the KSP wallet desktop application.
 
+use tauri_plugin_dialog::DialogExt; // rust-rules: trait-import
+
 /// Runs the Wallet Desk application.
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run(arguments: &[std::ffi::OsString]) -> ksp_core_lib::Result<()> {
@@ -32,16 +34,19 @@ fn configure_state(builder: tauri::Builder<tauri::Wry>, app_state: crate::AppSta
 
 fn configure_plugins(builder: tauri::Builder<tauri::Wry>) -> tauri::Builder<tauri::Wry> {
     let tracing_plugin = tauri_plugin_tracing::Builder::new().build::<tauri::Wry>();
-    return builder.plugin(tracing_plugin);
+    return builder.plugin(tauri_plugin_dialog::init()).plugin(tracing_plugin);
 }
 
 #[allow(clippy::question_mark_used)] // Tauri generates the question-mark operator internally for async command dispatch.
 fn configure_commands(builder: tauri::Builder<tauri::Wry>) -> tauri::Builder<tauri::Wry> {
     return builder.invoke_handler(tauri::generate_handler![
+        clear_import_source,
         create_wallet,
         deselect_wallet,
         emit_frontend_log,
         get_runtime_status,
+        import_wallet,
+        inspect_import_source,
         list_wallets,
         lock_wallet,
         refresh_wallet_balance,
@@ -70,6 +75,15 @@ fn configure_setup(builder: tauri::Builder<tauri::Wry>) -> tauri::Builder<tauri:
     });
 }
 
+#[tauri::command]
+fn clear_import_source(state: tauri::State<'_, crate::AppState>) -> std::result::Result<(), crate::CommandErrorDto> {
+    let result = state.clear_import_source();
+    return match result {
+        std::result::Result::Ok(()) => std::result::Result::Ok(()),
+        std::result::Result::Err(error) => std::result::Result::Err(crate::CommandErrorDto::from_error(&error)),
+    };
+}
+
 #[tauri::command]
 async fn create_wallet(
     request: crate::WalletCreateRequestDto,
@@ -109,6 +123,59 @@ fn get_runtime_status(state: tauri::State<'_, crate::AppState>) -> std::result::
     };
 }
 
+#[tauri::command]
+async fn import_wallet(
+    request: crate::WalletImportRequestDto,
+    state: tauri::State<'_, crate::AppState>,
+) -> std::result::Result<crate::WalletAuthorizedDto, crate::CommandErrorDto> {
+    let result = state.import_wallet(request).await;
+    return match result {
+        std::result::Result::Ok(value) => std::result::Result::Ok(value),
+        std::result::Result::Err(error) => std::result::Result::Err(crate::CommandErrorDto::from_error(&error)),
+    };
+}
+
+#[tauri::command]
+async fn inspect_import_source(
+    app: tauri::AppHandle,
+    request: crate::WalletImportSourceRequestDto,
+    state: tauri::State<'_, crate::AppState>,
+) -> std::result::Result<std::option::Option<crate::WalletTransferInspectionDto>, crate::CommandErrorDto> {
+    let cleared = state.clear_import_source();
+    if let std::result::Result::Err(error) = cleared {
+        return std::result::Result::Err(crate::CommandErrorDto::from_error(&error));
+    }
+    let format = request.format;
+    let extensions = [format.default_extension()];
+    let selected = app
+        .dialog()
+        .file()
+        .set_title("Select Solana keypair transfer source")
+        .add_filter("Solana keypair transfer", &extensions)
+        .blocking_pick_file();
+    let selected = match selected {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => {
+            ksp_logging_lib::debug!(target: crate::TRACING_TARGET, domain = crate::TRACING_DOMAIN_WALLET_IMPORT, transfer_format = format.code(), "Wallet import native picker cancelled");
+            return std::result::Result::Ok(std::option::Option::None);
+        },
+    };
+    let path = selected.into_path();
+    let path = match path {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => {
+            let error =
+                ksp_core_lib::Error::new(crate::ERROR_CODE_WALLET_IMPORT_SOURCE_INVALID, "Selected Wallet transfer source is not a local filesystem path");
+            return std::result::Result::Err(crate::CommandErrorDto::from_error(&error));
+        },
+    };
+    let result = state.stage_import_source(path, format).await;
+    return match result {
+        std::result::Result::Ok(value) => std::result::Result::Ok(std::option::Option::Some(value)),
+        std::result::Result::Err(error) => std::result::Result::Err(crate::CommandErrorDto::from_error(&error)),
+    };
+}
+
 #[tauri::command]
 async fn refresh_wallet_balance(state: tauri::State<'_, crate::AppState>) -> std::result::Result<crate::WalletBalanceDto, crate::CommandErrorDto> {
     let result = state.refresh_wallet_balance().await;
diff --git a/crates/ksp-app-wallet-desk/src/wallet_import.rs b/crates/ksp-app-wallet-desk/src/wallet_import.rs
new file mode 100644
index 0000000..6d1ae47
--- /dev/null
+++ b/crates/ksp-app-wallet-desk/src/wallet_import.rs
@@ -0,0 +1,190 @@
+// file: crates/ksp-app-wallet-desk/src/wallet_import.rs
+// version: 1
+
+//! Native-picker transfer import staging with bounded secret material kept only in Rust.
+
+use tokio::io::AsyncReadExt; // rust-rules: trait-import
+use ts_rs::TS; // rust-rules: trait-import
+
+/// Transfer format selected before opening the native import picker.
+#[derive(Clone, Copy, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize, TS)]
+#[serde(rename_all = "snake_case")]
+#[ts(export, export_to = "../frontend/ts/bindings/ksp_app_wallet_desk/wallet_import/WalletTransferFormatDto.ts")]
+pub(crate) enum WalletTransferFormatDto {
+    /// Standard Solana CLI keypair JSON array containing 64 byte values.
+    SolanaCliJson,
+    /// Canonical Base58 encoding of the complete 64-byte Solana keypair.
+    SolanaKeypairBase58,
+}
+
+impl WalletTransferFormatDto {
+    /// Maps the desktop DTO to the stable Wallet transfer format.
+    #[must_use]
+    pub(crate) const fn wallet_format(self) -> ksp_wallet_lib::WalletTransferFormat {
+        return match self {
+            Self::SolanaCliJson => ksp_wallet_lib::WalletTransferFormat::SolanaCliJson,
+            Self::SolanaKeypairBase58 => ksp_wallet_lib::WalletTransferFormat::SolanaKeypairBase58,
+        };
+    }
+
+    /// Returns the native picker extension used as a convenience filter.
+    #[must_use]
+    pub(crate) const fn default_extension(self) -> &'static str {
+        return match self {
+            Self::SolanaCliJson => "json",
+            Self::SolanaKeypairBase58 => "txt",
+        };
+    }
+
+    /// Returns the stable transfer format code used by safe diagnostics.
+    #[must_use]
+    pub(crate) const fn code(self) -> &'static str {
+        return match self {
+            Self::SolanaCliJson => "solana_cli_json",
+            Self::SolanaKeypairBase58 => "solana_keypair_base58",
+        };
+    }
+
+    const fn maximum_source_bytes(self) -> usize {
+        return match self {
+            Self::SolanaCliJson => ksp_wallet_lib::KSPWALLET_TRANSFER_MAX_SOLANA_CLI_JSON_BYTES,
+            Self::SolanaKeypairBase58 => ksp_wallet_lib::KSPWALLET_TRANSFER_MAX_BASE58_BYTES,
+        };
+    }
+}
+
+/// Request that chooses only the transfer format; the source path comes from the native Rust picker.
+#[derive(serde::Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "../frontend/ts/bindings/ksp_app_wallet_desk/wallet_import/WalletImportSourceRequestDto.ts")]
+pub(crate) struct WalletImportSourceRequestDto {
+    /// Transfer encoding expected for the selected external file.
+    pub(crate) format: WalletTransferFormatDto,
+}
+
+/// Safe projection returned after validating one native-picker import source.
+#[derive(Clone, serde::Serialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "../frontend/ts/bindings/ksp_app_wallet_desk/wallet_import/WalletTransferInspectionDto.ts")]
+pub(crate) struct WalletTransferInspectionDto {
+    /// Transfer format used to validate the secret source.
+    pub(crate) format: WalletTransferFormatDto,
+    /// Public identity derived from the imported keypair.
+    pub(crate) pubkey: String,
+    /// Basename only; no parent path is ever projected.
+    pub(crate) source_name: String,
+}
+
+/// Import request whose new native Wallet credentials move frontend -> Rust only.
+#[derive(serde::Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "../frontend/ts/bindings/ksp_app_wallet_desk/wallet_import/WalletImportRequestDto.ts")]
+pub(crate) struct WalletImportRequestDto {
+    /// Optional protected internal alias stored in the new native Wallet.
+    pub(crate) alias: std::option::Option<String>,
+    /// Root-scoped destination filename under the effective Wallet directory.
+    pub(crate) filename: String,
+    /// Optional first protected note stored in the imported Wallet.
+    pub(crate) initial_note: std::option::Option<String>,
+    /// New OWNER password transported only frontend -> Rust.
+    pub(crate) owner_password: String,
+    /// Optional new VIEW password; `None` keeps VIEW disabled.
+    pub(crate) view_password: std::option::Option<String>,
+}
+
+/// Rust-only staged transfer source. Secret bytes are bounded and zeroized on drop.
+pub(crate) struct PendingWalletImport {
+    bytes: zeroize::Zeroizing<std::vec::Vec<u8>>,
+    format: WalletTransferFormatDto,
+    inspection: WalletTransferInspectionDto,
+}
+
+impl PendingWalletImport {
+    /// Returns the safe inspection projection without exposing source bytes or path.
+    #[must_use]
+    pub(crate) fn safe_projection(&self) -> WalletTransferInspectionDto {
+        return self.inspection.clone();
+    }
+
+    /// Returns the bounded secret transfer bytes for one immediate Wallet import operation.
+    #[must_use]
+    pub(crate) fn source_bytes(&self) -> &[u8] {
+        return self.bytes.as_slice();
+    }
+
+    /// Returns the stable Wallet transfer format corresponding to the staged source.
+    #[must_use]
+    pub(crate) const fn wallet_format(&self) -> ksp_wallet_lib::WalletTransferFormat {
+        return self.format.wallet_format();
+    }
+}
+
+/// Reads, bounds and validates one native-picker transfer source while retaining no external path.
+pub(crate) async fn stage_wallet_import_source(source: std::path::PathBuf, format: WalletTransferFormatDto) -> ksp_core_lib::Result<PendingWalletImport> {
+    let metadata = tokio::fs::symlink_metadata(source.as_path()).await;
+    let metadata = match metadata {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => {
+            return std::result::Result::Err(
+                ksp_core_lib::Error::new(crate::ERROR_CODE_WALLET_IMPORT_SOURCE_INVALID, "Cannot inspect the selected Wallet transfer source")
+                    .with_source(error),
+            );
+        },
+    };
+    if metadata.file_type().is_symlink() || !metadata.is_file() {
+        return std::result::Result::Err(ksp_core_lib::Error::new(
+            crate::ERROR_CODE_WALLET_IMPORT_SOURCE_INVALID,
+            "Selected Wallet transfer source must be one regular non-symlink file",
+        ));
+    }
+    let source_name = source.file_name().and_then(std::ffi::OsStr::to_str);
+    let source_name = match source_name {
+        std::option::Option::Some(value) if !value.is_empty() => value.to_owned(),
+        _ => "selected-transfer".to_owned(),
+    };
+    let file = tokio::fs::File::open(source.as_path()).await;
+    let file = match file {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => {
+            return std::result::Result::Err(
+                ksp_core_lib::Error::new(crate::ERROR_CODE_WALLET_IMPORT_SOURCE_INVALID, "Cannot open the selected Wallet transfer source").with_source(error),
+            );
+        },
+    };
+    let maximum_source_bytes = format.maximum_source_bytes();
+    let read_limit = maximum_source_bytes.saturating_add(1);
+    let read_limit = u64::try_from(read_limit);
+    let read_limit = match read_limit {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => {
+            return std::result::Result::Err(
+                ksp_core_lib::Error::new(crate::ERROR_CODE_APP_STATE_INVALID, "Wallet transfer source bound exceeds platform range").with_source(error),
+            );
+        },
+    };
+    let mut reader = file.take(read_limit);
+    let mut bytes = zeroize::Zeroizing::new(std::vec::Vec::with_capacity(maximum_source_bytes.saturating_add(1)));
+    let read_result = reader.read_to_end(&mut *bytes).await;
+    if let std::result::Result::Err(error) = read_result {
+        return std::result::Result::Err(
+            ksp_core_lib::Error::new(crate::ERROR_CODE_WALLET_IMPORT_SOURCE_INVALID, "Cannot read the selected Wallet transfer source").with_source(error),
+        );
+    }
+    if bytes.len() > maximum_source_bytes {
+        return std::result::Result::Err(ksp_core_lib::Error::new(
+            crate::ERROR_CODE_WALLET_IMPORT_SOURCE_INVALID,
+            "Selected Wallet transfer source exceeds the supported format bound",
+        ));
+    }
+    let inspection = ksp_wallet_lib::inspect_wallet_transfer(bytes.as_slice(), format.wallet_format());
+    let inspection = match inspection {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let dto = WalletTransferInspectionDto { format, pubkey: inspection.pubkey().to_string(), source_name };
+    return std::result::Result::Ok(PendingWalletImport { bytes, format, inspection: dto });
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/wallet_import.rs"]
+mod tests;
diff --git a/crates/ksp-app-wallet-desk/tauri.conf.json b/crates/ksp-app-wallet-desk/tauri.conf.json
index dc55d29..e1feb3c 100644
--- a/crates/ksp-app-wallet-desk/tauri.conf.json
+++ b/crates/ksp-app-wallet-desk/tauri.conf.json
@@ -1,7 +1,7 @@
 {
     "$schema": "https://schema.tauri.app/config/2",
     "productName": "KSP Wallet Desk",
-    "version": "0.2.6-pre.7.fix.2",
+    "version": "0.2.6-pre.8",
     "identifier": "com.sasedev.ksp-app-wallet-desk",
     "build": {
         "beforeDevCommand": "npm run dev",
diff --git a/crates/ksp-app-wallet-desk/tests/desktop_contract.rs b/crates/ksp-app-wallet-desk/tests/desktop_contract.rs
index f5276e8..264dff3 100644
--- a/crates/ksp-app-wallet-desk/tests/desktop_contract.rs
+++ b/crates/ksp-app-wallet-desk/tests/desktop_contract.rs
@@ -1,5 +1,5 @@
 // file: crates/ksp-app-wallet-desk/tests/desktop_contract.rs
-// version: 7
+// version: 8
 
 //! Desktop build, shell and Config-status contract audits for Wallet Desk.
 
@@ -198,3 +198,28 @@ fn pre_007_balance_uses_authorized_pubkey_and_composite_transport() {
     assert!(main.contains("renderWalletBalance"));
     assert!(main.contains("refresh_wallet_balance"));
 }
+
+#[test]
+fn pre_008_import_uses_rust_native_picker_and_wallet_transfer_adapters() {
+    let root = app_root();
+    let manifest = read_text(root.join("Cargo.toml").as_path());
+    let state = read_text(root.join("src/app_state.rs").as_path());
+    let import = read_text(root.join("src/wallet_import.rs").as_path());
+    let tauri = read_text(root.join("src/tauri.rs").as_path());
+    let html = read_text(root.join("frontend/main.html").as_path());
+    let main = read_text(root.join("frontend/ts/main.ts").as_path());
+    assert!(manifest.contains("tauri-plugin-dialog.workspace = true"));
+    assert!(manifest.contains("zeroize.workspace = true"));
+    assert!(tauri.contains("tauri_plugin_dialog::init()"));
+    assert!(tauri.contains("blocking_pick_file"));
+    assert!(tauri.contains("inspect_import_source"));
+    assert!(tauri.contains("import_wallet"));
+    assert!(import.contains("ksp_wallet_lib::inspect_wallet_transfer"));
+    assert!(import.contains("zeroize::Zeroizing"));
+    assert!(state.contains("ksp_wallet_lib::import_wallet_transfer_v1"));
+    assert!(html.contains("id=\"inspectImportSource\""));
+    assert!(html.contains("id=\"importWalletForm\""));
+    assert!(html.contains("id=\"importSourcePubkey\""));
+    assert!(main.contains("WalletTransferInspectionDto"));
+    assert!(main.contains("bindImportWalletForm"));
+}
diff --git a/crates/ksp-app-wallet-desk/tests/desktop_security.rs b/crates/ksp-app-wallet-desk/tests/desktop_security.rs
index 9ab5cc5..0924149 100644
--- a/crates/ksp-app-wallet-desk/tests/desktop_security.rs
+++ b/crates/ksp-app-wallet-desk/tests/desktop_security.rs
@@ -1,5 +1,5 @@
 // file: crates/ksp-app-wallet-desk/tests/desktop_security.rs
-// version: 7
+// version: 8
 
 //! Static desktop security contracts for the Wallet Desk pre.002 shell.
 
@@ -126,3 +126,39 @@ fn balance_refresh_never_accepts_pubkey_or_endpoint_url_from_frontend() {
     assert!(!main.contains("endpointUrl"));
     assert!(state.contains("wallet.pubkey()"));
 }
+
+#[test]
+fn import_picker_path_and_transfer_secret_never_cross_into_frontend() {
+    let root = app_root();
+    let package = read_text(root.join("package.json").as_path());
+    let capability = read_text(root.join("capabilities/default.json").as_path());
+    let import = read_text(root.join("src/wallet_import.rs").as_path());
+    let tauri = read_text(root.join("src/tauri.rs").as_path());
+    let main = read_text(root.join("frontend/ts/main.ts").as_path());
+    assert!(!package.contains("@tauri-apps/plugin-dialog"));
+    assert!(!capability.contains("dialog:"));
+    assert!(!capability.contains("fs:"));
+    assert!(!main.contains("@tauri-apps/plugin-dialog"));
+    assert!(!main.contains("sourcePath"));
+    assert!(!main.contains("source_path"));
+    assert!(import.contains("zeroize::Zeroizing"));
+    let inspection = import.split("pub(crate) struct WalletTransferInspectionDto").nth(1);
+    assert!(inspection.is_some());
+    let inspection = inspection.unwrap_or_default().split("}\n").next().unwrap_or_default();
+    let inspection_fields = inspection.lines().filter(|line| return line.trim_start().starts_with("pub(crate) ")).collect::<std::vec::Vec<_>>().join("\n");
+    assert!(!inspection_fields.contains("path"));
+    assert!(!inspection_fields.contains("password"));
+    let request = import.split("pub(crate) struct WalletImportRequestDto").nth(1);
+    assert!(request.is_some());
+    let request = request.unwrap_or_default().split("}\n").next().unwrap_or_default();
+    let request_fields = request.lines().filter(|line| return line.trim_start().starts_with("pub(crate) ")).collect::<std::vec::Vec<_>>().join("\n");
+    assert!(request_fields.contains("owner_password"));
+    assert!(request_fields.contains("view_password"));
+    assert!(!request_fields.contains("path"));
+    let command_start = tauri.find("async fn inspect_import_source");
+    assert!(command_start.is_some());
+    let command = &tauri[command_start.unwrap_or_default()..];
+    let command = command.split("#[tauri::command]").next().unwrap_or_default();
+    assert!(command.contains("WalletImportSourceRequestDto"));
+    assert!(!command.contains("source_path"));
+}
diff --git a/crates/ksp-app-wallet-desk/unit_tests/wallet_import.rs b/crates/ksp-app-wallet-desk/unit_tests/wallet_import.rs
new file mode 100644
index 0000000..9d25cd2
--- /dev/null
+++ b/crates/ksp-app-wallet-desk/unit_tests/wallet_import.rs
@@ -0,0 +1,49 @@
+// file: crates/ksp-app-wallet-desk/unit_tests/wallet_import.rs
+// version: 1
+
+#[test]
+fn transfer_format_dto_maps_exact_supported_wallet_formats_and_bounds() {
+    assert_eq!(crate::WalletTransferFormatDto::SolanaCliJson.wallet_format(), ksp_wallet_lib::WalletTransferFormat::SolanaCliJson);
+    assert_eq!(crate::WalletTransferFormatDto::SolanaKeypairBase58.wallet_format(), ksp_wallet_lib::WalletTransferFormat::SolanaKeypairBase58);
+    assert_eq!(crate::WalletTransferFormatDto::SolanaCliJson.maximum_source_bytes(), ksp_wallet_lib::KSPWALLET_TRANSFER_MAX_SOLANA_CLI_JSON_BYTES);
+    assert_eq!(crate::WalletTransferFormatDto::SolanaKeypairBase58.maximum_source_bytes(), ksp_wallet_lib::KSPWALLET_TRANSFER_MAX_BASE58_BYTES);
+}
+
+#[test]
+fn import_request_does_not_require_debug_or_clone_password_contracts() {
+    fn consume(_request: crate::WalletImportRequestDto) {}
+    consume(crate::WalletImportRequestDto {
+        alias: std::option::Option::None,
+        filename: "imported.kspwallet".to_owned(),
+        initial_note: std::option::Option::None,
+        owner_password: "owner-canary".to_owned(),
+        view_password: std::option::Option::Some("view-canary".to_owned()),
+    });
+}
+
+#[test]
+fn staged_base58_source_keeps_only_safe_projection_and_bounded_zeroizing_bytes() {
+    let source = "99eUso3aSbE9tqGSTXzo3TLfKb9RkMTURrHKQ1K7Zh3StnzFNUx8FKCPPPPpR479qsw5zv2WNBKmgiz7WqgAJfM";
+    let path = std::env::temp_dir().join(format!("ksp-wallet-import-{}-seed7.txt", std::process::id()));
+    let written = std::fs::write(path.as_path(), source.as_bytes());
+    assert!(written.is_ok());
+    let runtime = tokio::runtime::Builder::new_current_thread().enable_all().build();
+    assert!(runtime.is_ok());
+    let runtime = match runtime {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let staged = runtime.block_on(crate::stage_wallet_import_source(path.clone(), crate::WalletTransferFormatDto::SolanaKeypairBase58));
+    let removed = std::fs::remove_file(path.as_path());
+    assert!(removed.is_ok());
+    assert!(staged.is_ok());
+    let staged = match staged {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let projection = staged.safe_projection();
+    assert_eq!(projection.pubkey, "GmaDrppBC7P5ARKV8g3djiwP89vz1jLK23V2GBjuAEGB");
+    assert_eq!(projection.format, crate::WalletTransferFormatDto::SolanaKeypairBase58);
+    assert!(projection.source_name.ends_with("seed7.txt"));
+    assert_eq!(staged.source_bytes(), source.as_bytes());
+}
diff --git a/deltas/0.2.6/pre.008.md b/deltas/0.2.6/pre.008.md
new file mode 100644
index 0000000..d6af216
--- /dev/null
+++ b/deltas/0.2.6/pre.008.md
@@ -0,0 +1,115 @@
+<!-- file: deltas/0.2.6/pre.008.md -->
+<!-- version: 1 -->
+
+# Delta `0.2.6-pre.008` — import natif Solana CLI JSON / Base58
+
+## Base et version
+
+- Base : `0.2.6-pre.007-fix.002`.
+- Version Cargo : `0.2.6-pre.8`.
+- Commit attendu : `v0.2.6-pre.008`.
+- Aucun tag prerelease.
+
+## Objet
+
+Cette tranche matérialise l'import d'un keypair Solana externe vers un nouveau Wallet natif `.kspwallet` sans donner au frontend la propriété d'un chemin filesystem ni du contenu secret importé.
+
+Les formats pris en charge sont les deux formats de transfert déjà possédés par `ksp-wallet-lib` :
+
+- Solana CLI keypair JSON ;
+- keypair Solana Base58 canonique.
+
+## Picker natif backend-only
+
+`tauri-plugin-dialog` est ajouté comme dépendance Rust workspace et initialisé par Wallet Desk. Le frontend ne dépend pas de `@tauri-apps/plugin-dialog` et aucune permission guest Dialog/FS n'est ajoutée.
+
+Le frontend transmet uniquement le format attendu à `inspect_import_source`. Rust ouvre le picker natif, convertit la sélection en chemin local et ne renvoie jamais ce chemin par IPC.
+
+Une annulation du picker est une sortie normale sans source staged.
+
+## Staging borné et secret
+
+`wallet_import.rs` lit uniquement un fichier régulier non-symlink et applique avant parsing les bornes publiques de `ksp-wallet-lib` :
+
+- `KSPWALLET_TRANSFER_MAX_SOLANA_CLI_JSON_BYTES` ;
+- `KSPWALLET_TRANSFER_MAX_BASE58_BYTES`.
+
+Les octets sont conservés dans `Zeroizing<Vec<u8>>` côté Rust. La validation utilise `ksp-wallet-lib::inspect_wallet_transfer` et la projection frontend ne contient que :
+
+- format ;
+- Pubkey dérivée ;
+- basename de la source.
+
+Le parent du chemin, les octets du keypair et tout secret restent hors IPC/logs.
+
+## Import vers `.kspwallet`
+
+`import_wallet` consomme atomiquement la source staged et appelle `ksp-wallet-lib::import_wallet_transfer_v1` en mémoire. Le fichier destination :
+
+- est dérivé uniquement de la racine Wallet effective possédée par Config et du filename root-scoped validé ;
+- hérite des garanties no-clobber de Wallet ;
+- reçoit un nouveau password OWNER et, optionnellement, un nouveau password VIEW ;
+- peut recevoir alias et note initiale protégés ;
+- conserve la même identité Solana que la source validée.
+
+Après succès, le `WalletOwner` importé est conservé uniquement dans `AppState` et la session devient OWNER ouverte. La source staged est consommée et zéroïsée à sa destruction.
+
+## Frontend
+
+La vue `Create / Import` ajoute :
+
+- sélection du format de transfert ;
+- bouton d'ouverture du picker natif ;
+- aperçu sûr basename / format / Pubkey ;
+- filename `.kspwallet` destination ;
+- alias optionnel ;
+- password OWNER ;
+- VIEW optionnel + password VIEW ;
+- note initiale optionnelle ;
+- action d'import.
+
+Changer le format purge la projection et la source staged Rust. Après import ou erreur, les inputs sensibles et la projection de source sont purgés ; une nouvelle sélection native est nécessaire après un échec d'import.
+
+## Sécurité / frontières
+
+- aucun chemin source dans les DTO frontend ;
+- aucun contenu keypair dans les DTO ou logs ;
+- aucun accès filesystem guest ;
+- aucun dialogue navigateur natif ;
+- aucune dépendance npm Dialog ;
+- le frontend ne choisit jamais la destination absolue ;
+- `ksp-wallet-lib` reste propriétaire du décodage/import et de la publication no-clobber.
+
+## Fichiers principaux
+
+Ajouts :
+
+- `crates/ksp-app-wallet-desk/src/wallet_import.rs` ;
+- `crates/ksp-app-wallet-desk/unit_tests/wallet_import.rs` ;
+- `deltas/0.2.6/pre.008.md`.
+
+Modifications principales :
+
+- dépendances/version workspace et Wallet Desk ;
+- `AppState` pour staging/import ;
+- commandes/plugins Tauri ;
+- shell Create / Import et bindings frontend ;
+- canaris desktop contract/security ;
+- plan `0.2.6`, séquence fonctionnelle et roadmap.
+
+## Validation opérateur attendue
+
+```bash
+cargo fmt --all
+python3 scripts/audit_rust_workspace_rules.py
+cargo check --workspace
+cargo clippy --workspace --all-targets
+
+cargo test -p ksp-app-wallet-desk
+cargo test --workspace
+
+KSP_WALLETS_DIRECTORY=var/wallet-desk-pre008 \
+cargo tauri dev -c crates/ksp-app-wallet-desk/tauri.conf.json
+```
+
+Ne pas exécuter `cargo tauri build` dans cette tranche.
diff --git a/docs/plans/002-FUNCTIONAL_RELEASE_SEQUENCE.md b/docs/plans/002-FUNCTIONAL_RELEASE_SEQUENCE.md
index a2d3c15..e994f44 100644
--- a/docs/plans/002-FUNCTIONAL_RELEASE_SEQUENCE.md
+++ b/docs/plans/002-FUNCTIONAL_RELEASE_SEQUENCE.md
@@ -1,5 +1,5 @@
 <!-- file: docs/plans/002-FUNCTIONAL_RELEASE_SEQUENCE.md -->
-<!-- version: 71 -->
+<!-- version: 72 -->
 
 # Séquence des releases fonctionnelles KSP
 
@@ -430,7 +430,7 @@ Le prompt [`../../prompts/011-V0_2_6_START_PROMPT.md`](../../prompts/011-V0_2_6_
 
 `0.2.6-pre.001` confirme que le registre Config doit être étendu pour `cfg.std.wallet`/`schema.std.wallet` et `cfg.composite.ksp-app-wallet-desk`. `wallets_directory` reste global avec fallback `${KSP_WALLETS_DIRECTORY:-wallets}` et chaque profil peut définir un `wallets_subdirectory` relatif pour isoler tests, temporaires ou futurs scénarios. Wallet Desk prépare/crée le répertoire effectif après résolution Config et journalise le succès en debug ou l'échec en error. Le gabarit Config Desk est réutilisé avec Bootstrap, Font Awesome, DataTables/Select, SimpleBar et `resize-observer-polyfill`. L'inventory reste non récursive `.kspwallet`, sans symlink d'entrée et root-scoped; les handles VIEW/OWNER restent exclusivement côté Rust. L'ouverture accepte un password éphémère saisi ou une tentative explicite de secrets Config `KSP_SECRET_WALLET_PASS_*`, dont ni nom ni valeur ne traversent le frontend. `getBalance` utilise la Pubkey du handle autorisé et les flows OWNER metadata/rotations/revocation/export fichier délèguent à Wallet. La CSP reste `null` par défaut comme dans Config Desk et n'est réauditée qu'en présence d'un besoin WebView concret. Le forecast souple détaillé s'étend jusqu'à `pre.014`, dernière tranche prévue pour README/USAGE/docs/validation, prompt `0.2.7` et build Tauri final; le plan actif est `docs/plans/013-V0_2_6_WALLET_DESK_PLAN.md`.
 
-`0.2.6-pre.002` matérialise le shell Tauri spécialisé. `0.2.6-pre.003` matérialise ensuite la première composition Config propre à Wallet Desk : `cfg.std.wallet`/`schema.std.wallet`, le composite `cfg.composite.ksp-app-wallet-desk`, `ResolvedWalletConfig`, la racine `${KSP_WALLETS_DIRECTORY:-wallets}`, les sous-répertoires de profils `temporary`/`tests`, la préservation de provenance `Composite` dans les adapters Logging/Wallet et la création sûre des répertoires par l’application. Aucun inventory ou fichier `.kspwallet` n’est encore ouvert dans cette tranche. `0.2.6-pre.003-fix.001` corrige ensuite les tests de registry/fixtures devenus obsolètes et instrumente les clics frontend génériques sans sérialiser la valeur des contrôles. `0.2.6-pre.003-fix.002` corrige le scanner d’inventaire `.env.example` qui interprétait `FILE_ID_COMPOSITE_KSP_APP_WALLET_DESK` comme une variable d’environnement, remplace le profil Logging ad hoc Wallet Desk par les profils génériques console-only/`file_info`/`superdev`/`supertrace`, et sélectionne temporairement `supertrace` dans le composite Wallet Desk. `0.2.6-pre.003-fix.003` corrige les deux canaris révélés par la validation opérateur de `fix.002` sans modifier cette surface Logging : closures avec `return` explicite sous la politique Clippy KSP et test lexical séparant fragment d’identifiant d’un vrai nom KSP suffixé. `0.2.6-pre.003-fix.004` complète cette remédiation en ajoutant les `return` explicites aux cinq closures restantes du canari `config_composition` de Wallet Desk ; aucune surface Config/Logging/frontend n’est modifiée. `0.2.6-pre.004` ajoute l’inventory `.kspwallet` réel sous `effective_wallets_directory` : lecture non récursive, extension exacte, exclusion des symlinks et non-fichiers, inspection par `ksp-wallet-lib::inspect_locked_wallet_file_v1`, lignes invalides conservées avec diagnostic sûr, DTOs locked sans identité protégée, DataTable/refresh actifs et sélection filename root-scoped revalidée côté Rust. Aucun handle VIEW/OWNER ni password n’est introduit dans cette tranche. `0.2.6-pre.004-fix.001` limite ensuite à `#[cfg(test)]` les deux réexports crate-root internes des enums d’état/inspection, uniquement consommés par les unit tests ; le build runtime ne les importe plus, tandis que les tests conservent le chemin `crate::...` imposé par les règles d’exports KSP. Le contrat runtime et TS-RS reste inchangé. `0.2.6-pre.005` branche ensuite la création native sur `create_wallet_file_v1` et introduit un `WalletSession` durable dans `AppState` : création -> OWNER ouvert, sélection existante -> Locked, puis lock/deselect/refresh/changement de wallet -> drop des handles et purge des projections protégées. Les passwords de création transitent uniquement frontend -> Rust et sont immédiatement déplacés dans les wrappers Wallet ; les unlock de wallets existants restent `pre.006`. `0.2.6-pre.005-fix.001` ferme le premier gate opérateur sans changer ce contrat : `WalletOwner` est boxed dans la variante OWNER pour éviter un `WalletSession` de plus de 1 KiB et le test statique de sécurité initialise correctement son offset `request_start`. `0.2.6-pre.006` matérialise les unlock manuels VIEW/OWNER et les secrets configurés : Config découvre les variables `KSP_SECRET_WALLET_PASS_*`, Wallet Desk ordonne les candidats par filename normalisé puis labels numériques puis nommés, ne révèle chaque valeur qu’au moment d’une tentative explicitement demandée, conserve noms/suffixes/valeurs hors IPC/logs, et protège les KDF concurrents avec `PrivilegedOperation` avant d’installer `WalletView` ou `WalletOwner` uniquement en Rust. `0.2.6-pre.006-fix.001` corrige les deux canaris statiques de `desktop_security` qui recherchaient le token `password` dans toute la définition textuelle de `WalletAuthorizedDto` et confondaient ainsi la documentation sûre de `configured_secret_candidate_count` avec un champ secret ; les assertions sont désormais bornées aux lignes de champs Rust de la projection. `0.2.6-pre.007` ferme le MVP obligatoire Config composite + Wallet + Transport : `resolve_transport_config_profile` préserve la provenance `Composite`, Wallet Desk construit le pool HTTP au bootstrap et valide statiquement une route `getBalance` sur le rôle `default`, puis `refresh_wallet_balance` copie uniquement la Pubkey depuis un handle VIEW/OWNER avant de libérer le mutex session et d'effectuer l'I/O. La réponse expose lamports exacts, SOL formaté sans flottant, slot, `api_version`, profil/rôle Transport ; une complétion devenue stale après lock/deselect/changement de session est rejetée. Les diagnostics Transport restent limités à profile/cluster/provider/compteurs, sans URL. `0.2.6-pre.007-fix.001` corrige uniquement son canari cross-crates : `config_composition.rs` utilisait par erreur `ConfigEnvironment::from_maps`, API `pub(crate)` réservée aux unit tests de Config. Le canari charge désormais l'environnement via `ConfigEnvironment::load`, surface publique également utilisée par le runtime. `0.2.6-pre.007-fix.002` retire ensuite du message d'assertion la tentative de formatage `Debug` du `Result<ConfigEnvironment, _>` : `ConfigEnvironment` reste volontairement non-`Debug`, et aucun contrat runtime n'est élargi pour les besoins du test.
+`0.2.6-pre.002` matérialise le shell Tauri spécialisé. `0.2.6-pre.003` matérialise ensuite la première composition Config propre à Wallet Desk : `cfg.std.wallet`/`schema.std.wallet`, le composite `cfg.composite.ksp-app-wallet-desk`, `ResolvedWalletConfig`, la racine `${KSP_WALLETS_DIRECTORY:-wallets}`, les sous-répertoires de profils `temporary`/`tests`, la préservation de provenance `Composite` dans les adapters Logging/Wallet et la création sûre des répertoires par l’application. Aucun inventory ou fichier `.kspwallet` n’est encore ouvert dans cette tranche. `0.2.6-pre.003-fix.001` corrige ensuite les tests de registry/fixtures devenus obsolètes et instrumente les clics frontend génériques sans sérialiser la valeur des contrôles. `0.2.6-pre.003-fix.002` corrige le scanner d’inventaire `.env.example` qui interprétait `FILE_ID_COMPOSITE_KSP_APP_WALLET_DESK` comme une variable d’environnement, remplace le profil Logging ad hoc Wallet Desk par les profils génériques console-only/`file_info`/`superdev`/`supertrace`, et sélectionne temporairement `supertrace` dans le composite Wallet Desk. `0.2.6-pre.003-fix.003` corrige les deux canaris révélés par la validation opérateur de `fix.002` sans modifier cette surface Logging : closures avec `return` explicite sous la politique Clippy KSP et test lexical séparant fragment d’identifiant d’un vrai nom KSP suffixé. `0.2.6-pre.003-fix.004` complète cette remédiation en ajoutant les `return` explicites aux cinq closures restantes du canari `config_composition` de Wallet Desk ; aucune surface Config/Logging/frontend n’est modifiée. `0.2.6-pre.004` ajoute l’inventory `.kspwallet` réel sous `effective_wallets_directory` : lecture non récursive, extension exacte, exclusion des symlinks et non-fichiers, inspection par `ksp-wallet-lib::inspect_locked_wallet_file_v1`, lignes invalides conservées avec diagnostic sûr, DTOs locked sans identité protégée, DataTable/refresh actifs et sélection filename root-scoped revalidée côté Rust. Aucun handle VIEW/OWNER ni password n’est introduit dans cette tranche. `0.2.6-pre.004-fix.001` limite ensuite à `#[cfg(test)]` les deux réexports crate-root internes des enums d’état/inspection, uniquement consommés par les unit tests ; le build runtime ne les importe plus, tandis que les tests conservent le chemin `crate::...` imposé par les règles d’exports KSP. Le contrat runtime et TS-RS reste inchangé. `0.2.6-pre.005` branche ensuite la création native sur `create_wallet_file_v1` et introduit un `WalletSession` durable dans `AppState` : création -> OWNER ouvert, sélection existante -> Locked, puis lock/deselect/refresh/changement de wallet -> drop des handles et purge des projections protégées. Les passwords de création transitent uniquement frontend -> Rust et sont immédiatement déplacés dans les wrappers Wallet ; les unlock de wallets existants restent `pre.006`. `0.2.6-pre.005-fix.001` ferme le premier gate opérateur sans changer ce contrat : `WalletOwner` est boxed dans la variante OWNER pour éviter un `WalletSession` de plus de 1 KiB et le test statique de sécurité initialise correctement son offset `request_start`. `0.2.6-pre.006` matérialise les unlock manuels VIEW/OWNER et les secrets configurés : Config découvre les variables `KSP_SECRET_WALLET_PASS_*`, Wallet Desk ordonne les candidats par filename normalisé puis labels numériques puis nommés, ne révèle chaque valeur qu’au moment d’une tentative explicitement demandée, conserve noms/suffixes/valeurs hors IPC/logs, et protège les KDF concurrents avec `PrivilegedOperation` avant d’installer `WalletView` ou `WalletOwner` uniquement en Rust. `0.2.6-pre.006-fix.001` corrige les deux canaris statiques de `desktop_security` qui recherchaient le token `password` dans toute la définition textuelle de `WalletAuthorizedDto` et confondaient ainsi la documentation sûre de `configured_secret_candidate_count` avec un champ secret ; les assertions sont désormais bornées aux lignes de champs Rust de la projection. `0.2.6-pre.007` ferme le MVP obligatoire Config composite + Wallet + Transport : `resolve_transport_config_profile` préserve la provenance `Composite`, Wallet Desk construit le pool HTTP au bootstrap et valide statiquement une route `getBalance` sur le rôle `default`, puis `refresh_wallet_balance` copie uniquement la Pubkey depuis un handle VIEW/OWNER avant de libérer le mutex session et d'effectuer l'I/O. La réponse expose lamports exacts, SOL formaté sans flottant, slot, `api_version`, profil/rôle Transport ; une complétion devenue stale après lock/deselect/changement de session est rejetée. Les diagnostics Transport restent limités à profile/cluster/provider/compteurs, sans URL. `0.2.6-pre.007-fix.001` corrige uniquement son canari cross-crates : `config_composition.rs` utilisait par erreur `ConfigEnvironment::from_maps`, API `pub(crate)` réservée aux unit tests de Config. Le canari charge désormais l'environnement via `ConfigEnvironment::load`, surface publique également utilisée par le runtime. `0.2.6-pre.007-fix.002` retire ensuite du message d'assertion la tentative de formatage `Debug` du `Result<ConfigEnvironment, _>` : `ConfigEnvironment` reste volontairement non-`Debug`, et aucun contrat runtime n'est élargi pour les besoins du test. `0.2.6-pre.008` ajoute ensuite l'import Solana CLI JSON/Base58 via un picker natif exclusivement Rust : `tauri-plugin-dialog` reste backend-only, aucun chemin source ni contenu secret ne traverse IPC, les octets sont lus avec une borne stricte puis conservés dans `Zeroizing<Vec<u8>>`, l'inspection ne projette que basename/format/Pubkey, et `import_wallet_transfer_v1` publie no-clobber sous la racine Config avec de nouveaux credentials OWNER/VIEW avant d'ouvrir la session OWNER.
 
 ## `0.2.7` — WebSocket Solana standard
 
diff --git a/docs/plans/013-V0_2_6_WALLET_DESK_PLAN.md b/docs/plans/013-V0_2_6_WALLET_DESK_PLAN.md
index 1d3a1b9..cf08286 100644
--- a/docs/plans/013-V0_2_6_WALLET_DESK_PLAN.md
+++ b/docs/plans/013-V0_2_6_WALLET_DESK_PLAN.md
@@ -1,5 +1,5 @@
 <!-- file: docs/plans/013-V0_2_6_WALLET_DESK_PLAN.md -->
-<!-- version: 19 -->
+<!-- version: 20 -->
 
 # Plan `0.2.6` — Wallet Desk
 
@@ -23,7 +23,7 @@ Les validations opérateur du `2026-08-20` ont ensuite confirmé la base `pre.00
 
 `0.2.6-pre.002` matérialise ensuite la première tranche technique : la crate `ksp-app-wallet-desk` rejoint le workspace avec le shell splash/main du gabarit Config Desk, le bootstrap Config + Logging commun, les ports `1432/1433`, Bootstrap, Font Awesome, DataTables/Select, SimpleBar, `resize-observer-polyfill`, TS-RS et le bridge frontend -> Rust -> `ksp-logging-lib`. Cette tranche ne branche encore ni `std.wallet`, ni inventory filesystem réel, ni `ksp-wallet-lib`, ni Transport : ces responsabilités restent dans les prereleases déjà dimensionnées.
 
-`0.2.6-pre.003` matérialise la composition Config prévue : `cfg.std.wallet`/`schema.std.wallet`, le composite `cfg.composite.ksp-app-wallet-desk`, les profils Wallet `default`/`temporary`/`tests`, `ResolvedWalletConfig` et les adapters qui peuvent consommer un profil déjà sélectionné par composite sans perdre la provenance `Composite`. Wallet Desk valide les composants `logging`/`transport`/`wallet`, crée la racine et le sous-répertoire effectif absents avec logs `debug`, refuse les objets filesystem invalides/symlinks de sous-répertoire avec logs `error`, et expose uniquement les chemins/profils non secrets dans le statut runtime. Aucun inventory `.kspwallet` n’est encore effectué. `pre.003-fix.001` corrige les deux régressions de tests révélées par la validation workspace et le warning Clippy, puis rend visibles les événements `trace` frontend. `pre.003-fix.002` corrige ensuite le canari d’inventaire `.env.example` qui confondait un fragment d’identifiant Rust avec une variable KSP, remplace le profil temporaire `wallet_desk_dev` par une famille Logging réutilisable (`console_*`, `file_info`, `superdev`, `supertrace`) et fait sélectionner temporairement `supertrace` par le composite Wallet Desk afin de conserver la visibilité des actions frontend sans profil spécifique à l’application. `pre.003-fix.003` corrige uniquement les canaris révélés par la validation de `fix.002` : conformité `clippy::implicit_return` et séparation explicite entre fragment lexical KSP incorporé dans un identifiant et nom d’environnement concret suffixé. `pre.003-fix.004` ferme le dernier défaut Clippy de cette série en ajoutant les `return` explicites aux cinq closures restantes du test de composition `supertrace`, sans changer les profils Logging ni le composite. `pre.004` matérialise ensuite l’inventory locked réel. Sa validation opérateur confirme le comportement fonctionnel et le workspace complet, mais révèle deux warnings `unused_imports` sur des réexports crate-root internes uniquement utiles aux unit tests ; `pre.004-fix.001` les limite à `#[cfg(test)]` : ils disparaissent du build runtime mais restent disponibles au crate-root pour les unit tests, conformément aux règles d’exports KSP, sans changement de comportement. `pre.005` matérialise ensuite la création native dans Wallet Desk et le premier lifecycle durable `WalletSession` : création no-clobber sous la racine Config via `create_wallet_file_v1`, session OWNER conservée uniquement en Rust après création, sélection locked durable, `Lock`/`Deselect`/Refresh/changement de wallet avec drop des handles et purge frontend des projections protégées/passwords. Les unlock VIEW/OWNER de wallets existants restent strictement `pre.006`. `pre.005-fix.001` corrige le gate de compilation/tests révélé par l'opérateur sans modifier le lifecycle : la variante `WalletSession::Owner` contient désormais `Box<WalletOwner>` afin de fermer `clippy::large_enum_variant`, et le canari de sécurité définit explicitement `request_start` avant de contrôler les champs password request-only. `pre.006` matérialise ensuite les unlock existants : VIEW/OWNER manuel, découverte Config des candidats `KSP_SECRET_WALLET_PASS_*`, ordre déterministe filename normalisé -> numérique -> nommé, actions configurées explicites et jamais automatiques, `PrivilegedOperation` pendant Argon2, puis sessions `View`/`Owner` Rust-only avec candidate count seul projeté vers l’UI. `pre.006-fix.001` corrige les deux canaris `desktop_security` qui inspectaient trop largement le texte de `WalletAuthorizedDto` : la documentation du compteur de candidats contient légitimement le mot `password`, mais aucun champ password n’est sérialisé ; le test filtre désormais uniquement les lignes de champs `pub(crate)` de la structure. `pre.007` ferme ensuite le MVP réseau : Config sait mapper un profil Transport déjà sélectionné par composite sans perdre la provenance `Composite`; Wallet Desk construit et conserve `HttpTransportPool`, publie uniquement profile/role/cluster/provider/compteurs sûrs, et `refresh_wallet_balance` accepte zéro argument frontend. Rust copie la Pubkey depuis `WalletView`/`WalletOwner`, libère le mutex avant l'I/O `getBalance`, utilise `confirmed`, puis projette lamports, SOL exact à neuf décimales, slot et `api_version`. Une réponse arrivée après lock/deselect/changement d'autorisation est refusée afin d'empêcher une balance stale de réapparaître. `pre.007-fix.001` corrige uniquement le canari d'intégration qui utilisait le constructeur test-only `ConfigEnvironment::from_maps`; le test passe désormais par `ConfigEnvironment::load`, API publique utilisée en production. `pre.007-fix.002` corrige le second défaut du même canari : son message d'assertion ne formate plus `environment` avec `{:?}`, ce qui aurait exigé `ConfigEnvironment: Debug`. ConfigEnvironment reste volontairement non-`Debug` et le runtime n'est pas modifié.
+`0.2.6-pre.003` matérialise la composition Config prévue : `cfg.std.wallet`/`schema.std.wallet`, le composite `cfg.composite.ksp-app-wallet-desk`, les profils Wallet `default`/`temporary`/`tests`, `ResolvedWalletConfig` et les adapters qui peuvent consommer un profil déjà sélectionné par composite sans perdre la provenance `Composite`. Wallet Desk valide les composants `logging`/`transport`/`wallet`, crée la racine et le sous-répertoire effectif absents avec logs `debug`, refuse les objets filesystem invalides/symlinks de sous-répertoire avec logs `error`, et expose uniquement les chemins/profils non secrets dans le statut runtime. Aucun inventory `.kspwallet` n’est encore effectué. `pre.003-fix.001` corrige les deux régressions de tests révélées par la validation workspace et le warning Clippy, puis rend visibles les événements `trace` frontend. `pre.003-fix.002` corrige ensuite le canari d’inventaire `.env.example` qui confondait un fragment d’identifiant Rust avec une variable KSP, remplace le profil temporaire `wallet_desk_dev` par une famille Logging réutilisable (`console_*`, `file_info`, `superdev`, `supertrace`) et fait sélectionner temporairement `supertrace` par le composite Wallet Desk afin de conserver la visibilité des actions frontend sans profil spécifique à l’application. `pre.003-fix.003` corrige uniquement les canaris révélés par la validation de `fix.002` : conformité `clippy::implicit_return` et séparation explicite entre fragment lexical KSP incorporé dans un identifiant et nom d’environnement concret suffixé. `pre.003-fix.004` ferme le dernier défaut Clippy de cette série en ajoutant les `return` explicites aux cinq closures restantes du test de composition `supertrace`, sans changer les profils Logging ni le composite. `pre.004` matérialise ensuite l’inventory locked réel. Sa validation opérateur confirme le comportement fonctionnel et le workspace complet, mais révèle deux warnings `unused_imports` sur des réexports crate-root internes uniquement utiles aux unit tests ; `pre.004-fix.001` les limite à `#[cfg(test)]` : ils disparaissent du build runtime mais restent disponibles au crate-root pour les unit tests, conformément aux règles d’exports KSP, sans changement de comportement. `pre.005` matérialise ensuite la création native dans Wallet Desk et le premier lifecycle durable `WalletSession` : création no-clobber sous la racine Config via `create_wallet_file_v1`, session OWNER conservée uniquement en Rust après création, sélection locked durable, `Lock`/`Deselect`/Refresh/changement de wallet avec drop des handles et purge frontend des projections protégées/passwords. Les unlock VIEW/OWNER de wallets existants restent strictement `pre.006`. `pre.005-fix.001` corrige le gate de compilation/tests révélé par l'opérateur sans modifier le lifecycle : la variante `WalletSession::Owner` contient désormais `Box<WalletOwner>` afin de fermer `clippy::large_enum_variant`, et le canari de sécurité définit explicitement `request_start` avant de contrôler les champs password request-only. `pre.006` matérialise ensuite les unlock existants : VIEW/OWNER manuel, découverte Config des candidats `KSP_SECRET_WALLET_PASS_*`, ordre déterministe filename normalisé -> numérique -> nommé, actions configurées explicites et jamais automatiques, `PrivilegedOperation` pendant Argon2, puis sessions `View`/`Owner` Rust-only avec candidate count seul projeté vers l’UI. `pre.006-fix.001` corrige les deux canaris `desktop_security` qui inspectaient trop largement le texte de `WalletAuthorizedDto` : la documentation du compteur de candidats contient légitimement le mot `password`, mais aucun champ password n’est sérialisé ; le test filtre désormais uniquement les lignes de champs `pub(crate)` de la structure. `pre.007` ferme ensuite le MVP réseau : Config sait mapper un profil Transport déjà sélectionné par composite sans perdre la provenance `Composite`; Wallet Desk construit et conserve `HttpTransportPool`, publie uniquement profile/role/cluster/provider/compteurs sûrs, et `refresh_wallet_balance` accepte zéro argument frontend. Rust copie la Pubkey depuis `WalletView`/`WalletOwner`, libère le mutex avant l'I/O `getBalance`, utilise `confirmed`, puis projette lamports, SOL exact à neuf décimales, slot et `api_version`. Une réponse arrivée après lock/deselect/changement d'autorisation est refusée afin d'empêcher une balance stale de réapparaître. `pre.007-fix.001` corrige uniquement le canari d'intégration qui utilisait le constructeur test-only `ConfigEnvironment::from_maps`; le test passe désormais par `ConfigEnvironment::load`, API publique utilisée en production. `pre.007-fix.002` corrige le second défaut du même canari : son message d'assertion ne formate plus `environment` avec `{:?}`, ce qui aurait exigé `ConfigEnvironment: Debug`. ConfigEnvironment reste volontairement non-`Debug` et le runtime n'est pas modifié. `pre.008` ajoute ensuite l'import de keypairs Solana CLI JSON/Base58 via le plugin Dialog utilisé exclusivement côté Rust : le frontend choisit seulement le format, Rust ouvre le picker natif, convertit le résultat en chemin local, lit la source avec une borne stricte, valide la Pubkey via `ksp-wallet-lib`, conserve les octets secrets dans `Zeroizing<Vec<u8>>` et ne renvoie que basename/format/Pubkey. L'import consomme cette source staged en mémoire avec `import_wallet_transfer_v1`, publie no-clobber sous la racine Wallet Config et ouvre la session OWNER avec de nouveaux credentials KSP. Aucun chemin source, contenu secret ou permission guest Dialog/FS ne traverse l'IPC.
 
 ## 2. Sources relues et hiérarchie appliquée
 
@@ -776,8 +776,8 @@ outil de logging contrôlé
 | `unlock_wallet_owner_with_configured_secret` | —                  | authorized OWNER / operation result | Config env + Wallet open OWNER  |
 | `lock_wallet`                                | —                  | `LockedWalletDto`                   | drop handle + inspect           |
 | `refresh_wallet_balance`                     | —                  | `WalletBalanceDto`                  | Transport getBalance            |
-| `inspect_import_source`                      | native picker path | transfer inspection DTO             | Wallet inspect transfer         |
-| `import_wallet`                              | import request     | authorized OWNER                    | Wallet import file              |
+| `inspect_import_source`                      | format only         | transfer inspection DTO / cancel    | Rust native picker + Wallet inspect |
+| `import_wallet`                              | import request     | authorized OWNER                    | staged bytes + Wallet import         |
 | `update_wallet_alias`                        | alias mutation     | authorized DTO                      | WalletOwner                     |
 | `add_wallet_note`                            | note create        | authorized DTO                      | WalletOwner                     |
 | `update_wallet_note`                         | note update        | authorized DTO                      | WalletOwner                     |
@@ -888,14 +888,14 @@ core:default
 tracing:default
 ```
 
-Lorsque les pickers sont réellement ajoutés :
+À partir de `pre.008`, le plugin Dialog est initialisé **uniquement côté Rust**. Le frontend n'appelle aucune guest API Dialog ; la capability reste donc :
 
 ```text
-dialog:allow-open
-dialog:allow-save
+core:default
+tracing:default
 ```
 
-Aucun plugin filesystem n'est nécessaire pour l'inventory : Rust effectue les opérations côté application.
+Aucune permission `dialog:*` ni `fs:*` n'est accordée. Rust ouvre le picker via `tauri_plugin_dialog::DialogExt`, convertit le résultat en chemin local puis lit la source lui-même. Le même principe est à conserver pour le futur save picker d'export tant qu'aucun besoin guest JavaScript n'apparaît. Aucun plugin filesystem n'est nécessaire pour l'inventory ou l'import desktop.
 
 ### 15.2 CSP
 
@@ -984,16 +984,20 @@ répertoire effectif Config
 ### 17.2 Import
 
 ```text
-picker open
--> inspect_wallet_transfer_file
+format choisi côté UI
+-> picker open côté Rust
+-> chemin local Rust-only
+-> lecture bornée + Zeroizing<Vec<u8>>
+-> inspect_wallet_transfer
+-> projection sûre basename / format / Pubkey
 -> choix destination sous root effectif
 -> nouveaux credentials KSP
--> import_wallet_transfer_file_v1
+-> import_wallet_transfer_v1 sur les mêmes octets staged
 -> no-clobber
 -> session OWNER
 ```
 
-La source n'est jamais parsée en TypeScript.
+La source n'est jamais parsée en TypeScript, son path ne traverse pas IPC et l'import consomme exactement les octets déjà inspectés.
 
 ### 17.3 Export
 
@@ -1193,7 +1197,7 @@ resize-observer-polyfill 1.5.1
 
 Les ranges du template couvrent ces générations. `simplebar ^6.3` est conservé depuis le template validé ; la version exacte sera réaudité au moment de création du `package.json` comme toute dépendance effectivement ajoutée.
 
-Le plugin Dialog n'est ajouté qu'à la tranche import/export qui le consomme et sa version Rust/npm est vérifiée à ce moment.
+`pre.008` ajoute `tauri-plugin-dialog ^2.7` côté Rust (2.7.2 courant lors de l'audit du 2026-08-21). Le package npm n'est volontairement pas ajouté puisque le guest JavaScript n'utilise aucune API Dialog ; le picker est entièrement possédé par les commandes Rust.
 
 Sources d'audit actuelles :
 
@@ -1437,19 +1441,28 @@ Aucun `Debug` n'est ajouté à `ConfigEnvironment`; aucune API Config, logique T
 
 ### `pre.008` — import Solana CLI JSON / Base58
 
-Objectifs :
+Statut : **implémenté dans `0.2.6-pre.008`**.
+
+Surface livrée :
 
 ```text
-plugin Dialog open minimal
-picker source
-inspect transfer sûr
-import destination root-scoped
-nouveaux OWNER/VIEW credentials
+ta​uri-plugin-dialog Rust-only
+format choisi par le frontend
+picker natif ouvert côté Rust
+source externe -> path local Rust uniquement
+lecture bornée selon le format
+Zeroizing<Vec<u8>> en staging Rust-only
+inspect_wallet_transfer -> basename / format / Pubkey sûrs
+import_wallet_transfer_v1 -> destination root-scoped
+nouveaux OWNER/VIEW credentials request-only
 no-clobber
-inventory/session refresh
+OWNER session ouverte après succès
+inventory refresh
 ```
 
-Le contenu secret de la source importée reste côté Rust. Les nouveaux passwords éventuellement saisis dans l'UI transitent uniquement dans la request Tauri HTML/TypeScript -> Rust, puis sont purgés côté frontend ; ils ne reviennent jamais dans une réponse.
+La source n'est jamais parsée en TypeScript et son chemin n'est jamais sérialisé dans un DTO. `inspect_import_source` accepte uniquement un `WalletImportSourceRequestDto { format }`; le picker est invoqué par Rust avec `DialogExt`. Une source valide est lue une seule fois dans une mémoire bornée et zeroized, puis conservée comme `PendingWalletImport`. `import_wallet` consomme ce staging en mémoire avec `import_wallet_transfer_v1`, ce qui supprime le risque de réutiliser un chemin externe fourni par le frontend et évite une seconde lecture de la source entre inspection et import.
+
+Le plugin Dialog n'est pas exposé au guest JavaScript : aucun package npm `@tauri-apps/plugin-dialog`, aucune permission `dialog:*` et aucun plugin filesystem ne sont ajoutés. Le frontend ne reçoit que `source_name` (basename), `format` et `pubkey`. Les nouveaux passwords OWNER/VIEW transitent uniquement HTML/TypeScript -> Rust pour l'opération demandée, sont déplacés dans les wrappers Wallet, puis purgés côté frontend ; ils ne reviennent jamais dans une réponse.
 
 ### `pre.009` — metadata OWNER