SOLIDWORKS Bridge

@@ -1 +1 @@-0.9.10+0.9.11

@@ -107,7 +107,7 @@ dependencies = [  [[package]] name = "swx-bridge"-version = "0.9.10"+version = "0.9.11" dependencies = [  "serde",  "serde_json",

@@ -1,6 +1,6 @@ [package] name = "swx-bridge"-version = "0.9.10"+version = "0.9.11" edition = "2021" rust-version = "1.80" description = "Adom SOLIDWORKS bridge — swx_* verbs over the SOLIDWORKS COM API, as a single native binary"

@@ -9,13 +9,15 @@ One native binary. No Python, no PowerShell, no interpreter to provision: ab spawns `swx-bridge.exe` directly (`spawn.kind: "exe"`) and it is serving in about ten milliseconds. -## What it does — 63 verbs+## What it does — 67 verbs  | Area | Verbs | |---|---| | **Create & open** | `swx_new_document` (part/assembly/drawing from the stock template), `swx_open`, `swx_import` (STEP/IGES/Parasolid/STL), `swx_save`, `swx_save_as`, `swx_close_doc`, `swx_find_files`, `swx_docs` | | **Model** | `swx_run_script` — a typed modelling DSL: `new_part`, `sketch_rect`, `sketch_circle`, `extrude`, `cut`, `set_material`, `set_prop`, `save_as`, `rebuild`, `zoom_fit`. Everything in millimetres. | | **Macros** | `swx_run_macro` — `ISldWorks::RunMacro2` on a `.swp`/`.swb`/`.dll`. Arbitrary code, so it needs the write opt-in every time. Scaffolding: not yet run live. |+| **Assemble** | `swx_add_component` — insert a part or sub-assembly into the active assembly, positioned and rotated. |+| **Close & quit safely** | `swx_close_all_safely` (saves every open document to a recovery folder, verifies each file, then closes), `swx_shutdown` (that sweep, then a graceful quit), `swx_recover_list` (what was preserved and where), `swx_close_import_temps`, `swx_user_presence` (is someone working in this session? the bridge refuses to end a session a person is using). | | Export | `swx_export` plus per-format aliases `swx_export_step/iges/stl/3mf/glb/sat/parasolid/pdf/dxf/dwg`, `swx_pack_and_go` | | Read the design back | `swx_design_info`, `swx_inspect_bodies` (geometry in mm), `swx_get_parameters`, `swx_set_parameter`, `swx_mass_properties`, `swx_bom`, `swx_interference`, `swx_rebuild_check`, `swx_document_info` | | Metadata | `swx_props_get`, `swx_props_set` (custom properties, file- or configuration-scope) |@@ -458,7 +460,18 @@ not.  ## Roadmap -- v0.9.10 (this): **the bridge's documents are only the ones it opened.**+- v0.9.11 (this): **a session cannot be starting for hours.** Measured LIVE on+  2026-10-01: Drew's three-hour-old session with 34 documents open was locked+  out of every gated verb after an update respawned the bridge — the log's+  `"UNLOAD_ADDIN" "SWK3DCompassAddin.dll"` line contains `LOAD_ADDIN` and was+  read as the platform add-in loading. Load events are now parsed as the exact+  token (the measured log is a fixture); a process older than ten minutes with+  COM's start complete holds "loading" only while startup lines are still+  changing; periodic `<PROCMEM>` lines no longer count as startup activity; the+  ready latch is persisted across bridge restarts; and `swx_user_presence` is+  exempt from the startup gate, reporting documents as unknown until the session+  is verified ready. 502 tests.+- v0.9.10: **the bridge's documents are only the ones it opened.**   Adversary pass 46 found the user's own documents could enter the presence   guard's baseline three ways (a session the user launched, a document opened   before the bridge's first verb, and any later bridge verb re-reading the open

@@ -2,7 +2,7 @@   "manifest_version": 1,   "name": "solidworks",   "displayName": "SOLIDWORKS",-  "version": "0.9.10",+  "version": "0.9.11",   "description": "Bridge for SOLIDWORKS desktop CAD \u2014 create and open documents, a modeling DSL, file management (find/open/save/export/Pack and Go), custom properties, BOM generation, design analysis (mass properties, bodies, parameters, interference, rebuild health) and background window/dialog etiquette, over the SOLIDWORKS COM API. Single native binary: no interpreter, no PowerShell, ~10ms cold start.",   "author": "Adom Inc.",   "license": "MIT",

@@ -114,7 +114,7 @@ templates**, alisamsam **22**. | 48 | **A title collision between SAVED documents is impossible here — measured, not assumed** | ✗ | **✓ MEASURED LIVE 2026-09-17** — `tools/drain-gate.py --fixture new` copied a bridge-created document's own file to a second directory under the same basename and called `swx_open` on it. SOLIDWORKS REFUSED: `errors = 65536` (`swFileWithSameTitleAlreadyOpen`). So the drain's title-collision guard — which refuses to close any document whose title another open document shares, and names both paths — can only ever fire for PATHLESS documents, which is exactly the state identity-at-birth removes. The guard stays (a document the bridge did not create can still be pathless, and an older bridge's leftovers are), and the measurement is recorded next to it in `com.rs` so nobody "simplifies" it on the assumption that saved collisions are the common case. No MCP server measures this at all | ✗ | ✗ | ✗ | ✗ | ✗ | | 52 | **Never ends a session the user is working in** (a measured user-presence guard on every quit and sweep) | ✗ | **✓ 0.9.9, from an event MEASURED 2026-10-01**: Drew took over a bridge-launched session — a "leave as found" quit met his File Open dialog, and minutes later the session held his 34-document crate assembly. Every quit, sweep and priming now measures presence (SOLIDWORKS foreground + input under 120 s, documents the bridge did not open, an earlier take-over), refuses `user_is_active` with the evidence, fails closed on an unreadable measurement, and marks the session taken over for good; only the user's explicit override proceeds, and the gates never pass it. 0.9.10: a document is the bridge's only if a bridge verb opened or created it — in a session the user launched, every document is theirs. No MCP server has a presence guard at all | ✗ | ✗ | ✗ | ✗ | ✗ | | 51 | **Dialogs judged by MEASURED MODALITY, not by existence** (a notification never blocks; a modal always does) | ✗ | **✓ LIVE-PROVEN 2026-10-01 on 0.9.4** — with the 3DEXPERIENCE "Connected" notice on screen, `swx_stop` quit in 5.1 s and reported it as a notification with its evidence. **0.9.4, from a blocker MEASURED 2026-10-01**: the 3DEXPERIENCE "Connected to …" notice — a title-less `#32770` tool window whose owner frame stayed ENABLED for 95 s, with no Button-class control — blocked every quit, sweep and import for minutes. Now a window blocks when its kind is known-blocking, its owner frame is disabled, or it has a Button-class control; it is a `notification` (reported with owner, ownerEnabled, styles, rect and child controls; never answered) only when all of that was measured; unread evidence fails closed. Template placeholder captions are flagged, never presented as the window's words. **0.9.5 (adversary pass 43): the window's WORDS count — a save/recovery/import kind in its text blocks whatever the evidence, two or more button-like captions in any control class block, and measured notification evidence overrides a licence-type title alone; 0.9.7: swx_dismiss_blocking_dialogs uses the same title-and-words classifier before it closes anything; 0.9.8, from a live measurement: an owner frame read disabled for an instant (SOLIDWORKS busy) is re-read before a notice is called a modal.** No MCP server looks at a dialog at all | ✗ | ✗ | ✗ | ✗ | ✗ |-| 50 | **Readiness gating — attached is not ready** (no document command reaches a SOLIDWORKS that has not finished starting) | ✗ | **✓ 0.9.3, from a crash MEASURED 2026-10-01**: `swx_new_document` 8 s after COM attach, `swx_open` at 9 s and `swx_close_all_safely` at 12 s crashed SOLIDWORKS while its 3DEXPERIENCE add-in was still initialising (performance log: LOAD_ADDIN still running, SWEXH/UNHANDLED, the 3DEXPERIENCE marker only after the document commands, SWERR_REPORT); a control launch with no document commands crashed nothing. Now a READY stage follows `attached`, decided by two independent signals — COM `StartupProcessCompleted` and the performance log's 3DEXPERIENCE marker after the last LOAD_ADDIN — with an honest grace and timeout that never promote to ready; every verb that reaches SOLIDWORKS refuses `host_app_starting` with `retryAfterSeconds` until then — **0.9.5: gated by default with a pinned 16-verb exemption list, the performance log bound to this session's process creation time (an earlier session's log is never "complete"), COM alone never enough on a machine that writes markers, an on-demand add-in told from a start by quiet + which add-in, the grace unlocking reads only, and the window-message quit rungs ungated under userAuthorized; LIVE 2026-10-01 a document verb was refused during startup. 0.9.6: every gated reply carries the readiness its gate evaluated, the log is read from its per-start header, and the on-demand rule keys on the platform DLL SWK3DCompassAddin.dll; 0.9.7 (LIVE-PROVEN 0.9.6): no marker history — a disabled platform add-in never locks the bridge out, and a log still being written holds even a machine's first start**; a sweep during which SOLIDWORKS dies says `host_app_gone` with the log's crash markers. The rescue held under the crash (26,129 bytes verified). No MCP server distinguishes attached from ready at all | ✗ | ✗ | ✗ | ✗ | ✗ |+| 50 | **Readiness gating — attached is not ready** (no document command reaches a SOLIDWORKS that has not finished starting) | ✗ | **✓ 0.9.3, from a crash MEASURED 2026-10-01**: `swx_new_document` 8 s after COM attach, `swx_open` at 9 s and `swx_close_all_safely` at 12 s crashed SOLIDWORKS while its 3DEXPERIENCE add-in was still initialising (performance log: LOAD_ADDIN still running, SWEXH/UNHANDLED, the 3DEXPERIENCE marker only after the document commands, SWERR_REPORT); a control launch with no document commands crashed nothing. Now a READY stage follows `attached`, decided by two independent signals — COM `StartupProcessCompleted` and the performance log's 3DEXPERIENCE marker after the last LOAD_ADDIN — with an honest grace and timeout that never promote to ready; every verb that reaches SOLIDWORKS refuses `host_app_starting` with `retryAfterSeconds` until then — **0.9.5: gated by default with a pinned 16-verb exemption list, the performance log bound to this session's process creation time (an earlier session's log is never "complete"), COM alone never enough on a machine that writes markers, an on-demand add-in told from a start by quiet + which add-in, the grace unlocking reads only, and the window-message quit rungs ungated under userAuthorized; LIVE 2026-10-01 a document verb was refused during startup. 0.9.6: every gated reply carries the readiness its gate evaluated, the log is read from its per-start header, and the on-demand rule keys on the platform DLL SWK3DCompassAddin.dll; 0.9.7 (LIVE-PROVEN 0.9.6): no marker history — a disabled platform add-in never locks the bridge out, and a log still being written holds even a machine's first start; 0.9.11, from a live lock-out: `UNLOAD_ADDIN` is never read as a load, a session older than ten minutes with COM's start complete is never held by a log rule unless startup lines are still changing, and the ready latch survives a bridge restart**; a sweep during which SOLIDWORKS dies says `host_app_gone` with the log's crash markers. The rescue held under the crash (26,129 bytes verified). No MCP server distinguishes attached from ready at all | ✗ | ✗ | ✗ | ✗ | ✗ | | 49 | **The user's rescued work survives the bridge's own updates — and ab's** (recovery never lives in a directory anything else owns) | ✗ | **✓ 0.9.1: the data root is `%LOCALAPPDATA%\adom-solidworks-bridge\`, a directory only this bridge writes to** — moved out of `Adom Bridge\` altogether after adversary pass 39 found 0.9.0's `Adom Bridge\solidworks-data` sitting inside the directory ab's installer and uninstaller own, whose fate on an ab uninstall or reinstall is documented nowhere; both earlier locations are migrated oldest first, every copy recorded by (root, path, size, mtime, sha256) so a legacy file that changes after its copy is copied again BESIDE it and reported `changedSinceCopy`, never settled by name — and since 0.9.2 a small file whose size and mtime match is hashed too, and two versions of the ledger or the ownership registry are MERGED (union, both versions kept beside) rather than one picked; a temp-directory fallback makes every sweep refuse (`data_root_is_temp`), and an unwritable recovery folder is refused once before the first save (`recovery_dir_unwritable`). **0.9.0, from a SEV-1 MEASURED 2026-09-30**: `bridges-cache\solidworks` was found CREATED 2026-09-18 09:42 by ab's auto-install of 0.8.9 — the updater re-extracts the whole directory, and every recovery folder from the day before, the ledger and the ownership registry went with it (test documents only; nothing of Drew's was lost). The data root is now `%LOCALAPPDATA%\Adom Bridge\solidworks-data\`, a sibling of the install cache; the first start MIGRATES what an older bridge left (copied under a temporary name and renamed into place once verified byte for byte — so a start that dies mid-copy never leaves a truncated rescue under the real name — never over an existing file, originals left in place, each file once, a copy that does not verify removed and retried next start); `swx_recover_list` still reads the old location and marks each rescue there `atRiskFromUpdate`, saying whether a verified copy exists — and in the data root calls a file whose copy has not landed `notCopiedYet` (pointing at its only copy), never "gone"; and a sweep REFUSES (`recovery_inside_install_dir`, nothing written, nothing closed) if its recovery folder would land under the install directory or the install cache — however the path is spelled (links, `..`, case). Every rule mutation-verified. No MCP server keeps a recovery folder at all | ✗ | ✗ | ✗ | ✗ | ✗ | | 47 | **Interconnect-aware import: refuses honestly, with the reason and the setting** | ✗ | **✓ MEASURED + shipped 0.8.2** — on SOLIDWORKS Connected 2026 with `swMultiCAD_Enable3DInterconnect` TRUE there is NO programmatic neutral-file import route at all: LoadFile4 returns nothing (`errors=1`) both with `Nothing` and with a real `GetImportFileData` object, LoadFile2 returns false, OpenDoc6 answers `swFileRequiresRepairError` (2097152) across four option values and `swInvalidFileTypeError` (1024) for docType 0. So `swx_import` makes ONE LoadFile4 attempt (a future edition that accepts it simply works) and then fails with `interconnect_blocks_import`, naming the exact setting — Tools > Options > System Options > Import > Enable 3D Interconnect — the measurement date, and the fact that **this bridge does not change user settings, not even temporarily**. No MCP server reads that toggle at all: they report a translator failure, which sends the reader hunting a missing translator that is not the problem | ✗ | ✗ | ✗ | ✗ | ✗ | | 46 | **3D Interconnect is understood, obeyed and reported** (the user's own setting decides how a neutral file comes in; the bridge reads it and never writes it) | ✗ | **✓ LIVE-MEASURED 2026-09-17, routed in 0.8.0** — `GetUserPreferenceToggle(691)` = TRUE on the install, so a STEP is not translated at all: `LoadFile4` executes and returns nothing with `errors=1`, and SOLIDWORKS instead OPENS the file with `OpenDoc6(path, swDocPART, …)` as a part holding a LINKED 3D Interconnect feature. `swx_import` reads the toggle, routes accordingly, and reports `interconnect` / `linked` / `sourcePath` so a caller knows the part is not self-contained. The preference is NEVER written — not even flip-and-restore, because a crash between the halves would leave the user's CAD configured differently than they left it — and `dissolve:true` is REFUSED until the link-breaking call is measured on this edition. Import-diagnostics auto-run (toggle 291) is also TRUE, so the modal dialog it raises is classified, reported as `stoppedByDialog`, and never answered. Toggle ids read from the installed `SolidWorks.Interop.swconst.dll` | ✗ | ✗ | ✗ | ✗ | ✗ |

@@ -1085,7 +1085,7 @@ launch gate now waits for READY before any probe of its own.  | | | |---|---|-| Gated by default | Every verb waits for readiness unless it is on `STARTUP_EXEMPT` (16 verbs, each with its reason in `src/verbs.rs`: the status/start/describe probes, the bridge-local and disk verbs, the window-census and window-message verbs, the screenshot, the badge, and `swx_kill`). The 15-name gate list had left `swx_show_*` (an `open`), `swx_export` and the ten `swx_export_*` (`SaveAs3` — the crash log's `CMD:DocSave`), `swx_com_eval`, `swx_set_parameter`, `swx_props_set`, `swx_rebuild_check`, `swx_bom`, `swx_pack_and_go`, `swx_activate_document` and `swx_set_preference` reachable during add-in load. The gate also moved BEFORE the handler table (several arms return directly). `tests/wiring.rs` pins the exemption list name by name; a new verb is gated until someone adds it there |+| Gated by default | Every verb waits for readiness unless it is on `STARTUP_EXEMPT` (16 verbs in 0.9.5, 17 from 0.9.11 with `swx_user_presence`, each with its reason in `src/verbs.rs`: the status/start/describe probes, the bridge-local and disk verbs, the window-census and window-message verbs, the screenshot, the badge, and `swx_kill`). The 15-name gate list had left `swx_show_*` (an `open`), `swx_export` and the ten `swx_export_*` (`SaveAs3` — the crash log's `CMD:DocSave`), `swx_com_eval`, `swx_set_parameter`, `swx_props_set`, `swx_rebuild_check`, `swx_bom`, `swx_pack_and_go`, `swx_activate_document` and `swx_set_preference` reachable during add-in load. The gate also moved BEFORE the handler table (several arms return directly). `tests/wiring.rs` pins the exemption list name by name; a new verb is gated until someone adds it there | | The log speaks only for THIS session | A log last written before this process's creation time (census; the host's own word if there is no census) is `notThisSession` — never `complete`. Within a bound log the latest start is located by position (the format has no timestamps this bridge relies on) | | COM alone is never enough on a machine that writes markers | Measured: `StartupProcessCompleted` was TRUE before the marker. Once a marker has been seen in this machine's log (remembered in the data root, `perflog-markers-seen`), a session with no marker of its own is `loading`, and an untied log makes the session `unverifiable` — COM's `true` does not decide. Only an edition whose log has never held a marker lets COM decide alone | | An add-in loaded ON DEMAND | A `LOAD_ADDIN` after this session's marker is read as on-demand (ready) only when COM says the start completed, the log has been quiet for 60 s (`ON_DEMAND_QUIET_SECS`), and none of the `LOAD_ADDIN` lines after the marker names the 3DEXPERIENCE add-in (every start loads it — it writes the marker — so naming it means a start, possibly wedged). The verdict `onDemandAddInAfterComplete` carries this basis in `why` |@@ -1167,6 +1167,26 @@ gap between COM true and the marker. Read-only, no document commands; it waits until Drew is no longer working in the session (0.9.9's presence guard is what tells the harness so). +**MEASURED LOCK-OUT, 2026-10-01 on hosted 0.9.10, and 0.9.11.** Drew's session+— pid 26924, started 14:59:33, 34 documents open, nearly three hours old — had+every gated verb refused `host_app_starting`: the update had respawned the+bridge (the ready latch was gone) and the log read "loading … names the+platform add-in". The log, verbatim: lines 93–101 `<AD2> "LOAD_ADDIN" …` (100 =+`"SWK3DCompassAddin.dll" "3DEXPERIENCE for WORKS"`), 106 `<3DXINITERROR>0`, 107+`<3DXLOAD_TIME>19000</3DXLOAD_TIME>`, 114–120 `<AD2> "UNLOAD_ADDIN" …` (119 =+the platform add-in UNLOADING), 124 `<AD2> "LOAD_ADDIN" "sldfuncfeat.dll"`, then+periodic `<PROCMEM> CMD:AppRunTime` lines (last write 15 min before the read).+**The bug:** `UNLOAD_ADDIN` contains `LOAD_ADDIN`, so line 119 read as the+platform add-in loading after the marker — "a start".++| 0.9.11 | |+|---|---|+| L1 — parse the token | A load event is the quoted token `"LOAD_ADDIN"` (or the `<LOAD_ADDIN>` tag), never a substring; `"UNLOAD_ADDIN"` is its own event and never evidence of loading. The measured log is a fixture: it reads `onDemandAddInAfterComplete` → ready |+| L2 — a session cannot be starting for hours | Process older than 10 min (`SWX_LONG_RUNNING_SECS`) AND COM StartupProcessCompleted true: "loading" holds only if a startup line changed within the quiet window; otherwise ready, basis `longRunningSession` |+| L3 — startup activity, not file activity | An active session writes `<PROCMEM> CMD:AppRunTime` periodically, so the FILE is never quiet. The quiet window now counts only add-in loads and markers: the bridge remembers, per session, when those lines last changed (all were written at or before the file's mtime when first seen) |+| L4 — swx_user_presence is exempt | It answers during a start or a wedge: foreground and last input from the process census; documents asked of COM only on a verified-ready session, otherwise `documentsUnknown:true`, which counts as present. The exemption list is 17 verbs |+| L5 — the latch survives a respawn | A session seen ready is persisted in the data root (`ready-sessions.json`, by pid + creation time); a respawned bridge reads it (`readyBeforeThisBridgeRestarted`) |+ ## Live proof 4 — 0.9.3 on Drew's machine (2026-10-01)  | | Measured |

