migrate(C11): UI/accessibility coprocessors — NO_NEW_BRAINS (all senses)

All 10 C11 files are host-side senses. DualAlert integer brain was already
extracted in C6 (DualAlert.affine, 613/613 parity, LOSSLESS). ForceLayout
is a float-only physics wasm (f64 kernel, float-wall). The remaining 8 UI
components (Button, HubButton, NavButton, Label, VolumeSlider, InventoryUI,
HardwareWiring, DualAlertCoprocessor) are pure PixiJS/PixiUI senses.

Ledger and worklist updated; NEXT: C9.

https://claude.ai/code/session_01WoKhFQePiRsAj7aqnxbG8s

Author: claude

proposals/MIGRATION-PLAN.adoc

@@ -195,8 +195,9 @@ Heuristic:
 | C2 wave 2a | DONE | Scalar multiply/divide (2026-06-05, Opus). `Mul`/`Div` turned out to be pure *scalar* value-transforms (not memory ops), so they need *no* array ABI — split out of "wave 2" and landed now. *1 kernel* `VmMulDiv` (11 exports) under `proposals/idaptik/migrated/`. Brain = the reversible ancilla multiply (`c := c + a*b`, inverse `c := c - a*b`) + the quotient/remainder divide whose dividend is reconstructable (`q*b + r == a` for all b incl. 0); the intentional-flaw in-place/simple variants migrated as value transforms with no rt==id claim. *Four gates green:* 1/1 compile, *3322/3322 parity* (incl. mul reversibility roundtrip + div reconstruction), G3 n/a (numeric transform), 1/1 assail-clean. *2 new i32 ABI facts:* (a) JS `a*b` loses precision >2^53 → oracle must use `Math.imul` to match `i32.mul`; (b) `i32.div_s` TRAPS on `b==0` and `INT_MIN/-1` (ReScript wraps the latter) → brain guards both (nested-`if`, avoiding the unverified `&&` codegen path) so the wasm is total. Evidence: `migrated/EVIDENCE-C2-wave2a.adoc`. NEXT: C2 wave 2b.
 | C2 wave 2b | DONE | Memory/stack/port/control opcodes (2026-06-05, Opus). *The "needs an array/linear-memory ABI" premise was WRONG and re-decomposition overturned it:* reading the sources, the VM's memory/stack/port buffers are not arrays in the brain — `VmState.res` stores every one as string-keyed dict slots (`_mem:N`, `_s:N`, `_pin:port`), i.e. host-side STATE (senses). The integer brains are all scalar. *4 kernels* `VmMemory` (LOAD/STORE), `VmStack` (PUSH/POP), `VmPort` (RECV/SEND), `VmControl` (IF_POS/IF_ZERO/LOOP) covering *9 opcodes*. *Four gates green:* 4/4 compile, *1568/1568 parity* (incl. load/store/sp/recv/send round-trips), G3 n/a (transforms/predicates), 4/4 assail-clean. No-kernel senses (classified, not migrated): Call (orchestration), CoprocessorCall (tombstone — never implemented), State/VmState/VM/SubroutineRegistry/VmStateCoprocessor/InstructionCoprocessor (state containers / bridges). Evidence: `migrated/EVIDENCE-C2-wave2b.adoc`. *No array ABI was required* (the blocker was a triage-bucket artefact). *Cluster C2 COMPLETE.* NEXT: C3.
 | C3 | DONE | Coprocessor wiring layer (2026-06-05, Opus) — *classified, no new brains to extract.* C3's 17 `src/shared/` files are the host-side bridge layer that exposes C1's already-migrated wasm brains to the game engine. Verified de-dup (by constant, not name): the integer cores C3 needs (`compute_gate`/`data_limit_for_domain` 513/16/259/1024, `max_concurrent_compute` 10, `is_transient` 503/504/429, policy table, DeviceType/GameEvent ordinals) are *all* already migrated + 4-gate-verified in C1. The 12 `*Coprocessor.res` are pure-FFI passthrough (0 logic lines); `Kernel_Compute`/`RetryPolicy` (src/shared) are async/float wrappers over C1 brains; `DeviceType`/`GameEvent` add string-gated ops (string wall, Phase F). No 4-gate run (nothing new to verify). Bridges stay host-side as the essential wasm-loading glue (ADDITIVE, FeaturePacks-flagged); their ReScript→glue fate is a Phase-Ω cutover decision. Evidence: `migrated/EVIDENCE-C3.adoc`. NEXT: C5.
