rose-ash/plans/sx-review/core.md

SX Language Core Review — spec/ semantics

Reviewer axis: LANGUAGE CORE (spec/evaluator.sx CEK machine, parser.sx, primitives.sx, render.sx, special-forms.sx, eval-rules.sx, stdlib.sx, signals.sx, coroutines.sx, canonical.sx). Note: brief mentions spec/types.sx — it no longer exists; strict-typing machinery lives in evaluator.sx. Status: COMPLETE — all 8 dimension sweeps merged (CEK core, env/scope, HO forms, special forms/macros, parser/serializer/canonical, primitives/stdlib, render modes, strict typing + signals/coroutines/harness).

TOTALS: 104 CONFIRMED findings (3 critical, 26 high, 40 medium, 2 low-medium, 33 low)

• 5 SUSPECTED. Every CONFIRMED item has a runtime repro (fresh sx_server.exe unless noted). All 3 criticals additionally re-verified on the shipped WASM browser kernel (see CROSS-LANE CHECK).

THEMES a ranker should know:

1. Nested cek-run instead of CEK frames is one root cause behind ≥4 findings (shift-k double-execution, threading guard/IO break, + suspected macro/let-values/qq boundaries).
2. Handler still installed while handler runs explains the guard/handler-bind hang family.
3. Name-before-env dispatch explains the ~60 unshadowable names + HO-not-first-class family.
4. Global mutable stacks popped only on normal exit explains provide/winder/batch leak family (scope stack, winders, batch-depth — none unwind-safe).
5. Test-runner-only bindings make whole suites (values, canonical floats, batch, coroutines) green for features the shipped runtime doesn't have; one test passes vacuously because of the very bug it tests (signal-return).
6. Per-host re-bound platform primitives (parse-number, char-code, escape-string, split, get…) are the drift engine behind parser AST divergence + harness/runtime divergence.

CROSS-LANE CHECK (vs /tmp/sx-review/hosts.md and conformance.md, done 2026-07-03):