@@ -1,6 +1,6 @@ {   "slug": "solidworks-bridge",-  "version": "0.9.10",+  "version": "0.9.11",   "type": "app",   "description": "Skills for your container so your AI knows how to drive the SOLIDWORKS bridge (swx_* verbs). The bridge runtime itself is the release zip \u2014 a single native swx-bridge.exe; Adom Bridge loads that.",   "tags": [

@@ -86,7 +86,10 @@ Read this before starting SOLIDWORKS, while waiting through a launch or a 3DEXPE   after the start (a quiet log, an add-in other than 3DEXPERIENCE, COM true)   does not make a started session "starting" again. A session that never   loads the platform add-in (it can be disabled) is ready once its log is quiet-  and COM agrees; a log still being written holds the start.+  and COM agrees; a log still being written holds the start. A session older+  than ten minutes whose COM says the start completed is never held by the log+  unless add-in loads are still appearing (`longRunningSession`), and a session+  seen ready stays ready across a bridge update. - **`state:"unverifiable"`** — nothing can verify the start. After the grace   (`readsAllowed:true`) READ verbs run; anything that creates, opens, saves,   closes or changes a document refuses with `startingUnverifiable:true`

@@ -230,6 +230,56 @@ fn mark_taken_over(pid: u32, created: Option<u64>, evidence: &Value) {     crate::ledger::record("session_taken_over_by_user", json!({"pid": pid, "createdAt": created, "evidence": evidence})); } +/// PRESENCE WITHOUT COM (0.9.11, L4): for swx_user_presence while SOLIDWORKS+/// has not finished starting (or COM cannot answer) — the foreground window and+/// the last input are measured exactly as always, from the process census; the+/// DOCUMENT part is unknown, and unknown counts as present.+pub fn measure_without_com() -> Option<(bool, Value)> {+    let os = crate::launchos::os();+    let census = os.processes().ok()?;+    let sw: Vec<&crate::launchos::ProcInfo> =+        census.iter().filter(|p| p.image.eq_ignore_ascii_case("SLDWORKS.exe")).collect();+    let [one] = sw.as_slice() else { return None };+    let (pid, created) = (one.pid, one.created_at);+    let children: Vec<u32> = census.iter().filter(|p| p.ppid == Some(pid)).map(|p| p.pid).collect();+    let fg = os.foreground_window();+    let input = os.seconds_since_last_input().ok();+    let (fg_json, fg_is_sw) = match &fg {+        Ok(Some(w)) => (+            json!({"hwnd": w.hwnd, "pid": w.pid, "title": w.title, "className": w.class_name}),+            w.pid == pid || children.contains(&w.pid),+        ),+        Ok(None) => (json!({"unreadable": "no window has the foreground"}), false),+        Err(e) => (json!({"unreadable": e}), false),+    };+    let at_keyboard = fg_is_sw && input.map(|n| n < idle_secs()).unwrap_or(false);+    let taken = taken_over(pid, created).is_some();+    let evidence = json!({+        "present": true,+        "foregroundWindow": fg_json,+        "foregroundIsSolidworks": fg_is_sw,+        "secondsSinceLastInput": input,+        "idleThresholdSecs": idle_secs(),+        "foreignDocuments": Value::Null,+        "documentsUnknown": true,+        "takenOverByUser": taken || at_keyboard,+        "takenOverEarlier": taken,+        "processId": pid,+        "processCreatedAt": created,+        "basis": if at_keyboard {+            "SOLIDWORKS is the foreground window and the user gave input recently"+        } else {+            "SOLIDWORKS cannot be asked about its documents right now (it has not finished starting, \+             or COM cannot answer), so whether the user has documents open is UNKNOWN — which counts \+             as present"+        },+    });+    if at_keyboard {+        mark_taken_over(pid, created, &evidence);+    }+    Some((true, evidence))+}+ /// MEASURE PRESENCE. `(present, evidence)`. pub fn measure(ctx: &crate::verbs::Ctx) -> Option<(bool, Value)> {     let s = session(ctx)?;

@@ -3045,7 +3045,17 @@ pub const CATALOG: &[(&str, &str, &str)] = &[ /// guarded by, on its own (0.9.9). Read-only towards SOLIDWORKS; positive /// evidence marks the session taken over by the user, exactly as the guard does. fn swx_user_presence(ctx: &Ctx, _args: &Value) -> Value {-    match crate::presence::measure(ctx) {+    // EXEMPT FROM THE STARTUP GATE (0.9.11, L4): a read about the USER, needed+    // most while SOLIDWORKS is starting or wedged. It asks COM for documents+    // only when the session is verified ready; otherwise it measures without+    // COM and says the document part is unknown.+    let ready = crate::readiness::assess(ctx).get("ready").and_then(|v| v.as_bool()) == Some(true);+    let measured = if ready {+        crate::presence::measure(ctx).or_else(crate::presence::measure_without_com)+    } else {+        crate::presence::measure_without_com()+    };+    match measured {         None => ok(json!({"present": Value::Null, "running": false,                           "_hint": "No running SOLIDWORKS session to measure."})),         Some((present, evidence)) => ok(json!({@@ -3120,6 +3130,7 @@ pub const STARTUP_EXEMPT: &[(&str, &str)] = &[     ("swx_screenshot", "through ab's generic screenshot; no com host"),     ("swx_set_driving_badge", "the taskbar badge; no com host"),     ("swx_kill", "the last resort for a wedged start (reason + confirm); reads the document count only to say what is lost"),+    ("swx_user_presence", "a read about the USER, needed most during a start; asks COM for documents only on a verified-ready session"), ];  /// swx_stop is gated with one carve-out: under `userAuthorized`, a plan that

@@ -1068,7 +1068,7 @@ fn the_startup_exemption_list_is_pinned_name_by_name() {         "swx_status", "swx_readiness", "swx_start", "swx_describe", "swx_progress",         "swx_action_ledger", "swx_verb_times", "swx_uninstall", "swx_find_files",         "swx_recover_list", "swx_window_info", "swx_dismiss_blocking_dialogs",-        "swx_close_window", "swx_screenshot", "swx_set_driving_badge", "swx_kill",+        "swx_close_window", "swx_screenshot", "swx_set_driving_badge", "swx_kill", "swx_user_presence",     ];     pinned.sort();     assert_eq!(