-| C5 | DONE | Engine coprocessors (2026-06-05, Opus). *2 integer brains extracted + 9 senses classified.* `Maths` (clamp/lerp-milli/dist_sq — float-wall convention, sqrt host-side) and — the strategic one — `Random`, the deterministic **xmur3 + mulberry32 PRNG**, the multiplayer-reproducibility backbone (host iterates the seed string + does the final u32→[0,1) float div; brain owns the i32 mixing). *Four gates green:* 2/2 compile, *2108/2108 parity* (Random **bit-exact** vs the JS source over the full i32 domain + UTF-16 code units, incl. the `>>>` emulation + signed-i32 multiplier constants), G3 n/a (transforms/mixing), 2/2 assail-clean. Senses (classified, not migrated): 5 `*Coprocessor` FFI bridges, Resize/GetResolution (float+DOM), Audio (Pixi), Navigation (screen-stack orchestration + async asset load, effect-gated), WaitFor (timing). Evidence: `migrated/EVIDENCE-C5.adoc`. NEXT: C11.
-| C9..C12 | TODO | Remaining clusters per `migration-map.json`: *C11 (10, "pure integer presentation state" — font scaling/keyboard-nav/popup logic)* next (highest brain-yield); then C9 (16, game-loop/AffineTEA/VeriSim types — mixed) and C10 (21, utils/tools/companions/narrative/proven — mixed); C12 (43, render-glue screens/PixiJS bindings — senses-heavy, migrated last). Established scalar/enum/predicate recipe. Genuine compiler gates remain: string wall (52 non-test .res — note the `[len:i32][utf8]` layout is already in `codegen.ml:375`, only the *ops* are missing), effect wall (110); unary-`~` codegen bug is a candidate Phase-F fix.
+| C5 | DONE | Engine coprocessors (2026-06-05, Opus). *2 integer brains extracted + 9 senses classified.* `Maths` (clamp/lerp-milli/dist_sq — float-wall convention, sqrt host-side) and — the strategic one — `Random`, the deterministic **xmur3 + mulberry32 PRNG**, the multiplayer-reproducibility backbone (host iterates the seed string + does the final u32→[0,1) float div; brain owns the i32 mixing). *Four gates green:* 2/2 compile, *2108/2108 parity* (Random **bit-exact** vs the JS source over the full i32 domain + UTF-16 code units, incl. the `>>>` emulation + signed-i32 multiplier constants), G3 n/a (transforms/mixing), 2/2 assail-clean. Senses (classified, not migrated): 5 `*Coprocessor` FFI bridges, Resize/GetResolution (float+DOM), Audio (Pixi), Navigation (screen-stack orchestration + async asset load, effect-gated), WaitFor (timing). Evidence: `migrated/EVIDENCE-C5.adoc`. NEXT: C11 (done below).
+| C11 | DONE | UI and accessibility coprocessors (2026-06-05) — *classified, NO_NEW_BRAINS.* All 10 files are host-side senses. `DualAlert.res` integer core (alert-level ordinals, escalation, trigger-milli, scrub, overall-threat, dispatch predicates) was already extracted in C6 (`DualAlert.affine`, 613/613 parity, LOSSLESS boundary proof). `DualAlertCoprocessor.res` is the existing ReScript FFI bridge to that wasm. `ForceLayoutCoprocessor.res` wraps `forcelayout.wasm`, a float-only physics kernel (euclidean/repulsion/attraction/velocity/alpha — f64 throughout; float-wall: brain stays host-side). Remaining 7 files (`Button`, `HubButton`, `NavButton`, `Label`, `VolumeSlider`, `InventoryUI`, `HardwareWiring`) are pure PixiJS/PixiUI senses with zero separable integer computation. No 4-gate run. Evidence: `migrated/EVIDENCE-C11.adoc`. NEXT: C9.
+| C9..C12 | TODO | Remaining clusters per `migration-map.json`: *C9 (16, game-loop/AffineTEA/VeriSim types — mixed)* next; then C10 (21, utils/tools/companions/narrative/proven — mixed); C12 (43, render-glue screens/PixiJS bindings — senses-heavy, migrated last). Established scalar/enum/predicate recipe. Genuine compiler gates remain: string wall (52 non-test .res — note the `[len:i32][utf8]` layout is already in `codegen.ml:375`, only the *ops* are missing), effect wall (110); unary-`~` codegen bug is a candidate Phase-F fix.
 | F+ | TODO | Compiler walls (string backend, then effects).
 | Ω | TODO (access-gated) | Cutover + ReScript extinction.
 |===

