NeroAI_CopyTrade.py

# -- DPI awareness -- must be set BEFORE tkinter is imported ---------------
try:
    import ctypes
    ctypes.windll.shcore.SetProcessDpiAwareness(2)
except Exception:
    try:
        ctypes.windll.user32.SetProcessDPIAware()
    except Exception:
        pass

import tkinter as tk
from tkinter import scrolledtext, messagebox, ttk
import os
import sys
import subprocess
import threading, requests, time, io, base64
from datetime import datetime
from PIL import Image, ImageTk
from ib_insync import IB, Stock, MarketOrder, LimitOrder, StopOrder, StopLimitOrder

# ── auto-updater ───────────────────────────────────────────────────────────────
APP_VERSION  = "1.0.15"
_VERSION_URL = "https://raw.githubusercontent.com/advillegas/pax-americana/main/version.txt"
_DOWNLOAD_URL = "https://github.com/advillegas/pax-americana/releases/latest/download/Pax_Americana.zip"

def _version_tuple(v):
    try:
        return tuple(int(x) for x in v.strip().split("."))
    except Exception:
        return (0,)

def _check_and_apply_update():
    """Check GitHub for a newer version and self-update if found.
    Only runs when packaged as exe. Never blocks startup on any failure."""
    if not getattr(sys, "frozen", False):
        return  # running as .py script — skip
    try:
        latest = requests.get(_VERSION_URL, timeout=5).text.strip()
        if _version_tuple(latest) <= _version_tuple(APP_VERSION):
            return  # already up to date

        # Notify user
        _r = tk.Tk()
        _r.withdraw()
        messagebox.showinfo(
            "Update Available",
            f"A new version is available ({APP_VERSION} → {latest}).\n"
            "Downloading now — the app will restart automatically."
        )
        _r.destroy()

        # ONEDIR update flow: sys.executable lives inside an install
        # directory containing _internal/. Download the new zip, expand
        # to a temp dir, robocopy /MIR over the install directory.
        exe_path    = sys.executable
        install_dir = os.path.dirname(exe_path)
        zip_path    = os.path.join(install_dir, "Pax_Americana_update.zip")

        resp = requests.get(_DOWNLOAD_URL, timeout=300, stream=True)
        resp.raise_for_status()
        total   = int(resp.headers.get("content-length", 0))
        written = 0
        with open(zip_path, "wb") as f:
            for chunk in resp.iter_content(chunk_size=65536):
                f.write(chunk)
                written += len(chunk)
        if total and written != total:
            try: os.remove(zip_path)
            except Exception: pass
            return

        ps1_path = os.path.join(install_dir, "_pax_update.ps1")
        my_pid   = os.getpid()
        ps = f"""$ErrorActionPreference = 'SilentlyContinue'
$pid_wait = {my_pid}
$zip      = '{zip_path}'
$dst      = '{install_dir}'
$tmp      = Join-Path $env:TEMP ('PaxUpdate_' + [Guid]::NewGuid().ToString())

try {{ Wait-Process -Id $pid_wait -Timeout 60 }} catch {{ }}
try {{ Unblock-File -Path $zip }} catch {{ }}

New-Item -ItemType Directory -Path $tmp -Force | Out-Null
Expand-Archive -LiteralPath $zip -DestinationPath $tmp -Force

robocopy $tmp $dst /E /IS /IT /R:30 /W:1 /NFL /NDL /NJH /NJS /NP | Out-Null

Remove-Item -Recurse -Force -Path $tmp
Remove-Item -Force -Path $zip

$exe = Join-Path $dst 'Pax_Americana.exe'
try {{ Unblock-File -Path $exe }} catch {{ }}
Start-Process -FilePath $exe

try {{ Remove-Item -Force -Path $MyInvocation.MyCommand.Path }} catch {{ }}
"""
        with open(ps1_path, "w", encoding="utf-8") as f:
            f.write(ps)

        subprocess.Popen(
            ["powershell.exe", "-ExecutionPolicy", "Bypass",
             "-WindowStyle", "Hidden", "-File", ps1_path],
            creationflags=subprocess.CREATE_NO_WINDOW,
        )
        sys.sys.sys.sys.exit(0)

    except Exception:
        pass  # never block startup due to update failure

def _resource_path(rel_path: str) -> str:
    base = getattr(sys, "_MEIPASS", os.path.abspath(os.path.dirname(__file__)))
    return os.path.join(base, rel_path)

def _remove_near_black_bg(img: Image.Image, threshold: int = 18) -> Image.Image:
    rgba = img.convert("RGBA")
    new_px = []
    for (r, g, b, a) in rgba.getdata():
        if r < threshold and g < threshold and b < threshold:
            new_px.append((r, g, b, 0))
        else:
            new_px.append((r, g, b, a))
    rgba.putdata(new_px)
    return rgba

