SOLIDWORKS Bridge

@@ -1 +1 @@-0.9.3+0.9.4

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

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

@@ -458,7 +458,22 @@ not.  ## Roadmap -- v0.9.3 (this): **attached is not ready — and a declined quit is about the+- v0.9.4 (this): **a notification is not a modal.** Measured 2026-10-01 on+  hosted 0.9.3 (where an ab update was also measured to leave the data root+  byte-for-byte untouched, and readiness worked — with `StartupProcessCompleted`+  TRUE before the log marker, so both signals stay required): the 3DEXPERIENCE+  "Connected to …" notice — a title-less `#32770` tool window whose owner frame+  stayed enabled for 95 s and which had no Button-class control — blocked every+  quit, sweep and import for minutes. The window census now records evidence for+  every candidate (owner, ownerEnabled, style, exstyle, rect, child control+  classes and visibility) and returns it in every dialog report; a window blocks+  when its kind is known-blocking, its owner frame is disabled, or it offers a+  Button-class control, and is a reported, never-answered `notification` only when+  all of that was measured otherwise — anything unread fails closed. Template+  placeholder captions are flagged (`textIsTemplatePlaceholder`) and not presented+  as the window's words; the quit gate prints full evidence when blocked.+  `neverAnswer` is unchanged. 452 tests.+- v0.9.3: **attached is not ready — and a declined quit is about the   session's history.** Both measured live on 2026-10-01.    Document commands sent 8 s after COM attach CRASHED SOLIDWORKS while its

@@ -2,7 +2,7 @@   "manifest_version": 1,   "name": "solidworks",   "displayName": "SOLIDWORKS",-  "version": "0.9.3",+  "version": "0.9.4",   "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",

