Fusion - the Fusion 360 Bridge

@@ -5099,6 +5099,18 @@ except Exception:     pass  +def _host_op_active() -> bool:+    """THE shared invariant (#52 item 3): is a long op or recent driving in flight? Every+    BACKGROUND subsystem that would act ON the host app (synthetic input, window closes,+    update clicks) must stand down while this is true - so subsystem number four is born+    safe instead of being diagnosed in a six-hour thread. Seat takeover is the one+    documented exemption: the seat dialog BLOCKS the very op we are protecting."""+    import time as _t+    if _LONG_OP.get("name"):+        return True+    return bool(_LAST_DRIVE_AT[0] and (_t.time() - _LAST_DRIVE_AT[0]) < 180)++ def _fusion_verifiably_idle() -> dict:     """May the bridge do something that EXITS Fusion right now? Only when ALL of:     no registered long op, no driving verb for 3+ minutes, and no open documents@@ -6550,7 +6562,7 @@ def _seat_sweep_tick():         import ctypes as _ct         from handlers.dismiss_recovery import _find_window_by_title as _fwt         _ch = _fwt("Fusion Error Report")-        if _ch:+        if _ch and not _host_op_active():             _u32 = _ct.windll.user32             _pid = _ct.c_ulong(0)             _u32.GetWindowThreadProcessId(_ct.c_void_p(int(_ch)), _ct.byref(_pid))@@ -6628,7 +6640,8 @@ def _signin_janitor_loop():                         # so it is ALWAYS safe to close in the background. (John, 2026-08-16:                         # "anytime it comes up, just ignore it and close it".)                         try:-                            dismiss_recovery_dialog(background=True)+                            if not _host_op_active():+                                dismiss_recovery_dialog(background=True)                         except Exception:                             pass                 except Exception:@@ -9124,6 +9137,17 @@ def _orchestrate_bind_library_3d(args: dict) -> dict:     if not urn:         return {"success": False, "error": "mint failed: " + str(mint.get("error"))[:150],                 "_hint": str(mint.get("_hint") or "")[:150]}+    # WRITE-BACK NOTICE (#52 item 8): the minted binding is written INTO the caller's+    # .lbr on purpose (the file on disk is what Fusion opens, and it must open BOUND) -+    # but silently mutating an input cost the matrix runner a pristine-restore ritual.+    # Keep a one-time .prebind backup beside it and SAY the mutation out loud.+    try:+        import shutil as _sh+        _bak = lbr_path + ".prebind"+        if not os.path.exists(_bak):+            _sh.copyfile(lbr_path, _bak)+    except Exception:+        pass     txt = re.sub(r'<packages3d>.*?</packages3d>\n?', '', txt, flags=re.S)     binding = ('<packages3d><package3d name="%s" urn="" wip_urn="%s" locally_modified="yes" type="model">'                '<packageinstances><packageinstance name="%s"/></packageinstances>'@@ -9150,17 +9174,21 @@ def _orchestrate_bind_library_3d(args: dict) -> dict:         _why = str(reopened.get("error") or reopened.get("_hint")                    or "library re-open returned success:false with no detail (open_lbr)")[:220]         return {"success": True, "wip_urn": urn, "libraryPath": lbr_path,-                "deviceset": deviceset, "bound": True, "reopened": False,+                "deviceset": deviceset, "bound": True, "reopened": False, "mutatedInput": True,+                "prebindBackup": lbr_path + ".prebind",                 "reopenError": _why,                 "_hint": ("Binding minted (%s) and WRITTEN to the .lbr - the bind is real and "                           "persisted. Re-opening the library into Fusion failed (reopenError "                           "above); the prove stage opens the library itself, so the chain "                           "continues. If prove's 3D frame is missing, the library just needs a "                           "clean re-open once Fusion is idle." % urn)}-    return {"success": True, "wip_urn": urn,+    return {"success": True, "wip_urn": urn, "mutatedInput": True,+            "prebindBackup": lbr_path + ".prebind",             "libraryPath": lbr_path, "deviceset": deviceset,             "bound": True, "reopened": True,-            "_hint": ("Library re-opened WITH the 3D binding. The Content Manager's 3D preview "+            "_hint": ("NOTE: the input .lbr was REWRITTEN with the minted package3d binding "+                      "(account-scoped; pristine copy kept at <libraryPath>.prebind). "+                      "Library re-opened WITH the 3D binding. The Content Manager's 3D preview "                       "resolves after Autodesk's thumbnail service catches up (~2-3 min for a "                       "fresh mint) - EDIT %s.dev then screenshot to verify the render." % deviceset)} @@ -9967,6 +9995,18 @@ def _prove_capture(label: str, view: str) -> dict:         _t.sleep(3)     _t.sleep(2.0)                             # paint beat: the canvas lands after the thread frees     out = {"step": label, "view": view, "ok": False, "screenshot": None}+    # WORKSPACE STAMP on EVERY frame (#52 item 2: gates must assert content, not count+    # artifacts). package3d already hard-fails outside Design; the other views get their+    # expected-workspace names captured from green runs via this stamp first, THEN their+    # own hard gates - a gate that can false-fail is as useless as one that cannot fail.+    try:+        _wsr = _proxy_to_addin("execute_text_command",+                               {"command": "DebugCommands.ActiveWorkspace"}, timeout=10)+        _wsv = ((_wsr.get("data") or {}).get("output") or (_wsr.get("data") or {}).get("result") or "")+        if _wsv:+            out["activeWorkspace"] = str(_wsv).strip()[:60]+    except Exception:+        pass     try:         shot = _handle_screenshot_fusion({}, {})         p = shot.get("savedTo") or shot.get("localSafePath")@@ -10720,7 +10760,32 @@ def _handle_prove_result(fusion_info: dict, args: dict) -> dict:     run now persists its outcome, and this verb hands it back: fire prove_library, and on a     relay timeout poll THIS until it reports the run you started.     """-    res = _PROVE_LAST[0]+    # RESULT IDENTITY (#52 item 6, 2026-08-24): with several threads driving one Fusion,+    # "the last run globally" is the WRONG run for anyone who passed a runId - the matrix+    # runner picked up another thread's TLV9001 chain as its own result. A given runId is+    # now authoritative: looked up in the per-run store, and an unknown id is an ERROR,+    # never silently the latest.+    _rid = str(args.get("runId") or "").strip()+    res = None+    if _rid:+        try:+            import tempfile as _tf+            _runs = json.loads(open(os.path.join(_tf.gettempdir(), "fusion-prove-runs.json"),+                                    encoding="utf-8").read())+            res = _runs.get(_rid)+        except Exception:+            res = None+        if res is None:+            _pl = _PROVE_LAST[0]+            if _pl and _pl.get("runId") == _rid:+                res = _pl+        if res is None:+            return {"success": False, "errorCode": "unknown_run_id",+                    "error": "no prove run with runId %r on this box" % _rid,+                    "_hint": "runId comes from fusion_create_library's response. Omit runId "+                             "for the latest completed run (single-caller convenience only)."}+    if res is None:+        res = _PROVE_LAST[0]     if res is None:         try:             import tempfile as _tf@@ -11063,6 +11128,45 @@ COMMAND_HANDLERS["create_library"] = _handle_create_library COMMAND_HANDLERS["demo_control"] = lambda info, args: _handle_demo_control(args)  +def _handle_action_ledger(args: dict) -> dict:+    """READ-ONLY view of the background-action ledger (#52 item 1: 'a caller on a relay or+    in a container is blind to it'). Answers "who touched my host app" without filesystem+    access. args: {limit (default 50, max 500), sinceSeconds, action (substring filter)}."""+    import pathlib as _pl+    p = _pl.Path(os.path.expanduser("~")) / ".adom" / "fusion-bridge" / "actions.jsonl"+    if not p.exists():+        return {"success": True, "entries": [], "count": 0,+                "_hint": "Ledger empty: the bridge has taken no background actions on this "+                         "box since 1.9.177 (or none since the file was last cleared)."}+    limit = max(1, min(int(args.get("limit") or 50), 500))+    since = args.get("sinceSeconds")+    want = str(args.get("action") or "").lower()+    import time as _t+    cutoff = (_t.time() - float(since)) if since else None+    out = []+    try:+        for line in p.read_text(encoding="utf-8", errors="replace").splitlines():+            try:+                e = json.loads(line)+            except Exception:+                continue+            if cutoff and float(e.get("epoch") or 0) < cutoff:+                continue+            if want and want not in str(e.get("action") or "").lower():+                continue+            out.append(e)+    except Exception as e:+        return {"success": False, "error": "ledger unreadable: %s" % e}+    return {"success": True, "entries": out[-limit:], "count": len(out),+            "_hint": ("Every background action the bridge takes on the host app - update "+                      "clicks and deferrals, seat takeovers, dialog dismissals, doc closes, "+                      "hang-gate kills, WM_CLOSEs (with window class+size) - appended live, "+                      "survives respawns. Filter: {action:'wm_close', sinceSeconds:3600}.")}+++COMMAND_HANDLERS["action_ledger"] = lambda info, args: _handle_action_ledger(args or {})++  def _handle_check_3d_thumbnail(fusion_info: dict, args: dict) -> dict:     """Is the Library Manager's 3D THUMBNAIL actually rendered? Deterministic, no pixels.