HS-plan: cluster 32 MutationObserver blocked (env + scope)

loops/hs worktree ships without the sx-tree MCP binary built; even
after running `dune build bin/mcp_tree.exe` this iteration, tools
don't surface mid-session and the block-sx-edit hook prevents raw
`.sx` edits. The cluster scope itself spans parser/compiler/runtime
plus JS mock plus generator skip-list, so even with sx-tree loaded
it's a multi-commit job for a dedicated worktree.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

plans/hs-conformance-scoreboard.md

@@ -7,7 +7,7 @@ Baseline:   1213/1496 (81.1%)
 Merged:     1277/1496 (85.4%)   delta +64
 Worktree:   all landed
 Target:     1496/1496 (100.0%)
-Remaining:  ~219 tests (cluster 29 blocked on sx-tree MCP outage + parser scope)
+Remaining:  ~219 tests (clusters 17/22/29/31/32 blocked; 31/32 need dedicated sx-tree worktree)
 ```
 
 ## Cluster ledger
@@ -61,8 +61,8 @@ Remaining:  ~219 tests (cluster 29 blocked on sx-tree MCP outage + parser scope)
 
 | # | Cluster | Status | Δ |
 |---|---------|--------|---|
-| 31 | runtime null-safety error reporting | pending | (+15–18 est) |
+| 31 | runtime null-safety error reporting | blocked | — |
-| 32 | MutationObserver mock + `on mutation` | pending | (+10–15 est) |
+| 32 | MutationObserver mock + `on mutation` | blocked | — |
 | 33 | cookie API | pending | (+5 est) |
 | 34 | event modifier DSL | pending | (+6–8 est) |
 | 35 | namespaced `def` | pending | (+3 est) |
@@ -88,7 +88,7 @@ Defer until A–D drain. Estimated ~25 recoverable tests.
 | A      | 12   | 4       | 0       | 0       | 1       | —           | 17    |
 | B      | 6    | 0       | 0       | 0       | 1       | —           | 7     |
 | C      | 4    | 0       | 0       | 0       | 1       | —           | 5     |
-| D      | 0    | 0       | 0       | 5       | 0       | —           | 5     |
+| D      | 0    | 0       | 0       | 3       | 2       | —           | 5     |
 | E      | 0    | 0       | 0       | 0       | 0       | 5           | 5     |
 | F      | —    | —       | —       | ~10     | —       | —           | ~10   |
 

plans/hs-conformance-to-100.md

@@ -115,9 +115,9 @@ Orchestrator cherry-picks worktree commits onto `architecture` one at a time; re
 
 ### Bucket D: medium features (bigger commits, plan-first)
 
-31. **[pending] runtime null-safety error reporting** — 18 tests in `runtimeErrors`. When accessing `.foo` on nil, emit a structured error with position info. One coordinated fix in the compiler emit paths for property access, function calls, set/put. Expected: +15-18.
+31. **[blocked: Bucket-D plan-first scope, doesn't fit one cluster budget. All 18 tests are SKIP (untranslated) — generator has no `error("HS")` helper. Required pieces: (a) generator-side `eval-hs-error` helper + recognizer for `expect(await error("HS")).toBe("MSG")` blocks; (b) runtime helpers `hs-null-error!` / `hs-named-target` / `hs-named-target-list` raising `'<sel>' is null`; (c) compiler patches at every target-position `(query SEL)` emit to wrap in named-target carrying the original selector source — that's ~17 command emit paths (add, remove, hide, show, measure, settle, trigger, send, set, default, increment, decrement, put, toggle, transition, append, take); (d) function-call null-check at bare `(name)`, `hs-method-call`, and `host-get` chains, deriving the leftmost-uncalled-name `'x'` / `'x.y'` from the parse tree; (e) possessive-base null-check (`set x's y to true` → `'x' is null`). Each piece is straightforward in isolation but the cross-cutting compiler change touches every emit path and needs a coordinated design pass. Recommend a dedicated design doc + multi-commit worktree like buckets E36-E40.] runtime null-safety error reporting** — 18 tests in `runtimeErrors`. When accessing `.foo` on nil, emit a structured error with position info. One coordinated fix in the compiler emit paths for property access, function calls, set/put. Expected: +15-18.
 