@@ -112,13 +112,14 @@ templates**, alisamsam **22**. | 44 | **Graceful QUIT that is measured, not assumed** (never a kill, never answers a dialog, proves the exit from the process census) | ✗ | **✓ LIVE-PROVEN 2026-09-17 (rung a)** — `swx_stop {userAuthorized, maxRung:"a"}` quit a bridge-launched session on the FIRST rung (UserControl=false; ExitApp; every COM reference released), verified absent from the process census; `swx_shutdown` then removed a stray empty instance (pid 145188) and `tasklist` showed no `sldworks.exe` at all. **`ExitApp` is NOT declined at zero documents on this edition** — the long-held `host_app_stop_declined` belief was a SAVE-PROMPT STALL misread as a refusal, which is why the ladder was built pinned at rung (a) and why the preserve-then-close sweep is what actually unblocked it. A rung ladder (a `ExitApp` → f Restart Manager *without* `RmForceShutdown`), pinned at rung (a); 7 re-measured preconditions where UNKNOWN refuses and `force` waives the UNSAVED question ONLY; every COM reference released before and after each rung, with outstanding refs named in the report; success = *this pid AND this creation time* absent from the census, never `GetActiveObject`; per-session children reaped while the documented platform daemons are left alone; a dialog stops the ladder permanently and is never answered; nothing disowned until the exit is verified. every precondition re-measured before EVERY rung (a mid-ladder refusal is a real outcome), the exit POLLED to the rung's budget rather than sampled once (a real `ExitApp` returns before the process goes), the dialog census covering the `swCefSubProc` web-view children by parentage, the count cross-checked against the enumeration, and the message rungs re-verifying window ownership before they send. `tools/quit-gate.py` proves the session was bridge-launched, and **its FULL CYCLE PASSED LIVE 2026-09-30 through the bridge ab hosts**: rung (a), process gone 29.5 s, per-session servers reaped, nothing on screen, no crash reporter, every rung reported, and SOLIDWORKS relaunched by the bridge 54.7 s later. The gate now reaches the bridge through ab's verb routing (the side-loaded dev copy on 24695 is terminated by ab 2.1.163 within 30 s) and passes `userAuthorized:true` — the standing authorization — rather than the write-gate pair, which the hosted bridge rightly never enables. **MEASURED 2026-10-01: the decline is about session HISTORY** — rung (a) was declined three times on a session that had never held a document and quit in 3.4 s once one had been created and closed; since 0.9.3 the ladder PRIMES such a session (empty, no dialog, user-authorized only) and asks again, and the gate's "no longer running" claim — which had passed vacuously after declines — now requires `running:false` and is self-tested | ✗ | ✗ | ✗ | ✗ | ✗ |  | 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 | ✗ | ✗ | ✗ | ✗ | ✗ |+| 51 | **Dialogs judged by MEASURED MODALITY, not by existence** (a notification never blocks; a modal always does) | ✗ | **✓ 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. 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; fifteen document and quit verbs refuse `host_app_starting` with `retryAfterSeconds` until then; 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` | ✗ | ✗ | ✗ | ✗ | ✗ | | 45 | **Closes its own documents without asking — and loses nothing doing it** (preserve-then-close: every open document written to a recovery folder and verified there BEFORE anything closes) | ✗ | **✓ LIVE-PROVEN 2026-09-17 (0.7.7)** — `swx_shutdown {reason}` / `swx_close_all_safely {reason}` save every open document into `%LOCALAPPDATA%\adom-solidworks-bridge\recovery\<timestamp>\` (0.9.0: `Adom Bridge\solidworks-data\…`, inside the directory ab's installer owns; before that `…\bridges-cache\solidworks\recovery\…`, inside ab's install cache, which an update empties: row 49), verify it, close parents before children, then quit; no write opt-in, no per-document confirmation (Drew, 2026-09-11: *"I despise every time you ask for help closing"*). The authorization is to CLOSE, not to lose anything, so the consent question is replaced by checkable rules: the sweep REFUSES TO START when the recovery volume cannot hold the session it is about to write (`insufficient_headroom` with free/needed/shortfall, nothing written, nothing closed), re-checked before every save, with `headroomBytesBefore` and `estimatedWriteBytes` always reported — because a recovery file can be the RIGHT document CUT SHORT and no check on the file can tell (the marker is at offset 4, so every prefix carries it); the recovery file is verified STRUCTURALLY — it must be a recognised SOLIDWORKS container AND at least as big as the smallest real document of its KIND (part 24 KB, assembly 80 KB, drawing 256 KB — one floor for all three would have to be the lowest of them, letting an assembly stop at a third of its size), with the KIND carried from the COM read to the verdict and NEVER re-derived from the recovery file's name, because that name is chosen from the kind and so cannot check it; an unreadable document type falls back to the document's OWN PATH and then its title (evidence about the document, not names this sweep chose) and only then to UNKNOWN, which takes a neutral `.sldrecover` name and the strictest floor — and if SOLIDWORKS refuses to write that name the file is re-saved as `.SLDPRT` with the fallback RECORDED and the unknown-kind verification unchanged; `swx_recover_list` re-runs the verdict on every file it lists and reports `verified` with the reason — a file the sweep refused is listed (never deleted: those bytes are the only ones there are) but never called a rescue, never offered as openable, and its entry says the document was left OPEN — and gives every genuine rescue its own `howToOpen`, because SOLIDWORKS will not open a `.sldrecover` file until it is renamed, published as `recoverySignatureOk` + `recoveryBytes`, and it fails CLOSED (`exists()` passes a zero-byte file and any byte floor passes a truncated one; both are what a full disk leaves). The container marker was MEASURED on 166 real documents from three hardware repositories, because the signature every reference names for a SOLIDWORKS document (OLE compound file) appears in NONE of them — verifying that, as pass 23 specified, would have refused to close every document on a modern install; **FIRST AUTONOMOUS CLOSE, live 2026-09-17**: `swx_close_all_safely {userAuthorized, batch:1}` on a bridge-launched session took 4 documents (3 same-titled pathless import temps + a throwaway part) to `recovery\20260917-150646\` under unique names (25,834 / 26,031 / 25,773 / 26,047 bytes, `recoverySignatureOk:true`, `namingFallback:null`), closed each BY PATH, count 4 → 0, `done:true`, `stoppedBy:null`, headroom 1.59 TB — nobody was asked to close anything. A document that could not be written is left OPEN and named in `remaining`; the user's saved-then-edited file is copied to recovery under a new name and their original is asserted byte-for-byte unchanged; `SaveAs3` uses `swSaveAsOptions_Silent` ALONE so the document RE-POINTS at the recovery file and the close key is read from the document after the save; a dialog stops the sweep and is never answered, with the census taken before EVERY save and EVERY close (a save can raise a prompt of its own, which a per-batch census could not see until the closes had happened); and an UNREADABLE window census is its own outcome — saves proceed, nothing closes, `stoppedBy:"dialogCensusUnknown"`. Ordering is proven from a journal, not from the end state. Every rule is mutation-verified (disable it and exactly one test fails). **Ownership measured live 2026-09-30, both halves**: a pathless `Part2` preserved (25,959 bytes, verified, listed from the manifest) and Drew's saved `R_0603_1608Metric_1.step-1.sldprt` closed with its original untouched (same 32,311 bytes, same mtime). Since 0.9.0 such a document is RECORDED as `closedInPlace` with its original's size and mtime, and `swx_recover_list` says "closed at its own path, untouched" — or that it has changed since, or is gone — by measuring the file, not by assuming it | ✗ | ✗ | ✗ | ✗ | ✗ | -*(50 numbered rows; rows 29–31 are the N/A block that accounts for most of the Fusion verb-count gap. Rows 36–42 added 2026-09-08 from the crate build and the launch-resilience rounds; rows 43–45 from the import-leak, quit and safe-close work, and 46–49 from the live runs of 2026-09-17 and 2026-09-30 — the bar is "significantly more powerful than the MCP servers", so every robustness capability gets a row with its evidence level, not a slogan.)*+*(51 numbered rows; rows 29–31 are the N/A block that accounts for most of the Fusion verb-count gap. Rows 36–42 added 2026-09-08 from the crate build and the launch-resilience rounds; rows 43–45 from the import-leak, quit and safe-close work, and 46–49 from the live runs of 2026-09-17 and 2026-09-30 — the bar is "significantly more powerful than the MCP servers", so every robustness capability gets a row with its evidence level, not a slogan.)*  ## Per-competitor notes 

