v0.2.6-pre.009

crates/ksp-app-wallet-desk/frontend/main.html

@@ -252,6 +252,40 @@
                                 <div id="balanceStatus" class="alert alert-secondary mb-0" role="status">Unlock VIEW ou OWNER pour interroger getBalance.</div>
                             </div>
                         </div>
+                        <div class="card shadow-sm mt-3">
+                            <div class="card-header fw-semibold">Administration metadata OWNER</div>
+                            <div class="card-body">
+                                <p class="text-body-secondary">Alias et notes sont protégés dans le wallet. Les contrôles restent désactivés tant qu’une session OWNER n’est pas ouverte.</p>
+                                <div class="row g-3">
+                                    <div class="col-lg-6">
+                                        <label class="form-label" for="ownerWalletAlias">Alias interne</label>
+                                        <div class="input-group">
+                                            <input id="ownerWalletAlias" class="form-control" type="text" autocomplete="off" data-owner-metadata-control disabled>
+                                            <button id="saveOwnerAlias" class="btn btn-outline-primary" type="button" data-owner-metadata-control disabled>Save</button>
+                                            <button id="clearOwnerAlias" class="btn btn-outline-secondary" type="button" data-owner-metadata-control disabled>Clear</button>
+                                        </div>
+                                        <div class="form-text">Limite V1 : 256 octets UTF-8. La validation autoritative reste dans ksp-wallet-lib.</div>
+                                    </div>
+                                    <div class="col-lg-6">
+                                        <label class="form-label" for="ownerNewNote">Nouvelle note</label>
+                                        <div class="input-group">
+                                            <textarea id="ownerNewNote" class="form-control" rows="2" autocomplete="off" data-owner-metadata-control disabled></textarea>
+                                            <button id="addOwnerNote" class="btn btn-outline-primary" type="button" data-owner-metadata-control disabled>Add note</button>
+                                        </div>
+                                    </div>
+                                    <div class="col-12">
+                                        <div class="d-flex justify-content-between align-items-center mb-2">
+                                            <span class="fw-semibold">Notes autorisées</span>
+                                            <small class="text-body-secondary">64 notes maximum en V1</small>
+                                        </div>
+                                        <div id="ownerNotesList" class="vstack gap-2"><span class="text-body-secondary">Ouvrir OWNER pour administrer les notes.</span></div>
+                                    </div>
+                                    <div class="col-12">
+                                        <div id="ownerMetadataStatus" class="alert alert-secondary mb-0" role="status">Session OWNER requise.</div>
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
                     </section>
                     <section data-view-panel="security" hidden>
                         <div class="row g-3">
@@ -310,8 +344,23 @@
             </section>
         </div>
     </main>
+    <div class="modal fade" id="deleteWalletNoteModal" tabindex="-1" aria-labelledby="deleteWalletNoteModalLabel" aria-hidden="true">
+        <div class="modal-dialog modal-dialog-centered">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h2 class="modal-title fs-5" id="deleteWalletNoteModalLabel">Supprimer la note protégée ?</h2>
+                    <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+                </div>
+                <div class="modal-body">Cette mutation OWNER est définitive pour la note sélectionnée. Le contenu protégé n’est pas recopié dans la confirmation.</div>
+                <div class="modal-footer">
+                    <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Cancel</button>
+                    <button id="confirmDeleteWalletNote" type="button" class="btn btn-danger">Delete note</button>
+                </div>
+            </div>
+        </div>
+    </div>
     <footer class="app-footer bg-dark text-white-50 d-flex align-items-center px-4">
-        <span>KSP Wallet Desk · native transfer import pre.008</span>
+        <span>KSP Wallet Desk · OWNER metadata pre.009</span>
     </footer>
     <script type="module" src="./ts/main.ts"></script>
 </body>

crates/ksp-app-wallet-desk/frontend/ts/main.ts

@@ -1,13 +1,14 @@
 // file: crates/ksp-app-wallet-desk/frontend/ts/main.ts
-// version: 8
+// version: 9
 
-import "bootstrap";
+import { Modal } from "bootstrap";
 import DataTable from "datatables.net-bs5";
 import "datatables.net-select-bs5";
 import ResizeObserver from "resize-observer-polyfill";
 import "simplebar";
 import { getCurrentWindow } from "@tauri-apps/api/window";
 import type { WalletBalanceDto } from "./bindings/ksp_app_wallet_desk/wallet_balance/WalletBalanceDto.ts";
+import type { CommandErrorDto } from "./bindings/ksp_app_wallet_desk/dto_common/CommandErrorDto.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";
@@ -16,6 +17,10 @@ import type { WalletTransferInspectionDto } from "./bindings/ksp_app_wallet_desk
 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";
+import type { WalletAliasUpdateRequestDto } from "./bindings/ksp_app_wallet_desk/wallet_metadata/WalletAliasUpdateRequestDto.ts";
+import type { WalletNoteAddRequestDto } from "./bindings/ksp_app_wallet_desk/wallet_metadata/WalletNoteAddRequestDto.ts";
+import type { WalletNoteDeleteRequestDto } from "./bindings/ksp_app_wallet_desk/wallet_metadata/WalletNoteDeleteRequestDto.ts";
+import type { WalletNoteUpdateRequestDto } from "./bindings/ksp_app_wallet_desk/wallet_metadata/WalletNoteUpdateRequestDto.ts";
 import type { WalletAuthorizedDto } from "./bindings/ksp_app_wallet_desk/wallet_session/WalletAuthorizedDto.ts";
 import type { WalletCreateRequestDto } from "./bindings/ksp_app_wallet_desk/wallet_session/WalletCreateRequestDto.ts";
 import type { WalletSessionDto } from "./bindings/ksp_app_wallet_desk/wallet_session/WalletSessionDto.ts";
