diff --git a/CHANGELOG.md b/CHANGELOG.md
index c3e1f5d..5aafa85 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -50,6 +50,9 @@ The first stable open-source release.
 - The data-sync config loads without a `consumer_config.ini`.
 - Cache files with two-word categories are filed under the right ticker.
 - `/api/bands_replay` reads the analysis cache instead of a fixed developer folder.
+- Every module resolves the per-user folder the same way, so Pulse Room finds the cone and band
+  files the sync client and the local engine write (it looked in another folder outside the desktop
+  app). Files from the old locations are copied in once, never moved or overwritten.
 - Pydantic v2 deprecation warnings are gone.
 
 ## [0.1.0-alpha] — 2026-05-21
diff --git a/backend/account_manager.py b/backend/account_manager.py
index 36eae25..edbcf87 100644
--- a/backend/account_manager.py
+++ b/backend/account_manager.py
@@ -33,13 +33,18 @@
 
 import json
 import logging
-import os
 from dataclasses import dataclass, field, asdict
 from typing import Dict, List, Optional
 from datetime import datetime, date, timedelta
 from pathlib import Path
 
-# version: v4 (broker-TZ-aware period-pnl bucketing)
+import app_paths
+
+# version: v5 (user-data dir from app_paths)
+# v5 — _get_user_data_dir() returns app_paths.app_data_dir(), shared with
+#      every other module. Off Windows that is ~/.<APP_DIR>/ (exact case)
+#      rather than ~/.<app_dir lowercased>/; app_paths copies existing
+#      account_settings.json / account_state.json over once.
 # v4 — get_period_pnl now corrects for the broker TZ before bucketing
 #      deals into today/yesterday/this_week/etc. The MetaTrader5 library
 #      returns deal.time as broker server time treated as a Unix epoch
@@ -55,23 +60,13 @@
 
 PROJECT_ROOT = Path(__file__).resolve().parent
 