proposals/idaptik/migrated/EVIDENCE-C11.adoc

@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// SPDX-FileCopyrightText: 2025-2026 Jonathan D.A. Jewell <j.d.a.jewell@open.ac.uk>
+= Cluster C11 (UI and accessibility coprocessors) — migration evidence (2026-06-05)
+:toc: macro
+
+[IMPORTANT]
+====
+*Verdict: NO_NEW_BRAINS — wiring/senses cluster.* All 10 files are host-side
+senses (PixiJS UI components, coprocessor bridges, float-physics wiring). No
+new AffineScript kernels are required because:
+
+1. The integer brain of `DualAlert.res` (alert-level ordinals, escalation,
+   trigger-milli, scrub, overall-threat, dispatch predicates) was already
+   extracted in *cluster C6* (`DualAlert.affine`, 613/613 parity, LOSSLESS
+   boundary proof). `DualAlertCoprocessor.res` is the existing ReScript
+   bridge to that wasm.
+2. `ForceLayoutCoprocessor.res` is a bridge to `forcelayout.wasm` (a
+   float-only physics kernel — euclidean distance, repulsion/attraction
+   velocity deltas, velocity decay, position integration, alpha cooling).
+   The brain is f64-only; the float-wall convention defers it to host-side.
+3. `Button`, `HubButton`, `NavButton`, `Label`, `VolumeSlider`,
+   `InventoryUI`, `HardwareWiring` are pure PixiJS/PixiUI components with
+   zero separable integer computation.
+
+No 4-gate recipe is applied; no new wasm is produced.
+====
+
+toc::[]
+
+== File-by-file disposition
+
+[cols="3,1,4",options="header"]
+|===
+| File | Disposition | Reason
+| `src/app/ui/DualAlert.res` | SENSES (brain in C6) | Integer core (`levelValue`, `levelColor`, `escalateLevel`, `scrubStep`, trigger-milli, cooldown-milli, `overallThreat`, `shouldDispatchAntiHacker`, `guardsCheckingTerminals`) already lives in `DualAlert.affine` (C6, 613/613 parity). Float progress/trigger-severity orchestration stays host-side.
+| `src/app/ui/DualAlertCoprocessor.res` | SENSES (bridge) | ReScript FFI wrapping `DualAlertCoprocessorBridge.js` → `dualalert.wasm`. Pure `external` declarations; no logic.
+| `src/app/popups/ForceLayoutCoprocessor.res` | SENSES (float-brain bridge) | Wraps `forcelayout.wasm` float kernel (euclidean, repelDv, attractDv, decayVelocity, integratePosition, decayAlpha). All f64 primitives; float-wall convention: brain deferred to host-side.
+| `src/app/ui/Button.res` | SENSES (PixiJS) | FancyButton nine-slice wrapper + FontScale + Audio SFX. Zero integer computation.
+| `src/app/ui/HardwareWiring.res` | SENSES (PixiJS) | Interactive patch-panel with float catenary sag (`computeSagLocal`), quadratic Bézier cable rendering, pointer-event wiring, string template port IDs. No separable integer brain.
+| `src/app/ui/HubButton.res` | SENSES (PixiJS) | Programmatic Graphics FancyButton variant. Zero integer computation.
+| `src/app/ui/InventoryUI.res` | SENSES (UI) | `formatQuickbar` maps inventory slots to HUD display records. No integer computation.
+| `src/app/ui/Label.res` | SENSES (PixiJS) | `Text.make` wrapper with centered anchor. Zero integer computation.
+| `src/app/ui/NavButton.res` | SENSES (PixiJS) | Sidebar navigation FancyButton with active-indicator Graphics. Zero integer computation.
+| `src/app/ui/VolumeSlider.res` | SENSES (PixiJS) | PixiUI Slider component factory. Zero integer computation.
+|===
+
+== DualAlert — de-duplication verification
+
+The C11 cluster description names `src/app/ui/DualAlert.res` as a source file.
+C6's kernel inventory entry is:
+
+----
+DualAlert.affine  |  DualAlert.res — dual-threat alert level machine
+----
+
+Cross-check of C6 evidence versus C11 `DualAlert.res` content:
+
+* C6 `DualAlert.affine` exports: `level_value`, `level_color`, `escalate_level`,
+  `scrub_step`, `trigger_escalates`, `trigger_progress`, `trigger_level`,
+  `cooldown_progress`, `overall_threat`, `should_dispatch_anti_hacker`,
+  `guards_checking_terminals`.
+* C11 `DualAlertCoprocessor.res` bridge methods: `levelValue`, `levelColour`,
+  `escalateLevel`, `scrubStep`, `triggerEscalates`, `triggerProgress`,
+  `triggerLevel`, `cooldownProgress`, `overallThreat`, `shouldDispatchAntiHacker`,
+  `guardsCheckingTerminals` — exact semantic correspondence.
+* The float functions in `DualAlert.res` (`physicalSeverity`, `cyberSeverity`,
+  `triggerPhysical`, `triggerCyber`, `updateCooldown`) operate on the mutable
+  `alertState` record (float progress/cooldown fields) — these are host-side
+  orchestration that feeds integer primitives to the wasm.
+
+Verdict: *no new brain needed*; C6's `DualAlert.affine` covers the integer surface.
+C6 evidence: `proposals/idaptik/migrated/EVIDENCE-C6.adoc` (Gate 2: 613/613 parity,
+Gate 3: LOSSLESS boundary proof, Gate 4: clean).
+
+== Host-side senses: ForceLayout physics
+
+`ForceLayoutCoprocessor.res` bridges the following float-only exports of
+`forcelayout.wasm`:
+
+* `euclidean(bridge, x1, y1, x2, y2): float` — Euclidean distance
+* `repelDv(bridge, dist, d, strength, radius): float` — repulsion velocity delta
+* `attractDv(bridge, dist, d, strength): float` — attraction velocity delta
+* `decayVelocity(bridge, v, decay): float` — velocity damping
+* `integratePosition(bridge, pos, v, alpha): float` — position integration step
+* `decayAlpha(bridge, alpha, alphaDecay): float` — simulation cooling
+
+All parameters and return values are `float`. This is a pure f64 physics
+kernel; the float-wall convention requires the brain to remain host-side
+(the AffineScript wasm backend has no f64 sqrt or general float codegen).
+No integer decomposition is applicable — the physics simulation requires
+continuous-domain arithmetic throughout.
+
+== Impact on remaining clusters
+
+C11 being NO_NEW_BRAINS does not affect the C9/C10/C12 roadmap. The
+`DualAlertCoprocessor` wasm is already live; the UI components remain host-side
+ReScript throughout Phase Ω. The completion-drive directive proceeds to *C9*.