@@ -43,7 +48,10 @@ const viewTitles: Record<ViewId, string> = {
 let activeWalletId: string | null = null;
 let activeSessionState: ActiveSessionState = "no_selection";
 let activeViewEnabled = false;
+let authorizedWalletProjection: WalletAuthorizedDto | null = null;
 let configuredSecretCandidateCount = 0;
+let deleteNoteModal: Modal | null = null;
+let pendingDeleteNoteId: string | null = null;
 let stagedImportSource: WalletTransferInspectionDto | null = null;
 
 function isViewId(value: string): value is ViewId {
@@ -212,6 +220,14 @@ function updateSessionActions(): void {
         refreshBalance.disabled = activeSessionState !== "view_open" && activeSessionState !== "owner_open";
     }
     updateUnlockActions();
+    updateOwnerMetadataActions();
+}
+
+function updateOwnerMetadataActions(): void {
+    const ownerOpen = activeSessionState === "owner_open";
+    document.querySelectorAll<HTMLInputElement | HTMLTextAreaElement | HTMLButtonElement>("[data-owner-metadata-control]").forEach(control => {
+        control.disabled = !ownerOpen;
+    });
 }
 
 function updateUnlockActions(): void {
@@ -314,6 +330,8 @@ function clearBalanceProjection(): void {
 }
 
 function clearAuthorizedProjection(): void {
+    authorizedWalletProjection = null;
+    clearOwnerMetadataProjection();
     setText("#currentWalletPubkey", "—");
     setText("#currentWalletAlias", "—");
     setText("#currentWalletNotes", "—");
@@ -371,6 +389,7 @@ function renderLockedWallet(wallet: LockedWalletDto): void {
 
 function renderAuthorizedWallet(wallet: WalletAuthorizedDto): void {
     activeWalletId = wallet.walletId;
+    authorizedWalletProjection = wallet;
     activeSessionState = wallet.capability === "view" ? "view_open" : "owner_open";
     activeViewEnabled = wallet.viewEnabled;
     configuredSecretCandidateCount = wallet.configuredSecretCandidateCount;
@@ -392,6 +411,7 @@ function renderAuthorizedWallet(wallet: WalletAuthorizedDto): void {
     setText("#detailsWalletPubkey", wallet.pubkey);
     setText("#detailsWalletAlias", wallet.alias ?? "—");
     setText("#detailsWalletNotes", notesText);
+    renderOwnerMetadataProjection(wallet);
     clearBalanceProjection();
     setText("#balanceStatus", "Session autorisée. Refresh balance appelle getBalance avec la Pubkey détenue par Rust.");
     setText("#unlockStatus", `${capabilityLabel} ouvert. Lock pour purger le handle autorisé.`);
@@ -405,6 +425,195 @@ function renderAuthorizedWallet(wallet: WalletAuthorizedDto): void {
     });
 }
 
+function clearOwnerMetadataProjection(): void {
+    pendingDeleteNoteId = null;
+    const alias = document.querySelector<HTMLInputElement>("#ownerWalletAlias");
+    const newNote = document.querySelector<HTMLTextAreaElement>("#ownerNewNote");
+    const list = document.querySelector<HTMLElement>("#ownerNotesList");
+    if (alias) {
+        alias.value = "";
+    }
+    if (newNote) {
+        newNote.value = "";
+    }
+    if (list) {
+        const empty = document.createElement("span");
+        empty.className = "text-body-secondary";
+        empty.textContent = "Ouvrir OWNER pour administrer les notes.";
+        list.replaceChildren(empty);
+    }
+    setText("#ownerMetadataStatus", "Session OWNER requise.");
+}
+
+function renderOwnerMetadataProjection(wallet: WalletAuthorizedDto): void {
+    const alias = document.querySelector<HTMLInputElement>("#ownerWalletAlias");
+    const list = document.querySelector<HTMLElement>("#ownerNotesList");
+    if (alias) {
+        alias.value = wallet.alias ?? "";
+    }
+    if (list) {
+        if (wallet.notes.length === 0) {
+            const empty = document.createElement("span");
+            empty.className = "text-body-secondary";
+            empty.textContent = wallet.capability === "owner" ? "Aucune note protégée." : "Les notes sont visibles en VIEW mais modifiables uniquement en OWNER.";
+            list.replaceChildren(empty);
+        } else {
+            const rows = wallet.notes.map(note => {
+                const row = document.createElement("div");
+                row.className = "border rounded p-2";
+                const textarea = document.createElement("textarea");
+                textarea.className = "form-control mb-2";
+                textarea.rows = 2;
+                textarea.value = note.text;
+                textarea.disabled = wallet.capability !== "owner";
+                textarea.autocomplete = "off";
+                textarea.dataset.ownerMetadataControl = "true";
+                const actions = document.createElement("div");
+                actions.className = "d-flex gap-2 justify-content-end";
+                const save = document.createElement("button");
+                save.className = "btn btn-outline-primary btn-sm";
+                save.type = "button";
+                save.textContent = "Save note";
+                save.disabled = wallet.capability !== "owner";
+                save.dataset.ownerMetadataControl = "true";
+                save.addEventListener("click", () => {
+                    const request: WalletNoteUpdateRequestDto = { noteId: note.id, text: textarea.value };
+                    void runOwnerMetadataMutation("update_wallet_note", { request }, "Mise à jour de la note…", "Note mise à jour.");
+                });
+                const remove = document.createElement("button");
+                remove.className = "btn btn-outline-danger btn-sm";
+                remove.type = "button";
+                remove.textContent = "Delete";
+                remove.disabled = wallet.capability !== "owner";
+                remove.dataset.ownerMetadataControl = "true";
+                remove.addEventListener("click", () => {
+                    pendingDeleteNoteId = note.id;
+                    deleteNoteModal?.show();
+                    frontendDebug("main", "OWNER note delete confirmation opened", { walletId: wallet.walletId });
+                });
+                actions.append(save, remove);
+                row.append(textarea, actions);
+                return row;
+            });
+            list.replaceChildren(...rows);
+        }
+    }
+    setText("#ownerMetadataStatus", wallet.capability === "owner" ? "OWNER ouvert : metadata modifiable." : "VIEW ouvert : metadata en lecture seule.");
+    updateOwnerMetadataActions();
+}
+
+function isWalletStateConflict(caughtError: unknown): boolean {
+    if (typeof caughtError !== "object" || caughtError === null) {
+        return false;
+    }
+    const error = caughtError as Partial<CommandErrorDto>;
+    return error.domain === "wallet" && error.code === "state_conflict";
+}
+
+async function recoverOwnerMetadataStateConflict(walletId: string): Promise<void> {
+    clearAuthorizedProjection();
+    clearBalanceProjection();
+    const request: WalletSelectionRequestDto = { walletId };
+    try {
+        const wallet = await invokeKsp<LockedWalletDto>("main", "select_wallet", { request });
+        renderLockedWallet(wallet);
+        setText("#ownerMetadataStatus", "Le fichier wallet a changé hors de cette session. Le handle OWNER stale a été purgé ; unlock OWNER requis avant toute nouvelle mutation.");
+        setText("#unlockStatus", "Conflit d’état détecté : wallet réinspecté et reverrouillé. Réautoriser OWNER explicitement.");
+        await loadWalletInventory("list_wallets", false);
+        activateView("security", "user");
+        frontendWarn("main", "Wallet state conflict forced OWNER reauthorization", { walletId });
+    } catch {
+        clearSelectedWallet();
+        setText("#ownerMetadataStatus", "Conflit d’état détecté et réinspection impossible. Resélectionner le wallet depuis l’inventaire.");
+        frontendWarn("main", "Wallet state conflict recovery failed", { walletId });
+    }
+}
+
+async function runOwnerMetadataMutation(
+    command: "add_wallet_note" | "delete_wallet_note" | "update_wallet_alias" | "update_wallet_note",
+    args: Record<string, unknown>,
+    pendingMessage: string,
+    successMessage: string,
+): Promise<boolean> {
+    if (activeSessionState !== "owner_open" || !activeWalletId || authorizedWalletProjection?.capability !== "owner") {
+        setText("#ownerMetadataStatus", "Session OWNER requise.");
+        return false;
+    }
+    const walletId = activeWalletId;
+    activeSessionState = "privileged_operation";
+    setText("#currentWalletState", "OWNER mutation…");
+    setText("#ownerMetadataStatus", pendingMessage);
+    updateSessionActions();
+    frontendDebug("main", "OWNER metadata mutation requested", { command, walletId });
+    try {
+        const wallet = await invokeKsp<WalletAuthorizedDto>("main", command, args);
+        if (activeWalletId !== walletId) {
+            frontendWarn("main", "Stale OWNER metadata response ignored", { command, walletId });
+            return false;
+        }
+        renderAuthorizedWallet(wallet);
+        setText("#ownerMetadataStatus", successMessage);
+        await loadWalletInventory("list_wallets", false);
+        return true;
+    } catch (caughtError) {
+        if (isWalletStateConflict(caughtError)) {
+            await recoverOwnerMetadataStateConflict(walletId);
+            return false;
+        }
+        if (activeWalletId === walletId) {
+            activeSessionState = "owner_open";
+            setText("#currentWalletState", "OWNER open");
+            setText("#ownerMetadataStatus", "Mutation refusée ; la session OWNER reste ouverte.");
+            updateSessionActions();
+        }
+        frontendWarn("main", "OWNER metadata mutation failed", { command, walletId });
+        return false;
+    }
+}
+
+function bindOwnerMetadataActions(): void {
+    const modalElement = document.querySelector<HTMLElement>("#deleteWalletNoteModal");
+    if (modalElement) {
+        deleteNoteModal = new Modal(modalElement);
+    }
+    document.querySelector<HTMLButtonElement>("#saveOwnerAlias")?.addEventListener("click", () => {
+        const alias = document.querySelector<HTMLInputElement>("#ownerWalletAlias");
+        if (!alias) {
+            return;
+        }
+        const request: WalletAliasUpdateRequestDto = { alias: alias.value.length === 0 ? null : alias.value };
+        void runOwnerMetadataMutation("update_wallet_alias", { request }, "Mise à jour de l’alias…", "Alias mis à jour.");
+    });
+    document.querySelector<HTMLButtonElement>("#clearOwnerAlias")?.addEventListener("click", () => {
+        const request: WalletAliasUpdateRequestDto = { alias: null };
+        void runOwnerMetadataMutation("update_wallet_alias", { request }, "Suppression de l’alias…", "Alias supprimé.");
+    });
+    document.querySelector<HTMLButtonElement>("#addOwnerNote")?.addEventListener("click", () => {
+        const text = document.querySelector<HTMLTextAreaElement>("#ownerNewNote");
+        if (!text || text.value.length === 0) {
+            setText("#ownerMetadataStatus", "Texte de note requis.");
+            return;
+        }
+        const request: WalletNoteAddRequestDto = { text: text.value };
+        void runOwnerMetadataMutation("add_wallet_note", { request }, "Ajout de la note…", "Note ajoutée.").then(succeeded => {
+            if (succeeded && activeSessionState === "owner_open") {
+                text.value = "";
+            }
+        });
+    });
+    document.querySelector<HTMLButtonElement>("#confirmDeleteWalletNote")?.addEventListener("click", () => {
+        const noteId = pendingDeleteNoteId;
+        pendingDeleteNoteId = null;
+        deleteNoteModal?.hide();
+        if (!noteId) {
+            return;
+        }
+        const request: WalletNoteDeleteRequestDto = { noteId };
+        void runOwnerMetadataMutation("delete_wallet_note", { request }, "Suppression de la note…", "Note supprimée.");
+    });
+    frontendTrace("main", "OWNER metadata action handlers installed");
+}
+
 async function selectWallet(walletId: string): Promise<void> {
     clearSelectedWallet();
     const request: WalletSelectionRequestDto = { walletId };
@@ -824,7 +1033,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 ; import natif, VIEW/OWNER et getBalance prêts.");
+    setText("#shellStatus", "Config/Transport résolus ; import, VIEW/OWNER, metadata OWNER et getBalance prêts.");
     frontendTrace("main", "Wallet Desk runtime status rendered", {
         compositeProfile: status.activeCompositeProfile,
         fallbackLoggingActive: status.fallbackLoggingActive,
@@ -875,6 +1084,7 @@ async function initializeMain(): Promise<void> {
     bindImportWalletForm();
     bindUnlockActions();
     bindBalanceActions();
+    bindOwnerMetadataActions();
     bindShellActions();
     clearSelectedWallet();
     activateView("dashboard", "startup");

crates/ksp-app-wallet-desk/package.json

@@ -1,7 +1,7 @@
 {
     "name": "ksp-app-wallet-desk",
     "private": true,
-    "version": "0.2.6-pre.8.fix.1",
+    "version": "0.2.6-pre.9",
     "type": "module",
     "scripts": {
         "dev": "vite",

crates/ksp-app-wallet-desk/src/app_state.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-app-wallet-desk/src/app_state.rs
-// version: 10
+// version: 11
 
 //! Shared backend state owned by the Wallet Desk Tauri application.
 
@@ -126,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.008-wallet-import".to_owned(),
+            shell_phase: "pre.009-owner-metadata".to_owned(),
             startup_diagnostic: runtime.startup_diagnostic.clone(),
             transport_available_endpoint_count,
             transport_clusters: self.transport_runtime.clusters(),
@@ -217,7 +217,7 @@ impl AppState {
             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) };
+        *session = crate::WalletSession::Owner { wallet_id: filename.clone(), path: destination, view_enabled, wallet: std::boxed::Box::new(owner) };
         ksp_logging_lib::info!(target: crate::TRACING_TARGET, domain = crate::TRACING_DOMAIN_WALLET_SESSION, wallet_id = filename.as_str(), view_enabled, "Wallet created and OWNER session opened");
         return std::result::Result::Ok(dto);
     }
@@ -313,7 +313,7 @@ impl AppState {
             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) };
+        *session = crate::WalletSession::Owner { wallet_id: filename.clone(), path: destination, view_enabled, 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);
     }
@@ -483,6 +483,18 @@ impl AppState {
                     "Wallet unlock operation is already in progress",
                 ));
             },
+            crate::WalletSession::OwnerOperation { wallet_id, path, pubkey, view_enabled } => {
+                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::OwnerOperation { wallet_id, path, pubkey, view_enabled };
+                return std::result::Result::Err(ksp_core_lib::Error::new(
+                    crate::ERROR_CODE_WALLET_SESSION_INVALID,
+                    "Wallet OWNER metadata operation is already in progress",
+                ));
+            },
             crate::WalletSession::View { wallet_id, path, wallet, .. } => {
                 drop(wallet);
                 (wallet_id, path)
@@ -595,7 +607,7 @@ impl AppState {
             },
         };
         let dto = crate::view_projection(wallet_id.as_str(), view_enabled, configured_secret_candidate_count, &view);
-        *session = crate::WalletSession::View { wallet_id: wallet_id.clone(), path, wallet: std::boxed::Box::new(view) };
+        *session = crate::WalletSession::View { wallet_id: wallet_id.clone(), path, view_enabled, wallet: std::boxed::Box::new(view) };
         ksp_logging_lib::info!(target: crate::TRACING_TARGET, domain = crate::TRACING_DOMAIN_WALLET_SESSION, wallet_id = wallet_id.as_str(), capability = "view", "Wallet VIEW session opened");
         return std::result::Result::Ok(dto);
     }
@@ -633,7 +645,7 @@ impl AppState {
             },
         };
         let dto = crate::owner_projection(wallet_id.as_str(), view_enabled, configured_secret_candidate_count, &owner);
-        *session = crate::WalletSession::Owner { wallet_id: wallet_id.clone(), path, wallet: std::boxed::Box::new(owner) };
+        *session = crate::WalletSession::Owner { wallet_id: wallet_id.clone(), path, view_enabled, wallet: std::boxed::Box::new(owner) };
         ksp_logging_lib::info!(target: crate::TRACING_TARGET, domain = crate::TRACING_DOMAIN_WALLET_SESSION, wallet_id = wallet_id.as_str(), capability = "owner", "Wallet OWNER session opened");
         return std::result::Result::Ok(dto);
     }
@@ -649,6 +661,178 @@ impl AppState {
         };
     }
 