def _pad_to_square(img: Image.Image, pad_ratio: float = 0.10) -> Image.Image:
    rgba = img.convert("RGBA")
    w, h = rgba.size
    side = max(w, h)
    pad = int(side * pad_ratio)
    side2 = side + pad * 2
    canvas = Image.new("RGBA", (side2, side2), (0, 0, 0, 0))
    canvas.paste(rgba, ((side2 - w) // 2, (side2 - h) // 2), rgba)
    return canvas

def _trim_transparent(img: Image.Image) -> Image.Image:
    rgba = img.convert("RGBA")
    bbox = rgba.split()[-1].getbbox()
    return rgba.crop(bbox) if bbox else rgba

# ── config ────────────────────────────────────────────────────────────────────
# MASTER_URL        = "http://170.39.187.228:5001" # Test
MASTER_URL        = "http://148.113.203.188:5001" # Real
MASTER_API_KEY    = ""    # set to match API_KEY env var on master (leave empty if auth disabled)
SYNC_INTERVAL_SEC = 15   # position sync check every 15 seconds
LICENSE_URL       = "https://portal.neroai.com/api/licenses/equities"
LICENSE_CHECK_SEC = 60   # re-check license every 60 seconds

def _api_headers():
    """Returns headers dict with X-API-Key when configured."""
    if MASTER_API_KEY:
        return {"X-API-Key": MASTER_API_KEY}
    return {}

# ── theme ─────────────────────────────────────────────────────────────────────
# -- Color Palette -- Dark Navy + Fintech Green --------------------------------
BG          = "#060d1a"
BG_PANEL    = "#0b1628"
BG_INPUT    = "#081220"
BORDER      = "#142240"
ACCENT      = "#00d4aa"
GREEN       = "#00e68a"
GREEN_DIM   = "#00b36b"
RED         = "#ff4d6a"
RED_DIM     = "#cc3355"
AMBER       = "#ffb347"
TEXT        = "#e8f0fe"
TEXT_INPUT  = "#a0ff8a"
TEXT_DIM    = "#e8f0fe"
TEXT_HEADER = "#3d8af7"
BTN_GREEN   = "#00b377"
BTN_GREEN_H = "#00d48f"
BTN_RED     = "#e63956"
BTN_RED_H   = "#ff5272"
BTN_GRAY    = "#142240"
BTN_GRAY_H  = "#1c3058"

# -- Aliases for backward compatibility with existing widget references ---------
PANEL   = BG_PANEL
PANEL2  = BG_PANEL
TEAL    = ACCENT
CYAN    = "#00c8ff"
YELLOW  = AMBER
SUB     = TEXT_DIM
WHITE   = "#ffffff"
DIM2    = BORDER

# -- Typography ----------------------------------------------------------------
FONT        = ("Consolas", 10)
FONT_SM     = ("Consolas", 9)
FONT_HEADER = ("Consolas", 9, "bold")
FONT_TITLE  = ("Consolas", 13, "bold")
FONT_STATUS = ("Consolas", 9)

LOGO_B64 = "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"
ICON_B64 = "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"


class PaxAmericanaClient:
    def __init__(self, root):
        self.root    = root
        self.root.title("Pax Americana")
        # Scale window to screen size, capped at 1000x750
        sw = root.winfo_screenwidth()
        sh = root.winfo_screenheight()
        w = min(1000, int(sw * 0.85))
        h = min(750, int(sh * 0.85))
        x = (sw - w) // 2
        y = (sh - h) // 2
        self.root.geometry(f"{w}x{h}+{x}+{y}")
        self.root.minsize(300, 60)
        self.root.configure(bg=BG)
        self.root.resizable(True, True)

        self.ib                    = IB()
        self.running               = False
        self._last_idx             = 0
        self._stop                 = threading.Event()
        self._counts               = {"received": 0, "placed": 0, "failed": 0}
        self._mode                 = tk.StringVar(value="new")
        self._trade_mode           = tk.StringVar(value="long_short")
        self._account_mode         = tk.StringVar(value="live")
        self._tws_account_var      = tk.StringVar(value="")
        self._tws_account          = ""
        self._multiplier           = tk.DoubleVar(value=1.0)
        self._max_drawdown         = tk.DoubleVar(value=10.0)
        self._start_balance        = 0.0
        self._master_balance       = 0.0
        self._drawdown_hit         = False
        self._last_poll_warn       = 0.0
        self._last_balance_refresh = 0.0   # tracks periodic client balance refresh
        self._last_idx_needs_reset = True
        self._last_sync_time       = 0.0
        self._sync_done_close      = set()
        self._sync_done_open       = set()
        self._positions_cache      = {}      # symbol -> {position, contract} — updated by background thread
        self._positions_cache_lock = threading.Lock()
        self._ib_lock              = threading.Lock()   # serialises concurrent ib.placeOrder calls
        self._close_all_done       = set()   # symbols already submitted via Close All this session
        self._close_all_running    = False   # prevent concurrent Close All threads

        self._build_ui()
        self._set_icon()

        # Prefetch the TWS account list on launch so the dropdown is
        # populated BEFORE the user clicks START (license check needs the
        # right account selected up front).
        self.root.after(800, self._prefetch_accounts)

    # ── icon ──────────────────────────────────────────────────────────────────
    def _set_icon(self):
        try:
            icon_path = _resource_path(os.path.join("assets", "pax_americana.png"))
            pil_icon = Image.open(icon_path, encoding="utf-8")
            pil_icon = _remove_near_black_bg(pil_icon)
            pil_icon = _trim_transparent(pil_icon)
            pil_icon = _pad_to_square(pil_icon, pad_ratio=0.04)
            self._app_icon_imgs = []
            for s in [512, 256, 128, 64, 32, 16]:
                im = pil_icon.resize((s, s), Image.LANCZOS)
                self._app_icon_imgs.append(ImageTk.PhotoImage(im))
            self.root.iconphoto(True, *self._app_icon_imgs)
            return
        except Exception:
            pass
        try:
            if ICON_B64:
                import tempfile
                tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".ico")
                tmp.write(base64.b64decode(ICON_B64))
                tmp.close()
                self.root.iconbitmap(tmp.name)
        except Exception:
            pass

    # ── UI ────────────────────────────────────────────────────────────────────
    def _build_ui(self):
        # -- ttk styling (one theme rules them all so combobox + scrollbar
        # don't fight each other) --
        style = ttk.Style()
        try: style.theme_use("clam")
        except Exception: pass

        # Slim, arrowless dark scrollbar — override clam's default layout to
        # drop the up/down buttons entirely so we just get a thumb + trough.
        try:
            style.layout("Dark.Vertical.TScrollbar", [
                ('Vertical.Scrollbar.trough', {
                    'children': [('Vertical.Scrollbar.thumb', {
                        'expand': '1', 'sticky': 'nswe'
                    })],
                    'sticky': 'ns',
                }),
            ])
        except Exception:
            pass
        style.configure("Dark.Vertical.TScrollbar",
                         background=BORDER, troughcolor=BG,
                         bordercolor=BG, lightcolor=BG, darkcolor=BG,
                         relief="flat", borderwidth=0, gripcount=0,
                         arrowcolor=BORDER, arrowsize=0)
        style.map("Dark.Vertical.TScrollbar",
                   background=[("pressed", ACCENT),
                               ("active",  GREEN_DIM),
                               ("!active", BORDER)])

        hdr = tk.Frame(self.root, bg=PANEL2)
        hdr.pack(fill="x")
        stripe = tk.Canvas(hdr, height=3, bg=BG, highlightthickness=0)
        stripe.pack(fill="x")
        for i in range(1000):
            g = int(0xd4 + (0xc8 - 0xd4) * i / 1000)
            b = int(0xaa + (0xff - 0xaa) * i / 1000)
            stripe.create_line(i, 0, i, 3, fill=f"#00{g:02x}{b:02x}")
        inner = tk.Frame(hdr, bg=PANEL2, padx=20, pady=12)
        inner.pack(fill="x")

        try:
            if LOGO_B64:
                pil_img = Image.open(io.BytesIO(base64.b64decode(LOGO_B64, encoding="utf-8"))).convert("RGBA")
                try:
                    bg_pixel = pil_img.getpixel((0, 0))[:3]
                    tol = 28
                    new_px = [(r, g, b, 0) if abs(r-bg_pixel[0])<=tol and abs(g-bg_pixel[1])<=tol and abs(b-bg_pixel[2])<=tol else (r, g, b, a)
                              for (r, g, b, a) in pil_img.getdata()]
                    pil_img.putdata(new_px)
                except Exception:
                    pass
                self._logo_img = ImageTk.PhotoImage(pil_img)
                tk.Label(inner, image=self._logo_img, bg=PANEL2, bd=0).pack(side="left")
        except Exception:
            pass

        tk.Label(inner, text="  Pax Americana",
                 font=FONT, fg=SUB, bg=PANEL2).pack(side="left")
        self._time_lbl = tk.Label(inner, text="", font=FONT, fg=SUB, bg=PANEL2)
        self._time_lbl.pack(side="right")
        self._tick_clock()
        tk.Frame(self.root, bg=BORDER, height=1).pack(fill="x")

        # status bar
        sbar = tk.Frame(self.root, bg=BG_PANEL, height=28)
        sbar.pack(fill="x")
        sbar.pack_propagate(False)
        self._dot = tk.Label(sbar, text="●", font=FONT_TITLE, fg=RED, bg=BG_PANEL)
        self._dot.pack(side="left", padx=(16, 0))
        self._status_lbl = tk.Label(sbar, text="  Disconnected",
                                     font=("Consolas", 10, "bold"), fg=RED, bg=BG_PANEL)
        self._status_lbl.pack(side="left")
        tk.Frame(sbar, width=1, bg=BORDER).pack(side="left", fill="y", padx=12, pady=4)
        self._bal_lbl = tk.Label(sbar, text="Net Liquidation:  —",
                                  font=FONT, fg=TEXT_DIM, bg=BG_PANEL)
        self._bal_lbl.pack(side="right", padx=(0, 16))

        # ── Scrollable main content area ──
        self._main_container = tk.Frame(self.root, bg=BG)
        self._main_container.pack(fill="both", expand=True)

        self._main_canvas = tk.Canvas(self._main_container, bg=BG, highlightthickness=0)
        self._main_scrollbar = ttk.Scrollbar(self._main_container, orient="vertical",
                                              command=self._main_canvas.yview,
                                              style="Dark.Vertical.TScrollbar")
        self._main_canvas.configure(yscrollcommand=self._on_main_scroll)
        self._main_sb_visible = False
        self._main_sb_dragging = False
        self._main_scrollbar.bind("<ButtonPress-1>",
            lambda e: setattr(self, '_main_sb_dragging', True))
        self._main_scrollbar.bind("<ButtonRelease-1>",
            lambda e: setattr(self, '_main_sb_dragging', False))
        self._main_canvas.pack(side="left", fill="both", expand=True)

        self._scroll_frame = tk.Frame(self._main_canvas, bg=BG)
        self._canvas_window = self._main_canvas.create_window((0, 0), window=self._scroll_frame, anchor="nw")

        def _on_frame_configure(e):
            self._main_canvas.configure(scrollregion=self._main_canvas.bbox("all"))
        self._scroll_frame.bind("<Configure>", _on_frame_configure)

        def _on_canvas_configure(e):
            self._main_canvas.itemconfig(self._canvas_window, width=e.width)
        self._main_canvas.bind("<Configure>", _on_canvas_configure)

        def _on_mousewheel(event):
            self._main_canvas.yview_scroll(int(-1 * (event.delta / 120)), "units")
        self._main_canvas.bind_all("<MouseWheel>", _on_mousewheel)

        # connection panel
        cp = tk.Frame(self._scroll_frame, bg=PANEL, highlightthickness=1, highlightbackground=BORDER)
        cp.pack(fill="x", padx=24, pady=(4, 8))
        ci = tk.Frame(cp, bg=PANEL, padx=20, pady=10)
        ci.pack(fill="x")
        tk.Label(ci, text="TWS CONNECTION", font=FONT_HEADER,
                 fg=TEXT_HEADER, bg=PANEL).grid(row=0, column=0, columnspan=8, sticky="w", pady=(0,8))

        tk.Label(ci, text="Mode", font=FONT, fg=SUB, bg=PANEL).grid(
            row=1, column=0, sticky="w", padx=(0,4))
        acct_frame = tk.Frame(ci, bg=PANEL)
        acct_frame.grid(row=2, column=0, padx=(0,20))
        for val, lbl in [("live","Live"), ("paper","Paper")]:
            tk.Radiobutton(
                acct_frame, text=lbl, variable=self._account_mode, value=val,
                font=FONT, fg=TEXT, bg=PANEL,
                selectcolor=DIM2, activebackground=PANEL, activeforeground=TEAL,
                indicatoron=0, relief="flat", cursor="hand2",
                highlightthickness=1, highlightbackground=BORDER,
                highlightcolor=TEAL, padx=12, pady=5,
                command=self._on_account_mode_change
            ).pack(side="left", padx=(0,4))

        self._btn = tk.Button(ci, text="▶   START", font=("Consolas", 11, "bold"),
                               bg=ACCENT, fg="#0a1220", relief="flat",
                               activebackground=BTN_GREEN_H, activeforeground="#0a1220",
                               cursor="hand2", padx=28, pady=9, bd=0,
                               highlightthickness=0, command=self._toggle)
        self._btn.grid(row=2, column=1)
        def _btn_enter(e):
            if "START" in self._btn.cget("text"):
                self._btn.configure(bg=BTN_GREEN_H)
            else:
                self._btn.configure(bg=RED_DIM)
        def _btn_leave(e):
            if "START" in self._btn.cget("text"):
                self._btn.configure(bg=ACCENT)
            else:
                self._btn.configure(bg=RED)
        self._btn.bind("<Enter>", _btn_enter)
        self._btn.bind("<Leave>", _btn_leave)

        self._close_all_btn = tk.Button(
            ci, text="CLOSE ALL TRADES", font=("Consolas", 11, "bold"),
            bg=YELLOW, fg="#0a1220", relief="flat",
            activebackground="#ffe08a", activeforeground="#0a1220",
            cursor="hand2", padx=22, pady=9, bd=0,
            highlightthickness=0, command=self._close_all_trades
        )
        self._close_all_btn.grid(row=2, column=2, padx=(10, 0))
        self._close_all_btn.bind("<Enter>", lambda e: self._close_all_btn.configure(bg="#ffe08a"))
        self._close_all_btn.bind("<Leave>", lambda e: self._close_all_btn.configure(bg=YELLOW))

        # Account dropdown — placed to the right of CLOSE ALL TRADES,
        # auto-populated from TWS managedAccounts() at launch + on toggle.
        try:
            style = ttk.Style(self.root)
            style.configure("Pax.TCombobox",
                fieldbackground=BG_INPUT, background=BG_INPUT, foreground=TEXT,
                arrowcolor=ACCENT, bordercolor=BORDER, lightcolor=BORDER,
                darkcolor=BORDER, selectbackground=BG_INPUT, selectforeground=TEXT,
                padding=4)
            style.map("Pax.TCombobox",
                fieldbackground=[("readonly", BG_INPUT), ("disabled", BG_INPUT)],
                foreground=[("readonly", TEXT), ("disabled", SUB)],
                selectbackground=[("readonly", BG_INPUT)],
                selectforeground=[("readonly", TEXT)])
            self.root.option_add("*TCombobox*Listbox.background", BG_INPUT)
            self.root.option_add("*TCombobox*Listbox.foreground", TEXT)
            self.root.option_add("*TCombobox*Listbox.selectBackground", ACCENT)
            self.root.option_add("*TCombobox*Listbox.selectForeground", "#0a1220")
            self.root.option_add("*TCombobox*Listbox.font", FONT)
        except Exception:
            pass
        ci.grid_columnconfigure(3, weight=1)
        tk.Label(ci, text="Account", font=FONT, fg=SUB, bg=PANEL).grid(
            row=1, column=3, sticky="w", padx=(40, 0))
        acct_row = tk.Frame(ci, bg=PANEL)
        acct_row.grid(row=2, column=3, sticky="ew", padx=(40, 0))
        self._acct_combo = ttk.Combobox(acct_row, textvariable=self._tws_account_var,
                                         values=[], state="readonly", width=22,
                                         font=FONT, style="Pax.TCombobox")
        self._acct_combo.pack(side="left", fill="x", expand=True)
        self._acct_refresh_btn = tk.Button(
            acct_row, text="↻", font=("Consolas", 10, "bold"),
            bg=BTN_GRAY, fg=TEXT, activebackground=BTN_GRAY_H, activeforeground=ACCENT,
            relief="flat", bd=0, cursor="hand2", padx=8, pady=2,
            command=self._prefetch_accounts)
        self._acct_refresh_btn.pack(side="left", padx=(6, 0))

        self._add_toggle_panel("EXECUTION MODE", self._mode,
            [("new","New Trades Only"),("all","Existing + New Trades")],
            "_mode_lbl", self._on_mode_change, self._scroll_frame)

        self._add_toggle_panel("TRADING MODE", self._trade_mode,
            [("long_short","Long & Short"),("long_only","Long Only")],
            "_trade_lbl", self._on_trade_mode_change, self._scroll_frame)

        # risk management
        rm = tk.Frame(self._scroll_frame, bg=PANEL, highlightthickness=1, highlightbackground=BORDER)
        rm.pack(fill="x", padx=24, pady=(0, 8))
        rm_inner = tk.Frame(rm, bg=PANEL, padx=20, pady=10)
        rm_inner.pack(fill="x")
        tk.Label(rm_inner, text="RISK MANAGEMENT", font=FONT_HEADER,
                 fg=TEXT_HEADER, bg=PANEL).grid(row=0, column=0, columnspan=6, sticky="w", pady=(0,10))

        tk.Label(rm_inner, text="Size Multiplier", font=FONT, fg=SUB, bg=PANEL).grid(
            row=1, column=0, sticky="w", padx=(0,10))
        self._mult_val_lbl = tk.Label(rm_inner, text="1.0×",
                                       font=("Consolas", 10, "bold"), fg=TEAL, bg=PANEL, width=5)
        self._mult_val_lbl.grid(row=1, column=1, padx=(0,10))
        tk.Scale(rm_inner, from_=0.1, to=5.0, resolution=0.1, orient="horizontal",
                 variable=self._multiplier, bg=PANEL, fg=TEXT, troughcolor=DIM2,
                 highlightthickness=0, relief="flat", activebackground=TEAL,
                 sliderrelief="flat", length=200, showvalue=0,
                 command=self._on_mult_change).grid(row=1, column=2, padx=(0,40))
        tk.Label(rm_inner, text="0.1×", font=("Consolas", 8), fg=SUB, bg=PANEL).grid(row=2, column=2, sticky="w")
        tk.Label(rm_inner, text="5.0×", font=("Consolas", 8), fg=SUB, bg=PANEL).grid(row=2, column=2, sticky="e", padx=(0,40))

        tk.Label(rm_inner, text="Max Drawdown", font=FONT, fg=SUB, bg=PANEL).grid(
            row=1, column=3, sticky="w", padx=(0,10))
        self._dd_val_lbl = tk.Label(rm_inner, text="10.0%",
                                     font=("Consolas", 10, "bold"), fg=RED, bg=PANEL, width=6)
        self._dd_val_lbl.grid(row=1, column=4, padx=(0,10))
        tk.Scale(rm_inner, from_=1.0, to=50.0, resolution=0.5, orient="horizontal",
                 variable=self._max_drawdown, bg=PANEL, fg=TEXT, troughcolor=DIM2,
                 highlightthickness=0, relief="flat", activebackground=RED,
                 sliderrelief="flat", length=200, showvalue=0,
                 command=self._on_dd_change).grid(row=1, column=5, padx=(0,10))
        tk.Label(rm_inner, text="1%",  font=("Consolas", 8), fg=SUB, bg=PANEL).grid(row=2, column=5, sticky="w")
        tk.Label(rm_inner, text="50%", font=("Consolas", 8), fg=SUB, bg=PANEL).grid(row=2, column=5, sticky="e", padx=(0,10))

        self._risk_lbl = tk.Label(rm_inner,
            text="Proportional sizing active. Trading stops if drawdown exceeds 10.0%",
            font=FONT, fg=SUB, bg=PANEL)
        self._risk_lbl.grid(row=3, column=0, columnspan=6, sticky="w", pady=(8,0))

        # stat cards
        cards = tk.Frame(self._scroll_frame, bg=BG)
        cards.pack(fill="x", padx=24, pady=(0, 8))
        self._stat_labels = {}
        for i, (title, key, color) in enumerate([
                ("ORDERS RECEIVED","received",CYAN),
                ("ORDERS PLACED","placed",TEAL),
                ("FAILED","failed",RED)]):
            f = tk.Frame(cards, bg=PANEL, highlightthickness=1, highlightbackground=BORDER)
            f.pack(side="left", fill="x", expand=True, padx=(0 if i==0 else 8, 0))
            tk.Label(f, text=title, font=FONT_HEADER, fg=SUB, bg=PANEL).pack(pady=(10,0))
            v = tk.Label(f, text="0", font=("Consolas", 22, "bold"), fg=color, bg=PANEL)
            v.pack(pady=(2,10))
            self._stat_labels[key] = v

        # log
        lf = tk.Frame(self._scroll_frame, bg=PANEL, highlightthickness=1, highlightbackground=BORDER)
        lf.pack(fill="both", expand=True, padx=24, pady=(0, 16))
        lf_hdr = tk.Frame(lf, bg=BORDER, padx=16, pady=6)
        lf_hdr.pack(fill="x")
        tk.Label(lf_hdr, text="LIVE ORDER FEED",
                 font=("Consolas", 10, "bold"), fg=TEXT_HEADER, bg=BORDER).pack(side="left")
        actions = tk.Frame(lf_hdr, bg=BORDER)
        actions.pack(side="right")
        ca_lbl = tk.Label(actions, text="CLOSE ALL TRADES",
                          font=("Consolas", 10, "bold"), fg=YELLOW, bg=BORDER, cursor="hand2")
        ca_lbl.pack(side="right", padx=(12, 0))
        ca_lbl.bind("<Button-1>", lambda e: self._close_all_trades())
        ca_lbl.bind("<Enter>", lambda e: ca_lbl.configure(fg="#ffe08a"))
        ca_lbl.bind("<Leave>", lambda e: ca_lbl.configure(fg=YELLOW))
        clr = tk.Label(actions, text="clear", font=FONT, fg=SUB, bg=BORDER, cursor="hand2")
        clr.pack(side="right")
        clr.bind("<Button-1>", lambda e: self._clear_log())
        clr.bind("<Enter>", lambda e: clr.configure(fg=TEXT))
        clr.bind("<Leave>", lambda e: clr.configure(fg=SUB))

        log_inner = tk.Frame(lf, bg=BORDER, bd=0)
        log_inner.pack(fill="both", expand=True)

        self.log = tk.Text(log_inner, font=FONT, bg=BG, fg=TEXT,
                           insertbackground=ACCENT, relief="flat", bd=8,
                           state="disabled", wrap="none",
                           selectbackground=ACCENT, selectforeground="#ffffff",
                           highlightthickness=1, highlightbackground=BORDER)
        self.log.pack(side="left", fill="both", expand=True)

        self._log_scrollbar = ttk.Scrollbar(log_inner, orient="vertical",
                                             command=self.log.yview,
                                             style="Dark.Vertical.TScrollbar")
        self.log.configure(yscrollcommand=self._on_log_scroll)
        self._log_scrollbar_visible = False
        self._log_scrollbar_dragging = False
        self._log_scrollbar.bind("<ButtonPress-1>",
            lambda e: setattr(self, '_log_scrollbar_dragging', True))
        self._log_scrollbar.bind("<ButtonRelease-1>",
            lambda e: setattr(self, '_log_scrollbar_dragging', False))

        for tag, color in [("ok",GREEN),("err",RED),("info",CYAN),("warn",YELLOW),
                           ("dim",SUB),("buy","#00ff99"),("sell","#ff4060"),
                           ("symbol",WHITE),("price",CYAN)]:
            self.log.tag_config(tag, foreground=color)

        self._log_info("Pax Americana ready. Configure connection and press START.")

    def _add_toggle_panel(self, label, var, options, desc_var, callback, parent=None):
        f = tk.Frame(parent or self.root, bg=PANEL, highlightthickness=1, highlightbackground=BORDER)
        f.pack(fill="x", padx=24, pady=(0, 8))
        inner = tk.Frame(f, bg=PANEL, padx=20, pady=12)
        inner.pack(fill="x")
        tk.Label(inner, text=label, font=FONT_HEADER,
                 fg=TEXT_HEADER, bg=PANEL).pack(side="left", padx=(0,20))
        for val, lbl in options:
            tk.Radiobutton(
                inner, text=lbl, variable=var, value=val,
                font=FONT, fg=TEXT, bg=PANEL,
                selectcolor=DIM2, activebackground=PANEL, activeforeground=TEAL,
                indicatoron=0, relief="flat", cursor="hand2",
                highlightthickness=1, highlightbackground=BORDER,
                highlightcolor=TEAL, padx=14, pady=6, command=callback
            ).pack(side="left", padx=(0,8))
        lbl_w = tk.Label(inner, text="", font=FONT, fg=SUB, bg=PANEL)
        lbl_w.pack(side="left", padx=(10,0))
        setattr(self, desc_var, lbl_w)
        callback()

    # ── callbacks ─────────────────────────────────────────────────────────────
    def _on_account_mode_change(self):
        # Live/Paper toggled — re-probe the corresponding TWS port for accounts
        self._prefetch_accounts()

    # ── account dropdown helpers ─────────────────────────────────────────────
    def _populate_account_combo(self, accts):
        """Push the detected TWS account list into the dropdown.

        Preserves the user's current selection if it's still present,
        otherwise auto-selects the first account. Must run on Tk thread.
        """
        accts = [a for a in (accts or []) if a]
        try:
            self._acct_combo.config(values=accts)
        except Exception:
            return
        current = self._tws_account_var.get()
        if current and current in accts:
            return
        self._tws_account_var.set(accts[0] if accts else "")

    def _prefetch_accounts(self):
        """Spawn a background probe to fetch managedAccounts() from TWS so
        the dropdown is populated before the user clicks START."""
        if self.running:
            return  # don't disturb the active engine connection
        threading.Thread(target=self._prefetch_accounts_worker,
                         daemon=True).start()

    def _prefetch_accounts_worker(self):
        """Probe TWS to fetch managedAccounts(). Tries the selected port
        first, then the other port, and rotates through several clientIds
        in case 19 is taken/restricted on the user's TWS install."""
        import asyncio
        asyncio.set_event_loop(asyncio.new_event_loop())
        host = "127.0.0.1"
        primary  = 7496 if self._account_mode.get() == "live" else 7497
        fallback = 7497 if primary == 7496 else 7496
        candidate_cids = [19, 99, 199, 299, 399, 499, 599, 699, 799, 899]

        last_err = None
        for port in (primary, fallback):
            for cid in candidate_cids:
                probe = IB()
                try:
                    probe.connect(host, port, clientId=cid, timeout=4)
                    accts = []
                    for _ in range(15):
                        accts = [a for a in (probe.managedAccounts() or []) if a]
                        if accts:
                            break
                        probe.sleep(0.2)
                    self.root.after(0, lambda a=accts: self._populate_account_combo(a))
                    if accts:
                        self.root.after(0, lambda n=len(accts), p=port:
                            self._log_ok(f"Detected {n} TWS account(s) on port {p} — pick one before pressing START"))
                    else:
                        self.root.after(0, lambda p=port:
                            self._log_warn(f"Connected to TWS on port {p} but managedAccounts() returned empty"))
                    return
                except Exception as e:
                    last_err = e
                    if cid == candidate_cids[0]:
                        msg = str(e) or type(e).__name__
                        self.root.after(0, lambda p=port, m=msg, c=cid:
                            self._log_warn(f"Account probe port={p} cid={c}: {m}"))
                finally:
                    try: probe.disconnect()
                    except Exception: pass

        self.root.after(0, lambda err=last_err: self._log_err(
            f"Account prefetch: could not reach TWS on 7497 or 7496 "
            f"({type(err).__name__ if err else 'no response'} — is TWS running with API enabled?)"))

    def _on_mode_change(self):
        self._mode_lbl.config(text="Only new orders placed after START will be executed"
            if self._mode.get() == "new" else "All current open orders + new orders will be executed")

    def _on_trade_mode_change(self):
        self._trade_lbl.config(text="SELL orders will be skipped"
            if self._trade_mode.get() == "long_only" else "BUY and SELL orders will be executed")

    def _on_mult_change(self, val):
        self._mult_val_lbl.config(text=f"{float(val):.1f}×")
        self._update_risk_lbl()

    def _on_dd_change(self, val):
        self._dd_val_lbl.config(text=f"{float(val):.1f}%")
        self._update_risk_lbl()

    def _update_risk_lbl(self):
        self._risk_lbl.config(
            text=f"Proportional sizing × {self._multiplier.get():.1f}. "
                 f"Trading stops if drawdown exceeds {self._max_drawdown.get():.1f}%")

    def _tick_clock(self):
        self._time_lbl.config(text=datetime.now().strftime("%Y-%m-%d  %H:%M:%S"))
        self.root.after(1000, self._tick_clock)

    # ── logging ───────────────────────────────────────────────────────────────
    def _log_raw(self, parts):
        ts = datetime.now().strftime("%H:%M:%S")
        self.log.config(state="normal")
        self.log.insert("end", f"[{ts}]  ", "dim")
        for text, tag in parts:
            self.log.insert("end", text, tag)
        self.log.insert("end", "\n")
        self.log.see("end")
        self.log.config(state="disabled")

    def _log_info(self, msg):  self._log_raw([(msg, "info")])
    def _log_err(self, msg):   self._log_raw([(msg, "err")])
    def _log_warn(self, msg):  self._log_raw([(msg, "warn")])
    def _log_ok(self, msg):    self._log_raw([(msg, "ok")])

    def _log_order(self, o, qty):
        tag = "buy" if o["action"] == "BUY" else "sell"
        self._log_raw([
            (f"{o['action']:<4s}  ", tag),
            (f"{o['symbol']:<6s}", "symbol"),
            (f"  qty={qty}  {o['orderType']} @ ", "dim"),
            (f"{o['price']}", "price"),
        ])

    def _clear_log(self):
        self.log.config(state="normal")
        self.log.delete("1.0", "end")
        self.log.config(state="disabled")

    def _on_log_scroll(self, first, last):
        """Auto-show/hide log scrollbar based on content overflow."""
        self._log_scrollbar.set(first, last)
        all_visible = float(first) <= 0.0 and float(last) >= 1.0
        if not all_visible and not self._log_scrollbar_visible:
            self._log_scrollbar.pack(side="right", fill="y", before=self.log)
            self._log_scrollbar_visible = True
        elif all_visible and self._log_scrollbar_visible and not self._log_scrollbar_dragging:
            self._log_scrollbar.pack_forget()
            self._log_scrollbar_visible = False

    def _on_main_scroll(self, first, last):
        """Auto-show/hide main content scrollbar."""
        self._main_scrollbar.set(first, last)
        all_visible = float(first) <= 0.0 and float(last) >= 1.0
        if not all_visible and not self._main_sb_visible:
            self._main_scrollbar.pack(side="right", fill="y")
            self._main_sb_visible = True
        elif all_visible and self._main_sb_visible and not self._main_sb_dragging:
            self._main_scrollbar.pack_forget()
            self._main_sb_visible = False

    def _set_status(self, connected):
        c = GREEN if connected else RED
        self._dot.config(fg=c)
        self._status_lbl.config(
            text="  Connected  —  Scanning active" if connected else "  Disconnected", fg=c)

    def _inc(self, key):
        self._counts[key] += 1
        self._stat_labels[key].config(text=str(self._counts[key]))

    # ── close all trades ──────────────────────────────────────────────────────
    def _close_all_trades(self):
        if not self.running:
            self._log_warn("Not connected — press START first.")
            return
        if not messagebox.askyesno(
            "Close All Trades",
            "This will CANCEL all open orders and CLOSE ALL open positions\n"
            "using MARKET orders.\n\nAre you sure?"
        ):
            return
        threading.Thread(target=self._close_all_worker, daemon=True).start()

    def _close_all_worker(self):
        if self._close_all_running:
            self.root.after(0, lambda: self._log_warn("Close all already running — please wait."))
            return
        self._close_all_running = True
        import asyncio
        try:
            asyncio.get_event_loop()
        except RuntimeError:
            asyncio.set_event_loop(asyncio.new_event_loop())

        try:
            # Step 1: cancel any pending open orders (don't use reqAllOpenOrders — it hangs)
            self.root.after(0, lambda: self._log_warn("Close all: cancelling pending orders…"))
            cancelled = 0
            try:
                for t in list(self.ib.trades()):
                    st = t.orderStatus.status
                    if st in ("Submitted", "PreSubmitted", "PendingSubmit", "PendingCancel"):
                        try:
                            self.ib.cancelOrder(t.order)
                            cancelled += 1
                        except Exception:
                            pass
                time.sleep(0.8)
            except Exception:
                pass
            self.root.after(0, lambda c=cancelled: self._log_info(f"Cancelled {c} pending orders."))

            # Step 2: read from positions cache — populated by main run loop
            self.root.after(0, lambda: self._log_warn("Close all: reading positions…"))
            with self._positions_cache_lock:
                snapshot = dict(self._positions_cache)

            # Filter out symbols already submitted this session
            pending = {s: d for s, d in snapshot.items() if s not in self._close_all_done}

            if not pending:
                self.root.after(0, lambda: self._log_ok("No new positions to close — orders already submitted."))
                return

            self.root.after(0, lambda n=len(pending): self._log_warn(f"Closing {n} positions…"))

            # Step 3: place closing market orders
            closed = 0
            for sym, cdata in pending.items():
                try:
                    qty     = float(cdata["position"])
                    abs_qty = int(abs(qty))
                    if abs_qty == 0:
                        continue
                    action   = "SELL" if qty > 0 else "BUY"
                    contract = cdata["contract"]
                    currency = contract.currency or "USD"

                    c         = Stock(symbol=sym, exchange="SMART", currency=currency)
                    c.conId   = contract.conId
                    order     = MarketOrder(action, abs_qty)
                    order.tif = "DAY"

                    with self._ib_lock:
                        self.ib.placeOrder(c, order)
                    self._close_all_done.add(sym)  # never re-submit this symbol
                    closed += 1
                    self.root.after(0, lambda s=sym, a=action, q=abs_qty:
                        self._log_ok(f"Close all: {a} {s}  qty={q}  MKT ✓"))
                    time.sleep(0.3)
                except Exception as e:
                    sym2 = sym
                    self.root.after(0, lambda s=sym2, e=e:
                        self._log_err(f"Close all failed {s}: {e}"))

            self.root.after(0, lambda c=closed: self._log_ok(f"Done — submitted {c} closing orders."))
            self.root.after(0, lambda: self._log_warn(
                "Close All: new positions opened after this point won't be auto-closed. "
                "Press STOP then START to reset."))

        except Exception as e:
            self.root.after(0, lambda e=e: self._log_err(f"Close all error: {e}"))
        finally:
            self._close_all_running = False

    # ── position sync ─────────────────────────────────────────────────────────
    def _refresh_positions_cache(self):
        """
        Refreshes _positions_cache from ib.portfolio() (incremental updates).
        Called every 2s from the main run loop.
        Only updates the cache if TWS is connected — never clears on disconnection.
        """
        if not self.ib.isConnected():
            return
        try:
            snapshot = {}
            for item in self.ib.portfolio():
                qty = float(item.position)
                if qty == 0:
                    continue
                snapshot[item.contract.symbol] = {
                    "position": qty,
                    "contract": item.contract,
                }
            # Only overwrite cache if snapshot is non-empty.
            # ib.portfolio() can return [] briefly after reconnect while TWS
            # re-streams data — never clear real positions based on that.
            # _force_refresh_positions_cache (reqPositions) is the authoritative
            # source for a flat account and runs every sync cycle.
            if snapshot:
                with self._positions_cache_lock:
                    self._positions_cache.clear()
                    self._positions_cache.update(snapshot)
        except Exception:
            pass

    def _force_refresh_positions_cache(self):
        """
        Forces a FULL position refresh using reqPositions() — use for initial sync only.
        reqPositions() must be called from the IB event loop thread (main _run thread).
        Returns the snapshot dict for immediate use.
        """
        try:
            self.ib.reqPositions()
            # Wait for TWS to stream all positions — poll until stable
            prev_count = -1
            stable_checks = 0
            for _ in range(20):  # max 10 seconds
                time.sleep(0.5)
                positions = self.ib.positions()
                curr_count = len([p for p in positions if float(p.position) != 0])
                if curr_count == prev_count:
                    stable_checks += 1
                    if stable_checks >= 3:  # stable for 1.5s — done
                        break
                else:
                    stable_checks = 0
                prev_count = curr_count

            snapshot = {}
            for p in self.ib.positions():
                qty = float(p.position)
                if qty == 0:
                    continue
                snapshot[p.contract.symbol] = {
                    "position": qty,
                    "contract": p.contract,
                }
            with self._positions_cache_lock:
                self._positions_cache.clear()
                self._positions_cache.update(snapshot)
            return snapshot
        except Exception as e:
            return {}

    def _sync_positions(self):
        """
        Every SYNC_INTERVAL_SEC seconds, compare master positions vs client positions.

        Case 1: Master HAS symbol, Client DOES NOT  → open it on client (once per session)
        Case 2: Client HAS symbol, Master DOES NOT  → close it on client (once per session)

        _sync_done_close / _sync_done_open are session-scoped sets.
        Once an order is submitted for a symbol, we NEVER resubmit it this session.
        User must press STOP then START to reset.
        """
        # Fetch master positions
        try:
            base_url = MASTER_URL.rstrip("/")
            resp = requests.get(f"{base_url}/positions", timeout=6, headers=_api_headers()).json()
            master_positions = resp.get("positions", [])
            # Safety guard: if master returns an error or empty list, it may not be
            # properly connected. Never close client positions based on an empty response —
            # that would wipe out all positions incorrectly.
            if resp.get("error"):
                self.root.after(0, lambda: self._log_warn("Sync skipped — master not connected."))
                return
        except Exception:
            return  # network issue — retry next cycle silently

        master_map = {p["symbol"]: p for p in master_positions}

        # Read from our own positions cache — populated by main run loop
        with self._positions_cache_lock:
            client_map = dict(self._positions_cache)

        # Safety guard: if master has 0 positions AND client has many,
        # this is almost certainly a connectivity/startup issue on the master side.
        # Never close all client positions based on this — skip sync.
        if len(master_map) == 0 and len(client_map) > 2:
            self.root.after(0, lambda: self._log_warn(
                "Sync skipped — master shows 0 positions but client has open trades. "
                "Check master connection."
            ))
            return

        # ── Case 1: Master has it, client doesn't → open on client ───────────
        for sym, mp in master_map.items():
            if sym in client_map:
                # Symbol now in client — remove from done so future sessions re-check
                self._sync_done_open.discard(sym)
                continue
            if sym in self._sync_done_open:
                continue  # already submitted this session — don't repeat
            qty = self._calc_quantity(mp["quantity"])
            if qty <= 0:
                continue
            action   = mp["side"]
            currency = mp.get("currency", "USD")
            if self._trade_mode.get() == "long_only" and action == "SELL":
                continue
            try:
                contract  = Stock(symbol=sym, exchange="SMART", currency=currency)
                ot        = mp.get("orderType", "MKT")
                price     = float(mp.get("price", 0) or 0)
                aux_price = float(mp.get("auxPrice", 0) or 0)
                if ot == "LMT":
                    order = LimitOrder(action, qty, price)
                elif ot == "STP":
                    order = StopOrder(action, qty, aux_price)
                elif ot == "STP LMT":
                    order = StopLimitOrder(action, qty, price, aux_price)
                else:
                    order = MarketOrder(action, qty)
                order.tif = "DAY"
                with self._ib_lock:
                    self.ib.placeOrder(contract, order)
                self._sync_done_open.add(sym)
                self.root.after(0, lambda s=sym, a=action, q=qty, t=ot:
                    self._log_warn(f"Sync: opening missed position — {a} {s} qty={q} ({t})"))
                time.sleep(0.5)  # small gap between orders to avoid TWS rate limit
            except Exception as e:
                self.root.after(0, lambda s=sym, e=e:
                    self._log_err(f"Sync open failed {s}: {e}"))

        # ── Case 2: Client has it, master doesn't → close on client ──────────
        # WARNING: this will also close any positions the client opened manually
        # that the master does not hold. STOP the engine to protect manual trades.
        for sym, cdata in client_map.items():
            if sym in master_map:
                self._sync_done_close.discard(sym)  # master has it again — reset
                continue
            if sym in self._sync_done_close:
                continue  # already submitted this session — don't repeat
            self.root.after(0, lambda s=sym: self._log_warn(
                f"Sync: {s} not in master — closing. Stop engine to keep manual positions."))
            qty     = float(cdata["position"])
            abs_qty = int(abs(qty))
            if abs_qty == 0:
                continue
            action   = "SELL" if qty > 0 else "BUY"
            contract = cdata["contract"]
            currency = contract.currency or "USD"
            try:
                # Don't use cached conId — can be stale after reconnect and
                # cause silent order failures. Let TWS resolve by symbol.
                c         = Stock(symbol=sym, exchange="SMART", currency=currency)
                order     = MarketOrder(action, abs_qty)
                order.tif = "DAY"
                with self._ib_lock:
                    self.ib.placeOrder(c, order)
                # Only mark as done AFTER successful placement — if it throws,
                # we retry next cycle instead of leaving the orphan forever.
                self._sync_done_close.add(sym)
                self.root.after(0, lambda s=sym, a=action, q=abs_qty:
                    self._log_warn(f"Sync: closing orphan position — {a} {s} qty={q}"))
                time.sleep(0.3)
            except Exception as e:
                self.root.after(0, lambda s=sym, e=e:
                    self._log_err(f"Sync close failed {s}: {e}"))

    # ── license verification ─────────────────────────────────────────────────
    def _check_license(self, account: str) -> bool:
        """Return True if *account* appears in the license endpoint."""
        try:
            resp = requests.get(LICENSE_URL, timeout=6)
            resp.raise_for_status()
            data = resp.json()
            licenses = data.get("licenses", []) if isinstance(data, dict) else data
            for entry in licenses:
                val = entry if isinstance(entry, str) else str(entry.get("key", ""))
                if val == account:
                    return True
            return False
        except Exception as e:
            self._log_warn(f"License check failed: {e}")
            return False

    # ── start / stop ──────────────────────────────────────────────────────────
    def _toggle(self):
        if not self.running: self._start()
        else: self._stop_engine()

    def _start(self):
        import hashlib, socket
        host = "127.0.0.1"
        port = 7496 if self._account_mode.get() == "live" else 7497
        # Derive a stable clientId (21-999) from the hostname so two machines
        # don't collide, while staying well clear of clientId=0 used by master.
        _hash = int(hashlib.md5(socket.gethostname().encode()).hexdigest(), 16)
        cid   = 21 + (_hash % 978)
        self._btn.config(text="■   STOP", bg=RED, activebackground=RED_DIM, fg="#0a1220")
        self._log_info(f"Connecting to TWS  {host}:{port}  clientId={cid} …")
        self._drawdown_hit         = False
        self._last_sync_time       = time.time() + 9999  # block periodic sync until startup sync completes
        self._sync_done_close      = set()
        self._sync_done_open       = set()
        with self._positions_cache_lock:
            self._positions_cache.clear()
        self._close_all_done = set()
        threading.Thread(target=self._run, args=(host, port, cid), daemon=True).start()

    def _stop_engine(self):
        self._stop.set()
        self.running = False
        self._last_idx_needs_reset = True
        self._btn.config(text="▶   START", bg=ACCENT, activebackground=BTN_GREEN_H, fg="#0a1220")
        self.root.after(0, lambda: self._set_status(False))
        self._log_warn("Engine stopped.")
        try: self.ib.disconnect()
        except: pass
        self.ib = IB()

    # ── main loop ─────────────────────────────────────────────────────────────
    def _run(self, host, port, cid):
        import asyncio
        asyncio.set_event_loop(asyncio.new_event_loop())
        self._stop.clear()

        try:
            self.ib.connect(host, port, clientId=cid)

            # ── license gate ──────────────────────────────────────────
            # managedAccounts() can briefly return [] right after connect —
            # poll up to ~3s for TWS to push the account list, then sync
            # the dropdown so the user's selection (or first detected) wins.
            accts = []
            for _ in range(15):
                accts = [a for a in (self.ib.managedAccounts() or []) if a]
                if accts:
                    break
                self.ib.sleep(0.2)

            populated = threading.Event()
            def _populate_then_signal():
                self._populate_account_combo(accts)
                populated.set()
            self.root.after(0, _populate_then_signal)
            populated.wait(timeout=2)

            self._tws_account = self._tws_account_var.get().strip()
            if len(accts) > 1:
                self.root.after(0, lambda n=len(accts), a=self._tws_account:
                    self._log_info(f"TWS reports {n} accounts — using {a} (change via Account dropdown)"))
            if not self._tws_account:
                self.root.after(0, lambda: self._log_err(
                    "No TWS account selected." if accts else
                    "Could not retrieve TWS account number."))
                self.root.after(0, lambda: self._btn.config(
                    text="▶   START", bg=ACCENT, fg="#0a1220"))
                try: self.ib.disconnect()
                except: pass
                return
            self.root.after(0, lambda a=self._tws_account:
                self._log_info(f"TWS account: {a}"))
            if not self._check_license(self._tws_account):
                self.root.after(0, lambda: self._log_err(
                    "License not found — this account is not authorized. "
                    "Contact support@neroai.com"))
                self.root.after(0, lambda: self._btn.config(
                    text="▶   START", bg=ACCENT, fg="#0a1220"))
                try: self.ib.disconnect()
                except: pass
                return
            self.root.after(0, lambda: self._log_ok("License verified ✓"))
            self._last_license_check = time.time()
            # ──────────────────────────────────────────────────────────

            self.running = True
            self.root.after(0, lambda: self._set_status(True))
            self._log_info("TWS connected ✓")
            self._log_info(f"Mode: {self._mode.get()} | Account: {self._account_mode.get()}")
            self._fetch_client_balance()
        except Exception:
            self.root.after(0, lambda: self._log_err(
                "Connection failed. Make sure TWS is running and API is enabled."))
            self.root.after(0, lambda: self._btn.config(text="▶   START", bg=ACCENT, fg="#0a1220"))
            return

        base_url = MASTER_URL.rstrip("/")

        # fetch master balance
        try:
            resp = requests.get(f"{base_url}/balance", timeout=4, headers=_api_headers()).json()
            self._master_balance = float(resp.get("master_balance", 0))
        except Exception:
            pass

        # determine starting order index
        # We ALWAYS start from the latest index regardless of mode.
        # Existing positions are handled by the position sync (every 15s),
        # which compares master vs client positions and only acts on mismatches.
        # This prevents double-placing orders that are already in the account.
        if getattr(self, "_last_idx_needs_reset", True):
            try:
                resp = requests.get(f"{base_url}/orders", timeout=4, headers=_api_headers()).json()
                self._last_idx = resp.get("total", 0)
            except Exception:
                pass
            self._last_idx_needs_reset = False

        # If "Existing + New Trades" mode — force full position load then sync
        if self._mode.get() == "all":
            self.root.after(0, lambda: self._log_info("Existing + New mode — fetching all positions…"))
            # Block periodic sync for the full duration of startup sync
            self._last_sync_time = time.time() + 9999
            # Run entirely in THIS thread — has the IB event loop for both reqPositions + placeOrder
            snapshot = self._force_refresh_positions_cache()
            n = len(snapshot)
            self.root.after(0, lambda n=n: self._log_info(f"Position cache ready — {n} positions found. Running sync…"))
            self._sync_positions()   # called directly — same thread, same event loop
            self._last_sync_time = time.time()  # periodic sync resumes from now

        while not self._stop.is_set():

            # ── auto-reconnect if TWS dropped ─────────────────────────────────
            if not self.ib.isConnected():
                self.running = False
                self.root.after(0, lambda: self._set_status(False))
                self.root.after(0, lambda: self._log_warn("TWS disconnected — reconnecting in 10s…"))
                for _ in range(10):
                    if self._stop.is_set():
                        break
                    time.sleep(1)
                if self._stop.is_set():
                    break
                try:
                    self.ib.disconnect()
                except Exception:
                    pass
                self.ib = IB()
                try:
                    self.ib.connect(host, port, cid)
                    self.running = True
                    self.root.after(0, lambda: self._set_status(True))
                    self.root.after(0, lambda: self._log_ok("TWS reconnected ✓ — resuming…"))
                    self._fetch_client_balance()
                    # Force position refresh after reconnect so cache is accurate
                    self._force_refresh_positions_cache()
                except Exception:
                    self.root.after(0, lambda: self._log_warn("Reconnect failed — will retry…"))
                    continue

            # ── drawdown guard ────────────────────────────────────────────────
            if self._drawdown_hit:
                time.sleep(2)
                continue

            current_bal = self._get_client_balance()
            if current_bal > 0 and self._start_balance > 0:
                dd = (self._start_balance - current_bal) / self._start_balance * 100
                if dd >= self._max_drawdown.get():
                    self._drawdown_hit = True
                    self.root.after(0, lambda: self._log_err(
                        "Max drawdown limit hit — trading stopped."))
                    self.root.after(0, lambda: self._set_status(False))
                    time.sleep(2)
                    continue

            # ── periodic license check ────────────────────────────────────────
            _now = time.time()
            if _now - self._last_license_check >= LICENSE_CHECK_SEC:
                self._last_license_check = _now
                if not self._check_license(self._tws_account):
                    self.root.after(0, lambda: self._log_err(
                        "License revoked — account no longer authorized. Stopping engine."))
                    self.root.after(0, lambda: self._stop_engine())
                    break

            # ── refresh client balance every 60s (keeps sizing ratio accurate) ─
            if _now - self._last_balance_refresh >= 60:
                refreshed = self._get_client_balance()
                if refreshed > 0:
                    self._start_balance = refreshed
                self._last_balance_refresh = _now

            # ── refresh positions cache (used by sync + close all) ────────────
            self._refresh_positions_cache()

            # ── poll new orders ───────────────────────────────────────────────
            try:
                resp = requests.get(
                    f"{base_url}/orders?since={self._last_idx}", timeout=4,
                    headers=_api_headers()).json()
                new_orders = resp.get("orders", [])
                mb = float(resp.get("master_balance", 0))
                if mb > 0:
                    self._master_balance = mb
                for o in new_orders:
                    if self._maybe_place(o):
                        self._last_idx += 1
                    else:
                        break  # TWS down — retry this order next cycle
            except Exception:
                now = time.time()
                if now - self._last_poll_warn > 30:
                    self._last_poll_warn = now
                    self.root.after(0, lambda: self._log_warn("Connection issue — retrying…"))

            # ── position sync every SYNC_INTERVAL_SEC ────────────────────────
            now = time.time()
            if now - self._last_sync_time >= SYNC_INTERVAL_SEC:
                self._last_sync_time = now
                # Run entirely in THIS thread — IB event loop required for both calls
                self._force_refresh_positions_cache()
                self._sync_positions()

            time.sleep(2)

    def _fetch_client_balance(self):
        try:
            for v in self.ib.accountValues():
                if v.tag == "NetLiquidation" and v.currency == "USD":
                    bal = float(v.value)
                    self._start_balance = bal
                    self.root.after(0, lambda b=bal: self._bal_lbl.config(
                        text=f"Net Liquidation:  ${b:,.2f}", fg=TEXT))
                    return bal
        except Exception:
            pass
        return 0.0

    def _get_client_balance(self):
        try:
            for v in self.ib.accountValues():
                if v.tag == "NetLiquidation" and v.currency == "USD":
                    bal = float(v.value)
                    self.root.after(0, lambda b=bal: self._bal_lbl.config(
                        text=f"Net Liquidation:  ${b:,.2f}", fg=TEXT))
                    return bal
        except Exception:
            pass
        return 0.0

    # ── order placement ───────────────────────────────────────────────────────
    def _maybe_place(self, o):
        """Returns True if the order was placed or intentionally skipped.
        Returns False only on a TWS placement failure — caller should not advance _last_idx."""
        if not self.running:
            return True
        required = ("symbol", "action", "orderType", "quantity", "currency")
        missing  = [k for k in required if not o.get(k)]
        if missing:
            self.root.after(0, lambda m=missing: self._log_err(
                f"Malformed order from master — missing fields: {m}"))
            return True
        if o["action"] not in ("BUY", "SELL"):
            self.root.after(0, lambda: self._log_err(
                f"Invalid action '{o['action']}' in order — skipped"))
            return True
        if o["orderType"] not in ("MKT", "LMT", "STP", "STP LMT"):
            self.root.after(0, lambda: self._log_err(
                f"Unsupported orderType '{o['orderType']}' — skipped"))
            return True
        try:
            float(o["quantity"])
        except (ValueError, TypeError):
            self.root.after(0, lambda: self._log_err(
                f"Invalid quantity '{o['quantity']}' — skipped"))
            return True
        if self._trade_mode.get() == "long_only" and o["action"] == "SELL":
            self.root.after(0, lambda: self._log_warn(f"Skipped SELL {o['symbol']} (Long Only mode)"))
            return True
        qty = self._calc_quantity(float(o["quantity"]))
        if qty <= 0:
            self.root.after(0, lambda: self._log_warn(f"Skipped {o['symbol']} — qty is 0"))
            return True
        self.root.after(0, lambda: self._inc("received"))
        try:
            contract  = Stock(o["symbol"], "SMART", o["currency"])
            ot        = o["orderType"]
            price     = float(o.get("price", 0) or 0)
            aux_price = float(o.get("auxPrice", 0) or 0)
            if ot == "MKT":
                order = MarketOrder(o["action"], qty)
            elif ot == "LMT":
                order = LimitOrder(o["action"], qty, price)
            elif ot == "STP":
                order = StopOrder(o["action"], qty, aux_price)
            else:  # STP LMT
                order = StopLimitOrder(o["action"], qty, price, aux_price)
            order.tif    = "DAY"
            with self._ib_lock:
                self.ib.placeOrder(contract, order)
            # Prevent sync from also opening/closing this symbol in the same session
            self._sync_done_open.add(o["symbol"])
            self._sync_done_close.add(o["symbol"])
            time.sleep(0.5)
            self.root.after(0, lambda: self._inc("placed"))
            self.root.after(0, lambda oo=o, q=qty: self._log_order(oo, q))
            return True
        except Exception:
            self.root.after(0, lambda: self._inc("failed"))
            self.root.after(0, lambda: self._log_err("Order failed. Check TWS for details."))
            return False

    def _calc_quantity(self, master_qty):
        multiplier = self._multiplier.get()
        if self._master_balance <= 0 or self._start_balance <= 0:
            # Balances not yet loaded — return 0 so the order is skipped.
            # Placing at full master size when account sizes are unknown is unsafe.
            self.root.after(0, lambda: self._log_warn(
                "Order skipped — balance not yet loaded. Retry after balances appear."))
            return 0
        ratio = self._start_balance / self._master_balance
        return max(1, round(master_qty * ratio * multiplier))


def _apply_dark_title_bar(root):
    """Apply dark title bar on Windows to match the app's dark theme."""
    try:
        from ctypes import wintypes
        root.update()
        wm_frame = root.wm_frame()
        hwnd = int(wm_frame, 16) if isinstance(wm_frame, str) else wm_frame
        dwmapi = ctypes.windll.dwmapi
        DWORD = wintypes.DWORD
        BOOL = wintypes.BOOL
        value = BOOL(1)
        for attr in (20, 19):
            if dwmapi.DwmSetWindowAttribute(hwnd, DWORD(attr),
                    ctypes.byref(value), ctypes.sizeof(value)) == 0:
                break
        # Set title bar color to match BG (#060d1a) as COLORREF (0x001a0d06)
        color = DWORD(0x06 | (0x0d << 8) | (0x1a << 16))
        dwmapi.DwmSetWindowAttribute(hwnd, DWORD(35),
                                      ctypes.byref(color), ctypes.sizeof(color))
        root.withdraw()
        root.after(20, root.deiconify)
    except Exception:
        pass


if __name__ == "__main__":
    _check_and_apply_update()
    root = tk.Tk()
    try:
        dpi = root.winfo_fpixels("1i")
        root.tk.call("tk", "scaling", dpi / 72.0)
    except Exception:
        pass
    root.configure(bg=BG)
    root.withdraw()
    app = PaxAmericanaClient(root)
    root.after(50, lambda: _apply_dark_title_bar(root))
    root.after(100, root.deiconify)
    root.mainloop()