proposals/idaptik/migration-map.json

@@ -370,7 +370,15 @@
       "id": "C11",
       "name": "UI and accessibility coprocessors",
       "description": "UI widget logic, font scaling, i18n, keyboard navigation, popup logic \u2014 pure integer presentation state.",
-      "status": "TODO",
+      "status": "DONE",
+      "done": {
+        "date": "2026-06-05",
+        "phase": "G",
+        "verdict": "NO_NEW_BRAINS \u2014 wiring/senses cluster",
+        "note": "All 10 files are host-side senses. DualAlert integer brain already extracted in C6 (DualAlert.affine, 613/613 parity, LOSSLESS boundary proof). DualAlertCoprocessor.res = bridge to C6 wasm. ForceLayoutCoprocessor.res = bridge to float-only physics wasm (euclidean/repulsion/attraction/velocity/alpha kernel; float-wall: deferred host-side). Button/HubButton/NavButton/Label/VolumeSlider/InventoryUI/HardwareWiring = pure PixiJS/UI senses with zero integer computation.",
+        "no_4gate": "nothing new to compile/parity/prove; DualAlert integer core C6-verified (613/613), float physics stays host-side",
+        "evidence": "proposals/idaptik/migrated/EVIDENCE-C11.adoc"
+      },
       "files": [
         "src/app/popups/ForceLayoutCoprocessor.res",
         "src/app/ui/Button.res",