@@ -1080,3 +1080,44 @@ CONTROL launch with no document commands: no `SWEXH`, and the log gained marker appears; whether `LOAD_ADDIN`-then-marker holds on every start (the log format is undocumented — this is a heuristic read of one machine's log). The launch gate now waits for READY before any probe of its own.++## Live proof 4 — 0.9.3 on Drew's machine (2026-10-01)++| | Measured |+|---|---|+| **An ab update leaves the data root alone** | ab updated the hosted bridge 0.9.2 → 0.9.3 on `refresh_bridges`; the listing of `%LOCALAPPDATA%\adom-solidworks-bridge\` was BYTE-FOR-BYTE IDENTICAL before and after. The move of 0.9.0/0.9.1 is now proven on a real update, not just argued. |+| Readiness | a document verb sent early was refused `host_app_starting` and created nothing; the session became READY 3.4 s after attach, when `<3DXINITERROR>` appeared after the last `LOAD_ADDIN`. **`StartupProcessCompleted` was already TRUE before that marker** — COM alone is not sufficient; requiring both signals is right. |+| Ownership sweep | PASSED: `Part1` preserved by ownership (26,171 bytes, verified, closed); Drew's part `closedInPlace`, untouched (32,311 bytes); `lockFiles: []` |+| Drain gate | 5 / 5 |+| **New blocker** | see below — a NOTIFICATION was judged a modal and blocked every quit |++**The notification that blocked every quit.** `swx_stop` → `stop_blocked_by_dialog`+on a window the census called kind `unknown`, title `""`, text `["Title",+"Description","Button1","Button2","Hyperlink Text 1","Hyperlink Text 2"]`,+buttons `[]`. Captured independently: hwnd 331370, owner process sldworks, class+`#32770`, visible, style 0x94000044, exstyle 0x90080 (WS_EX_TOOLWINDOW |+WS_EX_LAYERED | WS_EX_CONTROLPARENT), rect 533,45–834,112 (301x67 px near the top+of the frame), GW_OWNER = the main frame, ALL children class `Static` (visible:+"Title", "Description"; hidden: the Button/Hyperlink statics). It appeared ~18 s+after a document create + drain (not at idle before any document), persisted+over 100 s, and for all 20 reads over 95 s its OWNER FRAME WAS ENABLED — not a+modal. A background screenshot showed a green check and "Connected to+OI000616940 — SOLIDWORKS is connected to your 3DEXPERIENCE platform": the+3DEXPERIENCE connection notice, custom-drawn, so the Static captions read were+TEMPLATE PLACEHOLDERS, not its words. It blocked the quit gate (rungsTried+empty); an earlier stop had succeeded only because it was gone by then. It does+NOT clear by itself: nine `swx_stop` attempts one minute apart (16:55:13–17:03:15+UTC) all returned `stop_blocked_by_dialog` on the same window, which had appeared+at ~16:52:08 — more than eleven minutes on an idle, empty session. So waiting and+re-censusing is not a remedy, and 0.9.4 adds none: the modality judgement is the+fix.++**0.9.4 judges windows by measured modality** (`quit::judge_window`): a window+blocks when its kind is a known blocking kind, its owner frame is DISABLED, or it+has a Button-class control; it is a `notification` — reported with its evidence+(owner, ownerEnabled, styles, rect, child controls), never answered, and NOT a+reason to refuse a quit, a sweep or an import — only when it was measured to be+a tool window with an enabled owner and no Button-class control. Anything unread+fails closed: blocking. A window whose readable captions are all template+placeholders says `textIsTemplatePlaceholder:true` and does not present them as+its words. `neverAnswer` is unchanged.

@@ -1922,3 +1922,20 @@ was measured on sessions that had held documents. Startup timing is NOT the caus The coordinator is still investigating whether a session relaunched after a crash holds document-recovery state; this section does not claim history is the only cause of a decline — only that it is one, measured.++### 5.16 A notification is not a modal — measured 2026-10-01++The 3DEXPERIENCE "Connected to …" notice (hwnd 331370: `#32770`, no title,+WS_EX_TOOLWINDOW | WS_EX_LAYERED | WS_EX_CONTROLPARENT, owner = the main frame+and ENABLED for all 20 reads over 95 s, all children Static) appeared ~18 s after+a document create and stayed for minutes, and 0.9.3's census — which treated any+visible `#32770` as blocking — refused every quit while it was up+(`stop_blocked_by_dialog`, `rungsTried: []`). The precondition "no dialog" was+right in spirit and wrong in its instrument: the question is whether the window+is MODAL, and that is measurable. Since 0.9.4 (`quit::judge_window`): blocking =+a known blocking kind, OR the owner frame disabled, OR a Button-class control;+`notification` = a tool window, owner enabled, no Button-class control, all+measured; unknown = blocking. Every dialog report carries the evidence, and+`tools/quit-gate.py` prints it in full when a window stops the ladder. The+licence dialog of 2026-09-17 stays blocking BY KIND — its text and buttons were+measured, its owner's enablement was not.

@@ -1,6 +1,6 @@ {   "slug": "solidworks-bridge",-  "version": "0.9.3",+  "version": "0.9.4",   "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 — a single native swx-bridge.exe; Adom Bridge loads that.",   "tags": [

@@ -22,11 +22,5 @@       "label": "Change a dimension",       "prompt": "Set the extrusion depth on my SolidWorks part to 25mm"     }-  ],-  "hero": {-    "type": "billboard",-    "auto": true,-    "headline": "solidworks-bridge",-    "subhead": "On the Adom Wiki."-  }+  ] }\ No newline at end of file