-32. **[pending] MutationObserver mock + `on mutation` dispatch** — 15 tests in `on`. Add MO mock to runner. Compile `on mutation [of attribute/childList/attribute-specific]`. Expected: +10-15.
+32. **[blocked: environment + scope. (env) The `loops/hs` worktree at `/root/rose-ash-loops/hs/` ships without a built sx-tree MCP binary; even after running `dune build bin/mcp_tree.exe` on this iteration, the tools don't surface to the current session — they'd need to load at session start, and rebuilding doesn't re-register them. CLAUDE.md mandates sx-tree for any `.sx` edit and a hook blocks Edit/Read/Write on `.sx`/`.sxc`. (scope) The cluster needs coordinated changes across `lib/hyperscript/parser.sx` (recognise `on mutation of <filter>` with attribute/childList/characterData/`@name [or @name]*`), `lib/hyperscript/compiler.sx` (analogue of intersection's `:having`-style attach call passing filter info), `lib/hyperscript/runtime.sx` (`hs-on-mutation-attach!` constructing real `MutationObserver` with config matched to filter, dispatching `mutation` event with detail), `tests/hs-run-filtered.js` (replace the no-op MutationObserver mock with a working version + hook `El.setAttribute`/`appendChild`/etc. to fire registered observers), `tests/playwright/generate-sx-tests.py` (drop 7 mutation entries from `SKIP_TEST_NAMES`). The current parser drops bodies after `of` because `parse-on-feat` only consumes `having` clauses — confirmed via compile snapshot (`on mutation of attributes put "Mutated" into me` → `(hs-on me "mutation" (fn (event) nil))`). Recommended path: dedicated worktree with sx-tree loaded at session start, multi-commit (parser, compiler+attach, mock+runner, generator skip-list pruning).] MutationObserver mock + `on mutation` dispatch** — 15 tests in `on`. Add MO mock to runner. Compile `on mutation [of attribute/childList/attribute-specific]`. Expected: +10-15.
 
 33. **[pending] cookie API** — 5 tests in `expressions/cookies`. `document.cookie` mock in runner + `the cookies` + `set the xxx cookie` keywords. Expected: +5.
 
@@ -177,6 +177,12 @@ Many tests are `SKIP (untranslated)` because `tests/playwright/generate-sx-tests
 
 (Reverse chronological — newest at top.)
 
+### 2026-04-25 — cluster 32 MutationObserver mock + on mutation dispatch (blocked)
+- Two issues conspire: (1) `loops/hs` worktree has no pre-built sx-tree binary so MCP tools aren't loaded, and the block-sx-edit hook prevents raw `Edit`/`Read`/`Write` on `.sx` files. Built `hosts/ocaml/_build/default/bin/mcp_tree.exe` via `dune build` this iteration but tools don't surface mid-session. (2) Cluster scope is genuinely big: parser must learn `on mutation of <filter>` (currently drops body after `of` — verified via compile dump: `on mutation of attributes put "Mutated" into me` → `(hs-on me "mutation" (fn (event) nil))`), compiler needs `:of-filter` plumbing similar to intersection's `:having`, runtime needs `hs-on-mutation-attach!`, JS runner mock needs a real MutationObserver (currently no-op `class{observe(){}disconnect(){}}` at hs-run-filtered.js:348) plus `setAttribute`/`appendChild` instrumentation, and 7 entries removed from `SKIP_TEST_NAMES`. Recommended next step: dedicated worktree where sx-tree loads at session start, multi-commit shape (parser → compiler+attach → mock+runner → generator skip-list).
+
+### 2026-04-25 — cluster 31 runtime null-safety error reporting (blocked)
+- All 18 tests are `SKIP (untranslated)` — generator has no `error("HS")` helper at all. Inspected representative compile outputs: `add .foo to #doesntExist` → `(for-each ... (hs-query-all "#doesntExist"))` (silently no-ops on empty list, no error); `hide #doesntExist` → `(hs-hide! (hs-query-all "#doesntExist") "display")` (likewise); `put 'foo' into #doesntExist` → `(hs-set-inner-html! (hs-query-first "#doesntExist") "foo")` (passes nil through); `x()` → `(x)` (raises `Undefined symbol: x`, wrong format); `x.y.z()` → `(hs-method-call (host-get x "y") "z")`. Implementing this requires generator helper + 17 compiler emit-path patches + function-call/method-call/possessive-base null guards + new `hs-named-target`/`hs-named-target-list` runtime — too many surfaces for a single-iteration commit. Bucket D explicitly says "plan-first" — recommended path is a dedicated design doc and multi-commit worktree like E36-E40, not a loop iteration.
+
 ### 2026-04-24 — cluster 29 hyperscript:before:init / :after:init / :parse-error (blocked)
 - **2b486976** — `HS-plan: mark cluster 29 blocked`. sx-tree MCP file ops returning `Yojson__Safe.Util.Type_error("Expected string, got null")` on every file-based call (sx_read_subtree, sx_find_all, sx_replace_by_pattern, sx_summarise, sx_pretty_print, sx_write_file). Only in-memory ops work (sx_eval, sx_build, sx_env). Without sx-tree I can't edit integration.sx to add before:init/after:init dispatch on hs-activate!. Investigated the 6 tests: 2 bootstrap (before/after init) need dispatchEvent wrapping activate; 4 parser tests require stricter parser error-rejection — `add - to` currently parses silently to `(set! nil (hs-add-to! (- 0 nil) nil))`, `on click blargh end on mouseenter also_bad` parses silently to `(do (hs-on me "click" (fn (event) blargh)) (hs-on me "mouseenter" (fn (event) also_bad)))`. Fundamental parser refactor is out of single-cluster budget regardless of sx-tree availability.