+    /// Updates or clears the protected alias through the current OWNER handle.
+    pub(crate) async fn update_wallet_alias(&self, request: crate::WalletAliasUpdateRequestDto) -> ksp_core_lib::Result<crate::WalletAuthorizedDto> {
+        let context = self.begin_owner_metadata_operation("alias_update");
+        let mut context = match context {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let alias = normalize_optional_text(request.alias);
+        let result = context.owner.update_alias(context.path.as_path(), alias).await;
+        return self.finish_owner_metadata_operation(context, result).await;
+    }
+
+    /// Appends one protected note through the current OWNER handle.
+    pub(crate) async fn add_wallet_note(&self, request: crate::WalletNoteAddRequestDto) -> ksp_core_lib::Result<crate::WalletAuthorizedDto> {
+        let context = self.begin_owner_metadata_operation("note_add");
+        let mut context = match context {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let result = context.owner.add_note(context.path.as_path(), request.text).await;
+        let result = match result {
+            std::result::Result::Ok(_) => std::result::Result::Ok(()),
+            std::result::Result::Err(error) => std::result::Result::Err(error),
+        };
+        return self.finish_owner_metadata_operation(context, result).await;
+    }
+
+    /// Updates one protected note through the current OWNER handle.
+    pub(crate) async fn update_wallet_note(&self, request: crate::WalletNoteUpdateRequestDto) -> ksp_core_lib::Result<crate::WalletAuthorizedDto> {
+        let context = self.begin_owner_metadata_operation("note_update");
+        let mut context = match context {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let result = context.owner.update_note(context.path.as_path(), request.note_id.as_str(), request.text).await;
+        return self.finish_owner_metadata_operation(context, result).await;
+    }
+
+    /// Deletes one protected note through the current OWNER handle.
+    pub(crate) async fn delete_wallet_note(&self, request: crate::WalletNoteDeleteRequestDto) -> ksp_core_lib::Result<crate::WalletAuthorizedDto> {
+        let context = self.begin_owner_metadata_operation("note_delete");
+        let mut context = match context {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let result = context.owner.delete_note(context.path.as_path(), request.note_id.as_str()).await;
+        return self.finish_owner_metadata_operation(context, result).await;
+    }
+
+    fn begin_owner_metadata_operation(&self, operation: &'static str) -> ksp_core_lib::Result<OwnerMetadataContext> {
+        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()),
+        };
+        let previous = std::mem::replace(&mut *session, crate::WalletSession::no_selection());
+        let (wallet_id, path, view_enabled, owner) = match previous {
+            crate::WalletSession::Owner { wallet_id, path, view_enabled, wallet } => (wallet_id, path, view_enabled, wallet),
+            other => {
+                *session = other;
+                return std::result::Result::Err(ksp_core_lib::Error::new(
+                    crate::ERROR_CODE_WALLET_AUTHORIZATION_REQUIRED,
+                    "Wallet metadata administration requires an authorized OWNER session",
+                ));
+            },
+        };
+        let pubkey = owner.pubkey().to_owned();
+        let context = OwnerMetadataContext { operation, owner, path: path.clone(), pubkey, view_enabled, wallet_id: wallet_id.clone() };
+        *session = crate::WalletSession::OwnerOperation { wallet_id, path, pubkey, view_enabled };
+        ksp_logging_lib::debug!(target: crate::TRACING_TARGET, domain = crate::TRACING_DOMAIN_WALLET_SESSION, wallet_id = context.wallet_id.as_str(), operation, "Wallet OWNER metadata operation started");
+        return std::result::Result::Ok(context);
+    }
+
+    async fn finish_owner_metadata_operation(
+        &self,
+        context: OwnerMetadataContext,
+        operation_result: ksp_core_lib::Result<()>,
+    ) -> ksp_core_lib::Result<crate::WalletAuthorizedDto> {
+        if let std::result::Result::Err(error) = operation_result {
+            if error.code() == ksp_wallet_lib::ERROR_CODE_STATE_CONFLICT {
+                self.recover_owner_metadata_state_conflict(context).await;
+                return std::result::Result::Err(error);
+            }
+            self.restore_owner_after_metadata_failure(context);
+            return std::result::Result::Err(error);
+        }
+        return self.install_owner_after_metadata_success(context);
+    }
+
+    fn install_owner_after_metadata_success(&self, context: OwnerMetadataContext) -> ksp_core_lib::Result<crate::WalletAuthorizedDto> {
+        let OwnerMetadataContext { operation, owner, path, pubkey, view_enabled, wallet_id } = context;
+        let configured_secret_candidate_count = self.secret_candidate_count_or_zero(wallet_id.as_str());
+        let dto = crate::owner_projection(wallet_id.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()),
+        };
+        let previous = std::mem::replace(&mut *session, crate::WalletSession::no_selection());
+        match previous {
+            crate::WalletSession::OwnerOperation {
+                wallet_id: reserved_wallet_id,
+                path: reserved_path,
+                pubkey: reserved_pubkey,
+                view_enabled: reserved_view_enabled,
+            } if reserved_wallet_id == wallet_id && reserved_path == path && reserved_pubkey == pubkey && reserved_view_enabled == view_enabled => {
+                *session = crate::WalletSession::Owner { wallet_id: wallet_id.clone(), path, view_enabled, wallet: owner };
+                ksp_logging_lib::info!(target: crate::TRACING_TARGET, domain = crate::TRACING_DOMAIN_WALLET_SESSION, wallet_id = wallet_id.as_str(), operation, "Wallet OWNER metadata operation completed");
+                return std::result::Result::Ok(dto);
+            },
+            other => {
+                *session = other;
+                drop(owner);
+                return std::result::Result::Err(ksp_core_lib::Error::new(
+                    crate::ERROR_CODE_WALLET_SESSION_INVALID,
+                    "Wallet metadata completion no longer owns the selected OWNER session",
+                ));
+            },
+        }
+    }
+
+    fn restore_owner_after_metadata_failure(&self, context: OwnerMetadataContext) {
+        let OwnerMetadataContext { operation, owner, path, pubkey, view_enabled, wallet_id } = context;
+        let session = self.wallet_session.lock();
+        let mut session = match session {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(_) => return,
+        };
+        let previous = std::mem::replace(&mut *session, crate::WalletSession::no_selection());
+        match previous {
+            crate::WalletSession::OwnerOperation {
+                wallet_id: reserved_wallet_id,
+                path: reserved_path,
+                pubkey: reserved_pubkey,
+                view_enabled: reserved_view_enabled,
+            } if reserved_wallet_id == wallet_id && reserved_path == path && reserved_pubkey == pubkey && reserved_view_enabled == view_enabled => {
+                *session = crate::WalletSession::Owner { wallet_id: wallet_id.clone(), path, view_enabled, wallet: owner };
+                ksp_logging_lib::debug!(target: crate::TRACING_TARGET, domain = crate::TRACING_DOMAIN_WALLET_SESSION, wallet_id = wallet_id.as_str(), operation, "Wallet OWNER metadata operation failed without invalidating the authenticated handle");
+            },
+            other => {
+                *session = other;
+                drop(owner);
+            },
+        }
+    }
+
+    async fn recover_owner_metadata_state_conflict(&self, context: OwnerMetadataContext) {
+        let OwnerMetadataContext { operation, owner, path, pubkey, view_enabled, wallet_id } = context;
+        drop(owner);
+        let inspected = ksp_wallet_lib::inspect_locked_wallet_file_v1(path.as_path()).await;
+        let session = self.wallet_session.lock();
+        let mut session = match session {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(_) => return,
+        };
+        let previous = std::mem::replace(&mut *session, crate::WalletSession::no_selection());
+        match previous {
+            crate::WalletSession::OwnerOperation {
+                wallet_id: reserved_wallet_id,
+                path: reserved_path,
+                pubkey: reserved_pubkey,
+                view_enabled: reserved_view_enabled,
+            } if reserved_wallet_id == wallet_id && reserved_path == path && reserved_pubkey == pubkey && reserved_view_enabled == view_enabled => {
+                if let std::result::Result::Ok(locked_info) = inspected {
+                    *session = crate::WalletSession::Locked { wallet_id: wallet_id.clone(), path, locked_info };
+                }
+                ksp_logging_lib::warn!(target: crate::TRACING_TARGET, domain = crate::TRACING_DOMAIN_WALLET_SESSION, wallet_id = wallet_id.as_str(), operation, "Wallet OWNER metadata state conflict purged the stale handle and forced reauthorization");
+            },
+            other => *session = other,
+        }
+    }
+
     /// Refreshes the native SOL balance for the currently authorized VIEW/OWNER Wallet.
     pub(crate) async fn refresh_wallet_balance(&self) -> ksp_core_lib::Result<crate::WalletBalanceDto> {
         let context = self.authorized_balance_context();
@@ -702,10 +886,12 @@ impl AppState {
             crate::WalletSession::Owner { wallet_id, wallet, .. } => {
                 std::result::Result::Ok(WalletBalanceContext { capability: "owner", pubkey: wallet.pubkey().to_owned(), wallet_id: wallet_id.clone() })
             },
-            crate::WalletSession::PrivilegedOperation { .. } => std::result::Result::Err(ksp_core_lib::Error::new(
-                crate::ERROR_CODE_WALLET_SESSION_INVALID,
-                "Wallet balance is unavailable while a privileged Wallet operation is running",
-            )),
+            crate::WalletSession::OwnerOperation { .. } | crate::WalletSession::PrivilegedOperation { .. } => {
+                std::result::Result::Err(ksp_core_lib::Error::new(
+                    crate::ERROR_CODE_WALLET_SESSION_INVALID,
+                    "Wallet balance is unavailable while a privileged Wallet operation is running",
+                ))
+            },
             crate::WalletSession::Locked { .. } | crate::WalletSession::NoSelection => std::result::Result::Err(ksp_core_lib::Error::new(
                 crate::ERROR_CODE_WALLET_AUTHORIZATION_REQUIRED,
                 "Wallet balance requires an authorized VIEW or OWNER session",
@@ -726,7 +912,10 @@ impl AppState {
             crate::WalletSession::Owner { wallet_id, wallet, .. } => {
                 context.capability == "owner" && wallet_id == &context.wallet_id && wallet.pubkey() == &context.pubkey
             },
-            crate::WalletSession::NoSelection | crate::WalletSession::Locked { .. } | crate::WalletSession::PrivilegedOperation { .. } => false,
+            crate::WalletSession::NoSelection
+            | crate::WalletSession::Locked { .. }
+            | crate::WalletSession::OwnerOperation { .. }
+            | crate::WalletSession::PrivilegedOperation { .. } => false,
         };
     }
 
@@ -772,6 +961,15 @@ fn configured_secret_missing_error() -> ksp_core_lib::Error {
     return ksp_core_lib::Error::new(crate::ERROR_CODE_WALLET_SECRET_CANDIDATES_MISSING, "No effective Config-owned Wallet password candidate is available");
 }
 
+struct OwnerMetadataContext {
+    operation: &'static str,
+    owner: std::boxed::Box<ksp_wallet_lib::WalletOwner>,
+    path: std::path::PathBuf,
+    pubkey: ksp_core_lib::Pubkey,
+    view_enabled: bool,
+    wallet_id: String,
+}
+
 struct WalletBalanceContext {
     capability: &'static str,
     pubkey: ksp_core_lib::Pubkey,

crates/ksp-app-wallet-desk/src/lib.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-app-wallet-desk/src/lib.rs
-// version: 8
+// version: 9
 
 //! Tauri desktop application shell for KSP Wallet management and inspection.
 
@@ -23,6 +23,7 @@ mod wallet_balance;
 mod wallet_config;
 mod wallet_import;
 mod wallet_inventory;
+mod wallet_metadata;
 mod wallet_secrets;
 mod wallet_session;
 
@@ -186,6 +187,14 @@ pub(crate) use self::wallet_inventory::resolve_locked_wallet;
 /// Re-inspects one root-scoped Wallet selection in crate unit tests.
 #[cfg(test)]
 pub(crate) use self::wallet_inventory::select_locked_wallet;
+/// OWNER alias update request carrying protected metadata only frontend -> Rust.
+pub(crate) use self::wallet_metadata::WalletAliasUpdateRequestDto;
+/// OWNER note append request carrying protected metadata only frontend -> Rust.
+pub(crate) use self::wallet_metadata::WalletNoteAddRequestDto;
+/// OWNER note delete request selecting one authorized stable note identifier.
+pub(crate) use self::wallet_metadata::WalletNoteDeleteRequestDto;
+/// OWNER note update request carrying protected metadata only frontend -> Rust.
+pub(crate) use self::wallet_metadata::WalletNoteUpdateRequestDto;
 /// Discovers Config-owned Wallet password candidates without exposing their names or values.
 pub(crate) use self::wallet_secrets::discover_wallet_secret_candidates;
 /// Returns the configured Wallet password candidate count without exposing their names or values.

crates/ksp-app-wallet-desk/src/tauri.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-app-wallet-desk/src/tauri.rs
-// version: 6
+// version: 7
 
 //! Tauri runtime assembly for the KSP wallet desktop application.
 
@@ -40,8 +40,10 @@ fn configure_plugins(builder: tauri::Builder<tauri::Wry>) -> tauri::Builder<taur
 #[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![
+        add_wallet_note,
         clear_import_source,
         create_wallet,
+        delete_wallet_note,
         deselect_wallet,
         emit_frontend_log,
         get_runtime_status,
@@ -57,6 +59,8 @@ fn configure_commands(builder: tauri::Builder<tauri::Wry>) -> tauri::Builder<tau
         unlock_wallet_owner_manual,
         unlock_wallet_view_configured,
         unlock_wallet_view_manual,
+        update_wallet_alias,
+        update_wallet_note,
     ]);
 }
 
@@ -75,6 +79,18 @@ fn configure_setup(builder: tauri::Builder<tauri::Wry>) -> tauri::Builder<tauri:
     });
 }
 