@@ -111,6 +111,15 @@ Read this before closing any document, quitting SOLIDWORKS, draining leaked impo   `swx_stop` creates and closes one bridge-owned scratch part and asks again; the   second attempt in `rungsTried` says `primed:true`. Nothing is ever primed while   a document is open.+- **A NOTIFICATION does not stop anything.** A window is judged by measured+  modality: it blocks when it is a known blocking kind, its owner frame is+  disabled, or it offers a button; a tool window over an enabled frame with+  nothing to click is a `notification` (`kind:"notification"`, `blocking:false`)+  — reported under `notifications` with its `evidence`, never answered, and the+  quit, sweep or import goes ahead. The 3DEXPERIENCE "Connected to …" notice is+  one (measured 2026-10-01). `textIsTemplatePlaceholder:true` means the captions+  read were a template's ("Title", "Description", …), not what the window shows —+  do not quote them to the user as its message. - **`swx_shutdown` is idempotent.** SOLIDWORKS not running answers `success:true,   alreadyStopped:true`. It is the last thing you do, and the last thing should be   safe to repeat.

@@ -13,7 +13,11 @@ //!   * COM: `ISldWorks::StartupProcessCompleted` (host command `startup_state`); //!   * the performance log: a 3DEXPERIENCE load marker written after the last //!     `LOAD_ADDIN` line (`perflog::startup_complete`) — file-based, no COM.-//! READY = every available signal says so. When NEITHER can be read, a grace of+//! READY = every available signal says so. MEASURED 2026-10-01 on hosted 0.9.3:+//! `StartupProcessCompleted` was already TRUE before the log's marker appeared,+//! and the session became ready 3.4 s after attach when `<3DXINITERROR>` was+//! written after the last `LOAD_ADDIN` — so COM alone is NOT sufficient, and+//! requiring both is the rule. When NEITHER can be read, a grace of //! `GRACE_SECS` after the bridge first saw this session stands in, and the //! answer says so (`basedOn: ["graceAfterFirstSeen"]`) — never silently. A start //! that does not become ready within `TIMEOUT_SECS` stays `starting`, with

