feat(chat): persistent, seed-encrypted message store (Phase 2)

Swap the in-memory-only chat store for durable sqlite persistence with real
per-transaction timestamps, encrypted at rest under a key derived from the
wallet's own seed (no passphrase, works on encrypted and unencrypted wallets).

- ChatDatabase (src/chat/chat_database.{h,cpp}): sqlite store mirroring
  data::TransactionHistoryCache. unlockWithSecret(seed) derives a 32-byte AEAD
  storage key and a wallet-partition tag via domain-separated keyed BLAKE2b
  (generichash) contexts. Every record — bodies, peer z-addrs, threading,
  timestamps — is crypto_aead_xchacha20poly1305_ietf-encrypted with a random
  nonce and the wallet tag as associated data; even the dedup key is a keyed
  hash of txid+position, so nothing about your conversations is in cleartext on
  disk. Rows are partitioned per-wallet; a different seed sees nothing. Messages
  are decrypted once at ingest then re-encrypted under the storage key, so
  load() needs only the storage key, not the chat identity.
- ChatService: ingest() now stamps each message with its own transaction time
  (txid->time map + fallback) and writes new (store-deduped) messages through to
  the database; loadFromDatabase() rehydrates the in-memory read model on unlock.
- App: unlock the chat DB with the same seed in provisionChatIdentityFromSecret
  and load prior history; lock the DB + clear the decrypted in-memory store on
  relock and on lite-controller rebuild.

Adversarial review (4 confirmed findings, all fixed): don't provision if the
wallet locks mid-fetch (re-check isLocked at completion); wipe the serialized
plaintext temporary in append(); trim the seed into a separate fully-wiped
buffer (no residue past a shrunk size()); scrub the mnemonic copy in the RPC
json result.

Tests: ChatDatabase round-trip (persist/reload, field + order fidelity), dedup,
per-wallet isolation, lock inertness, and ChatService write-through + reload
without an identity. Gated by DRAGONX_ENABLE_CHAT (default OFF). Verified:
Linux + Windows(mingw) build with chat ON, ctest 100%, hygiene clean; caches
restored to the OFF default.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

src/chat/chat_service.h

@@ -10,10 +10,14 @@
 #include "chat_store.h"
 
 #include <cstdint>
+#include <string>
+#include <unordered_map>
 #include <vector>
 
 namespace dragonx::chat {
 
+class ChatDatabase;  // optional persistent backing (Phase 2); set via setPersistence
+
 class ChatService {
 public:
     ChatService() = default;
@@ -30,10 +34,21 @@ public:
     void clearIdentity();  // wipes the held secret key
 
     // Decrypt/record each metadata entry (a Message is decrypted; a ContactRequest carries its
-    // plaintext through) and thread it into the store. `txTimestamp` is stamped onto every
-    // message in this batch. Returns the number of NEW messages added. Returns 0 with no
-    // identity. Undecryptable Messages are dropped silently (no logging of memo/plaintext).
-    int ingest(const std::vector<HushChatTransactionMetadata>& metadata, std::int64_t txTimestamp = 0);
+    // plaintext through) and thread it into the store. Each message is stamped with its own
+    // transaction time via `txTimestamps` (keyed by txid), falling back to `fallbackTimestamp`
+    // when the txid isn't present. Newly-added messages are also persisted (if a database is
+    // attached). Returns the number of NEW messages added; 0 with no identity. Undecryptable
+    // Messages are dropped silently (no logging of memo/plaintext).
+    int ingest(const std::vector<HushChatTransactionMetadata>& metadata,
+               const std::unordered_map<std::string, std::int64_t>& txTimestamps,
+               std::int64_t fallbackTimestamp = 0);
+
+    // Attach a persistent backing store (Phase 2). Not owned. Pass nullptr to detach. New messages
+    // from ingest() are written through; loadFromDatabase() rehydrates the in-memory store from it.
+    void setPersistence(ChatDatabase* db) { db_ = db; }
+    // Load previously-persisted messages (already decrypted at ingest, re-encrypted at rest under
+    // the seed-derived key) into the in-memory store. No-op without an unlocked database.
+    void loadFromDatabase();
 
     const ChatStore& store() const { return store_; }
     ChatStore& store() { return store_; }
@@ -42,6 +57,7 @@ private:
     ChatKeyPair identity_{};
     bool has_identity_ = false;
     ChatStore store_;
+    ChatDatabase* db_ = nullptr;  // optional; not owned
 };
 
 } // namespace dragonx::chat