Fusion - the Fusion 360 Bridge

@@ -137,6 +137,67 @@ def _resolve_seat_via_uia(dlg: dict) -> bool:         return False  +def _owned_popup_count(main_hwnd) -> int:+    """ownedPopupCount on a window via AD's desktop_screenshot_window - the SAME+    parent/child screenshot signal John kept pointing at (2026-07-06): a modal seat/+    error dialog shows up as an OWNED POPUP of the main Fusion window. This is the+    ground-truth 'is a dialog still up' check used to VERIFY a seat dialog actually+    cleared, instead of trusting a window-size heuristic (which false-'resolved' the+    823x262 'Suspend Remote Session' confirm). Returns the count, or -1 if unavailable."""+    try:+        if not main_hwnd or not ad_client.available():+            return -1+        res = ad_client.call("desktop_screenshot_window", {"hwnd": int(main_hwnd)})+        if isinstance(res, dict):+            c = res.get("ownedPopupCount")+            if c is None and isinstance(res.get("data"), dict):+                c = res["data"].get("ownedPopupCount")+            if c is not None:+                return int(c)+    except Exception:+        pass+    return -1+++def _resolve_seat_dialog(max_clicks: int = 8) -> dict:+    """Detect + resolve the seat/licensing modal deterministically, IN THE BACKGROUND,+    and VERIFY it truly cleared by SCREENSHOTTING the parent window's ownedPopupCount -+    not by re-running a size heuristic (that false-'resolved' bit John hard, 2026-07-06:+    the code clicked once, the size filter then failed to re-detect the short confirm+    variant, and readiness lied that the dialog was gone while it sat there blocking).++    Each pass: find the dialog -> UIA-invoke 'Continue' (background, Suspend pre-selected+    so it grabs the license) -> screenshot the parent's ownedPopupCount. Done only when+    BOTH find_licensing_dialog() sees nothing AND the parent shows 0 owned popups (or the+    screenshot signal is unavailable and the heuristic agrees). Returns+    {sawDialog, clicks, verified}. Never raises."""+    import time as _t+    clicks = 0+    saw = False+    verified = False+    for _ in range(max_clicks):+        try:+            dlg = find_licensing_dialog()+        except Exception:+            dlg = None+        if not dlg:+            verified = True+            break+        saw = True+        parent = dlg.get("owner")+        _resolve_seat_via_uia(dlg)+        clicks += 1+        _t.sleep(1.5)+        # Ground-truth confirm via parent/child screenshot (John's insisted-on check).+        cnt = _owned_popup_count(parent)+        if cnt == 0:+            verified = True+            break+        # cnt == -1 (screenshot unavailable): fall through, the next find_licensing_dialog+        # pass decides. cnt > 0: still up, loop and click again.+    return {"sawDialog": saw, "clicks": clicks, "verified": verified}++ def _handle_launch(fusion_info: dict, args: dict) -> dict:     """Launch Fusion 360 and optionally wait for the AdomBridge add-in."""     # LIVE detect (not the stale bridge-start fusion_info snapshot) so a launch right@@ -221,10 +282,12 @@ def _handle_launch(fusion_info: dict, args: dict) -> dict:         except Exception:             _lic = None         if _lic:+            # Resolve + SCREENSHOT-VERIFY it cleared (parent ownedPopupCount), not a+            # size heuristic that false-'resolved' the short confirm variant.             if _seat_clicks < 10:-                if _resolve_seat_via_uia(_lic):-                    _seat_clicks += 1-            _t.sleep(1.5)+                _r = _resolve_seat_dialog(max_clicks=3)+                _seat_clicks += _r.get("clicks", 0)+            _t.sleep(1.0)             continue         # No seat dialog -> is the add-in actually serving? (ground truth for drivable)         if _probe_addin(timeout=1.5):@@ -853,12 +916,39 @@ def _handle_fusion_readiness(fusion_info: dict, args: dict) -> dict:     # instance answers while the CURRENT Fusion sits blocked behind the seat dialog, so     # gating on `not addin_ok` false-negatived `licensingDialog` while the dialog sat     # right there on the user's screen.+    #+    # ⚠️ GAP FIX (John caught it live 2026-07-06): the launch loop only auto-resolves the+    # seat dialog during its ~50s window. But this dialog also appears LATER - minutes+    # after sign-in, when the license server notices too many sessions - long after that+    # loop exited, so it just sat there blocking while readiness passively reported+    # licensingDialog:true. Now readiness SELF-HEALS: whenever it detects the dialog it+    # AUTO-RESOLVES it in the background (UIA 'Continue' + screenshot-verify), so the seat+    # is handled deterministically in CODE no matter when it shows up - the AI never has+    # to notice or act. (John: "do all this tracking from your code so it's deterministic+    # ... the ai never follows skills.")+    seat_resolved = False     licensing = False     if running:         try:             licensing = find_licensing_dialog() is not None         except Exception:             licensing = False+        if licensing:+            try:+                _r = _resolve_seat_dialog()+                seat_resolved = _r.get("clicks", 0) > 0+                # Re-check: did it actually clear? (screenshot-verified inside.)+                licensing = find_licensing_dialog() is not None+            except Exception:+                pass+            if not licensing:+                # Cleared - re-probe the add-in; Fusion may be drivable now.+                try:+                    addin_status = _check_addin_status(timeout=1.5)+                    addin_ok = addin_status is not None+                    ready = installed and running and addin_ok and not needs_signin+                except Exception:+                    pass     if licensing:         ready = False  # a seat/licensing dialog blocking the UI is never "ready" @@ -900,11 +990,14 @@ def _handle_fusion_readiness(fusion_info: dict, args: dict) -> dict:     elif ready:         hint = "READY - drive Fusion (fusion_open_lbr / build_library_3d / etc.)."     elif installed and running and licensing:-        hint = ("Fusion is blocked by a SEAT/LICENSING dialog ('Active Sessions Exceeded') - detected "-                "by owning process + dialog size (its title is just 'Fusion360'). fusion_start "-                "AUTO-RESOLVES it in the BACKGROUND by UIA-invoking its 'Continue' button (no "-                "foreground, no user action) and retries until it clears. If you see this persist, just "-                "call fusion_start again - it is not a crash, and never coordinate-click or ask the user.")+        hint = ("Fusion is blocked by a SEAT/LICENSING dialog ('Active Sessions Exceeded' / 'Suspend "+                "Remote Session') - detected DETERMINISTICALLY as an OWNED POPUP of the main Fusion "+                "window (its title is just 'Fusion360' and it can be as short as 262px, so it is found "+                "by owner+parent-screenshot, NOT a size guess). This verb JUST TRIED to auto-resolve it "+                "in the BACKGROUND (UIA 'Continue', Suspend pre-selected so it reclaims the seat) but it "+                "is still up - it may be mid-render (the first UIA Invoke no-ops). Just POLL "+                "fusion_readiness again in a few seconds; it keeps auto-resolving. Never coordinate-click "+                "or ask the user, and never kill/relaunch (the server keeps the seat).")     elif installed and running:         hint = ("Fusion is RUNNING but its add-in is NOT responding yet - NOT ready to drive. Either it "                 "is still finishing launch / signing in (poll fusion_readiness a few more times), or the "@@ -939,6 +1032,9 @@ def _handle_fusion_readiness(fusion_info: dict, args: dict) -> dict:     if licensing:         result["licensingDialog"] = True         result["statusVerb"] = "fusion_readiness"+    if seat_resolved:+        # We acted on it this call (whether or not it fully cleared yet).+        result["seatDialogAutoResolved"] = True     return result