← Commit history
README.md+51−47
@@ -1,6 +1,6 @@-# Adom Desktop - Fusion 360 Bridge+# Adom Bridge - Fusion 360 Bridge -Drive **Autodesk Fusion 360** from the cloud through [Adom Desktop](https://wiki.adom.inc/adom/adom-desktop):+Drive **Autodesk Fusion 360** from the cloud through [Adom Bridge (macOS)](https://wiki.adom.inc/adom/adom-bridge-macos): component libraries with real 3D, parametric IPC package generation with laser-etched markings, electronics board workflows, manufacturing exports (Gerbers/BOM/CPL), per-manufacturer design rules, and fast APS cloud-file search - all by asking your AI. Every verb returns a rich `_hint`, so a@@ -15,7 +15,7 @@ calling AI never has to guess. New to this? Run **one verb** and watch:  ```bash-adom-desktop fusion_demo '{}'+adom-bridge fusion_demo '{}' ```  `fusion_demo` takes a first-time user from nothing to a real board. It launches Fusion, **finishes@@ -30,7 +30,7 @@ the exact next action. Keep calling it until `done:true`. Two things it deliberately does NOT do:  - **It never leaves you parked on the sign-in page.** It drives the sign-in through your **native-  browser** (via the Adom browser extension), because that profile is usually already signed into+  browser** (via the Adom native-browser bridge), because that profile is usually already signed into   Autodesk - one click instead of a password + 2FA. An anonymous automation browser would force a   full fresh login, so the demo never uses one. - **It never just name-drops cloud search.** It sets **APS** up for you, then runs a live sample@@ -55,7 +55,7 @@ chip previews, and the footprint/package **Mapped** check EEs look for. - `fusion_capture_library_views` - capture the symbol / footprint / component view per part - Get the library: [adom-basic-parts-fusion-lbr](https://wiki.adom.inc/adom/adom-basic-parts-fusion-lbr) -<video controls width="100%" src="https://wiki.adom.inc/api/v1/pages/adom-desktop-fusion-bridge/files/AdomBasicParts-138-library.mp4"></video>+<video controls width="100%" src="https://wiki.adom.inc/api/v1/pages/fusion-bridge/files/AdomBasicParts-138-library.mp4"></video>  ![138-part overview](screenshots/lib3-138-overview.png) @@ -68,7 +68,7 @@ package + laser-etched marking + STEP export, in ONE call, a few seconds per par ![0603 chip with 103 etched](screenshots/epg-0603-103.png)  ```bash-adom-desktop fusion_generate_package '{+adom-bridge fusion_generate_package '{   "type": "soic",   "params": {"DPins": 8, "D": 4.9, "E": 6.0, "E1": 3.9, "e": 1.27, "A": 1.6, "A1": 0.1, "b": 0.41, "L": 0.84},   "etch": "LM358\nADOM-A",@@ -129,9 +129,9 @@ verbs reprimand via `_hint` if you open a non-project file. One verb each, straight from the open board:  ```bash-adom-desktop fusion_export_gerbers '{"outputPath": "/tmp/gerbers"}'   # JLCPCB-ready CAM job-adom-desktop fusion_export_bom     '{"outputPath": "/tmp/bom.csv"}'   # grouped by value+package-adom-desktop fusion_export_cpl     '{"outputPath": "/tmp/cpl.csv"}'   # pick-and-place centroids+adom-bridge fusion_export_gerbers '{"outputPath": "/tmp/gerbers"}'   # JLCPCB-ready CAM job+adom-bridge fusion_export_bom     '{"outputPath": "/tmp/bom.csv"}'   # grouped by value+package+adom-bridge fusion_export_cpl     '{"outputPath": "/tmp/cpl.csv"}'   # pick-and-place centroids ```  Plus mechanical exports: STEP / IGES / STL / 3MF / USDZ / OBJ / DXF / DWG. Long exports return@@ -143,8 +143,8 @@ The bridge ships manufacturer rule files + CAM jobs in `resources/` and loads th board, so DRC matches what the fab actually checks:  ```bash-adom-desktop fusion_load_design_rules '{"ruleFile": "JLCPCB-2layer.dru"}'-adom-desktop fusion_set_design_rules  '{"rules": {"minClearance": 0.127}}'   # ad-hoc tweaks+adom-bridge fusion_load_design_rules '{"layers": "2"}'                  # bundled JLCPCB .edru+adom-bridge fusion_set_design_rules  '{"action": "apply", "layers": "auto"}' ```  Included: JLCPCB 2-layer + 4-layer DRU rules, the matching Gerber CAM jobs (used by@@ -152,36 +152,38 @@ Included: JLCPCB 2-layer + 4-layer DRU rules, the matching Gerber CAM jobs (used  ## How the bridge talks to Fusion (architecture) -![Architecture: cloud AI to AD relay to bridge to add-in to Fusion](screenshots/architecture.svg)+![Architecture: cloud AI to Adom Bridge relay to bridge to add-in to Fusion](screenshots/architecture.svg)  The bridge picks the right channel per task: -1. **Python bridge server** (`server.py`) - spawned by Adom Desktop, receives every `fusion_*` verb.+1. **Python bridge server** (`server.py`) - spawned by Adom Bridge, receives every `fusion_*` verb. 2. **AdomBridge add-in** - installed BY the bridge into every Fusion add-in location-   (`%APPDATA%\Autodesk\FusionAddins` on 2025+ Fusion, plus the legacy `API\AddIns` dirs - Fusion-   moved this across versions and silently ignores the others). It serves HTTP :8774 inside Fusion+   (`~/Library/Application Support/Autodesk/FusionAddins` on 2025+ Fusion, plus the legacy+   `Autodesk Fusion[ 360]/API/AddIns` dirs under the same folder - Fusion moved this across+   versions and silently ignores the others). It serves HTTP :8774 inside Fusion    and marshals work onto Fusion's single main thread via CustomEvent. 3. **In-Fusion channels**: the `adsk` Python API for data/geometry, `executeTextCommand` for EAGLE    editor commands (EDIT / ADD / WINDOW FIT), `Electron.run` for electronics-UI JS    (zoom/pan/select), and `run_modeling_script` for free-form CAD (this is how EPG packages and    laser markings are generated).-4. **Win32 / UIA side channel** - when the API can't reach it: background hwnd screenshots, WM_CLOSE-   dialog dismissal (no focus steal), SendInput keys/clicks, and AD core verbs-   (`desktop_find_control` / `desktop_ui_click`).+4. **macOS window side channel** - when the API can't reach it: background window screenshots+   (CGWindowList + `screencapture -l`), dialog dismissal via the Accessibility API+   (AXCloseButton/AXPress - no focus steal), CGEvent keys/clicks, and Adom Bridge core verbs.+   No Apple Events / System Events anywhere: only the Accessibility grant is used. 5. **APS cloud** (`aps.py`) - fast server-indexed search + file ops at scale (below).  ## Dialog awareness: parent/child screenshots (the automation breakthrough)  Fusion's classic failure mode is a **modal dialog** (save prompt, recovery, licensing) silently blocking the add-in's main thread while the caller sees only a fake "not responding". The-breakthrough: Adom Desktop's window capture returns a window's **owned child popups** - dialogs that+breakthrough: Adom Bridge's window capture returns a window's **owned child popups** - dialogs that don't even enumerate in a normal window list - so every mutating verb returns a **classified dialog array + screenshots** and the AI can never fly blind past one.  ![A licensing decision dialog caught during first launch](screenshots/dialog-active-sessions.png)  - Benign launch errors (an incomplete webdeploy folder) are **auto-dismissed in the background**-  (WM_CLOSE - never a focus-stealing Escape).+  (the dialog's AX close button - never a focus-stealing Escape). - DECISION dialogs - like the seat conflict above, whose options suspend Fusion on the user's OTHER   machine - are **never auto-picked**: the bridge returns `needsUserDecision:true` and the AI   notifies + asks the user.@@ -215,11 +217,11 @@ The bridge **checks APS state in code on every cloud call** (`_aps_guarded`) and self-teaching `_hint` (is it configured? signed in? token live? the full verb list, and the exact next step) so the AI is never stuck on an opaque auth error. -### Best sign-in: your NATIVE Chrome/Edge via ABE (adom-browser-extension)+### Best sign-in: your NATIVE Chrome/Edge via NBE (adom-native-browser)  Autodesk's email OTP / 2FA and "which profile is signed in" headaches vanish if the AI drives the-browser you're **already logged into Autodesk** with. That is what **ABE-([adom-browser-extension](https://wiki.adom.inc/adom/adom-browser-extension))** provides. If ABE+browser you're **already logged into Autodesk** with. That is what **NBE+([adom-native-browser](https://wiki.adom.inc/adom/adom-native-browser))** provides. If NBE isn't installed, the AI will walk you through the one-time install, then open the Autodesk auth URL in your real profile and capture the token - **no password typing**. Fallback: `fusion_aps_signin {allowDefaultBrowser:true}` (OS default browser).@@ -229,7 +231,7 @@ in your real profile and capture the token - **no password typing**. Fallback: | Verb | Does | |---|---| | `fusion_aps_status` | configured? signed in? token live? + never-charge meter |-| `fusion_aps_signin` | one-time OAuth sign-in (prefer ABE native browser) |+| `fusion_aps_signin` | one-time OAuth sign-in (prefer NBE native browser) | | `fusion_aps_search {query}` | server-indexed name search across the whole team hub | | `fusion_aps_open {query}` | find + open a design in Fusion, any folder depth | | `fusion_aps_browse` / `fusion_aps_recent` | walk hubs/projects/folders, newest-modified designs |@@ -248,34 +250,36 @@ precisely by lineage URN (never by name).  The AI does the whole setup - the user never gets handed a download link: -- **Detection first:** AD detects an existing Fusion via this bridge's `detect` paths - per-user-  (`%LOCALAPPDATA%`) AND system-wide (`%ProgramFiles%`, from `--globalinstall`) webdeploy installs.-  `fusion_readiness` / AD's `bridge_readiness` answer installed/running/ready without launching+- **Detection first:** Adom Bridge detects an existing Fusion via this bridge's `detect` paths - the+  per-user webdeploy install (`~/Library/Application Support/Autodesk/webdeploy/production/<hash>/`)+  plus `~/Applications` and `/Applications`.+  `fusion_readiness` / Adom Bridge's `bridge_readiness` answer installed/running/ready without launching   anything. - **AI-driven install:** if Fusion is absent, the AI OFFERS to install it and does it on a yes - the-  fusion-onboarding skill silent-installs the **free trial / personal-use tier** (plenty for viewing-  and real work), drives the Autodesk sign-in (the user types only their own credentials/2FA), and+  fusion-onboarding skill drives Autodesk's mac installer dmg for the **free trial / personal-use+  tier** (plenty for viewing and real work), then the Autodesk sign-in (the user types only their+  own credentials/2FA), and   deploys the add-in. A **view-only trial** install is a first-class option for users who just need   to open and inspect designs. - **Never a manual step:** the bridge restarts Fusion itself (`fusion_stop`/`fusion_start`),-  installs the add-in to every add-in directory Fusion has ever used, and fires an AD toast the+  installs the add-in to every add-in directory Fusion has ever used, and fires an Adom Bridge toast the   moment a step genuinely needs the user (sign-in, 2FA, license acceptance).  ## Full verb catalog  All verbs return a rich `_hint`. `fusion_describe '{}'` is the machine-readable source of truth; this table is generated from it.-_55 verbs._+_78 verbs._  **Lifecycle**  - `fusion_start` - Launch Fusion 360 (if needed) and wait for the AdomBridge add-in to be ready.-- `fusion_stop` - Gracefully STOP Fusion 360: close docs cleanly + WM_CLOSE, then wait-- `fusion_kill` - Force-KILL Fusion 360 (taskkill /F) - the desperate path for when fusion_stop cannot close it (stuck modal / wedged proc+- `fusion_stop` - Gracefully STOP Fusion 360: close docs cleanly, then a native quit, then wait+- `fusion_kill` - Force-KILL Fusion 360 (SIGKILL) - the desperate path for when fusion_stop cannot close it (stuck modal / wedged proc - `fusion_close_window` - Close the active Fusion document/window. - `fusion_get_app_state` - Current app state: running, active document, workspace, isElectronics - `fusion_readiness` - FAST readiness check (does NOT launch Fusion): is the Fusion host app installed + running + the bridge ready to drive? A - `fusion_new_electronics_from_eagle` - Import a legacy EAGLE .sch (+ paired .brd) into a NEW Fusion electronics design so the parts INSTANTIATE (schematic + po-- `fusion_notify_owner` - LAST-RESORT human escalation: toast the user's MAIN computer (fans out cross-AD to every peer on the relay, so it reache+- `fusion_notify_owner` - LAST-RESORT human escalation: toast the user's MAIN computer (fans out cross-Bridge to every peer on the relay, so it reache  **Cloud search & files (APS)** @@ -307,7 +311,7 @@ _55 verbs._ - `fusion_board_info` - Raw board geometry XML (copper/arcs/lines) for the open board. - `fusion_open_lbr` - Import an EAGLE .lbr library into Fusion's Electronics LIBRARY editor (Content Manager / Electronics Library workspace), - `fusion_attach_3d_package` - Attach a real 3D chip model to a library package, end to end: opens the .lbr (library active), runs Electron.Create3DPac-- `fusion_install_fusion` - Install Fusion 360 FOR the user - downloads Autodesk's official Client Downloader and streams the free trial silently, w+- `fusion_install_fusion` - Reports install state; there is no documented silent macOS installer, so it returns `fusion_install_manual_on_macos` and the AI drives Autodesk's dmg per the fusion-onboarding skill - `fusion_generate_package` - Generate an IPC-7351-compliant parametric 3D package via Fusion's BUILT-IN ElectronicsPackageGenerator (EPG) - ~50 packa - `fusion_make_3d_package` - Create a RENDERING component 3D package (FOOTPRINT + chip, aligned) for ONE part, fully programmatically with ZERO GUI d - `fusion_build_library_3d` - Build a RENDERING multi-part 3D library in ONE call - the whole programmatic pipeline@@ -337,7 +341,7 @@ _55 verbs._  **Self** -- `fusion_describe` - Self-describe every verb the bridge exposes (this list) for AD's Verbs tab + runner.+- `fusion_describe` - Self-describe every verb the bridge exposes (this list) for Adom Bridge's Verbs tab + runner.  ## Two install layers (they are NOT the same thing) @@ -345,33 +349,33 @@ This page ships **two separate artifacts**, and it matters which one you want:  | Layer | What it is | Who installs it | Contents | Size | |---|---|---|---|---|-| **Wiki package** (`adom-wiki pkg install adom/adom-desktop-fusion-bridge`) | **SKILLS ONLY** for a container's AI | your cloud/HD container | `SKILL.md` + `skills/**` (the AI playbooks: APS, driving, onboarding, cloud hygiene, molecule export, PCB stackup) | tiny, text |-| **Release zip** (`adom-bridge-fusion-v<ver>.zip`, pointed at by `adom-bridge-fusion-manifest.json`) | the **bridge RUNTIME** | Adom Desktop, via `bridge_install` | `server.py`, `aps.py`, `describe.py`, `handlers/`, the `AdomBridge` Fusion add-in, `resources/` | ~456 KB |+| **Wiki package** (`adom-wiki pkg install adom/fusion-bridge-macos`) | **SKILLS ONLY** for a container's AI | your cloud/Hydrogen container | `SKILL.md` + `skills/**` (the AI playbooks: APS, driving, onboarding, cloud hygiene, molecule export, PCB stackup) | tiny, text |+| **Release zip** (`adom-bridge-fusion-v<ver>.zip`, pointed at by `adom-bridge-fusion-manifest.json`) | the **bridge RUNTIME** | Adom Bridge, via `bridge_install` | `server.py`, `aps.py`, `describe.py`, `handlers/`, the `AdomBridge` Fusion add-in, `resources/` | ~456 KB | -The package teaches your AI **how** to drive Fusion; the release zip is the code Adom Desktop actually+The package teaches your AI **how** to drive Fusion; the release zip is the code Adom Bridge actually runs on the machine where Fusion lives. Installing the package alone gives you skills with no bridge; `bridge_install` alone gives you a working bridge whose calling AI has no skills. Most setups want both.  The release zip is deliberately **runtime-only**: demo videos and screenshots live on this page (Files tab), never inside the artifact streamed to every user's machine. -## Install (via Adom Desktop)+## Install (via Adom Bridge)  ```bash-adom-desktop bridge_install '{"manifestUrl": "https://wiki.adom.inc/api/v1/pages/adom-desktop-fusion-bridge/files/adom-bridge-fusion-manifest.json"}'-adom-wiki pkg install adom/adom-desktop-fusion-bridge   # the skills pack for your AI+adom-bridge bridge_install '{"manifestUrl": "https://wiki.adom.inc/api/v1/pages/fusion-bridge/files/adom-bridge-fusion-manifest.json"}'+adom-wiki pkg install adom/fusion-bridge-macos   # the skills pack for your AI ``` -Auto-updates via `updateManifestUrl` (AD polls on launch + every 4h). 55 verbs -+Auto-updates via `updateManifestUrl` (Adom Bridge polls on launch + every 4h). 78 verbs - `fusion_describe '{}'` returns the full machine-readable catalog. More demos: -<video controls width="100%" src="https://wiki.adom.inc/api/v1/pages/adom-desktop-fusion-bridge/files/library2-3d-montage.mp4"></video>+<video controls width="100%" src="https://wiki.adom.inc/api/v1/pages/fusion-bridge/files/library2-3d-montage.mp4"></video>  ## Source code  The full source lives on this page (Files tab): `server.py`, `aps.py`, the AdomBridge add-in, `describe.py`, handlers, skills, and manufacturer resources. GitHub mirror:-`adom-inc/adom-desktop-fusion-bridge` (the wiki is canonical). MIT licensed.+`adom-inc/hydrogen-macos` (`plugins/fusion360/`; the wiki page is what ships). MIT licensed.  ## Platforms @@ -381,6 +385,6 @@ supported (Autodesk ships no Fusion host app for Linux). ## Contributing  Open a discussion on this page - bug reports with a repro (like-[#55](https://wiki.adom.inc/adom/adom-desktop-fusion-bridge/discussions/55) and-[#63](https://wiki.adom.inc/adom/adom-desktop-fusion-bridge/discussions/63), both root-caused and+[#55](https://wiki.adom.inc/adom/fusion-bridge/discussions/55) and+[#63](https://wiki.adom.inc/adom/fusion-bridge/discussions/63), both root-caused and fixed) directly shape releases.
SKILL.md+50−100
@@ -1,15 +1,15 @@ ----name: adom-desktop-fusion+name: adom-bridge-fusion public: true-description: "Launch and drive Fusion 360 on the user's laptop from this container via the adom-desktop CLI. Includes FAST cloud-file search via APS (Autodesk Platform Services) — search/browse/open the team's Fusion cloud designs in seconds (set up once per company, each user signs in once, never charged). Plus open .f3d/.f3z designs, open cloud files, close documents, dismiss recovery dialogs, capture Fusion window screenshots, send keys + click, run the add-in (STEP/GLB/.lbr import-export, BOM/parameters). Trigger words: fusion, Fusion 360, fast cloud search, fusion_aps_search, search fusion files, find a design, browse cloud files, fusion_aps_open, aps, open fusion, launch fusion, open design, f3d, f3z, import STEP, export STEP, export GLB, export lbr, Fusion electronics, Fusion PCB, BOM from Fusion, Fusion parameters, Fusion API, dismiss recovery, Fusion screenshot, fusion_click, fusion_send_key, fusion bridge, close fusion."+description: "Launch and drive Fusion 360 on the user's laptop from this container via the adom-bridge CLI. Includes FAST cloud-file search via APS (Autodesk Platform Services) — search/browse/open the team's Fusion cloud designs in seconds (set up once per company, each user signs in once, never charged). Plus open .f3d/.f3z designs, open cloud files, close documents, dismiss recovery dialogs, capture Fusion window screenshots, send keys + click, run the add-in (STEP/GLB/.lbr import-export, BOM/parameters). Trigger words: fusion, Fusion 360, fast cloud search, fusion_aps_search, search fusion files, find a design, browse cloud files, fusion_aps_open, aps, open fusion, launch fusion, open design, f3d, f3z, import STEP, export STEP, export GLB, export lbr, Fusion electronics, Fusion PCB, BOM from Fusion, Fusion parameters, Fusion API, dismiss recovery, Fusion screenshot, fusion_click, fusion_send_key, fusion bridge, close fusion." --- -# adom-desktop — Fusion 360 bridge+# adom-bridge — Fusion 360 bridge  All commands dispatch to the Fusion Python bridge. From this container:  ```bash-adom-desktop fusion_<action> '<json_args>'+adom-bridge fusion_<action> '<json_args>' ```  The leading `fusion_` routes to the Fusion plugin; `<action>` is the plugin-side name.@@ -24,22 +24,22 @@ Branch on the stable `errorCode`, never the prose: | `ready:true` (fusion_readiness) | Fusion up + add-in current | drive | | `running:false` / `fusion_not_running` | installed, not launched | `fusion_start` (returns when the add-in is ready, or `stillLaunching` on a slow first launch) | | `stillLaunching:true` (fusion_start) | first launch, add-in not up yet (can take 2-4 min) | do NOT re-call `fusion_start`; POLL `fusion_readiness` every ~10s until `ready:true` |-| `installed:false` / `host_app_not_installed` (AD >=1.9.79, + a `hostApp` field) | no Fusion host app | OFFER to install, then **`fusion_install_fusion`** (no shell approval; elevation-aware, streams the free trial) -> poll `fusion_readiness` (`installing:true`) until `installed:true` -> `fusion_start`. Details: [fusion-onboarding](skills/fusion-onboarding/SKILL.md) |-| `needsSignin:true` (`fusion_start` **and** `fusion_readiness`) | Fusion is running but stuck at the first-run Autodesk sign-in (main UI blocked, add-in can't serve, so `ready:false`) | AUTOMATE it (proven sequence, see [fusion-onboarding](skills/fusion-onboarding/SKILL.md)): (1) clear STALE `signin.autodesk.com` tabs (a dead tab = expired code = "Sign-in request expired"); (2) `desktop_ui_click` "Retry browser sign-in" / "Sign In" for ONE fresh request; (3) click "Open Product" with **`desktop_click` (SendInput=isTrusted)** — `desktop_ui_click` (UIA) does NOT fire the protocol; (4) on the in-page "open Autodesk Identity Manager?" overlay (NOT an owned popup) tick "Always allow" + "Open" via `desktop_click`, FAST; (5) poll `fusion_readiness`. `nbrowser` (CDP) can do 3-4 headlessly if it's on the SAME browser window. NEVER auto-enter password/2FA. To ask the user, `notify_user` works directly (AD ≥1.9.84); add a cross-AD `target` if you're on a VM |+| `installed:false` / `host_app_not_installed` (Adom Bridge >=1.9.79, + a `hostApp` field) | no Fusion host app | Install it FOR them: follow [fusion-onboarding](skills/fusion-onboarding/SKILL.md) (Autodesk dmg -> `Install Autodesk Fusion.app`) -> poll `fusion_readiness` until `installed:true` -> `fusion_start`. (`fusion_install_fusion` only reports state; there is no documented silent mac installer.) Details: [fusion-onboarding](skills/fusion-onboarding/SKILL.md) |+| `needsSignin:true` (`fusion_start` **and** `fusion_readiness`) | Fusion is running but stuck at the first-run Autodesk sign-in (main UI blocked, add-in can't serve, so `ready:false`) | AUTOMATE it (proven sequence, see [fusion-onboarding](skills/fusion-onboarding/SKILL.md)): (1) clear STALE `signin.autodesk.com` tabs (a dead tab = expired code = "Sign-in request expired"); (2) `desktop_ui_click` "Retry browser sign-in" / "Sign In" for ONE fresh request; (3) click "Open Product" with **`desktop_click` (a real CGEvent click)** — an Accessibility press (`ui_click`) is not a user gesture, so the browser blocks the protocol launch; (4) on the in-page "Open Autodesk Identity Manager?" sheet (part of the browser window, so no window-list scan will show it) tick "Always allow" + "Open" via `desktop_click`, FAST; (5) poll `fusion_readiness`. `nbrowser` (CDP) can do 3-4 headlessly if it's on the SAME browser window. NEVER auto-enter password/2FA. To ask the user, `notify_user` works directly (Adom Bridge ≥1.9.84); add a cross-Bridge `target` if you're on a VM | | `addinStale:true` / `addin_stale` | Fusion runs an OLD add-in that never re-synced (silent-failure risk) | `fusion_stop` then `fusion_start` — the bridge re-syncs the add-in from cache on start (Fusion must be CLOSED) |-| `bridge_restarting` + `stillRunning:true` (AD ≥1.9.77) | the bridge is respawning after a `bridge_install` | NEVER a not-installed/fatal signal: poll `fusion_readiness` until `ready:true`, then retry. Read-only verbs (`fusion_readiness`/`fusion_describe`/`fusion_get_app_state`) forward straight through even mid-respawn — no sleep-and-recheck hacks needed |+| `bridge_restarting` + `stillRunning:true` (Adom Bridge ≥1.9.77) | the bridge is respawning after a `bridge_install` | NEVER a not-installed/fatal signal: poll `fusion_readiness` until `ready:true`, then retry. Read-only verbs (`fusion_readiness`/`fusion_describe`/`fusion_get_app_state`) forward straight through even mid-respawn — no sleep-and-recheck hacks needed | | `blockingDialogs:[…]` | a modal is blocking the add-in | dismiss in the BACKGROUND, then the op auto-resumes | -**Runtime note:** AD **provisions Python itself** (a portable no-UAC 3.12.13 runtime if none is on PATH — the bridge never bootstraps its own; check AD's `runtimes` verb). You never install Python.+**Runtime note:** Adom Bridge **provisions Python itself** (a portable, no-admin 3.12.13 runtime if none is on PATH — the bridge never bootstraps its own; check Adom Bridge's `runtimes` verb). You never install Python.  ## The 8 conventions (from the Bridge SDK) -1. **Poll readiness, don't launch blindly.** `fusion_readiness` (or AD's `bridge_readiness`) is read-only — it reports `installed`/`running`/`ready`/`addinStale` WITHOUT launching anything. Loop: readiness → act on the row above → drive.+1. **Poll readiness, don't launch blindly.** `fusion_readiness` (or Adom Bridge's `bridge_readiness`) is read-only — it reports `installed`/`running`/`ready`/`addinStale` WITHOUT launching anything. Loop: readiness → act on the row above → drive. 2. **`fusion_readiness` is the standardized cold-start probe.** (Fusion is a detected HOST APP with no heavy download, so there's no `prewarm` step — readiness is the whole gate.) 3. **Core verbs live in the table below; `fusion_describe '{}'` is the full machine-readable catalog.** Read the table to act fast; hit `describe` for completeness — don't guess a verb.-4. **Background by default — automate first, NOTIFY only at a true wall.** This bridge drives the AI's workspace, not the user's screen: dismiss dialogs in the BACKGROUND (`fusion_close_window`, never `fusion_send_key`/Escape, which steals focus). AUTOMATE sign-in / dialogs yourself (see the proven sign-in sequence in [fusion-onboarding](skills/fusion-onboarding/SKILL.md)); reserve an AD **`notify_user`** for something only the user can do — a **UAC/elevation** prompt, a license accept, a **2FA/password** step you must not auto-fill, or a licensing **DECISION** that risks their other machine. **`notify_user` works directly over the bridge's direct API (AD ≥1.9.84) — call it, don't relay a payload for the AI to send.** When this bridge runs UNATTENDED (e.g. on a VM) and the user is elsewhere, add a cross-AD **`target`** (a peer clientName from the `targets` verb, or `"all"`) so the toast lands where they are. Only foreground Fusion to SHOW the user something. See [fusion-driving](skills/fusion-driving/SKILL.md) and [fusion-onboarding](skills/fusion-onboarding/SKILL.md).+4. **Background by default — automate first, NOTIFY only at a true wall.** This bridge drives the AI's workspace, not the user's screen: dismiss dialogs in the BACKGROUND (`fusion_close_window`, never `fusion_send_key`/Escape, which steals focus). AUTOMATE sign-in / dialogs yourself (see the proven sign-in sequence in [fusion-onboarding](skills/fusion-onboarding/SKILL.md)); reserve an Adom Bridge **`notify_user`** for something only the user can do — a **UAC/elevation** prompt, a license accept, a **2FA/password** step you must not auto-fill, or a licensing **DECISION** that risks their other machine. **`notify_user` works directly over the bridge's direct API (Adom Bridge ≥1.9.84) — call it, don't relay a payload for the AI to send.** When this bridge runs UNATTENDED (e.g. on a VM) and the user is elsewhere, add a cross-Bridge **`target`** (a peer clientName from the `targets` verb, or `"all"`) so the toast lands where they are. Only foreground Fusion to SHOW the user something. See [fusion-driving](skills/fusion-driving/SKILL.md) and [fusion-onboarding](skills/fusion-onboarding/SKILL.md). 5. **`ok:true` is not enough — verify.** A long op that "times out" at ~60s is usually STILL RUNNING server-side (the relay caps the request, not the work). Verify by artifacts (the saved file / a screenshot / `fusion_get_app_state`), don't blindly retry.-6. **Reuse the running Fusion — and when a restart IS needed, YOU do it, never the user.** Fusion is a singleton: `fusion_readiness` before `fusion_start`; if `ready`, just drive. But a stale/missing add-in or a wedged session needs a restart, and that is YOUR job — `fusion_stop` then `fusion_start`. NEVER tell the user "restart Fusion" / "enable the add-in in UTILITIES" — doing it for them is the entire point of this bridge. (Add-in installs land in ALL Fusion add-in dirs — 2025+ Fusion scans `%APPDATA%\Autodesk\FusionAddins`, older builds use `...\Autodesk Fusion[ 360]\API\AddIns` — so a restart always picks it up.)+6. **Reuse the running Fusion — and when a restart IS needed, YOU do it, never the user.** Fusion is a singleton: `fusion_readiness` before `fusion_start`; if `ready`, just drive. But a stale/missing add-in or a wedged session needs a restart, and that is YOUR job — `fusion_stop` then `fusion_start`. NEVER tell the user "restart Fusion" / "enable the add-in in UTILITIES" — doing it for them is the entire point of this bridge. (Add-in installs land in ALL Fusion add-in dirs — 2025+ Fusion scans `~/Library/Application Support/Autodesk/FusionAddins`, older builds use `~/Library/Application Support/Autodesk/Autodesk Fusion[ 360]/API/AddIns` — so a restart always picks it up.) 7. **Surface `_hint` verbatim + branch on `errorCode`.** Every verb returns an actionable `_hint`; relay it to the user unchanged and key your logic off the stable `errorCode`, not the prose. 8. **Never write files to a shared cloud ROOT.** Uploads default to an `Adom AI Workspace` folder; see [fusion-cloud-hygiene](skills/fusion-cloud-hygiene/SKILL.md). @@ -132,15 +132,21 @@ are dimmed). So:  ## Extended commands via the in-process add-in -If the Adom add-in is installed (`cd ~/project/adom-desktop/plugins/fusion360 && python install_addin.py` on the laptop), Fusion 360 exposes an additional API over its own ports. Typical extra commands proxied through the bridge:+The add-in installs itself — `server.py` runs `install_addin` on every `fusion_start`, into all+three Fusion add-in dirs. To force a reinstall, `fusion_stop` then `fusion_start`; never ask the+user to run a script. With it loaded, Fusion exposes these extra commands through the bridge:  - `fusion_import_step` — import a STEP file into the active document - `fusion_export_step` — export active body/occurrence to STEP-- `fusion_export_glb` — export to GLB (used by the 3D viewer)+- `fusion_export_optimized_glb` / `fusion_fetch_optimized_glb` — GLB for the 3D viewer - `fusion_export_lbr` — export an Eagle library (used by the Eagle workflow)-- `fusion_open_lbr` / `fusion_open_symbol` — open symbol libraries-- `fusion_command` — generic `{"command": "<fusion_api_name>", "args": {...}}` pass-through for any Fusion API call-- `fusion_list_cloud_projects`, `fusion_list_cloud_files`, `fusion_walk_cloud_tree`, `fusion_search_cloud_files`, `fusion_open_cloud_file`, `fusion_export_cloud_file` — Autodesk cloud Data API operations+- `fusion_open_lbr` — open an EAGLE library in the Electronics library editor+- `fusion_execute_text_command` / `fusion_run_modeling_script` — the generic escape hatches for+  any Fusion API call (there is no `fusion_command` verb)+- `fusion_list_cloud_projects`, `fusion_list_cloud_files`, `fusion_open_cloud_file`,+  `fusion_export_cloud_file` — Autodesk cloud Data API operations++`fusion_describe '{}'` is the machine-readable source of truth for the full list (78 verbs).  **Opening multi-design electronics files — pass `fileExtension`.** A Fusion electronics data file that links to multiple designs (common for boards with variants) makes `fusion_open_cloud_file` pop Fusion's native **"Select Electronics Design File" picker** — a CEF/Chromium modal whose list is **not keyboard- or Win32-navigable** (and screen-coord clicks are unreliable on multi-monitor/HiDPI), so it **can't be resolved headlessly**. Avoid it by opening the specific file directly: `fusion_open_cloud_file {"fileName":"<name>","fileExtension":"fbrd", ...}` (the `.fbrd` board lands straight in PCB Editor — live-confirmed). Opening the bare name or the `.fprj` project triggers the picker. If a picker still appears, `_diagnose_addin_timeout`/`blockingDialogs` will classify it (see below). @@ -149,98 +155,40 @@ If the Adom add-in is installed (`cd ~/project/adom-desktop/plugins/fusion360 && Several Fusion modals (the multi-link "Select Electronics Design File" picker, "Fusion needs to update", Document Recovery, "Save changes?") block the add-in's main thread. The bridge now **classifies them by title** and, on a blocked command, returns `blockingDialogs: [{hwnd, title, category, resolution}]` with the precise cause + fix — instead of a misleading "add-in not responding / may have crashed". So a blocked open tells you *which* modal is up and how to clear it.  Resolution notes:-- **Multi-link picker** is a **CEF/web modal whose list is NOT keyboard- or Win32-navigable** (SendInput reaches only the native Cancel/OK; screen-coord clicks are unreliable on multi-monitor/HiDPI). It currently **must be resolved on the desktop**. *Headless fix tracked separately:* have the add-in open the specific linked design via the Fusion API, avoiding the picker entirely.+- **Multi-link picker** is a **CEF/web modal whose list is NOT keyboard- or Accessibility-navigable** (synthetic clicks reaches only the native Cancel/OK; screen-coord clicks are unreliable on multi-monitor/HiDPI). It currently **must be resolved on the desktop**. *Headless fix tracked separately:* have the add-in open the specific linked design via the Fusion API, avoiding the picker entirely. - **Update nag** is reported, not auto-dismissed (auto-confirming could start an update mid-run) — clear it on the desktop; doing so also commonly resolves recurring add-in crashes (host/add-in version drift). - **Recovery** prompts: `fusion_dismiss_recovery` / `fusion_relocate_recovery`.  Check `fusion_addin_status` first — if the add-in isn't loaded, these will fail with a `_hint` pointing at the install script. -## Cloud search — defensive contract (add-in v1.0.2+)--`fusion_search_cloud_files` is the most-used long-running verb. Its v1.0.2 behavior is engineered specifically so the AI never misreports a failed search as "file not found":--| You read in the response | Mean |-|---|---|-| `searchComplete: true` + `totalFound: 0` | **Confirmed negative.** No match in the searched scope. |-| `searchComplete: true` + `totalFound: N` | All matches returned. |-| `searchComplete: false` (any reason) | **Search stopped early.** May or may not be more matches. Do NOT say "not found" to the user. Re-run with broader caps OR narrower `folderPath`. |--`searchComplete` is `true` ONLY when every one of these is clean: not `folderLimitReached`, not result-`truncated`, not `searchTimedOut`, `foldersSkipped == 0`, `filesSkipped == 0`. Five conditions, all five must pass.--### Performance + the slow-search etiquette--`fusion_search_cloud_files` runs at ~1 folder/sec because Autodesk's free Fusion 360 Python API has no indexed search endpoint — it walks the cloud Data API one folder at a time (30+ min on a real hub). **⚠️ Prefer `fusion_aps_search` instead** (see the APS section at the top) — it uses Autodesk Platform Services' server-side index and returns in **seconds**. This legacy walk verb remains only as a fallback for when APS isn't set up; if a user is hitting slow searches, set up APS (`fusion_aps_status` → its `_hint`) rather than tuning the walk.--**Before firing a broad search**, ask the user which subfolder is likely. Naming a folder like "Molecules" cuts 5-40 min searches down to ~10s. The verb's response includes a `costAnalysis` block (`foldersPerSecond`, `estimatedSecondsPer100Folders`) so the AI can budget realistically.--### Streaming progress+## Cloud search — use APS, the walk verbs are DISABLED -For interactive sessions, wrap long searches in `watch` so the AI gets one JSON-line progress event per `interval` seconds:+`fusion_search_cloud_files` and `fusion_walk_cloud_tree` are **hard-blocked in the bridge** and+return an error: the in-add-in folder walk took 30+ minutes and crashed Fusion. There is no+fallback. Use **`fusion_aps_search {query}`** (server-indexed, seconds, works without Fusion+running) and `fusion_aps_open` — see the APS section above and the `fusion-aps-search` skill. -```bash-adom-desktop watch '{-  "command": "fusion_search_cloud_files",-  "args": {-    "query": "cosmiic",-    "projectName": "Main",-    "folderPath": "Molecules",-    "recursive": true,-    "maxFolders": 300,-    "maxDepth": 10,-    "searchTimeout": 340,-    "timeout": 400-  },-  "interval": 3-}'-```--Output:-```-{"event":"started", ...}-{"event":"progress", "foldersVisited": 12, "filesFound": 1, "elapsedSeconds": 15.1, "currentFolder": "Molecules/COSMIIC", ...}-{"event":"progress", "foldersVisited": 173, "filesFound": 3, "elapsedSeconds": 168.3, ...}-{"event":"complete", "result": {... full response with searchComplete:true ...}}-```--The `watch` wrapper composes with the `Monitor` tool — each stdout line becomes a notification.--### Args (no hard upper caps in v1.0.2+)--| Arg | Default | Notes |-|---|---|---|-| `query` | (required) | Substring of file name. **Case-insensitive both directions.** |-| `projectName` | active | Cloud project name. |-| `folderPath` | project root | Starting subfolder. **NARROW HERE — biggest perf lever.** |-| `recursive` | `false` | Descend into subfolders. |-| `maxDepth` | 2 | Recursion depth cap. |-| `maxFolders` | 10 | Folder-visit cap. |-| `maxResults` | 20 | Result cap. |-| `folderTimeout` | 30s | Per-folder cloud-API timeout. Bridge skips slow folders. |-| `searchTimeout` | 120s | Overall wall-clock timeout. Set 300+ for big walks. |-| `timeout` | 620s | HTTP envelope timeout (CLI+direct API). Bump if `searchTimeout` > 180. |--Real-world live test: `Main/Molecules` recursive depth-10 cosmiic search hit 173 folders in 168s with `searchComplete:true, totalFound:3, foldersSkipped:0, filesSkipped:0`. Fusion stayed `main_thread: responsive` throughout.+> The CLI `watch` streaming wrapper only ever accepted those two verbs, so it is dead for this+> bridge too. Long APS/export work reports progress through `statusVerb: fusion_get_app_state`+> instead — poll it rather than blocking.  ## Quick examples  ```bash # Launch Fusion-adom-desktop fusion_start '{}'+adom-bridge fusion_start '{}'  # Open a local design-adom-desktop fusion_open_design '{"path":"/Users/<user>/designs/board.f3d"}'+adom-bridge fusion_open_design '{"path":"/Users/<user>/designs/board.f3d"}'  # Screenshot all Fusion windows-adom-desktop fusion_screenshot_all '{}'+adom-bridge fusion_screenshot_all '{}' -# Run a Fusion API command (add-in required)-adom-desktop fusion_command '{-  "command":"export_step",-  "args":{"occurrence":"body1","output":"/tmp/part.step"}-}'+# Run arbitrary Fusion API work (add-in required)+adom-bridge fusion_run_modeling_script '{"script":"<adsk.fusion python>"}'  # Check add-in health-adom-desktop fusion_addin_status '{}'+adom-bridge fusion_addin_status '{}' ```  ## Error shape@@ -251,27 +199,27 @@ Every failing response includes a `_hint` field. Surface it verbatim when a Fusi  Earlier versions used hardcoded port `8773` for the bridge and `8774` for the in-process add-in. **v1.8.31 made the bridge use OS-assigned ephemeral ports.** The add-in port is still 8774 (it's inside Fusion's process and the manifest pins it), but that's an internal detail. -- The CLI (`adom-desktop fusion_*`) routes through adom-desktop's direct API → the bridge's runtime port. No callers need port numbers.+- The CLI (`adom-bridge fusion_*`) routes through adom-bridge's direct API → the bridge's runtime port. No callers need port numbers. - The add-in v1.0.2 ships a stale-lock watchdog in `http_server.py`: if a command holds the main-thread lock longer than `per_command_timeout + 30s` (e.g. Fusion's native cloud SDK wedges on a slow API call), the watchdog force-releases so subsequent commands work without restarting Fusion. The wedged command is orphaned but no longer blocks everything else. - The `searchComplete` contract (see above) prevents false-negative reporting on capped/skipped searches. Always check `data.searchComplete` before telling the user "file not found".  ## How this bridge is packaged + delivered (3 artifacts) -This bridge is ONE wiki page (`wiki.adom.inc/adom/adom-desktop-fusion-bridge`) that ships **three things**:+This bridge is ONE wiki page (`wiki.adom.inc/adom/fusion-bridge-macos`) that ships **three things**:  1. **The page git repo** — the ONE source of truth (all source, `skills/`, the docs, `page.json`, and the    bridge manifest). Edit + push here.-2. **The Release zip + the bridge manifest** (`adom-bridge-fusion-manifest.json`) — what **adom-desktop**-   consumes on `bridge_install`: the manifest tells adom-desktop who this bridge is (name, version, the+2. **The Release zip + the bridge manifest** (`adom-bridge-fusion-manifest.json`) — what **adom-bridge**+   consumes on `bridge_install`: the manifest tells adom-bridge who this bridge is (name, version, the    Release-zip URL, sha256, size, verb prefixes, health), and it streams that zip into its bridge cache.-3. **The adom-wiki skills pkg** (`adom-wiki pkg install adom/adom-desktop-fusion-bridge`) — **skills only**.+3. **The adom-wiki skills pkg** (`adom-wiki pkg install adom/fusion-bridge-macos`) — **skills only**.    It deploys these skills into a container's `~/.claude/skills/` so the AI knows how to drive this bridge    and Fusion. -**Install handshake:** when an AI has adom-desktop install this bridge, adom-desktop installs the Release+**Install handshake:** when an AI has adom-bridge install this bridge, adom-bridge installs the Release AND tells the AI to `adom-wiki pkg install` this pkg — so the container gets all these skills. An AI can also install the pkg itself; then the skills **auto-update** via the pkg mechanism (the goal). Full detail-+ the publish ritual + the hero-relink reminder: the **`fusion-bridge-dev`** skill.++ the publish ritual + the hero-relink reminder: the **`fusion-bridge-dev`** skill (`dev-skills/` in the source tree — not shipped in the user pkg).  ## Related @@ -279,14 +227,16 @@ also install the pkg itself; then the skills **auto-update** via the pkg mechani - **`fusion-aps-search`** + **`fusion-aps-signin`** — APS fast-search reasoning + the AI-driven one-time setup (bundled in this repo's `skills/`). - **`fusion-mcp-and-preferences`** — Autodesk's local Fusion MCP server (`127.0.0.1:27182`, proxied by the `fusion_mcp_*` verbs) + changing any Fusion preference. On macOS the enable toggle is a one-time manual step (the skill covers it); the client verbs are cross-platform. - **`fusion-web-export`** — STEP/STL/OBJ out of a Fusion CLOUD design with no desktop app (APS Model Derivative or a pup-driven Fusion Team export) — the path on Linux/containers.-- `adom-desktop-kicad` — sibling bridge for KiCad.-- `adom-desktop-direct-api` — the direct API contract that callers route through.-- **Canonical repo:** the wiki page `https://wiki.adom.inc/adom/adom-desktop-fusion-bridge` (+ GitHub backup `adom-inc/adom-desktop-fusion-bridge`). The old `adom-inc/adom-desktop/plugins/fusion360/` is a stale seed.+- `adom-bridge-kicad` — sibling bridge for KiCad.+- `adom-bridge-direct-api` — the direct API contract that callers route through.+- **Canonical repo:** the wiki page `https://wiki.adom.inc/adom/fusion-bridge-macos`; source of truth for the mac line is `adom-inc/hydrogen-macos` → `plugins/fusion360/`.  ## Quick demo on first install (sample library included)  The repo ships a ready sample so you can prove the bridge end to end right after installing:-`examples/ADS8588SIPM.fusion.lbr` (a real 4-sided LQFP-64 library) + `examples/ADS8588SIPM.step` (its 3D).+`ADS8588SIPM.fusion.lbr` (a real 4-sided LQFP-64 library) + `ADS8588SIPM.step` (its 3D). They are+**page assets**, not payload — download them from this page's Files tab (or `adom-wiki repo clone`)+onto the machine running Fusion; neither the skills package nor the release zip carries them.  1. Download both from this page's Files tab (or `adom-wiki repo clone`) onto this machine    (send_files if they were produced elsewhere).
VERBS.md+1456−265
@@ -1,39 +1,40 @@ # Fusion bridge - verb reference  Every `fusion_*` verb this bridge exposes, generated from the bridge's own self-describe-(`describe.py` / `fusion_describe`) so it never drifts. Call as:+(`describe.py` / `fusion_describe`) by `tools/gen_verbs_md.py`. Regenerate it on every+publish; do not hand-edit. Call a verb as:  ```-adom-desktop fusion_<verb> '<input json>'+adom-bridge fusion_<verb> '<input json>' ```  `input` / `output` below are the SCHEMA (field -> type/notes); `example` is a real input.-`timeoutSeconds` is AD's wait; `longRunning` verbs keep working after a timeout - poll `statusVerb`.+`timeoutSeconds` is Adom Bridge's wait; `longRunning` verbs keep working after a timeout - poll+`statusVerb`. -## Verbs by group +_78 verbs._ -**Lifecycle:** `fusion_start` `fusion_stop` `fusion_kill` `fusion_close_window` `fusion_get_app_state` -**Cloud search & files (APS):** `fusion_aps_status` `fusion_aps_set_client_id` `fusion_aps_signin` `fusion_aps_search` `fusion_aps_open` `fusion_open_by_urn` `fusion_aps_browse` `fusion_aps_recent` `fusion_aps_file_info` `fusion_aps_versions` `fusion_aps_download` `fusion_aps_upload` `fusion_aps_create_folder` `fusion_aps_get` `fusion_walk_cloud_tree` `fusion_search_cloud_files` -**Electronics:** `fusion_show_schematic` `fusion_show_2d_board` `fusion_show_3d_board` `fusion_board_info` `fusion_open_lbr` `fusion_run_modeling_script` -**CAD & 3D export:** `fusion_export_step` `fusion_export_iges` `fusion_export_stl` `fusion_export_3mf` `fusion_export_usdz` `fusion_export_obj` `fusion_export_dxf` `fusion_export_dwg` -**Manufacturing:** `fusion_export_gerbers` `fusion_export_bom` `fusion_export_cpl` `fusion_set_design_rules` `fusion_load_design_rules` `fusion_detect_layers` `fusion_dismiss_blocking_dialogs` `fusion_electron_run` `fusion_electron_zoom` `fusion_electron_pan` `fusion_electron_select` -**Self-describe:** `fusion_describe` +## Index ----+`fusion_start` `fusion_stop` `fusion_kill` `fusion_close_window` `fusion_get_app_state` `fusion_readiness` `fusion_new_electronics_from_eagle` `fusion_notify_owner` `fusion_signin` `fusion_mcp_status` `fusion_mcp_enable` `fusion_mcp_tools` `fusion_mcp_call` `fusion_mcp_resources` `fusion_prefs_open` `fusion_prefs_close` `fusion_set_auto_update` `fusion_signin_2fa` `fusion_demo` `fusion_aps_status` `fusion_aps_set_client_id` `fusion_aps_signin` `fusion_aps_set_browser` `fusion_aps_get_browser` `fusion_aps_forget_browser` `fusion_aps_search` `fusion_aps_open` `fusion_open_by_urn` `fusion_aps_browse` `fusion_aps_recent` `fusion_aps_file_info` `fusion_aps_versions` `fusion_aps_download` `fusion_aps_upload` `fusion_aps_create_folder` `fusion_aps_get` `fusion_walk_cloud_tree` `fusion_search_cloud_files` `fusion_show_schematic` `fusion_show_2d_board` `fusion_show_3d_board` `fusion_board_info` `fusion_open_lbr` `fusion_attach_3d_package` `fusion_install_fusion` `fusion_generate_package` `fusion_make_3d_package` `fusion_build_library_3d` `fusion_capture_library_views` `fusion_cleanup_cloud_files` `fusion_run_modeling_script` `fusion_assembly_bom` `fusion_physical_properties` `fusion_set_preference` `fusion_get_preferences` `fusion_export_step` `fusion_export_iges` `fusion_export_stl` `fusion_export_3mf` `fusion_export_usdz` `fusion_export_optimized_glb` `fusion_fetch_optimized_glb` `fusion_board_stackup` `fusion_export_obj` `fusion_export_dxf` `fusion_export_dwg` `fusion_export_gerbers` `fusion_export_bom` `fusion_export_cpl` `fusion_set_design_rules` `fusion_load_design_rules` `fusion_detect_layers` `fusion_dismiss_blocking_dialogs` `fusion_electron_run` `fusion_electron_zoom` `fusion_electron_pan` `fusion_electron_select` `fusion_describe` -## Lifecycle+---  ### `fusion_start`  Launch Fusion 360 (if needed) and wait for the AdomBridge add-in to be ready. -**Input** `{}`+**Input** (schema):++```json+{}+```  **Example call:**  ```-adom-desktop fusion_start '{}'+adom-bridge fusion_start '{}' ```  **Output** (shape):@@ -46,11 +47,13 @@ adom-desktop fusion_start '{}' } ``` -_timeout 150s · long-running (poll `fusion_get_app_state`)_+_timeout 150s_ · _long-running_++**If the relay cuts it:** The launch outlives the cut. Poll fusion_readiness; do NOT launch again.  ### `fusion_stop` -Gracefully STOP Fusion 360: close docs cleanly + WM_CLOSE, then wait. NO force-kill - the clean opposite of fusion_start. If a window will not close it returns failure; use fusion_kill then.+Gracefully STOP Fusion 360: close docs cleanly + background window close, then wait. NO force-kill - the clean opposite of fusion_start. If a window will not close it returns failure; use fusion_kill then.  **Input** (schema): @@ -63,7 +66,7 @@ Gracefully STOP Fusion 360: close docs cleanly + WM_CLOSE, then wait. NO force-k **Example call:**  ```-adom-desktop fusion_stop '{}'+adom-bridge fusion_stop '{}' ```  **Output** (shape):@@ -77,9 +80,11 @@ adom-desktop fusion_stop '{}'  _timeout 60s_ +**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.+ ### `fusion_kill` -Force-KILL Fusion 360 (taskkill /F) - the desperate path for when fusion_stop cannot close it (stuck modal / wedged process). Closes docs cleanly first when reachable.+Force-KILL Fusion 360 (SIGKILL) - the desperate path for when fusion_stop cannot close it (stuck modal / wedged process). Closes docs cleanly first when reachable.  **Input** (schema): @@ -92,7 +97,7 @@ Force-KILL Fusion 360 (taskkill /F) - the desperate path for when fusion_stop ca **Example call:**  ```-adom-desktop fusion_kill '{}'+adom-bridge fusion_kill '{}' ```  **Output** (shape):@@ -106,6 +111,8 @@ adom-desktop fusion_kill '{}'  _timeout 30s_ +**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.+ ### `fusion_close_window`  Close the active Fusion document/window.@@ -121,7 +128,7 @@ Close the active Fusion document/window. **Example call:**  ```-adom-desktop fusion_close_window '{}'+adom-bridge fusion_close_window '{}' ```  **Output** (shape):@@ -134,16 +141,22 @@ adom-desktop fusion_close_window '{}'  _timeout 30s_ +**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.+ ### `fusion_get_app_state` -Current app state: running, active document, workspace, isElectronics. The poll/status verb for long-running calls.+Current app state: running, active document, workspace, isElectronics. NOT a progress reporter: it returns app state, not whether your long call finished. While a long verb holds Fusion's main thread EVERY other verb (including this one) returns errorCode main_thread_busy with busyCommand + elapsedSeconds - that error is the progress signal, and it clearing means the long call is done. Each verb's onTimeout says what to check.++**Input** (schema): -**Input** `{}`+```json+{}+```  **Example call:**  ```-adom-desktop fusion_get_app_state '{}'+adom-bridge fusion_get_app_state '{}' ```  **Output** (shape):@@ -158,162 +171,1202 @@ adom-desktop fusion_get_app_state '{}'  _timeout 20s_ -## Cloud search & files (APS)+**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing. -### `fusion_aps_status`+### `fusion_readiness` -APS state: configured, signed in, token live, never-charge meter.+FAST readiness check (does NOT launch Fusion): is the Fusion host app installed + running + the bridge ready to drive? Adom Bridge DETECTS Fusion (never installs it) via bridge.json 'detect', and auto-installs Python if missing (Adom Bridge >=1.9.47). Call this before driving Fusion; if installed-but-not-running, fusion_start. SELF-HEALS the seat/licensing dialog (background Accessibility + screenshot-verify) whenever it detects one. Pairs with Adom Bridge's bridge_readiness. -**Input** `{}`+**Input** (schema):++```json+{}+```  **Example call:**  ```-adom-desktop fusion_aps_status '{}'+adom-bridge fusion_readiness '{}' ```  **Output** (shape):  ```json {-  "configured": "bool",-  "signedIn": "bool",-  "neverCharge": "bool"+  "installed": "bool",+  "running": "bool",+  "ready": "bool",+  "hostApp": "str",+  "bridgeVersion": "str" } ``` -_timeout 20s_+_timeout 15s_ -### `fusion_aps_set_client_id`+**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing. -Set the org's APS (PKCE) client id used for cloud search.+### `fusion_new_electronics_from_eagle`++Import a legacy EAGLE .sch (+ paired .brd) into a NEW Fusion electronics design so the parts INSTANTIATE (schematic + populated board, lands in the PCB editor). The ONLY way to author a board from EAGLE source: Document.newDesignFromLocal opens the schematic editor but does NOT instantiate parts, and the Fusion-native .fsch/.fbrd container is opaque binary you can't build offline. This fires Fusion's own ImportSCHAndBRDCmd and drives BOTH native Open dialogs (the .sch then the .brd) in the BACKGROUND via desktop_ui_click by accessible name (no foreground). Stage both files onto this machine first (send_files). After: fusion_show_2d_board, RATSNEST + 'AUTO ;' to autoroute, fusion_show_3d_board for 3D.  **Input** (schema):  ```json {-  "clientId": "required str"+  "schPath": "required str (local path to .sch)",+  "brdPath": "optional str (defaults to sibling .brd)" } ```  **Example call:**  ```-adom-desktop fusion_aps_set_client_id '{"clientId": "D5nn...EPAq"}'+adom-bridge fusion_new_electronics_from_eagle '{"schPath": "/Users/me/adom-lib/MyBoard.sch", "brdPath": "/Users/me/adom-lib/MyBoard.brd"}' ```  **Output** (shape):  ```json {-  "success": "bool"+  "success": "bool",+  "imported": "list"+}+```++_timeout 200s_++**If the relay cuts it:** The import continues. Check activeDocument before re-importing.++### `fusion_notify_owner`++LAST-RESORT human escalation: toast the user's MAIN computer (fans out cross-Bridge to every peer on the relay, so it reaches them even when this bridge runs on an unattended VM). ONLY for true human walls - password/2FA entry, UAC elevation, a physical step. Exhaust programmatic options first (Accessibility background clicks, seat auto-resolve, warm-SSO sign-in). After sending, WAIT and poll fusion_readiness; do not re-toast within a few minutes.++**Input** (schema):++```json+{+  "title": "optional str",+  "body": "required str",+  "level": "optional str info|warning|error"+}+```++**Example call:**++```+adom-bridge fusion_notify_owner '{"title": "Fusion needs you", "body": "Please complete the Autodesk 2FA prompt on winvm - everything else is done."}'+```++**Output** (shape):++```json+{+  "success": "bool",+  "targets": "list" } ```  _timeout 20s_ -### `fusion_aps_signin`+**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.++### `fusion_signin`++Sign Fusion in through the CORRECT browser profile - the fix for Fusion's dumb OAuth that fires at the OS-DEFAULT browser and lands in the wrong Autodesk account. Fusion opens its sign-in in whatever browser is default (e.g. a personal Chrome), but a user's Autodesk seat often lives in a different profile (work). This verb reads the FULL authorize URL (client_id/PKCE/state/request_id) that Fusion wrote into that wrong browser's HISTORY and re-opens it in the RIGHT profile IN THE BACKGROUND; the URL completes back to the running Fusion via the idmgr/callback + autodesk:// handoff, so the browser no longer has to be the OS default. Pass {profile:'chrome:[email protected]'} to fix + remember your Autodesk profile; else it probes each profile for a live Autodesk session (or asks). Staged: if Fusion hasn't opened the browser yet it returns stage:'click_signin' so you click Fusion's Sign In first. BEST: pass {auto:true} to run the WHOLE chain in ONE server-side call - it clicks Fusion's Sign In, polls the browser history on-box for the fresh authorize URL, and re-opens it in the target profile, all without extra remote round-trips, so it fits inside Fusion's ~2-min OAuth request expiry even on a slow/flaky relay (the manual staged path is the fallback). Fusion's request EXPIRES in ~2 min, so a stale captured URL returns stage:'stale' - restart Fusion (fusion_stop/start) for a fresh request and retry auto PROMPTLY. See the 'fusion-multiprofile-signin' skill.++**Input** (schema):++```json+{+  "profile": "optional str (chrome:<email>/edge:<email> - the profile your Autodesk account is in; remembered)",+  "auto": "optional bool (do click+capture+reopen in one on-box call - recommended)",+  "waitSec": "optional int (server-side poll budget for the fresh URL, default 32)"+}+```++**Example call:**++```+adom-bridge fusion_signin '{}'+```++**Output** (shape):++```json+{+  "stage": "str",+  "done": "bool",+  "signinWhere": "str",+  "signinProfile": "str",+  "signinProfileReason": "str",+  "signinWrongBrowser": "str",+  "signinAuthUrl": "str",+  "signinOpenedVia": "str (extension|extension_free)",+  "signinWall": "str|null (twofactor_email_code|credentials|protocol_handoff)",+  "notifyDelivered": "bool",+  "signinWallHint": "str|null",+  "narrate": "str"+}+```++_timeout 120s_ · _long-running_++**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.++### `fusion_mcp_status`++Is Autodesk's Fusion MCP server up, and what does it expose? Autodesk + Anthropic ship a LOCAL MCP server at http://127.0.0.1:27182/mcp exposing Fusion's own text-to-CAD surface (read geometry, execute/update features, read Electronics design data). It binds LOOPBACK on the user's machine and was built for Claude Desktop running there, so a CLOUD AI cannot reach it at all - this bridge runs on that machine and proxies it for you. Returns enabled, serverInfo and the live tool list. OFF by default: if it reports enabled:false, call fusion_mcp_enable and the bridge turns it on for the user.++**Input** (schema):++```json+{}+```++**Example call:**++```+adom-bridge fusion_mcp_status '{}'+```++**Output** (shape):++```json+{+  "enabled": "bool",+  "serverInfo": "obj",+  "toolCount": "int",+  "tools": "[{name,description}]"+}+```++_timeout 45s_++**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.++### `fusion_mcp_enable`++Turn Autodesk's Fusion MCP server ON by driving Fusion's Preferences dialog for the user. Autodesk exposes NO API for this toggle, so the UI is the only route: this opens Preferences (Commands.Start PreferencesCommand), expands General, selects API, ticks 'Fusion MCP Server (runs locally on this device)', then clicks Apply and OK. Needs Fusion running; briefly uses the foreground and announces why with an on-screen caption. NEVER ask the user to do this by hand first - do it for them, then tell them it is handled. Note the setting is DISCARDED if Fusion is killed or restarted before Apply is clicked.++**Input** (schema):++```json+{}+```++**Example call:**++```+adom-bridge fusion_mcp_enable '{}'+```++**Output** (shape):++```json+{+  "enabled": "bool",+  "alreadyOn": "bool",+  "steps": "list",+  "serverInfo": "obj"+}+```++_timeout 180s_ · _long-running_++**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.++### `fusion_mcp_tools`++Full tool list from Autodesk's Fusion MCP server INCLUDING input schemas, so you can construct a valid fusion_mcp_call. These are Autodesk's tools, not this bridge's.++**Input** (schema):++```json+{}+```++**Example call:** -Open the Autodesk sign-in in the browser; a background listener captures the token.+```+adom-bridge fusion_mcp_tools '{}'+```++**Output** (shape):++```json+{+  "count": "int",+  "tools": "list"+}+```++_timeout 45s_++**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.++### `fusion_mcp_call`++Call any tool on Autodesk's Fusion MCP server (fusion_mcp_read, fusion_mcp_update, fusion_mcp_execute, fusion_mcp_electronics_read). The bridge handles the MCP streamable-HTTP handshake for you (initialize -> MCP-Session-Id -> notifications/initialized) and re-establishes a dropped session automatically. MCP acts on the ACTIVE Fusion document, so open one first. PREFER a native fusion_* verb when one exists - they are tested here and return richer hints - and reach for MCP for Autodesk's text-to-CAD surface.++**Input** (schema):++```json+{+  "tool": "required str (from fusion_mcp_tools)",+  "arguments": "optional obj (per that tool's inputSchema)",+  "timeout": "optional int seconds, default 120"+}+```++**Example call:**++```+adom-bridge fusion_mcp_call '{"tool": "fusion_mcp_read", "arguments": {"queryType": "summary"}}'+```++**Output** (shape):++```json+{+  "result": "obj",+  "tool": "str"+}+```++_timeout 150s_ · _long-running_++**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.++### `fusion_mcp_resources`++List Autodesk MCP resources, or read one by uri. These are mostly the Electronics entity schemas (resource://mcp.electronics_schema_*) that describe what fusion_mcp_electronics_read can return.++**Input** (schema):++```json+{+  "uri": "optional str (omit to list)"+}+```++**Example call:**++```+adom-bridge fusion_mcp_resources '{}'+```++**Output** (shape):++```json+{+  "count": "int",+  "resources": "[str]",+  "result": "obj"+}+```++_timeout 60s_++**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.++### `fusion_prefs_open`++Open Fusion's Preferences dialog and optionally jump to a section, then hand back a SCREENSHOT + shotId you can click in. This is how you reach ANY Fusion preference: the Python API exposes only a thin slice (theme/orbit/units, debuggingPort, developer tools) and everything else, including the MCP server toggle, is UI-only. Sections: general, api, design, manufacture, electronics, render, drawing, material, graphics, network, preview features. Child sections under General are lazily rendered by Qt and never appear in the Accessibility tree, which is why this returns an image to click rather than control names. ALWAYS finish with fusion_prefs_close {save:true} - nothing is saved otherwise, and killing/restarting Fusion first discards the change.++**Input** (schema):++```json+{+  "section": "optional str (see knownSections in the response)"+}+```++**Example call:**++```+adom-bridge fusion_prefs_open '{"section": "api"}'+```++**Output** (shape):++```json+{+  "hwnd": "int",+  "shotId": "str",+  "screenshot": "str",+  "knownSections": "[str]",+  "steps": "list"+}+```++_timeout 120s_ · _long-running_++**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.++### `fusion_prefs_close`++Apply+OK (save:true, the default) or Cancel Fusion's Preferences dialog. Settings changed via fusion_prefs_open are NOT persisted until this is called with save:true.++**Input** (schema):++```json+{+  "save": "optional bool, default true"+}+```++**Example call:**++```+adom-bridge fusion_prefs_close '{"save": true}'+```++**Output** (shape):++```json+{+  "closed": "bool",+  "saved": "bool"+}+```++_timeout 60s_++**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.++### `fusion_set_auto_update`++Turn AUTOMATIC Fusion updating on/off for this user. ON BY DEFAULT, and deliberately INVISIBLE: Fusion ships updates constantly and nags with an 'Update Now / Update Later' panel plus a '14 days until Fusion must update' countdown. Every fusion_readiness call checks for that offer and, if present, the bridge clicks it IN THE BACKGROUND (Accessibility, no foreground, no caption) so the download starts and the newer build comes up on the next launch. The user should never have to click it. Call with no args to read the current setting; {enabled:false} opts out and the choice is STICKY (~/.adom/fusion-bridge/prefs.json) - once a user opts out, NEVER click their update prompts again. Tell the user this is handled for them rather than asking them to update.++**Input** (schema):++```json+{+  "enabled": "optional bool (omit to read current value)"+}+```++**Example call:**++```+adom-bridge fusion_set_auto_update '{"enabled": true}'+```++**Output** (shape):++```json+{+  "autoUpdateFusion": "bool",+  "narrate": "str"+}+```++_timeout 30s_ · _long-running_++**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.++### `fusion_signin_2fa`++Submit Autodesk's emailed 6-DIGIT verification code to finish a Fusion sign-in, typed IN THE BACKGROUND (Accessibility set-value + Invoke - never steals the user's foreground or moves their cursor). Exists so you can finish a login END TO END for the user instead of parking them on a 2FA screen: if `adom-google` is available in your container, read the code out of their Gmail (`adom-google gmail search 'from:autodesk verification code' --limit 1`), pull the 6 digits, and call this. If adom-google is NOT installed, tell the user that installing it would let you automate logins like this, then let them type it. NEVER ask the user for a code you could read yourself. The bridge ALSO toasts the user's desktop whenever it hits a human wall, so you do not need to ask it to.++**Input** (schema):++```json+{+  "code": "required str (the 6 digits; non-digits are stripped)",+  "hwnd": "optional int (the 2FA window; auto-detected)"+}+```++**Example call:**++```+adom-bridge fusion_signin_2fa '{"code": "123456"}'+```++**Output** (shape):++```json+{+  "submitted": "bool",+  "steps": "list",+  "narrate": "str"+}+```++_timeout 90s_ · _long-running_++**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.++### `fusion_demo`++FIRST-TIME-USER DEMO in one verb - the thing to run when someone new wants to SEE what this bridge does (Hydrogen's installer calls this). Takes them from nothing to a real board: launches Fusion, FINISHES the Autodesk sign-in - it OPENS the sign-in in the user's NATIVE browser IN THE BACKGROUND (never interrupting their work) and returns signinWhere/signinProfile/signinSession so you can tell them exactly where it is waiting, then offer three paths: they finish it, you foreground it, or (with their OK) you drive it. Native browser via NBE/nbrowser_* because that profile is already signed into Autodesk - never pup, which is anonymous, sets up APS cloud search (or explains it if declined) and runs a LIVE sample search so they see 2-second results, then opens an electronics PROJECT and walks SCHEMATIC -> 2D BOARD -> 3D BOARD, screenshotting each view to show them. STAGED + RESUMABLE: every call advances as far as it safely can and returns stage/done/narrate/screenshots plus a _hint with the exact next action; keep calling it until done:true. NEVER leave a first-time user parked on the sign-in screen - that is the failure this verb exists to prevent. See the 'fusion-demo' skill.++**Input** (schema):++```json+{+  "query": "optional str (design to demo; else picked from APS search)",+  "stage": "optional str ('skip_aps' to proceed without cloud search)"+}+```++**Example call:**++```+adom-bridge fusion_demo '{}'+```++**Output** (shape):++```json+{+  "stage": "str",+  "done": "bool",+  "narrate": "str",+  "screenshots": "[{label,path}]",+  "steps": "[str]",+  "apsSampleSearch": "[{name,project}]"+}+```++_timeout 240s_ · _long-running_++**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.++### `fusion_aps_status`++APS state: configured, signed in, token live, never-charge meter.++**Input** (schema):++```json+{}+```++**Example call:**++```+adom-bridge fusion_aps_status '{}'+```++**Output** (shape):++```json+{+  "configured": "bool",+  "signedIn": "bool",+  "neverCharge": "bool"+}+```++_timeout 20s_++**If the relay cuts it:** The APS call completes server-side; re-read state with fusion_aps_status / _browse.++### `fusion_aps_set_client_id`++Set the org's APS (PKCE) client id used for cloud search.++**Input** (schema):++```json+{+  "clientId": "required str"+}+```++**Example call:**++```+adom-bridge fusion_aps_set_client_id '{"clientId": "D5nn...EPAq"}'+```++**Output** (shape):++```json+{+  "success": "bool"+}+```++_timeout 20s_++**If the relay cuts it:** The APS call completes server-side; re-read state with fusion_aps_status / _browse.++### `fusion_aps_signin`++Open the Autodesk sign-in in the REMEMBERED browser+profile (not the OS default); a background listener captures the token. Pass {exe,profileDir,name} to use+remember a specific browser, or {allowDefaultBrowser:true} to fall back to the OS default. If nothing is remembered, returns needsExtensionOpen so the caller opens authUrl in the user's real browser via nbrowser_open_window.++**Input** (schema):++```json+{+  "exe": "optional str (browser binary to launch+remember)",+  "profileDir": "optional str (e.g. 'Default','Profile 2')",+  "name": "optional str",+  "allowDefaultBrowser": "optional bool"+}+```++**Example call:**++```+adom-bridge fusion_aps_signin '{}'+```++**Output** (shape):++```json+{+  "success": "bool",+  "authUrl": "str",+  "openedVia": "str",+  "needsExtensionOpen": "bool"+}+```++_timeout 30s_++**If the relay cuts it:** The APS call completes server-side; re-read state with fusion_aps_status / _browse.++### `fusion_aps_set_browser`++Remember the browser+profile that authed to Autodesk so every later sign-in reuses it (power users have many browsers/profiles; the OS default is usually the wrong one). Call after a driven sign-in succeeds.++**Input** (schema):++```json+{+  "name": "optional str",+  "exe": "str (browser binary) OR how:'extension'",+  "profileDir": "optional str",+  "how": "optional 'extension'|'launch'"+}+```++**Example call:**++```+adom-bridge fusion_aps_set_browser '{"name": "Chrome", "exe": "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome", "profileDir": "Default"}'+```++**Output** (shape):++```json+{+  "success": "bool",+  "browser": "{name,exe,profileDir}"+}+```++_timeout 10s_++**If the relay cuts it:** The APS call completes server-side; re-read state with fusion_aps_status / _browse.++### `fusion_aps_get_browser`++Show the remembered Autodesk sign-in browser (None until set).++**Input** (schema):++```json+{}+```++**Example call:**++```+adom-bridge fusion_aps_get_browser '{}'+```++**Output** (shape):++```json+{+  "success": "bool",+  "browser": "{name,exe,profileDir}|null"+}+```++_timeout 10s_++**If the relay cuts it:** The APS call completes server-side; re-read state with fusion_aps_status / _browse.++### `fusion_aps_forget_browser`++Forget the remembered Autodesk sign-in browser (re-detect next time).++**Input** (schema):++```json+{}+```++**Example call:**++```+adom-bridge fusion_aps_forget_browser '{}'+```++**Output** (shape):++```json+{+  "success": "bool",+  "cleared": "bool"+}+```++_timeout 10s_++**If the relay cuts it:** The APS call completes server-side; re-read state with fusion_aps_status / _browse.++### `fusion_aps_search`++Server-indexed search across the whole team hub (seconds, not a 30-min folder walk).++**Input** (schema):++```json+{+  "query": "required str",+  "limit": "optional int (default 50)",+  "hubId": "optional str",+  "projectId": "optional str"+}+```++**Example call:**++```+adom-bridge fusion_aps_search '{"query": "Molecule", "limit": 10}'+```++**Output** (shape):++```json+{+  "count": "int",+  "results": "[{name,id,projectName,lastModified}]"+}+```++_timeout 60s_++**If the relay cuts it:** The APS call completes server-side; re-read state with fusion_aps_status / _browse.++### `fusion_aps_open`++Find a cloud design by name and open it in Fusion (any folder depth). Fire-and-poll.++**Input** (schema):++```json+{+  "query": "required str",+  "wait": "optional bool"+}+```++**Example call:**++```+adom-bridge fusion_aps_open '{"query": "BME690 Molecule"}'+```++**Output** (shape):++```json+{+  "opening": "bool",+  "match": "{name}",+  "statusVerb": "str"+}+```++_timeout 60s_ · _long-running_++**If the relay cuts it:** The APS call completes server-side; re-read state with fusion_aps_status / _browse.++### `fusion_open_by_urn`++Open a cloud ELECTRONICS DESIGN by URN. PCB/ELECTRONICS NAV RULE: a board is NOT a standalone file - the schematic, 2D board and 3D board are VIEWS inside ONE electronics DESIGN. Open the DESIGN document first (fusion_open_cloud_file or fusion_open_by_urn), THEN switch to its schematic and its 2D board (fusion_show_2d_board) and 3D board (fusion_show_3d_board). A Select-Electronics-Design-File picker IS that design list of its schematic + board. An EMPTY 2D board usually means you opened a derivative or the wrong file, or it is out of sync - reopen the parent electronics DESIGN and switch to its board view; do NOT open a .brd or .sch as a standalone file.++**Input** (schema):++```json+{+  "urn": "required str"+}+```++**Example call:**++```+adom-bridge fusion_open_by_urn '{"urn": "urn:adsk.wipprod:fs.file:vf.xxxx?version=1"}'+```++**Output** (shape):++```json+{+  "success": "bool",+  "output": "str"+}+```++_timeout 240s_ · _long-running_++**If the relay cuts it:** Fusion may already be opening the document. Check fusion_get_app_state's activeDocument BEFORE re-opening or you get a duplicate window.++### `fusion_aps_browse`++Browse hubs/projects/folders without launching Fusion.++**Input** (schema):++```json+{+  "hubId": "optional str",+  "projectId": "optional str",+  "folderId": "optional str"+}+```++**Example call:**++```+adom-bridge fusion_aps_browse '{}'+```++**Output** (shape):++```json+{+  "items": "[{name,type,id}]"+}+```++_timeout 60s_++**If the relay cuts it:** The APS call completes server-side; re-read state with fusion_aps_status / _browse.++### `fusion_aps_recent`++Most-recently-modified designs across the team hub, newest first.++**Input** (schema):++```json+{+  "limit": "optional int (default 25)"+}+```++**Example call:**++```+adom-bridge fusion_aps_recent '{"limit": 25}'+```++**Output** (shape):++```json+{+  "count": "int",+  "results": "[...]"+}+```++_timeout 60s_++**If the relay cuts it:** The APS call completes server-side; re-read state with fusion_aps_status / _browse.++### `fusion_aps_file_info`++Version history + who/when/size for a file (tip + recent versions).++**Input** (schema):++```json+{+  "query": "str  OR  projectId+urn"+}+```++**Example call:**++```+adom-bridge fusion_aps_file_info '{"query": "BME690 Molecule"}'+```++**Output** (shape):++```json+{+  "versionCount": "int",+  "tip": "{...}",+  "versions": "[...]"+}+```++_timeout 40s_++**If the relay cuts it:** The APS call completes server-side; re-read state with fusion_aps_status / _browse.++### `fusion_aps_versions`++Full (uncapped) version history of a file.++**Input** (schema):++```json+{+  "query": "str  OR  projectId+urn"+}+```++**Example call:**++```+adom-bridge fusion_aps_versions '{"query": "BME690 Molecule"}'+```++**Output** (shape):++```json+{+  "versionCount": "int",+  "versions": "[...]"+}+```++_timeout 40s_++**If the relay cuts it:** The APS call completes server-side; re-read state with fusion_aps_status / _browse.++### `fusion_aps_download`++Download a cloud file to the local machine (no Fusion needed).++**Input** (schema):++```json+{+  "query": "str OR projectId+urn",+  "saveDir": "optional str",+  "fileName": "optional str"+}+```++**Example call:**++```+adom-bridge fusion_aps_download '{"query": "BME690 Molecule"}'+```++**Output** (shape):++```json+{+  "path": "str",+  "bytes": "int"+}+```++_timeout 90s_++**If the relay cuts it:** The download continues in the bridge process. Check the target path first.++### `fusion_aps_upload`++Upload a local file as a NEW cloud file (free Data Management; needs data:write scope). ⛔ FOLDER HYGIENE: NEVER pass a project ROOT folderId - the bridge REFUSES it (refused_root_upload). Loose files in a shared root clutter the team's cloud. Create/choose a real subfolder first (fusion_aps_create_folder under an 'Adom AI Workspace' folder), or just use fusion_make_3d_package / fusion_build_library_3d which auto-target a non-root workspace. To RELOCATE an existing file, MOVE it (preserves its urn) - do NOT delete + re-upload (mints a new urn, breaks 3D bindings). See the fusion-cloud-hygiene skill.++**Input** (schema):++```json+{+  "projectId": "required str",+  "folderId": "required str (NON-ROOT subfolder)",+  "localPath": "required str",+  "fileName": "optional str"+}+```++**Example call:**++```+adom-bridge fusion_aps_upload '{"projectId": "a.YnVz...", "folderId": "urn:...", "localPath": "/tmp/x.f3d"}'+```++**Output** (shape):++```json+{+  "itemUrn": "str",+  "bytes": "int"+}+```++_timeout 90s_++**If the relay cuts it:** The upload continues and may have created the cloud file. Nothing refuses a retry - this verb is not serialized - so fusion_aps_browse the target folder BEFORE retrying or you WILL upload twice.++### `fusion_aps_create_folder`++Create a subfolder in a project (free; needs data:create scope). Use this to make an 'Adom AI Workspace' folder + per-task subfolders so the bridge never dumps loose files in the shared project root. See fusion-cloud-hygiene.++**Input** (schema):++```json+{+  "projectId": "required str",+  "parentFolderId": "required str",+  "name": "required str"+}+```++**Example call:**++```+adom-bridge fusion_aps_create_folder '{"projectId": "a.YnVz...", "parentFolderId": "urn:...", "name": "Adom AI Workspace"}'+```++**Output** (shape):++```json+{+  "folderId": "str"+}+```++_timeout 50s_++**If the relay cuts it:** The APS call completes server-side; re-read state with fusion_aps_status / _browse.++### `fusion_aps_get`++Raw authenticated GET against a free APS path (dev/verify helper).++**Input** (schema):++```json+{+  "path": "required str"+}+```++**Example call:**++```+adom-bridge fusion_aps_get '{"path": "/project/v1/hubs"}'+```++**Output** (shape):++```json+{+  "status": "int",+  "body": "obj"+}+```++_timeout 40s_++**If the relay cuts it:** The APS call completes server-side; re-read state with fusion_aps_status / _browse.++### `fusion_walk_cloud_tree`++⛔ DISABLED (returns an error): the in-app add-in walk took 30+ min and CRASHED Fusion (WinError 10054). It is hard-blocked in the bridge. Use fusion_aps_search / fusion_aps_open. See the 'fusion-aps-search' skill.++**Input** (schema):++```json+{}+```++**Example call:**++```+adom-bridge fusion_walk_cloud_tree '{}'+```++**Output** (shape):++```json+{+  "disabled": "bool"+}+```++_timeout 15s_++**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.++### `fusion_search_cloud_files`++⛔ DISABLED (returns an error): the in-app add-in search took 30+ min and CRASHED Fusion (WinError 10054). It is hard-blocked in the bridge. Use fusion_aps_search {query} — server-indexed, seconds, no Fusion. See the 'fusion-aps-search' skill.++**Input** (schema):++```json+{+  "query": "required str"+}+```++**Example call:**++```+adom-bridge fusion_search_cloud_files '{"query": "Molecule"}'+```++**Output** (shape):++```json+{+  "disabled": "bool"+}+```++_timeout 15s_++**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.++### `fusion_show_schematic`++Switch the OPEN electronics design to its SCHEMATIC view (the symmetric partner of fusion_show_2d_board / fusion_show_3d_board, via Fusion's SwitchSchDocCmd). A VIEW of the project, not a standalone file. Drive it for demos with fusion_electron_zoom / _pan / _select.++**Input** (schema):++```json+{}+```++**Example call:**++```+adom-bridge fusion_show_schematic '{}'+```++**Output** (shape):++```json+{+  "success": "bool",+  "activeWorkspace": "str",+  "productType": "str"+}+```++_timeout 70s_ · _long-running_++**If the relay cuts it:** The view switch completes. Re-read fusion_get_app_state rather than re-issuing.++### `fusion_show_2d_board`++Switch the OPEN electronics design to its 2D PCB Editor (board layout) view. This is a VIEW of the project, not a file to open standalone - if the board is empty, you opened a child/derivative instead of the EcadDesignProductType PROJECT; reopen the project. Drive the view with fusion_electron_run WINDOW commands.++**Input** (schema): -**Input** `{}`+```json+{}+```  **Example call:**  ```-adom-desktop fusion_aps_signin '{}'+adom-bridge fusion_show_2d_board '{}' ```  **Output** (shape):  ```json {-  "success": "bool",-  "authUrl": "str"+  "activeWorkspace": "str" } ``` -_timeout 30s_+_timeout 70s_ · _long-running_ -### `fusion_aps_search`+**If the relay cuts it:** The view switch completes. Re-read fusion_get_app_state rather than re-issuing. -Server-indexed search across the whole team hub (seconds, not a 30-min folder walk).+### `fusion_show_3d_board`++Switch the OPEN electronics design to its 3D PCB view (populated board). A VIEW of the project, not a standalone file. Orbit it for demos via fusion_run_modeling_script (app.activeViewport.camera + vp.refresh()).  **Input** (schema):  ```json-{-  "query": "required str",-  "limit": "optional int (default 50)",-  "hubId": "optional str",-  "projectId": "optional str"-}+{} ```  **Example call:**  ```-adom-desktop fusion_aps_search '{"query": "Molecule", "limit": 10}'+adom-bridge fusion_show_3d_board '{}' ```  **Output** (shape):  ```json {-  "count": "int",-  "results": "[{name,id,projectName,lastModified}]"+  "activeWorkspace": "str",+  "screenshots": "[...]" } ``` -_timeout 60s_+_timeout 70s_ · _long-running_ -### `fusion_aps_open`+**If the relay cuts it:** The view switch completes. Re-read fusion_get_app_state rather than re-issuing. -Find a cloud design by name and open it in Fusion (any folder depth). Fire-and-poll.+### `fusion_board_info`++Raw board geometry XML (copper/arcs/lines) for the open board.  **Input** (schema):  ```json-{-  "query": "required str",-  "wait": "optional bool"-}+{} ```  **Example call:**  ```-adom-desktop fusion_aps_open '{"query": "BME690 Molecule"}'+adom-bridge fusion_board_info '{}' ```  **Output** (shape):  ```json {-  "opening": "bool",-  "match": "{name}",-  "statusVerb": "str"+  "rawXml": "str" } ``` -_timeout 60s · long-running (poll `fusion_get_app_state`)_+_timeout 60s_ -### `fusion_open_by_urn`+**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing. -Open a cloud ELECTRONICS DESIGN by URN. PCB/ELECTRONICS NAV RULE: a board is NOT a standalone file - the schematic, 2D board and 3D board are VIEWS inside ONE electronics DESIGN. Open the DESIGN document first (fusion_open_cloud_file or fusion_open_by_urn), THEN switch to its schematic and its 2D board (fusion_show_2d_board) and 3D board (fusion_show_3d_board). A Select-Electronics-Design-File picker IS that design list of its schematic + board. An EMPTY 2D board usually means you opened a derivative or the wrong file, or it is out of sync - reopen the parent electronics DESIGN and switch to its board view; do NOT open a .brd or .sch as a standalone file.+### `fusion_open_lbr`++Import an EAGLE .lbr library into Fusion's Electronics LIBRARY editor (Content Manager / Electronics Library workspace), not a PCB design. PITFALL: filePath MUST be a path local to THIS machine. If the .lbr was produced elsewhere (e.g. the chip-fetcher/adom-lbr pipeline in a cloud container), STAGE it onto this machine first (send_files), then pass the local path. PITFALL: an adom-lbr .lbr is 2D ONLY - symbol + footprint + a PLACEHOLDER 3D package; the real 3D chip is NOT attached (that needs a Fusion cloud URN). To attach the 3D, see the 'fusion-libraries' skill. Pass verify:true to round-trip-confirm Fusion parsed the deviceset, then check fusion_get_app_state (activeWorkspace 'Electronics Library').  **Input** (schema):  ```json {-  "urn": "required str"+  "filePath": "required str (.lbr local path; stage onto this machine first)",+  "symbolName": "optional str",+  "verify": "optional bool" } ```  **Example call:**  ```-adom-desktop fusion_open_by_urn '{"urn": "urn:adsk.wipprod:fs.file:vf.xxxx?version=1"}'+adom-bridge fusion_open_lbr '{"filePath": "/Users/<user>/adom-lib/nRF54L15.lbr"}' ```  **Output** (shape):@@ -321,460 +1374,534 @@ adom-desktop fusion_open_by_urn '{"urn": "urn:adsk.wipprod:fs.file:vf.xxxx?versi ```json {   "success": "bool",-  "output": "str"+  "postOpenScreenshot": "{savedTo}" } ``` -_timeout 240s · long-running (poll `fusion_get_app_state`)_+_timeout 50s_++**If the relay cuts it:** Fusion may already be opening the document. Check fusion_get_app_state's activeDocument BEFORE re-opening or you get a duplicate window. -### `fusion_aps_browse`+### `fusion_attach_3d_package` -Browse hubs/projects/folders without launching Fusion.+Attach a real 3D chip model to a library package, end to end: opens the .lbr (library active), runs Electron.Create3DPackage to enter the Package3DEnvironment showing the footprint, imports the STEP + auto-orients it flat on the footprint, then executes Package3DStop (FINISH). This BINDS the 3D onto the deviceset (Content Manager shows the 3D nested under the package; the Packages 'Package' column flips Placeholder->part-name). ONE desktop-side step remains: Fusion pops a modal Save dialog (an OWNED popup) - the response _hint gives the exact desktop_ui_click to confirm it. AFTER: re-grab desktop_screenshot_window and check ownedPopupCount for errors; the 3D preview LAGS a beat before showing the real chip. Both paths (filePath/modelPath) are WINDOWS paths - stage from the container first.  **Input** (schema):  ```json {-  "hubId": "optional str",-  "projectId": "optional str",-  "folderId": "optional str"+  "filePath": "required str (.lbr local path)",+  "modelPath": "required str (.step local path)",+  "packageName": "optional str" } ```  **Example call:**  ```-adom-desktop fusion_aps_browse '{}'+adom-bridge fusion_attach_3d_package '{"filePath": "/Users/<user>/adom-lib/ADS8588SIPM.fusion.lbr", "modelPath": "/Users/<user>/adom-lib/ADS8588SIPM.step", "packageName": "ADS8588SIPM"}' ```  **Output** (shape):  ```json {-  "items": "[{name,type,id}]"+  "success": "bool",+  "savePending": "bool",+  "data": "{steps}",+  "_hint": "the Save-dialog click + verify steps" } ``` -_timeout 60s_+_timeout 240s_ · _long-running_ -### `fusion_aps_recent`+**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing. -Most-recently-modified designs across the team hub, newest first.+### `fusion_install_fusion`++Reports whether Fusion is already installed, and otherwise returns errorCode fusion_install_manual_on_macos: Autodesk publishes NO documented silent-install switches for the mac streamer, so this bridge does not pretend to have one. The INSTALL IS STILL THE AI'S JOB - follow the fusion-onboarding skill (curl the Fusion Client Downloader dmg, hdiutil attach, open 'Install Autodesk Fusion.app', poll fusion_readiness until installed:true). Declared as detect.installVerb so Adom Bridge's bridge_readiness points here.  **Input** (schema):  ```json-{-  "limit": "optional int (default 25)"-}+{} ```  **Example call:**  ```-adom-desktop fusion_aps_recent '{"limit": 25}'+adom-bridge fusion_install_fusion '{}' ```  **Output** (shape):  ```json {-  "count": "int",-  "results": "[...]"+  "success": "bool",+  "alreadyInstalled": "bool?",+  "errorCode": "fusion_install_manual_on_macos?",+  "_hint": "str" } ``` -_timeout 60s_+_timeout 90s_ -### `fusion_aps_file_info`+**If the relay cuts it:** No automated mac install path — see the fusion-onboarding skill. -Version history + who/when/size for a file (tip + recent versions).+### `fusion_generate_package`++Generate an IPC-7351-compliant parametric 3D package via Fusion's BUILT-IN ElectronicsPackageGenerator (EPG) - ~50 package families (chip/soic/qfn/qfp/bga/sot23/dfn/melf/ecap/crystal/headers/...), each a few seconds, ZERO GUI. Optionally LASER-ETCH a marking (MPN / '103') into the body top as REAL cut geometry (survives STEP), and export STEP in the same call - the royalty-free, license-clean path to a whole component library (our own generated output, not vendor models). Proven live: 0603 + '103' etch + STEP in ~2s.  **Input** (schema):  ```json {-  "query": "str  OR  projectId+urn"+  "type": "required str (EPG family, e.g. chip|soic|qfn|qfp|bga|sot23|dfn2|melf|ecap|crystal|header_straight - see supportedTypes in the error for the full list)",+  "params": "optional dict (generator dims in MM by default, e.g. chip: {D,E,A,L,L1}; soic: {A,A1,b,D,E,E1,e,L,DPins}; omitted keys use EPG defaults)",+  "unitsCm": "optional bool (params already EPG-native cm)",+  "etch": "optional str (marking text on the chip top: MPN / '103'; multi-line with newline, e.g. MPN+variant - laid along the LONGEST face axis)",+  "etchStyle": "optional str raised|engraved (default raised = thin WHITE positive extrude, silkscreen-style contrast; engraved = sunken cut)",+  "etchDepthMm": "optional float (marking height/depth, default 0.03)",+  "etchHeightMm": "optional float (text height; default auto-fit: top-5%-band face, 10% margin, width-aware)",+  "outputStep": "optional str (WINDOWS path; exports STEP incl. the marking)" } ```  **Example call:**  ```-adom-desktop fusion_aps_file_info '{"query": "BME690 Molecule"}'+adom-bridge fusion_generate_package '{"type": "chip", "params": {"D": 1.6, "E": 0.8, "A": 0.45, "L": 0.3, "L1": 0.3}, "etch": "103", "outputStep": "/tmp/ADOM-R0603-103.step"}' ```  **Output** (shape):  ```json {-  "versionCount": "int",-  "tip": "{...}",-  "versions": "[...]"+  "success": "bool",+  "bodies": "[{name,vol}]",+  "etched": "str|null",+  "stepPath": "str|null",+  "manifest": "obj (settings+why+bboxes; also written as <step>.manifest.json sidecar for marking refreshes)",+  "manifestPath": "str|null",+  "epgDir": "str" } ``` -_timeout 40s_+_timeout 120s_ · _long-running_ -### `fusion_aps_versions`+**If the relay cuts it:** Keeps running; check outputStep on disk before re-running. -Full (uncapped) version history of a file.+### `fusion_make_3d_package`++Create a RENDERING component 3D package (FOOTPRINT + chip, aligned) for ONE part, fully programmatically with ZERO GUI dialogs. Opens the .lbr, runs Electron.Create3DPackage to load the package's footprint into a generator doc, imports the STEP onto it, orients it flat, saveAs an .f3d (skips the FINISH Save dialog + the two unbeatable 'Fusion360' CEF modals), uploads the f3d via APS, and returns an fs.file:vf wip_urn to hand-write into the library's <packages3d>. projectId/folderId default to the MAIN-project upload folder. Pass captureLabel to also get a BEFORE (footprint) + AFTER (chip placed) screenshot. PITFALL: a RAW STEP upload binds but renders NOTHING ('Thumbnail download failed') - this verb makes an f3d, which renders. Prefer fusion_build_library_3d for many parts.  **Input** (schema):  ```json {-  "query": "str  OR  projectId+urn"+  "lbrPath": "required str (.lbr WINDOWS path; its FIRST package's footprint is loaded)",+  "modelPath": "required str (.step WINDOWS path)",+  "projectId": "optional str (default MAIN-project)",+  "folderId": "optional str (default upload folder)",+  "fileName": "optional str",+  "captureLabel": "optional str (capture before/after)",+  "orient": "optional bool (default true)" } ```  **Example call:**  ```-adom-desktop fusion_aps_versions '{"query": "BME690 Molecule"}'+adom-bridge fusion_make_3d_package '{"lbrPath": "/tmp/newlib/R_4k7.lbr", "modelPath": "/tmp/newlib/R_4k7.step", "captureLabel": "R_4k7"}' ```  **Output** (shape):  ```json {-  "versionCount": "int",-  "versions": "[...]"+  "success": "bool",+  "wip_urn": "str",+  "dims_mm": "[x,y,z]",+  "f3d": "str",+  "before": "str|null",+  "after": "str|null" } ``` -_timeout 40s_+_timeout 200s_ · _long-running_ -### `fusion_aps_download`+**If the relay cuts it:** Keeps running; poll for main_thread_busy to clear, then check the output. -Download a cloud file to the local machine (no Fusion needed).+### `fusion_build_library_3d`++Build a RENDERING multi-part 3D library in ONE call - the whole programmatic pipeline. For each part it makes the footprint+chip f3d package (no GUI dialogs, optional before/after screenshots) and collects the wip_urn, then injects ALL bindings into the combined .lbr in one pass (no hand XML surgery) and opens the finished library once. This is the verb for a basic-parts sampler / any many-part library; it replaces the per-part make_3d_package loop + manual binding. projectId/folderId default to the MAIN-project upload folder. Each part is independent, so re-run just the failed parts if Fusion resets mid-run.  **Input** (schema):  ```json {-  "query": "str OR projectId+urn",-  "saveDir": "optional str",-  "fileName": "optional str"+  "lbrPath": "required str (combined .lbr WINDOWS path to bind + open)",+  "parts": "required [{package, lbrPath (per-part footprint .lbr), modelPath (.step)}]",+  "outLbrPath": "optional str (default: overwrite lbrPath)",+  "capture": "optional bool (default true)",+  "projectId": "optional str",+  "folderId": "optional str",+  "openWhenDone": "optional bool (default true)" } ```  **Example call:**  ```-adom-desktop fusion_aps_download '{"query": "BME690 Molecule"}'+adom-bridge fusion_build_library_3d '{"lbrPath": "/tmp/newlib/AdomBasicParts2.lbr", "parts": [{"package": "R_4k7", "lbrPath": "/tmp/newlib/R_4k7.lbr", "modelPath": "/tmp/newlib/R_4k7.step"}]}' ```  **Output** (shape):  ```json {-  "path": "str",-  "bytes": "int"+  "success": "bool",+  "boundLbr": "str",+  "partsBound": "int",+  "partsTotal": "int",+  "parts": "[{package,success,wip_urn,dims_mm,error}]",+  "screenshots": "[{package,stage,path}]",+  "opened": "bool" } ``` -_timeout 90s_+_timeout 1800s_ · _long-running_ -### `fusion_aps_upload`+**If the relay cuts it:** Runs for many minutes and keeps going. Poll with any cheap verb: while it holds the main thread you get main_thread_busy; when that clears it is done.++### `fusion_capture_library_views` -Upload a local file as a NEW cloud file (free Data Management; needs data:write scope).+Capture the LIBRARY-EDITOR views EEs trust: the schematic SYMBOL (full pinout), the FOOTPRINT (pads + layer stack), and the COMPONENT/device view (Content Manager: symbol + the package table with the footprint<->package Mapped check + pin/pad counts). The 3D before/after shots don't show these. Requires the .lbr OPEN in the Electronics Library workspace (fusion_open_lbr first). Runs EDIT <pkg>.sym/.pac/.dev + WINDOW FIT + a background hwnd screenshot per view; returns the PNG paths on the box (/tmp/conduit-screenshots - pull with desktop_pull_file). EDIT uses the DEVICESET name (e.g. ESP32-S3FN8).  **Input** (schema):  ```json {-  "projectId": "required str",-  "folderId": "required str",-  "localPath": "required str",-  "fileName": "optional str"+  "packages": "required [<deviceset name>] (or 'package': single name)",+  "views": "optional subset of ['component','symbol','footprint'] (default all)",+  "settle": "optional float secs after each EDIT before capture (default 1.5; raise if a shot shows the PREVIOUS part)" } ```  **Example call:**  ```-adom-desktop fusion_aps_upload '{"projectId": "a.YnVz...", "folderId": "urn:...", "localPath": "C:/x.f3d"}'+adom-bridge fusion_capture_library_views '{"packages": ["ESP32-S3FN8", "ATSAMD51J20A-AUT"]}' ```  **Output** (shape):  ```json {-  "itemUrn": "str",-  "bytes": "int"+  "success": "bool",+  "captured": "[{package,view,path,ok}]" } ``` -_timeout 90s_+_timeout 300s_ · _long-running_ -### `fusion_aps_create_folder`+**If the relay cuts it:** Keeps running; poll for main_thread_busy to clear, then read the shots. -Create a subfolder in a project (free; needs data:create scope).+### `fusion_cleanup_cloud_files`++PRECISELY delete a list of cloud files by lineage urn - SAFE cleanup of AI-created clutter. Deletes ONLY the exact fileIds given (never name-guessing), so it can't touch a teammate's file in a shared folder. Loops server-side. Get the ids from fusion_aps_browse (item .id). Use this to remove f3d files the bridge created. A big list takes minutes (relay may time out at ~60s while deletes continue server-side - re-browse to confirm).  **Input** (schema):  ```json {-  "projectId": "required str",-  "parentFolderId": "required str",-  "name": "required str"+  "fileIds": "required [<lineage urn>]",+  "projectName": "optional str (default active project)",+  "folderPath": "optional str (default root - where the files live)" } ```  **Example call:**  ```-adom-desktop fusion_aps_create_folder '{"projectId": "a.YnVz...", "parentFolderId": "urn:...", "name": "new-folder"}'+adom-bridge fusion_cleanup_cloud_files '{"fileIds": ["urn:adsk.wipprod:dm.lineage:abc123"], "projectName": "Adom"}' ```  **Output** (shape):  ```json {-  "folderId": "str"+  "success": "bool",+  "deletedCount": "int",+  "failedCount": "int",+  "failed": "[{fileId,error}]" } ``` -_timeout 50s_+_timeout 60s_ · _long-running_ -### `fusion_aps_get`+**If the relay cuts it:** Deletes continue server-side after the ~60s relay cut — fusion_aps_browse to confirm rather than re-issuing. -Raw authenticated GET against a free APS path (dev/verify helper).+### `fusion_run_modeling_script`++Run an adsk.fusion modeling script in the live session (sketches/extrudes/params). Free programmatic CAD.  **Input** (schema):  ```json {-  "path": "required str"+  "script": "required str (Python using adsk; globals: adsk, app, ui, design)" } ```  **Example call:**  ```-adom-desktop fusion_aps_get '{"path": "/project/v1/hubs"}'+adom-bridge fusion_run_modeling_script '{"script": "import adsk.fusion\n# ...build geometry..."}' ```  **Output** (shape):  ```json {-  "status": "int",-  "body": "obj"+  "result": "obj",+  "documentName": "str" } ``` -_timeout 40s_+_timeout 180s_ · _long-running_ -### `fusion_walk_cloud_tree`+**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing. -DO NOT USE: slow in-app add-in walk (30+ min) that CAN CRASH Fusion (WinError 10054). Use fusion_aps_search instead; see the 'fusion-aps-search' skill.+### `fusion_assembly_bom` -**Input** `{}`+Structured, kit-aware MECHANICAL bill of materials for the active Design assembly (the counterpart to the electronics-only fusion_export_bom). Recurses organizational subassemblies but counts a physical part or a purchased kit/unit ONCE, so hardware modeled inside a kit (a '... with fasteners' bracket, a bearing/pulley) is NOT double-counted the way a flat allOccurrences walk counts it. Matches Fusion's Manage -> BOM quantities. Optionally writes a CSV.++**Input** (schema):++```json+{+  "treatAsUnit": "optional [str] name substrings counted as one unit (default ['with fasteners'])",+  "exclude": "optional [str] top-level name prefixes to skip",+  "includePhysicalProperties": "optional bool (adds volume_cm3/mass_kg per line)",+  "outputPath": "optional str (local CSV path)"+}+```  **Example call:**  ```-adom-desktop fusion_walk_cloud_tree '{}'+adom-bridge fusion_assembly_bom '{"treatAsUnit": ["with fasteners"], "includePhysicalProperties": true}' ```  **Output** (shape):  ```json {-  "tree": "obj"+  "success": "bool",+  "design": "str",+  "partCount": "int",+  "totalInstances": "int",+  "parts": "[{componentName, partNumber, description, material, quantity, bodies}]" } ``` -_timeout 600s · long-running (poll `fusion_get_app_state`)_+_timeout 120s_ -### `fusion_search_cloud_files`+**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.++### `fusion_physical_properties` -DO NOT USE: slow in-app add-in search (30+ min) that CAN CRASH Fusion (WinError 10054). Use fusion_aps_search instead; see the 'fusion-aps-search' skill.+Per-component physical properties (volume cm3, mass kg, density, area, center of mass) for the active design. Reads them directly so BOM/costing tools no longer have to run getPhysicalProperties inside a modeling script. Pass names to scope to specific components.  **Input** (schema):  ```json {-  "query": "required str"+  "names": "optional [str] component names to measure (default all)",+  "accuracy": "optional low|medium|high|veryhigh (default low)" } ```  **Example call:**  ```-adom-desktop fusion_search_cloud_files '{"query": "Molecule"}'+adom-bridge fusion_physical_properties '{"accuracy": "low"}' ```  **Output** (shape):  ```json {-  "results": "[...]"+  "success": "bool",+  "count": "int",+  "properties": "{name: {volume_cm3, mass_kg, density, area_cm2, center_of_mass}}" } ``` -_timeout 180s · long-running (poll `fusion_get_app_state`)_+_timeout 120s_ -## Electronics+**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing. -### `fusion_show_schematic`+### `fusion_set_preference` -Switch the OPEN electronics design to its SCHEMATIC view (the symmetric partner of fusion_show_2d_board / fusion_show_3d_board, via Fusion's SwitchSchDocCmd). A VIEW of the project, not a standalone file. Drive it for demos with fusion_electron_zoom / _pan / _select.+Set Fusion appearance/navigation preferences in the LIVE session - applies immediately, NO restart. Keys: theme (light/darkblue/darkgray/classic/device/dark; some builds only ship LightGray/DarkBlue/Device, failures reported per-key), invertScrollZoom (bool - mouse scroll/zoom direction), orbitScheme (fusion360/alias/inventor/solidworks/tinkercad/powermill), modelingOrientation (yup/zup), gestureNav (bool), cameraPivot (bool), lengthUnit (mm/cm/m/in/ft - active design). Per-key outcome in `applied`, resulting state in `current`.++**Input** (schema): -**Input** `{}`+```json+{+  "theme": "optional str",+  "invertScrollZoom": "optional bool",+  "orbitScheme": "optional str",+  "modelingOrientation": "optional str",+  "gestureNav": "optional bool",+  "cameraPivot": "optional bool",+  "lengthUnit": "optional str"+}+```  **Example call:**  ```-adom-desktop fusion_show_schematic '{}'+adom-bridge fusion_set_preference '{"theme": "dark"}' ```  **Output** (shape):  ```json {-  "success": "bool",-  "activeWorkspace": "str",-  "productType": "str"+  "applied": "obj",+  "current": "obj" } ``` -_timeout 70s · long-running (poll `fusion_get_app_state`)_+_timeout 30s_ · _long-running_ -### `fusion_show_2d_board`+**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing. -Switch the OPEN electronics design to its 2D PCB Editor (board layout) view. This is a VIEW of the project, not a file to open standalone - if the board is empty, you opened a child/derivative instead of the EcadDesignProductType PROJECT; reopen the project. Drive the view with fusion_electron_run WINDOW commands.+### `fusion_get_preferences`++Read current Fusion appearance/navigation preferences (theme, activeTheme, invertScrollZoom, orbitScheme, modelingOrientation, gestureNav, cameraPivot, lengthUnit) as friendly values - the same keys fusion_set_preference accepts.++**Input** (schema): -**Input** `{}`+```json+{}+```  **Example call:**  ```-adom-desktop fusion_show_2d_board '{}'+adom-bridge fusion_get_preferences '{}' ```  **Output** (shape):  ```json {-  "activeWorkspace": "str"+  "current": "obj" } ``` -_timeout 70s · long-running (poll `fusion_get_app_state`)_--### `fusion_show_3d_board`--Switch the OPEN electronics design to its 3D PCB view (populated board). A VIEW of the project, not a standalone file. Orbit it for demos via fusion_run_modeling_script (app.activeViewport.camera + vp.refresh()).+_timeout 20s_ -**Input** `{}`+**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing. -**Example call:**+### `fusion_export_step` -```-adom-desktop fusion_show_3d_board '{}'-```+Export the active design to STEP (needs the 3D view). -**Output** (shape):+**Input** (schema):  ```json {-  "activeWorkspace": "str",-  "screenshots": "[...]"+  "outputPath": "required str" } ``` -_timeout 70s · long-running (poll `fusion_get_app_state`)_--### `fusion_board_info`--Raw board geometry XML (copper/arcs/lines) for the open board.--**Input** `{}`- **Example call:**  ```-adom-desktop fusion_board_info '{}'+adom-bridge fusion_export_step '{"outputPath": "/tmp/out/board.step"}' ```  **Output** (shape):  ```json {-  "rawXml": "str"+  "format": "str",+  "fileSizeKB": "int" } ``` -_timeout 60s_+_timeout 300s_ · _long-running_ -### `fusion_open_lbr`+**If the relay cuts it:** The export completes server-side. Check the output path BEFORE re-running; re-exporting is safe but wasteful, and overwrites.++### `fusion_export_iges` -Import an EAGLE .lbr library into Fusion's Electronics library editor.+Export to IGES.  **Input** (schema):  ```json {-  "filePath": "required str (.lbr on the machine)",-  "symbolName": "optional str",-  "verify": "optional bool"+  "outputPath": "required str" } ```  **Example call:**  ```-adom-desktop fusion_open_lbr '{"filePath": "C:/libs/nRF52840-CKAA.lbr"}'+adom-bridge fusion_export_iges '{"outputPath": "/tmp/out/board.iges"}' ```  **Output** (shape):  ```json {-  "success": "bool",-  "postOpenScreenshot": "{savedTo}"+  "format": "str" } ``` -_timeout 50s_+_timeout 300s_ · _long-running_ -### `fusion_run_modeling_script`+**If the relay cuts it:** The export completes server-side. Check the output path BEFORE re-running; re-exporting is safe but wasteful, and overwrites. -Run an adsk.fusion modeling script in the live session (sketches/extrudes/params). Free programmatic CAD.+### `fusion_export_stl`++Export to STL mesh.  **Input** (schema):  ```json {-  "script": "required str (Python using adsk; globals: adsk, app, ui, design)"+  "outputPath": "required str" } ```  **Example call:**  ```-adom-desktop fusion_run_modeling_script '{"script": "import adsk.fusion\n# ...build geometry..."}'+adom-bridge fusion_export_stl '{"outputPath": "/tmp/out/part.stl"}' ```  **Output** (shape):  ```json {-  "result": "obj",-  "documentName": "str"+  "format": "str" } ``` -_timeout 180s · long-running (poll `fusion_get_app_state`)_+_timeout 300s_ · _long-running_ -## CAD & 3D export+**If the relay cuts it:** The export completes server-side. Check the output path BEFORE re-running; re-exporting is safe but wasteful, and overwrites. -### `fusion_export_step`+### `fusion_export_3mf` -Export the active design to STEP (needs the 3D view).+Export to 3MF mesh.  **Input** (schema): @@ -787,23 +1914,24 @@ Export the active design to STEP (needs the 3D view). **Example call:**  ```-adom-desktop fusion_export_step '{"outputPath": "C:/out/board.step"}'+adom-bridge fusion_export_3mf '{"outputPath": "/tmp/out/part.3mf"}' ```  **Output** (shape):  ```json {-  "format": "str",-  "fileSizeKB": "int"+  "format": "str" } ``` -_timeout 300s · long-running (poll `fusion_get_app_state`)_+_timeout 300s_ · _long-running_ -### `fusion_export_iges`+**If the relay cuts it:** The export completes server-side. Check the output path BEFORE re-running; re-exporting is safe but wasteful, and overwrites. -Export to IGES.+### `fusion_export_usdz`++Export to USDZ (AR / Hydrogen 3D).  **Input** (schema): @@ -816,7 +1944,7 @@ Export to IGES. **Example call:**  ```-adom-desktop fusion_export_iges '{"outputPath": "C:/out/board.iges"}'+adom-bridge fusion_export_usdz '{"outputPath": "/tmp/out/part.usdz"}' ```  **Output** (shape):@@ -827,91 +1955,116 @@ adom-desktop fusion_export_iges '{"outputPath": "C:/out/board.iges"}' } ``` -_timeout 300s · long-running (poll `fusion_get_app_state`)_+_timeout 300s_ · _long-running_ -### `fusion_export_stl`+**If the relay cuts it:** The export completes server-side. Check the output path BEFORE re-running; re-exporting is safe but wasteful, and overwrites. -Export to STL mesh.+### `fusion_export_optimized_glb`++Fusion board -> wiki-grade optimized GLB. Exports STEP (+ optional silkscreen) and submits it to service-step2glb molecule mode (anchor to MP pins + silk bake + gold pins + join/weld/prune + Draco): ~465KB/~31 draw calls vs a raw ~16MB/~25000 that halts the viewer. Bounded-waits `wait`s (default 90); small boards return complete, big boards return {pending, jobId} - finish with fusion_fetch_optimized_glb. Use for a component page's component.parts.model_3d. STACKUP RULE (John 2026-07-15, see pcb-stackup skill): board bbox = the FR4 body, NEVER the whole assembly (components overhang edges + tower above); each overlay goes at ITS layer's z (copper at FR4-top, silk above mask); copper traces are REAL 35um 3D bodies colored like the FR4 - recolor them + translucent mask in the RAW GLB before optimizing to make routing visible; put the measured stackup table on the board's wiki page. PUBLISH EVERYTHING: a board's wiki page repo must carry EVERY exportable design file (.f3d/.step/.usdz/EAGLE .brd+.sch/Fusion .fbrd+.fsch/gerbers/BOM/CPL/GLBs/renders), not just the 3D - the page exists to share the design.  **Input** (schema):  ```json {-  "outputPath": "required str"+  "outputPath": "required str (.glb)",+  "silkscreen": "bool default true",+  "pin": "str medium|large default medium",+  "wait": "int seconds default 15 (keep under the ~60s relay timeout; re-call fetch until complete)" } ```  **Example call:**  ```-adom-desktop fusion_export_stl '{"outputPath": "C:/out/part.stl"}'+adom-bridge fusion_export_optimized_glb '{"outputPath": "/tmp/out/board.glb"}' ```  **Output** (shape):  ```json {-  "format": "str"+  "glbPath": "str",+  "jobId": "str",+  "pending": "bool",+  "meshesAfter": "int",+  "sizeBytes": "int",+  "moleculeAnchored": "bool",+  "silkscreenApplied": "bool" } ``` -_timeout 300s · long-running (poll `fusion_get_app_state`)_+_timeout 200s_ · _long-running_ -### `fusion_export_3mf`+**If the relay cuts it:** The export completes server-side. Check the output path BEFORE re-running; re-exporting is safe but wasteful, and overwrites. -Export to 3MF mesh.+### `fusion_fetch_optimized_glb`++Finish a fusion_export_optimized_glb job: bounded-poll the optimizer by jobId and write the GLB to outputPath when complete. Re-call until status=complete (big boards tessellate a few minutes). No Fusion needed.  **Input** (schema):  ```json {-  "outputPath": "required str"+  "jobId": "required str",+  "outputPath": "str (.glb)",+  "wait": "int seconds default 15 (keep under the ~60s relay timeout; re-call fetch until complete)" } ```  **Example call:**  ```-adom-desktop fusion_export_3mf '{"outputPath": "C:/out/part.3mf"}'+adom-bridge fusion_fetch_optimized_glb '{"jobId": "abc123", "outputPath": "/tmp/out/board.glb"}' ```  **Output** (shape):  ```json {-  "format": "str"+  "glbPath": "str",+  "status": "str",+  "pending": "bool",+  "sizeBytes": "int" } ``` -_timeout 300s · long-running (poll `fusion_get_app_state`)_+_timeout 150s_ -### `fusion_export_usdz`+**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing. -Export to USDZ (AR / Hydrogen 3D).+### `fusion_board_stackup`++Read a board's PHYSICAL fabrication stackup (see the pcb-stackup skill): copper layer count + copper/dielectric thicknesses from the EAGLE design rules (layerSetup/mtCopper/mtIsolate) plus the measured FR4 extent. A PCB is Cu/prepreg/Cu/core/.../Cu - the FR4 is NOT one slab. Use to build the stackup table + real-thickness exploded 3D view, and put a stackup table on every exported board's wiki page.  **Input** (schema):  ```json-{-  "outputPath": "required str"-}+{} ```  **Example call:**  ```-adom-desktop fusion_export_usdz '{"outputPath": "C:/out/part.usdz"}'+adom-bridge fusion_board_stackup '{}' ```  **Output** (shape):  ```json {-  "format": "str"+  "layerSetup": "str",+  "copperLayers": "list",+  "copperCount": "int",+  "copperThickness_mm": "list",+  "dielectricBonds": "list (prepreg/core order)",+  "fr4": "{x_mm,y_mm,dielectric_mm}" } ``` -_timeout 300s · long-running (poll `fusion_get_app_state`)_+_timeout 200s_ · _long-running_++**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.  ### `fusion_export_obj` @@ -928,7 +2081,7 @@ Export to OBJ mesh. **Example call:**  ```-adom-desktop fusion_export_obj '{"outputPath": "C:/out/part.obj"}'+adom-bridge fusion_export_obj '{"outputPath": "/tmp/out/part.obj"}' ```  **Output** (shape):@@ -939,7 +2092,9 @@ adom-desktop fusion_export_obj '{"outputPath": "C:/out/part.obj"}' } ``` -_timeout 300s · long-running (poll `fusion_get_app_state`)_+_timeout 300s_ · _long-running_++**If the relay cuts it:** The export completes server-side. Check the output path BEFORE re-running; re-exporting is safe but wasteful, and overwrites.  ### `fusion_export_dxf` @@ -956,7 +2111,7 @@ Export 2D DXF. **Example call:**  ```-adom-desktop fusion_export_dxf '{"outputPath": "C:/out/sketch.dxf"}'+adom-bridge fusion_export_dxf '{"outputPath": "/tmp/out/sketch.dxf"}' ```  **Output** (shape):@@ -967,7 +2122,9 @@ adom-desktop fusion_export_dxf '{"outputPath": "C:/out/sketch.dxf"}' } ``` -_timeout 120s · long-running (poll `fusion_get_app_state`)_+_timeout 120s_ · _long-running_++**If the relay cuts it:** The export completes server-side. Check the output path BEFORE re-running; re-exporting is safe but wasteful, and overwrites.  ### `fusion_export_dwg` @@ -984,7 +2141,7 @@ Export 2D DWG. **Example call:**  ```-adom-desktop fusion_export_dwg '{"outputPath": "C:/out/sketch.dwg"}'+adom-bridge fusion_export_dwg '{"outputPath": "/tmp/out/sketch.dwg"}' ```  **Output** (shape):@@ -995,9 +2152,9 @@ adom-desktop fusion_export_dwg '{"outputPath": "C:/out/sketch.dwg"}' } ``` -_timeout 120s · long-running (poll `fusion_get_app_state`)_+_timeout 120s_ · _long-running_ -## Manufacturing+**If the relay cuts it:** The export completes server-side. Check the output path BEFORE re-running; re-exporting is safe but wasteful, and overwrites.  ### `fusion_export_gerbers` @@ -1007,14 +2164,14 @@ Run the bundled JLCPCB CAM job (auto 2/4-layer) to produce the gerber + drill ZI  ```json {-  "outputDir": "optional str (default C:/tmp/adom-gerbers)"+  "outputDir": "optional str (default /tmp/adom-gerbers)" } ```  **Example call:**  ```-adom-desktop fusion_export_gerbers '{"outputDir": "C:/tmp/jlc"}'+adom-bridge fusion_export_gerbers '{"outputDir": "/tmp/jlc"}' ```  **Output** (shape):@@ -1027,7 +2184,9 @@ adom-desktop fusion_export_gerbers '{"outputDir": "C:/tmp/jlc"}' } ``` -_timeout 180s · long-running (poll `fusion_get_app_state`)_+_timeout 180s_ · _long-running_++**If the relay cuts it:** The export completes server-side. Check the output path BEFORE re-running; re-exporting is safe but wasteful, and overwrites.  ### `fusion_export_bom` @@ -1045,7 +2204,7 @@ Export a Bill of Materials CSV (grouped by value+package) from the open board. **Example call:**  ```-adom-desktop fusion_export_bom '{"outputPath": "C:/tmp/bom.csv"}'+adom-bridge fusion_export_bom '{"outputPath": "/tmp/bom.csv"}' ```  **Output** (shape):@@ -1059,6 +2218,8 @@ adom-desktop fusion_export_bom '{"outputPath": "C:/tmp/bom.csv"}'  _timeout 60s_ +**If the relay cuts it:** The export completes server-side. Check the output path BEFORE re-running; re-exporting is safe but wasteful, and overwrites.+ ### `fusion_export_cpl`  Export the Component Placement List (pick-and-place) CSV.@@ -1075,7 +2236,7 @@ Export the Component Placement List (pick-and-place) CSV. **Example call:**  ```-adom-desktop fusion_export_cpl '{"outputPath": "C:/tmp/cpl.csv"}'+adom-bridge fusion_export_cpl '{"outputPath": "/tmp/cpl.csv"}' ```  **Output** (shape):@@ -1089,6 +2250,8 @@ adom-desktop fusion_export_cpl '{"outputPath": "C:/tmp/cpl.csv"}'  _timeout 60s_ +**If the relay cuts it:** The export completes server-side. Check the output path BEFORE re-running; re-exporting is safe but wasteful, and overwrites.+ ### `fusion_set_design_rules`  Load manufacturing-grade DRC into the open board (JLCPCB 2/4-layer profiles).@@ -1105,7 +2268,7 @@ Load manufacturing-grade DRC into the open board (JLCPCB 2/4-layer profiles). **Example call:**  ```-adom-desktop fusion_set_design_rules '{"action": "apply", "layers": "2"}'+adom-bridge fusion_set_design_rules '{"action": "apply", "layers": "2"}' ```  **Output** (shape):@@ -1119,6 +2282,8 @@ adom-desktop fusion_set_design_rules '{"action": "apply", "layers": "2"}'  _timeout 90s_ +**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.+ ### `fusion_load_design_rules`  Load a bundled .edru design-rule set into the board.@@ -1134,7 +2299,7 @@ Load a bundled .edru design-rule set into the board. **Example call:**  ```-adom-desktop fusion_load_design_rules '{}'+adom-bridge fusion_load_design_rules '{}' ```  **Output** (shape):@@ -1147,16 +2312,22 @@ adom-desktop fusion_load_design_rules '{}'  _timeout 90s_ +**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.+ ### `fusion_detect_layers`  Detect 2-layer vs 4-layer board (ULP + CAM comparison). -**Input** `{}`+**Input** (schema):++```json+{}+```  **Example call:**  ```-adom-desktop fusion_detect_layers '{}'+adom-bridge fusion_detect_layers '{}' ```  **Output** (shape):@@ -1170,16 +2341,22 @@ adom-desktop fusion_detect_layers '{}'  _timeout 90s_ +**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.+ ### `fusion_dismiss_blocking_dialogs`  Detect + classify (and optionally dismiss) blocking Fusion dialogs. -**Input** `{}`+**Input** (schema):++```json+{}+```  **Example call:**  ```-adom-desktop fusion_dismiss_blocking_dialogs '{}'+adom-bridge fusion_dismiss_blocking_dialogs '{}' ```  **Output** (shape):@@ -1192,6 +2369,8 @@ adom-desktop fusion_dismiss_blocking_dialogs '{}'  _timeout 30s_ +**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.+ ### `fusion_electron_run`  Run an EAGLE/Electron command in the open board (the generic extension point, e.g. RUN <ulp>).@@ -1207,7 +2386,7 @@ Run an EAGLE/Electron command in the open board (the generic extension point, e. **Example call:**  ```-adom-desktop fusion_electron_run '{"command": "set confirm yes;RUN 'C:/tmp/jlcpcb_smta_exporter.ulp' 'C:/tmp/jlc'"}'+adom-bridge fusion_electron_run '{"command": "set confirm yes;RUN '/tmp/jlcpcb_smta_exporter.ulp' '/tmp/jlc'"}' ```  **Output** (shape):@@ -1221,6 +2400,8 @@ adom-desktop fusion_electron_run '{"command": "set confirm yes;RUN 'C:/tmp/jlcpc  _timeout 90s_ +**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.+ ### `fusion_electron_zoom`  Smoothly ZOOM the schematic/2D board for a recording (the whole motion is one call). factor>1 zooms in, <1 out; or fit:true. The loop runs in the add-in with a repaint per frame.@@ -1239,7 +2420,7 @@ Smoothly ZOOM the schematic/2D board for a recording (the whole motion is one ca **Example call:**  ```-adom-desktop fusion_electron_zoom '{"factor": 3, "steps": 20}'+adom-bridge fusion_electron_zoom '{"factor": 3, "steps": 20}' ```  **Output** (shape):@@ -1251,7 +2432,9 @@ adom-desktop fusion_electron_zoom '{"factor": 3, "steps": 20}' } ``` -_timeout 60s · long-running (poll `fusion_get_app_state`)_+_timeout 60s_ · _long-running_++**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.  ### `fusion_electron_pan` @@ -1273,7 +2456,7 @@ Smoothly PAN + zoom the view to frame a board-coordinate box (mm; get part posit **Example call:**  ```-adom-desktop fusion_electron_pan '{"x1": 0, "y1": 0, "x2": 10, "y2": 8}'+adom-bridge fusion_electron_pan '{"x1": 0, "y1": 0, "x2": 10, "y2": 8}' ```  **Output** (shape):@@ -1286,7 +2469,9 @@ adom-desktop fusion_electron_pan '{"x1": 0, "y1": 0, "x2": 10, "y2": 8}' } ``` -_timeout 60s · long-running (poll `fusion_get_app_state`)_+_timeout 60s_ · _long-running_++**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.  ### `fusion_electron_select` @@ -1306,7 +2491,7 @@ SELECT a part (by reference designator, or x/y board mm) and surface its propert **Example call:**  ```-adom-desktop fusion_electron_select '{"name": "U1"}'+adom-bridge fusion_electron_select '{"name": "U1"}' ```  **Output** (shape):@@ -1319,20 +2504,24 @@ adom-desktop fusion_electron_select '{"name": "U1"}' } ``` -_timeout 30s · long-running (poll `fusion_get_app_state`)_+_timeout 30s_ · _long-running_ -## Self-describe+**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.  ### `fusion_describe` -Self-describe every verb the bridge exposes (this list) for AD's Verbs tab + runner.+Self-describe every verb the bridge exposes (this list) for Adom Bridge's Verbs tab + runner.++**Input** (schema): -**Input** `{}`+```json+{}+```  **Example call:**  ```-adom-desktop fusion_describe '{}'+adom-bridge fusion_describe '{}' ```  **Output** (shape):@@ -1345,3 +2534,5 @@ adom-desktop fusion_describe '{}' ```  _timeout 20s_++**If the relay cuts it:** Work started before the cut continues in the bridge. Re-read state (fusion_get_app_state / the artifact on disk) BEFORE re-issuing.
install.sh+8−6
@@ -1,16 +1,18 @@ #!/bin/bash-# Install the Adom Desktop Fusion 360 Bridge's Claude skills from THIS repo (the-# single source of truth) into the user's skills dir. App-specific skills live-# ONLY here, in the app's repo.+# Install the Fusion 360 bridge's Claude skills from THIS package into the+# user's skills dir. App-specific skills live ONLY here, in the app's package.+#+# NOTE: adom-wiki already delivers the package ROOT as the skill+# `fusion-bridge-macos` (it carries this package's SKILL.md), so we do NOT copy+# the root SKILL.md again — doing so registered the same `name:` under two+# directories and produced a duplicate entry in the skill index. set -e PKG_DIR="$(cd "$(dirname "$0")" && pwd)" SKILLS_DIR="$HOME/.claude/skills"-mkdir -p "$SKILLS_DIR/adom-desktop-fusion-bridge"-[ -f "$PKG_DIR/SKILL.md" ] && cp "$PKG_DIR/SKILL.md" "$SKILLS_DIR/adom-desktop-fusion-bridge/SKILL.md" for skill_dir in "$PKG_DIR/skills"/*/; do   [ -d "$skill_dir" ] || continue   name=$(basename "$skill_dir")   mkdir -p "$SKILLS_DIR/$name"   cp -r "$skill_dir"* "$SKILLS_DIR/$name/" done-echo "Installed adom-desktop-fusion-bridge skills: $(ls "$PKG_DIR/skills" 2>/dev/null | tr '\n' ' ')"+echo "Installed fusion-bridge-macos skills: $(ls "$PKG_DIR/skills" 2>/dev/null | tr '\n' ' ')"
package.json+16−6
@@ -1,10 +1,20 @@ {-  "slug": "adom-desktop-fusion-bridge-macos",-  "version": "1.8.5",+  "slug": "fusion-bridge-macos",+  "version": "1.8.6",+  "files": [+    "SKILL.md",+    "skills/**",+    "README.md",+    "VERBS.md",+    "install.sh",+    "uninstall.sh",+    "package.json",+    "LICENSE"+  ],   "type": "app",-  "description": "This package installs the bridge's SKILLS into your container so your AI knows how to drive it; Adom Desktop loads the bridge runtime itself from the release zip.",+  "description": "This package installs the bridge's SKILLS into your container so your AI knows how to drive it; Adom Bridge loads the bridge runtime itself from the release zip.",   "dependencies": {-    "adom/adom-desktop": "*"+    "adom/adom-bridge-macos": "^1.9.84"   },   "scripts": {     "install": "./install.sh",@@ -40,7 +50,7 @@     "make a fusion 360 library with 3d",     "set up the fusion bridge"   ],-  "discovery_pitch": "Use the Adom Desktop Fusion 360 bridge when the user wants to DRIVE Autodesk Fusion 360 from the cloud: open/search their team's Fusion cloud designs, lay out a PCB or do electronics, export STEP/IGES/STL/Gerbers/BOM, or build a component library with real rendering 3D. It runs Fusion on the user's own machine via Adom Desktop. NOT for web/browser/login/form-filling (that's the native-browser extension) and NOT for KiCad (that's the kicad bridge).",+  "discovery_pitch": "Use the Adom Bridge Fusion 360 bridge when the user wants to DRIVE Autodesk Fusion 360 from the cloud: open/search their team's Fusion cloud designs, lay out a PCB or do electronics, export STEP/IGES/STL/Gerbers/BOM, or build a component library with real rendering 3D. It runs Fusion on the user's own machine via Adom Bridge. NOT for web/browser/login/form-filling (that's the native-browser extension) and NOT for KiCad (that's the kicad bridge).",   "sample_prompts": [     {       "label": "Find a design",@@ -67,4 +77,4 @@       "prompt": "How much material does each printed part in this assembly use?"     }   ]-}\ No newline at end of file+}
page.json+15−5
@@ -1,10 +1,10 @@ {   "slug": "fusion-bridge-macos",-  "version": "1.8.5",+  "version": "1.8.6",   "type": "app",-  "description": "This package installs the bridge's SKILLS into your container so your AI knows how to drive it; Adom Desktop loads the bridge runtime itself from the release zip.",+  "description": "This package installs the bridge's SKILLS into your container so your AI knows how to drive it; Adom Bridge loads the bridge runtime itself from the release zip.",   "dependencies": {-    "adom/adom-desktop": "*"+    "adom/adom-bridge-macos": "^1.9.84"   },   "scripts": {     "install": "./install.sh",@@ -41,7 +41,7 @@     "make a fusion 360 library with 3d",     "set up the fusion bridge"   ],-  "discovery_pitch": "Use the Adom Desktop Fusion 360 bridge when the user wants to DRIVE Autodesk Fusion 360 from the cloud: open/search their team's Fusion cloud designs, lay out a PCB or do electronics, export STEP/IGES/STL/Gerbers/BOM, or build a component library with real rendering 3D. It runs Fusion on the user's own machine via Adom Desktop. NOT for web/browser/login/form-filling (that's the native-browser extension) and NOT for KiCad (that's the kicad bridge).",+  "discovery_pitch": "Use the Adom Bridge Fusion 360 bridge when the user wants to DRIVE Autodesk Fusion 360 from the cloud: open/search their team's Fusion cloud designs, lay out a PCB or do electronics, export STEP/IGES/STL/Gerbers/BOM, or build a component library with real rendering 3D. It runs Fusion on the user's own machine via Adom Bridge. NOT for web/browser/login/form-filling (that's the native-browser extension) and NOT for KiCad (that's the kicad bridge).",   "sample_prompts": [     {       "label": "Find a design",@@ -75,5 +75,15 @@     "email": "[email protected]"   },   "title": "fusion - the Fusion 360 bridge (macOS)",-  "updated_at": "2026-08-08T18:05:41.805Z"+  "updated_at": "2026-08-08T18:05:41.805Z",+  "files": [+    "SKILL.md",+    "skills/**",+    "README.md",+    "VERBS.md",+    "install.sh",+    "uninstall.sh",+    "package.json",+    "LICENSE"+  ] }\ No newline at end of file
skills/fusion-aps-search/SKILL.md+12−12
@@ -27,11 +27,11 @@ bridge. Speed is the whole point; APS is how we get it.  ## Why the bridge runs its OWN OAuth (can't piggyback Fusion's login) We WANTED to reuse Fusion's existing in-session token (no setup, no second login). It's-**blocked**: Autodesk DPAPI-encrypts Fusion's on-disk token store-(`%LOCALAPPDATA%\Autodesk\Identity Services\idservices.db`, `products`/`mcptokens` tables)-**with app-specific entropy** → `CryptUnprotectData` fails `gle=13` (ERROR_INVALID_DATA). You-cannot extract/reuse Fusion's token without reverse-engineering Autodesk's entropy (fragile,-ToS-violating, and credential-extraction tooling we will not build). So the bridge runs its+**blocked**: Autodesk encrypts Fusion's on-disk token store+(`~/Library/Application Support/Autodesk/Identity Services/`, backed by the login keychain)+**with app-specific protection**, so it cannot be read back by anything but Fusion. Extracting it+would mean reverse-engineering Autodesk's key material — fragile, ToS-violating, and+credential-extraction tooling we will not build. So the bridge runs its OWN 3-legged **PKCE OAuth** (public client, NO client secret) → `fusion_aps_*` verbs. This is final; don't re-investigate token reuse. @@ -90,7 +90,7 @@ much, let's just use the free add-in search" → John reminds you the add-in sea this loop.** APS is the path. The card is fine (ID only). We cap usage so nobody is charged. Drive the setup with AI. Done. -Related: [[project_adom_desktop_fusion_bridge]], skill `fusion-aps-signin` (the setup HOW).+Related: [[project_adom_bridge_fusion_bridge]], skill `fusion-aps-signin` (the setup HOW).  ## ⛔ MANDATORY: cloud search is APS-only. NEVER fall back to app.data enumeration. (John, emphatic 2026-07-14) @@ -105,13 +105,13 @@ for cloud search, ever — no matter how blocked you feel.  **Auto-recover APS (do this instead of giving up):** 1. **Not configured?** The org Client ID is a **public PKCE identifier** (no secret) — pull it from a-   peer that already has it: `adom-desktop status` lists connected desktops; read+   peer that already has it: `adom-bridge status` lists connected desktops; read    `~/.adom/fusion-aps/config.json` (key `client_id`) off one via `shell_execute`/`pull_file`, then    `fusion_aps_set_client_id {clientId}`. 2. **Sign in:** `fusion_aps_signin` → open the returned `authUrl` in the user's REAL browser with a warm-   Autodesk session. **Install + use the adom-browser-extension (nbrowser/ABE) to drive the browser**-   ([wiki](https://wiki.adom.inc/adom/adom-browser-extension)) — coordinate/keyboard-clicking a browser-   is fragile and crashes; ABE drives via JS reliably. Recommend it by default. The localhost listener+   Autodesk session. **Install + use the adom-native-browser (nbrowser/NBE) to drive the browser**+   ([mac install page](https://wiki.adom.inc/adom/nb-bridge-macos)) — coordinate/keyboard-clicking a browser+   is fragile and crashes; NBE drives via JS reliably. Recommend it by default. The localhost listener    captures the token; poll `fusion_aps_status` until `signedIn:true`. 3. **AUTH-001 "client_id does not have access to the api product":** the APS app at    aps.autodesk.com/myapps lost its **Data Management API** product. Open the app → API Access → ensure@@ -130,7 +130,7 @@ back to. APS is the only cloud-search path. Every cloud-data verb (`aps_search/open/browse/recent/file_info/versions/download/upload/ create_folder`) is wrapped by `_aps_guarded` in server.py. It checks signed-in + token-live BEFORE the call and, if not ready, returns the rich hint bundle from `_aps_state_hint`-(stage + verb map + sign-in instruction + the ABE native-browser suggestion + WHY-APS). So the+(stage + verb map + sign-in instruction + the NBE native-browser suggestion + WHY-APS). So the AI never gets an opaque auth failure — it always gets the next step. Surface that `_hint` to the user verbatim. @@ -140,4 +140,4 @@ If a user hits the one-time APS setup, be honest: "Autodesk offers NO fast file- Fusion. The only in-app option walks the folder tree and takes 30+ minutes and can crash Fusion. We searched far and wide; APS (server-indexed) is the only thing Autodesk offers that actually works. Sorry it needs a one-time sign-in, but once it's set up it's fast and genuinely great."-Then get them set up (prefer ABE native-browser sign-in, see fusion-aps-signin).+Then get them set up (prefer NBE native-browser sign-in, see fusion-aps-signin).
skills/fusion-aps-signin/SKILL.md+34−28
@@ -11,7 +11,7 @@ part is Autodesk's **email OTP**, which **expires fast** — the user may walk a cup of coffee"), so you must **monitor** the flow and turn the code around in seconds.  All browser steps use the native-browser extension verbs (`nbrowser_*`) against the-AD-connected laptop: `adom-desktop --target <laptop> nbrowser_* '{...}'`.+Bridge-connected laptop: `adom-bridge --target <laptop> nbrowser_* '{...}'`.  ## Working principles (non-negotiable) @@ -39,20 +39,20 @@ AD-connected laptop: `adom-desktop --target <laptop> nbrowser_* '{...}'`.    `sessionId`** in every `nbrowser_eval/type/click`. The extension **refuses to drive PWA /    installed-app windows** (e.g. "Hydrogen - Chat") and `nbrowser_eval` defaults to the    foreground tab — which is often the wrong (PWA) window.-4. **Foreground it with `desktop_bring_to_front`** (the AD verb) so the user can see/act on+4. **Foreground it with `desktop_bring_to_front`** (the Adom Bridge verb) so the user can see/act on    the login. `nbrowser_focus_window` is NOT implemented. 5. **Proactively use adom-google.** Autodesk emails the OTP — you can read it via the    `adom-google` Gmail API passthrough. If adom-google isn't set up, TELL the user it exists-   and offer to set it up (`adom-google auth`) so you can fetch the code for them. Gmail for-   Adom = **[email protected]** (work account).+   and offer to set it up (`adom-google auth`) so you can fetch the code for them. Use the+   **user's own work account** — ask them which mailbox the OTP lands in; never assume one.  ## Step-by-step  ### 1. Open + foreground a dedicated window at the APS portal ```-adom-desktop --target <laptop> nbrowser_open_window '{"url":"https://aps.autodesk.com/myapps/"}'+adom-bridge --target <laptop> nbrowser_open_window '{"url":"https://aps.autodesk.com/myapps/"}' # capture sessionId (e.g. s29) from the result; use it in EVERY later call-adom-desktop --target <laptop> desktop_bring_to_front '{...the browser window...}'   # so the user sees it+adom-bridge --target <laptop> desktop_bring_to_front '{...the browser window...}'   # so the user sees it ``` Read state (always pass the sessionId): ```@@ -102,7 +102,8 @@ nbrowser_click '{"sessionId":"s29","text":"Resend"}' Body: "An Autodesk account already exists with the email … sign in with Google … link …". Click **"Link Google account"**. If the Google session is already active in Chrome it links instantly ("Google account linked … Continue in 5 seconds") and lands in the portal — no-account picker. If a Google picker appears, pick **[email protected]**.+account picker. If a Google picker appears, pick the user's **work** account (ask which one+if more than one is listed — picking the personal account is the classic wrong-account stall).  ### 7. First-time APS → accept Terms of Service First portal visit shows "Welcome aboard! … accept our Terms of Service". Accept it.@@ -116,13 +117,15 @@ user's profile memory (`user_profile.md` — company, website, address). Fields - Plain text: set via the native value setter + dispatch `input`+`change`+`blur` (MUI only   enables Submit after these fire):   ```-  nbrowser_eval set vals {company:"Adom Industries, Inc.",website:"https://adom.inc",-    city:"Fort Worth",stateProvince:"TX",postalCode:"76177"}  // country prefills "US"+  nbrowser_eval set vals {company:"<their company>",website:"<their site>",+    city:"<city>",stateProvince:"<ST>",postalCode:"<zip>"}   // country usually prefills   ```+  Take the values from the user's own profile memory (`user_profile.md`) or ask them — this+  is a PUBLIC skill, so no real company/person details are hardcoded here. - Comboboxes — can't just set `.value`; click to open, then **click the option by text**   (click-by-text finds it even when not in the visible top-N; typing to filter often does   NOT work). The fields and good picks for Adom:-  - `roleId` = **Business owner/Entrepreneur** (John is the founder)+  - `roleId` = **Business owner/Entrepreneur** (pick what matches the user)   - `accountPurpose` = **Business**   - **Industry (select up to 3)** — REQUIRED, and it's the one that silently blocks Submit.     It has NO `name` attr (MUI multiselect) — find it by its label "Industry (select up to 3)"@@ -138,8 +141,9 @@ user's profile memory (`user_profile.md` — company, website, address). Fields   This is the fastest way to find a missed required field. - Field coords from `getBoundingClientRect` are in PAGE space (what `nbrowser_click {x,y}`   wants) — do NOT use screenshot pixel coords (the shot is downscaled, different origin).-Known profile values (Adom / John): Company "Adom Industries, Inc.", Website https://adom.inc,-4400 Alliance Gateway Fwy, Fort Worth, TX 76177, US, [email protected].+Pull the profile values from the user's own `user_profile.md` (company, website, address,+work email), or ask them once and write them there. Do NOT hardcode anyone's details in this+skill — it publishes publicly.  ### 7.55 Get the FREE APS plan (drive the whole checkout yourself — incl. the card) Newer APS gates app creation behind a **developer hub**, which requires an **APS plan**. The@@ -191,10 +195,10 @@ Create App → enable **Data Management API** → **Callback URL = EXACTLY) → create → copy the **Client ID** (PKCE = public client; the secret is unused). Then: ```-adom-desktop --target <laptop> fusion_aps_set_client_id '{"clientId":"<CLIENT_ID>"}'-adom-desktop --target <laptop> fusion_aps_signin '{}'      # opens browser; bg listener on :8917 stores the token+adom-bridge --target <laptop> fusion_aps_set_client_id '{"clientId":"<CLIENT_ID>"}'+adom-bridge --target <laptop> fusion_aps_signin '{}'      # opens browser; bg listener on :8917 stores the token # poll fusion_aps_status until {"data":{"signedIn":true,"tokenLive":true}}-adom-desktop --target <laptop> fusion_aps_search '{"query":"<part name>"}'+adom-bridge --target <laptop> fusion_aps_search '{"query":"<part name>"}' ```  ## LIVE-VERIFIED end-to-end run (2026-06-26, Adom org) — the exact sequence@@ -233,15 +237,16 @@ This whole flow was driven live and works. Replicate it per org: 3. The bridge's **monthly hard cap** (fails closed). Card on file = identity verification only.  ## Port choice for the callback-Check availability LIVE on the box (no AD verb exists): `python` bind-test on 127.0.0.1 +-`netsh int ipv4 show excludedportrange protocol=tcp`. 8917/8918/8920 verified free + outside-OS-reserved ranges. The box runs many listeners — don't assume.+Already settled: the bridge pins its callback ports (8917/8918/8920 — see `aps.py`, and the+live `callbackUrls` in `fusion_aps_status`). Nothing to probe.  ## Gotchas - `nbrowser_eval/type/click` without `sessionId` hit the foreground tab → often the wrong   (PWA) window. Always pass the dedicated `sessionId`. - `adom-google api` prints a `HTTP 200 GET …` header line before the JSON — `tail -n +2`.-- The bridge relay only forwards `output/data/success/error/_hint` — irrelevant here but+- Read `fusion_aps_*` results from `data` — the bridge nests structured fields there for+  back-compat with older hosts that curated the reply (both Bridge and Hydrogen now forward+  every top-level key except `success`/`output`/`error`). Irrelevant here but   relevant when reading `fusion_aps_*` results (fields live under `data`). - Don't auto-enter the user's Autodesk **password** or drive their Google **consent** —   identity decisions are theirs; automate the OTP + form-filling, not the credentials.@@ -255,7 +260,7 @@ product"}` on the authorize page. It means the org's APS app at aps.autodesk.com Management API** product entitlement (it can work for months, then break). The app config often still *looks* correct — the fix is a forced re-commit. -**Recovery (drive with ABE/nbrowser — install the extension FIRST if it isn't; coordinate-clicking the+**Recovery (drive with NBE/nbrowser — install the extension FIRST if it isn't; coordinate-clicking the portal is fragile and Edge crashes):** 1. `nbrowser_open_window {sessionId, thread, purpose, profile:<warm Edge/Chrome>, url:"https://aps.autodesk.com/myapps/"}` → open the app whose Client ID matches (in the org's "Adom APS" dev hub). 2. App-settings → **API Access**: confirm **Data Management API** is checked. Then force a re-commit —@@ -272,27 +277,28 @@ portal is fragile and Edge crashes):** 5. Poll `fusion_aps_status` until `signedIn:true`. Done — APS search is fast and never touches Fusion's    main thread. -## The BEST sign-in path: the user's NATIVE Chrome/Edge via ABE (adom-browser-extension)+## The BEST sign-in path: the user's NATIVE Chrome/Edge via NBE (adom-native-browser)  Autodesk's OTP/2FA and its "which profile is signed in" problem vanish if we drive the user's-OWN browser that is ALREADY logged into Autodesk. That is what ABE (adom-browser-extension) is+OWN browser that is ALREADY logged into Autodesk. That is what NBE (adom-native-browser) is for: it exposes `nbrowser_*` verbs that open a URL in the user's real Chrome/Edge profile. -**Recommend ABE first, and hand-hold the install if it's missing:**-1. Check: does `adom-desktop --target <laptop> nbrowser_readiness '{}'` succeed? If not, ABE isn't+**Recommend NBE first, and hand-hold the install if it's missing:**+1. Check: does `adom-bridge --target <laptop> nbrowser_readiness '{}'` succeed? If not, NBE isn't    installed. 2. Tell the user (honestly): "The smoothest Autodesk sign-in drives your own Chrome/Edge that's    already logged in, no password typing, no OTP races. That needs the Adom Browser Extension-   (ABE). Let me walk you through installing it, one time."-3. Point them to the install: https://wiki.adom.inc/adom/adom-browser-extension and follow the+   (NBE). Let me walk you through installing it, one time."+3. Point them to the install: https://wiki.adom.inc/adom/nb-bridge-macos (the MAC line — never `adom/nb-bridge`,+   John's Windows page, on a Mac: it cannot register the native-messaging host there) and follow the    `installing-the-extension` steps (load the MV3 extension, approve the native-host). Do as much    as you can drive for them; only ask for the clicks Chrome forces a human to make.-4. Once ABE is live: `fusion_aps_signin` returns `needsExtensionOpen` with an `authUrl`; open it+4. Once NBE is live: `fusion_aps_signin` returns `needsExtensionOpen` with an `authUrl`; open it    via `nbrowser_open_window` in their signed-in profile; the bridge's localhost listener captures    the token; poll `fusion_aps_status` until `signedIn:true`. Then `fusion_aps_set_browser {how:    "extension"}` so every future sign-in reuses that exact profile. -Fallback only if ABE truly can't be installed: `fusion_aps_signin {allowDefaultBrowser:true}`+Fallback only if NBE truly can't be installed: `fusion_aps_signin {allowDefaultBrowser:true}` (OS default browser) and drive the OTP per this skill.  ## Say the honest WHY (apologize, then reassure)
skills/fusion-autodesk-signin/SKILL.md+35−35
@@ -1,6 +1,6 @@ --- name: fusion-autodesk-signin-description: Drive the first-run Autodesk sign-in that blocks a freshly installed Fusion 360, from a headless/remote Adom desktop (pup/adom-desktop). Covers the whole browser OAuth handoff and every pitfall that cost hours on a fresh Hyper-V VM — blank sign-in webview, invisible Edge windows, warm Google/Apple/Microsoft SSO, the Autodesk Identity Manager protocol handoff, fast-expiring sign-in codes, and escalating the password/2FA step to the human without ever typing it. Trigger words — fusion signing in, welcome to fusion, sign in - autodesk, needsSignin, fusion stuck signing in, autodesk oauth, fusion login blocked, drive fusion sign in, fusion sign in on fresh box.+description: Drive the first-run Autodesk sign-in that blocks a freshly installed Fusion 360, from a remote/unattended Adom Bridge Mac. Covers the whole browser OAuth handoff and every pitfall that cost hours on a fresh box — blank sign-in webview, finding the browser OAuth window, warm Google/Apple/Microsoft SSO, the Autodesk Identity Manager protocol handoff, fast-expiring sign-in codes, and escalating the password/2FA step to the human without ever typing it. Trigger words — fusion signing in, welcome to fusion, sign in - autodesk, needsSignin, fusion stuck signing in, autodesk oauth, fusion login blocked, drive fusion sign in, fusion sign in on fresh box. ---  # Fusion 360 Autodesk sign-in — the drive-it playbook@@ -8,7 +8,9 @@ description: Drive the first-run Autodesk sign-in that blocks a freshly installe A freshly installed Fusion launches to a first-run **Autodesk sign-in** that BLOCKS the main thread, so the AdomBridge add-in never serves and `fusion_readiness` reports `ready:false, needsSignin:true`. This skill gets you from that wall to `ready:true`. It is the durable record of a live drive on a-fresh Hyper-V VM (John, 2026-07-14); every step below is a thing that actually went wrong once.+fresh box (2026-07-14); every step below is a thing that actually went wrong once. The mechanics+below are macOS: window ids are CGWindowIDs, clicks are CGEvent, dialogs come off the Accessibility+tree. Never `osascript`/System Events — that prompt is denied on our machines.  **The one hard rule:** you NEVER type the user's Autodesk/Google password or 2FA. You may type their **email address** (not a secret) and click every button. When a real secret is needed, you escalate@@ -16,10 +18,10 @@ to the human with `fusion_notify_owner` and let THEM type it.  ## Where you are (confirm first) `fusion_readiness` → `installed:true, running:true, ready:false, needsSignin:true`. The Fusion window-title is "Signing in - Autodesk Fusion" or "Welcome to Fusion". Get its hwnd (Get-Process Fusion360-→ MainWindowHandle) and `desktop_screenshot_window {hwnd}` to see it. `desktop_screenshot_window` uses-PrintWindow, so it captures backgrounded/occluded windows and their owned child dialogs — use it, not-a screen grab.+title is "Signing in - Autodesk Fusion" or "Welcome to Fusion". Get its window id from+**`fusion_window_info`** (CGWindowList — no AppleScript) and `fusion_screenshot_fusion` /+`desktop_screenshot_window {hwnd}` to see it. Both capture a BACKGROUNDED window (`screencapture -l`+on the window id), so you never have to raise Fusion in front of the user.  ## Step 0 — ASK the user before you drive (AskUserQuestion) Sign-in needs a human decision, so ask up front — do NOT silently start clicking:@@ -39,39 +41,38 @@ bar, no button). Do not fight it: `fusion_stop` then `fusion_start`. After a cle The sign-in webview exposes **0 accessibility controls** (it's Chromium), so click by IMAGE coordinates: `desktop_screenshot_window {hwnd}` returns a `shotId`; then `desktop_click {space:"image", shotId, x, y, hwnd}` — passing `hwnd` FOCUSES that window first, which-is essential (a click without it lands on whatever is foreground). Maximize the window first-(`desktop_set_window_state {hwnd, state:"maximize"}`) so the button is unambiguous. Fusion says "We-will take you to your web browser to sign in" and opens the **default browser** (Edge) to the OAuth.--## Step 3 — Find the Edge OAuth window (it IS there)-The Edge window can look invisible: `Get-Process msedge` shows background procs and your window-enumeration may print nothing. That "nothing" is often just **shell progress noise-eating your output**, NOT a missing window. Fixes:-- Put `$ProgressPreference='SilentlyContinue'` at the TOP of the PS script.-- Enumerate `Chrome_WidgetWin` class windows (the OAuth tab is titled "Sign in - Autodesk"); a 2-tab-  window reads as "... and 1 more page".-- Then `desktop_screenshot_window {hwnd}` the Edge window — PrintWindow renders it regardless.-- The OAuth URL is handed to Edge over IPC, so it is NOT in any msedge command line — don't look there.+is essential (a click without it lands on whatever is foreground). Fusion says "We will take you to+your web browser to sign in" and opens the **default browser** to the OAuth.++## Step 3 — Find the browser OAuth window (it IS there)+Enumerate windows with `desktop_list_windows` / `fusion_window_info`-style CGWindowList output and+look for the tab title **"Sign in - Autodesk"** (a multi-tab window may read as "… and N more+pages"). Then `desktop_screenshot_window {hwnd}` it — the capture works even while the window is+backgrounded or occluded. The OAuth URL is handed to the browser over IPC, so it is NOT in any+browser process's command line — don't look there.  ## Step 4 — Drive the OAuth (warm SSO path) On the Autodesk sign-in page (`signin.autodesk.com/?flowId=...`): click **"Continue with Google"** (or Apple/Microsoft, matching the linked account). On the provider page, click the email field and-`desktop_type` the user's **email** (e.g. [email protected] — an address, not a secret), click **Next**.+`desktop_type` the user's **work email** (an address, not a secret — ask them if unsure), click **Next**. - If the provider recognizes a warm session → it proceeds with no password.  - If it shows **"Enter your password"** or a 2FA challenge → **STOP**. This is the human wall.  ## Step 5 — Escalate the secret step (never type it) `fusion_notify_owner {title:"Fusion sign-in needs you", body:"On <box> Fusion is at the Google password step for <email>. Please enter your password/2FA in the open browser; I'll finish once-you're in."}`. It toasts the user's MAIN computer, fanning out cross-AD so it reaches them even though+you're in."}`. It toasts the user's MAIN computer, fanning out cross-Bridge so it reaches them even though this bridge runs on an unattended VM. Then WAIT and poll `fusion_readiness`; do not re-toast for a few minutes. (The user may instead remote into the box and type it — either way you take over after.)  ## Step 6 — The handoff back to Fusion (Autodesk Identity Manager) After auth, the browser lands on `signin.autodesk.com/idmgr/callback#code=...` ("You're signed in").-The code is delivered to Fusion by the **Autodesk Identity Manager** protocol, so Edge pops a-**"This site is trying to open Autodesk Identity Manager"** overlay: tick **"Always allow"** and click-**"Open"**. (Always-allow means later sign-ins skip the prompt.) If instead you see a big+The code is delivered to Fusion by the **Autodesk Identity Manager** protocol, so the browser pops a+**"Open Autodesk Identity Manager?"** sheet: tick **"Always allow"** and click **"Open"**. It is part+of the browser window (not a separate window), so a window-list scan will never show it — take a+screenshot. It also needs a REAL click (`desktop_click`, CGEvent) or an `nbrowser` CDP click; an+Accessibility press is not a user gesture as far as the browser is concerned, and the protocol+launch will be silently blocked. (Always-allow means later sign-ins skip the prompt.) If instead you see a big **"Open Product"** button, click it.  ## Step 7 — SPEED: the code expires (~2 min)@@ -82,8 +83,8 @@ across the tabs, it dies and you loop forever. Mitigations: - Once the Autodesk/browser session is warm (after the first successful auth), a fresh Fusion   "Sign In" click completes almost instantly — so if a code expires, just click Fusion "Sign In"   AGAIN for a fresh code; you don't redo the whole login.-- If Edge tabs get stuck on a stale expired-callback URL, clear them (`taskkill /F /IM msedge.exe` —-  browser-specific and safe; Autodesk cookies persist so it stays warm) and re-click Fusion "Sign In".+- If browser tabs get stuck on a stale expired-callback URL, close them (`cmd+w` on each, or quit+  the browser — Autodesk cookies persist so the session stays warm) and re-click Fusion "Sign In".  ## Step 8 — Confirm Poll `fusion_readiness` until `ready:true` (needsSignin clears, the add-in responds). Now Fusion is@@ -92,21 +93,20 @@ drivable: `fusion_open_lbr`, `fusion_build_library_3d`, exports, GPU/graphics ch ## Escalation ladder (in order) 1. Warm-SSO click-through (no secret) — try first. 2. Type the user's EMAIL only; let the provider's warm session finish it.-3. `fusion_notify_owner` for a genuine password/2FA/UAC/physical wall — the ONLY time a human is needed.+3. `fusion_notify_owner` for a genuine password/2FA/Gatekeeper/physical wall — the ONLY time a human is needed. 4. Ask the user to remote in — last resort if toasting doesn't land.  ## Related-- `fusion-onboarding` — the install that precedes this (streams Fusion, then hands off here).-- `fusion-bridge-dev` — how the bridge detects installed/installing/ready (Fusion360.exe completeness).+- `fusion-onboarding` — the install that precedes this (Autodesk dmg, then hands off here).+- `fusion-bridge-dev` — how the bridge detects installed/installing/ready (webdeploy bundle-binary completeness). -## ⭐ FIRST RULE FOR ANY BROWSER AUTOMATION: install + use ABE (nbrowser), don't coordinate-click (John, emphatic 2026-07-14)+## ⭐ FIRST RULE FOR ANY BROWSER AUTOMATION: install + use NBE (nbrowser), don't coordinate-click (John, emphatic 2026-07-14)  The MOMENT a task needs you to DRIVE a browser (the Autodesk OAuth, the APS portal at aps.autodesk.com/myapps, any web form), your FIRST move is to **recommend and install the-adom-browser-extension (ABE / nbrowser)** and drive via `nbrowser_*` (JS-level: read the DOM, click by-selector/text, reliably). Do NOT limp along with `desktop_click`/SendKeys coordinate-driving — on a VM-that Edge crashes, tabs multiply, buttons sit at the nav edge and clicks miss, and you waste enormous-time (learned the hard way here). Tell the user up front: "I need to install ABE to automate this-browser reliably." Install: `bridge_install {manifestUrl: .../adom-browser-extension/files/native-browser-bridge-manifest.json}`,+adom-native-browser (NBE / nbrowser)** and drive via `nbrowser_*` (JS-level: read the DOM, click by+selector/text, reliably). Do NOT limp along with coordinate-driving — tabs multiply, buttons sit at+the window edge and clicks miss, and you waste enormous time (learned the hard way here). Tell the user up front: "I need to install NBE to automate this+browser reliably." Install (MAC line — never the Windows `adom/nb-bridge` manifest on a Mac, it cannot register the native-messaging host there): `bridge_install {manifestUrl: "https://wiki.adom.inc/api/v1/pages/nb-bridge-macos/files/native-browser-macos-bridge-manifest.json"}`, then the `installing-the-extension` flow, then `nbrowser_readiness` until `state:"ready"`. Coordinate- driving is the fallback of last resort, never the default.
skills/fusion-build-parts-library/SKILL.md+2−2
@@ -12,7 +12,7 @@ build a 3D package per *footprint* (~10), then clone a deviceset per *value* (13  ## Step 1 - get the catalog + collapse it to unique footprints -The Adom basic parts catalog lives in the **[basic-parts-library](https://wiki.adom.inc/basic-parts-library)**+The Adom basic parts catalog lives in the **[adom-basic-parts-fusion-lbr](https://wiki.adom.inc/adom/adom-basic-parts-fusion-lbr)** wiki page (the parts array is embedded in its viewer html). Each part has `type`, `value`, `package`, `mfrPN`, `manufacturer`. Collapse to the unique **`(type, package)`** combos - the 138 parts are just **10 footprints**: R-0402, R-0603, C-0402, C-0603, C-0805, L, LED-0402, LED-0603, LED-2020, FB-0402.@@ -91,7 +91,7 @@ exports STEP in ONE call. Params are datasheet **mm** (auto-converted). markings are separate `Marking` bodies (white in Fusion and in the colored STEP).  ```bash-adom-desktop fusion_generate_package '{"type":"soic","params":{"DPins":8,"D":4.9,"E":6.0,"E1":3.9,"e":1.27,"A":1.6,"A1":0.1,"b":0.41,"L":0.84},"etch":"LM358","outputStep":"/tmp/ADOM-LM358-SOIC8.step"}'+adom-bridge fusion_generate_package '{"type":"soic","params":{"DPins":8,"D":4.9,"E":6.0,"E1":3.9,"e":1.27,"A":1.6,"A1":0.1,"b":0.41,"L":0.84},"etch":"LM358","outputStep":"/tmp/ADOM-LM358-SOIC8.step"}' ```  Read the verb's `_hint` on every call - it carries the band/margin/contrast rules and the per-family
skills/fusion-demo/SKILL.md+14−13
@@ -1,14 +1,14 @@ --- name: fusion-demo description: >-  Run a FIRST-TIME-USER demo of the Fusion 360 bridge - the guided tour Hydrogen Desktop's installer+  Run a FIRST-TIME-USER demo of the Fusion 360 bridge - the guided tour Adom Hydrogen's installer   fires when someone new wants to see what this thing does. Covers the one verb (fusion_demo), the   staged loop, and the two rules that make or break it: FINISH the Autodesk sign-in (never leave a new-  user parked on the sign-in page) by driving the user's NATIVE browser via ABE/nbrowser_* (already+  user parked on the sign-in page) by driving the user's NATIVE browser via NBE/nbrowser_* (already   signed into Autodesk) instead of pup (anonymous), and SET UP APS cloud search rather than just   mentioning it, then prove it with a live sample search. Then show real work in order: electronics   PROJECT -> SCHEMATIC -> 2D BOARD -> 3D BOARD. Trigger words - fusion demo, demo the bridge, show me-  fusion, first time user demo, hd installer demo, demo verb, guided tour, showcase fusion, new user+  fusion, first time user demo, hydrogen installer demo, demo verb, guided tour, showcase fusion, new user   onboarding demo, fusion_demo. --- @@ -16,7 +16,7 @@ description: >  ## Why this exists -HD's installer ran a "demo" that opened Fusion and then **sat on the Autodesk sign-in page doing+Hydrogen's installer ran a "demo" that opened Fusion and then **sat on the Autodesk sign-in page doing nothing** (John, 2026-07-20). A first-time user watched an app open and stall. That is the single worst first impression this bridge can make, and this skill exists to make it impossible. @@ -25,9 +25,9 @@ worst first impression this bridge can make, and this skill exists to make it im ## The one verb  ```bash-adom-desktop fusion_demo '{}'                       # start / resume the tour-adom-desktop fusion_demo '{"query":"BQ25792"}'      # demo a specific design-adom-desktop fusion_demo '{"stage":"skip_aps"}'     # user declined cloud-search setup+adom-bridge fusion_demo '{}'                       # start / resume the tour+adom-bridge fusion_demo '{"query":"BQ25792"}'      # demo a specific design+adom-bridge fusion_demo '{"stage":"skip_aps"}'     # user declined cloud-search setup ```  It is **staged and resumable**. Every call advances as far as it safely can and returns:@@ -52,9 +52,9 @@ interrupted. The response tells you where it landed: | Field | Meaning | |---|---| | `signinOpened` | true if the background tab is up |-| `signinWhere` | the EXACT place, e.g. "Chrome - John Personal ([email protected])" - say this verbatim |+| `signinWhere` | the EXACT place, e.g. "Chrome - Personal ([email protected])" - say this verbatim | | `signinProfileChoices` | every profile (describe/email/displayName/active/live/extensionInstalled) |-| `signinProfile` / `signinSession` | the ABE profile + sessionId (`fusion-signin`) to drive it |+| `signinProfile` / `signinSession` | the NBE profile + sessionId (`fusion-signin`) to drive it |  ### Pick the profile by EVIDENCE, never by "whichever is active" @@ -92,9 +92,9 @@ Never silently sit and wait, and never foreground it uninvited.  Then: -- **Use ABE (`nbrowser_*`), never pup.** pup is an anonymous browser, so Autodesk demands a full+- **Use NBE (`nbrowser_*`), never pup.** pup is an anonymous browser, so Autodesk demands a full   login with password + 2FA. The user's real Chrome/Edge profile is **typically already signed into-  Autodesk**, so the same flow is one click. `nbrowser_profiles` lists their real profiles; ABE+  Autodesk**, so the same flow is one click. `nbrowser_profiles` lists their real profiles; NBE   exposes these verbs even before the browser extension is installed. - Click Fusion's **Sign In** in the BACKGROUND (`desktop_find_control` + `desktop_ui_click`), never a   coordinate click, never steal focus.@@ -145,8 +145,9 @@ Do not just report "not installed". OFFER, and be concrete AND honest about the - **Even an expired / read-only install still OPENS and VIEWS designs** (it only blocks   save/export/modify), so nothing they make gets locked away. -Then `fusion_install_fusion` (no shell approval needed, streams the installer, 10-30 min), poll-`fusion_readiness` until `installed:true`, and call `fusion_demo` again to pick the tour back up.+Then run the mac install yourself per **fusion-onboarding** (curl the Autodesk dmg, `hdiutil+attach`, `open "Install Autodesk Fusion.app"` — it streams for 10-30 min), poll `fusion_readiness`+until `installed:true`, and call `fusion_demo` again to pick the tour back up. Full flow: **fusion-onboarding**.  ## If something else is missing
skills/fusion-driving/SKILL.md+12−12
@@ -37,14 +37,14 @@ ways to get the array, in order of preference:    enforces this" below.) 2. **`fusion_screenshot_all`** - captures the main window PLUS every Qt dialog window as separate    shots, and returns the list of saved paths. Read each.-3. **`desktop_screenshot_window {"hwnd": <fusion-hwnd>}`** (AD core) - returns `screenshots[]` and+3. **`desktop_screenshot_window {"hwnd": <fusion-hwnd>}`** (Adom Bridge core) - returns `screenshots[]` and    **`ownedPopupCount`**. `ownedPopupCount > 0` means dialogs are stacked on the window. Read the    shots. Get the hwnd from `fusion_window_info` (its `hwnd` field) or `desktop_find_window    {"titleContains":"Autodesk Fusion"}`.  **To actually SEE a shot - mind WHERE it lands:**-- AD core `desktop_screenshot_window {hwnd}` saves the PNG **into your container** (e.g.-  `/tmp/adom-desktop-screenshots/`) - Read it directly.+- Adom Bridge core `desktop_screenshot_window {hwnd}` saves the PNG **into your container** (e.g.+  `/tmp/adom-bridge-screenshots/`) - Read it directly. - The bridge's own captures (the auto `dialogArray[].screenshot` paths and `fusion_screenshot_all`)   are saved on this machine (`/tmp/conduit-screenshots/`). To see one, either re-capture that   hwnd with `desktop_screenshot_window {hwnd}` (lands in your container) or `desktop_pull_file` it over.@@ -58,7 +58,7 @@ Either way, LOOK - do not describe it from memory.   toward the foreground - **which disrupts the user, who may be doing something else.** It also   routinely captures the WRONG window. - ✅ **Always capture a specific `hwnd`** (`fusion_screenshot_all`, `fusion_screenshot_fusion`,-  `desktop_screenshot_window {hwnd}`). These use `PrintWindow` / WGC and capture the **exact window+  `desktop_screenshot_window {hwnd}`). These use `screencapture -l` on the window id and capture the **exact window   in the BACKGROUND** without bringing it forward. Fusion keeps running behind whatever the user is   doing. This is the only acceptable way to look at Fusion. @@ -75,13 +75,13 @@ A dialog has a correct answer that depends on what it says. Clicking the default To act on a specific dialog, target its `hwnd`: `fusion_click_fusion {"hwnd":<dlg>, ...}`, `fusion_send_key {"hwnd":<dlg>, "key":"escape"}`, or `fusion_close_window {"hwnd":<dlg>}`. -### ⛔ Dismiss in the BACKGROUND - `close_window` (WM_CLOSE), NEVER `send_key`/Escape+### ⛔ Dismiss in the BACKGROUND - `close_window` (AX close button), NEVER `send_key`/Escape -When you DO dismiss a dialog, use **`fusion_close_window {"hwnd":<dlg>}`** (WM_CLOSE via PostMessage =-Cancel/No). It dismisses **without stealing focus**. ⛔ **Do NOT use `fusion_send_key`/Escape to expire-a dialog** - `send_key` calls `SetForegroundWindow` and **YANKS Fusion to the foreground**, disrupting-the user (caught 2026-06-29: an Escape pulled Fusion to the front mid-task). WM_CLOSE is also more-reliable than Escape on Qt dialogs. The bridge's own auto-dismiss paths (`_dismiss_dialogs_bg`, the+When you DO dismiss a dialog, use **`fusion_close_window {"hwnd":<dlg>}`** (the window's+Accessibility close button = Cancel/No). It dismisses **without stealing focus**. ⛔ **Do NOT use+`fusion_send_key`/Escape to expire a dialog** - `send_key` must activate the app first and **YANKS+Fusion to the foreground**, disrupting the user (caught 2026-06-29: an Escape pulled Fusion to the+front mid-task). The AX close is also more reliable than Escape on Qt dialogs. The bridge's own auto-dismiss paths (`_dismiss_dialogs_bg`, the long-command pre-dismiss) all use `close_window` for exactly this reason. Background screenshots + background dismiss = the user never sees Fusion jump around. @@ -92,7 +92,7 @@ background dismiss = the user never sees Fusion jump around. | **"packages are being uploaded", "lose these changes", "are you sure you want to close"** | A doc is closing while 3D packages still upload to the Hub. Closing = **lose the packages + unsaved bindings**. | Click **No**. WAIT and poll until the upload finishes (see [fusion-cloud-save](../fusion-cloud-save/SKILL.md)), THEN close/save. NEVER click Yes. | | **"cannot be saved while packages are being uploaded", "save was cancelled"** | You tried saveAs mid-upload; Fusion refused. | Not fatal. Wait for the Hub upload to finish, then retry the saveAs (poll past it). | | **"needs to update", "update is available", "software update"** | Fusion wants to self-update. | Do NOT auto-confirm (it can update mid-automation). Clear on the desktop or let it finish, then retry. A pending update also causes add-in/host version-drift crashes. |-| **"select electronics design", "linked to multiple"** | A file links to multiple electronics designs; CEF picker. | Its list is NOT Win32/keyboard navigable. Open the specific design by URN/API instead, or select on the desktop. See [fusion-electronics](../fusion-electronics/SKILL.md). |+| **"select electronics design", "linked to multiple"** | A file links to multiple electronics designs; CEF picker. | Its list is NOT Accessibility/keyboard navigable. Open the specific design by URN/API instead, or select on the desktop. See [fusion-electronics](../fusion-electronics/SKILL.md). | | **"recovery", "recover unsaved", "document recovery"** | Document Recovery prompt. | `fusion_dismiss_recovery`, or `fusion_relocate_recovery` BEFORE `fusion_start` to prevent it. | | **"save changes", "unsaved changes", "do you want to save"** | Unsaved-changes prompt on close. | Use `fusion_close_document` (closes without the save modal). Only Escape/Cancel if you mean to keep editing. | | **"what do you want to design"** | Fusion's start picker (no doc open). | `fusion_send_key {"key":"escape"}`. |@@ -140,7 +140,7 @@ commands and told the AI to read them. That same capture now fires after **all m   only surfaced when the main window is actually disabled (`mainWindowEnabled:false` - a real modal is   up) or it matches a known dialog by title. That keeps the hint from crying wolf on every op, - on detection, classifies each (`classify_blocking_dialogs`) and screenshots it by hwnd-  (`screenshot_hwnd`, background `PrintWindow`),+  (`screenshot_hwnd`, background `screencapture -l`), - returns `dialogsDetected` + `dialogs[]` + a top-level `_hint` that says **ANALYZE these before   proceeding; do NOT blind-dismiss**. 
skills/fusion-eagle-commands/SKILL.md+4−4
@@ -1,13 +1,13 @@ --- name: fusion-eagle-commands-description: EAGLE command reference for Fusion 360 Electronics via fusion_electron_run. Use when driving the Fusion Electronics / PCB workspace through the Adom Desktop Fusion 360 bridge — the EAGLE-syntax commands (DRC, ROUTE, RATSNEST, DISPLAY, GRID, etc.) you pass to fusion_electron_run, and which ones BLOCK (ADD/SHOW/MOVE/WRITE/EDIT) vs are safe. Trigger words - eagle command, fusion_electron_run, electron run, DRC, ERC, RATSNEST, RIPUP, DISPLAY layers, WINDOW FIT, eagle layers, blocking command, WRITE blocks, export eagle source, eagle script.+description: EAGLE command reference for Fusion 360 Electronics via fusion_electron_run. Use when driving the Fusion Electronics / PCB workspace through the Adom Bridge Fusion 360 bridge — the EAGLE-syntax commands (DRC, ROUTE, RATSNEST, DISPLAY, GRID, etc.) you pass to fusion_electron_run, and which ones BLOCK (ADD/SHOW/MOVE/WRITE/EDIT) vs are safe. Trigger words - eagle command, fusion_electron_run, electron run, DRC, ERC, RATSNEST, RIPUP, DISPLAY layers, WINDOW FIT, eagle layers, blocking command, WRITE blocks, export eagle source, eagle script. ---  # EAGLE Commands for `fusion_electron_run` -> **Owned by the `adom-desktop-fusion-bridge` skill package.** This reference is Fusion-Electronics-> specific, so it ships here (you get it via `adom-wiki pkg install adom/adom-desktop-fusion-bridge`),-> not the adom-desktop core package. Companion skill: `fusion-electronics` (driving the editor).+> **Owned by the `fusion-bridge-macos` skill package.** This reference is Fusion-Electronics+> specific, so it ships here (you get it via `adom-wiki pkg install adom/fusion-bridge-macos`),+> not the adom-bridge core package. Companion skill: `fusion-electronics` (driving the editor).  Fusion's Electronics workspace is built on EAGLE. `fusion_electron_run` sends a text command through the same interface EAGLE's command line uses. 
skills/fusion-electronics/SKILL.md+6−6
@@ -45,19 +45,19 @@ one call = one smooth move, a repaint per frame (the 2D analogue of `vp.refresh(  ### Zoom (schematic / 2D board) `fusion_electron_zoom {factor, steps?, frameDelayMs?}` - `factor>1` zooms in, `<1` out; or `{fit:true}`.-  e.g. `adom-desktop fusion_electron_zoom '{"factor":3,"steps":20}'` (smooth zoom in over 20 frames).+  e.g. `adom-bridge fusion_electron_zoom '{"factor":3,"steps":20}'` (smooth zoom in over 20 frames).  ### Pan + frame a region (or a part) `fusion_electron_pan {x1,y1,x2,y2, steps?, frameDelayMs?}` - glide+zoom to a board-coordinate box (mm). Animates from where the view last was. Get part coordinates from `fusion_board_info` or the CPL export (`fusion_export_cpl` gives every part's Mid X / Mid Y) - frame a small box around a part to "go to" it.-  e.g. `adom-desktop fusion_electron_pan '{"x1":10,"y1":15,"x2":22,"y2":38,"steps":16}'`.+  e.g. `adom-bridge fusion_electron_pan '{"x1":10,"y1":15,"x2":22,"y2":38,"steps":16}'`.  ### Select a part + surface its properties `fusion_electron_select {name}` (reference designator) or `{x,y}` (board mm) - selects the part the way clicking it reveals the properties panel, and returns its device info. (Select highlights; pair with `fusion_electron_pan` to also center on it - the "select chip -> zoom to it" tour.)-  e.g. `adom-desktop fusion_electron_select '{"name":"U1"}'`.+  e.g. `adom-bridge fusion_electron_select '{"name":"U1"}'`.  ### Orbit / zoom the 3D PCB (Fusion camera) `fusion_show_3d_board`, then `fusion_run_modeling_script` with a camera loop: `app.activeViewport.camera`,@@ -72,9 +72,9 @@ step the eye around the target in azimuth (vary radius to zoom), `cam.isSmoothTr `sch_get_deviceinfo`. Reach for these only when a first-class verb doesn't cover what you need.  ### Capture without disrupting the user-Record with WGC (`desktop_record_window_start`) - background, no focus steal, and it grabs the LIVE EAGLE-GL canvas. PrintWindow (`desktop_screenshot_window`) shows the chrome but does NOT reflect the GL view-changing, so verify motion by the verb's `ok` + a WGC frame, not a PrintWindow pixel-diff. A black canvas+Record with `desktop_record_window_start` - background, no focus steal, and it grabs the LIVE EAGLE+GL canvas. A window capture (`desktop_screenshot_window`) shows the chrome but does NOT reflect the GL view+changing, so verify motion by the verb's `ok`, not a window-capture pixel-diff. A black canvas means an empty/wrong file - see section 1.  ## Gotcha: file paths WITH SPACES (fixed in v1.6.90 - issue #196)
skills/fusion-libraries/LIBRARY_FINDINGS.md+8−9
@@ -22,7 +22,7 @@ the thin 245KB `manufacturer.step`. That gave a footprint/3D size mismatch. Swit `.fusion.kicad_mod` + `-named.step` is the fix. (Convention confirmed in `chip-fetcher/src/thumbnails.rs`: it builds the lbr with `--name <mpn>.fusion` from the `.fusion` files.) -![adom-lbr's viewer: symbol | the curated 4-sided LQFP-64 footprint | the embossed 3D | pin->pad map - inspect this before touching Fusion](https://wiki.adom.inc/adom/adom-desktop-fusion-bridge/files/lib-06-adomlbr-viewer.png)+![adom-lbr's viewer: symbol | the curated 4-sided LQFP-64 footprint | the embossed 3D | pin->pad map - inspect this before touching Fusion](https://wiki.adom.inc/adom/fusion-bridge/files/lib-06-adomlbr-viewer.png)  ## 2. adom-lbr is the right tool; pass it the .fusion files @@ -34,10 +34,9 @@ adom-lbr-generated `.lbr` parses fine.  ## 3. Getting the .lbr / .step onto Windows -The pipeline runs in the cloud container; Fusion runs on Windows; there is NO container->Windows push-verb. Serve the files (`python3 -m http.server 8931`) and pull them with `shell_execute` +-`Invoke-WebRequest -OutFile C:\Users\<user>\adom-lib\...`. Build the shell JSON with `json.dumps`-(Windows paths need `\\`).+The pipeline runs in the cloud container; Fusion runs on the user's Mac. Use `send_files` to push+them across, or serve them (`python3 -m http.server 8931`) and pull with+`shell_execute {"command":"curl -L -o ~/adom-lib/NAME.lbr <url>"}`.  ## 4. Opening the footprint in the 3D viewer (Package3DEnvironment) @@ -111,14 +110,14 @@ Fusion error dialogs (e.g. "<file>.lbr has errors and cannot be opened") are **o NOT enumerate in `desktop_list_windows` and are invisible to a plain capture of the main window. A `fusion_*` verb can return `success:true` while an error dialog is actually up. -**`desktop_screenshot_window {hwnd}` (AD v1.8.177+) captures them automatically** and returns them at the+**`desktop_screenshot_window {hwnd}` (Adom Bridge v1.8.177+) captures them automatically** and returns them at the TOP LEVEL: **`ownedPopupCount`** (always present; 0 = none) + **`_screenshots[]`** (each owned popup: `title`, `kind:"owned_popup"`, `localSafePath`, `rect`, `coordMap`). The CLI auto-pulls each popup PNG.  RULE: after every Fusion open / `execute_text_command` / generator FINISH, grab `desktop_screenshot_window` on the Fusion main hwnd and **check `ownedPopupCount` / read the `screenshots[]` array** (each entry: `title`, `localSafePath`, `coordMap`, `shotId`; the CLI auto-pulls-each PNG to `/tmp/ad-shots/`). Do NOT just read `output.data.image` (that is the main window only and+each PNG to `/tmp/bridge-shots/`). Do NOT just read `output.data.image` (that is the main window only and misses owned dialogs). Treat `ownedPopupCount > 0` as "a dialog is up - read each popup before proceeding." (Field note: `_screenshots`/`_popups_note` are doc-strings; the real array is `screenshots`.) @@ -131,9 +130,9 @@ package under the deviceset, the Packages panel's `Package` column flips from `P name, and the 3D preview becomes the real chip. **This is the first time the full Fusion electronics 3D attach has been automated through the bridge.** -![The real ADS8588SIPM chip imported + auto-oriented onto the matched 4-sided footprint in the Package3D environment](https://wiki.adom.inc/adom/adom-desktop-fusion-bridge/files/lib-10-ads-chip-on-footprint.png)+![The real ADS8588SIPM chip imported + auto-oriented onto the matched 4-sided footprint in the Package3D environment](https://wiki.adom.inc/adom/fusion-bridge/files/lib-10-ads-chip-on-footprint.png) -![Bound: the Content Manager shows the 3D under the package under the deviceset, and the Packages `Package` column reads the part name (not Placeholder) with the real 3D preview](https://wiki.adom.inc/adom/adom-desktop-fusion-bridge/files/lib-09-3d-bound-moneyshot.png)+![Bound: the Content Manager shows the 3D under the package under the deviceset, and the Packages `Package` column reads the part name (not Placeholder) with the real 3D preview](https://wiki.adom.inc/adom/fusion-bridge/files/lib-09-3d-bound-moneyshot.png)  The repeatable sequence (all via existing verbs): 1. Build the `.lbr` from the chip-fetcher **`.fusion`** variant (`adom-lbr generate`); footprint must be a
skills/fusion-libraries/MAKING_LIBRARIES.md+20−20
@@ -4,7 +4,7 @@ How an Adom component library is built and gets into Fusion 360 Electronics as a captured end to end on a real part (Nordic **nRF54L15**). It covers the parts that work today and the one hard step that is still being automated: attaching the real 3D chip via a Fusion cloud URN. -> Companion skill: `skills/fusion-libraries/SKILL.md`. Verb reference: [VERBS.md](https://wiki.adom.inc/adom/adom-desktop-fusion-bridge/files/VERBS.md).+> Companion skill: `skills/fusion-libraries/SKILL.md`. Verb reference: [VERBS.md](https://wiki.adom.inc/adom/fusion-bridge-macos/files/VERBS.md).  ## Demo video @@ -12,11 +12,11 @@ A real screen recording, ~55 seconds (burned-in captions + voiceover): starting source view (symbol, the 4-sided footprint, and the 3D), the library opens in Fusion, `fusion_attach_3d_package` attaches the real 3D chip onto the footprint, then the library is saved to the cloud and reopened so the 3D binds onto the deviceset - a complete library: symbol, footprint, 3D,-and deviceset. Live screen capture (WGC + the adom-lbr pup viewer), not stitched stills.+and deviceset. Live screen capture (the adom-lbr pup viewer), not stitched stills. -<video controls width="100%" src="https://wiki.adom.inc/api/v1/pages/adom-desktop-fusion-bridge/files/library-3d-demo.mp4"></video>+<video controls width="100%" src="https://wiki.adom.inc/api/v1/pages/fusion-bridge/files/library-3d-demo.mp4"></video> -[Watch / download the demo video](https://wiki.adom.inc/api/v1/pages/adom-desktop-fusion-bridge/files/library-3d-demo.mp4)+[Watch / download the demo video](https://wiki.adom.inc/api/v1/pages/fusion-bridge/files/library-3d-demo.mp4)  ## The pipeline @@ -44,19 +44,19 @@ The `.lbr` is built in the cloud container; Fusion runs on Windows. There is **n push verb**, so stage the file first, then open the Windows path.  ```bash-# serve from the container-cd <dir-with-lbr> && python3 -m http.server 8931-# download onto Windows (build the JSON in Python; Windows paths need \\ )-adom-desktop shell_execute '{"command":"powershell -NoProfile -Command \"Invoke-WebRequest -Uri https://<workspace>.adom.cloud/proxy/8931/NAME.lbr -OutFile C:\\Users\\<user>\\adom-lib\\NAME.lbr\""}'+# push straight from the container to the Mac+adom-bridge send_files '{"files":["NAME.lbr"],"destination":"~/adom-lib/"}'+# (or: serve with `python3 -m http.server 8931` and pull with+#  adom-bridge shell_execute '{"command":"mkdir -p ~/adom-lib && curl -L -o ~/adom-lib/NAME.lbr <url>"}') # open it-adom-desktop fusion_open_lbr '{"filePath":"C:/Users/<user>/adom-lib/NAME.lbr","verify":true}'-adom-desktop fusion_get_app_state '{}'   # expect activeWorkspace "Electronics Library", isElectronics true+adom-bridge fusion_open_lbr '{"filePath":"~/adom-lib/NAME.lbr","verify":true}'+adom-bridge fusion_get_app_state '{}'   # expect activeWorkspace "Electronics Library", isElectronics true ```  The library loads with symbol + footprint + deviceset. The 3D package is a **placeholder** (the Content Manager 3D tab is empty). This is correct, and is the gap the rest of this guide closes. -![Library open in the Electronics Library editor; symbol + footprint mapped, 3D still a placeholder](https://wiki.adom.inc/adom/adom-desktop-fusion-bridge/files/lib-01-open.png)+![Library open in the Electronics Library editor; symbol + footprint mapped, 3D still a placeholder](https://wiki.adom.inc/adom/fusion-bridge/files/lib-01-open.png)  ## Step 2 - put the 3D model in the Fusion cloud (get a URN) @@ -65,10 +65,10 @@ Fusion does NOT embed the STEP in the `.lbr`. A package references its 3D model first. Stage the STEP to Windows (same as step 1), then upload it:  ```bash-adom-desktop fusion_aps_browse '{}'                                   # find hub + project-adom-desktop fusion_aps_browse '{"projectId":"<proj>"}'               # find the root folder-adom-desktop fusion_aps_create_folder '{"projectId":"<proj>","parentFolderId":"<root>","name":"Electronics 3D"}'-adom-desktop fusion_aps_upload '{"projectId":"<proj>","folderId":"<folder>","localPath":"C:/Users/<user>/adom-lib/NAME.step","fileName":"NAME-3D.step"}'+adom-bridge fusion_aps_browse '{}'                                   # find hub + project+adom-bridge fusion_aps_browse '{"projectId":"<proj>"}'               # find the root folder+adom-bridge fusion_aps_create_folder '{"projectId":"<proj>","parentFolderId":"<root>","name":"Electronics 3D"}'+adom-bridge fusion_aps_upload '{"projectId":"<proj>","folderId":"<folder>","localPath":"C:/Users/<user>/adom-lib/NAME.step","fileName":"NAME-3D.step"}' # -> { "itemUrn": "urn:adsk.wipprod:dm.lineage:...", "bytes": ... } ``` @@ -81,13 +81,13 @@ and returned a real URN. (`Electron.getCloudPathFromUrn` confirms the 3D package Fusion exposes a scriptable entry point:  ```bash-adom-desktop fusion_execute_text_command '{"command":"Electron.Create3DPackage C:/Users/<user>/adom-lib/NAME.lbr"}'+adom-bridge fusion_execute_text_command '{"command":"Electron.Create3DPackage C:/Users/<user>/adom-lib/NAME.lbr"}' ```  This opens the **3D PACKAGE Generator**: a Design-workspace authoring document with the footprint loaded (the green courtyard + `>NAME` / `>VALUE`), and a PACKAGE / SELECT / FINISH ribbon. -![The 3D Package Generator with the nRF54L15 footprint loaded, ready for a model](https://wiki.adom.inc/adom/adom-desktop-fusion-bridge/files/lib-02-generator.png)+![The 3D Package Generator with the nRF54L15 footprint loaded, ready for a model](https://wiki.adom.inc/adom/fusion-bridge/files/lib-02-generator.png)  The generator is itself an `adsk::fusion::Design` in the **`Package3DEnvironment`** workspace, with three command definitions: `Package3DCmd`, `Package3DCreateCmd`, `Package3DStop` (Stop = FINISH).@@ -107,7 +107,7 @@ ui.commandDefinitions.itemById("Package3DStop").execute()                 # FINI This **works**: the real chip imports at correct scale, orients flat, centered on the footprint, and FINISH saves a 3D package to the cloud (the Save dialog Name/Location are confirmed via `desktop_ui_click`). -![The ADS8588SIPM chip seated on its matched 4-sided LQFP-64 footprint in the Package3D viewer](https://wiki.adom.inc/adom/adom-desktop-fusion-bridge/files/lib-10-ads-chip-on-footprint.png)+![The ADS8588SIPM chip seated on its matched 4-sided LQFP-64 footprint in the Package3D viewer](https://wiki.adom.inc/adom/fusion-bridge/files/lib-10-ads-chip-on-footprint.png)  ### SOLVED - the 3D binds, end to end @@ -117,7 +117,7 @@ Launched from the **open library**, `Electron.Create3DPackage` -> import the mod Packages panel's `Package` column flips from `Placeholder` to the part name, and the 3D preview becomes the real chip. First time the full Fusion electronics 3D attach is automated via the bridge. -![3D bound: Content Manager shows the real chip under the package, Package column = part name](https://wiki.adom.inc/adom/adom-desktop-fusion-bridge/files/lib-09-3d-bound-moneyshot.png)+![3D bound: Content Manager shows the real chip under the package, Package column = part name](https://wiki.adom.inc/adom/fusion-bridge/files/lib-09-3d-bound-moneyshot.png)  GOTCHA: the right-panel preview LAGS after FINISH (still shows the gray placeholder for a moment) - the Content Manager tree / `Package` column is the source of truth; re-grab the window after a beat.@@ -158,7 +158,7 @@ directly given the model's versioned file URN. Full detail: [LIBRARY_FINDINGS.md | Verb | What it did here | |---|---| | `adom-lbr generate` / `validate` | build + validate `NAME.lbr` |-| `shell_execute` (PowerShell `Invoke-WebRequest`) | stage `.lbr` / `.step` onto Windows |+| `send_files` (or `shell_execute` + `curl`) | stage `.lbr` / `.step` onto the Mac | | `fusion_open_lbr` | open the library in the Electronics Library editor | | `fusion_get_app_state` | confirm active doc / workspace / isElectronics | | `desktop_find_window` + `desktop_screenshot_window` | capture the Fusion window |
skills/fusion-mcp-and-preferences/SKILL.md+11−11
@@ -26,12 +26,12 @@ own text-to-CAD surface. it. The fusion bridge runs on that machine, so it proxies:  ```bash-adom-desktop fusion_mcp_status '{}'          # up? serverInfo + live tool list-adom-desktop fusion_mcp_enable '{}'          # turn it ON for the user-adom-desktop fusion_mcp_tools  '{}'          # tools WITH input schemas-adom-desktop fusion_mcp_call   '{"tool":"fusion_mcp_electronics_read",+adom-bridge fusion_mcp_status '{}'          # up? serverInfo + live tool list+adom-bridge fusion_mcp_enable '{}'          # turn it ON for the user+adom-bridge fusion_mcp_tools  '{}'          # tools WITH input schemas+adom-bridge fusion_mcp_call   '{"tool":"fusion_mcp_electronics_read",                                  "arguments":{"entity_type":"electronics.Element"}}'-adom-desktop fusion_mcp_resources '{}'       # electronics entity schemas+adom-bridge fusion_mcp_resources '{}'       # electronics entity schemas ```  ### Do not ask the user to enable it@@ -94,10 +94,10 @@ The API exposes a thin slice (`generalPreferences`: theme/orbit/units; `apiPrefe `debuggingPort`, `isDeveloperToolsEnabled`). Everything else is UI-only.  ```bash-adom-desktop fusion_prefs_open  '{"section":"api"}'   # opens + navigates + screenshots+adom-bridge fusion_prefs_open  '{"section":"api"}'   # opens + navigates + screenshots # look at the screenshot, then click what you see:-adom-desktop desktop_click '{"space":"image","shotId":"<from response>","x":690,"y":476,"hwnd":<hwnd>}'-adom-desktop fusion_prefs_close '{"save":true}'       # Apply + OK+adom-bridge desktop_click '{"space":"image","shotId":"<from response>","x":690,"y":476,"hwnd":<hwnd>}'+adom-bridge fusion_prefs_close '{"save":true}'       # Apply + OK ```  Sections: `general`, `api`, `design`, `manufacture`, `electronics`, `render`, `drawing`,@@ -106,7 +106,7 @@ Sections: `general`, `api`, `design`, `manufacture`, `electronics`, `render`, `d ### Why it returns an image instead of control names  `Commands.Start PreferencesCommand` opens the dialog, and the **top-level** section tree IS in the-UIA tree. But the children under General (API, Design, Manufacture, Electronics, Render, Drawing,+Accessibility tree. But the children under General (API, Design, Manufacture, Electronics, Render, Drawing, Simulation) are rendered **lazily by Qt** and never appear there, even after `desktop_ui_expand` reports success. So child navigation is an image-space click, which takes the foreground and is announced with a caption.@@ -124,5 +124,5 @@ announced with a caption.  On the canonical (Windows) page — the guides apply to the client verbs verbatim: -- https://wiki.adom.inc/adom/adom-desktop-fusion-bridge/fusion-mcp-server.md-- https://wiki.adom.inc/adom/adom-desktop-fusion-bridge/fusion-preferences.md (with screenshots of all three steps)+- https://wiki.adom.inc/adom/fusion-bridge/fusion-mcp-server.md+- https://wiki.adom.inc/adom/fusion-bridge/fusion-preferences.md (with screenshots of all three steps)
skills/fusion-molecule-export/SKILL.md+1−1
@@ -87,7 +87,7 @@ pipeline: anchor to MP pins -> optional silk bake -> gold pins -> dedup/flatten/ prune -> Draco), so the same board comes out **~465 KB / ~31 draw calls, auto-anchored**. ALWAYS use this for a component page's `component.parts.model_3d` - never a raw STEP->GLB. -Two verbs, because a big board tessellates for minutes (longer than the AD relay's ~60s+Two verbs, because a big board tessellates for minutes (longer than the Adom Bridge relay's ~60s request timeout), so it is submit-then-poll, never one long blocking call:  ```
skills/fusion-multipart-libraries/CREATING_BASIC_PARTS_LIBRARIES.md+4−4
@@ -59,7 +59,7 @@ symbol body.** Not optional. A symbol that is just pins-and-a-box is a FAIL. | **adom-symbol** | builds + renders the schematic symbol AND the **3D-outline SVG** that becomes the symbol-art | `adom-symbol serve` (live app) + `adom-symbol ui ...` to drive it; `render` / `embed` | | **adom-footprint** | builds + renders the footprint (`.kicad_mod`) with layer / paste-dot views | `adom-footprint serve` + `ui`; `embed` | | **adom-lbr** | assembles the EAGLE `.lbr` (symbol + footprint + deviceset), embeds the symbol-art, writes the 3D sidecar | `adom-lbr generate ...`; `adom-lbr serve --file X.lbr` (symbol \| footprint \| 3D + pin-map viewer) |-| **adom-desktop-fusion-bridge** (this repo) | opens the `.lbr` in Fusion and attaches the 3D | `fusion_open_lbr`, `fusion_attach_3d_package` |+| **fusion-bridge-macos** (this repo) | opens the `.lbr` in Fusion and attaches the 3D | `fusion_open_lbr`, `fusion_attach_3d_package` | | **the Adom Basic Parts wiki** (`adom/basic-parts-library`) | the canonical catalog: 79 resistors, 40 MLCCs, 6 inductors, 11 LEDs, ferrite beads | open the page in a pup tab (it has a fun interactive viewer) |  ## Build recipe (per part)@@ -88,8 +88,8 @@ symbol body.** Not optional. A symbol that is just pins-and-a-box is a FAIL.    the per-part files: keep one file's `<layers>` skeleton, then concatenate every part's `<package>`,    `<symbol>`, `<deviceset>` (and `<package3d>` if pre-bound) children. Names are MPN-unique, so no    collisions. Validate: `adom-lbr validate combined.lbr`.-4. **Into Fusion.** Stage `combined.lbr` (+ each `<MPN>.step`) to Windows (no container→Windows push-   verb - serve + `Invoke-WebRequest`), `fusion_open_lbr`, then `fusion_attach_3d_package` **once per+4. **Into Fusion.** Stage `combined.lbr` (+ each `<MPN>.step`) onto the Mac with `send_files`+   (or serve + `curl`), `fusion_open_lbr`, then `fusion_attach_3d_package` **once per    part** (pass `packageName`). Save the library to the cloud, **close, reopen** - that forces the 3D    previews to refresh from gray placeholder to the real chip. @@ -101,7 +101,7 @@ symbol body.** Not optional. A symbol that is just pins-and-a-box is a FAIL.   chip-fetcher-lite's category status boxes lighting up, **adom-symbol showing the symbol WITH the 3D   outline**, adom-footprint's layers, the adom-lbr viewer (symbol \| footprint \| 3D), the fun   basic-parts wiki page.-- Record **Fusion** (WGC, `desktop_record_window_start` on the main "Autodesk Fusion" window) opening+- Record **Fusion** (`desktop_record_window_start` on the main "Autodesk Fusion" window) opening   the combined library and attaching the 3D. - Speed the snippets up and stitch them in **video-post** (`adom-video-post`): a "what it takes"   montage with burned-in captions + a TTS voiceover. Publish to this page and show it in pup.
skills/fusion-multipart-libraries/SKILL.md+4−4
@@ -45,7 +45,7 @@ fusion_build_library_3d {  ### ⚠️ Relay timeout - a many-part run "times out" but KEEPS GOING (don't panic) -The `adom-desktop` relay times out the *request* at ~60s, but `fusion_build_library_3d` for a dozen+The `adom-bridge` relay times out the *request* at ~60s, but `fusion_build_library_3d` for a dozen parts takes minutes. So you will often get **`status: timeout / Request timed out` while the build is still running server-side and finishes fine.** Do NOT treat that as failure. Instead: @@ -193,9 +193,9 @@ failed"; the f3d-bound nRF renders a clean black QFN.) ## ⛔ Do NOT use the GUI Package3D generator for this (it is dialog-trapped)  `Electron.Create3DPackage` + import + `Package3DStop` (FINISH) is the manual/GUI way and it is a trap:-- FINISH pops a native Save dialog AND **two opaque "Fusion360" CEF modals** that are unreadable by-  Win32, by UIA (`desktop_find_control` finds nothing), and by PrintWindow (captures solid black), and-  they ignore programmatic escape/WM_CLOSE.+- FINISH pops a native Save dialog AND **two opaque "Fusion360" CEF modals** that expose no+  Accessibility tree (`ui_find` finds nothing) and capture solid black, and they ignore a+  programmatic escape or AX close. - `Create3DPackage` also binds to the **first package of the OPEN library**, not the file you pass it,   so looping reordered files against one open library binds only 1/N. The f3d recipe above sidesteps ALL of this. Use it; do not fight the generator.
skills/fusion-multiprofile-signin/SKILL.md+9−9
@@ -20,16 +20,16 @@ lives in a *different* Chrome/Edge profile - personal Chrome is default but your `[email protected]` in your work profile - Fusion signs you into the wrong account or stalls on the wrong Google session. Autodesk should let you pick the profile; they don't. So we do. -Verified live (John, 2026-07-21): Fusion opened his personal Chrome (`[email protected]`) when his-Autodesk login is `[email protected]` in his work profile.+Verified live (2026-07-21): Fusion opened the user's PERSONAL Chrome profile when their Autodesk+login lives in the WORK profile — the signed-in Google session decides, not the account they want.  ## The fix: `fusion_signin`  ```bash # BEST - one server-side call does the whole chain, beats the ~2-min clock:-adom-desktop fusion_signin '{"auto":true,"profile":"chrome:[email protected]"}'-adom-desktop fusion_signin '{"profile":"chrome:[email protected]"}'   # staged/manual: fix + REMEMBER profile-adom-desktop fusion_signin '{}'                                  # staged: probe/remember/ask+adom-bridge fusion_signin '{"auto":true,"profile":"chrome:[email protected]"}'+adom-bridge fusion_signin '{"profile":"chrome:[email protected]"}'   # staged/manual: fix + REMEMBER profile+adom-bridge fusion_signin '{}'                                  # staged: probe/remember/ask ```  ### `auto:true` - the reliable path (do this)@@ -52,7 +52,7 @@ What it does:    cleans it), but Chrome's/Edge's **History DB keeps the full URL** - so the bridge copies the    locked History file and reads the newest Fusion (`idsdk`/`idmgr`) authorize entry. Racing the    address bar over the relay does NOT work; the History read is the reliable capture.-2. **Re-opens that exact URL in the RIGHT profile, backgrounded** (ABE / `nbrowser_open_window`), so+2. **Re-opens that exact URL in the RIGHT profile, backgrounded** (NBE / `nbrowser_open_window`), so    it never interrupts what the user is doing. 3. It completes back to the **running Fusion** on its own. The redirect is    `accounts.autodesk.com/idmgr/callback` + an `autodesk://` protocol handoff matched by@@ -72,7 +72,7 @@ What it does: ## The staged loop  - `stage:"click_signin"` - Fusion has not opened the browser yet. Click Fusion's **Sign In** (it is a-  webview with no UIA node, so an image-space `desktop_click` on the button; screenshot the Fusion+  webview with no Accessibility node, so an image-space `desktop_click` on the button; screenshot the Fusion   window first for a shotId), wait ~4s, call `fusion_signin` again. - `stage:"opened"` - the URL is now in the right profile (`signinWhere`). Tell the user where, why   (`signinProfileReason`), and offer: they finish it, you foreground it, or (with their OK) you drive@@ -96,8 +96,8 @@ Two things bite after the profile fix works:    dialog"** with a **Retry** button. Fusion completes only when Chrome's native    *"Open Autodesk Identity Manager?"* dialog is accepted (tick "Always allow", click "Open"). If it    does not auto-fire: click **Retry** on the callback tab, then accept the Chrome Open dialog-   (a native UIA dialog - `desktop_find_control`/`desktop_ui_click` "Open", or a foreground click if-   UIA Invoke no-ops). This step is the same for ALL Fusion sign-ins; it is not caused by the profile+   (a native Accessibility-exposed dialog - `desktop_find_control`/`desktop_ui_click` "Open", or a foreground click if+   an Accessibility press no-ops). This step is the same for ALL Fusion sign-ins; it is not caused by the profile    move.  ## Gotchas
skills/fusion-onboarding/SKILL.md+101−83
@@ -1,126 +1,139 @@ --- name: fusion-onboarding-description: Onboard a brand-new Adom user who wants Fusion 360 features but doesn't have Fusion installed — the AI downloads the Fusion installer, silent-installs it, drives the Autodesk login (free/trial is enough), and auto-installs the AdomBridge add-in so the bridge can inject commands. "Complete the circuit" so fusion_* verbs work end to end. Trigger words — install fusion, no fusion, fusion not installed, set up fusion, download fusion, onboard fusion, get fusion, fusion trial, install the bridge add-in, fusion addin not running, set up the fusion bridge from scratch.+description: Onboard a brand-new Adom user on a Mac who wants Fusion 360 features but doesn't have Fusion installed — the AI downloads Autodesk's Fusion installer, runs it, drives the Autodesk login (free/trial is enough), and auto-installs the AdomBridge add-in so the bridge can inject commands. "Complete the circuit" so fusion_* verbs work end to end. Trigger words — install fusion, no fusion, fusion not installed, set up fusion, download fusion, onboard fusion, get fusion, fusion trial, install the bridge add-in, fusion addin not running, set up the fusion bridge from scratch. --- -# Fusion 360 onboarding — from zero to a working bridge+# Fusion 360 onboarding (macOS) — from zero to a working bridge -Goal: a new Adom user with **no Fusion 360** should be able to use the Fusion bridge after a-hands-off, AI-driven setup. The AI installs Fusion, signs them in, and wires up the add-in so-`fusion_*` commands work. **The free/trial tier is plenty** for viewing files and a lot of real+Goal: a new Adom user with **no Fusion 360** on their Mac should be able to use the Fusion bridge+after a hands-off, AI-driven setup. The AI installs Fusion, signs them in, and wires up the add-in+so `fusion_*` commands work. **The free/trial tier is plenty** for viewing files and a lot of real work — nobody has to pay to get value. -All laptop steps run via `adom-desktop --target <laptop> shell_execute` / `run_script` /-`send_files`. Drive the user's own machine; don't ask them to do steps you can do.+All machine steps run via Adom Bridge (`adom-bridge --target <mac> shell_execute` / `run_script` /+`send_files`). Drive the user's own machine; don't ask them to do steps you can do. Nothing in+this flow needs admin rights: Fusion on macOS installs **per-user** under+`~/Library/Application Support/Autodesk/webdeploy/production/`.  ## Step 0 — Check readiness (fast, never launches Fusion)-Call **`fusion_readiness`** (or AD's **`bridge_readiness`**) FIRST - it reports `installed` / `running`-/ `ready` without launching anything:+Call **`fusion_readiness`** (or Adom Bridge's **`bridge_readiness`**) FIRST — it reports+`installed` / `running` / `ready` without launching anything: - `installed:false` → onboard (the steps below). - `installed:true, running:false` → **no onboarding needed**, just `fusion_start`, then drive. - `ready:true` → drive Fusion directly. -NOTE (AD >=1.9.63): AD **DETECTS** the Fusion host app (via the bridge.json `detect` block - the-`%LOCALAPPDATA%\Autodesk\webdeploy\production\*\FusionLauncher.exe` path) but **NEVER installs it** --Fusion is the user's host app. AD also **provisions Python itself** - a system install if one is on-PATH, else a portable, no-UAC python-build-standalone copy (pinned 3.12.13) under-`~/.adom/adom-runtimes/` - and spawns the bridge from it by absolute path. So **never** download or-bootstrap Python here; the user sees no UAC prompt for a runtime (check state with AD's `runtimes`-verb). Onboarding is only about Fusion itself + the Autodesk login + deploying the add-in.+How "installed" is decided: the bridge looks for the newest **complete** bundle+`~/Library/Application Support/Autodesk/webdeploy/production/<hash>/Autodesk Fusion.app` (complete =+`Contents/MacOS/Autodesk Fusion` present and ≥200 KB — a half-streamed install has the folder but+not the binary). Fusion never prunes old `<hash>` dirs after self-updates; the bridge always picks+the newest complete one. Adom Bridge **detects** the host app (the `detect` block in `bridge.json`)+but **never installs it** — and it provisions Python for the bridge itself (no admin prompt; check+with the `runtimes` verb), so **never** download or bootstrap Python here. Onboarding is only about+Fusion itself + the Autodesk login + deploying the add-in.++`fusion_install_fusion` on this line returns `fusion_install_manual_on_macos` on purpose: Autodesk+ships no documented silent-install switches for the mac streamer, so the bridge does not pretend+to have one. **This skill is the automation** — the AI runs the steps below itself instead of+handing the user a download link.  ## Step 1 — Download the Fusion installer-The installer is the small "Fusion Client Downloader" (it streams the full app during install).+Autodesk's mac installer is a small disk image that streams the full app during install: ```-URL: https://dl.appstreaming.autodesk.com/production/installers/Fusion Client Downloader.exe+https://dl.appstreaming.autodesk.com/production/installers/Fusion%20Client%20Downloader.dmg ```-Download it to a no-space path on the laptop (e.g. C:\tmp\): ```-shell_execute {"command":"curl -L -o C:\\tmp\\FusionDL.exe \"https://dl.appstreaming.autodesk.com/production/installers/Fusion%20Client%20Downloader.exe\""}+shell_execute {"command":"curl -L -o /tmp/FusionDL.dmg \"https://dl.appstreaming.autodesk.com/production/installers/Fusion%20Client%20Downloader.dmg\""} ```-(curl ships on macOS.)+(~28 MB; `curl` ships with macOS.) -## Step 2 — Silent install (elevated)+## Step 2 — Mount it and run the installer ```-"C:\tmp\FusionDL.exe" --globalinstall --quiet      # system-wide, no UI+shell_execute {"command":"hdiutil attach -nobrowse -mountpoint /tmp/fusion-installer /tmp/FusionDL.dmg && open \"/tmp/fusion-installer/Install Autodesk Fusion.app\""} ```-- Needs **admin/elevation** — run it so it elevates (UAC). On the user's own box this is one-  consent. It then **streams ~several GB**, so it can take 10-30 min — **monitor, don't block**-  (poll for the FusionLauncher under `%LOCALAPPDATA%\Autodesk\webdeploy\production\<hash>\`).-- Uninstall (if ever needed): `--globalinstall --process uninstall --quiet`.-- When done, `fusion_detect` flips to `installed:true` (the bridge finds the newest webdeploy-  launcher by mtime).+- The dmg contains **`Install Autodesk Fusion.app`** (Autodesk's "Fusion Client Downloader"+  streamer). Launching it opens a small progress window and streams **several GB** into+  `~/Library/Application Support/Autodesk/webdeploy/production/<hash>/` — 10-30 min on a normal+  connection. **Monitor, don't block**: poll `fusion_readiness` until `installed:true` (the bridge+  flips it the moment the bundle binary is complete).+- No admin/elevation is involved (per-user install). If macOS shows a Gatekeeper prompt for the+  installer app, that is a genuine wall — `notify_user` the user to click Open.+- Don't invent silent flags for the streamer binary; none are documented for macOS. If the+  installer wants the Autodesk sign-in *before* streaming, continue with Step 3 in the installer's+  window — same mechanism.+- Afterwards: `shell_execute {"command":"hdiutil detach /tmp/fusion-installer; rm -f /tmp/FusionDL.dmg"}`.+- Uninstall (if ever needed): remove the `webdeploy/production/<hash>` dirs and+  `~/Library/Application Support/Autodesk/Autodesk Fusion*`; there is no separate uninstaller.  ## Step 3 — First launch + Autodesk login (free account / trial)-`fusion_start` launches it; the first run needs an Autodesk login. If they have no Autodesk account,-the sign-in page has **Create account** (free) — and Fusion offers a **free trial / personal-use**-tier that's enough for viewing and a lot of work. **Don't auto-enter their password/2FA; do drive-everything else.**+`fusion_start` launches it (in the background — no focus steal); the first run needs an Autodesk+login. If they have no Autodesk account, the sign-in page has **Create account** (free) — and Fusion+offers a **free trial / personal-use** tier that's enough for viewing and a lot of work. **Don't+auto-enter their password/2FA; do drive everything else.** -> **Use the dedicated `fusion-autodesk-signin` skill for the full drive** — it has the complete,-> battle-tested sequence and every pitfall (blank webview → restart Fusion, invisible-Edge / CLIXML-> noise, warm Google/Apple/MS SSO, the Identity Manager protocol overlay, fast-expiring codes, and-> `fusion_notify_owner` escalation). The summary below is the mechanism; that skill is the how-to.+> **Use the dedicated `fusion-autodesk-signin` skill for the full drive** — it has the complete+> sequence and every pitfall (blank webview → restart Fusion, warm Google/Apple/MS SSO, the+> Identity Manager protocol overlay, fast-expiring codes, and `fusion_notify_owner` escalation).+> The summary below is the mechanism; that skill is the how-to.  ### The mechanism (why naive clicking fails)-Fusion's "Sign In" opens the **default browser** to an Autodesk OAuth page. When auth completes the-browser lands on `signin.autodesk.com/idmgr/callback#code=…`, whose JS posts the code to Fusion's-**localhost** listener via an `adskidmgr://` protocol handoff. Three traps make this fail if you-click naively:+Fusion's "Sign In" opens the **default browser** (Safari/Chrome/…) to an Autodesk OAuth page. When+auth completes the browser lands on `signin.autodesk.com/idmgr/callback#code=…`, whose JS posts the+code to Fusion's **localhost** listener via an `adskidmgr://` protocol handoff. Three traps make+this fail if you click naively: - **Codes expire fast.** A stale sign-in tab left open holds a dead code → "Sign-in request   expired". Every retry that races an old tab loses.-- **`desktop_ui_click` (UIA Invoke) does NOT fire the protocol.** Browsers block protocol launches-  from untrusted (synthetic-invoke) events. You need an **isTrusted** click: **`desktop_click`**-  (SendInput coordinate click) or an `nbrowser` CDP click.-- **An in-page "This site is trying to open Autodesk Identity Manager?" overlay** gates the launch.-  It is NOT an owned popup, so `desktop_screenshot_window` sees it but popup-capture (`ownedPopupCount`)-  never will. It must be clicked "Open".--### The PROVEN sequence (validated live 2026-07-05, zero password entry by the AI)+- **Browsers only launch a protocol handler from a trusted (real) click.** Use **`desktop_click`**+  (a CGEvent coordinate click — isTrusted) or an `nbrowser` CDP click. Do not rely on an AX-press+  (`ui_click`) for this step — it is not a user gesture as far as the browser is concerned.+- **An in-page "Open Autodesk Identity Manager?" sheet** gates the launch. It is part of the browser+  window, not a separate dialog, so `desktop_screenshot_window` sees it but a window-list scan+  never will. It must be clicked "Open" (tick "Always allow" first so it never blocks again).++### The sequence (mac) 1. **Warm the session / clear stale tabs.** If the user already authenticated Autodesk in the    browser, the session is warm. FIRST close any dead `signin.autodesk.com` / "Sign in - Autodesk"-   tabs (foreground the Edge window, `desktop_press_key {"key":"ctrl+w"}` per tab) — they only hold+   tabs (`desktop_press_key {"key":"cmd+w"}` per tab in the front browser window) — they only hold    expired codes and cause false "expired" screens.-2. **One fresh request.** `desktop_ui_click` **"Retry browser sign-in"** (or "Sign In") on the-   Fusion window to mint exactly one fresh code + open one live auth tab.-3. **Open Product, isTrusted.** On the "You're signed in" page, click **"Open Product"** with-   **`desktop_click`** (SendInput), NOT `desktop_ui_click`.-4. **Clear the protocol overlay, FAST.** When the "open Autodesk Identity Manager?" overlay appears,-   `desktop_click` the **"Always allow"** radio (so it never blocks again) then **"Open"** — before-   the code expires.+2. **One fresh request.** Click **"Retry browser sign-in"** (or "Sign In") in the Fusion window to+   mint exactly one fresh code + open one live auth tab.+3. **Open Product, trusted.** On the "You're signed in" page, click **"Open Product"** with+   **`desktop_click`** (CGEvent), or `nbrowser_eval` a DOM click.+4. **Clear the protocol sheet, FAST.** Tick **"Always allow"**, then **"Open"** — before the code+   expires. 5. **Confirm.** Poll `fusion_readiness`; the Fusion window title flips **"Signing in - Autodesk    Fusion" → "Home - Autodesk Fusion"** and `ready` goes true (`fusion_readiness` reports    `needsSignin:true` the whole time it's blocked, so branch on that). -**Headless variant:** if `nbrowser` (the Adom browser extension, `nbrowser_readiness`) is driving-the **same** browser window Fusion opened, do steps 3-4 via CDP (`nbrowser_eval` to click the DOM-button) — CDP clicks are isTrusted and need no window focus, beating the expiry race. Caveat: the-auth tab must be in nbrowser's window; if Fusion opened a different Edge window, use the SendInput-path above.+**Headless variant:** if `nbrowser` (the Adom native-browser bridge, `nbrowser_readiness`) is+driving the **same** browser window Fusion opened, do steps 3-4 via CDP (`nbrowser_eval` to click+the DOM button) — CDP clicks are trusted and need no window focus, beating the expiry race. Caveat:+the auth tab must be in nbrowser's window; if Fusion opened a different browser window, use the+`desktop_click` path above.  > **NOTIFY only when you truly can't proceed.** The sign-in is something you should AUTOMATE, not-> punt. Reserve an AD **`notify_user`** toast for a genuine wall (a UAC/elevation prompt, a-> `--globalinstall` consent, license acceptance, or a 2FA/password step you must not auto-fill).-> As of **AD 1.9.84** `notify_user` works directly over the bridge's direct API — you don't relay a-> payload to the AI anymore. **If the bridge runs UNATTENDED (e.g. on a VM) and the user is on-> another machine, add a cross-AD `target`** (a peer clientName from the `targets` verb, or `"all"`)-> so the toast lands where they actually are. The bridge already fires this itself for a seat/-> licensing DECISION dialog (a true wall) — see `notifyDelivered` in the launch response.+> punt. Reserve an Adom Bridge **`notify_user`** toast for a genuine wall (a Gatekeeper prompt,+> license acceptance, or a 2FA/password step you must not auto-fill). **If the bridge runs+> UNATTENDED and the user is on another machine, add a cross-Bridge `target`** (a peer clientName+> from the `targets` verb, or `"all"`) so the toast lands where they actually are. The bridge+> already fires this itself for a seat/licensing DECISION dialog (a true wall) — see+> `notifyDelivered` in the launch response.  ## Step 4 — Complete the circuit: auto-install the AdomBridge add-in This is what lets the bridge inject commands into Fusion after launch. - **The bridge does this for you:** on start, `server.py` auto-runs `install_addin`, which lands the-  add-in in **EVERY known Fusion add-in dir** — `%APPDATA%\Autodesk\FusionAddins\` (what 2025+-  Fusion actually scans) AND the legacy `Autodesk Fusion[ 360]\API\AddIns\` dirs. ⚠ Fusion MOVED+  add-in in **EVERY known Fusion add-in dir** —+  `~/Library/Application Support/Autodesk/FusionAddins/` (what 2025+ Fusion actually scans) AND the+  legacy `Autodesk Fusion[ 360]/API/AddIns/` dirs under the same `Autodesk/` folder. ⚠ Fusion MOVED   this directory across versions and silently ignores the others (an add-in only in the legacy dir   never loads on current Fusion — issue #63, proven live on a fresh install). Never assume one path. - **⛔ NEVER ask the user to restart Fusion or enable the add-in.** After installing, YOU restart it:-  `fusion_stop` then `fusion_start` — the add-in auto-loads (`runOnStartup:true`, verified live:-  port 8774 up 20s after restart, zero manual enabling). Asking the user to do it defeats the bridge.+  `fusion_stop` then `fusion_start` (a graceful `NSRunningApplication.terminate` + `open -g` — no+  Apple Events, no System Events prompt) — the add-in auto-loads (`runOnStartup:true`; port 8774 up+  ~20 s after restart, zero manual enabling). Asking the user to do it defeats the bridge. - **It auto-loads every launch:** `AdomBridge.manifest` has **`"runOnStartup": true`**, so Fusion   runs the add-in (and its localhost:8774 HTTP server) automatically on startup — **no manual-  "enable" needed**. (Verified: after a Fusion restart the add-in comes back `addinReady:true`-  with no UI interaction.)-- **If the add-in was just installed while Fusion was running**, restart Fusion (`fusion_close`+  "enable" needed**.+- **If the add-in was just installed while Fusion was running**, restart Fusion (`fusion_stop`   then `fusion_start`) so it picks up + runs the add-in.  ## Step 5 — Verify the circuit@@ -137,10 +150,15 @@ If they'll use cloud-file search, continue with the **`fusion-aps-search`** / charged).  ## Notes / gotchas-- The big install is the slow part — **monitor** it (poll for the webdeploy launcher), don't sit-  on a blocking call.-- Admin elevation is required for `--globalinstall`; expect one UAC consent on the user's box.-- After a major Fusion self-update (Fusion web-deploys updates ~weekly), the add-in survives in-  `API/AddIns`, but re-verify with `fusion_addin_status`; re-run `install_addin` if it drifted.-- Verify the current installer URL / flags if Autodesk changes them (Sources: silentinstallhq,-  Autodesk deploy docs).+- The big install is the slow part — **monitor** it (poll `fusion_readiness`), don't sit on a+  blocking call.+- **Permissions the bridge needs on the Mac are Adom Bridge's, granted once at first run:**+  Screen Recording (screenshots) and Accessibility (window raise/close, dialog dismiss, clicks).+  Nothing in this bridge uses Apple Events / System Events, so no "wants to control System+  Events" prompt should ever appear — if one does, that is a bug to report, not something to ask+  the user to allow.+- After a major Fusion self-update (Fusion web-deploys updates regularly), a NEW `<hash>` dir+  appears and the old one stays; the add-in lives outside both, in `FusionAddins/`, so it+  survives — but re-verify with `fusion_addin_status`; re-run `install_addin` if it drifted.+- Verify the current installer URL if Autodesk changes it (it is the same host Autodesk's own+  download page links to).
skills/fusion-web-export/SKILL.md+3−3
@@ -34,11 +34,11 @@ This reuses `aps.py`'s `_valid_access_token()` + `_http()` helpers; it is roughl - **Electronics/PCB designs are SCHEMATICS on the web - they export SCH/BRD only, NO STEP.** The 12-format dropdowns are present in the DOM but hidden templates; do not be fooled. STEP comes from the board's **3D** design (often a separate "3D Assets" design, or the board pushed to 3D).  ### Prereqs-`adom-desktop ping` connected + the pup (`browser_*`) bridge, a persistent pup profile logged into Autodesk (one-time), email access to the account that gets the export link (use **`adom-google`** - portable in any container; the claude.ai Gmail MCP connector also works if attached but is not guaranteed), and `step2glb` for the GLB.+`adom-bridge ping` connected + the pup (`browser_*`) bridge, a persistent pup profile logged into Autodesk (one-time), email access to the account that gets the export link (use **`adom-google`** - portable in any container; the claude.ai Gmail MCP connector also works if attached but is not guaranteed), and `step2glb` for the GLB.  ### Steps 1. **Open Fusion Team** in a logged-in pup session at `https://<hub>.autodesk360.com` (NOT `drive.autodesk.com` - it errors; NOT `fusion.online.autodesk.com` - that is the AppStream streamed editor, pure canvas, un-automatable).-   `adom-desktop browser_open_window '{"sessionId":"fusion-web","profile":"autodesk","url":"https://<hub>.autodesk360.com"}'`+   `adom-bridge browser_open_window '{"sessionId":"fusion-web","profile":"autodesk","url":"https://<hub>.autodesk360.com"}'`    Folder rows respond to a plain JS `.click()` via `browser_eval`; opening a design's detail page needs a TRUSTED click (`browser_input_dispatch`). 2. **Screenshot loop that works** (pup `browser_screenshot` errors os-13 on some hosts): `desktop_screenshot_window {hwnd}` (hwnd from `desktop_list_windows`, title "Google Chrome for Testing") -> read `safePathHost` from the JSON -> `pull_file {filePaths:[safePathHost], saveTo}` -> Read the PNG. Screenshot after every click. 3. **Open the 3D design**, then click the top-right download-arrow toggle by **VIEWPORT coords** from `getBoundingClientRect` (NOT screen coords; a `.trigger` selector click fails "not clickable"):@@ -69,5 +69,5 @@ step2glb convert /tmp/<Design>.stp -o /tmp/<Design>.glb  ## Related - [[fusion-aps-search]] / [[fusion-aps-signin]] - the APS OAuth + Data Management layer Path A builds on (`aps.py`).-- `adom-desktop-fusion-bridge` `fusion_export_step` - the DESKTOP path (needs Fusion open); use when Fusion is installed and running.+- `fusion-bridge-macos` `fusion_export_step` - the DESKTOP path (needs Fusion open); use when Fusion is installed and running. - `step2glb` - STEP -> GLB.
uninstall.sh+19−2
@@ -1,4 +1,21 @@ #!/bin/bash+# Reverse install.sh: remove every skill dir this package delivered.+# Derive the list from skills/ rather than hardcoding it — the old hardcoded+# list named 4 dirs while install.sh delivered 20, orphaning 16 of them.+set -e+PKG_DIR="$(cd "$(dirname "$0")" && pwd)" SKILLS_DIR="$HOME/.claude/skills"-rm -rf "$SKILLS_DIR/adom-desktop-fusion-bridge" "$SKILLS_DIR/fusion-aps-signin" "$SKILLS_DIR/fusion-aps-search" "$SKILLS_DIR/fusion-bridge-dev"-echo "Uninstalled adom-desktop-fusion-bridge skills"+removed=0+for skill_dir in "$PKG_DIR/skills"/*/; do+  [ -d "$skill_dir" ] || continue+  target="$SKILLS_DIR/$(basename "$skill_dir")"+  [ -d "$target" ] || continue+  rm -rf "$target"+  removed=$((removed + 1))+done+# Legacy roots from older installs (pre-1.8.6 install.sh copied the root+# SKILL.md under these names; adom-wiki now owns `fusion-bridge-macos`).+for legacy in adom-bridge-fusion-bridge adom-desktop-fusion-bridge; do+  [ -d "$SKILLS_DIR/$legacy" ] && rm -rf "$SKILLS_DIR/$legacy" && removed=$((removed + 1))+done+echo "Uninstalled fusion-bridge-macos skills ($removed removed)"