-# v3: AppData dir name from env var so v1 / v2 builds get separate dirs.
-APP_DIR = os.environ.get("MK_APP_DIR_NAME", "QuantumTerminal")
-
 
 def _get_user_data_dir() -> Path:
     """Per-user writable dir for account_settings.json + account_state.json.
     Fixes Errno 13 Permission denied under Program Files on installed consumer.
-    v3: AppData dir name comes from MK_APP_DIR_NAME (default "QuantumTerminal")."""
-    import platform as _platform
-    if _platform.system() == "Windows":
-        appdata = os.environ.get("APPDATA", "")
-        base = Path(appdata) / APP_DIR if appdata else \
-               Path.home() / "AppData" / "Roaming" / APP_DIR
-    else:
-        base = Path.home() / f".{APP_DIR.lower()}"
-    base.mkdir(parents=True, exist_ok=True)
-    return base
+    v3: AppData dir name comes from MK_APP_DIR_NAME (default "QuantumTerminal").
+    v5: resolved by app_paths.app_data_dir()."""
+    return app_paths.app_data_dir()
 
 
 def _resolve_default_settings_path() -> Path:
diff --git a/backend/app_paths.py b/backend/app_paths.py
new file mode 100644
index 0000000..3d1c4ee
--- /dev/null
+++ b/backend/app_paths.py
@@ -0,0 +1,151 @@
+"""
+================================================================================
+Quantum Terminal — per-user app-data and cache directories
+================================================================================
+Single source of truth for where the backend keeps per-user files. Every module
+that reads or writes them (sync client, cone/regime/stress-lab routes, Pulse
+Room, config, account state, logs, cache watcher) resolves its folder here, so
+they can never disagree about which directory holds the analysis files.
+
+    Windows:      %APPDATA%\\<name>\\     (APPDATA unset: ~\\AppData\\Roaming\\<name>\\)
+    Linux/macOS:  ~/.<name>/
+    cache:        <app-data dir>/cache/
+
+<name> is MK_APP_DIR_NAME when set, else "QuantumTerminal". The Electron shell
+passes MK_APP_DIR_NAME=QuantumTerminal-v2, so the desktop app keeps using the
+%APPDATA%\\QuantumTerminal-v2\\ data it already has, apart from browser-mode
+(`python launcher.py`) installs, which keep %APPDATA%\\QuantumTerminal\\.
+
+Paths are resolved on every call, not at import, so the process environment
+(or a test's monkeypatched one) always wins.
+
+Legacy locations: earlier builds kept a few files elsewhere. Pulse Room
+defaulted to "QuantumTerminal-v2" (under ~/.config off Windows), and off
+Windows the account files (including the simulator's paper account),
+consumer_config.ini and user_config.json each had their own folder. The first time a process resolves the app-data dir, any of
+those files missing from it are copied in — never moved, never overwritten —
+and a marker file stops the copy from running again.
+================================================================================
+"""
+
+import logging
+import os
+import shutil
+import sys
+import threading
+from datetime import datetime, timezone
+from pathlib import Path
+
+log = logging.getLogger("qt.app_paths")
+
+DEFAULT_APP_DIR_NAME = "QuantumTerminal"
+
+# Pulse Room's own default before it resolved through this module.
+_OLD_PULSE_DIR_NAME = "QuantumTerminal-v2"
+_PULSE_STATE_FILES = ("pulse_watchlist.json", "pulse_state.json")
+_MIGRATION_MARKER = ".migrated_legacy_paths"
+
+_migration_lock = threading.Lock()
+_migrated_targets: set = set()
+
+
+def _is_windows() -> bool:
+    return sys.platform == "win32"
+
+
+def app_dir_name() -> str:
+    """MK_APP_DIR_NAME if set and not blank, else "QuantumTerminal"."""
+    return os.environ.get("MK_APP_DIR_NAME", "").strip() or DEFAULT_APP_DIR_NAME
+
+
+def app_data_dir_for(name: str) -> Path:
+    """Where the app-data dir called `name` lives on this platform. Creates
+    nothing — use app_data_dir() for this process's own directory."""
+    if _is_windows():
+        appdata = os.environ.get("APPDATA", "")
+        base = Path(appdata) if appdata else Path.home() / "AppData" / "Roaming"
+        return base / name
+    return Path.home() / f".{name}"
+
+
+def app_data_dir() -> Path:
+    """This process's per-user app-data dir, created if missing."""
+    name = app_dir_name()
+    target = app_data_dir_for(name)
+    target.mkdir(parents=True, exist_ok=True)
+    if target not in _migrated_targets:
+        _copy_legacy_files(target, name)
+    return target
+
+
+def cache_dir() -> Path:
+    """The cache dir every reader and writer shares: <app-data dir>/cache."""
+    d = app_data_dir() / "cache"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+# ── Legacy locations ─────────────────────────────────────────────────────────
+
+def _legacy_locations(name: str) -> list:
+    """(directory, filenames) pairs where earlier builds kept files that now
+    belong in app_data_dir_for(name)."""
+    # Pulse Room honoured MK_APP_DIR_NAME but had its own default name.
+    if os.environ.get("MK_APP_DIR_NAME", "").strip():
+        pulse_name = name
+    else:
+        pulse_name = _OLD_PULSE_DIR_NAME
+    if _is_windows():
+        # Every other module already used %APPDATA%\<name>.
+        return [(app_data_dir_for(pulse_name), _PULSE_STATE_FILES)]
+    home = Path.home()
+    return [
+        # pulse_room: ~/.config/<name>
+        (home / ".config" / pulse_name, _PULSE_STATE_FILES),
+        # account_manager, the simulator's paper account, and launcher's
+        # consumer_config.ini fallback
+        (home / f".{name.lower()}",
+         ("account_settings.json", "account_state.json", "sim_paper_account.json",
+          "consumer_config.ini")),
+        # config_manager used the Windows layout under $HOME
+        (home / "AppData" / "Roaming" / name, ("user_config.json",)),
+    ]
+
+
+def _copy_legacy_files(target: Path, name: str) -> None:
+    """Copy files missing from `target` in from their legacy locations. Never
+    moves or overwrites anything; failures are logged and retried next run."""
+    with _migration_lock:
+        if target in _migrated_targets:
+            return
+        _migrated_targets.add(target)
+
+        marker = target / _MIGRATION_MARKER
+        if marker.exists():
+            return
+        sources = [(d, files) for d, files in _legacy_locations(name)
+                   if d != target and d.is_dir()]
+        if not sources:
+            return
+
+        copied, failed = [], False
+        for src_dir, files in sources:
+            for fname in files:
+                src, dst = src_dir / fname, target / fname
+                try:
+                    if src.is_file() and not dst.exists():
+                        shutil.copy2(src, dst)
+                        copied.append(f"{src} -> {dst}")
+                        log.info(f"Copied legacy {src} -> {dst}")
+                except OSError as e:
+                    failed = True
+                    log.warning(f"Could not copy legacy {src} -> {dst}: {e}")
+        if failed:
+            return  # no marker, so the next start retries what's still missing
+
+        stamp = datetime.now(timezone.utc).isoformat(timespec="seconds")
+        try:
+            marker.write_text("\n".join([f"migrated {stamp}", *copied]) + "\n",
+                              encoding="utf-8")
+        except OSError as e:
+            log.warning(f"Could not write {marker}: {e}")
diff --git a/backend/cache_watcher.py b/backend/cache_watcher.py
index 845f364..b1d8d71 100644
--- a/backend/cache_watcher.py
+++ b/backend/cache_watcher.py
@@ -1,4 +1,4 @@
-# version: v3
+# version: v4
 """
 ================================================================================
 Quantum Terminal Consumer — Cache Directory Watcher
@@ -51,6 +51,10 @@
      correct in-memory slot. Same resolver used by _load_all_from_cache at
      startup, ensuring watcher and loader stay consistent.
 
+v4 — Watched dir and the consumer_config.ini fallback both come from
+     app_paths (shared with data_sync_client and Pulse Room), on every
+     platform rather than only when APPDATA is set.
+
 Rule C1 compliance: this module performs ZERO calculations — it only reads
 files already on disk and pushes WS events.
 ================================================================================
@@ -60,15 +64,13 @@
 import configparser
 import json
 import logging
-import os
-
-# v2: AppData dir name (env-var driven; default "QuantumTerminal" preserves v1 path).
-APP_DIR = os.environ.get("MK_APP_DIR_NAME", "QuantumTerminal")
 import re
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Awaitable, Callable, Optional
 
+import app_paths  # v4: per-user app-data + cache dirs, shared by every module
+
 log = logging.getLogger("qt.cache_watcher")
 
 DEFAULT_INTERVAL_SECONDS = 1.0
@@ -93,9 +95,7 @@ def _read_config() -> tuple[bool, float]:
     if getattr(_sys, "frozen", False):
         candidates.append(Path(_sys.executable).parent / "consumer_config.ini")
 
-    appdata = os.environ.get("APPDATA", "")
-    if appdata:
-        candidates.append(Path(appdata) / APP_DIR / "consumer_config.ini")
+    candidates.append(app_paths.app_data_dir() / "consumer_config.ini")
 
     enabled = True
     interval = DEFAULT_INTERVAL_SECONDS
@@ -123,15 +123,11 @@ def _read_config() -> tuple[bool, float]:
 
 
 def _get_cache_dir() -> Optional[Path]:
-    """Resolve %APPDATA%\\QuantumTerminal\\cache via the same helper data_sync_client uses."""
+    """Resolve the cache dir data_sync_client writes to (app_paths.cache_dir())."""
     try:
-        from data_sync_client import _get_cache_dir as _dsc_cache_dir
-        return _dsc_cache_dir()
+        return app_paths.cache_dir()
     except Exception:
-        appdata = os.environ.get("APPDATA", "")
-        if not appdata:
-            return None
-        return Path(appdata) / APP_DIR / "cache"
+        return None
 
 
 def create_cache_watcher_task(
diff --git a/backend/config_manager.py b/backend/config_manager.py
index 29f01df..589cdcb 100644
--- a/backend/config_manager.py
+++ b/backend/config_manager.py
@@ -1,4 +1,11 @@
-# version: v11
+# version: v12
+# v12 — AppData dir resolved by app_paths.app_data_dir(), shared by every
+#       module (2026-10-17). Off Windows, user_config.json moves from
+#       ~/AppData/Roaming/<APP_DIR>/ to ~/.<APP_DIR>/ (app_paths copies the
+#       old file over once), and _legacy_user_config_paths() now includes the
+#       live file on every platform — previously, off Windows, the v11
+#       migration found no sources and stripped the profiles unmigrated.
+#
 # v11 — User-owned saves move to %USERPROFILE%\Documents\Quantum Terminal\ as
 #       per-file stores (2026-05-13). Bug: a 4-key trimmed user_config.json
 #       was being written when _load_user_config silently fell back to {}
@@ -111,28 +118,23 @@
 from typing import Dict, List, Optional, Any
 from datetime import datetime, timezone
 
+import app_paths
+
 log = logging.getLogger("config_manager")
 
 # ── Project root (Rule 3) ──
 PROJECT_ROOT = Path(__file__).resolve().parent
 
-# v6: AppData dir — same env-var convention used by license_client.py so v1
-#     and v2 can run side by side without sharing user state. Default
-#     "QuantumTerminal" preserves v1 behavior.
-APP_DIR = os.environ.get("MK_APP_DIR_NAME", "QuantumTerminal")
-
 
+# v6: AppData dir — MK_APP_DIR_NAME lets v1 and v2 run side by side without
+#     sharing user state; default "QuantumTerminal" preserves v1 behavior.
+#     v12: resolved by app_paths, like every other module.
 def _appdata_user_config_path() -> Path:
-    """Resolve %APPDATA%\\<APP_DIR>\\user_config.json. Used as the canonical
-    storage path for user preferences + saved profiles. Survives reinstalls
-    of the app (NSIS overwrites the install dir but leaves AppData alone)."""
-    appdata = os.environ.get("APPDATA")
-    if appdata:
-        base = Path(appdata) / APP_DIR
-    else:
-        base = Path.home() / "AppData" / "Roaming" / APP_DIR
-    base.mkdir(parents=True, exist_ok=True)
-    return base / "user_config.json"
+    """Resolve <app-data dir>\\user_config.json (%APPDATA%\\<APP_DIR>\\ on
+    Windows; see app_paths). Used as the canonical storage path for user
+    preferences + saved profiles. Survives reinstalls of the app (NSIS
+    overwrites the install dir but leaves AppData alone)."""
+    return app_paths.app_data_dir() / "user_config.json"
 
 
 # ════════════════════════════════════════════════════════════════
@@ -332,18 +334,15 @@ def _migration_marker_path() -> Path:
 def _legacy_user_config_paths() -> List[Path]:
     """Return up to three paths to legacy user_config.json files, in
     priority order: live AppData v2 first, then any sibling dirs."""
-    appdata = os.environ.get("APPDATA")
-    paths: List[Path] = []
-    if appdata:
-        base = Path(appdata)
-        # Live v2 first (most authoritative).
-        paths.append(base / APP_DIR / "user_config.json")
-        # QuantumTerminal-X — orphaned attempt with a typo'd env var.
-        if APP_DIR != "QuantumTerminal-X":
-            paths.append(base / "QuantumTerminal-X" / "user_config.json")
-        # v1 — read-only fallback (Rule 8: never write).
-        if APP_DIR != "QuantumTerminal":
-            paths.append(base / "QuantumTerminal" / "user_config.json")
+    app_dir = app_paths.app_dir_name()
+    # Live v2 first (most authoritative).
+    paths: List[Path] = [_appdata_user_config_path()]
+    # QuantumTerminal-X — orphaned attempt with a typo'd env var.
+    if app_dir != "QuantumTerminal-X":
+        paths.append(app_paths.app_data_dir_for("QuantumTerminal-X") / "user_config.json")
+    # v1 — read-only fallback (Rule 8: never write).
+    if app_dir != "QuantumTerminal":
+        paths.append(app_paths.app_data_dir_for("QuantumTerminal") / "user_config.json")
     return [p for p in paths if p.exists()]
 
 
diff --git a/backend/data_sync_client.py b/backend/data_sync_client.py
index 68fe0bf..5245c02 100644
--- a/backend/data_sync_client.py
+++ b/backend/data_sync_client.py
@@ -1,4 +1,4 @@
-# version: v12
+# version: v13
 """
 ================================================================================
 Quantum Terminal Consumer — Data Sync Client
@@ -6,6 +6,11 @@
 Downloads pre-computed data from the Quantum Terminal VPS and caches it locally
 for offline resilience.
 
+v13 — Cache dir comes from app_paths.cache_dir(), the one resolver every
+      module now shares (Pulse Room, regime/cone routes, cache watcher...).
+      Off Windows it honours MK_APP_DIR_NAME (~/.<name>/cache) instead of
+      always using ~/.QuantumTerminal/cache; the default name is unchanged.
+
 v11 — Parallel sync via httpx + asyncio.gather. The manifest path now
       issues all per-file GETs concurrently (semaphore-bounded at 8) using
       a single httpx.AsyncClient. On a typical fresh install (~150 files),
@@ -109,7 +114,7 @@
      recompute components at different cadences without redownloading the
      whole bundle. Exposed to the frontend via /api/data/global/{key}.
 
-Storage:
+Storage (app_paths.cache_dir(); Windows default shown):
     %APPDATA%\\QuantumTerminal\\cache\\{TICKER}_cones.json
     %APPDATA%\\QuantumTerminal\\cache\\{TICKER}_bands.json
     %APPDATA%\\QuantumTerminal\\cache\\{TICKER}_options.json
@@ -128,19 +133,17 @@
 import asyncio  # v8: needed for asyncio.to_thread to keep async handlers from blocking
 import json
 import logging
-import os
 import time
 import configparser
 from pathlib import Path
-
-# AppData directory name.
-APP_DIR = os.environ.get("MK_APP_DIR_NAME", "QuantumTerminal")
 from datetime import datetime, timezone, timedelta
 from email.utils import formatdate
 from typing import Optional, Dict, List, Any, Tuple
 from dataclasses import dataclass, field, asdict
 from enum import Enum
 
+import app_paths  # v13: per-user app-data + cache dirs, shared by every module
+
 log = logging.getLogger("qt.data_sync")
 
 PROJECT_ROOT = Path(__file__).resolve().parent
@@ -223,7 +226,6 @@ class StalenessInfo:
 # ============================================================
 
 def _read_config() -> configparser.ConfigParser:
-    import platform as _plat
     # Values are literal: "%APPDATA%" is a Windows-style path, not configparser
     # interpolation (which rejected the built-in defaults when no ini exists).
     config = configparser.ConfigParser(interpolation=None)
@@ -237,11 +239,7 @@ def _read_config() -> configparser.ConfigParser:
     if getattr(_sys, 'frozen', False):
         search_paths.append(Path(_sys.executable).parent / "consumer_config.ini")
 
-    if _plat.system() == "Windows":
-        import os as _os
-        appdata = _os.environ.get("APPDATA", "")
-        if appdata:
-            search_paths.append(Path(appdata) / APP_DIR / "consumer_config.ini")
+    search_paths.append(app_paths.app_data_dir() / "consumer_config.ini")
 
     for p in _sys.path:
         candidate = Path(p) / "consumer_config.ini"
@@ -255,7 +253,7 @@ def _read_config() -> configparser.ConfigParser:
 
     config.read_dict({
         "data": {
-            "cache_dir": f"%APPDATA%\\{APP_DIR}\\cache",
+            "cache_dir": f"%APPDATA%\\{app_paths.app_dir_name()}\\cache",
             "stale_warning_hours": "48",
             "stale_error_hours": "72",
         },
@@ -275,18 +273,9 @@ def _get_stale_thresholds() -> Tuple[float, float]:
 # ============================================================
 
 def _get_cache_dir() -> Path:
-    import platform, os
-    if platform.system() == "Windows":
-        appdata = os.environ.get("APPDATA", "")
-        if appdata:
-            base = Path(appdata) / APP_DIR / "cache"
-        else:
-            base = Path.home() / "AppData" / "Roaming" / APP_DIR / "cache"
-    else:
-        base = Path.home() / ".QuantumTerminal" / "cache"
-
-    base.mkdir(parents=True, exist_ok=True)
-    return base
+    """v13: thin wrapper kept for the modules that import it — the location
+    itself is decided by app_paths.cache_dir()."""
+    return app_paths.cache_dir()
 
 
 def _cache_path(ticker: str, data_type: str) -> Path:
diff --git a/backend/debug_subprocess.py b/backend/debug_subprocess.py
index b03557a..e3dce79 100644
--- a/backend/debug_subprocess.py
+++ b/backend/debug_subprocess.py
@@ -10,7 +10,7 @@
     <logs dir>/subprocess_logs/<label>.log
 
 The logs dir is the same one logging_setup uses (%APPDATA%\\<APP_DIR>\\logs\\
-on Windows, ~/.<app_dir>/logs/ elsewhere).
+on Windows, ~/.<APP_DIR>/logs/ elsewhere — see app_paths).
 ================================================================================
 """
 
diff --git a/backend/launcher.py b/backend/launcher.py
index 8ec4b70..2428c0c 100644
--- a/backend/launcher.py
+++ b/backend/launcher.py
@@ -23,6 +23,8 @@
 import logging
 from pathlib import Path
 
+import app_paths
+
 log = logging.getLogger("qt.launcher")
 
 
@@ -59,8 +61,8 @@ def _resolve_frontend_dir(candidates) -> Path:
 
 PORT = int(os.environ.get("MK_PORT", "8502"))   # v2: Electron passes MK_PORT
 
-# v2: AppData dir name (env-var driven; default "QuantumTerminal" preserves v1 path).
-APP_DIR = os.environ.get("MK_APP_DIR_NAME", "QuantumTerminal")
+# AppData dir name: MK_APP_DIR_NAME or "QuantumTerminal" (see app_paths).
+APP_DIR = app_paths.app_dir_name()
 
 # — Default config content (f-string so APP_DIR is substituted at module load) —
 DEFAULT_CONFIG = f"""\
@@ -116,28 +118,14 @@ def ensure_config():
 
 
 def _get_appdata_base() -> Path:
-    """Get AppData\\Roaming\\<APP_DIR> path. APP_DIR comes from MK_APP_DIR_NAME env var."""
-    import platform
-    if platform.system() == "Windows":
-        appdata = os.environ.get("APPDATA", "")
-        if appdata:
-            return Path(appdata) / APP_DIR
-    return Path.home() / f".{APP_DIR.lower()}"
+    """Get the per-user app-data dir (%APPDATA%\\<APP_DIR> on Windows)."""
+    return app_paths.app_data_dir()
 
 
 def ensure_appdata():
     """Create AppData directories for auth cache and data cache."""
-    appdata = os.environ.get("APPDATA", "")
-    if appdata:
-        base = Path(appdata) / APP_DIR
-    else:
-        base = Path.home() / "AppData" / "Roaming" / APP_DIR
-
-    for subdir in ["", "cache"]:
-        d = base / subdir if subdir else base
-        d.mkdir(parents=True, exist_ok=True)
-
-    return base
+    app_paths.cache_dir()  # creates the app-data dir and its cache subdir
+    return app_paths.app_data_dir()
 
 
 def open_browser():
diff --git a/backend/logging_setup.py b/backend/logging_setup.py
index ea785a1..067526d 100644
--- a/backend/logging_setup.py
+++ b/backend/logging_setup.py
@@ -6,7 +6,8 @@
 survive across runs and can be attached to support tickets, while keeping the
 console output identical to v1.
 
-Log location: %APPDATA%\\<APP_DIR>\\logs\\backend-YYYY-MM-DD.log
+Log location: <app-data dir>\\logs\\backend.log — app_paths.app_data_dir(),
+              i.e. %APPDATA%\\<APP_DIR>\\ on Windows, ~/.<APP_DIR>/ elsewhere
 Rotation:     daily at midnight, 14 days retained.
 Format:       same as console — `YYYY-MM-DD HH:MM:SS [logger.name] LEVEL: msg`
 
@@ -17,12 +18,10 @@
 
 import logging
 import logging.handlers
-import os
 import sys
 from pathlib import Path
 
-# Match the APP_DIR convention used elsewhere (license_client / data_sync_client)
-APP_DIR = os.environ.get("MK_APP_DIR_NAME", "QuantumTerminal")
+import app_paths
 
 _LOG_FORMAT = "%(asctime)s [%(name)s] %(levelname)s: %(message)s"
 _DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
@@ -31,11 +30,8 @@
 
 
 def _appdata_logs_dir() -> Path:
-    """Resolve %APPDATA%\\<APP_DIR>\\logs\\ (or ~/.<app_dir>/logs/ off-Windows)."""
-    appdata = os.environ.get("APPDATA", "")
-    if appdata:
-        return Path(appdata) / APP_DIR / "logs"
-    return Path.home() / f".{APP_DIR.lower()}" / "logs"
+    """Resolve <app-data dir>/logs/ (see app_paths)."""
+    return app_paths.app_data_dir() / "logs"
 
 
 def setup_logging(level: int = logging.INFO) -> Path:
diff --git a/backend/periodic_sync.py b/backend/periodic_sync.py
index 1dad36d..20081e7 100644
--- a/backend/periodic_sync.py
+++ b/backend/periodic_sync.py
@@ -1,4 +1,6 @@
-# version: v2
+# version: v3
+# v3 — consumer_config.ini AppData fallback comes from app_paths (every
+#      platform, same dir as the rest of the backend).
 """
 ================================================================================
 Quantum Terminal Consumer — Periodic Data Sync Poller
@@ -23,15 +25,12 @@
 
 import asyncio
 import logging
-import os
-
-# v2: AppData dir name (env-var driven; default "QuantumTerminal" preserves v1 path).
-APP_DIR = os.environ.get("MK_APP_DIR_NAME", "QuantumTerminal")
 import configparser
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Awaitable, Callable
 
+import app_paths  # v3: per-user app-data dir, shared by every module
 from pulse_room.sync_hook import on_sync_complete as _pulse_on_sync_complete
 
 log = logging.getLogger("qt.periodic_sync")
@@ -58,9 +57,7 @@ def _read_interval() -> int:
     if getattr(_sys, "frozen", False):
         candidates.append(Path(_sys.executable).parent / "consumer_config.ini")
 
-    appdata = os.environ.get("APPDATA", "")
-    if appdata:
-        candidates.append(Path(appdata) / APP_DIR / "consumer_config.ini")
+    candidates.append(app_paths.app_data_dir() / "consumer_config.ini")
 
     for p in candidates:
         if not p.exists():
diff --git a/backend/providers/sim_provider.py b/backend/providers/sim_provider.py
index 7e0180c..2e46afe 100644
--- a/backend/providers/sim_provider.py
+++ b/backend/providers/sim_provider.py
@@ -59,6 +59,7 @@
 
 import numpy as np
 
+import app_paths
 from models import (
     TickData, BarData, AccountInfo, SymbolInfo, ClosedTrade,
     OrderRequest, OrderResult, Position, PendingOrder,
@@ -981,10 +982,7 @@ def _resolve_state_path(cfg: Dict[str, Any]) -> Optional[Path]:
             return None
         if cfg.get("state_file"):
             return Path(cfg["state_file"]).expanduser()
-        app_dir = os.environ.get("MK_APP_DIR_NAME", "QuantumTerminal")
-        appdata = os.environ.get("APPDATA", "")
-        base = Path(appdata) / app_dir if appdata else Path.home() / f".{app_dir.lower()}"
-        return base / "sim_paper_account.json"
+        return app_paths.app_data_dir() / "sim_paper_account.json"
 
     def _save_state(self) -> None:
         if self._state_path is None:
diff --git a/backend/pulse_room/builder.py b/backend/pulse_room/builder.py
index 3cac642..678dc3d 100644
--- a/backend/pulse_room/builder.py
+++ b/backend/pulse_room/builder.py
@@ -1,4 +1,10 @@
-# version: v4
+# version: v6
+# v6 — bands_path() prefers {TICKER}_bands.json, the name the data pipeline
+#      writes; GLOBAL_<ticker>_bands.json is only used when it is the one present.
+# v5 — cache dir comes from app_paths.cache_dir(), the folder the sync client
+#      and the regime/cone routes read. Previously defaulted to
+#      "QuantumTerminal-v2" (and ~/.config off Windows), so outside Electron
+#      on Windows it never found the cones/bands files.
 """Pulse snapshot builder.
 
 Reads cached cones/bands JSONs, extracts SD edges as forward curves,
@@ -8,11 +14,12 @@
 
 import json
 import logging
-import os
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Optional
 
+import app_paths
+
 from . import state
 
 
@@ -22,11 +29,7 @@
 # ---------- path resolvers ----------
 
 def _default_cache_dir() -> Path:
-    appdata = os.environ.get("APPDATA")
-    if not appdata:
-        appdata = str(Path.home() / ".config")
-    dir_name = os.environ.get("MK_APP_DIR_NAME", "QuantumTerminal-v2")
-    return Path(appdata) / dir_name / "cache"
+    return app_paths.cache_dir()
 
 
 def cones_path(ticker: str, cache_dir: Optional[Path] = None) -> Path:
@@ -35,8 +38,13 @@ def cones_path(ticker: str, cache_dir: Optional[Path] = None) -> Path:
 
 
 def bands_path(ticker: str, cache_dir: Optional[Path] = None) -> Path:
+    """{TICKER}_bands.json, the current name; the legacy
+    GLOBAL_<ticker>_bands.json only when that is the one present (the sync
+    client reads both)."""
     cd = cache_dir or _default_cache_dir()
-    return cd / f"GLOBAL_{ticker.lower()}_bands.json"
+    current = cd / f"{ticker.upper()}_bands.json"
+    legacy = cd / f"GLOBAL_{ticker.lower()}_bands.json"
+    return legacy if legacy.is_file() and not current.is_file() else current
 
 
 # ---------- safe JSON loader ----------
@@ -312,8 +320,8 @@ def build_snapshot(
 ) -> dict:
     """Build the snapshot dict; optionally persist to AppData.
 
-    Returns the snapshot dict regardless. If `write=True`, writes to
-    %APPDATA%/QuantumTerminal-v2/pulse_snapshot.json atomically.
+    Returns the snapshot dict regardless. If `write=True`, writes
+    pulse_snapshot.json to the app-data dir (app_paths) atomically.
 
     Missing or malformed source files for an asset cause that asset
     to be skipped (with a logged warning). Other assets still build.
diff --git a/backend/pulse_room/state.py b/backend/pulse_room/state.py
index 582b590..e91db56 100644
--- a/backend/pulse_room/state.py
+++ b/backend/pulse_room/state.py
@@ -1,4 +1,8 @@
-# version: v2
+# version: v3
+# v3 — AppData root comes from app_paths.app_data_dir() (default name
+#      "QuantumTerminal", like the rest of the backend, instead of
+#      "QuantumTerminal-v2"). Existing watchlist/scanner files are copied
+#      over from the old folder once by app_paths.
 """Pulse Room state persistence.
 
 Owns the two AppData JSON files:
@@ -17,6 +21,8 @@
 from pathlib import Path
 from typing import Any
 
+import app_paths
+
 
 # Process-wide lock guarding pulse snapshot rebuilds. Both the user-initiated
 # Calculate (routes.py) and the auto-rebuild after sync (sync_hook.py) acquire
@@ -26,17 +32,11 @@
 
 
 def _appdata_root() -> Path:
-    """Return %APPDATA%/QuantumTerminal-v2 (or whatever MK_APP_DIR_NAME points to).
-
-    This mirrors v2's existing AppData isolation pattern. We import
-    config_manager lazily to avoid a circular import at module load time.
+    """Return the backend's app-data dir (app_paths.app_data_dir()) —
+    %APPDATA%/<MK_APP_DIR_NAME or "QuantumTerminal"> on Windows — so Pulse
+    Room state sits beside the cache the snapshot is built from.
     """
-    appdata = os.environ.get("APPDATA")
-    if not appdata:
-        # Fallback for non-Windows dev setups.
-        appdata = str(Path.home() / ".config")
-    dir_name = os.environ.get("MK_APP_DIR_NAME", "QuantumTerminal-v2")
-    return Path(appdata) / dir_name
+    return app_paths.app_data_dir()
 
 
 def _pulse_dir() -> Path:
diff --git a/backend/regime_routes.py b/backend/regime_routes.py
index 67f66d1..a185e01 100644
--- a/backend/regime_routes.py
+++ b/backend/regime_routes.py
@@ -1,7 +1,10 @@
-# version: v2
+# version: v3
 """
 regime_routes.py — Consumer terminal HMM regime routes.
 
+v3 — Disk fallback reads app_paths.cache_dir(), the same folder the sync
+     client writes and Pulse Room builds from.
+
 v2 — Lit up from stub. Serves the DC HMM-regime cache files produced by the
      Data Center and synced into %APPDATA%\\QuantumTerminal\\cache\\:
 
@@ -42,8 +45,8 @@ def _read_disk(*candidates):
 
     def _cache_dir() -> _Path:
         try:
-            from data_sync_client import _get_cache_dir
-            return _get_cache_dir()
+            from app_paths import cache_dir
+            return cache_dir()
         except Exception:
             return None
 
diff --git a/backend/tests/conftest.py b/backend/tests/conftest.py
index 4f3a312..6eaf80b 100644
--- a/backend/tests/conftest.py
+++ b/backend/tests/conftest.py
@@ -4,12 +4,19 @@
 Several backend modules resolve AppData / home-directory paths at import
 time, so every user-data location is pointed at a throwaway sandbox *before*
 any of them is imported — tests never touch a real profile.
+
+Tests that need their own empty folders (path resolution, legacy-file copies)
+take the `user_dirs` fixture; `os_layout` also runs them once with the Windows
+layout and once with the Linux/macOS one.
 """
 
 import os
 import sys
 import tempfile
 from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
 
 _SANDBOX = Path(tempfile.mkdtemp(prefix="qt-tests-"))
 os.environ["HOME"] = str(_SANDBOX)
@@ -23,3 +30,38 @@
 BACKEND_DIR = Path(__file__).resolve().parents[1]
 if str(BACKEND_DIR) not in sys.path:
     sys.path.insert(0, str(BACKEND_DIR))
+
+
+@pytest.fixture
+def user_dirs(tmp_path, monkeypatch):
+    """Fresh, empty HOME / USERPROFILE / APPDATA for one test, and no
+    MK_APP_DIR_NAME."""
+    home = tmp_path / "home"
+    appdata = tmp_path / "appdata"
+    home.mkdir()
+    appdata.mkdir()
+    monkeypatch.setenv("HOME", str(home))          # Path.home() on Linux/macOS
+    monkeypatch.setenv("USERPROFILE", str(home))   # Path.home() on Windows
+    monkeypatch.setenv("APPDATA", str(appdata))
+    monkeypatch.delenv("MK_APP_DIR_NAME", raising=False)
+    # The sync client is a process-wide singleton that caches what it reads.
+    monkeypatch.setattr("data_sync_client._sync_client", None)
+    return SimpleNamespace(home=home, appdata=appdata)
+
+
+@pytest.fixture(params=["windows", "posix"])
+def os_layout(request, monkeypatch):
+    import app_paths
+    monkeypatch.setattr(app_paths, "_is_windows", lambda: request.param == "windows")
+    return request.param
+
+
+@pytest.fixture
+def expected_app_dir(user_dirs, os_layout):
+    """Where app_paths should put the app-data dir called `name` under the
+    layout being tested."""
+    def expected(name="QuantumTerminal"):
+        if os_layout == "windows":
+            return user_dirs.appdata / name
+        return user_dirs.home / f".{name}"
+    return expected
diff --git a/backend/tests/test_app_paths.py b/backend/tests/test_app_paths.py
new file mode 100644
index 0000000..e6d18c9
--- /dev/null
+++ b/backend/tests/test_app_paths.py
@@ -0,0 +1,134 @@
+"""app_paths: the one resolver for the per-user app-data and cache dirs."""
+import shutil
+
+import pytest
+
+import app_paths
+
+# Each test gets its own empty HOME / APPDATA (see conftest).
+pytestmark = pytest.mark.usefixtures("user_dirs")
+
+
+def write(path, text):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(text, encoding="utf-8")
+    return path
+
+
+# ── layout ──────────────────────────────────────────────────────────────────
+
+def test_default_name_and_layout(expected_app_dir):
+    assert app_paths.app_dir_name() == "QuantumTerminal"
+    assert app_paths.app_data_dir() == expected_app_dir()
+    assert app_paths.cache_dir() == expected_app_dir() / "cache"
+    assert app_paths.cache_dir().is_dir()
+
+
+@pytest.mark.parametrize("name", ["QuantumTerminal-v2", "MyLab"])
+def test_mk_app_dir_name_is_honoured_on_every_platform(monkeypatch, expected_app_dir, name):
+    monkeypatch.setenv("MK_APP_DIR_NAME", name)
+    assert app_paths.cache_dir() == expected_app_dir(name) / "cache"
+
+
+def test_blank_mk_app_dir_name_means_default(monkeypatch, expected_app_dir):
+    monkeypatch.setenv("MK_APP_DIR_NAME", "  ")
+    assert app_paths.app_data_dir() == expected_app_dir()
+
+
+def test_resolved_per_call_not_at_import(monkeypatch, expected_app_dir):
+    assert app_paths.cache_dir() == expected_app_dir() / "cache"
+    monkeypatch.setenv("MK_APP_DIR_NAME", "QuantumTerminal-v2")
+    assert app_paths.cache_dir() == expected_app_dir("QuantumTerminal-v2") / "cache"
+
+
+def test_appdata_is_ignored_off_windows(user_dirs, monkeypatch):
+    monkeypatch.setattr(app_paths, "_is_windows", lambda: False)
+    assert app_paths.app_data_dir() == user_dirs.home / ".QuantumTerminal"
+
+
+def test_windows_without_appdata_uses_roaming_under_profile(user_dirs, monkeypatch):
+    monkeypatch.setattr(app_paths, "_is_windows", lambda: True)
+    monkeypatch.delenv("APPDATA")
+    assert app_paths.app_data_dir() == user_dirs.home / "AppData" / "Roaming" / "QuantumTerminal"
+
+
+# ── legacy locations ────────────────────────────────────────────────────────
+
+def test_electron_dir_gets_nothing_new(user_dirs, monkeypatch):
+    # Electron passes MK_APP_DIR_NAME=QuantumTerminal-v2: its existing
+    # folder is already the target, so nothing is copied or added there.
+    monkeypatch.setattr(app_paths, "_is_windows", lambda: True)
+    monkeypatch.setenv("MK_APP_DIR_NAME", "QuantumTerminal-v2")
+    write(user_dirs.appdata / "QuantumTerminal-v2" / "pulse_watchlist.json", "{}")
+
+    target = app_paths.app_data_dir()
+
+    assert target == user_dirs.appdata / "QuantumTerminal-v2"
+    assert [p.name for p in target.iterdir()] == ["pulse_watchlist.json"]
+
+
+def test_pulse_state_is_copied_from_its_old_default_dir(user_dirs, monkeypatch):
+    # Without MK_APP_DIR_NAME, Pulse Room used %APPDATA%\QuantumTerminal-v2.
+    monkeypatch.setattr(app_paths, "_is_windows", lambda: True)
+    old = write(user_dirs.appdata / "QuantumTerminal-v2" / "pulse_watchlist.json",
+                '{"assets": [{"symbol": "XAUUSD", "families": ["CO"]}]}')
+
+    new = app_paths.app_data_dir() / "pulse_watchlist.json"
+
+    assert new == user_dirs.appdata / "QuantumTerminal" / "pulse_watchlist.json"
+    assert new.read_text(encoding="utf-8") == old.read_text(encoding="utf-8")
+    assert old.exists()  # copied, not moved
+
+
+def test_posix_files_are_copied_once_and_never_overwritten(user_dirs, monkeypatch):
+    monkeypatch.setattr(app_paths, "_is_windows", lambda: False)
+    home = user_dirs.home
+    target = home / ".QuantumTerminal"
+    write(home / ".config" / "QuantumTerminal-v2" / "pulse_state.json", '{"enabled": true}')
+    write(home / "AppData" / "Roaming" / "QuantumTerminal" / "user_config.json", '{"universe": {}}')
+    write(home / ".config" / "QuantumTerminal-v2" / "pulse_watchlist.json", "old")
+    write(target / "pulse_watchlist.json", "current")
+
+    assert app_paths.app_data_dir() == target
+    assert (target / "pulse_state.json").read_text(encoding="utf-8") == '{"enabled": true}'
+    assert (target / "user_config.json").read_text(encoding="utf-8") == '{"universe": {}}'
+    assert (target / "pulse_watchlist.json").read_text(encoding="utf-8") == "current"
+
+    # A later start must not resurrect a file the user has since deleted.
+    (target / "user_config.json").unlink()
+    monkeypatch.setattr(app_paths, "_migrated_targets", set())  # fresh process
+    app_paths.app_data_dir()
+    assert not (target / "user_config.json").exists()
+
+
+def test_posix_account_files_are_copied_from_lowercase_dir(user_dirs, monkeypatch):
+    monkeypatch.setattr(app_paths, "_is_windows", lambda: False)
+    old_dir = user_dirs.home / ".quantumterminal"
+    write(old_dir / "account_state.json", '{"peak_equity": 1}')
+    write(old_dir / "sim_paper_account.json", '{"balance": 100000}')
+    if (user_dirs.home / ".QuantumTerminal").exists():
+        pytest.skip("case-insensitive filesystem: both spellings are one folder")
+
+    new_dir = app_paths.app_data_dir()
+
+    for name in ("account_state.json", "sim_paper_account.json"):
+        assert (new_dir / name).read_text(encoding="utf-8") == \
+            (old_dir / name).read_text(encoding="utf-8")
+
+
+def test_failed_copy_is_retried_on_next_start(user_dirs, monkeypatch):
+    monkeypatch.setattr(app_paths, "_is_windows", lambda: True)
+    write(user_dirs.appdata / "QuantumTerminal-v2" / "pulse_state.json", '{"enabled": true}')
+    real_copy2 = shutil.copy2
+
+    def locked(src, dst):
+        raise PermissionError("file in use")
+
+    monkeypatch.setattr(shutil, "copy2", locked)
+    target = app_paths.app_data_dir()
+    assert not (target / "pulse_state.json").exists()
+
+    monkeypatch.setattr(shutil, "copy2", real_copy2)
+    monkeypatch.setattr(app_paths, "_migrated_targets", set())  # fresh process
+    app_paths.app_data_dir()
+    assert (target / "pulse_state.json").read_text(encoding="utf-8") == '{"enabled": true}'
diff --git a/backend/tests/test_shared_cache_dir.py b/backend/tests/test_shared_cache_dir.py
new file mode 100644
index 0000000..9f6087b
--- /dev/null
+++ b/backend/tests/test_shared_cache_dir.py
@@ -0,0 +1,128 @@
+"""
+Pulse Room and the regime routes must read analysis files from the folder the
+sync client writes — on Windows and Linux/macOS, with MK_APP_DIR_NAME unset
+(`python launcher.py`) and set (Electron passes QuantumTerminal-v2).
+"""
+from datetime import datetime, timedelta, timezone
+
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+import app_paths
+import data_sync_client
+from pulse_room import builder, state
+from regime_routes import create_regime_router
+
+# Each test gets its own empty HOME / APPDATA (see conftest).
+pytestmark = pytest.mark.usefixtures("user_dirs")
+
+
+@pytest.fixture(params=[None, "QuantumTerminal-v2"], ids=["launcher", "electron"])
+def launched_by(request, monkeypatch):
+    if request.param:
+        monkeypatch.setenv("MK_APP_DIR_NAME", request.param)
+    return request.param
+
+
+@pytest.fixture
+def regime_api():
+    app = FastAPI()
+    app.include_router(create_regime_router())
+    return TestClient(app)
+
+
+def _dates(hours):
+    now = datetime.now(timezone.utc).replace(second=0, microsecond=0)
+    return [(now + timedelta(hours=h)).strftime("%Y-%m-%d %H:%M") for h in hours]
+
+
+HOURS = [0, 12, 24, 36, 48]
+
+
+def _cones():
+    return {"gbm_curr": {
+        "dates": _dates(HOURS),
+        "median": [100.0] * len(HOURS),
+        "sd1_high": [100.0, 101.0, 102.0, 103.0, 104.0],
+        "sd1_low": [100.0, 99.0, 98.0, 97.0, 96.0],
+    }}
+
+
+def _bands():
+    bands = {"timestamps": _dates(HOURS), "mean": [100.0] * len(HOURS)}
+    for sd in (1, 2, 3):
+        bands[f"gbm_{sd}sd_high"] = [100.0 + sd] * len(HOURS)
+        bands[f"gbm_{sd}sd_low"] = [100.0 - sd] * len(HOURS)
+    return bands
+
+
+def test_pulse_builder_and_regime_routes_resolve_the_same_cache_dir(
+        os_layout, launched_by, expected_app_dir, regime_api):
+    # Lay the files down exactly where the sync client writes them.
+    sync_cache = data_sync_client._get_cache_dir()
+    data_sync_client._write_cache(data_sync_client._cache_path("XAUUSD", "cones"), _cones())
+    data_sync_client._write_cache(sync_cache / builder.bands_path("XAUUSD").name, _bands())
+    data_sync_client._write_cache(sync_cache / "GLOBAL_macro_regime.json", {"regime": "GOLDILOCKS"})
+    # GLOBAL_<lower> naming bypasses the sync client's memory store, so this
+    # exercises the route's own disk lookup.
+    data_sync_client._write_cache(sync_cache / "GLOBAL_xauusd_regime.json", {"slow": "bull"})
+
+    assert sync_cache == expected_app_dir(launched_by or "QuantumTerminal") / "cache"
+    assert builder._default_cache_dir() == sync_cache
+    assert regime_api.get("/api/regime/macro").json() == {"regime": "GOLDILOCKS"}
+    assert regime_api.get("/api/regime/XAUUSD").json() == {"slow": "bull"}
+
+    watchlist = {"assets": [{"symbol": "XAUUSD", "families": ["CO", "QB"]}]}
+    snapshot = builder.build_snapshot(watchlist, write=True)
+
+    families = {e["family"] for e in snapshot["assets"]["XAUUSD"]["elements"]}
+    assert families == {"CO", "QB"}
+    assert (sync_cache.parent / "pulse_snapshot.json").is_file()
+
+
+def test_every_module_resolves_the_same_app_data_dir(os_layout, launched_by):
+    import account_manager
+    import cache_watcher
+    import config_manager
+    import launcher
+    import logging_setup
+    from providers.sim_provider import SimProvider
+
+    app_dir = app_paths.app_data_dir()
+    cache = app_dir / "cache"
+
+    assert data_sync_client._get_cache_dir() == cache
+    assert cache_watcher._get_cache_dir() == cache
+    assert builder._default_cache_dir() == cache
+    assert state._pulse_dir() == app_dir
+    assert config_manager._appdata_user_config_path() == app_dir / "user_config.json"
+    assert account_manager._get_user_data_dir() == app_dir
+    assert logging_setup._appdata_logs_dir() == app_dir / "logs"
+    assert launcher._get_appdata_base() == app_dir
+    assert launcher.ensure_appdata() == app_dir
+    assert SimProvider._resolve_state_path({}) == app_dir / "sim_paper_account.json"
+    assert cache.is_dir()
+
+
+def test_profile_migration_reads_live_user_config_off_windows(monkeypatch):
+    # Off Windows the v11 profile migration used to find no sources and then
+    # strip profiles from user_config.json without copying them anywhere.
+    import config_manager
+
+    monkeypatch.setattr(app_paths, "_is_windows", lambda: False)
+    monkeypatch.delenv("APPDATA")
+    live = config_manager._appdata_user_config_path()
+    live.write_text('{"profiles": {"Day": {}}}', encoding="utf-8")
+
+    assert config_manager._legacy_user_config_paths() == [live]
+
+
+def test_pulse_room_prefers_the_current_bands_file_name(tmp_path):
+    from pulse_room import builder
+    legacy = tmp_path / "GLOBAL_eurusd_bands.json"
+    legacy.write_text("{}")
+    assert builder.bands_path("EURUSD", cache_dir=tmp_path) == legacy
+    current = tmp_path / "EURUSD_bands.json"
+    current.write_text("{}")
+    assert builder.bands_path("EURUSD", cache_dir=tmp_path) == current
diff --git a/electron_shell/main.js b/electron_shell/main.js
index 7afcfe7..802185c 100644
--- a/electron_shell/main.js
+++ b/electron_shell/main.js
@@ -190,7 +190,10 @@ function startBackend() {
       PYTHONUNBUFFERED: "1",
       MK_PORT: String(BACKEND_PORT),       // launcher.py reads this
       MK_NO_BROWSER: "1",                  // skip auto-launch of system browser
-      MK_APP_DIR_NAME: "QuantumTerminal-v2",      // isolate AppData from v1 (auth, cache, account state)
+      // Keep: isolates AppData from v1/browser mode (auth, cache, account state).
+      // backend/app_paths.py defaults to "QuantumTerminal" without it, which
+      // would hide existing %APPDATA%\QuantumTerminal-v2 data.
+      MK_APP_DIR_NAME: "QuantumTerminal-v2",
       // `npm run start:sim` / `electron . --sim`: simulated market + paper trading
       ...(process.argv.includes("--sim") ? { MK_PROVIDER: "sim" } : {}),
     },