# SX Review — Master Remediation Plan

Consolidates every finding from the three parallel review sessions (2026-07-03):
- `core.md` — language core / spec semantics (K01–K110)
- `hosts.md` — per-host implementations + FFI (J*, C*, JS*, P*, S*, PY)
- `conformance.md` — cross-host agreement + test adequacy (F1–F15, conf-S1–S5)
- `RULINGS.md` — 40 draft normative rulings (R1–R40) that gate the ambiguity fixes

**How to read this.** Findings are grouped into workstreams (W1–W15). Each workstream lists the
finding IDs it resolves, the approach, what ratified ruling(s) it needs, and status. The full
per-ID coverage ledger is at the bottom — every finding maps to a workstream + status, so nothing
is silently dropped. `[DONE]` = landed in commit dc7aa709 (quick-wins batch). `[GATE]` = blocked on
a Phase-0 decision. `[dup→Kxx]` = same defect found by another lane, fixed once.

**Prime directive from the review:** the verification infrastructure currently cannot tell you
whether a fix works (runner envs diverge from production, the WASM kernel never runs the corpus,
the JS gate is structurally red, one test passed *because of* the bug it tested). So Phase 1 Track A
(gate repair) comes before the bulk of the semantic work — otherwise fixes land blind.

---

## Phase 0 — Decisions (BLOCKING; maintainer; no code)

Nothing in Phases 2+ that changes observable semantics should merge before the relevant ruling is
ratified. These three decisions unblock ~40 findings.

### D1. Host lineup
Evidence: the JS-transpiled bundle is hollow (C0a: define-library files → 0 bytes) and its gate is
red (C0b: 2490/5086 fail); nothing serves it. The standalone Python host cannot load (C30/PY).
Production = OCaml native + WASM kernel (one OCaml library) + the load-bearing Python parser/bridge
in `shared/sx/`.
**Recommendation:** declare the kernel family the only evaluator targets; retire `hosts/javascript`
+ `hosts/python` standalone; shrink `shared/sx/parser.py` to a wire-subset with a parity suite.
→ Ratifying this **closes W13 entirely** (C0a/C0b/JS1–JS8 become "delete") and simplifies W6/W7.

### D2. Ratify RULINGS.md (R1–R40)
Each ruling is one normative answer + one mechanical fix. Ratify in a pass; four need a
pre-ratification usage sweep because they're high-churn: **R17** (arity: kill nil-fill), **R9**
(cond flat-only), **R31** (append! errors on derived lists), **R15a** (HO swap only when
unambiguous). See RULINGS.md for the per-ruling recommendation.

### D3. Define the merge gate
Recommendation: (a) native `run_tests` green with hs-upstream skip-listed; (b) same corpus on the
WASM kernel; (c) cross-kernel differential battery output-identical; (d) CEK-vs-forced-JIT
differential when JIT is on; (e) `sx_ref.ml` regen + diff. This is W14's definition of done.

---

## Phase 1 — Trustworthy verification + stop the bleeding

### W14. Test gate & conformance infrastructure  *(do FIRST — everything else verifies against it)*
Findings: C0b, C9, C21, C22, C23, C3, C4, C5, C6, C7, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11,
F12, K19 (harness/runtime primitive drift, partial from batch), K104 (harness log-before-mock).
Approach:
1. **Unify runner env with production env** — delete or productionize every runner-only binding:
   `values`/`call-with-values` (F7, K42), the JS runner's fake sha3/equal?/apply/env-set! shims
   (JS5, F7). Rule: if the spec needs it, it's a kernel primitive; if not, the test can't have it.
2. **WASM corpus runner** in CI (F2) — promote conformance's `run_wasm.js` prototype.
3. **MCP harness honesty** (K19): `mcp_tree.ml` drops its parallel primitive table and links real
   `sx_primitives` (batch aligned 8 entries as a stopgap); make `sx_harness_eval` fresh per call.
4. **Harness fixes**: log IO before invoking the mock (C22/K104); real perform/suspend mode (C21);
   adapter-dom render-output tests (C23).
5. **Epoch-loop protocol fuzz suite** (C3/C4/C5/C6/C7) + skip-list hs-upstream (F10) + empty suite
   label (C9).