@@ -1082,6 +1082,9 @@ struct StopEvidence {     busy: Option<bool>,     identity: Option<crate::quit::Identity>,     dialog: Option<crate::quit::BlockingDialog>,+    /// Windows the census judged NOT blocking — notifications, reported with+    /// their evidence and never answered (0.9.4).+    notifications: Vec<crate::quit::BlockingDialog>,     /// The pids the dialog census actually covered — SOLIDWORKS plus its CEF     /// subprocesses, which is where a 3DEXPERIENCE sign-in window lives.     dialog_pids: Vec<u32>,@@ -1131,6 +1134,7 @@ impl StopEvidence {         let mut dialog_pids: Vec<u32> = Vec::new();         let mut census_readable = false;         let mut dialog = None;+        let mut notifications: Vec<crate::quit::BlockingDialog> = Vec::new();         if let Some(id) = identity.as_ref() {             if let Some(pids) = quit::dialog_census_pids(census.as_ref(), id) {                 let mut all_read = true;@@ -1151,10 +1155,11 @@ impl StopEvidence {                 // tell "your licence expired" from "the licence server is                 // unreachable and this session ends after five more tries".                 // Reading is not answering; nothing here presses anything.-                dialog = quit::first_blocking_dialog(&windows).map(|mut d| {-                    d.read_contents(os);-                    d-                });+                // JUDGED BY MEASURED MODALITY (0.9.4): a notification is reported,+                // never answered, and does not refuse the quit.+                let judged = quit::dialog_census(&windows, os);+                dialog = judged.blocking;+                notifications = judged.notifications;             }         }         // P5: responding, without COM.@@ -1170,6 +1175,7 @@ impl StopEvidence {             busy,             identity,             dialog,+            notifications,             dialog_pids,             census_readable,             responding,@@ -1203,6 +1209,7 @@ impl StopEvidence {             "documentsTruncated": self.docs_truncated,             "unsavedDocuments": self.unsaved,             "dialog": self.dialog.as_ref().map(|d| d.to_json()),+            "notifications": self.notifications.iter().map(|d| d.to_json()).collect::<Vec<_>>(),             "dialogCensusReadable": self.census_readable,             "dialogCensusPids": self.dialog_pids,             "busy": self.busy,@@ -1754,12 +1761,7 @@ fn run_rung(         census = os.processes();         gone = quit::process_gone(census.as_ref(), &id);         after_windows = os.windows_of_pid(id.pid);-        new_dialog = after_windows.as_ref().ok().and_then(|w| {-            quit::first_blocking_dialog(w).map(|mut d| {-                d.read_contents(&*os);-                d-            })-        });+        new_dialog = after_windows.as_ref().ok().and_then(|w| quit::dialog_census(w, os).blocking);         if gone == Some(true) || new_dialog.is_some() || std::time::Instant::now() >= wait_until         {             break;@@ -1845,7 +1847,7 @@ fn prime_session(         ));     }     match os.windows_of_pid(id.pid) {-        Ok(w) if quit::first_blocking_dialog(&w).is_none() => {}+        Ok(w) if quit::dialog_census(&w, os).blocking.is_none() => {}         Ok(_) => return Err("a dialog is up".into()),         Err(e) => return Err(format!("the window census could not be read: {e}")),     }

@@ -710,6 +710,18 @@ fn recovery_dir() -> Result<std::path::PathBuf, String> { /// `None` means the census could not be taken, which also stops: a dialog we /// cannot see is the one that matters. fn blocking_dialog_now(ctx: &Ctx) -> Option<Option<Value>> {+    dialog_census_now(ctx).map(|c| c.blocking.map(|d| d.to_json()))+}++/// The NOTIFICATIONS on screen now — windows the census judged not blocking —+/// with their evidence, for the reply. Empty when the census cannot be taken.+fn notifications_now(ctx: &Ctx) -> Vec<Value> {+    dialog_census_now(ctx)+        .map(|c| c.notifications.iter().map(|d| d.to_json()).collect())+        .unwrap_or_default()+}++fn dialog_census_now(ctx: &Ctx) -> Option<crate::quit::DialogCensus> {     let os = crate::launchos::os();     let state = ctx.call("app_state", json!({}), 20);     let pid = state@@ -736,10 +748,9 @@ fn blocking_dialog_now(ctx: &Ctx) -> Option<Option<Value>> {     // alone cannot tell "your licence expired" from "the licence server is     // unreachable and the session ends after five more tries". Reading is not     // answering — nothing here presses anything.-    Some(crate::quit::first_blocking_dialog(&windows).map(|mut d| {-        d.read_contents(os.as_ref());-        d.to_json()-    }))+    // JUDGED BY MEASURED MODALITY (0.9.4): a notification — owner frame enabled,+    // a tool window, nothing to click — does not stop a sweep or an import.+    Some(crate::quit::dialog_census(&windows, os.as_ref())) }  /// `swx_close_all_safely` — PRESERVE EVERYTHING, THEN CLOSE EVERYTHING.@@ -1211,6 +1222,9 @@ pub fn close_all_safely(ctx: &Ctx, args: &Value) -> Value {             "largestBytes": estimate.largest,         }),         "stoppedByDialog": stopped_by_dialog,+        // On screen and NOT blocking — reported with their evidence, never+        // answered (0.9.4).+        "notifications": notifications_now(ctx),         // WHY it stopped, in one word a caller can branch on.         "stoppedBy": if stopped_by_dialog.is_some() {             json!("dialog")

@@ -275,3 +275,50 @@ fn a_lock_file_in_a_recovery_folder_is_named_apart() {         s(&sweep)     ); }++/// A NOTIFICATION DOES NOT STOP A SWEEP (measured 2026-10-01): the 3DEXPERIENCE+/// "Connected to …" notice — owner frame enabled, a tool window, nothing to click+/// — appeared ~18 s after a document create and stayed for minutes. Under 0.9.3+/// it blocked every quit, sweep and import in that window. Now the sweep runs and+/// the notice is reported with its evidence; it is never answered.+#[test]+fn a_notification_does_not_stop_a_sweep_and_is_reported() {+    let scratch = TempDir::new("notice-sweep");+    session(+        &scratch,+        json!([{"docType": "part", "path": "untitled:a", "title": "Part1", "saved": false, "dirty": true}]),+    );+    let machine = TempDir::new("notice-sweep-machine");+    std::fs::write(+        machine.join("windows.json"),+        json!([{"hwnd": 331370, "className": "#32770", "title": "", "visible": true,+                "owner": 4242, "ownerEnabled": true, "style": 0x9400_0044u64,+                "exStyle": 0x90080u64, "rect": [533, 45, 834, 112]}])+        .to_string(),+    )+    .unwrap();+    std::fs::write(+        machine.join("dialog-open.json"),+        json!({"hwnd": 331370, "controls": [["Static", 0, "Title", true], ["Static", 0, "Description", true],+                                            ["Static", 0, "Button1", false], ["Static", 0, "Button2", false]]})+        .to_string(),+    )+    .unwrap();+    let b = Bridge::start_in(TempDir::borrowed(&scratch.0), &[("SWX_LAUNCH_FAKE_DIR", &machine.path())]);+    b.call("swx_start", json!({}));+    let r = b.call("swx_close_all_safely", json!({"reason": "the user asked me to close SOLIDWORKS"}));+    check!(+        b,+        "swx_close_all_safely: the notification does not stop the sweep",+        r["success"] == true && r["done"] == true && r["stoppedByDialog"].is_null(),+        s(&r)+    );+    check!(+        b,+        "swx_close_all_safely: ...and is reported, with its evidence, never answered",+        r["notifications"][0]["kind"] == "notification"+            && r["notifications"][0]["neverAnswer"] == true+            && r["notifications"][0]["evidence"]["window"]["toolWindow"] == true,+        s(&r["notifications"])+    );+}

@@ -956,6 +956,7 @@ fn acknowledge_only_is_exactly_one_acknowledgement() {         buttons: buttons.iter().map(|s| s.to_string()).collect(),         checkboxes: checkboxes.iter().map(|s| s.to_string()).collect(),         truncated: false,+        controls: vec![],     };     assert!(d(&["OK"], &[]).acknowledge_only(), "one OK is an acknowledgement");     assert!(d(&["&OK"], &[]).acknowledge_only(), "the accelerator ampersand is not part of it");

@@ -691,6 +691,18 @@ def run_ladder(base, max_rung, allow_rm, reason):         print("  rung %s: result=%s processGone=%s newWindows=%s %s" %               (t.get("rung"), t.get("result"), t.get("processGone"), t.get("newWindows"),                str(t.get("detail") or "")[:120]))+    # THE FULL DIALOG EVIDENCE, whenever a window stopped the ladder (0.9.4).+    # 2026-10-01 a title-less window stopped it with `kind: unknown` and nothing+    # else to judge it by; it turned out to be a NOTIFICATION. Print every field+    # the census measured — owner, ownerEnabled, styles, rect, child controls —+    # so the next one can be judged from this output alone.+    pre = r.get("preconditions") or {}+    blocked = r.get("blockingDialog") or pre.get("dialog")+    if blocked:+        show("BLOCKING WINDOW — full evidence (blocking=%s, why=%s)"+             % (blocked.get("blocking"), blocked.get("why")), blocked)+    for n in pre.get("notifications") or []:+        show("NOTIFICATION (not blocking, never answered) — evidence", n)     if r.get("blockingDialog"):         NOTES.append("a dialog stopped the ladder: %s — it is STILL ON SCREEN and this gate did "                      "not answer it — show the user a screenshot (swx_state) and let them "