Refactor app services and stabilize refresh/UI flows

- Add refresh scheduler and network refresh service boundaries for typed
  refresh results, ordered RPC collectors, applicators, and price parsing.
- Add daemon lifecycle and wallet security workflow helpers while preserving
  App-owned command RPC, decrypt, cancellation, and UI handoff behavior.
- Split balance, console, mining, amount formatting, and async task logic into
  focused modules with expanded Phase 4 test coverage.
- Fix market price loading by triggering price refresh immediately, avoiding
  queue-pressure drops, tracking loading/error state, and adding translations.
- Polish send, explorer, peers, settings, theme/schema, and related tab UI.
- Replace checked-in generated language headers with build-generated resources.
- Document the cleanup audit, UI static-state guidance, and architecture updates.

src/daemon/daemon_controller.h

@@ -0,0 +1,225 @@
+#pragma once
+
+#include "embedded_daemon.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace dragonx {
+namespace config { class Settings; }
+namespace daemon {
+
+class DaemonController {
+public:
+    using State = EmbeddedDaemon::State;
+    using StateCallback = EmbeddedDaemon::StateCallback;
+
+    enum class ShutdownAction {
+        DisconnectOnly,
+        StopDaemon
+    };
+
+    struct ShutdownDecision {
+        ShutdownAction action = ShutdownAction::DisconnectOnly;
+        const char* logReason = "no embedded daemon";
+        const char* status = "Disconnecting...";
+    };
+
+    enum class LifecycleOperation {
+        ManualRestart,
+        Rescan,
+        DeleteBlockchainData,
+        BootstrapStop
+    };
+
+    struct LifecycleDecision {
+        LifecycleOperation operation = LifecycleOperation::ManualRestart;
+        bool allowed = false;
+        bool wasRunning = false;
+        const char* taskName = "";
+        const char* status = "";
+        const char* warning = "";
+        bool resetCrashCount = false;
+        bool setRescanOnNextStart = false;
+        bool disconnectRpc = false;
+        int restartDelayMs = 0;
+    };
+
+    class LifecycleTaskContext {
+    public:
+        virtual ~LifecycleTaskContext() = default;
+        virtual bool cancelled() const = 0;
+        virtual bool shuttingDown() const = 0;
+        virtual void sleepForMs(int milliseconds) = 0;
+    };
+
+    class LifecycleRuntime {
+    public:
+        virtual ~LifecycleRuntime() = default;
+        virtual void stopDaemonWithPolicy() = 0;
+        virtual bool startDaemon() = 0;
+        virtual int deleteBlockchainData() = 0;
+        virtual void resetOutputOffset() = 0;
+        virtual void requestRpcStopAndDisconnect(const char* context, const char* reason) = 0;
+    };
+
+    struct LifecycleExecutionResult {
+        bool completed = false;
+        bool cancelled = false;
+        bool stopped = false;
+        bool started = false;
+        int deletedItems = 0;
+    };
+
+    DaemonController();
+    ~DaemonController();
+
+    DaemonController(const DaemonController&) = delete;
+    DaemonController& operator=(const DaemonController&) = delete;
+
+    EmbeddedDaemon* daemon() { return daemon_.get(); }
+    const EmbeddedDaemon* daemon() const { return daemon_.get(); }
+
+    void setStateCallback(StateCallback callback);
+    void syncSettings(const config::Settings* settings);
+
+    bool start(const config::Settings* settings);
+    void stop(int waitMs);
+
+    bool isRunning() const;
+    bool externalDaemonDetected() const;
+    State state() const;
+    const std::string& lastError() const;
+    int crashCount() const;
+    int lastBlockHeight() const;
+    double memoryUsageMB() const;
+    std::vector<std::string> recentLines(std::size_t count) const;
+    std::string outputSince(std::size_t& offset) const;
+
+    void resetCrashCount();
+    void setRescanOnNextStart(bool enabled);
+    bool rescanOnNextStart() const;
+
+    static ShutdownDecision evaluateShutdownPolicy(bool hasDaemon,
+                                                   bool externalDaemonDetected,
+                                                   bool keepDaemonRunning,
+                                                   bool stopExternalDaemon) {
+        if (!hasDaemon) {
+            return {};
+        }
+        if (keepDaemonRunning) {
+            return {ShutdownAction::DisconnectOnly,
+                    "keep_daemon_running enabled",
+                    "Disconnecting (daemon stays running)..."};
+        }
+        if (externalDaemonDetected && !stopExternalDaemon) {
+            return {ShutdownAction::DisconnectOnly,
+                    "external daemon (not ours to stop)",
+                    "Disconnecting (daemon stays running)..."};
+        }
+        return {ShutdownAction::StopDaemon,
+                "stopping managed daemon",
+                "Sending stop command to daemon..."};
+    }
+    static LifecycleDecision evaluateLifecycleOperation(LifecycleOperation operation,
+                                                        bool usingEmbeddedDaemon,
+                                                        bool hasDaemon,
+                                                        bool daemonRunning,
+                                                        bool restartInProgress = false) {
+        switch (operation) {
+            case LifecycleOperation::ManualRestart:
+                if (!usingEmbeddedDaemon || restartInProgress) return {};
+                return {operation, true, daemonRunning, "daemon-restart", "Restarting daemon...", "",
+                        true, false, true, 500};
+            case LifecycleOperation::Rescan:
+                if (!usingEmbeddedDaemon || !hasDaemon) {
+                    return {operation, false, daemonRunning, "", "",
+                            "Rescan requires embedded daemon. Restart your daemon with -rescan manually."};
+                }
+                return {operation, true, daemonRunning, "rescan-blockchain", "Starting rescan...", "",
+                        false, true, false, 3000};
+            case LifecycleOperation::DeleteBlockchainData:
+                if (!usingEmbeddedDaemon || !hasDaemon) {
+                    return {operation, false, daemonRunning, "", "",
+                            "Delete blockchain requires embedded daemon. Stop your daemon manually and delete the data directory."};
+                }
+                return {operation, true, daemonRunning, "delete-blockchain-data", "Deleting blockchain data...", "",
+                        false, false, false, 3000};
+            case LifecycleOperation::BootstrapStop:
+                return {operation, true, daemonRunning, "bootstrap-stop-daemon", "Stopping daemon for bootstrap...", "",
+                        false, false, true, 0};
+        }
+        return {};
+    }
+    void prepareLifecycleOperation(const LifecycleDecision& decision,
+                                   const config::Settings* settings = nullptr);
+    static inline LifecycleExecutionResult executeLifecycleOperation(const LifecycleDecision& decision,
+                                                                    LifecycleRuntime& runtime,
+                                                                    LifecycleTaskContext& task)
+    {
+        LifecycleExecutionResult result;
+        if (!decision.allowed) return result;
+
+        auto waitForDelay = [&]() {
+            int waitTicks = std::max(0, decision.restartDelayMs / 100);
+            for (int i = 0; i < waitTicks && !task.cancelled() && !task.shuttingDown(); ++i) {
+                task.sleepForMs(100);
+            }
+        };
+
+        auto cancelled = [&]() {
+            result.cancelled = task.cancelled() || task.shuttingDown();
+            return result.cancelled;
+        };
+
+        switch (decision.operation) {
+            case LifecycleOperation::BootstrapStop:
+                if (decision.wasRunning) {
+                    runtime.requestRpcStopAndDisconnect("Bootstrap daemon stop", "Bootstrap");
+                    result.stopped = true;
+                }
+                result.completed = true;
+                return result;
+            case LifecycleOperation::ManualRestart:
+                if (decision.wasRunning) {
+                    runtime.stopDaemonWithPolicy();
+                    result.stopped = true;
+                }
+                break;
+            case LifecycleOperation::Rescan:
+            case LifecycleOperation::DeleteBlockchainData:
+                runtime.stopDaemonWithPolicy();
+                result.stopped = true;
+                break;
+        }
+
+        if (cancelled()) return result;
+        waitForDelay();
+        if (cancelled()) return result;
+
+        if (decision.operation == LifecycleOperation::DeleteBlockchainData) {
+            result.deletedItems = runtime.deleteBlockchainData();
+            if (cancelled()) return result;
+        }
+
+        if (decision.operation == LifecycleOperation::Rescan ||
+            decision.operation == LifecycleOperation::DeleteBlockchainData) {
+            runtime.resetOutputOffset();
+        }
+
+        result.started = runtime.startDaemon();
+        result.completed = !cancelled();
+        return result;
+    }
+    ShutdownDecision shutdownDecision(bool keepDaemonRunning,
+                                      bool stopExternalDaemon) const;
+
+private:
+    std::unique_ptr<EmbeddedDaemon> daemon_;
+};
+
+} // namespace daemon
+} // namespace dragonx