+#[tauri::command]
+async fn add_wallet_note(
+    request: crate::WalletNoteAddRequestDto,
+    state: tauri::State<'_, crate::AppState>,
+) -> std::result::Result<crate::WalletAuthorizedDto, crate::CommandErrorDto> {
+    let result = state.add_wallet_note(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]
 fn clear_import_source(state: tauri::State<'_, crate::AppState>) -> std::result::Result<(), crate::CommandErrorDto> {
     let result = state.clear_import_source();
@@ -96,6 +112,18 @@ async fn create_wallet(
     };
 }
 
+#[tauri::command]
+async fn delete_wallet_note(
+    request: crate::WalletNoteDeleteRequestDto,
+    state: tauri::State<'_, crate::AppState>,
+) -> std::result::Result<crate::WalletAuthorizedDto, crate::CommandErrorDto> {
+    let result = state.delete_wallet_note(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]
 fn deselect_wallet(state: tauri::State<'_, crate::AppState>) -> std::result::Result<crate::WalletSessionDto, crate::CommandErrorDto> {
     let result = state.deselect_wallet();
@@ -286,3 +314,27 @@ async fn unlock_wallet_view_manual(
         std::result::Result::Err(error) => std::result::Result::Err(crate::CommandErrorDto::from_error(&error)),
     };
 }
+
+#[tauri::command]
+async fn update_wallet_alias(
+    request: crate::WalletAliasUpdateRequestDto,
+    state: tauri::State<'_, crate::AppState>,
+) -> std::result::Result<crate::WalletAuthorizedDto, crate::CommandErrorDto> {
+    let result = state.update_wallet_alias(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 update_wallet_note(
+    request: crate::WalletNoteUpdateRequestDto,
+    state: tauri::State<'_, crate::AppState>,
+) -> std::result::Result<crate::WalletAuthorizedDto, crate::CommandErrorDto> {
+    let result = state.update_wallet_note(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)),
+    };
+}

crates/ksp-app-wallet-desk/src/wallet_metadata.rs

@@ -0,0 +1,48 @@
+// file: crates/ksp-app-wallet-desk/src/wallet_metadata.rs
+// version: 1
+
+//! OWNER-only protected metadata administration contracts for Wallet Desk.
+
+use ts_rs::TS; // rust-rules: trait-import
+
+/// OWNER request that updates or clears the protected internal Wallet alias.
+#[derive(serde::Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "../frontend/ts/bindings/ksp_app_wallet_desk/wallet_metadata/WalletAliasUpdateRequestDto.ts")]
+pub(crate) struct WalletAliasUpdateRequestDto {
+    /// New protected alias, or `None` to clear it.
+    pub(crate) alias: std::option::Option<String>,
+}
+
+/// OWNER request that appends one protected Wallet note.
+#[derive(serde::Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "../frontend/ts/bindings/ksp_app_wallet_desk/wallet_metadata/WalletNoteAddRequestDto.ts")]
+pub(crate) struct WalletNoteAddRequestDto {
+    /// Protected note text transported only for the explicit mutation call.
+    pub(crate) text: String,
+}
+
+/// OWNER request that updates one protected Wallet note by stable identifier.
+#[derive(serde::Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "../frontend/ts/bindings/ksp_app_wallet_desk/wallet_metadata/WalletNoteUpdateRequestDto.ts")]
+pub(crate) struct WalletNoteUpdateRequestDto {
+    /// Stable note identifier returned by the authorized Wallet projection.
+    pub(crate) note_id: String,
+    /// Replacement protected note text transported only for the explicit mutation call.
+    pub(crate) text: String,
+}
+
+/// OWNER request that deletes one protected Wallet note by stable identifier.
+#[derive(serde::Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "../frontend/ts/bindings/ksp_app_wallet_desk/wallet_metadata/WalletNoteDeleteRequestDto.ts")]
+pub(crate) struct WalletNoteDeleteRequestDto {
+    /// Stable note identifier returned by the authorized Wallet projection.
+    pub(crate) note_id: String,
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/wallet_metadata.rs"]
+mod tests;

crates/ksp-app-wallet-desk/src/wallet_session.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-app-wallet-desk/src/wallet_session.rs
-// version: 3
+// version: 4
 
 //! Durable root-scoped Wallet session lifecycle for Wallet Desk.
 
@@ -149,6 +149,8 @@ pub(crate) enum WalletSession {
         path: std::path::PathBuf,
         /// Authorized VIEW handle retaining metadata capability only in Rust.
         wallet: std::boxed::Box<ksp_wallet_lib::WalletView>,
+        /// Whether the authenticated Wallet currently exposes a VIEW slot.
+        view_enabled: bool,
     },
     /// One Wallet kept open with OWNER capability.
     Owner {
@@ -158,6 +160,19 @@ pub(crate) enum WalletSession {
         path: std::path::PathBuf,
         /// Authorized OWNER handle retaining secret material only in Rust.
         wallet: std::boxed::Box<ksp_wallet_lib::WalletOwner>,
+        /// Whether the authenticated Wallet currently exposes a VIEW slot.
+        view_enabled: bool,
+    },
+    /// One OWNER metadata mutation temporarily owns the authorized handle outside the session mutex.
+    OwnerOperation {
+        /// Native Wallet filename / root-scoped identifier.
+        wallet_id: String,
+        /// Full root-scoped filesystem path retained only in Rust.
+        path: std::path::PathBuf,
+        /// Authorized Solana identity used only to reject stale completion.
+        pubkey: ksp_core_lib::Pubkey,
+        /// Whether the authenticated Wallet currently exposes a VIEW slot.
+        view_enabled: bool,
     },
 }
 
@@ -200,6 +215,11 @@ impl WalletSession {
                 state: WalletSessionStateDto::OwnerOpen,
                 wallet_id: std::option::Option::Some(wallet_id.clone()),
             },
+            Self::OwnerOperation { wallet_id, .. } => WalletSessionDto {
+                filename: std::option::Option::Some(wallet_id.clone()),
+                state: WalletSessionStateDto::PrivilegedOperation,
+                wallet_id: std::option::Option::Some(wallet_id.clone()),
+            },
         };
     }
 }

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.8.fix.1",
+    "version": "0.2.6-pre.9",
     "identifier": "com.sasedev.ksp-app-wallet-desk",
     "build": {
         "beforeDevCommand": "npm run dev",

crates/ksp-app-wallet-desk/tests/desktop_contract.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-app-wallet-desk/tests/desktop_contract.rs
-// version: 8
+// version: 9
 
 //! Desktop build, shell and Config-status contract audits for Wallet Desk.
 
@@ -223,3 +223,33 @@ fn pre_008_import_uses_rust_native_picker_and_wallet_transfer_adapters() {
     assert!(main.contains("WalletTransferInspectionDto"));
     assert!(main.contains("bindImportWalletForm"));
 }
+
+#[test]
+fn pre_009_owner_metadata_administration_uses_wallet_owner_and_refreshes_projection() {
+    let root = app_root();
+    let state = read_text(root.join("src/app_state.rs").as_path());
+    let metadata = read_text(root.join("src/wallet_metadata.rs").as_path());
+    let session = read_text(root.join("src/wallet_session.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!(state.contains("owner.update_alias"));
+    assert!(state.contains("owner.add_note"));
+    assert!(state.contains("owner.update_note"));
+    assert!(state.contains("owner.delete_note"));
+    assert!(state.contains("ERROR_CODE_STATE_CONFLICT"));
+    assert!(session.contains("OwnerOperation"));
+    assert!(metadata.contains("WalletAliasUpdateRequestDto"));
+    assert!(metadata.contains("WalletNoteAddRequestDto"));
+    assert!(metadata.contains("WalletNoteUpdateRequestDto"));
+    assert!(metadata.contains("WalletNoteDeleteRequestDto"));
+    assert!(tauri.contains("update_wallet_alias"));
+    assert!(tauri.contains("add_wallet_note"));
+    assert!(tauri.contains("update_wallet_note"));
+    assert!(tauri.contains("delete_wallet_note"));
+    assert!(html.contains("id=\"ownerWalletAlias\""));
+    assert!(html.contains("id=\"ownerNotesList\""));
+    assert!(html.contains("id=\"deleteWalletNoteModal\""));
+    assert!(main.contains("runOwnerMetadataMutation"));
+    assert!(main.contains("recoverOwnerMetadataStateConflict"));
+}

crates/ksp-app-wallet-desk/tests/desktop_security.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-app-wallet-desk/tests/desktop_security.rs
-// version: 8
+// version: 9
 
 //! Static desktop security contracts for the Wallet Desk pre.002 shell.
 
@@ -162,3 +162,24 @@ fn import_picker_path_and_transfer_secret_never_cross_into_frontend() {
     assert!(command.contains("WalletImportSourceRequestDto"));
     assert!(!command.contains("source_path"));
 }
+
+#[test]
+fn owner_metadata_values_are_request_only_and_state_conflict_forces_reauthorization() {
+    let root = app_root();
+    let metadata = read_text(root.join("src/wallet_metadata.rs").as_path());
+    let state = read_text(root.join("src/app_state.rs").as_path());
+    let main = read_text(root.join("frontend/ts/main.ts").as_path());
+    assert!(!metadata.contains("derive(Clone"));
+    assert!(!metadata.contains("derive(Debug"));
+    assert!(state.contains("recover_owner_metadata_state_conflict"));
+    assert!(state.contains("inspect_locked_wallet_file_v1"));
+    assert!(state.contains("ERROR_CODE_STATE_CONFLICT"));
+    assert!(main.contains("isWalletStateConflict"));
+    assert!(main.contains("select_wallet"));
+    assert!(main.contains("clearAuthorizedProjection"));
+    assert!(!main.contains("frontendDebug(\"main\", request.text"));
+    assert!(!main.contains("frontendTrace(\"main\", request.text"));
+    assert!(!main.contains("frontendDebug(\"main\", request.alias"));
+    assert!(!main.contains("window.confirm"));
+    assert!(main.contains("new Modal(modalElement)"));
+}

crates/ksp-app-wallet-desk/unit_tests/wallet_metadata.rs

@@ -0,0 +1,23 @@
+// file: crates/ksp-app-wallet-desk/unit_tests/wallet_metadata.rs
+// version: 1
+
+#[test]
+fn owner_metadata_requests_keep_protected_text_request_only() {
+    fn assert_deserializable<T>()
+    where
+        T: serde::de::DeserializeOwned,
+    {
+        return;
+    }
+    assert_deserializable::<crate::WalletAliasUpdateRequestDto>();
+    assert_deserializable::<crate::WalletNoteAddRequestDto>();
+    assert_deserializable::<crate::WalletNoteDeleteRequestDto>();
+    assert_deserializable::<crate::WalletNoteUpdateRequestDto>();
+}
+
+#[test]
+fn wallet_metadata_limits_are_owned_by_wallet_library() {
+    assert_eq!(ksp_wallet_lib::KSPWALLET_V1_MAX_ALIAS_BYTES, 256);
+    assert_eq!(ksp_wallet_lib::KSPWALLET_V1_MAX_NOTES, 64);
+    assert_eq!(ksp_wallet_lib::KSPWALLET_V1_MAX_NOTE_TEXT_BYTES, 8 * 1024);
+}