• All 3 criticals re-verified on the shipped WASM browser kernel (js_of_ocaml build browsers actually load; probe harness from the conformance lane): guard re-raise HANGS (node killed at 25s), signal-condition → 42 (same kont drop), shift repro → identical double-execution trace (99 ("r=escaped" "after-k" "r=99")). Kernel-family bugs: native server AND production browser. Conformance F-2 (corpus never runs on WASM) explains why nothing caught them there.
• Not masked by the JIT: hosts J2/J9 confirm guard-installing lambdas are interpret-only and any raise/call-cc in JIT'd code falls back to the CEK — my criticals are the live path.
• Three independent double-side-effect mechanisms now on record: my shift-k nested cek-run (critical #3), hosts J1 (-> miscompiled under serving-JIT, steps re-run), hosts J2 (JIT-fallback re-runs whole call). Same user-visible symptom, three distinct fixes.
• One of my findings corrected (apply — see the finding below); expt int63 wrap corroborated by conformance F-1 (WASM is worse: (expt 2 62) → 0); unshadowable-HO finding extended by hosts J8 (the VM DOES honor local bindings — CEK/VM divergence within one host); render dom/html attr parity independently confirmed as hosts C19; values/eq?/eqv? runner-only bindings corroborated by conformance F-7/F-9.
• No contradiction on canonical/CIDs: conformance's working cid-from-sx is a native kernel primitive (verified: works with spec/canonical.sx not loaded). My canonical.sx finding concerns the spec guest implementation — production CIDs bypass it. Two parallel CID implementations, only the native one exercised; spec-vs-native canonical-form agreement is untested (conformance F-3 checked native-vs-WASM only).

Verification recipe: sx_harness_eval (MCP) cross-checked against fresh real-runtime processes printf '(epoch 1)\n(eval "...")\n' | timeout 30 hosts/ocaml/_build/default/bin/sx_server.exe. TOOLING CAVEATS found during review (also listed as handoffs): (1) the MCP harness primitive table diverges from the real runtime; (2) sx_harness_eval is NOT a fresh sandbox — state persists and cross-contaminates calls; (3) sx_read_subtree ignores path, sx_read_tree ignores max_lines. All critical/divergent probes were re-verified on fresh sx_server.exe processes.

---

CONFIRMED findings (most severe first)

[critical] [CONFIRMED×2] Any raise/error inside a guard clause body or handler-bind handler loops forever — handler runs with its own handler frame still installed

• Location: spec/evaluator.sx, raise-eval case of step-continue (~4547-4573) + kont-unwind-to-handler (236-259); inherited by step-sf-guard (~1693)
• What: kont-unwind-to-handler returns {:handler match :kont kont} where kont still contains the matched handler frame; the handler is invoked with that kont. A raise inside the handler re-matches the same handler → infinite loop. Not just explicit re-raise: ANY error while a handler/clause body runs ((error ...), a raised different value) hangs instead of propagating. CL/R7RS: handlers run with the enclosing (outer) handler set. guard desugars clause bodies to run INSIDE the handler-bind extent ((__guard-k (cond ...)) — clauses evaluate before the escape), so the memory'd gotcha "(raise e) in a guard clause hangs" is exactly this. Contrast: the no-matching-clause auto-reraise is R7RS-correct ((guard (outer (true outer)) (guard (e ((= e 1) "one")) (raise 2))) → outer catches 2) because the sentinel re-raise happens after the call/cc return, OUTSIDE handler-bind — which is exactly how clause bodies should also run.
• Repro (bounded CLI, all timeout exit 124): (guard (e (true (raise e))) (raise 42)); (handler-bind (((fn (c) true) (fn (c) (raise c)))) (raise 1)); same with (raise "different") and (error "again").
• Cross-check: reproduced on the shipped WASM browser kernel (hangs, killed at 25s) — affects production browsers, not just the server. Hosts lane J2/J9: guard-installing lambdas are interpret-only, so the JIT never masks this.
• Coverage: test-r7rs.sx guard suite + test-conditions.sx cover happy paths only; no test raises from within a handler. test-cek-try-seq.sx "error in error handler propagates" passes because cek-try is a different mechanism.

[critical] [CONFIRMED] signal-return frame key mismatch drops the caller's continuation — continuable signal/raise-continuable returns the handler value as the WHOLE program's result; the covering test passes vacuously

• Location: spec/evaluator.sx, make-signal-return-frame (line 182, stores saved kont under :f) vs signal-return case of step-continue (~4509-4512, reads (get frame "saved-kont")); mirrored in hosts/ocaml/lib/sx_runtime.ml:210-231 (CekFrame get has no "saved-kont" mapping → Nil)
• What: the resume kont is always nil, so after the handler returns, its value becomes the terminal value of the entire CEK run — every frame outside the signal site (arithmetic, enclosing lists, asserts) is silently discarded.
• Repro: (list "outer" (handler-bind (((fn (c) true) (fn (c) 42))) (+ 1 (signal-condition 5))) "end") → 42; expected ("outer" 43 "end"). Same with raise-continuable → 42. The shipped test expr (handler-bind (((fn (c) true) (fn (c) (* c 10)))) (+ 1 (signal-condition 5))) → 50 on both CLI and harness, yet the test asserting 51 PASSES under run_tests.exe — the dropped continuation includes the assert-equal frame itself, so the assertion never executes (vacuous pass).
• Cross-check: reproduced byte-identically (42) on the shipped WASM browser kernel.
• Coverage: test-conditions.sx "signal returns handler value to call site" — passing vacuously; the bug defeats its own test.

[critical] [CONFIRMED] Invoking a shift-captured continuation uses a nested cek-run — escaping across that boundary re-executes the outer program tail (double execution, duplicated side effects); raising inside a resumed k can't reach outer handlers

• Location: spec/evaluator.sx, continue-with-call, continuation? branch (~4708-4716): (let ((result (cek-run (make-cek-value arg env captured)))) (make-cek-value result env kont))
• What: the nested run's kont ends at the captured frames; (a) a call/cc escape invoked inside the resumed extent rewrites the kont inside the nested run, which then runs the rest of the program to completion, returns that as the value of (k arg), and the outer run executes the program tail again; (b) handler frames in the outer kont are invisible to kont-unwind-to-handler inside the nested run.
• Repro (a): (do (define log (list)) (define r (call/cc (fn (esc) (reset (do (shift k (do (k 1) (set! log (append log (list "after-k"))) 99)) (esc "escaped") "unreached"))))) (set! log (append log (list (str "r=" r)))) (list r log)) → actual (99 ("r=escaped" "after-k" "r=99")) (tail executed twice); expected ("escaped" ("r=escaped")).
• Repro (b): (guard (e (true (list "caught" e))) (reset (do (shift k (k 1)) (raise "boom")))) → Unhandled exception: "boom"; expected ("caught" "boom").
• Cross-check: repro (a) reproduced with the identical wrong trace (99 ("r=escaped" "after-k" "r=99")) on the shipped WASM browser kernel. Note: hosts J1/J2 are two FURTHER independent double-side-effect mechanisms (JIT -> miscompile; JIT-fallback re-run) — three distinct fixes needed for "side effects ran twice" reports.
• Coverage: not covered (test-cek-advanced.sx shift/reset tests never cross the boundary with call/cc or raise).

[high] [CONFIRMED] Caller's immediate frame leaks into interpreted lambda calls — partial dynamic scoping, and the JIT disagrees

• Location: spec/evaluator.sx, continue-with-call ((local (env-merge (lambda-closure f) env)) ~4739; same in call-lambda ~896) + env_merge in hosts/ocaml/lib/sx_types.ml:390
• What: when the call-site env is NOT a descendant of the lambda's closure env, env_merge copies the caller's top frame bindings into the lambda's local env. Free variables in the body resolve to the caller's locals — a lexical-scoping violation. Depth-1 only (a binding one frame deeper does not leak). The JIT path disagrees: a VM-compiled body raises "VM undefined" for the same program — behavior flips depending on whether the body got JIT-compiled.
• Repro: (do (define mg (fn () (fn () (guard (e (true e)) leakedz)))) (define gz (mg)) (let ((leakedz 66)) (gz))) → 66 (guard forces interpretation); expected undefined-symbol error. Without guard → "VM undefined: leaked" (JIT). Depth-2 variant → Undefined symbol.
• Coverage: not covered — test-scope.sx "environment-isolation" tests only the lambda→caller direction.

[high] [CONFIRMED] letrec injects its bindings into foreign lambdas' closure envs — permanent global contamination

• Location: spec/evaluator.sx, sf-letrec (~1370: (env-bind! (lambda-closure val) n (env-get local n)))
• What: after evaluating inits, letrec binds ALL letrec names into the closure env of every lambda value. make_lambda stores the defining env directly, so a letrec whose value is a pre-existing (e.g. top-level) lambda writes the letrec names into that lambda's closure — the global env — permanently.
• Repro: (do (define idf (fn (x) x)) (letrec ((zzq idf) (zzn 55)) nil) zzn) → 55; expected "Undefined symbol: zzn". (This leak also polluted the shared MCP harness image across calls during verification.)
• Coverage: not covered — test-scope.sx "letrec-edge" only binds lambdas created inside the letrec (extra binds are no-ops there).

[high] [CONFIRMED] Named let leaks its loop name into the enclosing env frame and clobbers same-name bindings

• Location: spec/evaluator.sx, sf-named-let (~1035: (env-bind! (lambda-closure loop-fn) loop-name loop-fn))
• What: lambda-closure loop-fn IS the enclosing env (no fresh frame), so the loop name is bound into the surrounding scope: visible after the form, and it clobbers (not shadows) an existing binding of the same name.
• Repro: (do (let lp ((i 0)) i) (lambda? lp)) → true (expected unbound). (let ((lp2 5)) (let lp2 ((i 0)) i) lp2) → loop lambda in interpreter, nil under JIT — never the expected 5.
• Coverage: not covered — test-named-let-sx locks set!-accumulator patterns only.

[high] [CONFIRMED×3] ~60 special-form/HO names are silently unshadowable — define/let/defmacro accepted, call-position dispatch ignores them

• Location: spec/evaluator.sx step-eval-list (~1801-1958) — head-name match runs before any env lookup; only the _ fallthrough (custom special forms, ~1959) checks (not (env-has? env name))
• What: list-head dispatch checks built-in special/HO forms BEFORE env lookup. (define bind (fn (a b) "mine")) succeeds (type-of says lambda) but (bind 1 2) → 1 (special form runs). (define map ...), (let ((map ...)) ...), (defmacro if ...), (defmacro map ...) — all silently ignored in call position while honored in value position. Regular primitives ARE properly shadowable ((define get ...), (define inc ...) → user def wins) — only this name set is hijacked, and custom special forms DO respect user bindings, making built-ins doubly inconsistent.
• Unshadowable names (extracted from dispatch): if when cond case and or let let* lambda fn define defcomp defisland defmacro defio define-foreign io begin do guard quote quasiquote -> ->> |> as-> set! letrec reset shift deref scope provide peek provide! context bind emit! emitted handler-bind restart-case signal-condition invoke-restart match let-match dynamic-wind map map-indexed filter reduce some every? for-each raise raise-continuable call/cc call-with-current-continuation perform define-library import define-record-type define-protocol implement parameterize syntax-rules define-syntax. Collision-prone short ones: map filter reduce some bind match peek context deref guard io do case.
• Repro: (do (define map (fn (f xs) "mine")) (map (fn (x) (* x 10)) (list 1 2))) → (10 20); (let ((map (fn (a b) 42))) (map 1 2)) → Error: rest: 1 list arg; (let ((-> (fn (a b) 99))) (-> 1 2)) → Not callable: nil; (do (defmacro if (a b c) 99) (if true 1 2)) → 1.
• Coverage: not covered anywhere. Memory gotcha "bind/conj/disj shadowed" confirmed for bind; conj/disj aren't core primitives (guest-worktree lore).

[high] [CONFIRMED] cond grammar is ambiguous — an all-clauses-len-2 heuristic silently switches modes; multi-expr clause bodies are dropped or crash; flat-intent code can silently return the wrong value

• Location: spec/evaluator.sx, step-sf-cond (a scheme? detection binding selects clause-mode vs flat-pair mode)
• What: cond supports flat pairs (cond t1 r1 ... :else d) (the only documented syntax — eval-rules.sx:64) plus an undocumented Scheme clause mode auto-detected iff every arg is a 2-element list (or (test => proc)). All verified consequences:
  • Single clause with multi-expr body: (cond ((= 1 1) (set! a 1) (set! b 2))) → nil, neither set! runs — silent total drop of side effects.
  • Multi-expr body + other clauses: (cond ((= 1 1) "a" "b") (:else "no")) → Not callable: true — one len≠2 clause anywhere flips the WHOLE cond to flat mode.
  • Silent misinterpretation: (do (define x false) (define y true) (cond (not x) (list 1) (not y) (list 2))) → false (clause-mode reads (not x) as test=not, result=x); flat reading gives (1). Wrong answer, no error.
  • Test-only clause (cond (5)) → nil (Scheme: 5); poisons detection: (cond (true "t") (5)) → Not callable: nil.
  • Trailing odd flat arg silently ignored, never evaluated: (cond (set! a 99)) leaves a unchanged.
• Coverage: flat tested (test-eval.sx:306-312); clause mode only via cond-arrow suite (test-r7rs.sx:135-145). Ambiguity/multi-expr/test-only uncovered; clause mode entirely undocumented.

[high] [CONFIRMED] (unquote-splicing x) longhand silently no-splices; only splice-unquote is recognized

• Location: spec/evaluator.sx, qq-expand (checks (symbol-name (first item)) = "splice-unquote" only)
• What: ,@ sugar parses to splice-unquote and works; the R7RS-standard longhand unquote-splicing fails dispatch, is recursed into as an ordinary list, and is emitted literally — silent zero-splice. (unquote x) longhand works.
• Repro: (quasiquote (a (unquote-splicing xs))) → (a (unquote-splicing xs)); `(a ,@xs) and (splice-unquote xs) → (a 1 2).
• Coverage: not covered — worse, test-macros.sx tests are NAMED "unquote-splicing …" (lines 43-63) while all using ,@ sugar, actively reinforcing the trap. (Confirms memory gotcha; root cause now located.)

[high] [CONFIRMED] dynamic-wind before-thunks never re-run on continuation re-entry; global length-based winder stack corrupts across sibling wind contexts (afters skipped/duplicated)

• Location: spec/evaluator.sx, continue-with-call callcc-continuation branch (~4702-4707: (do (wind-escape-to w-len) ...)), wind-escape-to (261-271)
• What: invoking a captured continuation only pops after-thunks down to the captured length of the global *winders* stack. No common-ancestor computation, no before-thunks on entry (R7RS requires before/after along the path between extents). Lengths from unrelated wind contexts collide: resuming a k captured inside wind A while inside wind B (equal depth) unwinds nothing, then A's wind-after frame pops B's winder.
• Repro 1 (re-entry): capture k inside wind, escape, re-invoke → (2 ("b" "a" "a")); expected (2 ("b" "a" "b" "a")) (before not re-run; after ran twice).
• Repro 2 (sibling): capture in wind A, re-invoke from inside wind B → (2 ("A-in" "A-out" "B-in" "A-out")); expected B-out + A-in before final A-out. B's after silently never runs (resource-leak class), A's runs twice.
• Coverage: test-dynamic-wind.sx (8 tests): normal return, raise, one-shot escape only.

[high] [CONFIRMED×2] guard re-raise sentinel is forgeable — a body/clause legitimately returning (list '__guard-reraise__ X) is misinterpreted as a re-raise of X

• Location: spec/evaluator.sx, step-sf-guard (~1693-1767): sentinel (make-symbol "__guard-reraise__"), detected by structural = on any 2-element list escaping the guard
• Repro: (guard (e (true (list (quote __guard-reraise__) 42))) (raise 1)) → Unhandled exception: 42; (guard (e (true "handled")) (list (quote __guard-reraise__) 7)) → Unhandled exception: 7 — the guard body's return value converted into a raise. Should be an unforgeable/gensym'd token. (Severity judged high by one reviewer, low by another — data-dependent conversion of values into raises; rank accordingly.)
• Coverage: not covered.

[high] [CONFIRMED] ->/->> non-HO steps run in a nested CEK with empty kont — guard and IO suspension broken through threading

• Location: spec/evaluator.sx, thread-insert-arg/thread-insert-arg-last (72–89) call eval-expr (4828: cek-run with kont (list)); "thread" frame handler (~4074) stays CEK-native only for ho-form-name? heads
• What: a threaded non-HO step evaluates in a fresh machine that can't see outer guard frames and can't suspend. (a) raise inside a threaded call escapes an enclosing guard; (b) IO/effects inside a threaded step hard-crash instead of suspending. The HO path is CEK-native and correct — same expression works or fails depending on the step's head symbol. Same root pattern as the shift-k critical.
• Repro: (define boom (fn (x) (raise "T"))) (guard (e (else "caught")) (-> 1 boom)) → Unhandled exception: "T" (map version → caught). (-> {:op "noop"} (perform)) → Error: Sx_vm.VmSuspended(_,_) (map version suspends/resumes fine).
• Coverage: not covered

[high] [CONFIRMED] 2-arg (reduce f coll) silently returns the collection unchanged

• Location: spec/evaluator.sx, ho-setup-dispatch "reduce" branch (~3671) + ho-swap-args (~3557)
• What: fn-first 2-arg reduce makes init the collection and coll nil → returns init. Expected: fold with first element as init (Scheme/Clojure) or arity error. Asymmetrically, data-first (reduce coll f) DOES fold — with nil init (works only via nil-coercion in +/str).
• Repro: (reduce + (list 1 2 3)) → (1 2 3) (expected 6 or error); (reduce (list 1 2 3) +) → 6.
• Coverage: not covered (tests only use 3-arg forms)

[high] [CONFIRMED] ho-swap-args misreads (reduce init f coll) — breaks (-> init (reduce f coll))

• Location: spec/evaluator.sx, ho-swap-args reduce branch: (list b (nth evaled 2) a)
• What: with non-callable arg0, (reduce init f coll) treats arg0 as coll and arg2 as init — the threaded scalar seed becomes the "collection" → cryptic host error. The thread handler inserts the threaded value FIRST for HO forms, so any -> reduce with a scalar seed hits this.
• Repro: (-> 0 (reduce + (list 1 2 3))) → Error: rest: 1 list arg (expected 6); same for (reduce 0 + (list 1 2 3)).
• Coverage: not covered — thread-ho suite only tests (-> coll (reduce + 0)) (test-cek-advanced.sx:673)

[high] [CONFIRMED] Data-first ho-swap-args silently drops all args beyond the second

• Location: spec/evaluator.sx, ho-swap-args non-reduce branch: (list b a)
• What: when arg0 is data and arg1 callable, everything after arg1 is discarded — a data-first multi-collection map silently maps over only the first collection; with no lambda-arity enforcement, garbage results, not errors.
• Repro: (map (list 1 2) (fn (x) (* x 10)) (list 3 4)) → (10 20); (map (list 1 2) (fn (x y) (+ x y)) (list 30 40)) → (1 2) (y → nil, (+ 1 nil) = 1).
• Coverage: not covered

[high] [CONFIRMED] Infinite recursive component hangs the renderer — no depth guard

• Location: web/adapter-html.sx render-html-component/render-list-to-html; spec/render.sx has no recursion bound
• What: a self-referencing component with no base case (or data-driven cycle) recurses forever — one render pins the server thread indefinitely. No depth limit or cycle detection.
• Repro: (do (defcomp ~loop () (div (~loop))) (render-to-html '(~loop) (current-env))) → never returns (killed at 20s). Bounded (~nest :n 3) renders fine.
• Coverage: not covered (needs a depth limit + test)

[high] [CONFIRMED] append! silently no-ops on all derived lists

• Location: spec/primitives.sx append! (+ OCaml impl)
• What: append! mutates only literal (list ...) cells. Lists produced by map, filter, rest, reverse, append are silently unappendable — no error, mutation lost. append! returns the appended value, masking the failure.
• Repro: (let ((xs (map (fn (x) x) (list 1 2)))) (append! xs 3) xs) → (1 2); literal list → (1 2 3).
• Coverage: test-primitives.sx:339 uses append! only on a literal-list accumulator.

[high] [CONFIRMED] expt silently wraps at 63-bit int; inconsistent with +/* which promote to float

• Location: spec/primitives.sx expt
• Repro: (expt 2 62) → -4611686018427387904; (expt 2 100) → 0; but (* 4611686018427387904 4) → float and (+ 9223372036854775807 1) → float. (expt 2.0 100) correct.
• Coverage: test-math.sx:66-71 — overflow not covered.

[high] [CONFIRMED] MCP harness primitive table diverges from real runtime — invalidates harness-based verification

• Location: hosts/ocaml/bin/mcp_tree.ml (own primitive table, e.g. bind "contains?" L484, bind "split" L563) vs hosts/ocaml/lib/sx_primitives.ml (sx_server)
• What: sx_harness_eval runs a parallel implementation of many primitives. Divergences (harness → runtime): (empty? "")/(empty? {}) false → true (test-primitives.sx:89 asserts true — harness contradicts a passing test); (get {:a 1} :a 99) nil even for present key → 1; (get {:a 1} :zz 99) nil → 99; (get (list 10 20) 1) nil → 20; (split "a--b" "--") char-class → substring; (split "abc" "") crash → ("a" "b" "c"); equal? undefined → defined; (contains? {:a 1} :a) true → error; (keyword-name :kw) "" → error. CLAUDE.md mandates harness verification, so this drift silently produces false findings/passes.
• Coverage: nothing tests harness/runtime parity. (Cross-lane: host tooling — see handoffs — but it's the spec-mandated verification path.)

[high] [CONFIRMED] contains? does not support dicts in the real runtime, contradicting its spec doc

• Location: spec/primitives.sx contains? (":doc … Dicts: key check"); sx_primitives.ml
• Repro: (contains? {:a 1} :a) → Unhandled exception: "contains?: 2 args" (misleading arity error); lists/strings work.
• Coverage: list membership only (run_tests.ml:1255); no dict case.

[high] [CONFIRMED] canonical.sx depends on test-runner-only helpers — content addressing fails on ANY number outside run_tests

• Location: spec/canonical.sx, canonical-number (46-59) calls contains-char? (defined only in run_tests.ml:728 / run_tests.js:85) and trim-right (run_tests.js:87 only — not even OCaml run_tests). Neither exists in sx_primitives.ml, sx_server.ml, or mcp_tree.ml.
• What: canonical-serialize/content-id on the production server errors on any number. In the OCaml test runner the trim-right branch (floats with trailing zeros) is unreachable-but-passing because tests only canonicalise integers.
• Repro: fresh sx_server: (load "spec/canonical.sx") (canonical-serialize 42) → Undefined symbol: contains-char?; with a shim, (canonical-serialize 0.1) → Undefined symbol: trim-right.
• Coverage: test-canonical.sx covers ints/dict-sorting/CIDs — never a non-.0 float; failure mode invisible to all suites.

[high] [CONFIRMED] Serializer emits dict keys unescaped — non-identifier keys produce unparseable/wrong output; canonical form not a fixed point (CID hazard)

• Location: spec/parser.sx sx-serialize-dict (emits (str ":" key)); spec/canonical.sx canonical-dict (~79, same pattern)
• What: dict keys are strings; both serializers print : + raw key. Keys with spaces/parens/non-ident chars produce output that reparses differently or errors. Since canonical-serialize feeds sha3-256, CIDs exist for values whose canonical form violates canonical(parse(canonical(x))) = canonical(x). The native reader accepts string keys {"a b" 1}, so such dicts are creatable from plain source.
• Repro: dict with key "hello world" → "{:hello world 2 :k 1}" → reparse errors; {(+ 1 2) 5} → key "(+ 1 2)" → serializes {:(+ 1 2) 5} → garbage.
• Coverage: "serialize dict round-trips" uses keyword-shaped keys only.

[high] [CONFIRMED] Same source parses to different ASTs across the four ident/number classifier variants

• Location: hosts/ocaml/lib/sx_parser.ml:36-46 (native), hosts/ocaml/bin/sx_server.ml:1330-1348, hosts/ocaml/bin/mcp_tree.ml:391-410, hosts/javascript/platform.py:2622-2626 — four different ident-start/ident-char tables feeding the one spec grammar
• What (all verified live): (a,b) → single symbol on native/mcp/JS but (a (unquote b)) on sx_server guest; unicode idents accepted by mcp guest only (forbidden by the production reader); $x/|y| symbols on sx_server guest only; 0x10/0b101/1_000 → numbers 16/5/1000 on native (undocumented C-style acceptance) vs number 0 + symbol x10 on guest/JS (silent token split); inf/nan/-inf are float literals on native (can't be variable names!) vs symbols on guest/JS; 1+/1abc single symbols native vs silent 1 + symbol split guest/JS ((1+ 2) → 3-element list); #t/#f booleans native vs Undefined symbol: reader-macro-get on OCaml guest vs "Unknown reader macro" on JS; {1 2} rejected native vs silently stringified key "1" guest/JS.
• Coverage: none of these tokens appear in any test file — suites exercise only the intersection.

[high] [CONFIRMED] 1e bare-exponent numbers silently parse to nil in the guest parser

• Location: spec/parser.sx read-number → parse-number fallthrough (nil emitted as a value, no error)
• Repro: (sx-parse "1e") → (nil); JS parseAll('1e') → [null]; native reader yields Symbol "1e" — a third behavior. (foo 1e) becomes (foo nil) silently.
• Coverage: only valid exponent forms tested.

[high] [CONFIRMED] Guest parser cannot produce rationals on server/tooling hosts — 1/2 throws

• Location: spec/parser.sx read-number (215-231); sx_server.ml:1325 and mcp_tree.ml:384 override parse-number to always return float, shadowing the Integer-aware sx_primitives version; make-rational rejects (Number,Number)
• Repro: fresh sx_server: (load "spec/parser.sx") (sx-parse "1/2") → make-rational: expected 2 integers. Works only in run_tests env. Native reader parses 1/2 fine.
• Coverage: test-rationals.sx (62 tests) never uses sx-parse; test-parser.sx has zero rational tests.

[high] [CONFIRMED] Strict mode: HO-form callbacks bypass type checks entirely

• Location: spec/evaluator.sx step-continue — map/filter/reduce/for-each/some/every/multi-map frames call continue-with-call directly; only the "arg" frame runs strict-check-args (enforcement site 4152-4194). Same in sx_ref.ml:1009.
• What: with strict on and types declared for f, (f "a") errors but (map f coll)/(filter f coll)/(reduce f init coll)/(for-each f coll)/(every? f coll)/(some f coll) silently pass mistyped elements. Also unchecked: cond => arrow calls, call/cc continuation invocation, exception-handler invocation, signal-subscriber cek-calls.
• Repro: hh typed (x number): (hh "abc") → type error; (map hh (list "a" "b")) → ("a" "b") silently.
• Coverage: test-strict.sx checks direct calls only.

[high] [CONFIRMED] Strict mode: apply bypasses type checks on the target function

• Location: hosts/ocaml/lib/sx_primitives.ml:1534 / sx_server.ml:1240 — native prim spreads args and calls directly
• Repro: (apply hh (list "a")) → "a" (no error); direct (hh "a") errors.
• Coverage: not covered.

[high] [CONFIRMED] dispose-computed is a no-op — computed signals leak subscriptions after disposal

• Location: spec/signals.sx, dispose-computed — (signal-remove-sub! dep nil) passes nil as the subscriber; the actual recompute closure is trapped in computed's letrec and unreachable. The island-scope disposer registered by computed is therefore broken (contrast effect, whose dispose-fn works).
• Repro: computed on a2 (1 run); (dispose-computed c2); (reset! a2 5) → runs=2, value updated. Expected: runs=1, unchanged. Subscriber leak in island teardown.
• Coverage: no dispose-computed test exists.

[high] [CONFIRMED] Exception inside batch permanently wedges the reactive system

• Location: spec/signals.sx, batch — increments *batch-depth*, runs thunk with no unwind protection; decrement skipped on throw
• What: after any error escapes a batch thunk (even if caught outside), *batch-depth* stays >0 — every future notify-subscribers queues forever and never flushes; all reactivity dead. Related: (import (sx signals)) copies value bindings rather than aliasing, so the top-level *batch-depth* reads 0 while the library-internal one is 1 (exported mutable state vars are misleading).
• Repro: effect on a3 (fired=1); (guard (e (true "caught")) (batch (fn () (error "boom")))) → caught; (reset! a3 2) → fired stays 1. Control test without error flushes correctly.
• Coverage: not covered.

[high] [CONFIRMED — surfaced by hosts lane, verified here] emit!/emitted state accumulates across evaluator invocations — cross-request contamination on the server

• Location: spec/evaluator.sx scope/emit frame handlers + the process-global scope stacks (hosts: sx_primitives.ml _scope_stacks)
• What: (scope (emit! :k 1) (emit! :k 2) (len (emitted :k))) returns 2, then 4, then 6 on successive epoch-server evals — the emit accumulator for a normally-exited scope persists in process-global state and each new scope sees prior invocations' values. On the HTTP server this means one request's emitted values are visible to the next (correctness + information-leak class). Complements the provide/raise leak finding: the scope facility's global stacks are neither unwind-safe NOR invocation-scoped. (My in-eval probe showed no leak within one evaluation — the leak is across evaluator entries.)
• Repro: three identical (eval "(scope (emit! :k 1) (emit! :k 2) (len (emitted :k)))") epochs on one fresh sx_server → 2, 4, 6. JIT disabled, so not a VM bug.
• Coverage: scope/emit!/emitted have zero tests (noted previously); cross-invocation behavior untested anywhere.

[medium] [CONFIRMED] provide's dynamic value permanently leaks on non-local exit (raise, shift)

• Location: spec/evaluator.sx, step-sf-provide (:3344 scope-push!) + "provide" frame handler (:4293, scope-pop! only on normal completion); no pop during raise/guard/shift unwinding
• What: provide pushes onto a global per-name stack, popped only on normal frame completion. Any non-local exit through the body skips the pop — the value stays on the global stack forever, and context prefers scope-peek, so all later code sees the stale value.
• Repro: (do (guard (e (true "caught")) (provide "kk" 42 (raise "boom"))) (context "kk")) → 42 (expected nil). (do (reset (provide "esc" 9 (shift k 77))) (context "esc")) → 9.
• Coverage: test-unified-reactive.sx covers provide/context nesting for normal exits only.

[medium] [CONFIRMED] provide! outside any enclosing provide installs a permanent ambient global

• Location: spec/evaluator.sx, "provide-set" frame handler (:4334-4346: pop-then-push); host scope-pop! on empty stack is a no-op (sx_primitives.ml:1998)
• Repro: (do (provide! "pk" 7) nil) then, in a later top-level eval, (context "pk") → 7.
• Coverage: provide! tests all run inside provide scopes; bare case uncovered.

[medium] [CONFIRMED×2] set! on unbound name silently creates a binding — contradicting both spec docs — and JIT vs interpreter write different global tables (split brain)

• Location: spec/evaluator.sx step-sf-set! + hosts/ocaml/lib/sx_types.ml env_set_id (:378 root-create fallback) vs sx_vm.ml OP_GLOBAL_SET (:606 writes vm.globals); contradicted docs: spec/eval-rules.sx:112 ("Error if name is not bound"), spec/special-forms.sx:141 ("must already be bound")
• What: (a) interpreted set! on unbound silently creates a root binding — typo'd set! hides bugs, and directly contradicts both spec documents (test-scope.sx:196 locks the create behavior, so impl-vs-doc conflict must be resolved one way or the other). (b) inside a JIT-compiled lambda the same set! writes the VM's separate vm.globals table — visible to VM code, invisible to interpreted code.
• Repro: (set! never-defined-var 5) → 5 (readable after). Split brain: (do (define setter (fn () (set! q5 42))) (define reader (fn () q5)) (setter) (reader)) → "Undefined symbol: q5" (yet q5 reads as 42 inside setter).
• Coverage: test-scope.sx:196 asserts creation only; visibility split uncovered.

[medium] [CONFIRMED] Quasiquote has no depth tracking — nested quasiquote evaluates inner unquotes early; ,,x errors

• Location: spec/evaluator.sx, qq-expand (no level parameter)
• Repro: (let ((x 7)) (quasiquote (a (quasiquote (b (unquote x)))))) → (a (quasiquote (b 7))) (Scheme: unquote preserved); `(a `(b ,,x)) → Undefined symbol: unquote.
• Coverage: test-cek-advanced.sx:486 "nested unquote" is single-level despite its name.

[medium] [CONFIRMED] Quasiquote does not traverse dict literals — ,v inside {...} stays literal

• Location: spec/evaluator.sx, qq-expand (non-list templates returned as-is)
• Repro: (let ((v 3)) (quasiquote {:k (unquote v)})) → {:k (unquote v)}. Inconsistent with dict eval rule ("values are evaluated", eval-rules.sx:40).
• Coverage: not covered.

[medium] [CONFIRMED] guard clause bodies: multi-expr → crash; multi-expr else → "Undefined symbol: else"

• Location: spec/evaluator.sx, step-sf-guard — clauses spliced verbatim into a generated cond, inheriting the cond dual-mode defect
• Repro: (guard (e (true 1 2)) (raise 9)) → Not callable: nil; (guard (e (else 1 2 3)) (raise 9)) → Undefined symbol: else. R7RS requires body sequencing. => receiver works.
• Coverage: only single-expr clause bodies tested.

[medium] [CONFIRMED] defmacro/fn &key params silently misbind — keyword names ignored, off-by-one positional binding

• Location: spec/evaluator.sx, macro/lambda param binding (&key pairing implemented only for components)
• Repro: (defmacro mk2 (&key a b) ...): (mk2 :a 10 :b 20) → a=10, b=:b (the keyword itself); (mk2 :b 20 :a 10) → a=20 despite the :b label. Plain (fn (&key a b) ...) treats &key as a positional param name → "expects 3 args, got 4". Accepted without error, misbehaves.
• Coverage: not covered.

[medium] [CONFIRMED] Splicing a non-list silently wraps it; malformed splice forms pass through literally

• Location: spec/evaluator.sx, qq-expand
• Repro: (quasiquote (a (splice-unquote 5))) → (a 5) (Scheme: error); (splice-unquote xs ys) (arity 3) → stays literal; (unquote a b) silently drops b.
• Coverage: not covered.

[medium] [CONFIRMED] do misparses a first form whose head is a list (IIFE) as a Scheme do-loop

• Location: spec/evaluator.sx, step-eval-list "do" branch (~1843): dispatches to do-loop when (list? (first (first args)))
• Repro: (do ((fn (x) x) 5) 99) → error "first: expected list, got 5"; expected 99.
• Coverage: not covered.

[medium] [CONFIRMED] scope's :value parameter is parsed but unreadable — dead feature + dead frame type

• Location: spec/evaluator.sx, step-sf-scope (:3318) / make-scope-acc-frame (:120); context/peek never consult scope-acc frames. Pre-CEK sf-scope (:1495) did scope-push!; the CEK rewrite dropped it. Frame type "scope" (make-scope-frame :111, handler :4279) is never pushed by any live path.
• Repro: (scope "v" :value 10 (list (context "v") (peek "v"))) → (nil nil).
• Coverage: scope/emit!/emitted have ZERO tests in spec/tests (doc example only, eval-rules.sx:200).

[medium] [CONFIRMED] Host-level errors are uncatchable by guard (only SX-level raise is)

• Location: spec/evaluator.sx raise/handler machinery vs host primitive errors
• What: errors from host primitives (rest: 1 list arg, Undefined symbol, arity errors) escape enclosing guard entirely; only guest (raise ...) unwinds to handlers. Guest code cannot write defensive wrappers around primitive misuse.
• Repro: (guard (e (true "caught")) (undefined-symbol-xyz)) → propagates, guard never fires.
• Coverage: test-errors.sx/test-conditions.sx exercise guest raise only.

[medium] [CONFIRMED] values/call-with-values bound only inside the test runner — Undefined symbol on every real runtime surface; let-values/define-values unusable

• Location: spec/evaluator.sx values (2093), call-with-values (1392), sf-let-values (1403), sf-define-values (1437); hosts/ocaml/bin/run_tests.ml:1131 (bind "values" — test env only)
• Repro: (call-with-values (fn () (values 1 2)) +) on CLI → Undefined symbol: call-with-values; same expr under run_tests → PASS. test-values.sx (22 tests) overstates the shipped runtime.
• Coverage: green only in the runner environment.

[medium] [CONFIRMED] map/filter/map-indexed are O(n²)

• Location: spec/evaluator.sx, "map"/"filter" continue handlers (~4364, ~4397): (append results (list value)) per element; map-indexed also recomputes (len new-results) each step
• Repro: fresh sx_server: 10k → 0.58s, 20k → 2.56s, 40k → 13.6s (≈×4.7 per doubling); 100k map DNF in 120s while (reduce + 0 (in-range 100000)) takes 0.32s. Stack-safe — purely time.
• Coverage: not covered (no perf tests)

[medium] [CONFIRMED] HO form names are not first-class — value position yields nil with a misleading type

• Location: spec/evaluator.sx, symbol lookup (~1650) vs special-cased call dispatch
• Repro: (define f2 map) (f2 (fn (x) x) (list 1 2)) → Not callable: nil; yet (type-of map) → "function".
• Coverage: not covered

[medium] [CONFIRMED] Cryptic uncatchable errors for bad HO data: dicts, both-args-callable

• Location: spec/evaluator.sx, seq-to-list (else x) passthrough (~3573) + ho-setup-dispatch
• Repro: (map (fn (kv) kv) {:a 1 :b 2}) → rest: 1 list arg; (map (fn (x) 1) (fn (y) 2)) → same. Expected: iterate dict entries or a clear "map: cannot iterate X".
• Coverage: not covered

[medium] [CONFIRMED] Multi-collection map rejects strings/vectors that single-collection map accepts

• Location: spec/evaluator.sx, ho-setup-dispatch "map" N-coll branch skips seq-to-list
• Repro: (map + (vector 1 2) (vector 10 20)) → first: expected list, got #(1 2); single-collection vector/string map works.
• Coverage: list multi-map covered (test-r7rs.sx:110–124); strings/vectors not

[medium] [CONFIRMED] Threading a lambda literal returns a silently malformed lambda

• Location: spec/evaluator.sx, thread-insert-arg — splices the value into the params position of (fn ...)
• Repro: ((-> 5 (fn (y) (+ y 1))) 7) → Undefined symbol: y. Should error at thread time.
• Coverage: not covered

[medium] [CONFIRMED] Attribute names are never escaped/validated — spreading an untrusted-keyed dict injects attributes (XSS class)

• Location: spec/render.sx, render-attrs (emits key raw) + merge-spread-attrs (copies spread-dict keys verbatim)
• What: attribute values are escaped; attribute names are concatenated raw. Keys reach render-attrs via the spread operator, so spreading a dict built from user data yields event-handler injection.
• Repro: (render-attrs {"x onload=alert(1) y" "1"}) → x onload=alert(1) y="1". Values confirmed safe.
• Coverage: not covered

[medium] [CONFIRMED] Five void elements unrenderable — in VOID_ELEMENTS but missing from HTML_TAGS

• Location: spec/render.sx, VOID_ELEMENTS vs HTML_TAGS
• Repro: area base embed param track fall through to function-call dispatch: (render-to-html '(base :href "x") ...) → Undefined symbol: base.
• Coverage: void suite tests br/hr/img/input/meta/link/source/col/wbr only

[medium] [CONFIRMED] aser serialises list-valued keyword args as bare unquoted lists → breaks on client re-evaluation

• Location: web/adapter-sx.sx aser-call
• Repro: (aser '(~tags :items (list "a" "b")) env) → (~tags :items ("a" "b")); re-evaluating the wire form → Not callable: nil. Dicts round-trip fine; only lists break. Should emit (quote (...)) or (list ...).
• Coverage: test-aser covers lists as children, not as kwarg values

[medium] [CONFIRMED-html / SUSPECTED-dom — independently double-confirmed] render-to-dom disagrees with render-to-html on non-boolean attrs valued true/false (hydration mismatch)

• Location: web/adapter-dom.sx (attr cond ~357) vs spec/render.sx render-attrs
• What: for attrs NOT in BOOLEAN_ATTRS, HTML mode stringifies (data-flag="true", data-off="false"), DOM mode omits false and emits true as an empty attr. SSR HTML and hydrated DOM differ. HTML side executed; DOM side code-read (dom adapter not loadable in harness). Cross-check: hosts lane C19 found the same defect independently (same conclusion, same confidence split) — treat as confirmed pending a browser-side execution.
• Repro: (render-to-html '(div :data-flag true :data-off false) ...) → <div data-off="false" data-flag="true">.
• Coverage: not covered

[medium] [CONFIRMED] String primitives are byte-based; substring can produce invalid UTF-8

• Location: string-length, substring, upcase/downcase
• Repro: (string-length "é") → 2, "👍" → 4; (substring "é" 0 1) → "<22>"; (upcase "héllo") → "HéLLO". Constructors are codepoint-aware (char-from-code 233 → "é") while measurement is byte-based. Project rule "use UTF-8 chars" makes this a live hazard.
• Coverage: no codepoint-semantics tests.

[medium] [CONFIRMED] Spec declares primitives that don't exist; runtime has primitives the spec omits

• Location: spec/primitives.sx
• What: eq? (L285), eqv? (L292) declared, undefined in both harness and sx_server; into (L722) declared — IO-bridge-only in server; json-encode declared plain but IO-bridge-only; sort exists in runtime but NOT in spec; header (L27-35) claims ~40 functions "moved to stdlib.sx" but stdlib.sx contains only format.
• Repro: (eq? 1 1) → Undefined symbol: eq?; (sort (list 3 1 2)) → (1 2 3).
• Coverage: drift untested.

[medium] [CONFIRMED] Division-by-zero inconsistency: / returns inf silently, mod/quotient leak raw OCaml exception

• Repro: (/ 1 0) → inf; (mod 7 0)/(quotient 7 0) → unstructured host Division_by_zero.
• Coverage: not covered.

[medium] [CONFIRMED] / doc contradicts behavior: ":returns float" but exact results snap to int

• Repro: (integer? (/ 6 3)) → true. (/ 1 3) → float, never rational despite make-rational.
• Coverage: behavior covered green — the doc is wrong.

[medium] [CONFIRMED] sort takes no comparator

• Repro: (sort (list 3 1 2) (fn (a b) (> a b))) → Unhandled exception: "sort: 1 list". Natural ascending on numbers/strings only.
• Coverage: not covered.

[medium] [CONFIRMED] Strict type errors are uncatchable by guard (host/spec error-channel divergence)

• Location: sx_ref.ml strict_check_args (:516, raises Eval_error outside the CEK raise-eval machinery); the spec expresses it as (error ...) which would use the ordinary condition channel
• What: (guard (e (true ...)) (typed-call bad-arg)) does not catch — the type error escapes to top level, while user (error "boom") IS caught by the same guard. Programs cannot recover from type errors. Same channel problem as the general host-errors-uncatchable finding, but here spec and host disagree about which channel it should be.
• Repro: (guard (e (true (str "CAUGHT: " e))) (s1 "bad")) → protocol-level type error; (guard (e (true ...)) (error "boom")) → caught.
• Coverage: test-strict.sx asserts at the runner level; the guard channel untested.

[medium] [CONFIRMED] Strict mode: unknown type names silently match everything

• Location: spec/evaluator.sx value-matches-type? — _ fallback returns true for any unknown non-"?"-suffixed string; set-prim-param-types! does no validation
• Repro: gg typed (x "integer"): (gg "abc") → "abc" (typo silently disables checking); "frobnicate?" matches all values.
• Coverage: not covered.

[medium] [CONFIRMED] Strict mode: "keyword" type is dead; components are untypeable

• Location: value-matches-type? vs eval-rules.sx keyword rule (keywords evaluate to strings)
• What: (a) evaluated keyword args arrive as strings, so a "keyword"-typed param always fails on (f :foo) and passes plain strings via "string"; (b) type-of a component is "component", which fails "lambda", and "component" isn't a match branch — falls to the catch-all and accepts everything. No way to require a component.
• Repro: (pk :foo) → "expected keyword … got string (foo)"; c7 typed "component": (c7 42) passes.
• Coverage: no keyword/lambda/component type tests.

[medium] [CONFIRMED] Strict mode: component &key calls misalign with positional type specs

• Location: strict-check-args positional indexing vs component keyword calling convention
• Repro: ~tc typed (a number): (~tc :n 5) → "expected number for param a, got string (n)" — the keyword marker itself is checked as arg 0. Typing components via this machinery is impossible.
• Coverage: not covered.

[medium] [CONFIRMED] Signals: reset!/computed change-detection is dead for numbers and strings

• Location: spec/signals.sx reset!, swap!, computed — (when (not (identical? old value)) ...); identical? is physical equality: (identical? 5 5) → false
• What: setting a signal to its current value still notifies; computeds recomputing to an equal number/string still cascade — spurious re-runs throughout the reactive graph.
• Repro: effect on (signal 5) (runs=1); (reset! a7 5) → runs=2. Expected 1.
• Coverage: not covered.

[medium] [CONFIRMED] Signals: diamond dependency glitch — no glitch-freedom

• Location: spec/signals.sx — notify/flush propagate depth-first synchronously; batch dedups only direct subscribers of directly-mutated signals and decrements depth before cascades
• What: a → b,c → d: one change to a recomputes d twice; the first recompute observes new-b with stale-c (inconsistent intermediate state).
• Repro: initial d runs=1; (reset! a 2) → d runs=3, final value correct.
• Coverage: not covered.

[medium] [CONFIRMED] Datum comment #; cannot precede ) or end input — all three parsers

• Location: spec/parser.sx read-expr #; branch (discard-then-read-next); sx_parser.ml:167-171 same structure
• Repro: (sx-parse "(a #;b)") → Unexpected character: ); (sx-parse "1 2 #;3") → Unexpected end of input. Standard Lisp: (a #;b) = (a).
• Coverage: three datum-comment tests, all mid-list.

[medium] [CONFIRMED] Char values never compare equal — = lacks a Char case

• Location: hosts/ocaml/lib/sx_primitives.ml safe_eq (749-804): no Char,Char arm → falls to _ -> false
• Repro: (= (make-char 32) (make-char 32)) → false. parse(serialize(char)) ≠ char for every char; char-keyed memoization silently fails.
• Coverage: test-chars.sx compares via char->integer/predicates; no =-on-chars test.

[medium] [CONFIRMED] #\a char literals crash the guest parser on the mcp-tree host (Int/Float primitive drift)

• Location: mcp_tree.ml:378 (char-code returns float) vs sx_primitives.ml:2811 (make-char requires Integer)
• Repro: mcp harness (sx-parse "#\a") → make-char: expected integer codepoint; sx_server OK. Same shadowing family as parse-number.
• Coverage: no char-literal-via-sx-parse tests.

[medium] [CONFIRMED] Multibyte character literals broken everywhere; serialized chars ≥128 don't reparse; unknown char names silently truncate

• Location: sx_parser.ml:153-159 (byte-level Char.code); spec/parser.sx read-char-literal (byte-level); serializer emits #\ + raw char
• Repro: native '#\é → Parse_error "Unexpected char: \169"; (sx-serialize (make-char 233)) → "#\é" which no parser reads back; #\spade → #\s silently (both implementations).
• Coverage: no non-ASCII char literals tested.

[medium] [CONFIRMED] \uXXXX escape: invalid input crashes raw (OCaml) or silently corrupts (JS); no astral/surrogate-pair support

• Location: spec/parser.sx read-string \u branch (no hex validation, no bounds check, -1 from failed digit lookup); sx_parser.ml:70-77
• What: valid BMP works on all three parsers (the "never use \uXXXX" project rule is style, not brokenness). Invalid hex: guest → raw Invalid_argument (negative codepoint); native → uncaught Failure("int_of_string"); JS → silently yields garbage string. Surrogates: OCaml raises, JS produces lone surrogate. Truncated "\u41" → guest reads past the closing quote (Expected string, got nil). Astral unrepresentable.
• Coverage: zero \u tests in any suite.

[medium] [CONFIRMED] Unknown string escapes diverge: native keeps the backslash, guest/JS drop it

• Location: sx_parser.ml:79 (_ -> add '\\'; add esc) vs spec/parser.sx read-string :else esc
• Repro: "a\qb" is 4 chars through the native reader, 3 chars through guest/JS — same source file, different data depending on which parser read it. \b/\f unsupported both (silent literal); native additionally accepts undocumented \/ and \`.
• Coverage: only \n \t " tested.

[medium] [CONFIRMED] #name extensible reader-macro dispatch is unimplemented on OCaml hosts

• Location: spec/parser.sx:459 (reader-macro-get); registry exists only in hosts/javascript/platform.py:2639-2640
• Repro: mcp harness (sx-parse "#t") → Undefined symbol: reader-macro-get (instead of the intended "Unknown reader macro" error). The sole production evaluator cannot register reader macros at all.
• Coverage: reader-macro suite tests only #; #| #'.

[low-medium] [CONFIRMED] case: :else/else matches in ANY position, shadowing later valid clauses

• Location: spec/evaluator.sx, step-sf-case / is-else-clause?
• Repro: (case 1 :else "e" 1 "one") → "e".
• Coverage: not covered.

[low-medium] [CONFIRMED] case: evaluated datums, keyword/string punning, Scheme clause syntax crashes misleadingly

• Location: spec/evaluator.sx, step-sf-case; documented flat in eval-rules.sx:70 (but rule text doesn't say vals are evaluated)
• What (verified): vals evaluated sequentially until match (side effects only for pre-match vals), scrutinee once, comparison structural = (lists match), duplicates first-wins, no-match+no-else → nil; keywords evaluate to strings so (case "k" :k "kw") matches. Scheme datum-list clauses crash: (case "a" (("a") 1) (else 2)) → Not callable: ("a"). Flat form is intended (test-cek.sx:130-138); the unstated eval semantics + hostile diagnostic are the issues.
• Coverage: happy paths only.

[low] [CONFIRMED×2] letrec is parallel (not letrec*) and reference-before-init silently yields nil

• Location: spec/evaluator.sx, sf-letrec (~1366-1469: all inits evaluated before any name bound; names pre-bound nil)
• Repro: (letrec ((a b) (b 1)) a) → nil (R7RS: error); (letrec ((a 1) (b (+ a 1))) b) → 1 (nil-coerced by +; letrec* would give 2). Masks initialization-order bugs.
• Coverage: only well-formed lambda recursion tested.

[low] [CONFIRMED] Documentation contradicts implementation: let IS sequential and multi-expression bodies ARE implicit begin

• Location: spec/evaluator.sx step-sf-let (:3133 — let and let* dispatch identically, shared local frame) vs CLAUDE.md "SX Island Authoring Rules" (claims parallel let, last-expr-only bodies, "reactive text needs deref computed", "effects go in inner let")
• What: (let ((a 1) (b a)) b) → 1; (let ((x 5) (x (* x 2))) x) → 10; let/when/fn multi-expr bodies evaluate every form (side effects verified). Sequential let is explicitly tested intent (test-scope.sx:45). The CLAUDE.md gotchas describe a different evaluator (likely the OCaml SSR island path) — doc drift that misleads every SX author. Also (let ((f (fn () a2)) (a2 5)) (f)) → 5: binding-init lambdas capture the let frame itself (letrec-like — beyond even letrec* semantics; worth documenting).
• Coverage: sequential let tested; the doc is what's wrong.

[low] [CONFIRMED] Component &key argument false is coerced to nil

• Location: spec/evaluator.sx, component branch: (env-bind! local p (or (dict-get kwargs p) nil))
• Repro: (do (defcomp ~t1 (&key flag) (if (nil? flag) "NIL" "VAL")) (~t1 :flag false)) → "NIL". Components can't distinguish :flag false from omitted.
• Coverage: invisible to test-defcomp.sx (only used in conditionals).

[low] [CONFIRMED] Trailing keyword argument without a value silently accepted

• Location: spec/evaluator.sx, parse-keyword-args (:935)
• Repro: (do (defcomp ~c4 (&key a) (list a)) (~c4 :a)) → (nil); expected kwarg error.
• Coverage: not covered.

[low] [CONFIRMED] defmacro is unhygienic (classic capture) while the test suite is named "macro-hygiene"

• Repro: (defmacro my-or2 (a b) (let ((t ,a)) (if t t ,b))); (let ((t 5)) (my-or2 false t))→false`. CL-style defmacro — judged intended (gensym available, unique, tested); but test-macros.sx "macro-hygiene" suite (line 208) tests only the leak-OUT direction, overstating the guarantee.

[low] [CONFIRMED] match has no guard clauses — Racket-style (pattern (when cond)) silently read as a structural pattern

• Repro: (match 9 ((x (when (> x 5))) "big") (_ "small")) → "small" (silent structural fail → fall through). Supported features work; non-match raises properly. let-match is dict-destructuring only; list patterns give a confusing "no clause matched".
• Coverage: supported features covered; guard-clause rejection not.

[low] [CONFIRMED] Components not recognized by ho-fn?; map-with-component yields silent zeros

• Location: spec/evaluator.sx, ho-fn? (3554) — no component check
• Repro: (defcomp ~c2 (x) (* x 2)); (map ~c2 (list 1 2 3)) → (0 0 0); (map (list 1 2 3) ~c2) → rest: 1 list arg.
• Coverage: not covered

[low] [CONFIRMED] |> alias is dead code — parser rejects |

• Location: spec/evaluator.sx step-eval-list ("|>" ...) (1906); tokenizer
• Repro: (|> (list 1 2 3) ...) → Parse_error("Unexpected char: |"). Branch unreachable.

[low] [CONFIRMED] Keywords-as-getters unsupported in HO fn position and -> chains, with misleading errors

• Repro: (map :name (list {:name 1})) → Not callable: "name"; (-> {:a {:b 42}} :a :b) → Not callable: nil.
• Coverage: not covered

[low] [CONFIRMED] Zero/one-arg HO calls return empty results silently

• Repro: (map) → (); (map (fn (x) x)) → (); (reduce +) → nil; (-> (list 1 2 3) map) → () (plausible typo silently discards data).
• Coverage: not covered

[low] [CONFIRMED] Boolean-attr truthiness footguns: string "false" and 0 emit the bare attribute

• Location: spec/render.sx, render-attrs (SX truthiness)
• Repro: (input :disabled "false") → <input disabled />; (input :disabled 0) same. Aligns with SX truthiness but surprising when values come from data.
• Coverage: true/false booleans tested; string/number values not

[low] [CONFIRMED] is-render-expr? exported but dead; html: tags and hyphenated custom elements error despite being "recognised"

• Location: spec/render.sx, is-render-expr? — zero callers
• Repro: (render-to-html '(html:my-tag :foo "bar") ...) → Undefined symbol: html:my-tag; (aser '(custom-widget :foo "bar" "child") ...) → Undefined symbol: custom-widget.
• Coverage: not covered

[low] [CONFIRMED] <script>/<style> content is HTML-escaped like text — corrupts legitimate inline JS/CSS

• Location: web/adapter-html.sx render-html-element
• Repro: (script "if (a < b && c) { x=\"y\"; }") → entities inside script (broken JS); (style ".a > .b {}") → .a > .b {}. Blocks </script> breakout (good) but breaks real inline code; raw! is the workaround.
• Coverage: only script attrs tested, never content

[low] [CONFIRMED] Comparison/equality strictly binary; = is deep structural equality conflating exactness

• Repro: (< 1 2 3)/(= 1) → unstructured arity error (matches spec, deviates from Scheme); (= {:a 1} {:a 1}) → true; (= 1 1.0) → true (dedup-key hazard).

[low] [CONFIRMED] Rounding half-away-from-zero, not banker's; inexact->exact rounds; (sqrt -1) → nan

• Repro: (round 2.5) → 3 (R7RS: 2); (inexact->exact 1.5) → 2 (locked by test-numeric-tower.sx:115 — intended but R7RS-divergent); (sqrt -1) → nan silently.

[low] [CONFIRMED] Float/nil rendering inconsistencies across str/format/render

• Repro: (str 1.0) → "1" (float/int distinction lost — also (div 1.0) renders 1); (str nil) → "" but (format "~a" nil) → "()"; (format "~d" 3.7) → "3" (silent truncation).

[low] [CONFIRMED] Inconsistent nil/empty tolerance across list ops

• Repro: (first nil) → nil, (rest nil) → (), (nth (list 1 2) 5) → nil silently — but (last nil), (reverse nil), (nth nil 0) all raise.

[low] [CONFIRMED] keys returns strings in reverse insertion order

• Repro: (keys {:a 1 :b 2 :c 3}) → ("c" "b" "a"). Determinism footgun for serialization/content-addressing.

[low] [CONFIRMED] keyword-name unusable on evaluated keywords

• Repro: (keyword-name :kw) → error (:kw self-evaluates to "kw"); only (keyword-name ':kw) works.

[low] [CONFIRMED] string->number: no rational/whitespace parsing

• Repro: "1/2" → nil (despite make-rational), " 5 " → nil, "1e3" → 1000, garbage → nil (good).

[medium] [CONFIRMED — CORRECTED after cross-lane check] apply does not spread AT ALL on the native production surface

• Location: continue-with-call native-call path / apply primitive
• What: originally reported as "leading-args form missing, two-arg form works" — WRONG. Re-verified on fresh sx_server: (apply + (list 1 2)) → Unhandled exception: "Expected number, got list: ". The list is passed as a single argument, never spread — (apply str (list 1 2 3)) → "(1 2 3)" (str of the list itself). The earlier "works" observation came from a test-runner/harness environment with its own apply. Conformance lane F-3 independently found this AND that the WASM kernel spreads the 2-arg form (→ 6) while native errors — the same kernel family disagrees with itself on apply.
• Repro: (apply + (list 1 2)) → error; (apply + (list 1 2 3)) → error; (apply str (list 1 2 3)) → "(1 2 3)" (fresh sx_server, verified 2026-07-03).
• Coverage: not covered on the production surface (runner env has a different apply — see the values/call-with-values finding for the same pattern).

[low] [CONFIRMED] Strict checks are name-keyed at the call site — trivially evaded, and shadowers inherit checks

• Repro: (let ((zz hh)) (zz "a")) → unchecked; computed heads ((mk) "bad") → unchecked; conversely a user fn shadowing a typed name gets the declared checks applied to it. First-class function flow is entirely unchecked.
• Coverage: not covered.

[low] [CONFIRMED] set-prim-param-types! replaces wholesale; no validation; malformed specs fail cryptically and uncatchably

• What: second call wipes all earlier declarations (no merge); nonexistent prim names accepted silently; {"positional" "oops"} errors at call time with "Expected list, got string" (uncatchable, doesn't name the spec as culprit); {"name" "not-a-dict"} silently checks nothing; declaring types for HO-form names never fires (HO dispatch intercepts before the arg frame).
• Coverage: only the nil-reset path tested.

[low] [CONFIRMED] Too-few args never error and their declared types are silently skipped

• What: user lambdas nil-fill missing params ((f2 1) → (1 nil) with b typed number, no error); strict-check-args guards idx < len(args) so unsupplied params skip checking. Too-many args DO error. foreign-check-args has the mirror asymmetry (extra args unchecked; code-level).
• Coverage: not covered.

[low] [CONFIRMED] (:as type) parameter annotations are never enforced — even in strict mode

• Location: eval-rules.sx documents (:as type) in the lambda rule; spec/signals.sx uses them pervasively ((s :as signal))
• Repro: (define tf (fn ((x :as number)) x)) (tf "not-a-number") → returns the string, strict on or off. The natural per-param channel is decorative; strict mode reads only the global name-keyed dict.
• Coverage: not covered.

[low] [CONFIRMED] Strict-machinery paper cuts

• Return types unsupported anywhere (params only). Rest-arg errors index from 0 within the rest section ("rest arg 0" is overall arg 2). set-strict! is one global OCaml ref — not per-env, not captured by continuations; toggling mid-program retroactively affects existing lambdas. Dead shadowed duplicates _strict_ref/_prim_param_types_ref at sx_ref.ml:18-19 (transpiler cruft, no desync). Host surface inconsistency: sx_server binds set-strict!/set-prim-param-types! but not value-matches-type?; the harness binds none. Positive: error message quality is good (names function, param, expected, actual, value).

[low] [CONFIRMED] batch unusable on the server host; coroutines module inert outside the test runner

• What: batch calls (batch-begin!) on non-client hosts; batch-begin!/batch-end! are bound only in run_tests.ml:564 — on sx_server (batch ...) → Undefined symbol: batch-begin! (which, per the wedge finding, also leaves *batch-depth* stuck). Separately, spec/coroutines.sx lacks the trailing (import (sx coroutines)) re-export that signals.sx/harness.sx have — loading it binds nothing globally; tests work only via explicit import + run_tests-only cek-* hooks.
• Coverage: not covered.

[low] [CONFIRMED] effect stale cleanup double-invocation

• Location: spec/signals.sx effect/run-effect — cleanup-fn invoked at each re-run start but never cleared; only overwritten when a run returns a new callable
• Repro: effect returns cleanup only when v=0: after two resets, cleanup-calls = 2. Expected 1.
• Coverage: not covered.

[low] [CONFIRMED] Guest parse errors carry no source locations; native has line/col on only 2 of ~8 error types

• Location: spec/parser.sx (all error sites location-free); sx_parser.ml (locations only for "Unexpected end of input"/"Unexpected char"; unterminated string/list/dict etc. location-free)
• Repro: (sx-parse "(a (b)") → just "Unterminated list". Also test-source-locations.sx tests a parser-combinator library, NOT spec/parser.sx, and its cols are 0-based vs native 1-based.
• Coverage: no reader-location tests exist.

[low] [CONFIRMED] Dict literal edges: odd form count → misleading error; duplicate keys silently last-win

• Repro: {:a} → Unexpected character: } (no mention of pairing); {:a 1 :a 3} → {:a 3} silently (both parsers).
• Coverage: not covered.

[low] [CONFIRMED] #|...| is a raw string to the first |, not a block comment; #|a|# leaves a dangling #

• Repro: (sx-parse "#|hello world|") → ("hello world"). Documented, but a Scheme-expectation trap with no test for the |# suffix case.

[low] [CONFIRMED] Keyword edge tokens: : parses as keyword with empty name; ::a is a keyword named ":a"

• Coverage: numeric-suffix/consecutive keywords tested; :/:: not.

[low] [CONFIRMED] Harness contract nits

• A throwing mock leaves no IO-log entry (append happens after the mock returns) — failed calls invisible to assert-io-called. (assert cond) one-arg form works only via the evaluator-wide nil-fill of missing params.

[low] [CONFIRMED] CLAUDE.md points at a deleted canonical spec (shared/sx/ref/*.sx)

• What: CLAUDE.md instructs reading shared/sx/ref/eval.sx/parser.sx/primitives.sx/render.sx as "authoritative SX semantics"; the directory contains only BOUNDARY.md + Python cache. Live spec is spec/*.sx. Together with the island-authoring-rules drift (let/body semantics above), the project docs actively mislead on core semantics.

---

SUSPECTED findings (reasoning only, not reproduced)

[medium] [SUSPECTED] More nested-eval boundaries: expand-macro, sf-let-values, sf-define-values, qq-expand unquotes all evaluate via (trampoline (eval-expr ...)) instead of CEK frames

• Location: spec/evaluator.sx, expand-macro (1548-1580), sf-let-values (1411-1417), sf-define-values (1443-1445), qq-expand unquote eval
• Reasoning: same structural pattern as the three CONFIRMED nested-run bugs (shift-k invoke, threading, signal) — continuation capture, perform/IO suspension, or raise-to-outer-handler inside a macro body, let-values initializer, or unquote crosses a nested trampoline the outer kont cannot see. let-values untestable at runtime (values missing — see medium finding); macro-expansion capture is expansion-time and rare.
• Coverage: not covered.

[low] [SUSPECTED] env_merge is_descendant depth cap (>100) silently flips scoping semantics

• Location: hosts/ocaml/lib/sx_types.ml:394 (if depth > 100 then false)
• Reasoning: call-site env chains deeper than 100 frames false-negative the descendant check, activating the caller-frame-copy branch (the dynamic-scoping leak above) in code that was previously purely lexical. Rare (needs ~100 nested closure/let layers), silent flip. Code-read only.
• Coverage: not covered.

[medium] [SUSPECTED] Canonical serialization is not cross-host deterministic — CIDs can differ between OCaml and JS

• Location: spec/canonical.sx (canonical-number uses host str; string case uses host escape-string)
• Reasoning + partial confirmation: OCaml (canonical-serialize 1e-7) → "1e-07" (verified live) while JS String(1e-7) → "1e-7" (code-read) — different canonical text → different sha3 CIDs for the same value. Also: sx_server escapes \r (sx_server.ml:1275), JS platform does not (platform.py:2628); integers beyond 2^53 exact on OCaml, unrepresentable in JS. Full cross-host CID comparison not run.
• Coverage: test-canonical.sx never canonicalises exponent-form floats, CR strings, or big ints. (Dict-key sorting IS implemented and idempotence holds for tested classes.)

[medium] [SUSPECTED] Coroutine performing a non-yield effect is permanently wedged

• Location: spec/coroutines.sx, coroutine-handle-result — for a suspension with op ≠ "coroutine-yield" it does (perform request): forwards outward but discards both the answer and the coroutine's suspension; state stays "running" and coroutine-resume has no "running" branch → "unexpected state: running"
• Reasoning: code-level; not reproducible outside run_tests (needs cek-step-loop/cek-resume hooks bound only in run_tests.ml:951-955). Correct forwarding would cek-resume the suspension with the outer answer in a loop.
• Coverage: test-coroutines.sx (27 tests) has zero perform usage.

[low] [SUSPECTED] VM/JIT execution path has no strict checking

• Location: sx_vm.ml — zero callers of strict_check_args (repo-wide grep: only sx_ref.ml)
• Reasoning: any call executed as compiled bytecode bypasses checks. Could not confirm live — lazy JIT never engaged in CLI probes (bytecode-inspect after 300 calls: "no compiled bytecode").
• Coverage: not covered.

---

Checked, NOT reproducible (negative results correcting project memory)

• "Short helper names (name/dyad) hang the runtime": does NOT reproduce — (define name …)/(define dyad …) work. The guard case is the unshadowable-name finding (error, not hang).
• "split is char-class not substring": harness/guest-worktree only. Real sx_server (split "a--b" "--") → ("a" "b") substring, keeps empties. Multi-char delimiter untested in spec/tests — worth a pinning test.
• "let is parallel / bodies evaluate only last expr / effects need inner let" (CLAUDE.md island rules): all false for the spec evaluator — let is sequential, bodies are implicit begin (tested intent). Likely describes the separate OCaml SSR island path → doc fix + cross-lane check.

Clean areas verified

CEK core: TCO through all special forms (named-let 200k, mutual 100k, non-tail 100k heap-safe); call/cc escape/multi-shot/independence; shift/reset delimiting + multi-shot composable k; shift without reset → clean error; escape from HO callbacks; multi-shot resume INTO map frames (no accumulator leakage); raise through dynamic-wind one-shot (after exactly once, 50k-frame unwind); (and)/(or)/(begin)/(cond)/if-no-else edge values; cond =>; head-position exprs; parameterize; restart-case/invoke-restart.

Env/scope: closure sharing + isolation both directions; define local-in-lambda vs top-level redefine; set! write-through 1-2 levels; (let ((x x)) x) → outer; letrec mutual recursion (lambda case); emit!/emitted ordering/extent/nesting/TCO-survival/no-leak (correct but ZERO test coverage — gap worth closing given the scope/provide bugs); provide/context/peek normal-flow nesting (well covered); component &rest/kwarg interleaving; component set! does not write back to caller; primitive shadowing works for genuine primitives.

HO forms: HoSetupFrame stages both args exactly once, left-to-right, both orders; map over list-of-functions picks sane reading; guest raise mid-map caught cleanly; some/every?/filter/ for-each/map-indexed semantics sane (0/"" truthy — internally consistent); no double-eval in threading (quoted-value splice protects data both paths); as->; ->> normalizes via swap; nested map-in-map; reduce 100k in 0.3s; multi-map zips to shortest (covered).

Special forms: when/begin/do sequencing; and/or/if falsiness fully consistent (only false/nil falsy); short-circuit verified; defmacro recursive expansion, &rest + ,@ templates, ~name heads in qq; guard happy paths incl. R7RS auto-reraise; ->/set! interplay; eval-rules.sx accurate except set!-error claim, cond clause mode, case evaluated-vals; unless intentionally userland.

Render: text + attr-value escaping correct; raw!/SxExpr single-escape guarantee (no double- escape); registered void elements self-close, drop children silently; boolean-attr registry (23) correct for true/false/nil; numbers/booleans/nil as children; aser wire semantics (components unexpanded, control flow evaluated, string/dict args round-trip incl. quotes/unicode); recursive- with-base-case components; fragment/nil/string/number component returns; &rest spliced flat.

Primitives: quotient/remainder/modulo signs R7RS-correct; substring clamping; replace; trim/index-of/starts-with?/ends-with?; assoc/dissoc/merge/has-key?; range/flatten/chunk-every; rationals (normalization, contagion, zero-denominator errors); vectors/sets/ports/chars/string- buffers basics; dict-set! vs assoc; truthiness consistent; format directives; max/min zero-arg errors clean. Not probed (dedicated green suites): zip-pairs, bitwise, bytevectors, regexp.

Parser/serializer: basic escapes correct + exact round-trips (quotes/backslashes/newlines/ multibyte strings); quote sugar nesting incl. before )/EOF; 10k-deep nesting + 10k-char tokens parse fine (heap frames, no hangs on any adversarial input — every failure errors rather than loops); serializer round-trips for number/keyword/symbol/list/nested-dict(ident keys)/bool/nil; nil vs () vs {} distinct; canonical-dict key sorting + idempotence (tested classes); -0.0 → "0"; negative numbers vs - symbol; 5./1e10/-1.5e-3; comments at EOF; dotted pairs cleanly rejected on all hosts; keyword AST round-trip.

Strict typing: value-matches-type? core semantics correct (number/string/boolean/nil/list/ dict; empty list not a dict; nullability exclusively via "type?" suffix — consistent; floats+ints both "number"; quoted symbols; lambdas). ->/->> threading IS strict-checked (re-dispatches a real call form). Recovery after a strict error works. Error messages high quality.

Signals: effect does not re-run on unrelated signals; effect's dispose-fn unsubscribes correctly; batch dedups multiple resets of one signal (when it works — see wedge finding).

Harness (spec/harness.sx): interceptors log args/result/op correctly; arity fan-out 0-3 + apply; custom-platform merge over defaults; assertion messages descriptive.

---

Handoffs to other lanes

• HOSTS: hosts/ocaml/bin/mcp_tree.ml maintains its own primitive table, drifted from sx_primitives.ml (empty?/get/split/contains?/equal?/keyword-name differ — details in the harness-divergence finding). Also: sx_harness_eval is a shared persistent image, not a fresh sandbox; sx_read_subtree ignores path; sx_read_tree ignores max_lines.
• HOSTS/CONFORMANCE — JIT vs interpreter divergence: three confirmed behavior flips between VM-compiled and interpreted paths: (1) set!-unbound writes vm.globals vs root env (split brain); (2) env_merge caller-frame leak exists only interpreted ("VM undefined" under JIT); (3) named-let leaked loop name reads as lambda interpreted / nil under JIT. Parity suite has no coverage.
• HOSTS (Python shell): aser output embedded into <script> via json.dumps in shared/sx/helpers.py sx_streaming_resolve_script — json.dumps doesn't escape / or <; check whether serialized SX can ever contain </script> (aser HTML-escapes text children, but attr/raw paths unverified).
• CONFORMANCE: run_tests.ml injects bindings absent from the real runtime — values/ call-with-values (test-values.sx), contains-char?/trim-right (canonical.sx), batch-begin!/batch-end! (signals), cek-step-loop/cek-resume (coroutines). Whole suites are green only in-runner; test-env vs runtime-env parity needs a systematic sweep.
• CONFORMANCE — parser fleet: three parser implementations (native OCaml reader, spec guest parser over per-host primitive bindings, JS transpiled spec) with four ident/number classifier tables that were never reconciled (details in the AST-divergence finding). Guest-parser platform primitives (parse-number, char-code, contains-char?, trim-right, reader-macro-get, escape-string) drift per host because each host re-binds them ad hoc. Suites only exercise the intersection — that's why everything stays 1080/1080 green.
• HOSTS (JS): JS parser silently corrupts invalid \uXXXX escapes (garbage string, no error) where OCaml raises; JS reader-macro-get registry exists but OCaml's doesn't.
• DOCS: CLAUDE.md island-authoring rules describe non-spec semantics (parallel let, last-expr bodies); CLAUDE.md canonical-reference section points at deleted files.
• TOOLING incident log: mid-review another session polluted the shared MCP image (inc redefined to a constant, breaking guest parsing with spurious "Unterminated" errors); the parser agent restored it. Underlines the harness-not-fresh finding — harness state is shared across concurrent sessions.