6. **Test-debt ledger**: pin every confirmed finding with a failing test FIRST — the three lane
   files are a ready-made corpus of minimal reprs. **Batch gap to close: dc7aa709's fixes have no
   pinning tests** (except crit-2, now non-vacuous). Add tests for K09, K11, K18, K20, K39, K49,
   C1/C1b, S4 before further evaluator work.
Gate: none (this IS the gate). Status: OPEN — highest priority.

### W1. Condition system & delimited continuations  *(the kernel criticals)*
Findings: K01 (guard/handler re-raise hang — CRITICAL), K03 (shift-k nested cek-run double-exec —
CRITICAL), K10 (dynamic-wind re-entry + sibling winder corruption), K12 (`->` non-HO steps in
nested CEK), K36 (guard multi-expr clause body — inherits cond fix W5), K41 (host errors uncatchable
by guard), K57 (strict errors uncatchable), K106 (SUSPECTED: expand-macro/let-values/qq nested-eval
boundaries), S10 (VM inline-IO in HO callbacks can't suspend). K02 [DONE].
Root cause (shared by K03/K12/K106/S10): evaluation crosses a **nested `cek-run`/`trampoline
(eval-expr)` boundary** the outer continuation can't see. One architectural fix — invoke
continuations and evaluate these sub-expressions via CEK frames, not nested runs — resolves the
cluster. K01 is separate: run handlers with the OUTER handler set (unwound kont must EXCLUDE the
matched frame); make guard clause bodies evaluate after the escape (the no-match auto-reraise path
already does this — make it the only path). K10: common-ancestor before/after algorithm + winders
stored per-continuation, not one global length-keyed stack. K41/K57: raise host/primitive/strict
errors as structured catchable conditions (needs R7).
Gate: R6 (handler installation), R7 (what's catchable), R8 (raise-continuable). Status: OPEN —
**K01 is the single highest-value fix left** (DoS-able hang, server + browser).

### W3. HTTP-mode concurrency & serving safety  *(production robustness — lib/host is LIVE)*
Findings: S1 (multi-Domain render race — LIVE CRASH), S2 (per-request globals read by queued
workers), S3 (`expand-components?` bind/remove on shared env), S5 (cache key ignores cookies/query),
S11 (URL evaluated as SX — any env binding invokable), S12 (island hydration reuses no SSR DOM),
S13 (SSR/client purity, no dev-mode check), K30 (emit!/emitted cross-request — shared with W2). S4
[DONE], J1/J2/J3 mitigated by the batch JIT gate.
Approach: serialize or isolate rendering (S1: lock `_stream_mutex` or per-Domain env/cache);
per-request state carried with the request not process-global (S2/S3/K30); include query in cache
key + cookie policy (S5); whitelist URL-routable bindings to a `page:` prefix (S11); hydration cursor
+ dev-mode purity check (S12/S13). Pairs with W2 (per-flow scope stacks).
Gate: none for S1/S4/S5 (safety). Status: OPEN — S1 is a live crash.

---

## Phase 2 — Correctness families (each = ruling + fixes + conformance rows)

### W2. Environment & scope integrity
Findings: K04 (caller frame leaks into interpreted lambda + JIT disagrees), K05 (letrec injects into
foreign closures — global contamination), K06 (named-let leaks loop name), K07 (~60 unshadowable
names; = J8 VM-honors-CEK-doesn't), K30 (emit! cross-request — shared W3), K31 (provide leak on
raise/shift), K32 (provide! ambient global), K33 (set! unbound creates + JIT/interp split brain),
K40 (scope :value dead + dead frame type), K107 (SUSPECTED env_merge depth-100 flip).
Approach: fresh frames for letrec/named-let (K05/K06); drop the top-frame copy in env_merge
(K04/K107); reserved-words error for dispatch names, aligning VM+CEK (K07/J8); unwind-safe +
invocation-scoped dynamic state — one mechanism for provide/emit!/batch (K30/K31/K32); set!-unbound
per R1 + kill the JIT/interp global split (K33); remove dead scope :value/frame (K40).
Gate: R1 (set!), R2 (reserved names). Status: OPEN.

### W4. Higher-order forms & threading
Findings: K13 (2-arg reduce returns coll), K14 (reduce init-swap), K15 (data-first drops extra
args), K43 (O(n²) map/filter), K44 (HO names not first-class), K45 (cryptic uncatchable HO errors),
K46 (multi-coll rejects strings/vectors), K47 (thread lambda literal), K78 (component in HO → zeros),
K79 (dead `|>`), K80 (keyword getters in HO/->), K81 (zero-arg HO silent ()), J7 (VM data-first
deopt — shared W11).
Approach: implement R15 sub-rulings (swap only when one arg callable + error otherwise; reduce
arities; drop-extra→error; multi-coll seq-to-list parity; HO first-class; zero-arg→error); fix O(n²)
via reversed-cons accumulation; delete dead `|>`.
Gate: R13 (threading), R15 (HO forms). Status: OPEN.

### W5. Special forms & macros
Findings: K08 (cond dual-grammar — silent side-effect drops), K34 (qq depth), K35 (qq dict
traversal), K37 (&key misbind on fn/defmacro), K38 (splice non-list/malformed), K70 (case else any
position), K71 (case dialect + punning), K72 (letrec parallel + ref-before-init), K76 (defmacro
unhygienic vs "hygiene" test name), K77 (match guard clauses silently structural), K42 (values —
special forms now registered [DONE-partial]; `values` primitive still runner-only). K09/K11/K39 [DONE].
Approach: cond flat-only + explicit begin (R9); qq depth tracking + dict traversal + splice arity
errors (R12); &key one binding path for fn/defmacro/component (R5/K37); case final-else + evaluated-
datum doc + clause-syntax error (R10); letrec* + ref-before-init error (R4); match guards implemented
or error (R14); make `values` a real kernel primitive (finish K42).
Gate: R4, R5, R9, R10, R12, R14. Status: OPEN (K09/K11/K39 done).

### W6. Parser, serializer, canonical form & CIDs
Findings: K21 (canonical.sx runner-only helpers), K22 (serializer dict-key escaping + CID fixed-
point), K23 (four divergent ident/number classifiers), K24 (`1e`→nil), K25 (guest rationals throw),
K63 (`#;` before `)`), K64 (`=` no Char arm — shared W7), K65 (`#\a` mcp crash), K66 (multibyte char
literals), K67 (`\uXXXX` validation), K68 (unknown-escape divergence), K69 (`#name` reader macro
unimpl on OCaml), K100 (parse error locations), K101 (dict literal edges), K102 (`#|` raw string),
K103 (`:`/`::` keyword edges), K108 (SUSPECTED cross-host CID nondeterminism), C25 (Py↔OCaml escape
corruption), C26 (Py unicode symbols), C27 (Py dict order — shared W7/P9).
Approach: ONE normative ident/number classifier bound by every surface (R32); \u validation +
unknown-escape error + datum-comment fix (R27/R33); native `#name` reader macro registry;
canonical path = native CBOR/CID normative, spec/canonical.sx tested mirror or deleted, property-
test `parse(serialize(x))=x` and canonical fixed-point cross-kernel (R34/R35). CID determinism
(K108/K35-in-canonical) is sx-pub-critical.
Gate: R27, R32, R33, R34, R35. Status: OPEN.

### W7. Numbers, equality, strings, collection primitives
Findings: K17 (append! silent no-op), K52 (byte-based strings), K53 (spec/runtime primitive drift),
K54 (div-by-zero inconsistency), K55 (`/` doc), K56 (sort no comparator), K64 (char equality), K85
(binary `=`, exactness conflation), K86 (rounding/inexact->exact/sqrt), K87 (float/nil rendering),
K88 (nil/empty tolerance), K89 (keys reverse order — GATED, see R29 note: breaks render tests), K90
(keyword-name on evaluated kw), K91 (string->number), K92 (apply doesn't spread), P1 (lossy float
wire), P2 (sort mixed int/float), P3 (into needs bridge), P4 (int63 vs float64), P5 (= not deep on
JS dicts, missing eq?/eqv?), P6 (string units), P7 (JS coercion cluster — GATE D1), P8 (nil/list
strictness), P10 (NaN/Inf wire tokens), P11 (upcase/round), P12 (zip-pairs). K18/K20 [DONE].
Approach: append! errors on non-mutable lists + deprecate (R31); codepoint string semantics (R25);
implement eq?/eqv?, add `=` Char arm, n-ary comparisons (R19); exact-±2^53 + overflow-promote (R21);
shortest-round-trip float printing + inf/nan wire tokens (R23); div-by-zero catchable (R22); apply
spreads (R16); sort comparator + numeric compare (R30/P2); into native, contains?-on-dict [done],
merge-skip-nil, zip-pairs sliding window (R30/P8/P12); reconcile spec/runtime primitive lists (K53).
Gate: R16, R19, R21, R22, R23, R25, R29, R30, R31. Status: OPEN (K18/K20 done).

### W8. Render pipeline
Findings: K16 (infinite recursion no depth guard), K48 (attr-name injection — XSS class), K50 (aser
list kwargs), K51 (dom/html attr parity = C19), K82 (bool-attr truthiness footgun), K83 (dead
is-render-expr? / html: tags), K84 (script/style escaping), K87 (float render — shared W7), C19 (=K51),
C20 (CSRF cross-origin), S14 (deep nested-list flatten html vs aser), S9 (SPA boosted-nav fragility).
K49 [DONE]. Approach: depth limit + cycle guard (K16); attr-name validation (R36/K48); quote aser
list kwargs (R38/K50); align 4 adapters on bool-attr contract (R36/C19/K51); script/style raw-text
error-on-breakout (R37/K84); wire or delete is-render-expr? (R37/K83); depth-2 aser/html parity test
(S14). CSRF cross-origin (C20) + SPA manifest staleness (S9, overlaps W11 stale-bundle).
Gate: R36, R37, R38. Status: OPEN (K49 done).

### W9. Strict typing
Findings: K26 (HO callbacks bypass), K27 (apply bypasses), K58 (unknown type names match all), K59
(keyword type dead / components untypeable), K60 (component &key misalign), K93 (name-keyed, evaded),
K94 (set-prim-param-types! no validation), K95 (too-few args skip checks), K96 (`(:as type)` unenforced),
K97 (paper cuts). Approach (R20): move checks to continue-with-call/vm_call chokepoints (covers HO,
apply, components, => receivers); validate type names at declaration; real "component" branch, remove
dead "keyword" (R18); `(:as type)` as the declaration channel; merge+validate set-prim-param-types!;
strict errors catchable (R7, shared W1). Return types explicitly out of scope.
Gate: R7, R18, R20. Status: OPEN.

### W10. Signals & coroutines
Findings: K28 (dispose-computed no-op), K29 (batch wedge on exception), K61 (identity-not-equality
change detection), K62 (diamond glitch), K98 (batch unusable on server / coroutines inert), K99
(effect cleanup double-invoke), K109 (SUSPECTED coroutine non-yield wedge), K110 (SUSPECTED VM no
strict — shared W9/W11). Approach (R39): `=`-based change detection (needs W7 R19); unwind-safe batch
(shared W2 mechanism); two-phase/topological notify for glitch-freedom; fix dispose-computed + effect
cleanup; make batch/coroutines work outside run_tests (bind batch-begin!/end! + cek hooks in real
envs, or fold into kernel). Zero test coverage today — add suites.
Gate: R39. Status: OPEN.

### W12. Python bridge & boundary  *(load-bearing in production)*
Findings: C24 (boundary validation dead — [DONE-partial]: now warns; full revival needs tier-1
declarations recreated + zero-violation proof since SX_BOUNDARY_STRICT=1 is live), C28 (two SxExpr
classes double-quote), C29 (reader-macro auto-resolve broken), C30 (standalone Python host dead —
GATE D1: delete), C31 (14/33 test files broken + 5 live failures), S-bridge (coroutine-cancel
desync, no timeouts, dead _restart), S-bridge2 (numeric-result-as-epoch ambiguity), K42 (values —
shared W5). C25/C26/C27 live in W6 (parser). Approach: finish C24 (recreate declarations, prove
clean, re-enable); single SxExpr class (C28); fix OcamlSync.start→_ensure (C29); bridge timeouts +
working _restart (S-bridge); robust (ok N V) parse (S-bridge2); fix/retire broken tests (C31).
Gate: D1 (C30). Status: OPEN (C24 partial).

### W11. JIT correctness (serving-JIT re-enable preconditions)
Findings: J1 (`->` miscompile), J2 (fallback re-runs whole call — double side effects), J3 (macro
args eager), J4 (VM component kwargs misparse), J5 (specialized opcodes freeze redefs), J6 (compiler-
used prim redef poisons), J7 (data-first deopt — shared W4), J10 (stale Sx_compiler stub), J11 (JIT
debug paths diverge), K33 (set! split brain — shared W2), K19 (harness drift — shared W14), C10
(browser compiler one fix behind), C11 (stale module-manifest.sx), C12 (dead SOURCE_MAP paths), C14
(stale dist/ bundle). J12 = positive (perform/resume fixed). Currently MITIGATED (JIT gated OFF in
both epoch and — post-batch — HTTP mode). Approach: fix compile-thread-step (J1); fallback-before-
side-effects or compile-time reject of fallback-prone forms (J2); macro-aware compile (J3); keyword
tagging in constant pool (J4); redefinition invalidation (J5/J6); one browser-compiler sync pipeline
+ single bundle dir (C10/C11/C12/C14). Do NOT re-enable serving-JIT until the CEK-vs-JIT differential
(W14) is green.
Gate: W14 differential. Status: DEFERRED (mitigated; only unblock if serving-JIT is wanted).

### W16. Hyperscript engine — shipped-kernel conformance  *(production-facing; added post-ledger from conformance F-16–F-19)*
Findings: F-16 (shipped browser hs cannot call functions — `host-call-fn`/`host-call-fn-raising`
referenced by shipped `hs-runtime.sx`/`hs-integration.sx` but defined ONLY in run_tests.ml:3564;
906 "Undefined symbol: host-call-fn" on the behavioral corpus against the shipped stack), F-17
(shipped `shared/static/wasm/sx/hs-runtime.sx` dropped the `(jit-exclude! "hs-*")` guard that
`lib/hyperscript/runtime.sx` has — hs is JIT-eligible in the browser where the parser-combinator
recursion miscompiles; the tested config ≠ the shipped config), F-18 (the native runner's MOCK DOM
is the outlier: ≥118 of the 272 "permanent red" hs failures PASS on the shipped WASM kernel +
happy-dom — the red band mostly indicts the test env, not the engine; 9 genuine WASM-only failures
remain to bisect: behavior-scoping ×4, as-fragment `__host_handle` leak ×3, init/where ×2), F-19
(hs corpus drift — generated tests still expect the pre-`beingTold`/`poss` parser AST, ~50 shared
failures on every kernel; PLUS `assert=` is `(actual expected msg)` but the generated corpus calls
`(assert= expected actual)` so every failure prints Expected/got SWAPPED — actively misled diagnosis).
Approach:
1. **F-16 (quick, production):** register `host-call-fn`/`host-call-fn-raising` in the shipped
   platform (`sx-platform.js`) — or rename the runtime's calls to the existing `host-call`. One
   binding unbreaks ~900 hs behaviors in browsers. Same class as F-7/K42 (runner-only binding).
2. **F-17 (quick, safety):** restore `(jit-exclude! "hs-*")` in the shipped `hs-runtime.sx`, and —
   better — make the lib→`wasm/sx` sync SCRIPTED (this is the same manual-copy drift as C10/C11/C12/
   C14 in W11/W15; one sync script fixes the whole family so the guard can't silently drop again).
3. **F-19 (quick + medium):** fix `assert=` arg order (or the generator's call order) so failure
   messages stop lying — cosmetic but it misleads every future session; then regenerate the upstream
   hs corpus against the current parser AST (~50 tests fail purely from drift). Belongs with W14.
4. **F-18 (medium):** re-baseline the native red band — improve the mock DOM or skip-list the
   browser-only hs suites so FAIL means something (feeds W14's F-10 skip-list + gate). Then bisect
   the 9 WASM-only failures — the only candidates for real shipped-kernel bugs left in hs.
CAVEAT (accuracy): hs engine modules are shipped but may be absent from the production boot list
(`loadWebStackFallback`, sx-platform.js:670 — hs load path "unclear/on-demand only" per F-19), so
F-16/F-17 may be LATENT rather than live on blog.rose-ash.com today — confirm whether any served
page loads the hs engine before treating them as a live outage.
Ownership: F-16/F-17 are hosts-lane fixes; F-19 assert= + F-18 re-baseline are conformance/W14;
the WASM corpus runner they need is W14's. Note: js_of_ocaml is ~1-2 orders slower on this corpus
(≈24s/test) — gate on a curated subset, not the full 6k.
Gate: pairs with W14 (WASM runner) and W11/W15 (sync-script). Status: OPEN — F-16/F-17 are one-liners.

### W13. JS host  *(GATE D1 — likely "delete")*
Findings: C0a (hollow bundle), C0b (2490 fail gate), JS1 (define-record-type/makeRtd), JS2 (host-
callback type tag), JS3 (arithmetic drops args), JS4 (`.` symbol), JS5 (runner shims), JS6 (str nil),
JS7 (no qq emission), JS8 (stale metadata). If D1 retires the JS bundle: delete `hosts/javascript`,
remove from `sx-build-all.sh`/CI, keep only the WASM kernel path. If kept: this is a ~2500-test
revival project. Gate: D1. Status: BLOCKED on D1.

---

## Phase 3 — Hygiene & docs

### W15. Hygiene & documentation
Findings: C8 (triplicated hosts/ocaml/hosts/ tree), C13 (test_platform.js stale path), C15 (tracked
stale wasm blob), C16 (orphaned hosts/native), C17 (sx-platform-2.js + 23 dead .sxbc.json), C18
(spa-debug.js + root clutter), C2 (r7rs string->number radix shadow), F14 (doc drift — batch fixed
canonical-ref + island rules; suite counts + case-syntax + primitives-header still stale), F15
(sha3 stub / test.sx dead filename), F13 (regen reproducibility — [DONE] as batch side effect).
K105/K73 [DONE]. Approach: delete dead trees/blobs/files; fix r7rs shadow (C2); finish CLAUDE.md
(suite counts, case syntax); regen-diff CI check (F13 → make it a gate in W14).
Gate: D1 (some deletions). Status: OPEN (K105/K73/F13 done).

---

## Suggested execution shape (maps to the loop workflow)

Four loops, mostly independent after Phase 0:
1. **loops/sx-gate** (W14 + W15 hygiene) — the enabler. Start FIRST. Pins tests for the dc7aa709
   batch, builds the WASM corpus runner + differential battery, unifies runner env, cleans dead code.
2. **loops/sx-kernel** (W1 + W2 + W5) — condition system, scope integrity, special forms. Single
   owner (touches evaluator.sx + regen). TDD off W14's pinned tests. K01 first.
3. **loops/sx-runtime** (W3 HTTP safety + W12 Python bridge) — production robustness; can run
   parallel to kernel since it's mostly host OCaml + Python, not spec.
4. **loops/sx-families** (W4, W6, W7, W8, W9, W10) — one family at a time, each gated by its rulings
   + the new batteries. W6/W7 pay the sx-pub CID debt.
W11 (JIT) and W13 (JS) are decision-gated and sit out until D1 + a green differential exist.

**Sequencing rule:** no semantic fix merges before (a) its pinning test exists, (b) the relevant
ruling is ratified, (c) native + WASM both run it. D1/D2/D3 are the only hard blockers.

---

## Coverage ledger — every finding accounted for

Status key: DONE (dc7aa709) · OPEN · PARTIAL · DEFERRED · GATE(Dn) · dup→(primary). Workstream in [].

### Core (K01–K110)
- K01 [W1] OPEN — guard/handler re-raise hang (CRITICAL, highest value)
- K02 [W1] DONE — signal-return frame key
- K03 [W1] OPEN — shift-k nested cek-run (CRITICAL)
- K04 [W2] OPEN · K05 [W2] OPEN · K06 [W2] OPEN · K07 [W2] OPEN (=J8)
- K08 [W5] OPEN — cond dual grammar
- K09 [W5] DONE · K10 [W1] OPEN · K11 [W5] DONE
- K12 [W1] OPEN (=W4 threading) · K13 [W4] OPEN · K14 [W4] OPEN · K15 [W4] OPEN
- K16 [W8] OPEN · K17 [W7] OPEN — append! · K18 [W7] DONE · K19 [W14] PARTIAL · K20 [W7] DONE
- K21 [W6] OPEN · K22 [W6] OPEN · K23 [W6] OPEN · K24 [W6] OPEN · K25 [W6] OPEN
- K26 [W9] OPEN · K27 [W9] OPEN · K28 [W10] OPEN · K29 [W10] OPEN
- K30 [W2/W3] OPEN — emit! cross-request (=S2 dir)
- K31 [W2] OPEN · K32 [W2] OPEN · K33 [W2/W11] OPEN — set! split brain
- K34 [W5] OPEN · K35 [W5/W6] OPEN · K36 [W1/W5] OPEN · K37 [W5] OPEN · K38 [W5] OPEN
- K39 [W5] DONE · K40 [W2] OPEN · K41 [W1] OPEN · K42 [W5/W12] PARTIAL (forms registered; `values` prim runner-only)
- K43 [W4] OPEN · K44 [W4] OPEN · K45 [W4] OPEN · K46 [W4] OPEN · K47 [W4] OPEN
- K48 [W8] OPEN · K49 [W8] DONE · K50 [W8] OPEN · K51 [W8] OPEN (=C19)
- K52 [W7] OPEN · K53 [W7] OPEN · K54 [W7] OPEN · K55 [W7] OPEN · K56 [W7] OPEN
- K57 [W1/W9] OPEN · K58 [W9] OPEN · K59 [W9] OPEN · K60 [W9] OPEN
- K61 [W10] OPEN · K62 [W10] OPEN · K63 [W6] OPEN · K64 [W6/W7] OPEN — char `=`
- K65 [W6] OPEN · K66 [W6] OPEN · K67 [W6] OPEN · K68 [W6] OPEN · K69 [W6] OPEN
- K70 [W5] OPEN · K71 [W5] OPEN · K72 [W5] OPEN · K73 [W15] DONE
- K74 [W2] OPEN (component &key false→nil; R5) · K75 [W2] OPEN (trailing kw; R5)
- K76 [W5] OPEN · K77 [W5] OPEN · K78 [W4] OPEN · K79 [W4] OPEN · K80 [W4] OPEN · K81 [W4] OPEN
- K82 [W8] OPEN · K83 [W8] OPEN · K84 [W8] OPEN · K85 [W7] OPEN · K86 [W7] OPEN · K87 [W7/W8] OPEN
- K88 [W7] OPEN · K89 [W7] OPEN — keys order, GATED R29 (breaks render tests, see RULINGS note)
- K90 [W7] OPEN · K91 [W7] OPEN · K92 [W7] OPEN — apply spread
- K93 [W9] OPEN · K94 [W9] OPEN · K95 [W9] OPEN · K96 [W9] OPEN · K97 [W9] OPEN
- K98 [W10] OPEN · K99 [W10] OPEN · K100 [W6] OPEN · K101 [W6] OPEN · K102 [W6] OPEN · K103 [W6] OPEN
- K104 [W14] OPEN · K105 [W15] DONE
- K106 [W1] OPEN (SUSPECTED nested-eval boundaries) · K107 [W2] OPEN (SUSPECTED)
- K108 [W6] OPEN (SUSPECTED CID nondeterminism) · K109 [W10] OPEN (SUSPECTED) · K110 [W9/W11] OPEN (SUSPECTED)

### Hosts — JIT (J1–J12)
- J1 [W11] DEFERRED (mitigated: JIT gated off) · J2 [W11] DEFERRED · J3 [W11] DEFERRED
- J4 [W11] DEFERRED · J5 [W11] DEFERRED · J6 [W11] DEFERRED · J7 [W11/W4] DEFERRED
- J8 [W2] OPEN dup→K07 · J9 [W11/W14] DEFERRED · J10 [W11] DEFERRED · J11 [W11] DEFERRED
- J12 POSITIVE (no action — perform/resume verified fixed)

### Hosts — kernel/protocol/build (C*)
- C0a [W13] GATE(D1) · C0b [W13/W14] GATE(D1) · C1 [W3] DONE · C1b [W3] DONE
- C2 [W15] OPEN · C3 [W14] OPEN · C4 [W14] OPEN · C5 [W14] OPEN · C6 [W14] OPEN · C7 [W14] OPEN
- C8 [W15] OPEN · C9 [W14] OPEN · C10 [W11] DEFERRED · C11 [W11] DEFERRED · C12 [W11/W15] OPEN
- C13 [W15] OPEN · C14 [W11/W15] OPEN · C15 [W15] OPEN · C16 [W15] OPEN · C17 [W15] OPEN · C18 [W15] OPEN
- C19 [W8] OPEN dup→K51 · C20 [W8] OPEN · C21 [W14] OPEN · C22 [W14] OPEN · C23 [W14] OPEN
- C24 [W12] PARTIAL · C25 [W6] OPEN · C26 [W6] OPEN · C27 [W6/W7] OPEN dup→P9
- C28 [W12] OPEN · C29 [W12] OPEN · C30 [W12] GATE(D1) · C31 [W12] OPEN

### Hosts — JS host (JS1–JS8)
- JS1–JS8 [W13] all GATE(D1) — delete if JS retired, else ~2500-test revival

### Hosts — cross-host parity (P1–P12, PY)
- P1 [W7] OPEN · P2 [W7] OPEN · P3 [W7] OPEN · P4 [W7] OPEN · P5 [W7] OPEN · P6 [W7] OPEN
- P7 [W7] GATE(D1) · P8 [W7] OPEN · P9 [W6/W7] OPEN (=C27) · P10 [W7] OPEN · P11 [W7] OPEN · P12 [W7] OPEN
- PY [W13] GATE(D1) dup→C30

### Hosts — HTTP/suspected (S1–S14, S-bridge*)
- S1 [W3] OPEN (LIVE CRASH) · S2 [W3/W2] OPEN · S3 [W3] OPEN · S4 [W3] DONE · S5 [W3] OPEN
- S6 [W14] OPEN · S7 [W14/W1] OPEN (unify eval/IO paths) · S8 [W13/W8] OPEN (browser env prims)
- S9 [W8/W11] OPEN · S10 [W1] OPEN · S11 [W3] OPEN · S12 [W3] OPEN · S13 [W3] OPEN · S14 [W8] OPEN
- S-bridge [W12] OPEN · S-bridge2 [W12] OPEN

### Conformance (F1–F15, conf-S1–S5)
- F1 [W7] OPEN dup→K18/P4 (WASM int wrap) · F2 [W14] OPEN · F3 [W7/W6] OPEN (apply + dict order) · F4 [W13/W14] GATE(D1)
- F5 [W14] OPEN (host-neutral corpus) · F6 [W14] OPEN (directories one-host-gated) · F7 [W14] OPEN dup→K42
- F8 [W14] OPEN (differential battery) · F9 [W7/W14] OPEN (primitive parity) dup→K53 · F10 [W14] OPEN (skip hs, =F18)
- F11 [W12] OPEN dup→C24 · F12 [W6] OPEN dup→C25/26/27 · F13 [W15] DONE · F14 [W15] PARTIAL · F15 [W15] OPEN
- F16 [W16] OPEN (shipped hs host-call-fn binding gap — one-liner, ~900 tests) dup-class→F7/K42
- F17 [W16] OPEN (shipped hs missing jit-exclude! — sync drift) dup-class→C10/C11/C12/C14
- F18 [W16/W14] OPEN (mock-DOM red band re-baseline + 9 WASM-only bisect) dup→F10
- F19 [W16/W14] OPEN (hs corpus drift + inverted assert= labels)
- conf-S1 [W14] OPEN (native-vs-WASM web-stack diff) · conf-S2 RESOLVED→promoted to F16/F17/F18
- conf-S3 [W11] OPEN (import path browser vs test) · conf-S4 [W14] OPEN (float golden precision) · conf-S5 [W11] OPEN (JS build-flag ADT divergence)

### Tally
~217 finding-instances (incl. late conformance F16–F19). DONE: 13 (dc7aa709). PARTIAL: 4 (K19, K42,
C24, F14). DEFERRED: 12 (W11 JIT). GATE(D1): ~16 (JS host + Python standalone). RESOLVED-superseded:
1 (conf-S2). OPEN: the rest, distributed across W1–W12/W14/W15/W16.