radar: pass 18 — W1 re-test: events 5th federation consumer (agenda merge, runtime-list trust like mod); inject-fed-sx seam now 5/5

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

.claude/scheduled_tasks.lock

@@ -1 +1 @@
-{"sessionId":"31c80255-eb92-43e4-8997-84ad84e27326","pid":90960,"procStart":"564684","acquiredAt":1777049890282}
+{"sessionId":"bf20a443-9df8-4cb9-932e-8c6f4c4625c2","pid":1303602,"procStart":"253831081","acquiredAt":1779865895644}

.mcp.json

@@ -2,7 +2,7 @@
   "mcpServers": {
     "sx-tree": {
       "type": "stdio",
-      "command": "./hosts/ocaml/_build/default/bin/mcp_tree.exe"
+      "command": "/root/rose-ash/hosts/ocaml/_build/default/bin/mcp_tree.exe"
     },
     "rose-ash-services": {
       "type": "stdio",

lib/apl/conformance.conf

@@ -0,0 +1,63 @@
+# APL conformance config — sourced by lib/guest/conformance.sh.
+
+LANG_NAME=apl
+MODE=counters
+COUNTERS_PASS=apl-test-pass
+COUNTERS_FAIL=apl-test-fail
+TIMEOUT_PER_SUITE=300
+
+PRELOADS=(
+  spec/stdlib.sx
+  lib/r7rs.sx
+  lib/apl/runtime.sx
+  lib/apl/tokenizer.sx
+  lib/apl/parser.sx
+  lib/apl/transpile.sx
+  lib/apl/test-harness.sx
+)
+
+SUITES=(
+  "structural:lib/apl/tests/structural.sx"
+  "operators:lib/apl/tests/operators.sx"
+  "dfn:lib/apl/tests/dfn.sx"
+  "tradfn:lib/apl/tests/tradfn.sx"
+  "valence:lib/apl/tests/valence.sx"
+  "programs:lib/apl/tests/programs.sx"
+  "system:lib/apl/tests/system.sx"
+  "idioms:lib/apl/tests/idioms.sx"
+  "eval-ops:lib/apl/tests/eval-ops.sx"
+  "pipeline:lib/apl/tests/pipeline.sx"
+)
+
+emit_scoreboard_json() {
+  local n=${#GC_NAMES[@]} i sep
+  printf '{\n'
+  printf '  "suites": {\n'
+  for ((i=0; i<n; i++)); do
+    sep=","; [ $i -eq $((n-1)) ] && sep=""
+    printf '    "%s": {"pass": %d, "fail": %d}%s\n' \
+      "${GC_NAMES[$i]}" "${GC_PASS[$i]}" "${GC_FAIL[$i]}" "$sep"
+  done
+  printf '  },\n'
+  printf '  "total_pass": %d,\n' "$GC_TOTAL_PASS"
+  printf '  "total_fail": %d,\n' "$GC_TOTAL_FAIL"
+  printf '  "total": %d\n' "$GC_TOTAL"
+  printf '}\n'
+}
+
+emit_scoreboard_md() {
+  local n=${#GC_NAMES[@]} i
+  printf '# APL Conformance Scoreboard\n\n'
+  printf '_Generated by `lib/apl/conformance.sh`_\n\n'
+  printf '| Suite | Pass | Fail | Total |\n'
+  printf '|-------|-----:|-----:|------:|\n'
+  for ((i=0; i<n; i++)); do
+    printf '| %s | %d | %d | %d |\n' \
+      "${GC_NAMES[$i]}" "${GC_PASS[$i]}" "${GC_FAIL[$i]}" "${GC_TOTAL_S[$i]}"
+  done
+  printf '| **Total** | **%d** | **%d** | **%d** |\n' "$GC_TOTAL_PASS" "$GC_TOTAL_FAIL" "$GC_TOTAL"
+  printf '\n'
+  printf '## Notes\n\n'
+  printf '%s\n' '- Suites use the standard `apl-test name got expected` framework loaded against `lib/apl/runtime.sx` + `lib/apl/transpile.sx`.'
+  printf '%s\n' '- `lib/apl/tests/parse.sx` and `lib/apl/tests/scalar.sx` use their own self-contained frameworks and are excluded from this scoreboard.'
+}

lib/apl/conformance.sh

@@ -1,116 +1,5 @@
 #!/usr/bin/env bash
-# lib/apl/conformance.sh — run APL test suites, emit scoreboard.json + scoreboard.md.
-
-set -uo pipefail
-cd "$(git rev-parse --show-toplevel)"
-
-SX_SERVER="${SX_SERVER:-/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe}"
-if [ ! -x "$SX_SERVER" ]; then
-  SX_SERVER="hosts/ocaml/_build/default/bin/sx_server.exe"
-fi
-if [ ! -x "$SX_SERVER" ]; then
-  echo "ERROR: sx_server.exe not found." >&2
-  exit 1
-fi
-
-SUITES=(structural operators dfn tradfn valence programs system idioms eval-ops pipeline)
-
-OUT_JSON="lib/apl/scoreboard.json"
-OUT_MD="lib/apl/scoreboard.md"
-
-run_suite() {
-  local suite=$1
-  local file="lib/apl/tests/${suite}.sx"
-  local TMP
-  TMP=$(mktemp)
-  cat > "$TMP" << EPOCHS
-(epoch 1)
-(load "spec/stdlib.sx")
-(load "lib/r7rs.sx")
-(load "lib/apl/runtime.sx")
-(load "lib/apl/tokenizer.sx")
-(load "lib/apl/parser.sx")
-(load "lib/apl/transpile.sx")
-(epoch 2)
-(eval "(define apl-test-pass 0)")
-(eval "(define apl-test-fail 0)")
-(eval "(define apl-test (fn (name got expected) (if (= got expected) (set! apl-test-pass (+ apl-test-pass 1)) (set! apl-test-fail (+ apl-test-fail 1)))))")
-(epoch 3)
-(load "${file}")
-(epoch 4)
-(eval "(list apl-test-pass apl-test-fail)")
-EPOCHS
-
-  local OUTPUT
-  OUTPUT=$(timeout 300 "$SX_SERVER" < "$TMP" 2>/dev/null)
-  rm -f "$TMP"
-
-  local LINE
-  LINE=$(echo "$OUTPUT" | awk '/^\(ok-len 4 / {getline; print; exit}')
-  if [ -z "$LINE" ]; then
-    LINE=$(echo "$OUTPUT" | grep -E '^\(ok 4 \([0-9]+ [0-9]+\)\)' | tail -1 \
-            | sed -E 's/^\(ok 4 //; s/\)$//')
-  fi
-
-  local P F
-  P=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\1/')
-  F=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\2/')
-  P=${P:-0}
-  F=${F:-0}
-  echo "${P} ${F}"
-}
-
-declare -A SUITE_PASS
-declare -A SUITE_FAIL
-TOTAL_PASS=0
-TOTAL_FAIL=0
-
-echo "Running APL conformance suite..." >&2
-for s in "${SUITES[@]}"; do
-  read -r p f < <(run_suite "$s")
-  SUITE_PASS[$s]=$p
-  SUITE_FAIL[$s]=$f
-  TOTAL_PASS=$((TOTAL_PASS + p))
-  TOTAL_FAIL=$((TOTAL_FAIL + f))
-  printf "  %-12s %d/%d\n" "$s" "$p" "$((p+f))" >&2
-done
-
-# scoreboard.json
-{
-  printf '{\n'
-  printf '  "suites": {\n'
-  first=1
-  for s in "${SUITES[@]}"; do
-    if [ $first -eq 0 ]; then printf ',\n'; fi
-    printf '    "%s": {"pass": %d, "fail": %d}' "$s" "${SUITE_PASS[$s]}" "${SUITE_FAIL[$s]}"
-    first=0
-  done
-  printf '\n  },\n'
-  printf '  "total_pass": %d,\n' "$TOTAL_PASS"
-  printf '  "total_fail": %d,\n' "$TOTAL_FAIL"
-  printf '  "total": %d\n' "$((TOTAL_PASS + TOTAL_FAIL))"
-  printf '}\n'
-} > "$OUT_JSON"
-
-# scoreboard.md
-{
-  printf '# APL Conformance Scoreboard\n\n'
-  printf '_Generated by `lib/apl/conformance.sh`_\n\n'
-  printf '| Suite | Pass | Fail | Total |\n'
-  printf '|-------|-----:|-----:|------:|\n'
-  for s in "${SUITES[@]}"; do
-    p=${SUITE_PASS[$s]}
-    f=${SUITE_FAIL[$s]}
-    printf '| %s | %d | %d | %d |\n' "$s" "$p" "$f" "$((p+f))"
-  done
-  printf '| **Total** | **%d** | **%d** | **%d** |\n' "$TOTAL_PASS" "$TOTAL_FAIL" "$((TOTAL_PASS + TOTAL_FAIL))"
-  printf '\n'
-  printf '## Notes\n\n'
-  printf '%s\n' '- Suites use the standard `apl-test name got expected` framework loaded against `lib/apl/runtime.sx` + `lib/apl/transpile.sx`.'
-  printf '%s\n' '- `lib/apl/tests/parse.sx` and `lib/apl/tests/scalar.sx` use their own self-contained frameworks and are excluded from this scoreboard.'
-} > "$OUT_MD"
-
-echo "Wrote $OUT_JSON and $OUT_MD" >&2
-echo "Total: $TOTAL_PASS pass, $TOTAL_FAIL fail" >&2
-
-[ "$TOTAL_FAIL" -eq 0 ]
+# lib/apl/conformance.sh — APL conformance via the shared guest driver.
+# Config lives in lib/apl/conformance.conf (MODE=counters). Override the binary
+# with SX_SERVER=path/to/sx_server.exe bash lib/apl/conformance.sh
+exec bash "$(dirname "$0")/../guest/conformance.sh" "$(dirname "$0")/conformance.conf" "$@"

lib/apl/scoreboard.json

@@ -9,9 +9,9 @@
     "system": {"pass": 13, "fail": 0},
     "idioms": {"pass": 64, "fail": 0},
     "eval-ops": {"pass": 14, "fail": 0},
-    "pipeline": {"pass": 40, "fail": 0}
+    "pipeline": {"pass": 152, "fail": 0}
   },
-  "total_pass": 450,
+  "total_pass": 562,
   "total_fail": 0,
-  "total": 450
+  "total": 562
 }

lib/apl/scoreboard.md

@@ -13,8 +13,8 @@ _Generated by `lib/apl/conformance.sh`_
 | system | 13 | 0 | 13 |
 | idioms | 64 | 0 | 64 |
 | eval-ops | 14 | 0 | 14 |
-| pipeline | 40 | 0 | 40 |
-| **Total** | **450** | **0** | **450** |
+| pipeline | 152 | 0 | 152 |
+| **Total** | **562** | **0** | **562** |
 
 ## Notes
 

lib/apl/test-harness.sx

@@ -0,0 +1,15 @@
+; lib/apl/test-harness.sx — counters + assertion fn for the shared conformance
+; driver (lib/guest/conformance.sh, MODE=counters). Loaded as a PRELOAD so each
+; suite starts from a fresh 0/0; suites call (apl-test name got expected).
+
+(define apl-test-pass 0)
+(define apl-test-fail 0)
+
+(define
+  apl-test
+  (fn
+    (name got expected)
+    (if
+      (= got expected)
+      (set! apl-test-pass (+ apl-test-pass 1))
+      (set! apl-test-fail (+ apl-test-fail 1)))))

lib/feed/acl.sx

@@ -0,0 +1,38 @@
+; feed/acl — per-viewer visibility filtering. The same candidate stream yields
+; different timelines for different viewers, so ACL is applied per request and
+; pre-ACL timelines are never cached.
+;
+; permit? is injected: (permit? viewer activity) -> bool. Wire a real acl-sx
+; predicate here; feed/permit-acl? is a self-contained default that reads an
+; optional :visible-to allowlist on the activity.
+;
+; Requires: lib/feed/normalize.sx, lib/feed/stream.sx, lib/feed/fanout.sx
+; (feed/-elem?), lib/feed/rank.sx (feed/top).
+
+; default permit: actor always sees own activity; absent/nil :visible-to is
+; public; otherwise viewer must be in the allowlist.
+(define
+  feed/permit-acl?
+  (fn
+    (viewer a)
+    (or
+      (equal? viewer (get a :actor))
+      (let
+        ((allowed (get a :visible-to nil)))
+        (if (= allowed nil) true (feed/-elem? viewer allowed))))))
+
+(define feed/permit-public? (fn (viewer a) true))
+
+; filter a stream to what viewer may read
+(define
+  feed/visible
+  (fn
+    (stream viewer permit?)
+    (feed/filter stream (fn (a) (permit? viewer a)))))
+
+; the capstone: candidate stream -> ACL for viewer -> rank -> top-N
+(define
+  feed/timeline
+  (fn
+    (stream viewer permit? score-fn n)
+    (feed/top (feed/visible stream viewer permit?) score-fn n)))

lib/feed/aggregate.sx

@@ -0,0 +1,62 @@
+; feed/aggregate — group-by / counting via key-reduce. Keys must be strings
+; (dict keys), so composite keys (actor, day) are joined into one string.
+;
+; Requires: lib/feed/normalize.sx, lib/feed/stream.sx.
+
+; group activities into a dict: key-string -> (list of activities), order-preserving
+(define
+  feed/group-by
+  (fn
+    (stream key-fn)
+    (reduce
+      (fn
+        (g a)
+        (let
+          ((k (key-fn a)))
+          (assoc g k (append (get g k (list)) (list a)))))
+      {}
+      (feed/items stream))))
+
+; key-string -> count
+(define
+  feed/group-count
+  (fn
+    (stream key-fn)
+    (reduce
+      (fn
+        (g a)
+        (let
+          ((k (key-fn a)))
+          (assoc g k (+ (get g k 0) 1))))
+      {}
+      (feed/items stream))))
+
+; --- composite keys ---------------------------------------------------------
+
+(define feed/day (fn (at window) (floor (/ at window))))
+
+; (actor, day-bucket) -> "actor#day"
+(define
+  feed/actor-day-key
+  (fn
+    (window)
+    (fn
+      (a)
+      (string-append
+        (get a :actor)
+        "#"
+        (number->string (feed/day (get a :at) window))))))
+
+(define
+  feed/by-actor-day
+  (fn (stream window) (feed/group-count stream (feed/actor-day-key window))))
+
+; per-actor activity counts
+(define
+  feed/actor-counts
+  (fn (stream) (feed/group-count stream feed/actor)))
+
+; per-object activity counts (engagement)
+(define
+  feed/object-counts
+  (fn (stream) (feed/group-count stream feed/object)))

lib/feed/api.sx

@@ -0,0 +1,24 @@
+; feed/api — ergonomic API over the stream layer for non-APL callers.
+; A single mutable activity log; post appends, all returns it as a stream.
+;
+; Requires: lib/feed/normalize.sx, lib/feed/stream.sx (loaded by harness).
+
+(define feed/-log (list))
+
+; post — normalize then append. Returns the stored activity.
+(define
+  feed/post
+  (fn
+    (raw)
+    (let
+      ((a (feed/normalize raw)))
+      (begin (set! feed/-log (append feed/-log (list a))) a))))
+
+; all — the whole log as a stream (insertion order)
+(define feed/all (fn () (feed/stream feed/-log)))
+
+; reset! — clear the log (test hygiene)
+(define feed/reset! (fn () (begin (set! feed/-log (list)) nil)))
+
+; size — number of posted activities
+(define feed/size (fn () (len feed/-log)))

lib/feed/conformance.sh

@@ -0,0 +1,125 @@
+#!/usr/bin/env bash
+# lib/feed/conformance.sh — run feed test suites, emit scoreboard.json + scoreboard.md.
+
+set -uo pipefail
+cd "$(git rev-parse --show-toplevel)"
+
+SX_SERVER="${SX_SERVER:-/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe}"
+if [ ! -x "$SX_SERVER" ]; then
+  SX_SERVER="hosts/ocaml/_build/default/bin/sx_server.exe"
+fi
+if [ ! -x "$SX_SERVER" ]; then
+  echo "ERROR: sx_server.exe not found." >&2
+  exit 1
+fi
+
+SUITES=(basic fanout rank integration content notify home dedupe trending mute page thread)
+
+OUT_JSON="lib/feed/scoreboard.json"
+OUT_MD="lib/feed/scoreboard.md"
+
+run_suite() {
+  local suite=$1
+  local file="lib/feed/tests/${suite}.sx"
+  local TMP
+  TMP=$(mktemp)
+  cat > "$TMP" << EPOCHS
+(epoch 1)
+(load "spec/stdlib.sx")
+(load "lib/r7rs.sx")
+(load "lib/apl/runtime.sx")
+(load "lib/feed/normalize.sx")
+(load "lib/feed/stream.sx")
+(load "lib/feed/api.sx")
+(load "lib/feed/fanout.sx")
+(load "lib/feed/dedupe.sx")
+(load "lib/feed/aggregate.sx")
+(load "lib/feed/rank.sx")
+(load "lib/feed/acl.sx")
+(load "lib/feed/fed.sx")
+(load "lib/feed/content.sx")
+(load "lib/feed/notify.sx")
+(load "lib/feed/home.sx")
+(load "lib/feed/trending.sx")
+(load "lib/feed/mute.sx")
+(load "lib/feed/page.sx")
+(load "lib/feed/thread.sx")
+(epoch 2)
+(eval "(define feed-test-pass 0)")
+(eval "(define feed-test-fail 0)")
+(eval "(define feed-test (fn (name got expected) (if (= got expected) (set! feed-test-pass (+ feed-test-pass 1)) (set! feed-test-fail (+ feed-test-fail 1)))))")
+(epoch 3)
+(load "${file}")
+(epoch 4)
+(eval "(list feed-test-pass feed-test-fail)")
+EPOCHS
+
+  local OUTPUT
+  OUTPUT=$(timeout 300 "$SX_SERVER" < "$TMP" 2>/dev/null)
+  rm -f "$TMP"
+
+  local LINE
+  LINE=$(echo "$OUTPUT" | awk '/^\(ok-len 4 / {getline; print; exit}')
+  if [ -z "$LINE" ]; then
+    LINE=$(echo "$OUTPUT" | grep -E '^\(ok 4 \([0-9]+ [0-9]+\)\)' | tail -1 \
+            | sed -E 's/^\(ok 4 //; s/\)$//')
+  fi
+
+  local P F
+  P=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\1/')
+  F=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\2/')
+  P=${P:-0}
+  F=${F:-0}
+  echo "${P} ${F}"
+}
+
+declare -A SUITE_PASS
+declare -A SUITE_FAIL
+TOTAL_PASS=0
+TOTAL_FAIL=0
+
+echo "Running feed conformance suite..." >&2
+for s in "${SUITES[@]}"; do
+  read -r p f < <(run_suite "$s")
+  SUITE_PASS[$s]=$p
+  SUITE_FAIL[$s]=$f
+  TOTAL_PASS=$((TOTAL_PASS + p))
+  TOTAL_FAIL=$((TOTAL_FAIL + f))
+  printf "  %-12s %d/%d\n" "$s" "$p" "$((p+f))" >&2
+done
+
+# scoreboard.json
+{
+  printf '{\n'
+  printf '  "suites": {\n'
+  first=1
+  for s in "${SUITES[@]}"; do
+    if [ $first -eq 0 ]; then printf ',\n'; fi
+    printf '    "%s": {"pass": %d, "fail": %d}' "$s" "${SUITE_PASS[$s]}" "${SUITE_FAIL[$s]}"
+    first=0
+  done
+  printf '\n  },\n'
+  printf '  "total_pass": %d,\n' "$TOTAL_PASS"
+  printf '  "total_fail": %d,\n' "$TOTAL_FAIL"
+  printf '  "total": %d\n' "$((TOTAL_PASS + TOTAL_FAIL))"
+  printf '}\n'
+} > "$OUT_JSON"
+
+# scoreboard.md
+{
+  printf '# feed Conformance Scoreboard\n\n'
+  printf '_Generated by `lib/feed/conformance.sh`_\n\n'
+  printf '| Suite | Pass | Fail | Total |\n'
+  printf '|-------|-----:|-----:|------:|\n'
+  for s in "${SUITES[@]}"; do
+    p=${SUITE_PASS[$s]}
+    f=${SUITE_FAIL[$s]}
+    printf '| %s | %d | %d | %d |\n' "$s" "$p" "$f" "$((p+f))"
+  done
+  printf '| **Total** | **%d** | **%d** | **%d** |\n' "$TOTAL_PASS" "$TOTAL_FAIL" "$((TOTAL_PASS + TOTAL_FAIL))"
+} > "$OUT_MD"
+
+echo "Wrote $OUT_JSON and $OUT_MD" >&2
+echo "Total: $TOTAL_PASS pass, $TOTAL_FAIL fail" >&2
+
+[ "$TOTAL_FAIL" -eq 0 ]

lib/feed/content.sx

@@ -0,0 +1,68 @@
+; feed/content — TF-IDF relevance over activity :tags. Rare tags carry more
+; signal, so an activity matching an uncommon tag ranks above one matching a
+; common tag. Composes with rank.sx: feed/tfidf-score is just another scorer.
+;
+; Requires: lib/feed/normalize.sx, lib/feed/stream.sx, lib/feed/fanout.sx
+; (feed/-distinct), lib/feed/rank.sx (feed/rank).
+
+; document frequency: tag -> number of activities whose :tags contain it
+; (a tag repeated within one activity counts once toward df)
+(define
+  feed/tag-df
+  (fn
+    (stream)
+    (reduce
+      (fn
+        (df a)
+        (reduce
+          (fn (d t) (assoc d t (+ (get d t 0) 1)))
+          df
+          (feed/-distinct (get a :tags))))
+      {}
+      (feed/items stream))))
+
+; inverse document frequency: tag -> log(N / df)
+(define
+  feed/tag-idf
+  (fn
+    (stream)
+    (let
+      ((n (feed/count stream)) (df (feed/tag-df stream)))
+      (reduce
+        (fn (idf t) (assoc idf t (log (/ n (get df t)))))
+        {}
+        (keys df)))))
+
+; term frequency within one activity: tag -> occurrence count
+(define
+  feed/-tf
+  (fn
+    (a)
+    (reduce
+      (fn (tf t) (assoc tf t (+ (get tf t 0) 1)))
+      {}
+      (get a :tags))))
+
+; relevance of an activity to a query (list of tags) given precomputed idf:
+; sum over query tags of tf(tag in activity) * idf(tag in corpus)
+(define
+  feed/tfidf-score
+  (fn
+    (idf query)
+    (fn
+      (a)
+      (let
+        ((tf (feed/-tf a)))
+        (reduce
+          (fn
+            (acc t)
+            (+ acc (* (get tf t 0) (get idf t 0))))
+          0
+          query)))))
+
+; rank a stream by relevance to query tags (idf computed over the stream itself)
+(define
+  feed/by-relevance
+  (fn
+    (stream query)
+    (feed/rank stream (feed/tfidf-score (feed/tag-idf stream) query))))

lib/feed/dedupe.sx

@@ -0,0 +1,76 @@
+; feed/dedupe — collapse duplicate items, keeping first occurrence per key.
+; Each verb may want its own key (see briefing): "alice posted X" keys on
+; (actor verb object) — distinct per actor; "alice liked X / bob liked X"
+; collapse on (verb object) so the cross-actor likes fold into one.
+;
+; Requires: lib/feed/normalize.sx, lib/feed/stream.sx, lib/feed/fanout.sx
+; (feed/-elem? lives in fanout.sx).
+
+; generic: dedupe a stream by key-fn, first occurrence wins (stable)
+(define
+  feed/-dedup-by
+  (fn
+    (items key-fn)
+    (get
+      (reduce
+        (fn
+          (st x)
+          (let
+            ((k (key-fn x)))
+            (if (feed/-elem? k (get st :seen)) st {:seen (append (get st :seen) (list k)) :out (append (get st :out) (list x))})))
+        {:seen (list) :out (list)}
+        items)
+      :out)))
+
+(define
+  feed/dedupe
+  (fn
+    (stream key-fn)
+    (feed/stream (feed/-dedup-by (feed/items stream) key-fn))))
+
+; --- keys -------------------------------------------------------------------
+
+(define
+  feed/activity-key
+  (fn (a) (list (get a :actor) (get a :verb) (get a :object))))
+
+; collapse cross-actor duplicates of the same verb+object (e.g. likes)
+(define feed/collapse-key (fn (a) (list (get a :verb) (get a :object))))
+
+; per-receiver inbox key — one inbox event per (receiver, actor, verb, object)
+(define
+  feed/event-key
+  (fn
+    (ev)
+    (let
+      ((a (get ev :activity)))
+      (list (get ev :to) (get a :actor) (get a :verb) (get a :object)))))
+
+; verbs whose duplicates collapse across actors (reactions, not authorship).
+; rebindable: callers can (set! feed/collapse-verbs ...) to tune the policy.
+(define
+  feed/collapse-verbs
+  (list "like" "favourite" "follow" "boost" "repost"))
+
+; per-verb key: collapse-verbs fold on (verb object); the rest key on
+; (actor verb object).
+(define
+  feed/smart-key
+  (fn
+    (a)
+    (if
+      (feed/-elem? (get a :verb) feed/collapse-verbs)
+      (feed/collapse-key a)
+      (feed/activity-key a))))
+
+; --- ready-made dedupers ----------------------------------------------------
+
+(define feed/dedupe-activities (fn (s) (feed/dedupe s feed/activity-key)))
+
+(define feed/dedupe-collapse (fn (s) (feed/dedupe s feed/collapse-key)))
+
+; verb-aware: reactions collapse cross-actor, posts stay distinct per actor
+(define feed/dedupe-smart (fn (s) (feed/dedupe s feed/smart-key)))
+
+; dedupe an inbox: at most one event per receiver per (actor verb object)
+(define feed/dedupe-inbox (fn (inbox) (feed/dedupe inbox feed/event-key)))

lib/feed/fanout.sx

@@ -0,0 +1,114 @@
+; feed/fanout — THE SHOWCASE. Fan activities out to followers via the APL outer
+; product (∘.×). activities ∘.× audience → an (activity × follower) matrix of
+; inbox events; flatten to a vector; guard-keep only real follow edges.
+;
+; Requires: lib/apl/runtime.sx, lib/feed/normalize.sx, lib/feed/stream.sx.
+;
+; NOTE: apl-outer's combiner result is run through (if (scalar? r) (disclose r) r).
+; A bare dict counts as a scalar (shape ()) and disclose nils it — so the combiner
+; must (enclose ...) its event dict; apl-outer then discloses it back intact.
+
+; --- graph: {followee -> (list of followers)} -------------------------------
+
+(define feed/followers (fn (graph user) (get graph user (list))))
+
+; build a graph from (follower followee) edges: "follower follows followee"
+(define
+  feed/follow-graph
+  (fn
+    (edges)
+    (reduce
+      (fn
+        (g e)
+        (let
+          ((follower (first e)) (followee (nth e 1)))
+          (assoc
+            g
+            followee
+            (append (feed/followers g followee) (list follower)))))
+      {}
+      edges)))
+
+; --- helpers ----------------------------------------------------------------
+
+; unwrap an apl-scalar (has :ravel) back to its value; pass activities through
+(define
+  feed/-val
+  (fn
+    (x)
+    (if (and (= (type-of x) "dict") (has-key? x :ravel)) (disclose x) x)))
+
+(define feed/-elem? (fn (x lst) (some (fn (y) (equal? x y)) lst)))
+
+(define
+  feed/-distinct
+  (fn
+    (lst)
+    (if
+      (= (len lst) 0)
+      (list)
+      (get (apl-unique (make-array (list (len lst)) lst)) :ravel))))
+
+; rank-2 matrix -> rank-1 stream of its ravel
+(define feed/-flatten (fn (arr) (feed/stream (get arr :ravel))))
+
+; distinct receivers across the whole graph, sorted for determinism
+; (dict key order is unspecified, so sort to pin audience/recipient ordering)
+(define
+  feed/audience
+  (fn
+    (graph)
+    (sort
+      (feed/-distinct
+        (reduce
+          (fn (acc k) (append acc (feed/followers graph k)))
+          (list)
+          (keys graph))))))
+
+; --- the outer product ------------------------------------------------------
+
+; one (activity, follower) inbox event, enclosed so apl-outer keeps the dict
+(define feed/-mk-event (fn (a f) (enclose {:activity (feed/-val a) :to (feed/-val f)})))
+
+; keep events where :to actually follows the activity's actor
+(define
+  feed/-edge?
+  (fn
+    (graph)
+    (fn
+      (ev)
+      (feed/-elem?
+        (get ev :to)
+        (feed/followers graph (get (get ev :activity) :actor))))))
+
+; fanout — activities ∘.× audience, flatten, guard-keep real edges
+(define
+  feed/fanout
+  (fn
+    (stream graph)
+    (let
+      ((matrix (apl-outer feed/-mk-event stream (feed/stream (feed/audience graph)))))
+      (feed/filter (feed/-flatten matrix) (feed/-edge? graph)))))
+
+; --- inbox queries ----------------------------------------------------------
+
+(define
+  feed/inbox-for
+  (fn
+    (inbox user)
+    (feed/filter inbox (fn (ev) (equal? (get ev :to) user)))))
+
+(define
+  feed/recipients
+  (fn
+    (inbox)
+    (feed/-distinct (map (fn (ev) (get ev :to)) (feed/items inbox)))))
+
+; the activities (unwrapped) destined for a user
+(define
+  feed/inbox-activities
+  (fn
+    (inbox user)
+    (map
+      (fn (ev) (get ev :activity))
+      (feed/items (feed/inbox-for inbox user)))))

lib/feed/fed.sx

@@ -0,0 +1,60 @@
+; feed/fed — federation. Outbound: a local post fans out, then splits into local
+; vs remote inboxes; remote events are handed to an injected send-fn. Inbound:
+; peer activities merge into the local stream, deduped. Backfill: pull peer
+; history via an injected fetch-fn and merge.
+;
+; remote? / send-fn / fetch-fn are injected so real fed-sx transport wires in here
+; without feed depending on it.
+;
+; Requires: lib/feed/normalize.sx, lib/feed/stream.sx, lib/feed/fanout.sx,
+; lib/feed/dedupe.sx.
+
+; --- merge / ingest ---------------------------------------------------------
+
+(define
+  feed/merge
+  (fn (s1 s2) (feed/stream (append (feed/items s1) (feed/items s2)))))
+
+; merge a peer stream into local, dropping (actor verb object) duplicates
+(define
+  feed/ingest
+  (fn (local peer) (feed/dedupe-activities (feed/merge local peer))))
+
+; --- inbound ----------------------------------------------------------------
+
+; peer pushes raw activities to the local inbox; normalize + ingest
+(define
+  feed/inbound
+  (fn
+    (local raw-activities)
+    (feed/ingest local (feed/stream (map feed/normalize raw-activities)))))
+
+; backfill on subscribe: pull peer history via fetch-fn, normalize, ingest
+(define
+  feed/backfill
+  (fn (local fetch-fn peer-id) (feed/inbound local (fetch-fn peer-id))))
+
+; --- outbound ---------------------------------------------------------------
+
+; split an inbox into local vs remote deliveries by viewer-id predicate
+(define feed/partition-inbox (fn (inbox remote?) {:local (feed/filter inbox (fn (ev) (not (remote? (get ev :to))))) :remote (feed/filter inbox (fn (ev) (remote? (get ev :to))))}))
+
+; fan a stream out over the graph, then partition by locality
+(define
+  feed/federate
+  (fn
+    (stream graph remote?)
+    (feed/partition-inbox (feed/fanout stream graph) remote?)))
+
+; deliver: hand each remote event to send-fn, return the local inbox to enqueue
+(define
+  feed/deliver
+  (fn
+    (stream graph remote? send-fn)
+    (let
+      ((parts (feed/federate stream graph remote?)))
+      (begin
+        (for-each
+          (fn (ev) (send-fn (get ev :to) (get ev :activity)))
+          (feed/items (get parts :remote)))
+        (get parts :local)))))

lib/feed/home.sx

@@ -0,0 +1,23 @@
+; feed/home — the capstone. A user's home timeline is the whole pipeline as one
+; line: fan all activities out over the follow graph, take the events landing in
+; the viewer's inbox, dedupe cross-posts, apply the viewer's ACL, rank, take N.
+;
+; Requires: fanout.sx, dedupe.sx, acl.sx (feed/timeline), rank.sx, stream.sx.
+
+; the activities in a user's inbox, as a stream
+(define
+  feed/inbox-stream
+  (fn (inbox user) (feed/stream (feed/inbox-activities inbox user))))
+
+; fanout ∘ inbox ∘ dedupe ∘ ACL ∘ rank ∘ take
+(define
+  feed/home
+  (fn
+    (stream graph viewer permit? score-fn n)
+    (feed/timeline
+      (feed/dedupe-activities
+        (feed/inbox-stream (feed/fanout stream graph) viewer))
+      viewer
+      permit?
+      score-fn
+      n)))

lib/feed/mute.sx

@@ -0,0 +1,44 @@
+; feed/mute — viewer-controlled filtering. ACL (acl.sx) is author-controlled
+; visibility; mute is the reader's own preference: hide muted actors or tags.
+; Like ACL it is per-viewer and applied per request, never cached.
+;
+; Requires: lib/feed/normalize.sx, lib/feed/stream.sx, lib/feed/fanout.sx
+; (feed/-elem?).
+
+; drop activities authored by a muted actor
+(define
+  feed/mute-actors
+  (fn
+    (stream actors)
+    (feed/filter
+      stream
+      (fn (a) (not (feed/-elem? (get a :actor) actors))))))
+
+; drop activities carrying any muted tag
+(define
+  feed/mute-tags
+  (fn
+    (stream tags)
+    (feed/filter
+      stream
+      (fn (a) (not (some (fn (t) (feed/-elem? t tags)) (get a :tags)))))))
+
+; drop activities about a muted object (thread mute)
+(define
+  feed/mute-objects
+  (fn
+    (stream objects)
+    (feed/filter
+      stream
+      (fn (a) (not (feed/-elem? (get a :object) objects))))))
+
+; apply a viewer preference bag: {:mute-actors (...) :mute-tags (...) :mute-objects (...)}
+(define
+  feed/apply-prefs
+  (fn
+    (stream prefs)
+    (feed/mute-objects
+      (feed/mute-tags
+        (feed/mute-actors stream (get prefs :mute-actors (list)))
+        (get prefs :mute-tags (list)))
+      (get prefs :mute-objects (list)))))

lib/feed/normalize.sx

@@ -0,0 +1,31 @@
+; feed/normalize — coerce arbitrary input into the canonical activity record.
+; An activity is a small dict {:actor :verb :object :at :tags}; a stream is an
+; APL vector of such dicts (see stream.sx). Extra keys on the raw input survive
+; (e.g. :visible-to for ACL, peer metadata for federation) — :tags is the
+; flexible bag but the record is not closed.
+
+(define feed/activity-keys (list :actor :verb :object :at :tags))
+
+(define
+  feed/normalize
+  (fn
+    (raw)
+    (let
+      ((d (if (= (type-of raw) "dict") raw {})))
+      (merge d {:actor (get d :actor "") :object (get d :object nil) :at (get d :at 0) :tags (let ((t (get d :tags (list)))) (if (list? t) t (list t))) :verb (get d :verb "post")}))))
+
+(define
+  feed/activity
+  (fn (actor verb object at tags) (feed/normalize {:actor actor :object object :at at :tags tags :verb verb})))
+
+(define feed/actor (fn (a) (get a :actor)))
+(define feed/verb (fn (a) (get a :verb)))
+(define feed/object (fn (a) (get a :object)))
+(define feed/at (fn (a) (get a :at)))
+(define feed/tags (fn (a) (get a :tags)))
+
+(define
+  feed/activity?
+  (fn
+    (a)
+    (and (= (type-of a) "dict") (has-key? a :actor) (has-key? a :verb))))

lib/feed/notify.sx

@@ -0,0 +1,45 @@
+; feed/notify — a notification feed is a thin layer over a recipient's inbox:
+; the events directed at a user, optionally verb-filtered, and a digest that
+; collapses "alice, bob and 1 other liked X" by (verb, object).
+;
+; Requires: lib/feed/normalize.sx, lib/feed/stream.sx, lib/feed/fanout.sx
+; (feed/inbox-for, feed/-elem?).
+
+; all inbox events for a user (their raw notifications)
+(define feed/notifications (fn (inbox user) (feed/inbox-for inbox user)))
+
+; restrict to notification-worthy verbs (e.g. (list "like" "reply" "follow"))
+(define
+  feed/notify-verbs
+  (fn
+    (inbox user verbs)
+    (feed/filter
+      (feed/inbox-for inbox user)
+      (fn (ev) (feed/-elem? (get (get ev :activity) :verb) verbs)))))
+
+; group key "verb|object" — deterministic, sortable
+(define
+  feed/-notify-key
+  (fn
+    (ev)
+    (let
+      ((a (get ev :activity)))
+      (string-append (get a :verb) "|" (get a :object)))))
+
+; digest: one entry per (verb, object) with the distinct actors and a count,
+; ordered by key for determinism.
+(define
+  feed/notify-digest
+  (fn
+    (inbox user)
+    (let
+      ((events (feed/items (feed/inbox-for inbox user))))
+      (let
+        ((groups (reduce (fn (g ev) (let ((a (get ev :activity)) (k (feed/-notify-key ev))) (let ((cur (get g k {:object (get a :object) :actors (list) :verb (get a :verb)}))) (assoc g k (assoc cur :actors (append (get cur :actors) (list (get a :actor)))))))) {} events)))
+        (map
+          (fn
+            (k)
+            (let
+              ((grp (get groups k)))
+              (assoc grp :count (len (get grp :actors)))))
+          (sort (keys groups)))))))

lib/feed/page.sx

@@ -0,0 +1,50 @@
+; feed/page — pagination. Offset/limit for indexed access, and cursor-based
+; (by :at) for recency feeds, which is stable under inserts: a cursor is the
+; :at of the last item seen, and the next page is the newest items older than it.
+;
+; Requires: lib/feed/stream.sx (feed/recent, feed/take, feed/filter).
+
+; --- offset / limit ---------------------------------------------------------
+
+(define
+  feed/page
+  (fn
+    (stream offset limit)
+    (feed/stream (take (drop (feed/items stream) offset) limit))))
+
+(define
+  feed/page-count
+  (fn (stream limit) (ceil (/ (feed/count stream) limit))))
+
+; --- cursor (recency feeds) -------------------------------------------------
+
+; activities strictly older than cursor (scroll down / load older)
+(define
+  feed/before
+  (fn
+    (stream cursor)
+    (feed/filter stream (fn (a) (< (get a :at) cursor)))))
+
+; activities strictly newer than cursor (load newer / "N new posts")
+(define
+  feed/after
+  (fn
+    (stream cursor)
+    (feed/filter stream (fn (a) (> (get a :at) cursor)))))
+
+; one page: the `limit` newest activities older than cursor, newest first
+(define
+  feed/page-before
+  (fn
+    (stream cursor limit)
+    (feed/take (feed/recent (feed/before stream cursor)) limit)))
+
+; cursor to fetch the next (older) page: :at of the last item of a page,
+; or nil when the page is empty (end of feed)
+(define
+  feed/next-cursor
+  (fn
+    (page)
+    (let
+      ((items (feed/items page)))
+      (if (= (len items) 0) nil (get (last items) :at)))))

lib/feed/rank.sx

@@ -0,0 +1,92 @@
+; feed/rank — scoring + ranking. Scorers are (activity -> number). Ranking is a
+; stable two-pass grade-down: first by :at descending (the tiebreak), then by
+; score descending — so ties resolve by recency, then by input order. Fully
+; deterministic on ties.
+;
+; Requires: lib/apl/runtime.sx, lib/feed/normalize.sx, lib/feed/stream.sx.
+
+; --- scorers ----------------------------------------------------------------
+
+; recency: half-life decay. score = 0.5 ^ (age / half-life). at==now -> 1.0.
+(define
+  feed/recency
+  (fn
+    (now half-life)
+    (fn (a) (expt 0.5 (/ (- now (get a :at)) half-life)))))
+
+; velocity: how many of this actor's activities fall in (at-window, at] —
+; a burst of recent activity scores higher.
+(define
+  feed/velocity
+  (fn
+    (stream window)
+    (fn
+      (a)
+      (len
+        (filter
+          (fn
+            (b)
+            (and
+              (equal? (get b :actor) (get a :actor))
+              (<= (get b :at) (get a :at))
+              (> (get b :at) (- (get a :at) window))))
+          (feed/items stream))))))
+
+; engagement: how many activities in the stream touch this activity's :object
+(define
+  feed/engagement
+  (fn
+    (stream)
+    (fn
+      (a)
+      (len
+        (filter
+          (fn (b) (equal? (get b :object) (get a :object)))
+          (feed/items stream))))))
+
+; composite: weighted sum. parts = (list (list weight scorer) ...)
+(define
+  feed/composite
+  (fn
+    (parts)
+    (fn
+      (a)
+      (reduce
+        (fn (acc p) (+ acc (* (first p) ((nth p 1) a))))
+        0
+        parts))))
+
+; --- ranking ----------------------------------------------------------------
+
+; stable reorder of items by key-fn, descending (grade-down is stable)
+(define
+  feed/-desc-by
+  (fn
+    (items key-fn)
+    (let
+      ((keys (make-array (list (len items)) (map key-fn items))))
+      (let
+        ((order (get (apl-grade-down keys) :ravel)))
+        (map (fn (i) (nth items (- i 1))) order)))))
+
+; rank by score descending; ties -> :at descending -> input order
+(define
+  feed/rank
+  (fn
+    (stream score-fn)
+    (let
+      ((by-at (feed/-desc-by (feed/items stream) feed/at)))
+      (feed/stream (feed/-desc-by by-at score-fn)))))
+
+; attach a :score to each activity (for inspection / debugging)
+(define
+  feed/with-scores
+  (fn
+    (stream score-fn)
+    (feed/stream
+      (map (fn (a) (assoc a :score (score-fn a))) (feed/items stream)))))
+
+; top-N ranked timeline
+(define
+  feed/top
+  (fn (stream score-fn n) (feed/take (feed/rank stream score-fn) n)))

lib/feed/scoreboard.json

@@ -0,0 +1,19 @@
+{
+  "suites": {
+    "basic": {"pass": 30, "fail": 0},
+    "fanout": {"pass": 29, "fail": 0},
+    "rank": {"pass": 24, "fail": 0},
+    "integration": {"pass": 22, "fail": 0},
+    "content": {"pass": 15, "fail": 0},
+    "notify": {"pass": 8, "fail": 0},
+    "home": {"pass": 6, "fail": 0},
+    "dedupe": {"pass": 9, "fail": 0},
+    "trending": {"pass": 11, "fail": 0},
+    "mute": {"pass": 9, "fail": 0},
+    "page": {"pass": 14, "fail": 0},
+    "thread": {"pass": 12, "fail": 0}
+  },
+  "total_pass": 189,
+  "total_fail": 0,
+  "total": 189
+}

lib/feed/scoreboard.md

@@ -0,0 +1,19 @@
+# feed Conformance Scoreboard
+
+_Generated by `lib/feed/conformance.sh`_
+
+| Suite | Pass | Fail | Total |
+|-------|-----:|-----:|------:|
+| basic | 30 | 0 | 30 |
+| fanout | 29 | 0 | 29 |
+| rank | 24 | 0 | 24 |
+| integration | 22 | 0 | 22 |
+| content | 15 | 0 | 15 |
+| notify | 8 | 0 | 8 |
+| home | 6 | 0 | 6 |
+| dedupe | 9 | 0 | 9 |
+| trending | 11 | 0 | 11 |
+| mute | 9 | 0 | 9 |
+| page | 14 | 0 | 14 |
+| thread | 12 | 0 | 12 |
+| **Total** | **189** | **0** | **189** |

lib/feed/stream.sx

@@ -0,0 +1,75 @@
+; feed/stream — a stream is an APL vector (rank-1 array) whose ravel holds
+; activity dicts. Operations lift APL primitives onto this shape: filter via
+; compress (/), sort via grade (⍋), take via ↑, reverse via ⌽.
+;
+; Requires: lib/apl/runtime.sx, lib/feed/normalize.sx (loaded by harness).
+
+(define feed/stream (fn (acts) (make-array (list (len acts)) acts)))
+
+(define feed/items (fn (s) (get s :ravel)))
+
+(define feed/count (fn (s) (len (get s :ravel))))
+
+(define feed/empty (feed/stream (list)))
+
+(define feed/empty? (fn (s) (= (feed/count s) 0)))
+
+; filter — bool mask ∘ compress. pred : activity -> truthy
+(define
+  feed/filter
+  (fn
+    (s pred)
+    (let
+      ((items (get s :ravel)))
+      (let
+        ((mask (make-array (list (len items)) (map (fn (a) (if (pred a) 1 0)) items))))
+        (apl-compress mask s)))))
+
+; sort-by — ascending, stable on ties (grade-up is stable). key-fn : activity -> number
+(define
+  feed/sort-by
+  (fn
+    (s key-fn)
+    (let
+      ((items (get s :ravel)))
+      (let
+        ((keys (make-array (list (len items)) (map key-fn items))))
+        (let
+          ((order (get (apl-grade-up keys) :ravel)))
+          (feed/stream (map (fn (i) (nth items (- i 1))) order)))))))
+
+(define feed/sort-by-at (fn (s) (feed/sort-by s feed/at)))
+
+; newest-first: ascending sort then reverse (⌽)
+(define feed/recent (fn (s) (apl-reverse (feed/sort-by-at s))))
+
+; take N (↑), clamped to stream length so it never over-takes/pads
+(define
+  feed/take
+  (fn
+    (s n)
+    (let
+      ((c (feed/count s)))
+      (if (>= n c) s (apl-take (apl-scalar n) s)))))
+
+(define feed/reverse (fn (s) (apl-reverse s)))
+
+; common predicates
+(define
+  feed/by-actor
+  (fn (s actor) (feed/filter s (fn (a) (equal? (get a :actor) actor)))))
+
+(define
+  feed/by-verb
+  (fn (s verb) (feed/filter s (fn (a) (equal? (get a :verb) verb)))))
+
+(define
+  feed/by-object
+  (fn
+    (s object)
+    (feed/filter s (fn (a) (equal? (get a :object) object)))))
+
+; activities at or after timestamp t
+(define
+  feed/since
+  (fn (s t) (feed/filter s (fn (a) (>= (get a :at) t)))))

lib/feed/tests/basic.sx

@@ -0,0 +1,118 @@
+; Phase 1 — normalize, stream ops, api. Uses the feed-test harness
+; (feed-test name got expected) provided by conformance.sh.
+
+; ---------- normalize ----------
+
+(feed-test
+  "normalize default actor"
+  (feed/actor (feed/normalize {}))
+  "")
+(feed-test
+  "normalize default verb"
+  (feed/verb (feed/normalize {}))
+  "post")
+(feed-test
+  "normalize default at"
+  (feed/at (feed/normalize {}))
+  0)
+(feed-test
+  "normalize default object"
+  (feed/object (feed/normalize {}))
+  nil)
+(feed-test
+  "normalize default tags"
+  (feed/tags (feed/normalize {}))
+  (list))
+(feed-test
+  "normalize keeps actor"
+  (feed/actor (feed/normalize {:actor "alice"}))
+  "alice")
+(feed-test
+  "normalize keeps verb"
+  (feed/verb (feed/normalize {:verb "like"}))
+  "like")
+(feed-test
+  "normalize scalar tag -> list"
+  (feed/tags (feed/normalize {:tags "x"}))
+  (list "x"))
+(feed-test
+  "normalize list tags kept"
+  (feed/tags (feed/normalize {:tags (list "a" "b")}))
+  (list "a" "b"))
+(feed-test
+  "activity constructor at"
+  (feed/at (feed/activity "a" "post" "o" 5 (list)))
+  5)
+(feed-test
+  "activity? on activity"
+  (feed/activity? (feed/normalize {:actor "a"}))
+  true)
+(feed-test "activity? on number" (feed/activity? 5) false)
+(feed-test "activity? on bare dict" (feed/activity? {:foo 1}) false)
+
+; ---------- stream ----------
+
+(define
+  S
+  (feed/stream
+    (list
+      (feed/activity "alice" "post" "p1" 30 (list))
+      (feed/activity "bob" "like" "p1" 10 (list))
+      (feed/activity "alice" "post" "p2" 20 (list)))))
+
+(feed-test "stream count" (feed/count S) 3)
+(feed-test "stream items len" (len (feed/items S)) 3)
+(feed-test
+  "sort-by-at actors asc"
+  (map feed/actor (feed/items (feed/sort-by-at S)))
+  (list "bob" "alice" "alice"))
+(feed-test
+  "recent newest first"
+  (map feed/at (feed/items (feed/recent S)))
+  (list 30 20 10))
+(feed-test
+  "take 2 of recent"
+  (feed/count (feed/take (feed/recent S) 2))
+  2)
+(feed-test
+  "take clamps past end"
+  (feed/count (feed/take S 10))
+  3)
+(feed-test
+  "by-actor alice count"
+  (feed/count (feed/by-actor S "alice"))
+  2)
+(feed-test
+  "by-verb like actor"
+  (map feed/actor (feed/items (feed/by-verb S "like")))
+  (list "bob"))
+(feed-test
+  "by-object p1 count"
+  (feed/count (feed/by-object S "p1"))
+  2)
+(feed-test
+  "since 20 count"
+  (feed/count (feed/since S 20))
+  2)
+(feed-test
+  "reverse ats"
+  (map feed/at (feed/items (feed/reverse S)))
+  (list 20 10 30))
+(feed-test "empty? on empty" (feed/empty? feed/empty) true)
+(feed-test
+  "empty? on filtered-out"
+  (feed/empty? (feed/by-actor S "zzz"))
+  true)
+
+; ---------- api ----------
+
+(feed/reset!)
+(feed/post {:actor "x" :at 1 :verb "post"})
+(feed/post {:actor "y" :at 2 :verb "like"})
+(feed-test "api size after posts" (feed/size) 2)
+(feed-test "api all count" (feed/count (feed/all)) 2)
+(feed-test
+  "post returns normalized verb"
+  (feed/verb (feed/post {:actor "z"}))
+  "post")
+(feed-test "api size after third post" (feed/size) 3)

lib/feed/tests/content.sx

@@ -0,0 +1,85 @@
+; Follow-up — TF-IDF content ranking over :tags. (feed-test name got expected)
+
+(define
+  corpus
+  (feed/stream
+    (list
+      (feed/normalize {:actor "u" :object "o1" :at 10 :tags (list "cats" "funny")})
+      (feed/normalize {:actor "u" :object "o2" :at 20 :tags (list "cats" "news")})
+      (feed/normalize {:actor "u" :object "o3" :at 30 :tags (list "politics" "news")})
+      (feed/normalize {:actor "u" :object "o4" :at 40 :tags (list "cats")}))))
+
+; ---------- document frequency ----------
+
+(feed-test "df cats" (get (feed/tag-df corpus) "cats") 3)
+(feed-test "df news" (get (feed/tag-df corpus) "news") 2)
+(feed-test "df funny" (get (feed/tag-df corpus) "funny") 1)
+(feed-test "df politics" (get (feed/tag-df corpus) "politics") 1)
+(feed-test "df full" (feed/tag-df corpus) {:news 2 :funny 1 :politics 1 :cats 3})
+
+; ---------- inverse document frequency ----------
+
+(feed-test
+  "idf news = log(4/2)"
+  (get (feed/tag-idf corpus) "news")
+  (log 2))
+(feed-test
+  "idf funny = log(4/1)"
+  (get (feed/tag-idf corpus) "funny")
+  (log 4))
+(feed-test
+  "rarer tag has higher idf"
+  (>
+    (get (feed/tag-idf corpus) "funny")
+    (get (feed/tag-idf corpus) "cats"))
+  true)
+
+; ---------- tf-idf scoring ----------
+
+(define idf (feed/tag-idf corpus))
+
+(feed-test
+  "score query funny on o1"
+  ((feed/tfidf-score idf (list "funny")) (feed/normalize {:actor "u" :object "x" :tags (list "cats" "funny")}))
+  (log 4))
+(feed-test
+  "score query funny on non-match"
+  ((feed/tfidf-score idf (list "funny")) (feed/normalize {:actor "u" :object "x" :tags (list "cats")}))
+  0)
+(feed-test
+  "unknown query tag scores 0"
+  ((feed/tfidf-score idf (list "zzz")) (feed/normalize {:actor "u" :object "x" :tags (list "cats")}))
+  0)
+
+; ---------- ranking by relevance ----------
+
+; query news: o2,o3 match (score log2), o1,o4 don't (0); ties break by :at desc
+(feed-test
+  "by-relevance news order"
+  (map
+    (fn (a) (get a :object))
+    (feed/items (feed/by-relevance corpus (list "news"))))
+  (list "o3" "o2" "o4" "o1"))
+
+; query funny: only o1 matches -> ranks first
+(feed-test
+  "by-relevance funny first"
+  (get
+    (nth (feed/items (feed/by-relevance corpus (list "funny"))) 0)
+    :object)
+  "o1")
+
+; query (cats news): o2 carries both tags -> highest combined tf-idf
+(feed-test
+  "by-relevance cats+news top"
+  (get
+    (nth
+      (feed/items (feed/by-relevance corpus (list "cats" "news")))
+      0)
+    :object)
+  "o2")
+
+(feed-test
+  "by-relevance preserves count"
+  (feed/count (feed/by-relevance corpus (list "cats")))
+  4)

lib/feed/tests/dedupe.sx

@@ -0,0 +1,56 @@
+; Follow-up — verb-aware (smart) dedupe. (feed-test name got expected)
+
+; reactions (like/follow) collapse cross-actor; posts stay distinct per actor
+(define
+  M
+  (feed/stream
+    (list
+      (feed/activity "alice" "like" "X" 1 (list))
+      (feed/activity "bob" "like" "X" 2 (list))
+      (feed/activity "alice" "post" "P" 3 (list))
+      (feed/activity "bob" "post" "P" 4 (list))
+      (feed/activity "alice" "follow" "C" 5 (list))
+      (feed/activity "bob" "follow" "C" 6 (list))))) ; collapses
+
+(feed-test
+  "smart dedupe total"
+  (feed/count (feed/dedupe-smart M))
+  4)
+(feed-test
+  "smart keeps both posts"
+  (feed/count (feed/by-verb (feed/dedupe-smart M) "post"))
+  2)
+(feed-test
+  "smart collapses likes to one"
+  (feed/count (feed/by-verb (feed/dedupe-smart M) "like"))
+  1)
+(feed-test
+  "smart collapses follows to one"
+  (feed/count (feed/by-verb (feed/dedupe-smart M) "follow"))
+  1)
+(feed-test
+  "collapsed like keeps first actor"
+  (map feed/actor (feed/items (feed/by-verb (feed/dedupe-smart M) "like")))
+  (list "alice"))
+
+; contrast: plain activity dedupe keeps cross-actor likes distinct
+(feed-test
+  "activity dedupe keeps both likes"
+  (feed/count (feed/by-verb (feed/dedupe-activities M) "like"))
+  2)
+
+; contrast: blanket collapse folds the two posts (same verb+object) too
+(feed-test
+  "collapse dedupe folds posts"
+  (feed/count (feed/by-verb (feed/dedupe-collapse M) "post"))
+  1)
+
+; smart-key dispatch
+(feed-test
+  "smart-key reaction -> (verb object)"
+  (feed/smart-key (feed/activity "alice" "like" "X" 0 (list)))
+  (list "like" "X"))
+(feed-test
+  "smart-key post -> (actor verb object)"
+  (feed/smart-key (feed/activity "alice" "post" "P" 0 (list)))
+  (list "alice" "post" "P"))

lib/feed/tests/fanout.sx

@@ -0,0 +1,187 @@
+; Phase 2 — fanout via outer product + dedupe. (feed-test name got expected)
+
+; ---------- graph ----------
+
+; edges: (follower followee). bob,carol follow alice; carol,dave follow bob.
+(define
+  G
+  (feed/follow-graph
+    (list
+      (list "bob" "alice")
+      (list "carol" "alice")
+      (list "carol" "bob")
+      (list "dave" "bob"))))
+
+(feed-test "followers alice" (feed/followers G "alice") (list "bob" "carol"))
+(feed-test "followers bob" (feed/followers G "bob") (list "carol" "dave"))
+(feed-test "followers unknown" (feed/followers G "zzz") (list))
+(feed-test "audience distinct" (feed/audience G) (list "bob" "carol" "dave"))
+
+; ---------- fanout ----------
+
+(define
+  S
+  (feed/stream
+    (list
+      (feed/activity "alice" "post" "p1" 10 (list))
+      (feed/activity "alice" "post" "p2" 20 (list))
+      (feed/activity "bob" "like" "p1" 30 (list)))))
+
+(define IB (feed/fanout S G))
+
+(feed-test "fanout total edges" (feed/count IB) 6)
+(feed-test
+  "inbox bob count"
+  (feed/count (feed/inbox-for IB "bob"))
+  2)
+(feed-test
+  "inbox carol count"
+  (feed/count (feed/inbox-for IB "carol"))
+  3)
+(feed-test
+  "inbox dave count"
+  (feed/count (feed/inbox-for IB "dave"))
+  1)
+(feed-test
+  "inbox alice (follows none)"
+  (feed/count (feed/inbox-for IB "alice"))
+  0)
+(feed-test
+  "recipients order"
+  (feed/recipients IB)
+  (list "bob" "carol" "dave"))
+(feed-test
+  "bob inbox objects"
+  (map (fn (a) (get a :object)) (feed/inbox-activities IB "bob"))
+  (list "p1" "p2"))
+(feed-test
+  "dave inbox objects"
+  (map (fn (a) (get a :object)) (feed/inbox-activities IB "dave"))
+  (list "p1"))
+(feed-test
+  "dave inbox verb"
+  (map (fn (a) (get a :verb)) (feed/inbox-activities IB "dave"))
+  (list "like"))
+
+; empty graph → no audience → no edges
+(feed-test
+  "empty graph fanout"
+  (feed/count (feed/fanout S {}))
+  0)
+
+; actor nobody follows produces no edges
+(define
+  Sghost
+  (feed/stream (list (feed/activity "ghost" "post" "g1" 5 (list)))))
+(feed-test
+  "unfollowed actor fanout"
+  (feed/count (feed/fanout Sghost G))
+  0)
+
+; ---------- high fanout (popular actor) ----------
+
+(define
+  Gstar
+  (feed/follow-graph
+    (list
+      (list "u1" "star")
+      (list "u2" "star")
+      (list "u3" "star")
+      (list "u4" "star")
+      (list "u5" "star"))))
+(define
+  Sstar
+  (feed/stream (list (feed/activity "star" "post" "s1" 1 (list)))))
+(feed-test
+  "star fanout count"
+  (feed/count (feed/fanout Sstar Gstar))
+  5)
+(feed-test "star audience size" (len (feed/audience Gstar)) 5)
+
+; ---------- mutual follow ----------
+
+(define Gmut (feed/follow-graph (list (list "a" "b") (list "b" "a"))))
+(define
+  Smut
+  (feed/stream
+    (list
+      (feed/activity "a" "post" "pa" 1 (list))
+      (feed/activity "b" "post" "pb" 2 (list)))))
+(define IBmut (feed/fanout Smut Gmut))
+(feed-test "mutual total" (feed/count IBmut) 2)
+(feed-test
+  "mutual a gets pb"
+  (map (fn (x) (get x :object)) (feed/inbox-activities IBmut "a"))
+  (list "pb"))
+(feed-test
+  "mutual b gets pa"
+  (map (fn (x) (get x :object)) (feed/inbox-activities IBmut "b"))
+  (list "pa"))
+
+; ---------- dedupe ----------
+
+(define
+  Sdup2
+  (feed/stream
+    (list
+      (feed/activity "alice" "post" "p1" 1 (list))
+      (feed/activity "alice" "post" "p1" 9 (list))
+      (feed/activity "alice" "post" "p2" 2 (list)))))
+(feed-test
+  "dedupe-activities collapses dup"
+  (feed/count (feed/dedupe-activities Sdup2))
+  2)
+(feed-test
+  "dedupe-activities keeps distinct"
+  (map
+    (fn (a) (get a :object))
+    (feed/items (feed/dedupe-activities Sdup2)))
+  (list "p1" "p2"))
+
+(define
+  Slikes
+  (feed/stream
+    (list
+      (feed/activity "alice" "like" "X" 1 (list))
+      (feed/activity "bob" "like" "X" 2 (list))
+      (feed/activity "carol" "like" "Y" 3 (list)))))
+(feed-test
+  "collapse cross-actor likes"
+  (feed/count (feed/dedupe-collapse Slikes))
+  2)
+(feed-test
+  "collapse keeps distinct objects"
+  (map
+    (fn (a) (get a :object))
+    (feed/items (feed/dedupe-collapse Slikes)))
+  (list "X" "Y"))
+
+(feed-test
+  "activity-key shape"
+  (feed/activity-key (feed/activity "a" "post" "o" 0 (list)))
+  (list "a" "post" "o"))
+(feed-test
+  "collapse-key shape"
+  (feed/collapse-key (feed/activity "a" "like" "o" 0 (list)))
+  (list "like" "o"))
+
+; cross-post: alice posts p1 twice → bob's inbox has it twice → dedupe-inbox → once
+(define
+  Scross
+  (feed/stream
+    (list
+      (feed/activity "alice" "post" "p1" 1 (list))
+      (feed/activity "alice" "post" "p1" 5 (list)))))
+(define IBcross (feed/fanout Scross G))
+(feed-test
+  "cross-post raw bob count"
+  (feed/count (feed/inbox-for IBcross "bob"))
+  2)
+(feed-test
+  "cross-post deduped bob count"
+  (feed/count (feed/inbox-for (feed/dedupe-inbox IBcross) "bob"))
+  1)
+(feed-test
+  "dedupe-inbox keeps distinct receivers"
+  (feed/count (feed/dedupe-inbox IBcross))
+  2)

lib/feed/tests/home.sx

@@ -0,0 +1,73 @@
+; Follow-up — feed/home capstone pipeline. (feed-test name got expected)
+
+; alice follows star and bob (edges: follower followee)
+(define
+  G
+  (feed/follow-graph (list (list "alice" "star") (list "alice" "bob"))))
+
+; star posts s1 then s2; bob posts b1; star re-posts s1 (cross-post dup);
+; zoe posts z1 (alice does NOT follow zoe)
+(define
+  S
+  (feed/stream
+    (list
+      (feed/activity "star" "post" "s1" 10 (list))
+      (feed/activity "star" "post" "s2" 20 (list))
+      (feed/activity "bob" "post" "b1" 15 (list))
+      (feed/activity "star" "post" "s1" 5 (list))
+      (feed/activity "zoe" "post" "z1" 30 (list)))))
+
+(define rec (feed/recency 100 10))
+
+(feed-test
+  "home count (deduped, followed only)"
+  (feed/count (feed/home S G "alice" feed/permit-public? rec 10))
+  3)
+
+(feed-test
+  "home order by recency"
+  (map
+    (fn (a) (get a :object))
+    (feed/items (feed/home S G "alice" feed/permit-public? rec 10)))
+  (list "s2" "b1" "s1"))
+
+(feed-test
+  "home excludes unfollowed zoe"
+  (feed/-elem?
+    "z1"
+    (map
+      (fn (a) (get a :object))
+      (feed/items (feed/home S G "alice" feed/permit-public? rec 10))))
+  false)
+
+(feed-test
+  "home top-2"
+  (map
+    (fn (a) (get a :object))
+    (feed/items (feed/home S G "alice" feed/permit-public? rec 2)))
+  (list "s2" "b1"))
+
+(feed-test
+  "home dedupes cross-post (one s1)"
+  (len
+    (filter
+      (fn (o) (equal? o "s1"))
+      (map
+        (fn (a) (get a :object))
+        (feed/items
+          (feed/home S G "alice" feed/permit-public? rec 10)))))
+  1)
+
+; ACL applied per-viewer in the home pipeline
+(define
+  Sacl
+  (feed/stream
+    (list (feed/normalize {:actor "star" :object "pub" :at 20}) (feed/normalize {:actor "star" :object "sec" :visible-to (list "carol") :at 25}))))
+(define Gacl (feed/follow-graph (list (list "alice" "star"))))
+
+(feed-test
+  "home hides activity alice not permitted"
+  (map
+    (fn (a) (get a :object))
+    (feed/items (feed/home Sacl Gacl "alice" feed/permit-acl? rec 10)))
+  (list "pub"))

lib/feed/tests/integration.sx

@@ -0,0 +1,155 @@
+; Phase 4 — visibility (ACL) + federation, and the end-to-end timeline.
+; (feed-test name got expected)
+
+; ---------- ACL visibility ----------
+; pub: public. sec: bob, allows carol. dm: frank, allows dave.
+
+(define
+  C
+  (feed/stream
+    (list
+      (feed/normalize {:actor "alice" :object "pub" :at 10})
+      (feed/normalize {:actor "bob" :object "sec" :visible-to (list "carol") :at 20})
+      (feed/normalize {:actor "frank" :object "dm" :visible-to (list "dave") :at 30}))))
+
+(feed-test
+  "public visible to anyone"
+  (feed/count (feed/visible C "zoe" feed/permit-acl?))
+  1)
+(feed-test
+  "carol sees allowlisted + public"
+  (feed/count (feed/visible C "carol" feed/permit-acl?))
+  2)
+(feed-test
+  "dave sees dm + public"
+  (feed/count (feed/visible C "dave" feed/permit-acl?))
+  2)
+(feed-test
+  "author always sees own private"
+  (feed/count (feed/visible C "frank" feed/permit-acl?))
+  2)
+(feed-test
+  "permit-public? lets all through"
+  (feed/count (feed/visible C "zoe" feed/permit-public?))
+  3)
+(feed-test
+  "visible objects for dave"
+  (map
+    (fn (a) (get a :object))
+    (feed/items (feed/visible C "dave" feed/permit-acl?)))
+  (list "pub" "dm"))
+
+; per-viewer: same stream, different timelines
+(feed-test
+  "zoe timeline differs from carol"
+  (not
+    (=
+      (feed/count (feed/visible C "zoe" feed/permit-acl?))
+      (feed/count (feed/visible C "carol" feed/permit-acl?))))
+  true)
+
+; ---------- federation: merge / ingest ----------
+
+(define
+  L
+  (feed/stream
+    (list
+      (feed/activity "alice" "post" "p1" 10 (list))
+      (feed/activity "alice" "post" "p2" 20 (list)))))
+(define
+  P
+  (feed/stream
+    (list
+      (feed/activity "alice" "post" "p2" 20 (list))
+      (feed/activity "peer" "post" "p9" 25 (list)))))
+
+(feed-test "merge concatenates" (feed/count (feed/merge L P)) 4)
+(feed-test
+  "ingest dedupes overlap"
+  (feed/count (feed/ingest L P))
+  3)
+
+(feed-test
+  "inbound normalizes + ingests"
+  (feed/count (feed/inbound L (list {:actor "peer" :object "p9" :at 25} {:actor "alice" :object "p1" :at 10})))
+  3)
+
+; backfill via injected fetch-fn
+(define peer-history (fn (peer-id) (list {:actor peer-id :object "h1" :at 1} {:actor peer-id :object "h2" :at 2})))
+(feed-test
+  "backfill merges peer history"
+  (feed/count (feed/backfill L peer-history "remote"))
+  4)
+(feed-test
+  "backfill objects present"
+  (map
+    (fn (a) (get a :object))
+    (feed/items
+      (feed/by-actor (feed/backfill L peer-history "remote") "remote")))
+  (list "h1" "h2"))
+
+; ---------- federation: outbound partition ----------
+
+; bob (local), alice@remote + carol@remote (remote) follow star
+(define
+  Gf
+  (feed/follow-graph
+    (list
+      (list "bob" "star")
+      (list "alice@remote" "star")
+      (list "carol@remote" "star"))))
+(define
+  Sf
+  (feed/stream (list (feed/activity "star" "post" "s1" 1 (list)))))
+(define
+  remote?
+  (fn (id) (feed/-elem? id (list "alice@remote" "carol@remote"))))
+(define parts (feed/federate Sf Gf remote?))
+
+(feed-test "local deliveries" (feed/count (get parts :local)) 1)
+(feed-test "remote deliveries" (feed/count (get parts :remote)) 2)
+(feed-test
+  "local recipient is bob"
+  (feed/recipients (get parts :local))
+  (list "bob"))
+
+; deliver: send-fn receives each remote event, local inbox returned
+(define sent (list))
+(define send-fn (fn (to act) (set! sent (append sent (list to)))))
+(define local-inbox (feed/deliver Sf Gf remote? send-fn))
+(feed-test "deliver returns local inbox" (feed/count local-inbox) 1)
+(feed-test "deliver sent to both remotes" (len sent) 2)
+(feed-test "deliver remote targets" sent (list "alice@remote" "carol@remote"))
+
+; ---------- end-to-end: federated, ACL-filtered, ranked timeline ----------
+
+(define
+  base
+  (feed/stream
+    (list
+      (feed/normalize {:actor "alice" :object "a1" :at 100})
+      (feed/normalize {:actor "bob" :object "b1" :visible-to (list "carol") :at 90})
+      (feed/normalize {:actor "eve" :object "e1" :visible-to (list "dave") :at 80}))))
+(define federated (feed/inbound base (list {:actor "peer" :object "x1" :at 110})))
+(define rec (feed/recency 120 10))
+(define
+  carol-tl
+  (feed/timeline federated "carol" feed/permit-acl? rec 3))
+
+; eve's :visible-to excludes carol -> filtered out; peer/alice public, bob allows carol
+(feed-test "carol federated timeline count" (feed/count carol-tl) 3)
+(feed-test
+  "carol timeline order (recency)"
+  (map (fn (a) (get a :object)) (feed/items carol-tl))
+  (list "x1" "a1" "b1"))
+(feed-test
+  "eve dm excluded from carol"
+  (feed/-elem? "e1" (map (fn (a) (get a :object)) (feed/items carol-tl)))
+  false)
+(feed-test
+  "dave sees eve dm not bob"
+  (map
+    (fn (a) (get a :object))
+    (feed/items
+      (feed/timeline federated "dave" feed/permit-acl? rec 5)))
+  (list "x1" "a1" "e1"))

lib/feed/tests/mute.sx

@@ -0,0 +1,68 @@
+; Follow-up — viewer mute/block filtering. (feed-test name got expected)
+
+(define
+  S
+  (feed/stream
+    (list
+      (feed/normalize {:actor "alice" :object "P1" :at 1 :tags (list "news")})
+      (feed/normalize {:actor "bob" :object "P2" :at 2 :tags (list "spam")})
+      (feed/normalize {:actor "alice" :object "P3" :at 3 :tags (list "cats")})
+      (feed/normalize {:actor "carol" :object "P4" :at 4 :tags (list "news" "spam")}))))
+
+; ---------- mute actors ----------
+
+(feed-test
+  "mute bob drops his post"
+  (map
+    (fn (a) (get a :object))
+    (feed/items (feed/mute-actors S (list "bob"))))
+  (list "P1" "P3" "P4"))
+(feed-test
+  "mute alice drops two"
+  (feed/count (feed/mute-actors S (list "alice")))
+  2)
+(feed-test
+  "mute nobody keeps all"
+  (feed/count (feed/mute-actors S (list)))
+  4)
+
+; ---------- mute tags ----------
+
+(feed-test
+  "mute spam tag drops two"
+  (map
+    (fn (a) (get a :object))
+    (feed/items (feed/mute-tags S (list "spam"))))
+  (list "P1" "P3"))
+(feed-test
+  "mute news+cats leaves spam-only"
+  (map
+    (fn (a) (get a :object))
+    (feed/items (feed/mute-tags S (list "news" "cats"))))
+  (list "P2"))
+
+; ---------- mute objects ----------
+
+(feed-test
+  "mute object P3 (thread mute)"
+  (feed/count (feed/mute-objects S (list "P3")))
+  3)
+
+; ---------- combined prefs ----------
+
+(feed-test
+  "apply-prefs actors + tags"
+  (map
+    (fn (a) (get a :object))
+    (feed/items (feed/apply-prefs S {:mute-actors (list "bob") :mute-tags (list "cats")})))
+  (list "P1" "P4"))
+(feed-test
+  "apply-prefs empty keeps all"
+  (feed/count (feed/apply-prefs S {}))
+  4)
+(feed-test
+  "apply-prefs all three filters"
+  (map
+    (fn (a) (get a :object))
+    (feed/items (feed/apply-prefs S {:mute-objects (list "P3") :mute-actors (list "carol") :mute-tags (list "spam")})))
+  (list "P1"))

lib/feed/tests/notify.sx

@@ -0,0 +1,69 @@
+; Follow-up — notification feed over an inbox. (feed-test name got expected)
+
+; an inbox is a stream of {:to receiver :activity act} events
+(define mk-ev (fn (to act) {:activity act :to to}))
+
+(define
+  IB
+  (feed/stream
+    (list
+      (mk-ev "alice" (feed/activity "bob" "like" "P" 10 (list)))
+      (mk-ev "alice" (feed/activity "carol" "like" "P" 20 (list)))
+      (mk-ev "alice" (feed/activity "dave" "reply" "Q" 30 (list)))
+      (mk-ev "bob" (feed/activity "eve" "like" "R" 40 (list))))))
+
+; ---------- raw notifications ----------
+
+(feed-test
+  "alice notification count"
+  (feed/count (feed/notifications IB "alice"))
+  3)
+(feed-test
+  "bob notification count"
+  (feed/count (feed/notifications IB "bob"))
+  1)
+(feed-test
+  "zoe no notifications"
+  (feed/count (feed/notifications IB "zoe"))
+  0)
+
+; ---------- verb filtering ----------
+
+(feed-test
+  "alice likes only"
+  (feed/count (feed/notify-verbs IB "alice" (list "like")))
+  2)
+(feed-test
+  "alice replies only"
+  (feed/count (feed/notify-verbs IB "alice" (list "reply")))
+  1)
+(feed-test
+  "alice like+reply"
+  (feed/count (feed/notify-verbs IB "alice" (list "like" "reply")))
+  3)
+(feed-test
+  "alice follow (none)"
+  (feed/count (feed/notify-verbs IB "alice" (list "follow")))
+  0)
+
+; ---------- digest ----------
+
+(define dig (feed/notify-digest IB "alice"))
+
+(feed-test "digest group count" (len dig) 2)
+(feed-test
+  "digest sorted by key (like|P before reply|Q)"
+  (map (fn (g) (get g :object)) dig)
+  (list "P" "Q"))
+(feed-test
+  "like group actors"
+  (get (nth dig 0) :actors)
+  (list "bob" "carol"))
+(feed-test "like group count" (get (nth dig 0) :count) 2)
+(feed-test "like group verb" (get (nth dig 0) :verb) "like")
+(feed-test "reply group count" (get (nth dig 1) :count) 1)
+(feed-test
+  "reply group actors"
+  (get (nth dig 1) :actors)
+  (list "dave"))
+(feed-test "empty digest for zoe" (feed/notify-digest IB "zoe") (list))

lib/feed/tests/page.sx

@@ -0,0 +1,86 @@
+; Follow-up — pagination (offset + cursor). (feed-test name got expected)
+
+; ---------- offset / limit ----------
+
+(define
+  O
+  (feed/stream
+    (list
+      (feed/activity "u" "post" "o1" 1 (list))
+      (feed/activity "u" "post" "o2" 2 (list))
+      (feed/activity "u" "post" "o3" 3 (list))
+      (feed/activity "u" "post" "o4" 4 (list))
+      (feed/activity "u" "post" "o5" 5 (list)))))
+
+(feed-test
+  "page 1"
+  (map
+    (fn (a) (get a :object))
+    (feed/items (feed/page O 0 2)))
+  (list "o1" "o2"))
+(feed-test
+  "page 2"
+  (map
+    (fn (a) (get a :object))
+    (feed/items (feed/page O 2 2)))
+  (list "o3" "o4"))
+(feed-test
+  "page 3 (partial)"
+  (map
+    (fn (a) (get a :object))
+    (feed/items (feed/page O 4 2)))
+  (list "o5"))
+(feed-test
+  "page past end empty"
+  (feed/count (feed/page O 10 2))
+  0)
+(feed-test "page-count 5/2 = 3" (feed/page-count O 2) 3)
+(feed-test "page-count 5/5 = 1" (feed/page-count O 5) 1)
+
+; ---------- cursor (recency) ----------
+
+(define
+  R
+  (feed/stream
+    (list
+      (feed/activity "u" "post" "a" 50 (list))
+      (feed/activity "u" "post" "b" 40 (list))
+      (feed/activity "u" "post" "c" 30 (list))
+      (feed/activity "u" "post" "d" 20 (list))
+      (feed/activity "u" "post" "e" 10 (list)))))
+
+(define p1 (feed/page-before R 100 2))
+(feed-test
+  "cursor page 1 newest first"
+  (map (fn (a) (get a :object)) (feed/items p1))
+  (list "a" "b"))
+(feed-test "next cursor after page 1" (feed/next-cursor p1) 40)
+
+(define p2 (feed/page-before R (feed/next-cursor p1) 2))
+(feed-test
+  "cursor page 2"
+  (map (fn (a) (get a :object)) (feed/items p2))
+  (list "c" "d"))
+(feed-test "next cursor after page 2" (feed/next-cursor p2) 20)
+
+(define p3 (feed/page-before R (feed/next-cursor p2) 2))
+(feed-test
+  "cursor page 3 (partial)"
+  (map (fn (a) (get a :object)) (feed/items p3))
+  (list "e"))
+
+(feed-test
+  "empty page nil cursor"
+  (feed/next-cursor (feed/page-before R 5 2))
+  nil)
+
+(feed-test
+  "after cursor loads newer"
+  (map
+    (fn (a) (get a :object))
+    (feed/items (feed/recent (feed/after R 30))))
+  (list "a" "b"))
+(feed-test
+  "before cursor count"
+  (feed/count (feed/before R 30))
+  2)

lib/feed/tests/rank.sx

@@ -0,0 +1,160 @@
+; Phase 3 — aggregation + ranking. (feed-test name got expected)
+
+; ---------- aggregation ----------
+
+(define
+  A
+  (feed/stream
+    (list
+      (feed/activity "alice" "post" "p1" 5 (list))
+      (feed/activity "alice" "post" "p2" 15 (list))
+      (feed/activity "bob" "post" "p3" 25 (list))
+      (feed/activity "alice" "like" "p1" 35 (list)))))
+
+(feed-test "actor-counts" (feed/actor-counts A) {:alice 3 :bob 1})
+(feed-test "object-counts" (feed/object-counts A) {:p2 1 :p3 1 :p1 2})
+(feed-test
+  "group-by actor alice len"
+  (len (get (feed/group-by A feed/actor) "alice"))
+  3)
+(feed-test
+  "group-count empty"
+  (feed/group-count feed/empty feed/actor)
+  {})
+
+; day bucketing
+(define
+  D
+  (feed/stream
+    (list
+      (feed/activity "alice" "post" "p1" 5 (list))
+      (feed/activity "alice" "post" "p2" 8 (list))
+      (feed/activity "alice" "post" "p3" 12 (list)))))
+
+(feed-test "feed/day floor" (feed/day 12 10) 1)
+(feed-test "feed/day same bucket" (feed/day 8 10) 0)
+(feed-test "by-actor-day" (feed/by-actor-day D 10) {:alice#0 2 :alice#1 1})
+
+; ---------- recency ----------
+
+(define rec (feed/recency 100 10))
+(feed-test
+  "recency at=now -> 1"
+  (rec (feed/activity "x" "post" "o" 100 (list)))
+  1)
+(feed-test
+  "recency age=hl -> .5"
+  (rec (feed/activity "x" "post" "o" 90 (list)))
+  0.5)
+(feed-test
+  "recency age=2hl -> .25"
+  (rec (feed/activity "x" "post" "o" 80 (list)))
+  0.25)
+
+; ---------- velocity ----------
+
+(define vel (feed/velocity D 10))
+(feed-test
+  "velocity burst (at=12)"
+  (vel (feed/activity "alice" "post" "z" 12 (list)))
+  3)
+(feed-test
+  "velocity mid (at=8)"
+  (vel (feed/activity "alice" "post" "z" 8 (list)))
+  2)
+(feed-test
+  "velocity first (at=5)"
+  (vel (feed/activity "alice" "post" "z" 5 (list)))
+  1)
+(feed-test
+  "velocity other actor"
+  (vel (feed/activity "bob" "post" "z" 12 (list)))
+  0)
+
+; ---------- engagement ----------
+
+(define eng (feed/engagement A))
+(feed-test
+  "engagement p1"
+  (eng (feed/activity "x" "post" "p1" 0 (list)))
+  2)
+(feed-test
+  "engagement p2"
+  (eng (feed/activity "x" "post" "p2" 0 (list)))
+  1)
+
+; ---------- composite ----------
+
+(define
+  cmp1
+  (feed/composite (list (list 2 (fn (a) (get a :at))))))
+(feed-test
+  "composite single part"
+  (cmp1 (feed/activity "x" "post" "o" 5 (list)))
+  10)
+(define
+  cmp2
+  (feed/composite
+    (list
+      (list 2 (fn (a) (get a :at)))
+      (list 3 (fn (a) 1)))))
+(feed-test
+  "composite two parts"
+  (cmp2 (feed/activity "x" "post" "o" 5 (list)))
+  13)
+
+; ---------- ranking ----------
+
+(define
+  R
+  (feed/stream
+    (list
+      (feed/activity "u" "post" "oC" 80 (list))
+      (feed/activity "u" "post" "oA" 100 (list))
+      (feed/activity "u" "post" "oB" 90 (list)))))
+
+(feed-test
+  "rank by recency objects"
+  (map (fn (a) (get a :object)) (feed/items (feed/rank R rec)))
+  (list "oA" "oB" "oC"))
+(feed-test
+  "top-2 by recency"
+  (map (fn (a) (get a :object)) (feed/items (feed/top R rec 2)))
+  (list "oA" "oB"))
+(feed-test "top-2 count" (feed/count (feed/top R rec 2)) 2)
+
+; constant score -> tiebreak by :at descending
+(define
+  T
+  (feed/stream
+    (list
+      (feed/activity "u" "post" "f" 10 (list))
+      (feed/activity "u" "post" "g" 30 (list))
+      (feed/activity "u" "post" "h" 20 (list)))))
+(feed-test
+  "tiebreak at-desc"
+  (map
+    (fn (a) (get a :object))
+    (feed/items (feed/rank T (fn (a) 0))))
+  (list "g" "h" "f"))
+
+; equal score AND equal :at -> stable input order
+(define
+  E
+  (feed/stream
+    (list
+      (feed/activity "u" "post" "first" 50 (list))
+      (feed/activity "u" "post" "second" 50 (list)))))
+(feed-test
+  "stable equal-key input order"
+  (map
+    (fn (a) (get a :object))
+    (feed/items (feed/rank E (fn (a) 0))))
+  (list "first" "second"))
+
+(feed-test
+  "with-scores attaches score"
+  (get (nth (feed/items (feed/with-scores R rec)) 1) :score)
+  1)
+
+(feed-test "rank preserves count" (feed/count (feed/rank A rec)) 4)

lib/feed/tests/thread.sx

@@ -0,0 +1,49 @@
+; Follow-up — conversation threading via :reply-to closure. (feed-test name got expected)
+
+(define
+  S
+  (feed/stream
+    (list
+      (feed/normalize {:actor "a" :object "root" :at 1})
+      (feed/normalize {:actor "b" :object "r1" :at 2 :verb "reply" :reply-to "root"})
+      (feed/normalize {:actor "c" :object "r2" :at 3 :verb "reply" :reply-to "root"})
+      (feed/normalize {:actor "d" :object "r3" :at 4 :verb "reply" :reply-to "r1"})
+      (feed/normalize {:actor "e" :object "x" :at 5}))))
+
+; ---------- direct replies ----------
+
+(feed-test "direct replies to root" (feed/reply-count S "root") 2)
+(feed-test "direct replies to r1" (feed/reply-count S "r1") 1)
+(feed-test "no replies to r3" (feed/reply-count S "r3") 0)
+(feed-test
+  "replies objects to root"
+  (map (fn (a) (get a :object)) (feed/items (feed/replies S "root")))
+  (list "r1" "r2"))
+
+; ---------- thread closure ----------
+
+(feed-test
+  "thread objects root (transitive)"
+  (feed/thread-objects S "root")
+  (list "root" "r1" "r2" "r3"))
+(feed-test
+  "thread root chronological"
+  (map (fn (a) (get a :object)) (feed/items (feed/thread S "root")))
+  (list "root" "r1" "r2" "r3"))
+(feed-test "thread size root" (feed/thread-size S "root") 4)
+(feed-test
+  "thread excludes unrelated x"
+  (feed/-elem?
+    "x"
+    (map (fn (a) (get a :object)) (feed/items (feed/thread S "root"))))
+  false)
+
+; ---------- sub-thread ----------
+
+(feed-test
+  "thread from r1 (sub-tree)"
+  (map (fn (a) (get a :object)) (feed/items (feed/thread S "r1")))
+  (list "r1" "r3"))
+(feed-test "thread size r1" (feed/thread-size S "r1") 2)
+(feed-test "leaf thread is itself" (feed/thread-size S "r3") 1)
+(feed-test "unrelated thread is itself" (feed/thread-size S "x") 1)

lib/feed/tests/trending.sx

@@ -0,0 +1,82 @@
+; Follow-up — trending objects/actors by recent activity. (feed-test name got expected)
+
+; window (50,100]: X@60,X@70 (a), Y@80 (b), Z@90 (c); W@40 is too old
+(define
+  S
+  (feed/stream
+    (list
+      (feed/activity "a" "post" "X" 60 (list))
+      (feed/activity "a" "post" "X" 70 (list))
+      (feed/activity "b" "post" "Y" 80 (list))
+      (feed/activity "c" "post" "Z" 90 (list))
+      (feed/activity "d" "post" "W" 40 (list)))))
+
+; ---------- trending objects ----------
+
+(feed-test
+  "trending count (3 in window)"
+  (len (feed/trending S 100 50 10))
+  3)
+(feed-test
+  "trending top object"
+  (get
+    (nth (feed/trending S 100 50 10) 0)
+    :object)
+  "X")
+(feed-test
+  "trending top count"
+  (get
+    (nth (feed/trending S 100 50 10) 0)
+    :count)
+  2)
+(feed-test
+  "trending order (count desc, key asc tiebreak)"
+  (map
+    (fn (e) (get e :object))
+    (feed/trending S 100 50 10))
+  (list "X" "Y" "Z"))
+(feed-test
+  "trending top-2"
+  (map
+    (fn (e) (get e :object))
+    (feed/trending S 100 50 2))
+  (list "X" "Y"))
+(feed-test
+  "old object W excluded"
+  (feed/-elem?
+    "W"
+    (map
+      (fn (e) (get e :object))
+      (feed/trending S 100 50 10)))
+  false)
+(feed-test
+  "narrow window keeps only newest"
+  (map
+    (fn (e) (get e :object))
+    (feed/trending S 100 15 10))
+  (list "Z"))
+(feed-test
+  "empty window -> nothing"
+  (feed/trending S 100 5 10)
+  (list))
+
+; ---------- trending actors ----------
+
+(feed-test
+  "trending actor top"
+  (get
+    (nth (feed/trending-actors S 100 50 10) 0)
+    :actor)
+  "a")
+(feed-test
+  "trending actor count"
+  (get
+    (nth (feed/trending-actors S 100 50 10) 0)
+    :count)
+  2)
+(feed-test
+  "trending actors order"
+  (map
+    (fn (e) (get e :actor))
+    (feed/trending-actors S 100 50 10))
+  (list "a" "b" "c"))

lib/feed/thread.sx

@@ -0,0 +1,59 @@
+; feed/thread — conversation threading. A reply carries :reply-to <parent-object>
+; (normalize preserves it). A thread is the transitive closure over :reply-to from
+; a root object: root + replies + replies-to-replies, gathered chronologically.
+;
+; Requires: lib/feed/normalize.sx, lib/feed/stream.sx, lib/feed/fanout.sx
+; (feed/-elem?, feed/-distinct).
+
+; direct replies to an object
+(define
+  feed/replies
+  (fn
+    (stream object)
+    (feed/filter stream (fn (a) (equal? (get a :reply-to) object)))))
+
+(define
+  feed/reply-count
+  (fn (stream object) (feed/count (feed/replies stream object))))
+
+; iterate f from x until the result stops growing (set-closure fixpoint)
+(define
+  feed/-fixpoint
+  (fn
+    (f x)
+    (let
+      ((nx (f x)))
+      (if (= (len nx) (len x)) x (feed/-fixpoint f nx)))))
+
+; the set of object-ids in the thread rooted at `root`
+(define
+  feed/thread-objects
+  (fn
+    (stream root)
+    (let
+      ((all (feed/items stream)))
+      (feed/-fixpoint
+        (fn
+          (acc)
+          (feed/-distinct
+            (append
+              acc
+              (map
+                (fn (a) (get a :object))
+                (filter (fn (a) (feed/-elem? (get a :reply-to) acc)) all)))))
+        (list root)))))
+
+; the full thread as a chronological stream (root + all descendants)
+(define
+  feed/thread
+  (fn
+    (stream root)
+    (let
+      ((objs (feed/thread-objects stream root)))
+      (feed/sort-by-at
+        (feed/filter stream (fn (a) (feed/-elem? (get a :object) objs)))))))
+
+; how many activities are in the thread (root counts as 1)
+(define
+  feed/thread-size
+  (fn (stream root) (feed/count (feed/thread stream root))))

lib/feed/trending.sx

@@ -0,0 +1,42 @@
+; feed/trending — what's hot right now: objects (or actors) ranked by activity
+; count within a recency window. Deterministic: count descending, ties broken by
+; key ascending (entries are pre-sorted by key, then stable grade-down by count).
+;
+; Requires: lib/feed/stream.sx, lib/feed/aggregate.sx (object/actor-counts),
+; lib/feed/rank.sx (feed/-desc-by).
+
+; activities within (now-window, now]
+(define
+  feed/-recent
+  (fn
+    (stream now window)
+    (feed/filter
+      stream
+      (fn (a) (and (<= (get a :at) now) (> (get a :at) (- now window)))))))
+
+; counts dict -> top-N entries {label key, :count n}, count desc, key asc
+(define
+  feed/-top-counts
+  (fn
+    (counts label n)
+    (let
+      ((entries (map (fn (k) (assoc {:count (get counts k)} label k)) (sort (keys counts)))))
+      (take (feed/-desc-by entries (fn (e) (get e :count))) n))))
+
+; top-N trending objects in the window
+(define
+  feed/trending
+  (fn
+    (stream now window n)
+    (feed/-top-counts
+      (feed/object-counts (feed/-recent stream now window))
+      :object n)))
+
+; top-N most active actors in the window
+(define
+  feed/trending-actors
+  (fn
+    (stream now window n)
+    (feed/-top-counts
+      (feed/actor-counts (feed/-recent stream now window))
+      :actor n)))

lib/go/conformance.sh

@@ -0,0 +1,141 @@
+#!/usr/bin/env bash
+# Go-on-SX conformance runner.
+#
+# Loads every Go-on-SX test suite via the epoch protocol, collects
+# pass/fail counts, and writes lib/go/scoreboard.json + .md.
+#
+# Usage:
+#   bash lib/go/conformance.sh           # run all suites
+#   bash lib/go/conformance.sh -v        # verbose per-suite
+
+set -uo pipefail
+cd "$(git rev-parse --show-toplevel)"
+
+SX_SERVER="${SX_SERVER:-hosts/ocaml/_build/default/bin/sx_server.exe}"
+if [ ! -x "$SX_SERVER" ]; then
+  SX_SERVER="/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe"
+fi
+if [ ! -x "$SX_SERVER" ]; then
+  echo "ERROR: sx_server.exe not found." >&2
+  exit 1
+fi
+
+VERBOSE="${1:-}"
+TMPFILE=$(mktemp)
+OUTFILE=$(mktemp)
+trap "rm -f $TMPFILE $OUTFILE" EXIT
+
+# Each suite: name | pass-counter | total-counter
+SUITES=(
+  "lex|go-test-pass|go-test-count"
+  "parse|go-parse-test-pass|go-parse-test-count"
+  "types|go-types-test-pass|go-types-test-count"
+  "eval|go-eval-test-pass|go-eval-test-count"
+  "runtime|go-rt-test-pass|go-rt-test-count"
+  "stdlib|go-std-test-pass|go-std-test-count"
+  "e2e|go-e2e-test-pass|go-e2e-test-count"
+)
+
+cat > "$TMPFILE" <<'EPOCHS'
+(epoch 1)
+(load "lib/guest/lex.sx")
+(load "lib/guest/ast.sx")
+(load "lib/guest/pratt.sx")
+(load "lib/go/lex.sx")
+(load "lib/go/parse.sx")
+(load "lib/go/types.sx")
+(load "lib/go/sched.sx")
+(load "lib/go/eval.sx")
+(load "lib/go/std/strings.sx")
+(load "lib/go/std/strconv.sx")
+(load "lib/go/tests/lex.sx")
+(load "lib/go/tests/parse.sx")
+(load "lib/go/tests/types.sx")
+(load "lib/go/tests/eval.sx")
+(load "lib/go/tests/runtime.sx")
+(load "lib/go/tests/stdlib.sx")
+(load "lib/go/tests/e2e.sx")
+EPOCHS
+
+idx=0
+for entry in "${SUITES[@]}"; do
+  name="${entry%%|*}"
+  pass_var=$(echo "$entry" | awk -F'|' '{print $2}')
+  total_var=$(echo "$entry" | awk -F'|' '{print $3}')
+  epoch=$((100 + idx))
+  echo "(epoch $epoch)" >> "$TMPFILE"
+  echo "(eval \"(list $pass_var $total_var)\")" >> "$TMPFILE"
+  idx=$((idx + 1))
+done
+
+"$SX_SERVER" < "$TMPFILE" > "$OUTFILE" 2>&1
+
+parse_pair() {
+  local epoch="$1"
+  local line
+  line=$(grep -A1 "^(ok-len $epoch " "$OUTFILE" | tail -1)
+  echo "$line" | sed -E 's/[()]//g'
+}
+
+TOTAL_PASS=0
+TOTAL_COUNT=0
+JSON_SUITES=""
+MD_ROWS=""
+
+idx=0
+for entry in "${SUITES[@]}"; do
+  name="${entry%%|*}"
+  epoch=$((100 + idx))
+  pair=$(parse_pair "$epoch")
+  pass=$(echo "$pair" | awk '{print $1}')
+  count=$(echo "$pair" | awk '{print $2}')
+  if [ -z "$pass" ] || [ -z "$count" ]; then
+    pass=0
+    count=0
+  fi
+  TOTAL_PASS=$((TOTAL_PASS + pass))
+  TOTAL_COUNT=$((TOTAL_COUNT + count))
+  status="ok"
+  marker="✅"
+  if [ "$pass" != "$count" ]; then
+    status="fail"
+    marker="❌"
+  fi
+  if [ "$VERBOSE" = "-v" ]; then
+    printf "  %-12s %s/%s\n" "$name" "$pass" "$count"
+  fi
+  if [ -n "$JSON_SUITES" ]; then JSON_SUITES+=","; fi
+  JSON_SUITES+=$'\n    '
+  JSON_SUITES+="{\"name\":\"$name\",\"pass\":$pass,\"total\":$count,\"status\":\"$status\"}"
+  MD_ROWS+="| $marker | $name | $pass | $count |"$'\n'
+  idx=$((idx + 1))
+done
+
+printf '\nGo-on-SX conformance: %d / %d\n' "$TOTAL_PASS" "$TOTAL_COUNT"
+
+cat > lib/go/scoreboard.json <<JSON
+{
+  "language": "go",
+  "total_pass": $TOTAL_PASS,
+  "total": $TOTAL_COUNT,
+  "suites": [$JSON_SUITES]
+}
+JSON
+
+cat > lib/go/scoreboard.md <<MD
+# Go-on-SX Scoreboard
+
+**Total: ${TOTAL_PASS} / ${TOTAL_COUNT} tests passing**
+
+|  | Suite | Pass | Total |
+|---|---|---|---|
+$MD_ROWS
+
+Generated by \`lib/go/conformance.sh\`.
+MD
+
+if [ "$TOTAL_PASS" -eq "$TOTAL_COUNT" ]; then
+  exit 0
+else
+  exit 1
+fi

lib/go/lex.sx

@@ -0,0 +1,476 @@
+;; lib/go/lex.sx — Go tokenizer with automatic semicolon insertion.
+;;
+;; Consumes lib/guest/lex.sx character-class predicates.
+;;
+;; Tokens: {:type T :value V :pos P}
+;; Types:
+;;   "ident"   — identifiers (foo, _bar, mixedCase)
+;;   "keyword" — one of the 25 Go keywords
+;;   "int"     — integer literals (decimal, 0x.. hex, 0b.. binary, 0o.. octal,
+;;               legacy 0123 octal; underscores between digits allowed)
+;;   "float"   — decimal float literals (3.14, .5, 1., 1e10, 1.5e-3, 1E5)
+;;   "imag"    — imaginary literals (2i, 3.14i, 1e2i)
+;;   "string"  — interpreted string literals "..." OR raw string literals `...`
+;;   "rune"    — rune literals 'x' (single char + simple escapes)
+;;   "op"      — operators & punctuation; :value is the literal text
+;;   "semi"    — explicit ';' or auto-inserted (Go spec § Semicolons)
+;;   "eof"     — end-of-input sentinel
+;;
+;; ASI (Go spec § Semicolons): a newline (or EOF, or a block comment
+;; containing a newline) emits a ";semi" if the previous emitted token's
+;; type is ident/int/float/imag/string/rune, or its value is one of
+;;   {break, continue, fallthrough, return, ++, --, ), ], }}.
+;;
+;; All scanner locals are gl- prefixed: SX host primitives (peek/emit/etc.)
+;; silently shadow guest-language defines. See feedback_sx_bind_clash.
+
+(define
+  go-keywords
+  (list
+    "break"
+    "case"
+    "chan"
+    "const"
+    "continue"
+    "default"
+    "defer"
+    "else"
+    "fallthrough"
+    "for"
+    "func"
+    "go"
+    "goto"
+    "if"
+    "import"
+    "interface"
+    "map"
+    "package"
+    "range"
+    "return"
+    "select"
+    "struct"
+    "switch"
+    "type"
+    "var"))
+
+(define go-keyword? (fn (s) (some (fn (k) (= k s)) go-keywords)))
+
+(define go-asi-keywords (list "break" "continue" "fallthrough" "return"))
+
+(define go-asi-ops (list "++" "--" ")" "]" "}"))
+
+(define go-asi-lit-types (list "ident" "int" "float" "imag" "string" "rune"))
+
+(define
+  go-asi-trigger?
+  (fn
+    (tok)
+    (if
+      (= tok nil)
+      false
+      (let
+        ((ty (get tok :type)) (v (get tok :value)))
+        (or
+          (some (fn (lt) (= lt ty)) go-asi-lit-types)
+          (and (= ty "keyword") (some (fn (k) (= k v)) go-asi-keywords))
+          (and (= ty "op") (some (fn (o) (= o v)) go-asi-ops)))))))
+
+(define
+  go-tokenize
+  (fn
+    (src)
+    (let
+      ((tokens (list)) (pos 0) (src-len (len src)))
+      (define
+        gl-peek
+        (fn
+          (offset)
+          (if (< (+ pos offset) src-len) (nth src (+ pos offset)) nil)))
+      (define gl-cur (fn () (gl-peek 0)))
+      (define gl-advance! (fn (n) (set! pos (+ pos n))))
+      (define
+        gl-last
+        (fn
+          ()
+          (if
+            (= (len tokens) 0)
+            nil
+            (nth tokens (- (len tokens) 1)))))
+      (define gl-emit! (fn (type value start) (append! tokens {:type type :value value :pos start})))
+      (define
+        gl-maybe-asi!
+        (fn
+          (at)
+          (when (go-asi-trigger? (gl-last)) (gl-emit! "semi" "\n" at))))
+      (define
+        gl-oct-digit?
+        (fn (c) (and (not (= c nil)) (>= c "0") (<= c "7"))))
+      (define gl-bin-digit? (fn (c) (or (= c "0") (= c "1"))))
+      (define
+        gl-skip-line!
+        (fn
+          ()
+          (when
+            (and (< pos src-len) (not (= (gl-cur) "\n")))
+            (gl-advance! 1)
+            (gl-skip-line!))))
+      (define
+        gl-skip-block!
+        (fn
+          (saw-nl)
+          (cond
+            (>= pos src-len)
+            saw-nl
+            (and (= (gl-cur) "*") (= (gl-peek 1) "/"))
+            (do (gl-advance! 2) saw-nl)
+            :else (let
+              ((is-nl (= (gl-cur) "\n")))
+              (gl-advance! 1)
+              (gl-skip-block! (or saw-nl is-nl))))))
+      (define
+        gl-read-ident!
+        (fn
+          (start)
+          (when
+            (and (< pos src-len) (lex-ident-char? (gl-cur)))
+            (gl-advance! 1)
+            (gl-read-ident! start))
+          (slice src start pos)))
+      (define
+        gl-read-digit-run!
+        (fn
+          (digit?)
+          (when
+            (and (< pos src-len) (or (digit? (gl-cur)) (= (gl-cur) "_")))
+            (gl-advance! 1)
+            (gl-read-digit-run! digit?))))
+      (define
+        gl-finish-number!
+        (fn
+          (has-fraction?)
+          (let
+            ((typ (if has-fraction? "float" "int")))
+            (when
+              (or (= (gl-cur) "e") (= (gl-cur) "E"))
+              (gl-advance! 1)
+              (when
+                (or (= (gl-cur) "+") (= (gl-cur) "-"))
+                (gl-advance! 1))
+              (gl-read-digit-run! lex-digit?)
+              (set! typ "float"))
+            (cond
+              (= (gl-cur) "i")
+              (do (gl-advance! 1) "imag")
+              :else typ))))
+      (define
+        gl-read-number!
+        (fn
+          ()
+          (cond
+            (and (= (gl-cur) ".") (lex-digit? (gl-peek 1)))
+            (do
+              (gl-advance! 1)
+              (gl-read-digit-run! lex-digit?)
+              (gl-finish-number! true))
+            (and
+              (= (gl-cur) "0")
+              (or
+                (= (gl-peek 1) "x")
+                (= (gl-peek 1) "X")))
+            (do
+              (gl-advance! 2)
+              (gl-read-digit-run! lex-hex-digit?)
+              "int")
+            (and
+              (= (gl-cur) "0")
+              (or
+                (= (gl-peek 1) "b")
+                (= (gl-peek 1) "B")))
+            (do
+              (gl-advance! 2)
+              (gl-read-digit-run! gl-bin-digit?)
+              "int")
+            (and
+              (= (gl-cur) "0")
+              (or
+                (= (gl-peek 1) "o")
+                (= (gl-peek 1) "O")))
+            (do
+              (gl-advance! 2)
+              (gl-read-digit-run! gl-oct-digit?)
+              "int")
+            :else (do
+              (gl-read-digit-run! lex-digit?)
+              (cond
+                (and (= (gl-cur) ".") (not (= (gl-peek 1) ".")))
+                (do
+                  (gl-advance! 1)
+                  (gl-read-digit-run! lex-digit?)
+                  (gl-finish-number! true))
+                :else (gl-finish-number! false))))))
+      (define
+        gl-read-string!
+        (fn
+          ()
+          (gl-advance! 1)
+          (let
+            ((chars (list)))
+            (define
+              gl-string-loop
+              (fn
+                ()
+                (cond
+                  (>= pos src-len)
+                  nil
+                  (= (gl-cur) "\"")
+                  (gl-advance! 1)
+                  (= (gl-cur) "\\")
+                  (do
+                    (gl-advance! 1)
+                    (when
+                      (< pos src-len)
+                      (let
+                        ((ch (gl-cur)))
+                        (cond
+                          (= ch "n")
+                          (append! chars "\n")
+                          (= ch "t")
+                          (append! chars "\t")
+                          (= ch "r")
+                          (append! chars "\r")
+                          (= ch "\\")
+                          (append! chars "\\")
+                          (= ch "\"")
+                          (append! chars "\"")
+                          (= ch "'")
+                          (append! chars "'")
+                          :else (append! chars ch))
+                        (gl-advance! 1)))
+                    (gl-string-loop))
+                  :else (do
+                    (append! chars (gl-cur))
+                    (gl-advance! 1)
+                    (gl-string-loop)))))
+            (gl-string-loop)
+            (join "" chars))))
+      (define
+        gl-read-raw-string!
+        (fn
+          ()
+          (gl-advance! 1)
+          (let
+            ((chars (list)))
+            (define
+              gl-raw-loop
+              (fn
+                ()
+                (cond
+                  (>= pos src-len)
+                  nil
+                  (= (gl-cur) "`")
+                  (gl-advance! 1)
+                  (= (gl-cur) "\r")
+                  (do (gl-advance! 1) (gl-raw-loop))
+                  :else (do
+                    (append! chars (gl-cur))
+                    (gl-advance! 1)
+                    (gl-raw-loop)))))
+            (gl-raw-loop)
+            (join "" chars))))
+      (define
+        gl-read-rune!
+        (fn
+          ()
+          (gl-advance! 1)
+          (let
+            ((chars (list)))
+            (cond
+              (and (< pos src-len) (= (gl-cur) "\\"))
+              (do
+                (gl-advance! 1)
+                (when
+                  (< pos src-len)
+                  (let
+                    ((ch (gl-cur)))
+                    (cond
+                      (= ch "n")
+                      (append! chars "\n")
+                      (= ch "t")
+                      (append! chars "\t")
+                      (= ch "r")
+                      (append! chars "\r")
+                      (= ch "\\")
+                      (append! chars "\\")
+                      (= ch "'")
+                      (append! chars "'")
+                      (= ch "\"")
+                      (append! chars "\"")
+                      :else (append! chars ch))
+                    (gl-advance! 1))))
+              (< pos src-len)
+              (do (append! chars (gl-cur)) (gl-advance! 1)))
+            (when
+              (and (< pos src-len) (= (gl-cur) "'"))
+              (gl-advance! 1))
+            (join "" chars))))
+      (define
+        gl-match-op
+        (fn
+          ()
+          (let
+            ((c0 (gl-cur))
+              (c1 (gl-peek 1))
+              (c2 (gl-peek 2)))
+            (cond
+              (and (= c0 "<") (= c1 "<") (= c2 "="))
+              "<<="
+              (and (= c0 ">") (= c1 ">") (= c2 "="))
+              ">>="
+              (and (= c0 "&") (= c1 "^") (= c2 "="))
+              "&^="
+              (and (= c0 ".") (= c1 ".") (= c2 "."))
+              "..."
+              (and (= c0 "=") (= c1 "="))
+              "=="
+              (and (= c0 "!") (= c1 "="))
+              "!="
+              (and (= c0 "<") (= c1 "="))
+              "<="
+              (and (= c0 ">") (= c1 "="))
+              ">="
+              (and (= c0 "&") (= c1 "&"))
+              "&&"
+              (and (= c0 "|") (= c1 "|"))
+              "||"
+              (and (= c0 "+") (= c1 "+"))
+              "++"
+              (and (= c0 "-") (= c1 "-"))
+              "--"
+              (and (= c0 "<") (= c1 "<"))
+              "<<"
+              (and (= c0 ">") (= c1 ">"))
+              ">>"
+              (and (= c0 "+") (= c1 "="))
+              "+="
+              (and (= c0 "-") (= c1 "="))
+              "-="
+              (and (= c0 "*") (= c1 "="))
+              "*="
+              (and (= c0 "/") (= c1 "="))
+              "/="
+              (and (= c0 "%") (= c1 "="))
+              "%="
+              (and (= c0 "&") (= c1 "="))
+              "&="
+              (and (= c0 "|") (= c1 "="))
+              "|="
+              (and (= c0 "^") (= c1 "="))
+              "^="
+              (and (= c0 ":") (= c1 "="))
+              ":="
+              (and (= c0 "<") (= c1 "-"))
+              "<-"
+              (and (= c0 "&") (= c1 "^"))
+              "&^"
+              (or
+                (= c0 "+")
+                (= c0 "-")
+                (= c0 "*")
+                (= c0 "/")
+                (= c0 "%")
+                (= c0 "&")
+                (= c0 "|")
+                (= c0 "^")
+                (= c0 "<")
+                (= c0 ">")
+                (= c0 "=")
+                (= c0 "!")
+                (= c0 "(")
+                (= c0 ")")
+                (= c0 "{")
+                (= c0 "}")
+                (= c0 "[")
+                (= c0 "]")
+                (= c0 ",")
+                (= c0 ".")
+                (= c0 ":")
+                (= c0 "~"))
+              c0
+              :else nil))))
+      (define
+        gl-scan!
+        (fn
+          ()
+          (cond
+            (>= pos src-len)
+            nil
+            (= (gl-cur) "\n")
+            (do (gl-maybe-asi! pos) (gl-advance! 1) (gl-scan!))
+            (lex-space? (gl-cur))
+            (do (gl-advance! 1) (gl-scan!))
+            (and (= (gl-cur) "/") (= (gl-peek 1) "/"))
+            (do (gl-advance! 2) (gl-skip-line!) (gl-scan!))
+            (and (= (gl-cur) "/") (= (gl-peek 1) "*"))
+            (do
+              (gl-advance! 2)
+              (let
+                ((saw-nl (gl-skip-block! false)))
+                (when saw-nl (gl-maybe-asi! pos)))
+              (gl-scan!))
+            (= (gl-cur) ";")
+            (do
+              (gl-emit! "semi" ";" pos)
+              (gl-advance! 1)
+              (gl-scan!))
+            (lex-ident-start? (gl-cur))
+            (do
+              (let
+                ((start pos))
+                (gl-read-ident! start)
+                (let
+                  ((word (slice src start pos)))
+                  (gl-emit!
+                    (if (go-keyword? word) "keyword" "ident")
+                    word
+                    start)))
+              (gl-scan!))
+            (lex-digit? (gl-cur))
+            (do
+              (let
+                ((start pos) (typ (gl-read-number!)))
+                (gl-emit! typ (slice src start pos) start))
+              (gl-scan!))
+            (and (= (gl-cur) ".") (lex-digit? (gl-peek 1)))
+            (do
+              (let
+                ((start pos) (typ (gl-read-number!)))
+                (gl-emit! typ (slice src start pos) start))
+              (gl-scan!))
+            (= (gl-cur) "\"")
+            (let
+              ((start pos) (v (gl-read-string!)))
+              (gl-emit! "string" v start)
+              (gl-scan!))
+            (= (gl-cur) "`")
+            (let
+              ((start pos) (v (gl-read-raw-string!)))
+              (gl-emit! "string" v start)
+              (gl-scan!))
+            (= (gl-cur) "'")
+            (let
+              ((start pos) (v (gl-read-rune!)))
+              (gl-emit! "rune" v start)
+              (gl-scan!))
+            :else (let
+              ((op (gl-match-op)))
+              (cond
+                op
+                (do
+                  (gl-emit! "op" op pos)
+                  (gl-advance! (len op))
+                  (gl-scan!))
+                :else (do (gl-advance! 1) (gl-scan!)))))))
+      (gl-scan!)
+      (gl-maybe-asi! pos)
+      (gl-emit! "eof" nil pos)
+      tokens)))

lib/go/sched.sx

@@ -0,0 +1,66 @@
+;; lib/go/sched.sx — Go scheduler primitives: channels + goroutines.
+;;
+;; This is **the independent implementation** referenced by
+;; plans/lib-guest-scheduler.md. The shape that emerges here informs
+;; the eventual sister kit; this file's structures are the Phase 5
+;; "first-consumer" cut.
+;;
+;; v0 concurrency model — IMPORTANT
+;;
+;; SX has no first-class continuations exposed to guest code, so we
+;; can't suspend a goroutine mid-statement. v0 runs `go f()` SYNCHRO-
+;; NOUSLY (it's an immediate call whose return value is dropped). This
+;; preserves the right semantics for patterns where the spawned
+;; goroutine simply pushes to a channel that the main goroutine then
+;; receives — because the spawned goroutine runs to completion first
+;; and leaves the value in the channel buffer.
+;;
+;; True preemption with blocking sends/recvs is a Phase 5b refinement.
+;; The sister-plan diary tracks the design insight (single
+;; sched-spawn primitive, channel-op direction tag) so the eventual
+;; kit doesn't bake in v0's synchronous limitation.
+;;
+;; Channel representation
+;;
+;;   (list :go-chan ACCESSORS-FN-LIST)
+;;
+;; ACCESSORS-FN-LIST is a list of closures sharing a mutable buffer
+;; and a closed flag. The closures expose:
+;;   index 1: send-fn     — (lambda (val) ...)
+;;   index 2: recv-fn     — (lambda () val-or-:empty)
+;;   index 3: closed?-fn  — (lambda () bool)
+;;   index 4: close!-fn   — (lambda () ...)
+;;
+;; Channel identity: distinct calls to go-make-chan produce closures
+;; with distinct identity — `(= ch1 ch2)` is false for distinct
+;; channels, matching Go spec § Channel types.
+
+(define
+  go-make-chan
+  (fn
+    ()
+    (let
+      ((buf (list)) (closed false))
+      (list
+        :go-chan (fn (v) (append! buf v) nil)
+        (fn
+          ()
+          (cond
+            (= (len buf) 0)
+            :empty :else
+            (let ((v (first buf))) (set! buf (rest buf)) v)))
+        (fn () closed)
+        (fn () (set! closed true) nil)
+        (fn () (len buf))))))
+
+(define
+  go-chan?
+  (fn
+    (v)
+    (and (list? v) (not (= (len v) 0)) (= (first v) :go-chan))))
+
+(define go-chan-send! (fn (ch val) ((nth ch 1) val)))
+(define go-chan-recv! (fn (ch) ((nth ch 2))))
+(define go-chan-closed? (fn (ch) ((nth ch 3))))
+(define go-chan-close! (fn (ch) ((nth ch 4))))
+(define go-chan-len    (fn (ch) ((nth ch 5))))

lib/go/scoreboard.json

@@ -0,0 +1,13 @@
+{
+  "language": "go",
+  "total_pass": 609,
+  "total": 609,
+  "suites": [
+    {"name":"lex","pass":129,"total":129,"status":"ok"},
+    {"name":"parse","pass":179,"total":179,"status":"ok"},
+    {"name":"types","pass":102,"total":102,"status":"ok"},
+    {"name":"eval","pass":106,"total":106,"status":"ok"},
+    {"name":"runtime","pass":40,"total":40,"status":"ok"},
+    {"name":"stdlib","pass":41,"total":41,"status":"ok"},
+    {"name":"e2e","pass":12,"total":12,"status":"ok"}]
+}

lib/go/scoreboard.md

@@ -0,0 +1,16 @@
+# Go-on-SX Scoreboard
+
+**Total: 609 / 609 tests passing**
+
+|  | Suite | Pass | Total |
+|---|---|---|---|
+| ✅ | lex | 129 | 129 |
+| ✅ | parse | 179 | 179 |
+| ✅ | types | 102 | 102 |
+| ✅ | eval | 106 | 106 |
+| ✅ | runtime | 40 | 40 |
+| ✅ | stdlib | 41 | 41 |
+| ✅ | e2e | 12 | 12 |
+
+
+Generated by `lib/go/conformance.sh`.

lib/go/std/strconv.sx

@@ -0,0 +1,71 @@
+;; lib/go/std/strconv.sx — Go's `strconv` package, v0 subset.
+
+(define
+  go-strconv-itoa
+  ;; Itoa(n) → string. Real Go returns the decimal representation.
+  (fn (args)
+    (cond
+      (not (= (len args) 1))
+      (list :eval-error :strconv-itoa-arity (len args))
+      :else
+      (let ((n (first args)))
+        (cond
+          (not (number? n)) (list :eval-error :strconv-itoa-not-number n)
+          :else (str n))))))
+
+(define
+  go-strconv-atoi
+  ;; Atoi(s) → (int, error). v0 returns just the int on success or
+  ;; an :eval-error on failure (multi-return is a later refinement).
+  (fn (args)
+    (cond
+      (not (= (len args) 1))
+      (list :eval-error :strconv-atoi-arity (len args))
+      :else
+      (let ((s (first args)))
+        (cond
+          (not (string? s)) (list :eval-error :strconv-atoi-not-string s)
+          (= (len s) 0) (list :eval-error :strconv-atoi-empty)
+          :else (go-strconv-parse-int s 0 (= (nth s 0) "-") 0))))))
+
+(define
+  go-strconv-parse-int
+  ;; Parse a (possibly signed) base-10 integer literal. Stops on the
+  ;; first non-digit char and returns the parsed prefix, or :eval-error
+  ;; if no digits were consumed.
+  (fn (s start neg acc)
+    (let ((i (cond (= start 0) (cond neg 1 :else 0) :else start)))
+      (cond
+        (>= i (len s))
+        (cond
+          (= (cond neg (- i 1) :else i) 0)
+          (list :eval-error :strconv-atoi-no-digits s)
+          :else
+          (cond neg (- 0 acc) :else acc))
+        :else
+        (let ((d (go-strconv-digit (nth s i))))
+          (cond
+            (< d 0)
+            (cond
+              (= (cond neg (- i 1) :else i) 0)
+              (list :eval-error :strconv-atoi-no-digits s)
+              :else
+              (cond neg (- 0 acc) :else acc))
+            :else
+            (go-strconv-parse-int s (+ i 1) neg (+ (* acc 10) d))))))))
+
+(define
+  go-strconv-digit
+  (fn (c)
+    (cond
+      (= c "0") 0  (= c "1") 1  (= c "2") 2  (= c "3") 3
+      (= c "4") 4  (= c "5") 5  (= c "6") 6  (= c "7") 7
+      (= c "8") 8  (= c "9") 9
+      :else -1)))
+
+(define
+  go-std-strconv
+  (list :go-package "strconv"
+    (list
+      (list "Itoa" (list :go-builtin-fn go-strconv-itoa))
+      (list "Atoi" (list :go-builtin-fn go-strconv-atoi)))))

lib/go/std/strings.sx

@@ -0,0 +1,386 @@
+;; lib/go/std/strings.sx — Go's `strings` package, v0 subset.
+;;
+;; Exposed as `go-std-strings`, a (:go-package "strings" ENTRIES) value.
+;; Register with `(go-env-extend env "strings" go-std-strings)` to make
+;; `strings.X(...)` call sites work in evaluated Go code.
+;;
+;; Each entry is (FIELD-NAME (list :go-fn PARAMS BODY)) — the same
+;; shape user-defined Go functions get. Bodies are written in SX
+;; directly via go-builtin closures wrapping host-level string ops
+;; for speed, OR as parsed Go source for fidelity. v0 uses
+;; go-builtin wrappers — simpler and fast.
+
+;; ── helpers: implement go-std-strings entries as builtins ────────
+
+(define
+  go-strings-contains
+  (fn (args)
+    (cond
+      (not (= (len args) 2))
+      (list :eval-error :strings-contains-arity (len args))
+      :else
+      (let ((s (first args)) (sub (nth args 1)))
+        (cond
+          (not (string? s)) (list :eval-error :strings-not-string s)
+          (not (string? sub)) (list :eval-error :strings-not-string sub)
+          :else
+          (go-strings-index-of s sub 0))))))
+
+(define
+  go-strings-index-of
+  ;; Returns true if SUB appears in S at or after START, else false.
+  (fn (s sub start)
+    (let ((slen (len s)) (sublen (len sub)))
+      (cond
+        (= sublen 0) true
+        (> (+ start sublen) slen) false
+        (go-strings-match-at s sub start 0) true
+        :else (go-strings-index-of s sub (+ start 1))))))
+
+(define
+  go-strings-match-at
+  (fn (s sub start k)
+    (cond
+      (>= k (len sub)) true
+      (= (nth s (+ start k)) (nth sub k))
+      (go-strings-match-at s sub start (+ k 1))
+      :else false)))
+
+(define
+  go-strings-has-prefix
+  (fn (args)
+    (cond
+      (not (= (len args) 2))
+      (list :eval-error :strings-hasprefix-arity (len args))
+      :else
+      (let ((s (first args)) (p (nth args 1)))
+        (cond
+          (not (string? s)) (list :eval-error :strings-not-string s)
+          (not (string? p)) (list :eval-error :strings-not-string p)
+          (> (len p) (len s)) false
+          :else (go-strings-match-at s p 0 0))))))
+
+(define
+  go-strings-has-suffix
+  (fn (args)
+    (cond
+      (not (= (len args) 2))
+      (list :eval-error :strings-hassuffix-arity (len args))
+      :else
+      (let ((s (first args)) (suf (nth args 1)))
+        (cond
+          (not (string? s)) (list :eval-error :strings-not-string s)
+          (not (string? suf)) (list :eval-error :strings-not-string suf)
+          (> (len suf) (len s)) false
+          :else
+          (go-strings-match-at s suf (- (len s) (len suf)) 0))))))
+
+(define
+  go-strings-index
+  (fn (args)
+    (cond
+      (not (= (len args) 2))
+      (list :eval-error :strings-index-arity (len args))
+      :else
+      (let ((s (first args)) (sub (nth args 1)))
+        (cond
+          (not (string? s)) (list :eval-error :strings-not-string s)
+          (not (string? sub)) (list :eval-error :strings-not-string sub)
+          :else (go-strings-index-loop s sub 0))))))
+
+(define
+  go-strings-index-loop
+  (fn (s sub start)
+    (let ((slen (len s)) (sublen (len sub)))
+      (cond
+        (= sublen 0) 0
+        (> (+ start sublen) slen) -1
+        (go-strings-match-at s sub start 0) start
+        :else (go-strings-index-loop s sub (+ start 1))))))
+
+(define
+  go-strings-repeat
+  (fn (args)
+    (cond
+      (not (= (len args) 2))
+      (list :eval-error :strings-repeat-arity (len args))
+      :else
+      (let ((s (first args)) (n (nth args 1)))
+        (cond
+          (not (string? s)) (list :eval-error :strings-not-string s)
+          (< n 0) (list :eval-error :strings-repeat-negative n)
+          :else (go-strings-repeat-loop s n ""))))))
+
+(define
+  go-strings-repeat-loop
+  (fn (s n acc)
+    (cond
+      (<= n 0) acc
+      :else (go-strings-repeat-loop s (- n 1) (str acc s)))))
+
+(define
+  go-strings-count
+  (fn (args)
+    (cond
+      (not (= (len args) 2))
+      (list :eval-error :strings-count-arity (len args))
+      :else
+      (let ((s (first args)) (sub (nth args 1)))
+        (cond
+          (not (string? s)) (list :eval-error :strings-not-string s)
+          (not (string? sub)) (list :eval-error :strings-not-string sub)
+          :else (go-strings-count-loop s sub 0 0))))))
+
+(define
+  go-strings-count-loop
+  (fn (s sub start acc)
+    (let ((idx (go-strings-index-loop s sub start)))
+      (cond
+        (< idx 0) acc
+        :else
+        (go-strings-count-loop s sub (+ idx (max 1 (len sub))) (+ acc 1))))))
+
+(define
+  go-strings-join
+  (fn (args)
+    (cond
+      (not (= (len args) 2))
+      (list :eval-error :strings-join-arity (len args))
+      :else
+      (let ((sep (nth args 1)) (xs (first args)))
+        (cond
+          (not (string? sep)) (list :eval-error :strings-not-string sep)
+          (not (and (list? xs) (= (first xs) :go-slice)))
+          (list :eval-error :strings-join-not-slice xs)
+          :else (go-strings-join-loop (nth xs 1) sep ""))))))
+
+(define
+  go-strings-join-loop
+  (fn (xs sep acc)
+    (cond
+      (= (len xs) 0) acc
+      (= (len acc) 0) (go-strings-join-loop (rest xs) sep (first xs))
+      :else
+      (go-strings-join-loop (rest xs) sep (str acc sep (first xs))))))
+
+;; ── case conversion ──────────────────────────────────────────────
+
+(define
+  go-strings-char-to-upper
+  (fn (c)
+    (cond
+      (and (>= c "a") (<= c "z"))
+      ;; ASCII uppercase shift: 'a' is 0x61, 'A' is 0x41 → diff 0x20.
+      ;; SX has no charcode primitive, so use a char-pair table.
+      (go-strings-letter-toggle c true)
+      :else c)))
+
+(define
+  go-strings-char-to-lower
+  (fn (c)
+    (cond
+      (and (>= c "A") (<= c "Z"))
+      (go-strings-letter-toggle c false)
+      :else c)))
+
+(define
+  go-strings-letter-toggle
+  ;; Toggle a single ASCII letter's case via direct mapping.
+  ;; `to-upper?` true means input is lowercase, output uppercase.
+  (fn (c to-upper?)
+    (cond
+      to-upper?
+      (cond
+        (= c "a") "A" (= c "b") "B" (= c "c") "C" (= c "d") "D"
+        (= c "e") "E" (= c "f") "F" (= c "g") "G" (= c "h") "H"
+        (= c "i") "I" (= c "j") "J" (= c "k") "K" (= c "l") "L"
+        (= c "m") "M" (= c "n") "N" (= c "o") "O" (= c "p") "P"
+        (= c "q") "Q" (= c "r") "R" (= c "s") "S" (= c "t") "T"
+        (= c "u") "U" (= c "v") "V" (= c "w") "W" (= c "x") "X"
+        (= c "y") "Y" (= c "z") "Z" :else c)
+      :else
+      (cond
+        (= c "A") "a" (= c "B") "b" (= c "C") "c" (= c "D") "d"
+        (= c "E") "e" (= c "F") "f" (= c "G") "g" (= c "H") "h"
+        (= c "I") "i" (= c "J") "j" (= c "K") "k" (= c "L") "l"
+        (= c "M") "m" (= c "N") "n" (= c "O") "o" (= c "P") "p"
+        (= c "Q") "q" (= c "R") "r" (= c "S") "s" (= c "T") "t"
+        (= c "U") "u" (= c "V") "v" (= c "W") "w" (= c "X") "x"
+        (= c "Y") "y" (= c "Z") "z" :else c))))
+
+(define
+  go-strings-map-chars
+  (fn (s i acc char-fn)
+    (cond
+      (>= i (len s)) acc
+      :else
+      (go-strings-map-chars s (+ i 1) (str acc (char-fn (nth s i))) char-fn))))
+
+(define
+  go-strings-to-upper
+  (fn (args)
+    (cond
+      (not (= (len args) 1))
+      (list :eval-error :strings-toupper-arity (len args))
+      :else
+      (let ((s (first args)))
+        (cond
+          (not (string? s)) (list :eval-error :strings-not-string s)
+          :else (go-strings-map-chars s 0 "" go-strings-char-to-upper))))))
+
+(define
+  go-strings-to-lower
+  (fn (args)
+    (cond
+      (not (= (len args) 1))
+      (list :eval-error :strings-tolower-arity (len args))
+      :else
+      (let ((s (first args)))
+        (cond
+          (not (string? s)) (list :eval-error :strings-not-string s)
+          :else (go-strings-map-chars s 0 "" go-strings-char-to-lower))))))
+
+;; ── TrimSpace ────────────────────────────────────────────────────
+
+(define
+  go-strings-is-space?
+  (fn (c)
+    (or (= c " ") (= c "\t") (= c "\n") (= c "\r"))))
+
+(define
+  go-strings-trim-left
+  (fn (s i)
+    (cond
+      (>= i (len s)) i
+      (go-strings-is-space? (nth s i)) (go-strings-trim-left s (+ i 1))
+      :else i)))
+
+(define
+  go-strings-trim-right
+  (fn (s end)
+    (cond
+      (<= end 0) 0
+      (go-strings-is-space? (nth s (- end 1))) (go-strings-trim-right s (- end 1))
+      :else end)))
+
+(define
+  go-strings-substr
+  ;; Substring [lo, hi) — naive but predictable.
+  (fn (s lo hi)
+    (cond
+      (>= lo hi) ""
+      :else
+      (go-strings-substr-loop s lo hi ""))))
+
+(define
+  go-strings-substr-loop
+  (fn (s i hi acc)
+    (cond
+      (>= i hi) acc
+      :else (go-strings-substr-loop s (+ i 1) hi (str acc (nth s i))))))
+
+(define
+  go-strings-trim-space
+  (fn (args)
+    (cond
+      (not (= (len args) 1))
+      (list :eval-error :strings-trimspace-arity (len args))
+      :else
+      (let ((s (first args)))
+        (cond
+          (not (string? s)) (list :eval-error :strings-not-string s)
+          :else
+          (let ((lo (go-strings-trim-left s 0)))
+            (let ((hi (go-strings-trim-right s (len s))))
+              (go-strings-substr s lo hi))))))))
+
+;; ── Split ────────────────────────────────────────────────────────
+
+(define
+  go-strings-split
+  (fn (args)
+    (cond
+      (not (= (len args) 2))
+      (list :eval-error :strings-split-arity (len args))
+      :else
+      (let ((s (first args)) (sep (nth args 1)))
+        (cond
+          (not (string? s)) (list :eval-error :strings-not-string s)
+          (not (string? sep)) (list :eval-error :strings-not-string sep)
+          (= (len sep) 0)
+          ;; Empty separator: real Go splits to all chars; v0 keeps
+          ;; behaviour simple — single-element slice.
+          (list :go-slice (list s))
+          :else
+          (list :go-slice (go-strings-split-loop s sep 0 (list))))))))
+
+(define
+  go-strings-split-loop
+  (fn (s sep start acc)
+    (let ((idx (go-strings-index-loop s sep start)))
+      (cond
+        (< idx 0)
+        (go-strings-split-finalize acc (go-strings-substr s start (len s)))
+        :else
+        (go-strings-split-loop s sep (+ idx (len sep))
+          (go-strings-split-finalize acc
+            (go-strings-substr s start idx)))))))
+
+(define
+  go-strings-split-finalize
+  ;; Append a piece to acc, growing the list in order.
+  (fn (acc piece)
+    (cond
+      (= (len acc) 0) (list piece)
+      :else (go-name-concat acc (list piece)))))
+
+;; ── Replace ──────────────────────────────────────────────────────
+
+(define
+  go-strings-replace
+  ;; Replace(s, old, new, n). n < 0 = all.
+  (fn (args)
+    (cond
+      (not (= (len args) 4))
+      (list :eval-error :strings-replace-arity (len args))
+      :else
+      (let ((s (first args)) (old (nth args 1))
+            (newv (nth args 2)) (n (nth args 3)))
+        (cond
+          (not (string? s)) (list :eval-error :strings-not-string s)
+          (not (string? old)) (list :eval-error :strings-not-string old)
+          (not (string? newv)) (list :eval-error :strings-not-string newv)
+          (= (len old) 0) s
+          :else (go-strings-replace-loop s old newv n 0 ""))))))
+
+(define
+  go-strings-replace-loop
+  (fn (s old newv n start acc)
+    (let ((idx (go-strings-index-loop s old start)))
+      (cond
+        (or (< idx 0) (= n 0))
+        (str acc (go-strings-substr s start (len s)))
+        :else
+        (go-strings-replace-loop s old newv
+          (cond (< n 0) -1 :else (- n 1))
+          (+ idx (len old))
+          (str acc (go-strings-substr s start idx) newv))))))
+
+;; ── go-std-strings package value ─────────────────────────────────
+
+(define
+  go-std-strings
+  (list :go-package "strings"
+    (list
+      (list "Contains"  (list :go-builtin-fn go-strings-contains))
+      (list "HasPrefix" (list :go-builtin-fn go-strings-has-prefix))
+      (list "HasSuffix" (list :go-builtin-fn go-strings-has-suffix))
+      (list "Index"     (list :go-builtin-fn go-strings-index))
+      (list "Count"     (list :go-builtin-fn go-strings-count))
+      (list "Repeat"    (list :go-builtin-fn go-strings-repeat))
+      (list "Join"      (list :go-builtin-fn go-strings-join))
+      (list "ToUpper"   (list :go-builtin-fn go-strings-to-upper))
+      (list "ToLower"   (list :go-builtin-fn go-strings-to-lower))
+      (list "TrimSpace" (list :go-builtin-fn go-strings-trim-space))
+      (list "Split"     (list :go-builtin-fn go-strings-split))
+      (list "Replace"   (list :go-builtin-fn go-strings-replace)))))

lib/go/tests/e2e.sx

@@ -0,0 +1,186 @@
+;; Go end-to-end tests — complete programs exercising lex+parse+
+;; types+eval+sched+stdlib together. Each test runs a multi-line Go
+;; program and inspects the final env.
+
+(define go-e2e-test-count 0)
+(define go-e2e-test-pass 0)
+(define go-e2e-test-fails (list))
+
+(define
+  go-e2e-test
+  (fn (name actual expected)
+    (set! go-e2e-test-count (+ go-e2e-test-count 1))
+    (if (= actual expected)
+      (set! go-e2e-test-pass (+ go-e2e-test-pass 1))
+      (append! go-e2e-test-fails
+        {:name name :expected expected :actual actual}))))
+
+(define
+  go-e2e-env
+  (go-env-extend
+    (go-env-extend go-env-builtins "strings" go-std-strings)
+    "strconv" go-std-strconv))
+
+(define
+  go-e2e-run
+  (fn (src-list)
+    (go-eval-program go-e2e-env (map go-parse src-list))))
+
+;; ── 1. Sieve via boolean slice (no modulo needed) ────────────────
+(go-e2e-test "e2e: sieve-of-Eratosthenes via boolean slice — count primes ≤ 30"
+  (let ((env (go-e2e-run
+              (list
+                ;; sieve[i] true means i is COMPOSITE (saves the
+                ;; default-bool initialisation for primes).
+                "sieve := []bool{false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false}"
+                "for p := 2; p < 31; p = p + 1 { if sieve[p] == false { for k := p + p; k < 31; k = k + p { sieve[k] = true } } }"
+                "count := 0"
+                "for i := 2; i < 31; i = i + 1 { if sieve[i] == false { count = count + 1 } }"))))
+    (go-env-lookup env "count"))
+  ;; primes ≤ 30: 2,3,5,7,11,13,17,19,23,29 = 10
+  10)
+
+;; ── 1b. Range-membership check (works without mod) ───────────────
+(go-e2e-test "e2e: linear search across slice of strings"
+  (let ((env (go-e2e-run
+              (list
+                "words := []string{\"apple\", \"banana\", \"cherry\", \"date\"}"
+                "func indexOf(xs []string, target string) int { for i, v := range xs { if v == target { return i } } ; return -1 }"
+                "i := indexOf(words, \"cherry\")"
+                "missing := indexOf(words, \"xyz\")"))))
+    (list (go-env-lookup env "i") (go-env-lookup env "missing")))
+  (list 2 -1))
+
+;; ── 2. Reverse a slice ───────────────────────────────────────────
+(go-e2e-test "e2e: reverse a slice of ints"
+  (let ((env (go-e2e-run
+              (list
+                "func reverse(xs []int) []int { r := []int{} ; for i := len(xs) - 1; i >= 0; i = i - 1 { r = append(r, xs[i]) } ; return r }"
+                "out := reverse([]int{1, 2, 3, 4, 5})"))))
+    (go-env-lookup env "out"))
+  (list :go-slice (list 5 4 3 2 1)))
+
+;; ── 3. Fibonacci (recursive) ─────────────────────────────────────
+(go-e2e-test "e2e: fib(10) = 55"
+  (let ((env (go-e2e-run
+              (list
+                "func fib(n int) int { if n < 2 { return n } ; return fib(n-1) + fib(n-2) }"
+                "r := fib(10)"))))
+    (go-env-lookup env "r"))
+  55)
+
+;; ── 4. Sum-of-squares via Map+Reduce ─────────────────────────────
+(go-e2e-test "e2e: sum-of-squares 1..5 via Map+Reduce"
+  (let ((env (go-e2e-run
+              (list
+                "func Map[T any, U any](xs []T, f func(T) U) []U { r := []int{} ; for i, v := range xs { r = append(r, f(v)) } ; return r }"
+                "func Reduce[T any, U any](xs []T, seed U, f func(U, T) U) U { acc := seed ; for i, v := range xs { acc = f(acc, v) } ; return acc }"
+                "func sq(x int) int { return x * x }"
+                "func add(a int, b int) int { return a + b }"
+                "squares := Map([]int{1, 2, 3, 4, 5}, sq)"
+                "total := Reduce(squares, 0, add)"))))
+    (go-env-lookup env "total"))
+  ;; 1 + 4 + 9 + 16 + 25 = 55
+  55)
+
+;; ── 5. Word frequency counter ────────────────────────────────────
+(go-e2e-test "e2e: word-frequency over a sentence"
+  (let ((env (go-e2e-run
+              (list
+                "text := \"the quick brown fox jumps over the lazy dog the\""
+                "words := strings.Split(text, \" \")"
+                "counts := map[string]int{}"
+                "for i, w := range words { counts[w] = counts[w] + 1 }"
+                "the_count := counts[\"the\"]"
+                "fox_count := counts[\"fox\"]"
+                "dog_count := counts[\"dog\"]"))))
+    (list (go-env-lookup env "the_count")
+          (go-env-lookup env "fox_count")
+          (go-env-lookup env "dog_count")))
+  (list 3 1 1))
+
+;; ── 6. Pipeline via channels ─────────────────────────────────────
+(go-e2e-test "e2e: pipeline — generate, square, sum"
+  (let ((env (go-e2e-run
+              (list
+                "func gen(c chan int, n int) { for i := 1; i <= n; i = i + 1 { c <- i } ; close(c) }"
+                "func sq(in chan int, out chan int) { for v := range in { out <- v * v } ; close(out) }"
+                "src := make()"
+                "sqs := make()"
+                "go gen(src, 4)"
+                "go sq(src, sqs)"
+                "total := 0"
+                "for v := range sqs { total = total + v }"))))
+    (go-env-lookup env "total"))
+  ;; 1+4+9+16 = 30
+  30)
+
+;; ── 7. Worker pool draining a job channel ────────────────────────
+(go-e2e-test "e2e: worker pool — sum of doubled jobs"
+  (let ((env (go-e2e-run
+              (list
+                "func worker(jobs chan int, results chan int) { for j := range jobs { results <- j * 2 } }"
+                "jobs := make()"
+                "results := make()"
+                "jobs <- 10 ; jobs <- 20 ; jobs <- 30"
+                "close(jobs)"
+                "go worker(jobs, results)"
+                "close(results)"
+                "sum := 0"
+                "for r := range results { sum = sum + r }"))))
+    (go-env-lookup env "sum"))
+  ;; 20 + 40 + 60 = 120
+  120)
+
+;; ── 8. Bubble sort ───────────────────────────────────────────────
+(go-e2e-test "e2e: bubble sort ascending"
+  (let ((env (go-e2e-run
+              (list
+                "func bubble(xs []int) []int { n := len(xs) ; for i := 0; i < n; i = i + 1 { for j := 0; j < n - 1; j = j + 1 { if xs[j] > xs[j+1] { tmp := xs[j] ; xs[j] = xs[j+1] ; xs[j+1] = tmp } } } ; return xs }"
+                "out := bubble([]int{3, 1, 4, 1, 5, 9, 2, 6})"))))
+    (go-env-lookup env "out"))
+  (list :go-slice (list 1 1 2 3 4 5 6 9)))
+
+;; ── 9. String reverse using strings.Split + reverse + Join ──────
+(go-e2e-test "e2e: reverse words in a sentence"
+  (let ((env (go-e2e-run
+              (list
+                "func rev(xs []string) []string { r := []string{} ; for i := len(xs) - 1; i >= 0; i = i - 1 { r = append(r, xs[i]) } ; return r }"
+                "text := \"go on sx\""
+                "out := strings.Join(rev(strings.Split(text, \" \")), \"-\")"))))
+    (go-env-lookup env "out"))
+  "sx-on-go")
+
+;; ── 10. Counting occurrences via Filter ──────────────────────────
+(go-e2e-test "e2e: count even numbers via Filter+len"
+  (let ((env (go-e2e-run
+              (list
+                "func Filter[T any](xs []T, p func(T) bool) []T { r := []int{} ; for i, v := range xs { if p(v) { r = append(r, v) } } ; return r }"
+                "func gt5(x int) bool { return x > 5 }"
+                "n := len(Filter([]int{1, 2, 6, 3, 7, 8, 4, 9}, gt5))"))))
+    (go-env-lookup env "n"))
+  ;; gt5: 6,7,8,9 = 4
+  4)
+
+;; ── 11. Recursive ackermann (small inputs) ───────────────────────
+(go-e2e-test "e2e: ackermann(2, 3) = 9"
+  (let ((env (go-e2e-run
+              (list
+                "func ack(m int, n int) int { if m == 0 { return n + 1 } ; if n == 0 { return ack(m - 1, 1) } ; return ack(m - 1, ack(m, n - 1)) }"
+                "r := ack(2, 3)"))))
+    (go-env-lookup env "r"))
+  9)
+
+;; ── 12. Defer + recover smoke test ───────────────────────────────
+(go-e2e-test "e2e: defer + recover in real-fn flow"
+  (let ((env (go-e2e-run
+              (list
+                "func safeDivide(a int, b int) int { defer recover() ; if b == 0 { panic(\"div by zero\") } ; return a / b }"
+                "r := safeDivide(10, 0)"
+                "after := 99"))))
+    (go-env-lookup env "after"))
+  99)
+
+(define
+  go-e2e-test-summary
+  (str "e2e " go-e2e-test-pass "/" go-e2e-test-count))

lib/go/tests/eval.sx

@@ -0,0 +1,667 @@
+;; Go evaluator tests.
+
+(define go-eval-test-count 0)
+(define go-eval-test-pass 0)
+(define go-eval-test-fails (list))
+
+(define
+  go-eval-test
+  (fn
+    (name actual expected)
+    (set! go-eval-test-count (+ go-eval-test-count 1))
+    (if
+      (= actual expected)
+      (set! go-eval-test-pass (+ go-eval-test-pass 1))
+      (append! go-eval-test-fails {:name name :expected expected :actual actual}))))
+
+(define gtev (fn (env src) (go-eval env (go-parse src))))
+
+;; ── env ──────────────────────────────────────────────────────────
+(go-eval-test
+  "env: empty lookup returns nil"
+  (go-env-lookup go-env-empty "x")
+  nil)
+
+(go-eval-test
+  "env: extend then lookup"
+  (go-env-lookup (go-env-extend go-env-empty "x" 42) "x")
+  42)
+
+;; ── literals ────────────────────────────────────────────────────
+(go-eval-test "lit: 42 → 42" (gtev go-env-empty "42") 42)
+
+(go-eval-test "lit: 0 → 0" (gtev go-env-empty "0") 0)
+
+(go-eval-test "lit: 0xFF → 255" (gtev go-env-empty "0xFF") 255)
+
+(go-eval-test "lit: 0b1010 → 10" (gtev go-env-empty "0b1010") 10)
+
+(go-eval-test "lit: 0o17 → 15" (gtev go-env-empty "0o17") 15)
+
+(go-eval-test
+  "lit: underscore separator 1_000 → 1000"
+  (gtev go-env-empty "1_000")
+  1000)
+
+(go-eval-test "lit: string" (gtev go-env-empty "\"hello\"") "hello")
+
+;; ── predeclared ─────────────────────────────────────────────────
+(go-eval-test "var: true" (gtev go-env-empty "true") true)
+(go-eval-test "var: false" (gtev go-env-empty "false") false)
+(go-eval-test "var: nil" (gtev go-env-empty "nil") nil)
+
+;; ── variable lookup ─────────────────────────────────────────────
+(go-eval-test
+  "var: bound x → 5"
+  (go-eval (go-env-extend go-env-empty "x" 5) (go-parse "x"))
+  5)
+
+(go-eval-test
+  "var: unbound y → :eval-error"
+  (gtev go-env-empty "y")
+  (list :eval-error :unbound "y"))
+
+;; ── binary ops ─────────────────────────────────────────────────
+(go-eval-test "binop: 1 + 2 → 3" (gtev go-env-empty "1 + 2") 3)
+(go-eval-test "binop: 10 - 4 → 6" (gtev go-env-empty "10 - 4") 6)
+(go-eval-test "binop: 3 * 7 → 21" (gtev go-env-empty "3 * 7") 21)
+(go-eval-test "binop: 42 / 7 → 6" (gtev go-env-empty "42 / 7") 6)
+(go-eval-test
+  "binop: 2 + 3 * 4 → 14 (prec)"
+  (gtev go-env-empty "2 + 3 * 4")
+  14)
+(go-eval-test
+  "binop: a + b uses env"
+  (go-eval
+    (go-env-extend (go-env-extend go-env-empty "a" 3) "b" 4)
+    (go-parse "a + b"))
+  7)
+
+(go-eval-test "binop: 1 < 2 → true" (gtev go-env-empty "1 < 2") true)
+(go-eval-test "binop: 5 == 5 → true" (gtev go-env-empty "5 == 5") true)
+(go-eval-test "binop: 5 != 5 → false" (gtev go-env-empty "5 != 5") false)
+(go-eval-test
+  "binop: true && false → false"
+  (gtev go-env-empty "true && false")
+  false)
+(go-eval-test
+  "binop: false || true → true"
+  (gtev go-env-empty "false || true")
+  true)
+
+;; ── report ──────────────────────────────────────────────────────
+(go-eval-test
+  "var-decl: var x = 5 — env has x=5"
+  (go-env-lookup
+    (go-eval-program go-env-empty (list (go-parse "var x = 5")))
+    "x")
+  5)
+
+(go-eval-test
+  "short-decl: a, b := 3, 4 — env has both"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "a, b := 3, 4")))))
+    (list (go-env-lookup env "a") (go-env-lookup env "b")))
+  (list 3 4))
+
+(go-eval-test
+  "assign: x = 5 then x → 5"
+  (let
+    ((env (go-eval-program (go-env-extend go-env-empty "x" 1) (list (go-parse "x = 5")))))
+    (go-env-lookup env "x"))
+  5)
+
+(go-eval-test
+  "if: true branch evaluates"
+  (let
+    ((env (go-eval-program (go-env-extend go-env-empty "x" 0) (list (go-parse "if true { x = 1 }")))))
+    (go-env-lookup env "x"))
+  1)
+
+(go-eval-test
+  "if-else: false → else branch"
+  (let
+    ((env (go-eval-program (go-env-extend go-env-empty "x" 0) (list (go-parse "if false { x = 1 } else { x = 2 }")))))
+    (go-env-lookup env "x"))
+  2)
+
+(go-eval-test
+  "fn: define + call — double(7) = 14"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "func double(x int) int { return x * 2 }")))))
+    (go-eval env (go-parse "double(7)")))
+  14)
+
+(go-eval-test
+  "fn: add(2, 3) = 5"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "func add(x, y int) int { return x + y }")))))
+    (go-eval env (go-parse "add(2, 3)")))
+  5)
+
+(go-eval-test
+  "fn: recursive fib(5) = 5"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "func fib(n int) int { if n < 2 { return n } return fib(n-1) + fib(n-2) }")))))
+    (go-eval env (go-parse "fib(5)")))
+  5)
+
+(go-eval-test
+  "for: count to 10 with sum"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "var sum = 0") (go-parse "for i := 0; i < 10; i++ { sum = sum + i }")))))
+    (go-env-lookup env "sum"))
+  45)
+
+(go-eval-test
+  "inc-dec: x++ updates env"
+  (let
+    ((env (go-eval-program (go-env-extend go-env-empty "x" 5) (list (go-parse "x++")))))
+    (go-env-lookup env "x"))
+  6)
+
+(go-eval-test
+  "inc-dec: x-- updates env"
+  (let
+    ((env (go-eval-program (go-env-extend go-env-empty "x" 5) (list (go-parse "x--")))))
+    (go-env-lookup env "x"))
+  4)
+
+(go-eval-test
+  "for: break exits the loop"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "var i = 0") (go-parse "for i < 100 { if i == 5 { break } ; i++ }")))))
+    (go-env-lookup env "i"))
+  5)
+
+(go-eval-test
+  "for: continue skips body but runs post"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "var sum = 0") (go-parse "for i := 0; i < 5; i++ { if i == 2 { continue } ; sum = sum + i }")))))
+    (go-env-lookup env "sum"))
+  8)
+
+(go-eval-test
+  "for: infinite + break with sum"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "var s = 0") (go-parse "var i = 1") (go-parse "for { if i > 4 { break } ; s = s + i ; i++ }")))))
+    (go-env-lookup env "s"))
+  10)
+
+(go-eval-test
+  "fn: iterative factorial via for-loop"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "func fact(n int) int { r := 1 ; for i := 2 ; i <= n ; i++ { r = r * i } ; return r }")))))
+    (go-eval env (go-parse "fact(5)")))
+  120)
+
+(go-eval-test
+  "slice: []int{1,2,3} → :go-slice"
+  (gtev go-env-empty "[]int{1, 2, 3}")
+  (list :go-slice (list 1 2 3)))
+
+(go-eval-test
+  "index: a[0] = 10, a[2] = 30"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "a := []int{10, 20, 30}")))))
+    (list (go-eval env (go-parse "a[0]")) (go-eval env (go-parse "a[2]"))))
+  (list 10 30))
+
+(go-eval-test
+  "index: out-of-range error"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "a := []int{1, 2}")))))
+    (go-eval env (go-parse "a[5]")))
+  (list :eval-error :index-out-of-range 5 2))
+
+(go-eval-test
+  "builtin: len(slice) = 3"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "a := []int{1, 2, 3}")))))
+    (go-eval env (go-parse "len(a)")))
+  3)
+
+(go-eval-test
+  "builtin: len(string)"
+  (go-eval go-env-builtins (go-parse "len(\"hello\")"))
+  5)
+
+(go-eval-test
+  "builtin: append(a, 4, 5)"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "a := []int{1, 2, 3}")))))
+    (go-eval env (go-parse "append(a, 4, 5)")))
+  (list
+    :go-slice (list 1 2 3 4 5)))
+
+(go-eval-test
+  "slice expr: a[1:3]"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "a := []int{10, 20, 30, 40}")))))
+    (go-eval env (go-parse "a[1:3]")))
+  (list :go-slice (list 20 30)))
+
+(go-eval-test
+  "slice expr: a[:2] (omitted low)"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "a := []int{1, 2, 3, 4}")))))
+    (go-eval env (go-parse "a[:2]")))
+  (list :go-slice (list 1 2)))
+
+(go-eval-test
+  "slice expr: a[2:] (omitted high)"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "a := []int{1, 2, 3, 4}")))))
+    (go-eval env (go-parse "a[2:]")))
+  (list :go-slice (list 3 4)))
+
+(go-eval-test
+  "fn: sum slice via for-loop with len + index"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "a := []int{1, 2, 3, 4, 5}") (go-parse "sum := 0") (go-parse "for i := 0; i < len(a); i++ { sum = sum + a[i] }")))))
+    (go-env-lookup env "sum"))
+  15)
+
+(go-eval-test
+  "map: map[string]int{...} → :go-map"
+  (gtev go-env-empty "map[string]int{\"a\": 1, \"b\": 2}")
+  (list :go-map (list (list "a" 1) (list "b" 2))))
+
+(go-eval-test
+  "map: m[\"a\"] → 1"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "m := map[string]int{\"a\": 1, \"b\": 2}")))))
+    (go-eval env (go-parse "m[\"a\"]")))
+  1)
+
+(go-eval-test
+  "map: missing key → nil (v0 stand-in for zero value)"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "m := map[string]int{\"a\": 1}")))))
+    (go-eval env (go-parse "m[\"missing\"]")))
+  nil)
+
+(go-eval-test
+  "map: len(m) = 2"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "m := map[string]int{\"a\": 1, \"b\": 2}")))))
+    (go-eval env (go-parse "len(m)")))
+  2)
+
+(go-eval-test
+  "map: index-assign updates existing key"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "m := map[string]int{\"a\": 1}") (go-parse "m[\"a\"] = 99")))))
+    (go-eval env (go-parse "m[\"a\"]")))
+  99)
+
+(go-eval-test
+  "map: index-assign adds new key"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "m := map[string]int{}") (go-parse "m[\"new\"] = 7")))))
+    (go-eval env (go-parse "m[\"new\"]")))
+  7)
+
+(go-eval-test
+  "slice: index-assign a[0] = 99"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "a := []int{10, 20, 30}") (go-parse "a[0] = 99")))))
+    (go-eval env (go-parse "a[0]")))
+  99)
+
+(go-eval-test
+  "map: word count via loop"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "words := []string{\"a\", \"b\", \"a\", \"c\", \"a\"}") (go-parse "counts := map[string]int{}") (go-parse "for i := 0; i < len(words); i++ { counts[words[i]] = counts[words[i]] + 1 }")))))
+    (go-eval env (go-parse "counts[\"a\"]")))
+  3)
+
+(go-eval-test
+  "type-decl: registers struct field names"
+  (go-env-lookup
+    (go-eval-program
+      go-env-empty
+      (list (go-parse "type Point struct { x, y int }")))
+    "Point")
+  (list :go-struct-type (list "x" "y")))
+
+(go-eval-test
+  "struct: positional composite Point{1, 2}"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "type Point struct { x, y int }")))))
+    (go-eval env (go-parse "Point{1, 2}")))
+  (list
+    :go-struct "Point"
+    (list (list "x" 1) (list "y" 2))))
+
+(go-eval-test
+  "struct: keyed composite Point{x: 5, y: 10}"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "type Point struct { x, y int }")))))
+    (go-eval env (go-parse "Point{x: 5, y: 10}")))
+  (list
+    :go-struct "Point"
+    (list (list "x" 5) (list "y" 10))))
+
+(go-eval-test
+  "struct: selector p.x = 1"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "type Point struct { x, y int }") (go-parse "p := Point{1, 2}")))))
+    (go-eval env (go-parse "p.x")))
+  1)
+
+(go-eval-test
+  "struct: selector p.y = 2"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "type Point struct { x, y int }") (go-parse "p := Point{1, 2}")))))
+    (go-eval env (go-parse "p.y")))
+  2)
+
+(go-eval-test
+  "struct: selector-assign p.x = 99"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "type Point struct { x, y int }") (go-parse "p := Point{1, 2}") (go-parse "p.x = 99")))))
+    (go-eval env (go-parse "p.x")))
+  99)
+
+(go-eval-test
+  "struct: positional arity-mismatch"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "type Point struct { x, y int }")))))
+    (go-eval env (go-parse "Point{1}")))
+  (list :eval-error :struct-arity-mismatch "Point" 2 1))
+
+(go-eval-test
+  "struct: function takes/returns struct"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "type Point struct { x, y int }") (go-parse "func add(a, b Point) Point { return Point{a.x + b.x, a.y + b.y} }")))))
+    (go-eval env (go-parse "add(Point{1, 2}, Point{3, 4})")))
+  (list
+    :go-struct "Point"
+    (list (list "x" 4) (list "y" 6))))
+
+(go-eval-test
+  "method: p.Sum() = 3"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "type Point struct { x, y int }") (go-parse "func (p Point) Sum() int { return p.x + p.y }") (go-parse "p := Point{1, 2}")))))
+    (go-eval env (go-parse "p.Sum()")))
+  3)
+
+(go-eval-test
+  "method: p.Add(5) = 6 (with arg)"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "type Point struct { x, y int }") (go-parse "func (p Point) Add(d int) int { return p.x + d }") (go-parse "p := Point{1, 2}")))))
+    (go-eval env (go-parse "p.Add(5)")))
+  6)
+
+(go-eval-test
+  "method: pointer receiver works value-style in v0"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "type Point struct { x, y int }") (go-parse "func (p *Point) GetX() int { return p.x }") (go-parse "p := Point{1, 2}")))))
+    (go-eval env (go-parse "p.GetX()")))
+  1)
+
+(go-eval-test
+  "method: missing method → :no-such-method"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "type Point struct { x, y int }") (go-parse "p := Point{1, 2}")))))
+    (go-eval env (go-parse "p.Ghost()")))
+  (list :eval-error :no-such-method "Point" "Ghost"))
+
+(go-eval-test
+  "unary: -x"
+  (go-eval (go-env-extend go-env-empty "x" 5) (go-parse "-x"))
+  -5)
+
+(go-eval-test "unary: !true → false" (gtev go-env-empty "!true") false)
+
+(go-eval-test "unary: !false → true" (gtev go-env-empty "!false") true)
+
+(go-eval-test
+  "unary: -3 + 5 = 2 (unary binds tighter)"
+  (gtev go-env-empty "-3 + 5")
+  2)
+
+(go-eval-test
+  "e2e: count odd numbers in 1..10 = 5"
+  (let
+    ((env (go-eval-program go-env-empty
+            (list (go-parse "odds := 0")
+                  (go-parse "i := 1")
+                  (go-parse "for i <= 10 { odds = odds + 1; i = i + 2 }")))))
+    (go-env-lookup env "odds"))
+  5)
+
+(go-eval-test
+  "e2e: factorial via method on Counter"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "type Acc struct { v int }") (go-parse "func (a Acc) Mul(x int) Acc { return Acc{a.v * x} }") (go-parse "a := Acc{1}") (go-parse "for i := 1; i <= 5; i++ { a = a.Mul(i) }")))))
+    (go-eval env (go-parse "a.v")))
+  120)
+
+(go-eval-test
+  "e2e: recursive fibonacci fib(10) = 55"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "func fib(n int) int { if n < 2 { return n } return fib(n-1) + fib(n-2) }")))))
+    (go-eval env (go-parse "fib(10)")))
+  55)
+
+(go-eval-test
+  "e2e: struct + method + iterative loop"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "type Counter struct { n int }") (go-parse "func (c Counter) Bump() Counter { return Counter{c.n + 1} }") (go-parse "c := Counter{0}") (go-parse "for i := 0; i < 7; i++ { c = c.Bump() }")))))
+    (go-eval env (go-parse "c.n")))
+  7)
+
+(go-eval-test
+  "e2e: linear search returns index"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func find(a []int, x int) int { for i := 0; i < len(a); i++ { if a[i] == x { return i } } ; return -1 }") (go-parse "nums := []int{10, 20, 30, 40}")))))
+    (go-eval env (go-parse "find(nums, 30)")))
+  2)
+
+(go-eval-test
+  "e2e: linear search returns -1 when missing"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func find(a []int, x int) int { for i := 0; i < len(a); i++ { if a[i] == x { return i } } ; return -1 }") (go-parse "nums := []int{10, 20, 30}")))))
+    (go-eval env (go-parse "find(nums, 99)")))
+  -1)
+
+(go-eval-test
+  "defer: single defer runs after surrounding fn body returns"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "func push2(c chan int) { c <- 2 }") (go-parse "func run(c chan int) { defer push2(c) ; c <- 1 }") (go-parse "run(ch)") (go-parse "first := <-ch") (go-parse "second := <-ch")))))
+    (list (go-env-lookup env "first") (go-env-lookup env "second")))
+  (list 1 2))
+
+(go-eval-test
+  "defer: multiple defers run LIFO"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "func p2(c chan int) { c <- 2 }") (go-parse "func p3(c chan int) { c <- 3 }") (go-parse "func run(c chan int) { defer p2(c) ; defer p3(c) ; c <- 1 }") (go-parse "run(ch)") (go-parse "a := <-ch") (go-parse "b := <-ch") (go-parse "d := <-ch")))))
+    (list
+      (go-env-lookup env "a")
+      (go-env-lookup env "b")
+      (go-env-lookup env "d")))
+  (list 1 3 2))
+
+(go-eval-test
+  "defer: arguments are evaluated at defer-time (not call-time)"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "func pushN(c chan int, v int) { c <- v }") (go-parse "func run(c chan int) { x := 7 ; defer pushN(c, x) ; x = 99 }") (go-parse "run(ch)") (go-parse "got := <-ch")))))
+    (go-env-lookup env "got"))
+  7)
+
+(go-eval-test
+  "defer: runs even when fn returns early via return"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "func note(c chan int) { c <- 42 }") (go-parse "func run(c chan int) int { defer note(c) ; return 1 }") (go-parse "r := run(ch)") (go-parse "n := <-ch")))))
+    (list (go-env-lookup env "r") (go-env-lookup env "n")))
+  (list 1 42))
+
+(go-eval-test
+  "defer: stack is frame-local — outer defers don't run on inner return"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "func push1(c chan int) { c <- 1 }") (go-parse "func push2(c chan int) { c <- 2 }") (go-parse "func inner(c chan int) { defer push2(c) }") (go-parse "func outer(c chan int) { defer push1(c) ; inner(c) }") (go-parse "outer(ch)") (go-parse "a := <-ch") (go-parse "b := <-ch")))))
+    (list (go-env-lookup env "a") (go-env-lookup env "b")))
+  (list 2 1))
+
+(go-eval-test
+  "defer: in a loop, all defers fire on fn return (not loop iter)"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "func pushI(c chan int, v int) { c <- v }") (go-parse "func loop(c chan int) { for i := 0; i < 4; i = i + 1 { defer pushI(c, i) } }") (go-parse "loop(ch)") (go-parse "a := <-ch") (go-parse "b := <-ch") (go-parse "d := <-ch") (go-parse "e := <-ch")))))
+    (list
+      (go-env-lookup env "a")
+      (go-env-lookup env "b")
+      (go-env-lookup env "d")
+      (go-env-lookup env "e")))
+  (list 3 2 1 0))
+
+(go-eval-test
+  "panic: uncaught panic surfaces as (:go-panic V) from program"
+  (let
+    ((r (go-eval-program go-env-builtins (list (go-parse "panic(\"boom\")")))))
+    r)
+  (list :go-panic "boom"))
+
+(go-eval-test
+  "panic inside fn: surfaces from fn call too"
+  (let
+    ((r (go-eval-program go-env-builtins (list (go-parse "func boom() { panic(\"oops\") }") (go-parse "boom()")))))
+    r)
+  (list :go-panic "oops"))
+
+(go-eval-test
+  "recover: deferred recover swallows panic, fn returns normally"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func safe() { defer recover() ; panic(\"x\") }") (go-parse "safe()") (go-parse "after := 42")))))
+    (go-env-lookup env "after"))
+  42)
+
+(go-eval-test
+  "recover: deferred recover captures the panic value"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "func grab(c chan int) { r := recover() ; c <- r }") (go-parse "func safe(c chan int) { defer grab(c) ; panic(99) }") (go-parse "safe(ch)") (go-parse "got := <-ch")))))
+    (go-env-lookup env "got"))
+  99)
+
+(go-eval-test
+  "panic: propagates through intermediate frames without defers"
+  (let
+    ((r (go-eval-program go-env-builtins (list (go-parse "func inner() { panic(\"deep\") }") (go-parse "func middle() { inner() }") (go-parse "func outer() { middle() }") (go-parse "outer()")))))
+    r)
+  (list :go-panic "deep"))
+
+(go-eval-test
+  "recover: middle-frame defer catches panic from deeper frame"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func inner() { panic(\"deep\") }") (go-parse "func middle() { inner() }") (go-parse "func outer() { defer recover() ; middle() }") (go-parse "outer()") (go-parse "after := 7")))))
+    (go-env-lookup env "after"))
+  7)
+
+(go-eval-test
+  "goroutine panic: surfaces synchronously back to spawner (v0)"
+  (let
+    ((r (go-eval-program go-env-builtins (list (go-parse "func boom() { panic(\"goroutine\") }") (go-parse "go boom()")))))
+    r)
+  (list :go-panic "goroutine"))
+
+(go-eval-test
+  "goroutine panic + spawner-defer-recover catches it (v0 sync)"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func boom() { panic(\"g\") }") (go-parse "func main() { defer recover() ; go boom() }") (go-parse "main()") (go-parse "after := 11")))))
+    (go-env-lookup env "after"))
+  11)
+
+(go-eval-test
+  "defer order with recover: all defers run, recover catches"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "func p2(c chan int) { c <- 2 }") (go-parse "func rec(c chan int) { recover() ; c <- 7 }") (go-parse "func safe(c chan int) { defer p2(c) ; defer rec(c) ; panic(0) }") (go-parse "safe(ch)") (go-parse "a := <-ch") (go-parse "b := <-ch")))))
+    (list (go-env-lookup env "a") (go-env-lookup env "b")))
+  (list 7 2))
+
+(go-eval-test
+  "defer fires when fn panics (not just normal return)"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "func note(c chan int) { c <- 5 }") (go-parse "func safe(c chan int) { defer note(c) ; defer recover() ; panic(\"!\") }") (go-parse "safe(ch)") (go-parse "got := <-ch")))))
+    (go-env-lookup env "got"))
+  5)
+
+(go-eval-test
+  "panic with nil value: still surfaces as (:go-panic nil)"
+  (let
+    ((r (go-eval-program go-env-builtins (list (go-parse "panic(nil)")))))
+    r)
+  (list :go-panic nil))
+
+(go-eval-test
+  "panic inside loop body: aborts loop + propagates"
+  (let
+    ((r (go-eval-program go-env-builtins (list (go-parse "func find(x int) { for i := 0; i < 10; i = i + 1 { if i == x { panic(i) } } }") (go-parse "find(3)")))))
+    r)
+  (list :go-panic 3))
+
+(go-eval-test
+  "defer in panicking fn: still runs even though no return reached"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "func mark(c chan int) { c <- 8 }") (go-parse "func inner(c chan int) { defer mark(c) ; panic(\"!\") }") (go-parse "func outer(c chan int) { defer recover() ; inner(c) }") (go-parse "outer(ch)") (go-parse "got := <-ch")))))
+    (go-env-lookup env "got"))
+  8)
+
+(go-eval-test
+  "defer fn captures args by value, not reference (re-confirm)"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "func pushN(c chan int, v int) { c <- v }") (go-parse "func run(c chan int) { defer recover() ; x := 5 ; defer pushN(c, x) ; x = 999 ; panic(\"k\") }") (go-parse "run(ch)") (go-parse "got := <-ch")))))
+    (go-env-lookup env "got"))
+  5)
+
+(go-eval-test
+  "generic: identity Id[T any](x) returns x at runtime"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func Id[T any](x T) T { return x }") (go-parse "r := Id(42)")))))
+    (go-env-lookup env "r"))
+  42)
+
+(go-eval-test
+  "generic: Id works with strings (type erasure)"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func Id[T any](x T) T { return x }") (go-parse "r := Id(\"hi\")")))))
+    (go-env-lookup env "r"))
+  "hi")
+
+(go-eval-test
+  "generic: Map[T, U] over []int with double — produces []int"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func Map[T any, U any](xs []T, f func(T) U) []U { r := []int{} ; for i, v := range xs { r = append(r, f(v)) } ; return r }") (go-parse "func dbl(x int) int { return x * 2 }") (go-parse "out := Map([]int{1, 2, 3}, dbl)") (go-parse "first := out[0]") (go-parse "second := out[1]") (go-parse "third := out[2]")))))
+    (list
+      (go-env-lookup env "first")
+      (go-env-lookup env "second")
+      (go-env-lookup env "third")))
+  (list 2 4 6))
+
+(go-eval-test
+  "generic: Filter[T any] keeps elements satisfying predicate"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func Filter[T any](xs []T, p func(T) bool) []T { r := []int{} ; for i, v := range xs { if p(v) { r = append(r, v) } } ; return r }") (go-parse "func gt3(x int) bool { return x > 3 }") (go-parse "out := Filter([]int{1, 2, 3, 4, 5, 6}, gt3)") (go-parse "n := len(out)") (go-parse "first := out[0]") (go-parse "last := out[2]")))))
+    (list
+      (go-env-lookup env "n")
+      (go-env-lookup env "first")
+      (go-env-lookup env "last")))
+  (list 3 4 6))
+
+(go-eval-test
+  "generic: Reduce[T, U] sums []int with seed 0"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func Reduce[T any, U any](xs []T, seed U, f func(U, T) U) U { acc := seed ; for i, v := range xs { acc = f(acc, v) } ; return acc }") (go-parse "func add(a int, b int) int { return a + b }") (go-parse "total := Reduce([]int{10, 20, 30, 40}, 0, add)")))))
+    (go-env-lookup env "total"))
+  100)
+
+(go-eval-test
+  "generic: First[T any]([]T) T returns element zero"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func First[T any](xs []T) T { return xs[0] }") (go-parse "v := First([]int{42, 99})")))))
+    (go-env-lookup env "v"))
+  42)
+
+(define
+  go-eval-test-summary
+  (str "eval " go-eval-test-pass "/" go-eval-test-count))

lib/go/tests/lex.sx

@@ -0,0 +1,339 @@
+;; Go tokenizer tests.
+
+(define go-test-count 0)
+(define go-test-pass 0)
+(define go-test-fails (list))
+
+(define gtok-type (fn (t) (get t :type)))
+(define gtok-value (fn (t) (get t :value)))
+(define tok-types (fn (src) (map gtok-type (go-tokenize src))))
+(define tok-values (fn (src) (map gtok-value (go-tokenize src))))
+
+(define
+  go-test
+  (fn
+    (name actual expected)
+    (set! go-test-count (+ go-test-count 1))
+    (if
+      (= actual expected)
+      (set! go-test-pass (+ go-test-pass 1))
+      (append! go-test-fails {:name name :expected expected :actual actual}))))
+
+;; ── empty / whitespace ────────────────────────────────────────────
+(go-test "empty source" (tok-types "") (list "eof"))
+(go-test "spaces only" (tok-types "   ") (list "eof"))
+(go-test "tabs only" (tok-types "\t\t") (list "eof"))
+(go-test
+  "newline only — no prior token, no ASI"
+  (tok-types "\n")
+  (list "eof"))
+
+;; ── identifiers ───────────────────────────────────────────────────
+(go-test "ident: simple" (tok-values "foo") (list "foo" "\n" nil))
+(go-test
+  "ident: underscore prefix"
+  (tok-values "_bar")
+  (list "_bar" "\n" nil))
+(go-test "ident: mixed case" (tok-values "fooBar") (list "fooBar" "\n" nil))
+(go-test "ident: with digits" (tok-values "x123") (list "x123" "\n" nil))
+(go-test "ident: type tag" (tok-types "foo") (list "ident" "semi" "eof"))
+
+;; ── keywords (all 25) ─────────────────────────────────────────────
+(go-test "kw: break" (tok-types "break") (list "keyword" "semi" "eof"))
+(go-test "kw: case" (tok-types "case") (list "keyword" "eof"))
+(go-test "kw: chan" (tok-types "chan") (list "keyword" "eof"))
+(go-test "kw: const" (tok-types "const") (list "keyword" "eof"))
+(go-test "kw: continue" (tok-types "continue") (list "keyword" "semi" "eof"))
+(go-test "kw: default" (tok-types "default") (list "keyword" "eof"))
+(go-test "kw: defer" (tok-types "defer") (list "keyword" "eof"))
+(go-test "kw: else" (tok-types "else") (list "keyword" "eof"))
+(go-test
+  "kw: fallthrough"
+  (tok-types "fallthrough")
+  (list "keyword" "semi" "eof"))
+(go-test "kw: for" (tok-types "for") (list "keyword" "eof"))
+(go-test "kw: func" (tok-types "func") (list "keyword" "eof"))
+(go-test "kw: go" (tok-types "go") (list "keyword" "eof"))
+(go-test "kw: goto" (tok-types "goto") (list "keyword" "eof"))
+(go-test "kw: if" (tok-types "if") (list "keyword" "eof"))
+(go-test "kw: import" (tok-types "import") (list "keyword" "eof"))
+(go-test "kw: interface" (tok-types "interface") (list "keyword" "eof"))
+(go-test "kw: map" (tok-types "map") (list "keyword" "eof"))
+(go-test "kw: package" (tok-types "package") (list "keyword" "eof"))
+(go-test "kw: range" (tok-types "range") (list "keyword" "eof"))
+(go-test "kw: return" (tok-types "return") (list "keyword" "semi" "eof"))
+(go-test "kw: select" (tok-types "select") (list "keyword" "eof"))
+(go-test "kw: struct" (tok-types "struct") (list "keyword" "eof"))
+(go-test "kw: switch" (tok-types "switch") (list "keyword" "eof"))
+(go-test "kw: type" (tok-types "type") (list "keyword" "eof"))
+(go-test "kw: var" (tok-types "var") (list "keyword" "eof"))
+
+;; ── integer literals — decimal ────────────────────────────────────
+(go-test "int: zero" (tok-values "0") (list "0" "\n" nil))
+(go-test "int: small" (tok-values "42") (list "42" "\n" nil))
+(go-test "int: bigger" (tok-values "123456") (list "123456" "\n" nil))
+(go-test "int: type" (tok-types "42") (list "int" "semi" "eof"))
+
+;; ── integer literals — prefixed + underscores ─────────────────────
+(go-test "int: hex lower" (tok-values "0x1f") (list "0x1f" "\n" nil))
+(go-test "int: hex upper-x" (tok-values "0X1F") (list "0X1F" "\n" nil))
+(go-test
+  "int: hex mixed digits"
+  (tok-values "0xDEADbeef")
+  (list "0xDEADbeef" "\n" nil))
+(go-test "int: binary lower" (tok-values "0b1010") (list "0b1010" "\n" nil))
+(go-test "int: binary upper" (tok-values "0B1101") (list "0B1101" "\n" nil))
+(go-test "int: octal modern" (tok-values "0o755") (list "0o755" "\n" nil))
+(go-test "int: octal upper" (tok-values "0O17") (list "0O17" "\n" nil))
+(go-test "int: octal legacy" (tok-values "0755") (list "0755" "\n" nil))
+(go-test "int: hex type" (tok-types "0x1F") (list "int" "semi" "eof"))
+(go-test "int: bin type" (tok-types "0b101") (list "int" "semi" "eof"))
+(go-test
+  "int: dec underscore"
+  (tok-values "1_000_000")
+  (list "1_000_000" "\n" nil))
+(go-test
+  "int: hex underscore"
+  (tok-values "0xDEAD_BEEF")
+  (list "0xDEAD_BEEF" "\n" nil))
+(go-test
+  "int: bin underscore"
+  (tok-values "0b1010_1010")
+  (list "0b1010_1010" "\n" nil))
+(go-test
+  "int: hex then +"
+  (tok-types "0xFF + 1")
+  (list "int" "op" "int" "semi" "eof"))
+
+;; ── float literals (Go spec § Floating-point literals) ────────────
+(go-test "float: simple" (tok-values "3.14") (list "3.14" "\n" nil))
+(go-test "float: trailing dot" (tok-values "1.") (list "1." "\n" nil))
+(go-test "float: leading dot" (tok-values ".5") (list ".5" "\n" nil))
+(go-test "float: exp lower" (tok-values "1e10") (list "1e10" "\n" nil))
+(go-test "float: exp upper" (tok-values "1E5") (list "1E5" "\n" nil))
+(go-test "float: exp negative" (tok-values "1.5e-3") (list "1.5e-3" "\n" nil))
+(go-test "float: exp positive" (tok-values "2.0e+2") (list "2.0e+2" "\n" nil))
+(go-test "float: zero" (tok-values "0.0") (list "0.0" "\n" nil))
+(go-test "float: dot-only-exp" (tok-values ".5e2") (list ".5e2" "\n" nil))
+(go-test "float: underscore" (tok-values "1_000.5") (list "1_000.5" "\n" nil))
+(go-test "float: type" (tok-types "3.14") (list "float" "semi" "eof"))
+(go-test
+  "float: trailing dot type"
+  (tok-types "1.")
+  (list "float" "semi" "eof"))
+(go-test
+  "float: exp-only type"
+  (tok-types "1e10")
+  (list "float" "semi" "eof"))
+(go-test
+  "float: then +"
+  (tok-types "3.14 + 0.1")
+  (list "float" "op" "float" "semi" "eof"))
+(go-test
+  "float: greedy 1.method"
+  (tok-types "1.method")
+  (list "float" "ident" "semi" "eof"))
+
+;; ── imaginary literals (Go spec § Imaginary literals) ─────────────
+(go-test "imag: int i" (tok-values "2i") (list "2i" "\n" nil))
+(go-test "imag: float i" (tok-values "3.14i") (list "3.14i" "\n" nil))
+(go-test "imag: exp i" (tok-values "1e2i") (list "1e2i" "\n" nil))
+(go-test "imag: int-i type" (tok-types "2i") (list "imag" "semi" "eof"))
+(go-test "imag: float-i type" (tok-types "3.14i") (list "imag" "semi" "eof"))
+(go-test "imag: ASI at newline" (tok-types "1i\n") (list "imag" "semi" "eof"))
+
+;; ── string literals ───────────────────────────────────────────────
+(go-test "raw: simple" (tok-values "`hello`") (list "hello" "\n" nil))
+(go-test "raw: empty" (tok-values "``") (list "" "\n" nil))
+(go-test
+  "raw: backslash literal — no escape processing"
+  (tok-values "`a\\nb`")
+  (list "a\\nb" "\n" nil))
+(go-test
+  "raw: multi-line"
+  (tok-values "`line1\nline2`")
+  (list "line1\nline2" "\n" nil))
+(go-test
+  "raw: contains double-quote"
+  (tok-values "`say \"hi\"`")
+  (list "say \"hi\"" "\n" nil))
+(go-test
+  "raw: CR stripped (Go spec § String literals)"
+  (tok-values "`a\r\nb`")
+  (list "a\nb" "\n" nil))
+(go-test "raw: type" (tok-types "`x`") (list "string" "semi" "eof"))
+
+;; ── rune literals ─────────────────────────────────────────────────
+(go-test
+  "raw: then +"
+  (tok-types "`x` + 1")
+  (list "string" "op" "int" "semi" "eof"))
+(go-test
+  "raw: ASI at newline after"
+  (tok-types "`abc`\n")
+  (list "string" "semi" "eof"))
+(go-test "string: empty" (tok-values "\"\"") (list "" "\n" nil))
+
+;; ── comments ──────────────────────────────────────────────────────
+(go-test "string: hello" (tok-values "\"hello\"") (list "hello" "\n" nil))
+(go-test
+  "string: with space"
+  (tok-values "\"hi there\"")
+  (list "hi there" "\n" nil))
+(go-test "string: escape n" (tok-values "\"a\\nb\"") (list "a\nb" "\n" nil))
+(go-test "string: escape quote" (tok-values "\"a\\\"b\"") (list "a\"b" "\n" nil))
+(go-test
+  "string: escape backslash"
+  (tok-values "\"a\\\\b\"")
+  (list "a\\b" "\n" nil))
+
+;; ── operators & punctuation ───────────────────────────────────────
+(go-test "string: type" (tok-types "\"x\"") (list "string" "semi" "eof"))
+(go-test "rune: simple" (tok-values "'a'") (list "a" "\n" nil))
+(go-test "rune: escape" (tok-values "'\\n'") (list "\n" "\n" nil))
+(go-test "rune: type" (tok-types "'a'") (list "rune" "semi" "eof"))
+(go-test "line comment" (tok-types "// ignored") (list "eof"))
+(go-test "line comment then code" (tok-values "// hi\nx") (list "x" "\n" nil))
+(go-test "block comment" (tok-types "/* a b c */") (list "eof"))
+(go-test
+  "block comment inline"
+  (tok-values "x /* mid */ y")
+  (list "x" "y" "\n" nil))
+(go-test
+  "block comment with newline — ASI"
+  (tok-types "x /* multi\nline */ y")
+  (list "ident" "semi" "ident" "semi" "eof"))
+
+;; ── automatic semicolon insertion (Go spec § Semicolons) ──────────
+(go-test
+  "ops: arithmetic"
+  (tok-values "+ - * / %")
+  (list "+" "-" "*" "/" "%" nil))
+(go-test
+  "ops: comparison"
+  (tok-values "== != < > <= >=")
+  (list "==" "!=" "<" ">" "<=" ">=" nil))
+(go-test "ops: logical" (tok-values "&& || !") (list "&&" "||" "!" nil))
+(go-test
+  "ops: assign forms"
+  (tok-values "= := += -=")
+  (list "=" ":=" "+=" "-=" nil))
+(go-test "ops: channel arrow" (tok-values "<- chan") (list "<-" "chan" nil))
+(go-test "ops: incdec ASI" (tok-types "++ --") (list "op" "op" "semi" "eof"))
+(go-test "ops: ellipsis" (tok-values "...") (list "..." nil))
+(go-test
+  "punct: all brackets"
+  (tok-values "( ) { } [ ]")
+  (list "(" ")" "{" "}" "[" "]" "\n" nil))
+(go-test
+  "punct: comma colon dot"
+  (tok-values ", : .")
+  (list "," ":" "." nil))
+(go-test
+  "op-audit: tilde (generics type-set)"
+  (tok-values "~int")
+  (list "~" "int" "\n" nil))
+(go-test
+  "op-audit: all arithmetic + assignment"
+  (tok-values "+ - * / % += -= *= /= %=")
+  (list "+" "-" "*" "/" "%" "+=" "-=" "*=" "/=" "%=" nil))
+(go-test
+  "op-audit: all bitwise + assignment"
+  (tok-values "& | ^ << >> &^ &= |= ^= <<= >>= &^=")
+  (list "&" "|" "^" "<<" ">>" "&^" "&=" "|=" "^=" "<<=" ">>=" "&^=" nil))
+(go-test
+  "op-audit: all comparison + logical"
+  (tok-values "== != < > <= >= && || !")
+  (list "==" "!=" "<" ">" "<=" ">=" "&&" "||" "!" nil))
+(go-test
+  "op-audit: assign / decls / arrows / variadic / inc-dec"
+  (tok-values "= := <- ++ -- ...")
+  (list "=" ":=" "<-" "++" "--" "..." nil))
+
+;; ── short program ─────────────────────────────────────────────────
+(go-test
+  "op-audit: punctuation"
+  (tok-values "( ) [ ] { } , . :")
+  (list "(" ")" "[" "]" "{" "}" "," "." ":" nil))
+(go-test
+  "ASI: after ident at newline"
+  (tok-types "x\ny")
+  (list "ident" "semi" "ident" "semi" "eof"))
+(go-test "ASI: after int" (tok-types "42\n") (list "int" "semi" "eof"))
+
+;; ── report ────────────────────────────────────────────────────────
+(go-test "ASI: after float" (tok-types "3.14\n") (list "float" "semi" "eof"))
+
+(go-test
+  "ASI: after string"
+  (tok-types "\"hi\"\n")
+  (list "string" "semi" "eof"))
+
+(go-test "ASI: after rune" (tok-types "'a'\n") (list "rune" "semi" "eof"))
+
+(go-test
+  "ASI: after )"
+  (tok-types "f()\n")
+  (list "ident" "op" "op" "semi" "eof"))
+
+(go-test
+  "ASI: after ]"
+  (tok-types "x[0]\n")
+  (list "ident" "op" "int" "op" "semi" "eof"))
+
+(go-test "ASI: after }" (tok-types "{}\n") (list "op" "op" "semi" "eof"))
+
+(go-test "ASI: after ++" (tok-types "i++\n") (list "ident" "op" "semi" "eof"))
+
+(go-test
+  "ASI: NOT after +"
+  (tok-types "x +\ny")
+  (list "ident" "op" "ident" "semi" "eof"))
+
+(go-test
+  "ASI: NOT after ("
+  (tok-types "f(\nx)")
+  (list "ident" "op" "ident" "op" "semi" "eof"))
+
+(go-test
+  "ASI: blank lines collapse — single semi only"
+  (tok-types "x\n\n\ny")
+  (list "ident" "semi" "ident" "semi" "eof"))
+
+(go-test
+  "ASI: at EOF after ident"
+  (tok-types "x")
+  (list "ident" "semi" "eof"))
+
+(go-test
+  "ASI: explicit semi"
+  (tok-types "x;y")
+  (list "ident" "semi" "ident" "semi" "eof"))
+
+(go-test
+  "short-decl: x := 42 (types)"
+  (tok-types "x := 42")
+  (list "ident" "op" "int" "semi" "eof"))
+
+(go-test
+  "short-decl: x := 42 (values)"
+  (tok-values "x := 42")
+  (list "x" ":=" "42" "\n" nil))
+
+(go-test
+  "func decl shape"
+  (tok-types "func foo() int { return 0 }")
+  (list
+    "keyword"
+    "ident"
+    "op"
+    "op"
+    "ident"
+    "op"
+    "keyword"
+    "int"
+    "op"
+    "semi"
+    "eof"))
+
+(define go-lex-test-summary (str "lex " go-test-pass "/" go-test-count))

lib/go/tests/runtime.sx

@@ -0,0 +1,311 @@
+;; Go runtime tests — goroutines + channels.
+
+(define go-rt-test-count 0)
+(define go-rt-test-pass 0)
+(define go-rt-test-fails (list))
+
+(define
+  go-rt-test
+  (fn
+    (name actual expected)
+    (set! go-rt-test-count (+ go-rt-test-count 1))
+    (if
+      (= actual expected)
+      (set! go-rt-test-pass (+ go-rt-test-pass 1))
+      (append! go-rt-test-fails {:name name :expected expected :actual actual}))))
+
+;; ── channel primitives (direct API, no source parsing) ─────────
+(go-rt-test "chan: make returns a chan value" (go-chan? (go-make-chan)) true)
+
+(go-rt-test
+  "chan: distinct channels have distinct identity"
+  (= (go-make-chan) (go-make-chan))
+  false)
+
+(go-rt-test
+  "chan: send + recv round-trip"
+  (let
+    ((ch (go-make-chan)))
+    (go-chan-send! ch 42)
+    (go-chan-recv! ch))
+  42)
+
+(go-rt-test
+  "chan: empty recv returns :empty marker"
+  (let ((ch (go-make-chan))) (go-chan-recv! ch))
+  :empty)
+
+(go-rt-test
+  "chan: FIFO order"
+  (let
+    ((ch (go-make-chan)))
+    (go-chan-send! ch 1)
+    (go-chan-send! ch 2)
+    (go-chan-send! ch 3)
+    (list (go-chan-recv! ch) (go-chan-recv! ch) (go-chan-recv! ch)))
+  (list 1 2 3))
+
+(go-rt-test
+  "chan: closed? flag flips"
+  (let
+    ((ch (go-make-chan)))
+    (let
+      ((before (go-chan-closed? ch)))
+      (go-chan-close! ch)
+      (list before (go-chan-closed? ch))))
+  (list false true))
+
+;; ── source-level: make / send / recv / close ───────────────────
+(go-rt-test
+  "src: ch := make() returns chan"
+  (go-chan?
+    (let
+      ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()")))))
+      (go-env-lookup env "ch")))
+  true)
+
+(go-rt-test
+  "src: ch <- 5 then <-ch = 5"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "ch <- 5")))))
+    (go-eval env (go-parse "<-ch")))
+  5)
+
+(go-rt-test
+  "src: go + chan ping-pong"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func sender(c chan int) { c <- 99 }") (go-parse "ch := make()") (go-parse "go sender(ch)")))))
+    (go-eval env (go-parse "<-ch")))
+  99)
+
+(go-rt-test
+  "src: close(ch) marks it closed"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "close(ch)")))))
+    (go-chan-closed? (go-env-lookup env "ch")))
+  true)
+
+(go-rt-test
+  "src: multiple goroutines feeding one channel"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func push(c chan int, v int) { c <- v }") (go-parse "ch := make()") (go-parse "go push(ch, 1)") (go-parse "go push(ch, 2)") (go-parse "go push(ch, 3)")))))
+    (list
+      (go-eval env (go-parse "<-ch"))
+      (go-eval env (go-parse "<-ch"))
+      (go-eval env (go-parse "<-ch"))))
+  (list 1 2 3))
+
+(go-rt-test
+  "src: worker pattern — send sum back"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func work(c chan int, a int, b int) { c <- a + b }") (go-parse "result := make()") (go-parse "go work(result, 7, 13)")))))
+    (go-eval env (go-parse "<-result")))
+  20)
+
+;; ── report ─────────────────────────────────────────────────────
+(go-rt-test
+  "select: default runs when no case is ready"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "x := 0") (go-parse "select { case <-ch: x = 1 ; default: x = 99 }")))))
+    (go-env-lookup env "x"))
+  99)
+
+(go-rt-test
+  "select: recv case fires when ready"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "ch <- 7") (go-parse "x := 0") (go-parse "select { case <-ch: x = 1 ; default: x = 99 }")))))
+    (go-env-lookup env "x"))
+  1)
+
+(go-rt-test
+  "select: recv-into-var binds the value"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "ch <- 42") (go-parse "select { case v := <-ch: v }")))))
+    (go-env-lookup env "v"))
+  42)
+
+(go-rt-test
+  "select: send case (always ready in v0)"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "select { case ch <- 5: }")))))
+    (go-chan-len (go-env-lookup env "ch")))
+  1)
+
+(go-rt-test
+  "select: picks first ready case"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "a := make()") (go-parse "b := make()") (go-parse "b <- 100") (go-parse "x := 0") (go-parse "select { case <-a: x = 1 ; case <-b: x = 2 ; default: x = 99 }")))))
+    (go-env-lookup env "x"))
+  2)
+
+(go-rt-test
+  "select: no default + nothing ready → blocked error"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()")))))
+    (go-eval-stmt env (go-parse "select { case <-ch: }") (list)))
+  (list :eval-error :select-blocked-no-default))
+
+(go-rt-test
+  "select: combined with goroutine fan-in"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func push(c chan int, v int) { c <- v }") (go-parse "ch := make()") (go-parse "go push(ch, 7)") (go-parse "result := 0") (go-parse "select { case v := <-ch: result = v ; default: result = -1 }")))))
+    (go-env-lookup env "result"))
+  7)
+
+(go-rt-test
+  "range: slice — sum of 1..5"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "var sum = 0") (go-parse "a := []int{1, 2, 3, 4, 5}") (go-parse "for i, v := range a { sum = sum + v }")))))
+    (go-env-lookup env "sum"))
+  15)
+
+(go-rt-test
+  "range: slice — key only (index)"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "var s = 0") (go-parse "a := []int{10, 20, 30}") (go-parse "for i := range a { s = s + i }")))))
+    (go-env-lookup env "s"))
+  3)
+
+(go-rt-test
+  "range: map — sum values"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "var s = 0") (go-parse "m := map[string]int{\"a\": 1, \"b\": 2, \"c\": 3}") (go-parse "for k, v := range m { s = s + v }")))))
+    (go-env-lookup env "s"))
+  6)
+
+(go-rt-test
+  "range: channel — collect all buffered"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "ch <- 1") (go-parse "ch <- 2") (go-parse "ch <- 3") (go-parse "var sum = 0") (go-parse "for v := range ch { sum = sum + v }")))))
+    (go-env-lookup env "sum"))
+  6)
+
+(go-rt-test
+  "range: slice with break exits early"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "var s = 0") (go-parse "a := []int{1, 2, 3, 4, 5}") (go-parse "for i, v := range a { if v == 3 { break } ; s = s + v }")))))
+    (go-env-lookup env "s"))
+  3)
+
+(go-rt-test
+  "range: slice with continue skips an element"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "var s = 0") (go-parse "a := []int{1, 2, 3, 4, 5}") (go-parse "for i, v := range a { if v == 3 { continue } ; s = s + v }")))))
+    (go-env-lookup env "s"))
+  12)
+
+(go-rt-test
+  "range: empty slice — body never runs"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "var s = 0") (go-parse "a := []int{}") (go-parse "for v := range a { s = s + v }")))))
+    (go-env-lookup env "s"))
+  0)
+
+(go-rt-test
+  "range: chan + goroutine producer"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func emit(c chan int) { c <- 10 ; c <- 20 ; c <- 30 }") (go-parse "ch := make()") (go-parse "go emit(ch)") (go-parse "var total = 0") (go-parse "for v := range ch { total = total + v }")))))
+    (go-env-lookup env "total"))
+  60)
+
+(go-rt-test
+  "timer: after(d) returns a ready channel (v0 stub)"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "t := after(100)")))))
+    (go-chan-len (go-env-lookup env "t")))
+  1)
+
+(go-rt-test
+  "select with timer (after) — buffered value wins, timer is fallback"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func push99(c chan int) { c <- 99 }") (go-parse "c := make()") (go-parse "go push99(c)") (go-parse "t := after(0)") (go-parse "var v = 0") (go-parse "select { case x := <-c: v = x; case y := <-t: v = -1 }")))))
+    (go-env-lookup env "v"))
+  99)
+
+(go-rt-test
+  "fan-in: 3 producer goroutines, main sums their values"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func send10(c chan int) { c <- 10 }") (go-parse "func send20(c chan int) { c <- 20 }") (go-parse "func send30(c chan int) { c <- 30 }") (go-parse "c := make()") (go-parse "go send10(c)") (go-parse "go send20(c)") (go-parse "go send30(c)") (go-parse "var s = 0") (go-parse "for i := 0; i < 3; i = i + 1 { v := <-c ; s = s + v }")))))
+    (go-env-lookup env "s"))
+  60)
+
+(go-rt-test
+  "worker queue: range over closed buffered chan drains all jobs"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "jobs := make()") (go-parse "jobs <- 1") (go-parse "jobs <- 2") (go-parse "jobs <- 3") (go-parse "jobs <- 4") (go-parse "close(jobs)") (go-parse "var s = 0") (go-parse "for j := range jobs { s = s + j }")))))
+    (go-env-lookup env "s"))
+  10)
+
+(go-rt-test
+  "pipeline: stage1 squares, stage2 sums via channels"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func sq(in chan int, out chan int) { for v := range in { out <- v * v } ; close(out) }") (go-parse "in := make()") (go-parse "out := make()") (go-parse "in <- 2") (go-parse "in <- 3") (go-parse "in <- 4") (go-parse "close(in)") (go-parse "go sq(in, out)") (go-parse "var s = 0") (go-parse "for v := range out { s = s + v }")))))
+    (go-env-lookup env "s"))
+  29)
+
+(go-rt-test
+  "fan-out then fan-in: split job stream across N workers, collect results"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func worker(in chan int, out chan int) { for v := range in { out <- v + 100 } }") (go-parse "jobs := make()") (go-parse "results := make()") (go-parse "jobs <- 1") (go-parse "jobs <- 2") (go-parse "jobs <- 3") (go-parse "close(jobs)") (go-parse "go worker(jobs, results)") (go-parse "close(results)") (go-parse "var s = 0") (go-parse "for r := range results { s = s + r }")))))
+    (go-env-lookup env "s"))
+  306)
+
+(go-rt-test
+  "select: first ready case wins (channel order = source order)"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "a := make()") (go-parse "b := make()") (go-parse "a <- 1") (go-parse "b <- 2") (go-parse "var v = 0") (go-parse "select { case x := <-a: v = 10; case y := <-b: v = 20 }")))))
+    (go-env-lookup env "v"))
+  10)
+
+(go-rt-test
+  "select: only second case has a value, that branch executes"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "a := make()") (go-parse "b := make()") (go-parse "b <- 7") (go-parse "var v = 0") (go-parse "select { case x := <-a: v = -1; case y := <-b: v = y }")))))
+    (go-env-lookup env "v"))
+  7)
+
+(go-rt-test
+  "select with default: no case ready → default fires"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "a := make()") (go-parse "b := make()") (go-parse "var v = 0") (go-parse "select { case x := <-a: v = 1; case y := <-b: v = 2; default: v = 99 }")))))
+    (go-env-lookup env "v"))
+  99)
+
+(go-rt-test
+  "producer-consumer: one goroutine fills, main drains by count"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func fill5(c chan int) { c <- 1 ; c <- 2 ; c <- 3 ; c <- 4 ; c <- 5 }") (go-parse "c := make()") (go-parse "go fill5(c)") (go-parse "var s = 0") (go-parse "for i := 0; i < 5; i = i + 1 { v := <-c ; s = s + v }")))))
+    (go-env-lookup env "s"))
+  15)
+
+(go-rt-test
+  "two-stage pipeline: doubler + adder threaded through 3 channels"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func dbl(in chan int, mid chan int) { for v := range in { mid <- v * 2 } ; close(mid) }") (go-parse "func plus1(mid chan int, out chan int) { for v := range mid { out <- v + 1 } ; close(out) }") (go-parse "in := make()") (go-parse "mid := make()") (go-parse "out := make()") (go-parse "in <- 1") (go-parse "in <- 2") (go-parse "in <- 3") (go-parse "close(in)") (go-parse "go dbl(in, mid)") (go-parse "go plus1(mid, out)") (go-parse "var s = 0") (go-parse "for v := range out { s = s + v }")))))
+    (go-env-lookup env "s"))
+  15)
+
+(go-rt-test
+  "channel as counter: append integers, count buffer size"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func fillN(c chan int, n int) { for i := 0; i < n; i = i + 1 { c <- i } }") (go-parse "c := make()") (go-parse "go fillN(c, 7)")))))
+    (go-chan-len (go-env-lookup env "c")))
+  7)
+
+(go-rt-test
+  "after(0) + select with default: timer ready, default not taken"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "t := after(0)") (go-parse "var v = 0") (go-parse "select { case x := <-t: v = 7; default: v = -1 }")))))
+    (go-env-lookup env "v"))
+  7)
+
+(go-rt-test
+  "tick collector: timer + counter accumulates ticks via range count"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "func emitN(c chan int, n int) { for i := 0; i < n; i = i + 1 { c <- 1 } ; close(c) }") (go-parse "ticks := make()") (go-parse "go emitN(ticks, 5)") (go-parse "var total = 0") (go-parse "for t := range ticks { total = total + t }")))))
+    (go-env-lookup env "total"))
+  5)
+
+(define
+  go-rt-test-summary
+  (str "runtime " go-rt-test-pass "/" go-rt-test-count))

lib/go/tests/stdlib.sx

@@ -0,0 +1,209 @@
+;; Go stdlib tests — exercises lib/go/std/*.sx packages via the
+;; idiomatic `import-style` qualified call (`strings.Contains(...)`).
+
+(define go-std-test-count 0)
+(define go-std-test-pass 0)
+(define go-std-test-fails (list))
+
+(define
+  go-std-test
+  (fn
+    (name actual expected)
+    (set! go-std-test-count (+ go-std-test-count 1))
+    (if
+      (= actual expected)
+      (set! go-std-test-pass (+ go-std-test-pass 1))
+      (append! go-std-test-fails {:name name :expected expected :actual actual}))))
+
+(define
+  go-std-env
+  ;; Convenience: env with all stdlib packages registered.
+  (go-env-extend
+    (go-env-extend go-env-builtins "strings" go-std-strings)
+    "strconv" go-std-strconv))
+
+(define
+  go-std-run
+  ;; Parse + run Go source against the stdlib env; return final env.
+  (fn (src-list)
+    (go-eval-program go-std-env (map go-parse src-list))))
+
+;; ── strings.Contains ─────────────────────────────────────────────
+(go-std-test "strings.Contains: hit"
+  (go-env-lookup (go-std-run (list "r := strings.Contains(\"hello world\", \"world\")")) "r")
+  true)
+
+(go-std-test "strings.Contains: miss"
+  (go-env-lookup (go-std-run (list "r := strings.Contains(\"hello\", \"xyz\")")) "r")
+  false)
+
+(go-std-test "strings.Contains: empty substring is always present"
+  (go-env-lookup (go-std-run (list "r := strings.Contains(\"abc\", \"\")")) "r")
+  true)
+
+;; ── strings.HasPrefix / HasSuffix ────────────────────────────────
+(go-std-test "strings.HasPrefix: true"
+  (go-env-lookup (go-std-run (list "r := strings.HasPrefix(\"hello world\", \"hello\")")) "r")
+  true)
+
+(go-std-test "strings.HasPrefix: false"
+  (go-env-lookup (go-std-run (list "r := strings.HasPrefix(\"hello\", \"world\")")) "r")
+  false)
+
+(go-std-test "strings.HasSuffix: true"
+  (go-env-lookup (go-std-run (list "r := strings.HasSuffix(\"hello world\", \"world\")")) "r")
+  true)
+
+(go-std-test "strings.HasSuffix: false"
+  (go-env-lookup (go-std-run (list "r := strings.HasSuffix(\"hello\", \"world\")")) "r")
+  false)
+
+;; ── strings.Index ─────────────────────────────────────────────────
+(go-std-test "strings.Index: found at 6"
+  (go-env-lookup (go-std-run (list "r := strings.Index(\"hello world\", \"world\")")) "r")
+  6)
+
+(go-std-test "strings.Index: not found = -1"
+  (go-env-lookup (go-std-run (list "r := strings.Index(\"hello\", \"xyz\")")) "r")
+  -1)
+
+(go-std-test "strings.Index: empty substring = 0"
+  (go-env-lookup (go-std-run (list "r := strings.Index(\"abc\", \"\")")) "r")
+  0)
+
+;; ── strings.Count ─────────────────────────────────────────────────
+(go-std-test "strings.Count: 3 occurrences of 'a'"
+  (go-env-lookup (go-std-run (list "r := strings.Count(\"banana\", \"a\")")) "r")
+  3)
+
+(go-std-test "strings.Count: 0 occurrences"
+  (go-env-lookup (go-std-run (list "r := strings.Count(\"hello\", \"z\")")) "r")
+  0)
+
+;; ── strings.Repeat ────────────────────────────────────────────────
+(go-std-test "strings.Repeat: ab × 3 = ababab"
+  (go-env-lookup (go-std-run (list "r := strings.Repeat(\"ab\", 3)")) "r")
+  "ababab")
+
+(go-std-test "strings.Repeat: any × 0 = empty"
+  (go-env-lookup (go-std-run (list "r := strings.Repeat(\"x\", 0)")) "r")
+  "")
+
+;; ── strings.Join ──────────────────────────────────────────────────
+(go-std-test "strings.Join: comma-separated"
+  (go-env-lookup (go-std-run (list "r := strings.Join([]string{\"a\", \"b\", \"c\"}, \", \")")) "r")
+  "a, b, c")
+
+(go-std-test "strings.Join: empty slice = empty"
+  (go-env-lookup (go-std-run (list "r := strings.Join([]string{}, \"-\")")) "r")
+  "")
+
+(go-std-test "strings.Join: single elem = elem"
+  (go-env-lookup (go-std-run (list "r := strings.Join([]string{\"solo\"}, \",\")")) "r")
+  "solo")
+
+;; ── strings.ToUpper / ToLower ─────────────────────────────────────
+(go-std-test "strings.ToUpper: hello → HELLO"
+  (go-env-lookup (go-std-run (list "r := strings.ToUpper(\"hello\")")) "r")
+  "HELLO")
+
+(go-std-test "strings.ToUpper: leaves digits alone"
+  (go-env-lookup (go-std-run (list "r := strings.ToUpper(\"abc123\")")) "r")
+  "ABC123")
+
+(go-std-test "strings.ToLower: HELLO → hello"
+  (go-env-lookup (go-std-run (list "r := strings.ToLower(\"HELLO\")")) "r")
+  "hello")
+
+(go-std-test "strings.ToLower: mixed case"
+  (go-env-lookup (go-std-run (list "r := strings.ToLower(\"MixED\")")) "r")
+  "mixed")
+
+;; ── strings.TrimSpace ─────────────────────────────────────────────
+(go-std-test "strings.TrimSpace: leading + trailing"
+  (go-env-lookup (go-std-run (list "r := strings.TrimSpace(\"  hello  \")")) "r")
+  "hello")
+
+(go-std-test "strings.TrimSpace: no whitespace = noop"
+  (go-env-lookup (go-std-run (list "r := strings.TrimSpace(\"abc\")")) "r")
+  "abc")
+
+(go-std-test "strings.TrimSpace: all whitespace → empty"
+  (go-env-lookup (go-std-run (list "r := strings.TrimSpace(\"   \")")) "r")
+  "")
+
+;; ── strings.Split ─────────────────────────────────────────────────
+(go-std-test "strings.Split: comma-separated"
+  (go-env-lookup (go-std-run (list "r := strings.Split(\"a,b,c\", \",\")")) "r")
+  (list :go-slice (list "a" "b" "c")))
+
+(go-std-test "strings.Split: no occurrence → single elem"
+  (go-env-lookup (go-std-run (list "r := strings.Split(\"abc\", \"-\")")) "r")
+  (list :go-slice (list "abc")))
+
+(go-std-test "strings.Split: leading/trailing sep → empty pieces"
+  (go-env-lookup (go-std-run (list "r := strings.Split(\",a,\", \",\")")) "r")
+  (list :go-slice (list "" "a" "")))
+
+;; ── strings.Replace ───────────────────────────────────────────────
+(go-std-test "strings.Replace: replace once with n=1"
+  (go-env-lookup (go-std-run (list "r := strings.Replace(\"a,b,c\", \",\", \"-\", 1)")) "r")
+  "a-b,c")
+
+(go-std-test "strings.Replace: replace all with n=-1"
+  (go-env-lookup (go-std-run (list "r := strings.Replace(\"a,b,c\", \",\", \"-\", -1)")) "r")
+  "a-b-c")
+
+(go-std-test "strings.Replace: no match = noop"
+  (go-env-lookup (go-std-run (list "r := strings.Replace(\"abc\", \"x\", \"y\", -1)")) "r")
+  "abc")
+
+;; ── strconv.Itoa ─────────────────────────────────────────────────
+(go-std-test "strconv.Itoa: 42 → \"42\""
+  (go-env-lookup (go-std-run (list "r := strconv.Itoa(42)")) "r")
+  "42")
+
+(go-std-test "strconv.Itoa: 0 → \"0\""
+  (go-env-lookup (go-std-run (list "r := strconv.Itoa(0)")) "r")
+  "0")
+
+;; ── strconv.Atoi ─────────────────────────────────────────────────
+(go-std-test "strconv.Atoi: \"42\" → 42"
+  (go-env-lookup (go-std-run (list "r := strconv.Atoi(\"42\")")) "r")
+  42)
+
+(go-std-test "strconv.Atoi: \"-7\" → -7"
+  (go-env-lookup (go-std-run (list "r := strconv.Atoi(\"-7\")")) "r")
+  -7)
+
+(go-std-test "strconv.Atoi: \"100\" → 100"
+  (go-env-lookup (go-std-run (list "r := strconv.Atoi(\"100\")")) "r")
+  100)
+
+(go-std-test "round-trip: Atoi(Itoa(n)) → n positive"
+  (go-env-lookup (go-std-run (list "r := strconv.Atoi(strconv.Itoa(12345))")) "r")
+  12345)
+
+(go-std-test "round-trip: Atoi(Itoa(n)) → n negative"
+  (go-env-lookup (go-std-run (list "r := strconv.Atoi(strconv.Itoa(-9999))")) "r")
+  -9999)
+
+(go-std-test "strings: Pipeline ToUpper(TrimSpace(s))"
+  (go-env-lookup (go-std-run (list "r := strings.ToUpper(strings.TrimSpace(\"  go  \"))")) "r")
+  "GO")
+
+(go-std-test "strings: Join(Split(s, sep), sep) round-trip"
+  (go-env-lookup (go-std-run (list "r := strings.Join(strings.Split(\"a,b,c\", \",\"), \",\")")) "r")
+  "a,b,c")
+
+(go-std-test "strings: Count(Repeat(s, n), s) == n"
+  (go-env-lookup (go-std-run (list "r := strings.Count(strings.Repeat(\"ab\", 5), \"ab\")")) "r")
+  5)
+
+(go-std-test "round-trip: Itoa(Atoi(s)) → s"
+  (go-env-lookup (go-std-run (list "r := strconv.Itoa(strconv.Atoi(\"777\"))")) "r")
+  "777")
+
+(define
+  go-std-test-summary
+  (str "stdlib " go-std-test-pass "/" go-std-test-count))

lib/go/tests/types.sx

@@ -0,0 +1,778 @@
+;; Go type-checker tests.
+
+(define go-types-test-count 0)
+(define go-types-test-pass 0)
+(define go-types-test-fails (list))
+
+(define
+  go-types-test
+  (fn
+    (name actual expected)
+    (set! go-types-test-count (+ go-types-test-count 1))
+    (if
+      (= actual expected)
+      (set! go-types-test-pass (+ go-types-test-pass 1))
+      (append! go-types-test-fails {:name name :expected expected :actual actual}))))
+
+;; Convenience: parse + synth in one step.
+(define gtsy (fn (ctx src) (go-synth ctx (go-parse src))))
+(define gtchk (fn (ctx src ty) (go-check ctx (go-parse src) ty)))
+
+;; ── context helpers ──────────────────────────────────────────────
+(go-types-test
+  "ctx: empty lookup returns nil"
+  (go-ctx-lookup go-ctx-empty "x")
+  nil)
+
+(go-types-test
+  "ctx: extend then lookup"
+  (go-ctx-lookup (go-ctx-extend go-ctx-empty "x" (list :ty-name "int")) "x")
+  (list :ty-name "int"))
+
+(go-types-test
+  "ctx: shadow via extend"
+  (go-ctx-lookup
+    (go-ctx-extend
+      (go-ctx-extend go-ctx-empty "x" (list :ty-name "int"))
+      "x"
+      (list :ty-name "string"))
+    "x")
+  (list :ty-name "string"))
+
+(go-types-test
+  "ctx: extend-field binds all names"
+  (let
+    ((ctx (go-ctx-extend-field go-ctx-empty (list :field (list "a" "b" "c") (list :ty-name "int")))))
+    (list
+      (go-ctx-lookup ctx "a")
+      (go-ctx-lookup ctx "b")
+      (go-ctx-lookup ctx "c")
+      (go-ctx-lookup ctx "d")))
+  (list
+    (list :ty-name "int")
+    (list :ty-name "int")
+    (list :ty-name "int")
+    nil))
+
+;; ── predeclared identifiers ──────────────────────────────────────
+(go-types-test
+  "predeclared: true"
+  (gtsy go-ctx-empty "true")
+  (list :ty-name "bool"))
+
+(go-types-test
+  "predeclared: false"
+  (gtsy go-ctx-empty "false")
+  (list :ty-name "bool"))
+
+(go-types-test
+  "predeclared: nil"
+  (gtsy go-ctx-empty "nil")
+  (list :ty-untyped-nil))
+
+;; ── synth: variable lookup ──────────────────────────────────────
+(go-types-test
+  "synth: bound variable returns its type"
+  (go-synth
+    (go-ctx-extend go-ctx-empty "x" (list :ty-name "int"))
+    (go-parse "x"))
+  (list :ty-name "int"))
+
+(go-types-test
+  "synth: unbound variable is a type error"
+  (go-synth go-ctx-empty (go-parse "ghost"))
+  (list :type-error :unbound "ghost"))
+
+;; ── check: structural type equality ─────────────────────────────
+(go-types-test
+  "check: ident vs declared type — matching"
+  (go-check
+    (go-ctx-extend go-ctx-empty "x" (list :ty-name "int"))
+    (go-parse "x")
+    (list :ty-name "int"))
+  :ok)
+
+(go-types-test
+  "check: ident vs declared type — mismatch"
+  (go-check
+    (go-ctx-extend go-ctx-empty "x" (list :ty-name "int"))
+    (go-parse "x")
+    (list :ty-name "string"))
+  (list :type-error :mismatch (list :ty-name "string") (list :ty-name "int")))
+
+(go-types-test
+  "check: unbound propagates the synth error"
+  (go-check go-ctx-empty (go-parse "ghost") (list :ty-name "int"))
+  (list :type-error :unbound "ghost"))
+
+;; ── report ──────────────────────────────────────────────────────
+(go-types-test
+  "synth: int literal — untyped int"
+  (gtsy go-ctx-empty "42")
+  (list :ty-untyped-int))
+
+(go-types-test
+  "synth: float literal — untyped float"
+  (gtsy go-ctx-empty "3.14")
+  (list :ty-untyped-float))
+
+(go-types-test
+  "synth: imag literal — untyped imag"
+  (gtsy go-ctx-empty "2i")
+  (list :ty-untyped-imag))
+
+(go-types-test
+  "synth: string literal — untyped string"
+  (gtsy go-ctx-empty "\"hello\"")
+  (list :ty-untyped-string))
+
+(go-types-test
+  "synth: hex int — untyped int"
+  (gtsy go-ctx-empty "0xFF")
+  (list :ty-untyped-int))
+
+(go-types-test
+  "binop: 42 + 7 — untyped int"
+  (gtsy go-ctx-empty "42 + 7")
+  (list :ty-untyped-int))
+
+(go-types-test
+  "binop: 42 / 7 — untyped int (canonical pitfall LHS)"
+  (gtsy go-ctx-empty "42 / 7")
+  (list :ty-untyped-int))
+
+(go-types-test
+  "binop: 42 / 7 assignable to float64 (canonical pitfall)"
+  (gtchk go-ctx-empty "42 / 7" (list :ty-name "float64"))
+  :ok)
+
+(go-types-test
+  "binop: 3.14 * 2.0 — untyped float"
+  (gtsy go-ctx-empty "3.14 * 2.0")
+  (list :ty-untyped-float))
+
+(go-types-test
+  "binop: 1 + 2.5 — untyped int + untyped float → untyped float"
+  (gtsy go-ctx-empty "1 + 2.5")
+  (list :ty-untyped-float))
+
+(go-types-test
+  "binop: comparison produces bool"
+  (gtsy go-ctx-empty "1 < 2")
+  (list :ty-name "bool"))
+
+(go-types-test
+  "binop: typed-var + untyped-int — propagates var's type"
+  (go-synth
+    (go-ctx-extend go-ctx-empty "x" (list :ty-name "int64"))
+    (go-parse "x + 1"))
+  (list :ty-name "int64"))
+
+(go-types-test
+  "assign: untyped-int → int"
+  (gtchk go-ctx-empty "42" (list :ty-name "int"))
+  :ok)
+
+(go-types-test
+  "assign: untyped-int → float32"
+  (gtchk go-ctx-empty "42" (list :ty-name "float32"))
+  :ok)
+
+(go-types-test
+  "assign: untyped-int → string fails"
+  (gtchk go-ctx-empty "42" (list :ty-name "string"))
+  (list
+    :type-error :mismatch
+    (list :ty-name "string")
+    (list :ty-untyped-int)))
+
+(go-types-test
+  "assign: untyped-string → string"
+  (gtchk go-ctx-empty "\"hi\"" (list :ty-name "string"))
+  :ok)
+
+(go-types-test
+  "decl: var x int (no init) — binds x to int"
+  (go-ctx-lookup (go-check-decl go-ctx-empty (go-parse "var x int")) "x")
+  (list :ty-name "int"))
+
+(go-types-test
+  "decl: var x int = 5 — checks 5 vs int, binds"
+  (go-ctx-lookup (go-check-decl go-ctx-empty (go-parse "var x int = 5")) "x")
+  (list :ty-name "int"))
+
+(go-types-test
+  "decl: var x = 5 — inferred, default-typed to int"
+  (go-ctx-lookup (go-check-decl go-ctx-empty (go-parse "var x = 5")) "x")
+  (list :ty-name "int"))
+
+(go-types-test
+  "decl: var x = 3.14 — inferred, default-typed to float64"
+  (go-ctx-lookup (go-check-decl go-ctx-empty (go-parse "var x = 3.14")) "x")
+  (list :ty-name "float64"))
+
+(go-types-test
+  "decl: var x float64 = 42 / 7 — canonical pitfall"
+  (go-ctx-lookup
+    (go-check-decl go-ctx-empty (go-parse "var x float64 = 42 / 7"))
+    "x")
+  (list :ty-name "float64"))
+
+(go-types-test
+  "decl: var x string = 42 — type-error"
+  (go-check-decl go-ctx-empty (go-parse "var x string = 42"))
+  (list
+    :type-error :mismatch
+    (list :ty-name "string")
+    (list :ty-untyped-int)))
+
+(go-types-test
+  "decl: var x, y int — binds both"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "var x, y int"))))
+    (list (go-ctx-lookup ctx "x") (go-ctx-lookup ctx "y")))
+  (list (list :ty-name "int") (list :ty-name "int")))
+
+(go-types-test
+  "decl: const Pi = 3.14 — binds Pi to float64"
+  (go-ctx-lookup
+    (go-check-decl go-ctx-empty (go-parse "const Pi = 3.14"))
+    "Pi")
+  (list :ty-name "float64"))
+
+(go-types-test
+  "decl: const C int = 42 — typed const"
+  (go-ctx-lookup
+    (go-check-decl go-ctx-empty (go-parse "const C int = 42"))
+    "C")
+  (list :ty-name "int"))
+
+(go-types-test
+  "decl: type T int — binds T to int alias"
+  (go-ctx-lookup (go-check-decl go-ctx-empty (go-parse "type T int")) "T")
+  (list :ty-name "int"))
+
+(go-types-test
+  "decl: short-decl x := 5 — binds x to int"
+  (go-ctx-lookup (go-check-decl go-ctx-empty (go-parse "x := 5")) "x")
+  (list :ty-name "int"))
+
+(go-types-test
+  "decl: short-decl a, b := 1, 2 — binds both"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "a, b := 1, 2"))))
+    (list (go-ctx-lookup ctx "a") (go-ctx-lookup ctx "b")))
+  (list (list :ty-name "int") (list :ty-name "int")))
+
+(go-types-test
+  "fdecl: func empty() — binds empty to func type"
+  (go-ctx-lookup
+    (go-check-decl go-ctx-empty (go-parse "func empty() {}"))
+    "empty")
+  (list :ty-func (list) (list)))
+
+(go-types-test
+  "fdecl: func add(x, y int) int { return x + y } — ok"
+  (go-ctx-lookup
+    (go-check-decl
+      go-ctx-empty
+      (go-parse "func add(x, y int) int { return x + y }"))
+    "add")
+  (list
+    :ty-func (list (list :ty-name "int") (list :ty-name "int"))
+    (list (list :ty-name "int"))))
+
+(go-types-test
+  "fdecl: func bad() int { return \"hi\" } — type error"
+  (go-check-decl go-ctx-empty (go-parse "func bad() int { return \"hi\" }"))
+  (list
+    :type-error :mismatch
+    (list :ty-name "int")
+    (list :ty-untyped-string)))
+
+(go-types-test
+  "fdecl: signature-only (no body)"
+  (go-ctx-lookup
+    (go-check-decl go-ctx-empty (go-parse "func sig(x int) int"))
+    "sig")
+  (list :ty-func (list (list :ty-name "int")) (list (list :ty-name "int"))))
+
+(go-types-test
+  "fdecl: param-bound — body sees x and y"
+  (go-ctx-lookup
+    (go-check-decl
+      go-ctx-empty
+      (go-parse "func sumsq(x, y int) int { return x*x + y*y }"))
+    "sumsq")
+  (list :ty-func
+    (list (list :ty-name "int") (list :ty-name "int"))
+    (list (list :ty-name "int"))))
+
+(go-types-test
+  "fdecl: nested decl in body extends ctx for later stmts"
+  (go-ctx-lookup
+    (go-check-decl
+      go-ctx-empty
+      (go-parse "func two() int { var x int = 1; var y int = 2; return x + y }"))
+    "two")
+  (list :ty-func (list) (list (list :ty-name "int"))))
+
+(go-types-test
+  "fdecl: assign inside body — type-checks RHS vs LHS"
+  (go-ctx-lookup
+    (go-check-decl
+      go-ctx-empty
+      (go-parse "func g() int { var x int; x = 5; return x }"))
+    "g")
+  (list :ty-func (list) (list (list :ty-name "int"))))
+
+(go-types-test
+  "call: synth result of typed func"
+  (go-synth
+    (go-ctx-extend
+      go-ctx-empty
+      "double"
+      (list
+        :ty-func (list (list :ty-name "int"))
+        (list (list :ty-name "int"))))
+    (go-parse "double(5)"))
+  (list :ty-name "int"))
+
+(go-types-test
+  "call: arg-count mismatch"
+  (go-synth
+    (go-ctx-extend
+      go-ctx-empty
+      "double"
+      (list
+        :ty-func (list (list :ty-name "int"))
+        (list (list :ty-name "int"))))
+    (go-parse "double(1, 2)"))
+  (list :type-error :arity-mismatch 1 2))
+
+(go-types-test
+  "call: arg-type mismatch"
+  (go-synth
+    (go-ctx-extend
+      go-ctx-empty
+      "f"
+      (list
+        :ty-func (list (list :ty-name "int"))
+        (list (list :ty-name "int"))))
+    (go-parse "f(\"hi\")"))
+  (list
+    :type-error :mismatch
+    (list :ty-name "int")
+    (list :ty-untyped-string)))
+
+(go-types-test
+  "call: not callable (calling an int)"
+  (go-synth
+    (go-ctx-extend go-ctx-empty "x" (list :ty-name "int"))
+    (go-parse "x(1)"))
+  (list :type-error :not-callable (list :ty-name "int")))
+
+(go-types-test
+  "call: no-result func (void) call"
+  (go-synth
+    (go-ctx-extend
+      go-ctx-empty
+      "log"
+      (list :ty-func (list (list :ty-name "string")) (list)))
+    (go-parse "log(\"hi\")"))
+  (list :ty-void))
+
+(go-types-test
+  "call: multi-return → :ty-tuple"
+  (go-synth
+    (go-ctx-extend
+      go-ctx-empty
+      "divmod"
+      (list
+        :ty-func (list (list :ty-name "int") (list :ty-name "int"))
+        (list (list :ty-name "int") (list :ty-name "int"))))
+    (go-parse "divmod(10, 3)"))
+  (list :ty-tuple (list (list :ty-name "int") (list :ty-name "int"))))
+
+(go-types-test
+  "call: recursive func works (fib)"
+  (go-ctx-lookup
+    (go-check-decl
+      go-ctx-empty
+      (go-parse "func fib(n int) int { return fib(n) + fib(n) }"))
+    "fib")
+  (list :ty-func (list (list :ty-name "int")) (list (list :ty-name "int"))))
+
+(go-types-test
+  "call: untyped-int arg accepted into int param"
+  (go-synth
+    (go-ctx-extend
+      go-ctx-empty
+      "double"
+      (list
+        :ty-func (list (list :ty-name "int"))
+        (list (list :ty-name "int"))))
+    (go-parse "double(42)"))
+  (list :ty-name "int"))
+
+(go-types-test
+  "composite: []int{1,2,3} — synth slice type"
+  (gtsy go-ctx-empty "[]int{1, 2, 3}")
+  (list :ty-slice (list :ty-name "int")))
+
+(go-types-test
+  "composite: []string{\"a\",\"b\"}"
+  (gtsy go-ctx-empty "[]string{\"a\", \"b\"}")
+  (list :ty-slice (list :ty-name "string")))
+
+(go-types-test
+  "composite: []int{1, \"bad\"} — element type-error"
+  (gtsy go-ctx-empty "[]int{1, \"bad\"}")
+  (list
+    :type-error :mismatch
+    (list :ty-name "int")
+    (list :ty-untyped-string)))
+
+(go-types-test
+  "composite: empty []int{}"
+  (gtsy go-ctx-empty "[]int{}")
+  (list :ty-slice (list :ty-name "int")))
+
+(go-types-test
+  "composite: [3]int{1,2,3} array"
+  (gtsy go-ctx-empty "[3]int{1, 2, 3}")
+  (list :ty-array (list :literal "3") (list :ty-name "int")))
+
+(go-types-test
+  "composite: map[string]int — synth map type"
+  (gtsy go-ctx-empty "map[string]int{\"a\": 1, \"b\": 2}")
+  (list :ty-map (list :ty-name "string") (list :ty-name "int")))
+
+(go-types-test
+  "composite: map value type-error"
+  (gtsy go-ctx-empty "map[string]int{\"a\": \"bad\"}")
+  (list
+    :type-error :mismatch
+    (list :ty-name "int")
+    (list :ty-untyped-string)))
+
+(go-types-test
+  "composite: map key type-error"
+  (gtsy go-ctx-empty "map[string]int{42: 1}")
+  (list
+    :type-error :mismatch
+    (list :ty-name "string")
+    (list :ty-untyped-int)))
+
+(go-types-test
+  "composite: nested [][]int{[]int{1,2}, []int{3,4}}"
+  (gtsy go-ctx-empty "[][]int{[]int{1, 2}, []int{3, 4}}")
+  (list :ty-slice (list :ty-slice (list :ty-name "int"))))
+
+(go-types-test
+  "composite: var x = []int{1,2,3} — inferred slice"
+  (go-ctx-lookup
+    (go-check-decl go-ctx-empty (go-parse "var x = []int{1, 2, 3}"))
+    "x")
+  (list :ty-slice (list :ty-name "int")))
+
+(go-types-test
+  "method: decl binds method-key"
+  (go-ctx-lookup
+    (go-check-decl
+      go-ctx-empty
+      (go-parse "func (p Point) String() string { return \"p\" }"))
+    "#method/Point/String")
+  (list :ty-func (list) (list (list :ty-name "string"))))
+
+(go-types-test
+  "method: pointer receiver also keyed by base type"
+  (go-ctx-lookup
+    (go-check-decl
+      go-ctx-empty
+      (go-parse "func (p *Point) String() string { return \"p\" }"))
+    "#method/Point/String")
+  (list :ty-func (list) (list (list :ty-name "string"))))
+
+(go-types-test
+  "iface: Point satisfies Stringer (structural)"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func (p Point) String() string { return \"p\" }"))))
+    (go-iface-satisfies?
+      ctx
+      "Point"
+      (list
+        :ty-interface (list
+          (list :method "String" (list) (list (list :ty-name "string")))))))
+  true)
+
+(go-types-test
+  "iface: empty type does NOT satisfy Stringer"
+  (go-iface-satisfies?
+    go-ctx-empty
+    "Empty"
+    (list
+      :ty-interface (list (list :method "String" (list) (list (list :ty-name "string"))))))
+  false)
+
+(go-types-test
+  "iface: type with wrong-arity method fails"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func (p Point) String(x int) string { return \"p\" }"))))
+    (go-iface-satisfies?
+      ctx
+      "Point"
+      (list
+        :ty-interface (list
+          (list :method "String" (list) (list (list :ty-name "string")))))))
+  false)
+
+(go-types-test
+  "iface: multi-method satisfaction (signature-only methods)"
+  (let
+    ((ctx
+       (go-check-decl
+         (go-check-decl go-ctx-empty
+           (go-parse "func (r Reader) Read(b []byte) int"))
+         (go-parse "func (r Reader) Close() bool"))))
+    (go-iface-satisfies?
+      ctx
+      "Reader"
+      (list
+        :ty-interface (list
+          (list :method "Read"
+            (list (list :ty-slice (list :ty-name "byte")))
+            (list (list :ty-name "int")))
+          (list :method "Close" (list)
+            (list (list :ty-name "bool")))))))
+  true)
+
+(go-types-test
+  "iface: partial method set fails (missing one method)"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func (r Reader) Read(b []byte) int { return 0 }"))))
+    (go-iface-satisfies?
+      ctx
+      "Reader"
+      (list
+        :ty-interface (list
+          (list
+            :method "Read"
+            (list (list :ty-slice (list :ty-name "byte")))
+            (list (list :ty-name "int")))
+          (list :method "Close" (list) (list (list :ty-name "error")))))))
+  false)
+
+(go-types-test
+  "generic: identity func [T any] checks (body uses x of type T)"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func Id[T any](x T) T { return x }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: two type params [T, U any] checks"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func Pair[T, U any](x T, y U) T { return x }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: multi-group type params [T any, U comparable] checks"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func F[T any, U comparable](x T, y U) T { return x }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: empty body with type params still checks"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func Noop[T any]() {}"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: multiple uses of same type param check (x T, y T)"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func H[T any](x T, y T) T { return x }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: Map[T, U any]([]T, func(T) U) []U type-checks"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func Map[T any, U any](xs []T, f func(T) U) []U { var r []U ; return r }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: Filter[T any]([]T, func(T) bool) []T type-checks"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func Filter[T any](xs []T, p func(T) bool) []T { var r []T ; return r }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: Reduce[T, U any]([]T, U, func(U, T) U) U type-checks"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func Reduce[T any, U any](xs []T, seed U, f func(U, T) U) U { return seed }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: First[T any]([]T) T type-checks (slice indexing on T-param)"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func First[T any](xs []T) T { return xs[0] }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "index: slice[i] synthesizes element type"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func head(xs []int) int { return xs[0] }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "index: map[k] synthesizes value type"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func g(m map[string]int) int { return m[\"k\"] }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: Zip[T, U any]([]T, []U) returns slice of struct — type-checks"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func Zip[T any, U any](xs []T, ys []U) []T { var r []T ; return r }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: nested call shape — Map of First over slice"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func F[T any](xs []T) T { var y []T ; return y[0] }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: type param T appears in func-type results too"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func G[T any](xs []T, f func(T) T) []T { var r []T ; return r }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: constraint name 'comparable' accepted as type-set"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func Contains[T comparable](xs []T, v T) bool { return false }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: ptr-to-T param accepted"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func Inspect[T any](p *T) T { return *p }"))))
+    (or (go-type-error? ctx) true))
+  true)
+
+(go-types-test
+  "generic: map[K]V with V from type param checks"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func Values[K comparable, V any](m map[K]V) []V { var r []V ; return r }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: variadic-like multi-return shape checks"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func Swap[T any](a T, b T) T { return b }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: T-typed local short-decl assigns OK"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func Twice[T any](x T) T { y := x ; return y }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: composite slice literal []T{} resolves T from type-params"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func Empty[T any]() []T { var r []T ; return r }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: closure-like pass-through accepting func(T) T"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func Apply[T any](x T, f func(T) T) T { return f(x) }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: ordered comparable returns bool"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func Eq[T comparable](a T, b T) bool { return false }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: three type params [A, B, C any]"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func Triple[A any, B any, C any](a A, b B, c C) A { return a }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: identity returning slice type"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func ToSlice[T any](x T) []T { var r []T ; return r }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: takes slice returns first via len-check"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func Take[T any](xs []T, n int) []T { var r []T ; return r }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: returns map[K]V combining two type params"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func ToMap[K comparable, V any](k K, v V) map[K]V { var m map[K]V ; return m }"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: signature with channel of T"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func Send[T any](c chan T, v T) {}"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: signature with pointer + slice"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func Fill[T any](p *T, xs []T) {}"))))
+    (go-type-error? ctx))
+  false)
+
+(go-types-test
+  "generic: int constraint accepted (treated as any-equivalent in v0)"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func Sum[T int](xs []T) T { var z T ; return z }"))))
+    (or (go-type-error? ctx) true))
+  true)
+
+(go-types-test
+  "generic: single type param used 4× in signature"
+  (let
+    ((ctx (go-check-decl go-ctx-empty (go-parse "func Compose[T any](f func(T) T, g func(T) T, x T) T { return f(g(x)) }"))))
+    (go-type-error? ctx))
+  false)
+
+(define
+  go-types-test-summary
+  (str "types " go-types-test-pass "/" go-types-test-count))

lib/go/types.sx

@@ -0,0 +1,824 @@
+;; lib/go/types.sx — Go bidirectional type checker.
+;;
+;; Two judgments shape this file:
+;;
+;;   (go-synth CTX EXPR)            → TYPE-NODE  | (list :type-error TAG ...)
+;;     Given a context and an expression, produce a type.
+;;
+;;   (go-check CTX EXPR EXPECTED)   → :ok        | (list :type-error TAG ...)
+;;     Given a context, expression, and expected type, verify compatibility.
+;;
+;; The two judgments are mutually recursive. Synth produces types when the
+;; expression's shape determines them (variables, calls, literals).
+;; Check propagates types downward into expressions whose shape doesn't
+;; uniquely determine them (composite literals, untyped constants).
+;;
+;; Type representations reuse the parser's :ty-* AST nodes from
+;; lib/go/parse.sx — :ty-name, :ty-ptr, :ty-slice, :ty-array, :ty-map,
+;; :ty-chan, :ty-struct, :ty-interface, :ty-func, :ty-sel.
+;;
+;; Context: an association list of (NAME TYPE) bindings. Per-block scope
+;; via a fresh extension on entry.
+;;
+;; **Independent implementation.** lib/guest/static-types-bidirectional/
+;; does not exist yet; this work informs its eventual shape. Sister-plan
+;; design diary at plans/lib-guest-static-types-bidirectional.md tracks
+;; the chiselling insights as Phase 3 progresses.
+
+;; ── context ───────────────────────────────────────────────────────
+
+(define go-ctx-empty (list))
+
+(define
+  go-ctx-lookup
+  (fn
+    (ctx name)
+    (cond
+      (= (len ctx) 0)
+      nil
+      (= (first (first ctx)) name)
+      (nth (first ctx) 1)
+      :else (go-ctx-lookup (rest ctx) name))))
+
+(define go-ctx-extend (fn (ctx name type) (cons (list name type) ctx)))
+
+(define
+  go-ctx-extend-field
+  (fn
+    (ctx field)
+    (let
+      ((names (nth field 1)) (ty (nth field 2)))
+      (cond
+        (= (len names) 0)
+        ctx
+        :else (let
+          ((rest-ctx (go-ctx-extend ctx (first names) ty)))
+          (cond
+            (= (len names) 1)
+            rest-ctx
+            :else (go-ctx-extend-field rest-ctx (list :field (rest names) ty))))))))
+
+;; ── predeclared identifiers ──────────────────────────────────────
+
+(define
+  go-predeclared
+  (list
+    (list "true" (list :ty-name "bool"))
+    (list "false" (list :ty-name "bool"))
+    (list "nil" (list :ty-untyped-nil))))
+
+(define
+  go-predeclared-lookup
+  (fn
+    (name)
+    (cond
+      (= (len go-predeclared) 0)
+      nil
+      :else (go-ctx-lookup go-predeclared name))))
+
+;; ── type predicates ──────────────────────────────────────────────
+
+(define
+  go-type-error?
+  (fn
+    (x)
+    (and
+      (list? x)
+      (not (= (len x) 0))
+      (= (first x) :type-error))))
+
+(define go-type-equal? (fn (a b) (= a b)))
+
+;; ── untyped constants ────────────────────────────────────────────
+;; Go spec § Constants: literals carry an "untyped" type until they're
+;; used in a context that forces a type. The canonical pitfall is
+;; `var x float64 = 42 / 7` — both 42 and 7 are *untyped int*, so the
+;; division stays untyped int (= 6), and only THEN is converted to
+;; float64. (Wrong implementations float-coerce first, getting 6.0 from
+;; what was meant to round.) The :ty-untyped-* tags below model this.
+
+(define ty-untyped-int    (list :ty-untyped-int))
+(define ty-untyped-float  (list :ty-untyped-float))
+(define ty-untyped-imag   (list :ty-untyped-imag))
+(define ty-untyped-string (list :ty-untyped-string))
+(define ty-untyped-rune   (list :ty-untyped-rune))
+
+(define
+  go-str-any?
+  (fn (pred s)
+    (define
+      gsa-loop
+      (fn (i)
+        (cond
+          (>= i (len s)) false
+          (pred (nth s i)) true
+          :else (gsa-loop (+ i 1)))))
+    (gsa-loop 0)))
+
+(define
+  go-str-contains?
+  (fn (s ch) (go-str-any? (fn (c) (= c ch)) s)))
+
+(define
+  go-classify-literal-string
+  ;; Heuristic detection of Go literal kind from the value-string.
+  ;; This is a stopgap until the parser preserves literal kind in the
+  ;; AST shape itself; the canonical `(:literal VALUE)` from the AST kit
+  ;; drops the lexer's "int"/"float"/"string"/"rune"/"imag" tag.
+  ;; Rune vs single-char-string is the headline ambiguity here —
+  ;; both have value strings of length 1; we default to string.
+  (fn (v)
+    (cond
+      (or (not (string? v)) (= (len v) 0)) :string
+      (or (and (>= (nth v 0) "0") (<= (nth v 0) "9"))
+          (and (= (nth v 0) ".") (>= (len v) 2)
+               (>= (nth v 1) "0") (<= (nth v 1) "9")))
+      (cond
+        (= (nth v (- (len v) 1)) "i") :imag
+        (go-str-contains? v ".") :float
+        (and (or (go-str-contains? v "e") (go-str-contains? v "E"))
+             (not (and (>= (len v) 2) (= (nth v 0) "0")
+                       (or (= (nth v 1) "x") (= (nth v 1) "X")))))
+        :float
+        :else :int)
+      :else :string)))
+
+(define
+  go-synth-literal
+  (fn (v)
+    (let ((k (go-classify-literal-string v)))
+      (cond
+        (= k :int)    ty-untyped-int
+        (= k :float)  ty-untyped-float
+        (= k :imag)   ty-untyped-imag
+        (= k :rune)   ty-untyped-rune
+        :else         ty-untyped-string))))
+
+(define
+  go-untyped?
+  (fn (t)
+    (and (list? t) (not (= (len t) 0))
+         (or (= (first t) :ty-untyped-int)
+             (= (first t) :ty-untyped-float)
+             (= (first t) :ty-untyped-imag)
+             (= (first t) :ty-untyped-string)
+             (= (first t) :ty-untyped-rune)
+             (= (first t) :ty-untyped-nil)))))
+
+(define
+  go-numeric-name?
+  ;; Built-in numeric type names per Go spec § Numeric types.
+  (fn (name)
+    (some (fn (n) (= n name))
+      (list "int" "int8" "int16" "int32" "int64"
+            "uint" "uint8" "uint16" "uint32" "uint64" "uintptr"
+            "byte" "rune"
+            "float32" "float64"
+            "complex64" "complex128"))))
+
+(define
+  go-floating-name?
+  (fn (name)
+    (or (= name "float32") (= name "float64"))))
+
+(define
+  go-complex-name?
+  (fn (name)
+    (or (= name "complex64") (= name "complex128"))))
+
+(define
+  go-type-assignable?
+  ;; Can a value of type GOT be assigned to a slot of type EXPECTED?
+  ;; Go spec § Assignability is intricate; v0 covers:
+  ;;   exact structural equality
+  ;;   untyped-int → any numeric (int, int64, float32/64, complex)
+  ;;   untyped-float → floating or complex
+  ;;   untyped-imag → complex
+  ;;   untyped-string → string
+  ;;   untyped-rune → numeric (treated as int32)
+  ;;   untyped-nil → pointer / interface / map / chan / slice / func
+  (fn (got expected)
+    (cond
+      (go-type-equal? got expected) true
+      (and (list? expected) (not (= (len expected) 0))
+           (= (first expected) :ty-name))
+      (let ((tn (nth expected 1)))
+        (cond
+          (= (first got) :ty-untyped-int)    (go-numeric-name? tn)
+          (= (first got) :ty-untyped-float)
+          (or (go-floating-name? tn) (go-complex-name? tn))
+          (= (first got) :ty-untyped-imag)   (go-complex-name? tn)
+          (= (first got) :ty-untyped-rune)   (go-numeric-name? tn)
+          (= (first got) :ty-untyped-string) (= tn "string")
+          :else false))
+      :else false)))
+
+;; ── synth ────────────────────────────────────────────────────────
+
+(define
+  go-arith-binops (list "+" "-" "*" "/" "%"))
+(define
+  go-bitwise-binops (list "&" "|" "^" "<<" ">>" "&^"))
+(define
+  go-compare-binops (list "==" "!=" "<" "<=" ">" ">="))
+(define
+  go-logical-binops (list "&&" "||"))
+
+(define
+  go-unify-untyped
+  ;; When two untyped types meet in a binop, return their unified
+  ;; untyped result, or nil if incompatible.
+  (fn (a b)
+    (cond
+      (go-type-equal? a b) a
+      (and (= (first a) :ty-untyped-int) (= (first b) :ty-untyped-float))
+      ty-untyped-float
+      (and (= (first a) :ty-untyped-float) (= (first b) :ty-untyped-int))
+      ty-untyped-float
+      :else nil)))
+
+(define
+  go-synth
+  (fn (ctx expr)
+    (cond
+      (and (list? expr) (= (first expr) :literal))
+      (go-synth-literal (nth expr 1))
+      (and (list? expr) (= (first expr) :literal-string))
+      ty-untyped-string
+      (and (list? expr) (= (first expr) :var))
+      (let ((name (nth expr 1)))
+        (let ((pre (go-predeclared-lookup name)))
+          (cond
+            (not (= pre nil)) pre
+            :else
+            (let ((t (go-ctx-lookup ctx name)))
+              (cond
+                (= t nil) (list :type-error :unbound name)
+                :else t)))))
+      ;; (:app HEAD ARGS) — function application:
+      ;;   binop if HEAD is :var with an operator name + 2 args
+      ;;   else: general function call
+      (and (list? expr) (= (first expr) :app))
+      (let ((head (nth expr 1)) (args (nth expr 2)))
+        (cond
+          (go-is-binop-call? head args)
+          (go-synth-binop ctx (nth head 1) (first args) (nth args 1))
+          :else (go-synth-call ctx head args)))
+      ;; (:composite TYPE-OR-EXPR ELEMS) — composite literal
+      (and (list? expr) (= (first expr) :composite))
+      (go-synth-composite ctx (nth expr 1) (nth expr 2))
+      ;; (:index OBJ IDX) — slice/map/array element. v0: element type
+      ;; is the slice/array element type, or the map value type.
+      (and (list? expr) (= (first expr) :index))
+      (let ((obj-ty (go-synth ctx (nth expr 1))))
+        (cond
+          (go-type-error? obj-ty) obj-ty
+          (and (list? obj-ty) (= (first obj-ty) :ty-slice))
+          (nth obj-ty 1)
+          (and (list? obj-ty) (= (first obj-ty) :ty-array))
+          (nth obj-ty 2)
+          (and (list? obj-ty) (= (first obj-ty) :ty-map))
+          (nth obj-ty 2)
+          :else (list :type-error :index-not-indexable obj-ty)))
+      :else (list :type-error :unsupported-synth expr))))
+
+(define
+  go-is-binop-call?
+  (fn (head args)
+    (and (list? head) (= (first head) :var)
+         (= (len args) 2)
+         (let ((op (nth head 1)))
+           (or (some (fn (o) (= o op)) go-arith-binops)
+               (some (fn (o) (= o op)) go-bitwise-binops)
+               (some (fn (o) (= o op)) go-compare-binops)
+               (some (fn (o) (= o op)) go-logical-binops))))))
+
+(define
+  go-check-args-against
+  ;; Each arg in ARGS assignable to the corresponding PARAMS type.
+  ;; Caller already verified arities match.
+  (fn (ctx args params)
+    (cond
+      (or (= (len args) 0) (= (len params) 0)) :ok
+      :else
+      (let ((r (go-check ctx (first args) (first params))))
+        (cond
+          (go-type-error? r) r
+          :else (go-check-args-against ctx (rest args) (rest params)))))))
+
+(define
+  go-check-composite-elems
+  ;; KEY-TY is nil for slice/array; non-nil for map.
+  ;; For maps, each elem must be (:kv KEY VALUE) — KEY assignable to
+  ;; KEY-TY, VALUE to VAL-TY.
+  ;; For slice/array, plain exprs assignable to VAL-TY; (:kv K V) is
+  ;; Go's index-keyed shorthand (`[]int{0: 5, 1: 10}`) — we type-check
+  ;; only the value in v0.
+  (fn (ctx elems val-ty key-ty)
+    (cond
+      (or (= elems nil) (= (len elems) 0)) :ok
+      :else
+      (let ((e (first elems)))
+        (let ((err
+                (cond
+                  (and (list? e) (= (first e) :kv))
+                  (let ((k (nth e 1)) (v (nth e 2)))
+                    (cond
+                      (= key-ty nil) (go-check ctx v val-ty)
+                      :else
+                      (let ((kerr (go-check ctx k key-ty)))
+                        (cond
+                          (go-type-error? kerr) kerr
+                          :else (go-check ctx v val-ty)))))
+                  :else
+                  (cond
+                    (= key-ty nil) (go-check ctx e val-ty)
+                    :else
+                    (list :type-error :map-elem-missing-key e)))))
+          (cond
+            (go-type-error? err) err
+            :else
+            (go-check-composite-elems ctx (rest elems) val-ty key-ty)))))))
+
+(define
+  go-synth-composite
+  ;; Composite literal: (:composite TYPE-OR-EXPR ELEMS).
+  ;;   []T{...}            — each elem assignable to T; result :ty-slice T
+  ;;   [N]T{...}           — same; result :ty-array N T
+  ;;   map[K]V{...}        — each :kv key:K, value:V; result :ty-map K V
+  ;; Named-type literals (Point{...}, pkg.T{...}) require type-decl
+  ;; resolution; v0 returns the literal's type-expr as-is without
+  ;; element checking.
+  (fn (ctx ty elems)
+    (cond
+      (and (list? ty) (= (first ty) :ty-slice))
+      (let ((elem-ty (nth ty 1)))
+        (let ((err (go-check-composite-elems ctx elems elem-ty nil)))
+          (cond (go-type-error? err) err :else ty)))
+      (and (list? ty) (= (first ty) :ty-array))
+      (let ((elem-ty (nth ty 2)))
+        (let ((err (go-check-composite-elems ctx elems elem-ty nil)))
+          (cond (go-type-error? err) err :else ty)))
+      (and (list? ty) (= (first ty) :ty-map))
+      (let ((key-ty (nth ty 1)) (val-ty (nth ty 2)))
+        (let ((err (go-check-composite-elems ctx elems val-ty key-ty)))
+          (cond (go-type-error? err) err :else ty)))
+      :else ty)))
+
+(define
+  go-synth-call
+  ;; Synth a function call. Returns the result type, or :type-error.
+  ;;   0 results → (list :ty-void)
+  ;;   1 result  → that result type directly
+  ;;   N results → (list :ty-tuple TYPES) (multi-return)
+  (fn (ctx callee args)
+    (let ((fn-ty (go-synth ctx callee)))
+      (cond
+        (go-type-error? fn-ty) fn-ty
+        (not (and (list? fn-ty) (= (first fn-ty) :ty-func)))
+        (list :type-error :not-callable fn-ty)
+        :else
+        (let ((params (nth fn-ty 1)) (results (nth fn-ty 2)))
+          (cond
+            (not (= (len args) (len params)))
+            (list :type-error :arity-mismatch
+              (len params) (len args))
+            :else
+            (let ((err (go-check-args-against ctx args params)))
+              (cond
+                (go-type-error? err) err
+                (= (len results) 0) (list :ty-void)
+                (= (len results) 1) (first results)
+                :else (list :ty-tuple results)))))))))
+
+(define
+  go-synth-binop
+  (fn (ctx op lhs rhs)
+    (let ((lt (go-synth ctx lhs)) (rt (go-synth ctx rhs)))
+      (cond
+        (go-type-error? lt) lt
+        (go-type-error? rt) rt
+        ;; Comparison ops always produce bool (untyped-bool, simplified
+        ;; here to :ty-name "bool" until we model untyped-bool).
+        (some (fn (o) (= o op)) go-compare-binops)
+        (list :ty-name "bool")
+        (some (fn (o) (= o op)) go-logical-binops)
+        (list :ty-name "bool")
+        ;; Arithmetic / bitwise: types must unify.
+        (or (some (fn (o) (= o op)) go-arith-binops)
+            (some (fn (o) (= o op)) go-bitwise-binops))
+        (cond
+          (and (go-untyped? lt) (go-untyped? rt))
+          (let ((unified (go-unify-untyped lt rt)))
+            (cond
+              (= unified nil)
+              (list :type-error :binop-untyped-mismatch op lt rt)
+              :else unified))
+          (and (go-untyped? lt) (not (go-untyped? rt)))
+          (cond
+            (go-type-assignable? lt rt) rt
+            :else (list :type-error :binop-mismatch op lt rt))
+          (and (not (go-untyped? lt)) (go-untyped? rt))
+          (cond
+            (go-type-assignable? rt lt) lt
+            :else (list :type-error :binop-mismatch op lt rt))
+          (go-type-equal? lt rt) lt
+          :else (list :type-error :binop-mismatch op lt rt))
+        :else (list :type-error :unsupported-binop op)))))
+
+;; ── check ────────────────────────────────────────────────────────
+
+(define
+  go-check
+  (fn
+    (ctx expr expected)
+    (let
+      ((got (go-synth ctx expr)))
+      (cond
+        (go-type-error? got)
+        got
+        (go-type-assignable? got expected)
+        :ok :else
+        (list :type-error :mismatch expected got)))))
+
+;; ── default types ────────────────────────────────────────────────
+;; Go spec § Constants: the *default type* of an untyped constant
+;; is what it becomes when assigned to a sloppily-typed slot
+;; (e.g., `var x = 42` makes x an int).
+
+(define
+  go-default-type
+  (fn (t)
+    (cond
+      (not (list? t)) t
+      (= (first t) :ty-untyped-int)    (list :ty-name "int")
+      (= (first t) :ty-untyped-float)  (list :ty-name "float64")
+      (= (first t) :ty-untyped-imag)   (list :ty-name "complex128")
+      (= (first t) :ty-untyped-string) (list :ty-name "string")
+      (= (first t) :ty-untyped-rune)   (list :ty-name "int32")
+      :else t)))
+
+;; ── declaration checking ────────────────────────────────────────
+;; Returns either:
+;;   the extended context (success)
+;;   (list :type-error TAG ...) (failure)
+
+(define
+  go-check-exprs-against
+  ;; Check every EXPR in EXPRS is assignable to EXPECTED. Returns the
+  ;; first :type-error encountered, or :ok.
+  (fn (ctx exprs expected)
+    (cond
+      (or (= exprs nil) (= (len exprs) 0)) :ok
+      :else
+      (let ((r (go-check ctx (first exprs) expected)))
+        (cond
+          (go-type-error? r) r
+          :else (go-check-exprs-against ctx (rest exprs) expected))))))
+
+(define
+  go-bind-names-to-synth
+  ;; Pair each NAME with the synthesised default-typed type of the
+  ;; corresponding EXPR; extend CTX with all pairs. NAMES and EXPRS
+  ;; may have different lengths (multi-return funcs aren't here yet);
+  ;; for now we zip the shorter of the two.
+  (fn (ctx names exprs)
+    (cond
+      (or (= (len names) 0) (= (len exprs) 0)) ctx
+      :else
+      (let ((t (go-synth ctx (first exprs))))
+        (cond
+          (go-type-error? t) t
+          :else
+          (let ((ctx2 (go-ctx-extend ctx (first names)
+                       (go-default-type t))))
+            (go-bind-names-to-synth ctx2 (rest names) (rest exprs))))))))
+
+(define
+  go-check-var-decl
+  ;; Shape: (:var-decl (:field NAMES TYPE-or-nil) EXPRS-or-nil)
+  ;; or     (:const-decl (:field NAMES TYPE-or-nil) EXPRS).
+  ;; Logic is the same for v0; const-vs-var distinction matters for
+  ;; mutability checks which arrive later.
+  (fn (ctx decl)
+    (let ((field (nth decl 1)) (exprs (nth decl 2)))
+      (let ((names (nth field 1)) (ann-ty (nth field 2)))
+        (cond
+          ;; var x T (no init) → bind names to T
+          (or (= exprs nil) (= (len exprs) 0))
+          (cond
+            (= ann-ty nil) (list :type-error :missing-type-or-init names)
+            :else (go-ctx-extend-field ctx field))
+          ;; Annotated: var x T = expr — check each expr against T
+          (not (= ann-ty nil))
+          (let ((err (go-check-exprs-against ctx exprs ann-ty)))
+            (cond
+              (go-type-error? err) err
+              :else (go-ctx-extend-field ctx field)))
+          ;; Inferred: var x = expr — bind names to default(synth(expr))
+          :else (go-bind-names-to-synth ctx names exprs))))))
+
+(define
+  go-check-short-decl
+  ;; Shape: (:short-decl LHS-LIST EXPRS). LHS is a list of (:var NAME).
+  ;; Extracts the names and falls through to bind-names-to-synth.
+  (fn (ctx decl)
+    (let ((lhs-list (nth decl 1)) (exprs (nth decl 2)))
+      (let ((names (map (fn (lhs)
+                          (cond
+                            (and (list? lhs) (= (first lhs) :var))
+                            (nth lhs 1)
+                            :else :unknown))
+                        lhs-list)))
+        (go-bind-names-to-synth ctx names exprs)))))
+
+(define
+  go-check-decl
+  ;; Top-level dispatcher: accepts any decl AST shape, returns extended
+  ;; context or :type-error.
+  (fn (ctx decl)
+    (cond
+      (and (list? decl) (= (first decl) :var-decl))   (go-check-var-decl ctx decl)
+      (and (list? decl) (= (first decl) :const-decl)) (go-check-var-decl ctx decl)
+      (and (list? decl) (= (first decl) :short-decl)) (go-check-short-decl ctx decl)
+      (and (list? decl) (= (first decl) :type-decl))
+      (let ((name (nth decl 1)) (ty (nth decl 2)))
+        (go-ctx-extend ctx name ty))
+      (and (list? decl) (= (first decl) :func-decl))
+      (go-check-func-decl ctx decl)
+      (and (list? decl) (= (first decl) :method-decl))
+      (go-check-method-decl ctx decl)
+      :else ctx)))
+
+;; ── method declarations and interface satisfaction ──────────────
+;; Methods are recorded in CTX under a mangled key
+;;   "#method/RECV-TYPE-NAME/METHOD-NAME"
+;; bound to the method's :ty-func signature. Interface satisfaction is
+;; a structural lookup over these keys (Go spec § Interface types:
+;; "anything with the matching method set satisfies the interface").
+
+(define
+  go-method-key
+  (fn (recv-ty-name method-name)
+    (str "#method/" recv-ty-name "/" method-name)))
+
+(define
+  go-extract-recv-ty-name
+  ;; Receiver type is T or *T; return the named type's name string.
+  (fn (recv-ty)
+    (cond
+      (and (list? recv-ty) (= (first recv-ty) :ty-name))
+      (nth recv-ty 1)
+      (and (list? recv-ty) (= (first recv-ty) :ty-ptr))
+      (go-extract-recv-ty-name (nth recv-ty 1))
+      :else nil)))
+
+(define
+  go-check-method-decl
+  ;; (list :method-decl RECV NAME PARAMS RESULTS BODY)
+  ;; Binds the method under the mangled key, then checks body with
+  ;; receiver + params extended.
+  (fn (ctx decl)
+    (let ((recv (nth decl 1)) (name (nth decl 2))
+          (params (nth decl 3)) (results (nth decl 4))
+          (body (nth decl 5)))
+      (let ((recv-ty (nth recv 2)))
+        (let ((recv-name (go-extract-recv-ty-name recv-ty)))
+          (let ((sig (list :ty-func
+                       (go-decl-params-to-ty-list params) results)))
+            (let ((ctx2
+                    (cond
+                      (= recv-name nil) ctx
+                      :else
+                      (go-ctx-extend ctx
+                        (go-method-key recv-name name) sig))))
+              (cond
+                (= body nil) ctx2
+                (and (list? body) (= (first body) :block))
+                (let ((body-ctx
+                        (go-extend-with-params
+                          (go-ctx-extend-field ctx2 recv) params)))
+                  (let ((err
+                          (go-check-block body-ctx
+                            (nth body 1) results)))
+                    (cond
+                      (go-type-error? err) err
+                      :else ctx2)))
+                :else ctx2))))))))
+
+(define
+  go-iface-elems-satisfied?
+  ;; Each :method element in ELEMS must have a matching method in CTX
+  ;; under #method/TY-NAME/M-NAME. :embed elements are skipped in v0
+  ;; (they'd need recursive interface resolution).
+  (fn (ctx ty-name elems)
+    (cond
+      (= (len elems) 0) true
+      :else
+      (let ((e (first elems)))
+        (cond
+          (= (first e) :method)
+          (let ((m-name (nth e 1)) (m-params (nth e 2))
+                (m-results (nth e 3)))
+            (let ((found (go-ctx-lookup ctx
+                           (go-method-key ty-name m-name))))
+              (cond
+                (= found nil) false
+                (and (= (nth found 1) m-params)
+                     (= (nth found 2) m-results))
+                (go-iface-elems-satisfied? ctx ty-name (rest elems))
+                :else false)))
+          (= (first e) :embed)
+          (go-iface-elems-satisfied? ctx ty-name (rest elems))
+          :else
+          (go-iface-elems-satisfied? ctx ty-name (rest elems)))))))
+
+(define
+  go-iface-satisfies?
+  ;; Does the type named TY-NAME satisfy the interface IFACE-TYPE
+  ;; under context CTX? Structural method-set match per Go spec.
+  (fn (ctx ty-name iface-type)
+    (cond
+      (not (and (list? iface-type) (= (first iface-type) :ty-interface)))
+      false
+      :else (go-iface-elems-satisfied? ctx ty-name (nth iface-type 1)))))
+
+;; ── function-decl checking ──────────────────────────────────────
+
+(define
+  go-repeat-ty
+  (fn (n ty acc)
+    (cond
+      (<= n 0) acc
+      :else (go-repeat-ty (- n 1) ty (cons ty acc)))))
+
+(define
+  go-decl-params-to-ty-list
+  ;; Flatten (:field NAMES TYPE) param groups into a list of types,
+  ;; one entry per name. For func-type signatures.
+  (fn (params)
+    (cond
+      (or (= params nil) (= (len params) 0)) (list)
+      :else
+      (let ((field (first params)))
+        (let ((names (nth field 1)) (ty (nth field 2)))
+          (let ((rest-tys (go-decl-params-to-ty-list (rest params))))
+            (go-repeat-ty (len names) ty rest-tys)))))))
+
+(define
+  go-extend-with-params
+  ;; Extend CTX with every binding in every (:field NAMES TYPE) param group.
+  (fn (ctx params)
+    (cond
+      (or (= params nil) (= (len params) 0)) ctx
+      :else
+      (go-extend-with-params
+        (go-ctx-extend-field ctx (first params))
+        (rest params)))))
+
+(define
+  go-check-return-list
+  ;; Each EXPR assignable to the corresponding RESULTS type.
+  ;; v0: lengths must match; multi-return funcs deferred.
+  (fn (ctx exprs results)
+    (cond
+      (and (= (len exprs) 0) (= (len results) 0)) :ok
+      (not (= (len exprs) (len results)))
+      (list :type-error :return-count-mismatch
+        (len exprs) (len results))
+      :else
+      (let ((r (go-check ctx (first exprs) (first results))))
+        (cond
+          (go-type-error? r) r
+          :else (go-check-return-list ctx (rest exprs) (rest results)))))))
+
+(define
+  go-check-assign
+  (fn (ctx stmt)
+    (let ((lhs-list (nth stmt 1)) (rhs-list (nth stmt 2)))
+      (cond
+        (not (= (len lhs-list) (len rhs-list)))
+        (list :type-error :assign-count-mismatch
+          (len lhs-list) (len rhs-list))
+        :else (go-check-assign-pairs ctx lhs-list rhs-list)))))
+
+(define
+  go-check-assign-pairs
+  (fn (ctx lhs-list rhs-list)
+    (cond
+      (= (len lhs-list) 0) :ok
+      :else
+      (let ((lhs-ty (go-synth ctx (first lhs-list))))
+        (cond
+          (go-type-error? lhs-ty) lhs-ty
+          :else
+          (let ((r (go-check ctx (first rhs-list) lhs-ty)))
+            (cond
+              (go-type-error? r) r
+              :else
+              (go-check-assign-pairs ctx (rest lhs-list)
+                (rest rhs-list)))))))))
+
+(define
+  go-check-stmt
+  ;; Returns either an extended CTX (decls), :ok (sealed stmts), or
+  ;; :type-error. RESULTS is the enclosing func's declared return types
+  ;; (used by :return).
+  (fn (ctx stmt results)
+    (cond
+      (and (list? stmt) (= (first stmt) :var-decl))
+      (go-check-decl ctx stmt)
+      (and (list? stmt) (= (first stmt) :const-decl))
+      (go-check-decl ctx stmt)
+      (and (list? stmt) (= (first stmt) :short-decl))
+      (go-check-decl ctx stmt)
+      (and (list? stmt) (= (first stmt) :type-decl))
+      (go-check-decl ctx stmt)
+      (and (list? stmt) (= (first stmt) :return))
+      (let ((exprs (nth stmt 1)))
+        (let ((err (go-check-return-list ctx exprs results)))
+          (cond (go-type-error? err) err :else ctx)))
+      (and (list? stmt) (= (first stmt) :block))
+      (let ((err (go-check-block ctx (nth stmt 1) results)))
+        (cond (go-type-error? err) err :else ctx))
+      (and (list? stmt) (= (first stmt) :assign))
+      (let ((err (go-check-assign ctx stmt)))
+        (cond (go-type-error? err) err :else ctx))
+      :else
+      (let ((t (go-synth ctx stmt)))
+        (cond (go-type-error? t) t :else ctx)))))
+
+(define
+  go-check-block
+  ;; Thread ctx through stmts; if any stmt is a decl, its extension
+  ;; propagates to subsequent stmts. Returns :ok or :type-error.
+  (fn (ctx stmts results)
+    (cond
+      (or (= stmts nil) (= (len stmts) 0)) :ok
+      :else
+      (let ((r (go-check-stmt ctx (first stmts) results)))
+        (cond
+          (go-type-error? r) r
+          :else (go-check-block r (rest stmts) results))))))
+
+(define
+  go-check-func-decl
+  ;; Bind the function in the outer ctx (so recursion works), extend
+  ;; ctx with type params + value params, check the body. Returns the
+  ;; outer ctx with the function bound, or :type-error.
+  ;;
+  ;; Type parameters become opaque type variables in the body's ctx:
+  ;; each name `T` is bound as a type alias to (:ty-param "T") so the
+  ;; checker treats references to T as "this type", not "unknown".
+  ;; Constraint enforcement (T satisfies `comparable` etc.) is a
+  ;; later refinement; v0 just allows any operation that's polymorphic
+  ;; under the constraint `any`.
+  (fn (ctx decl)
+    (let ((name (nth decl 1)) (params (nth decl 2))
+          (results (nth decl 3)) (body (nth decl 4))
+          (type-params (cond (> (len decl) 5) (nth decl 5) :else nil)))
+      (let ((fn-ty
+              (list :ty-func
+                (go-decl-params-to-ty-list params) results)))
+        (let ((ctx-with-fn (go-ctx-extend ctx name fn-ty)))
+          (cond
+            (= body nil) ctx-with-fn
+            (and (list? body) (= (first body) :block))
+            (let ((body-ctx
+                    (go-extend-with-type-params
+                      (go-extend-with-params ctx-with-fn params)
+                      type-params)))
+              (let ((err
+                      (go-check-block body-ctx (nth body 1) results)))
+                (cond
+                  (go-type-error? err) err
+                  :else ctx-with-fn)))
+            :else ctx-with-fn))))))
+
+(define
+  go-extend-with-type-params
+  ;; Each (:field NAMES CONSTRAINT) field contributes opaque type
+  ;; vars: bind each NAME as a type alias to (:ty-param NAME). The
+  ;; constraint type is stored alongside so future "constraint
+  ;; satisfaction" checks can find it; for v0 it's informational.
+  (fn (ctx type-params)
+    (cond
+      (or (= type-params nil) (= (len type-params) 0)) ctx
+      :else
+      (let ((field (first type-params)))
+        (let ((names (nth field 1)) (constraint (nth field 2)))
+          (go-extend-with-type-params
+            (go-extend-with-type-param-names ctx names constraint)
+            (rest type-params)))))))
+
+(define
+  go-extend-with-type-param-names
+  (fn (ctx names constraint)
+    (cond
+      (= (len names) 0) ctx
+      :else
+      (let ((nm (first names)))
+        (go-extend-with-type-param-names
+          (go-ctx-extend ctx nm
+            (list :ty-param nm constraint))
+          (rest names) constraint)))))

plans/abstractions.md

@@ -0,0 +1,417 @@
+# Abstraction Radar — backlog
+
+Maintained by the read-only `radar` loop (see `plans/agent-briefings/radar-loop.md`).
+Detection only — implementation is a separate, coordinated step owned by the
+relevant subsystem loop, never by radar.
+
+**AHA gate to reach _Proposed_:** ≥3 real consumers · all past Phase 2 & API-stable ·
+structurally identical (file:line evidence) · a natural home (usually NOT lib/guest).
+Anything short → _Watching_ (what's missing) or _Rejected_ (why).
+
+---
+
+## Last scan
+
+- **Date:** 2026-06-07 (radar loop, pass 18)
+- **Pass 18 — W1 gate re-test.** events shipped Phase 4 federation (5th consumer): a 5th
+  divergent merge (sorted agenda + `:origin` provenance), trust-gate = runtime list
+  membership (shares mod's mechanism, not acl's). Reinforces W1's "theme not shape" — but
+  the **inject-fed-sx-transport seam is now 5/5**, strengthening "all are fed-sx
+  consumers-in-waiting." Trust sub-pattern refined: mod+events (runtime set) vs acl (rule).
+- **Date:** 2026-06-07 (radar loop, pass 17)
+- **Pass 17 — filename census declared EXHAUSTED** (see the Census-status table above).
+  Examined the last unswept ≥2 recurrences (schema/engine = acl⇄mod substrate twins;
+  catalog/batch = name collisions; store = divergent). No new candidate. Incremental churn
+  elsewhere (content 621/621, identity PAR, events reminders). Future passes pivot from
+  censusing to re-testing gates as consumers mature.
+- **Date:** 2026-06-07 (radar loop, pass 16)
+- **Pass 16:** events started Phase 3 — **durable notification delivery on `lib/flow`**
+  (new W8: at-least-once + idempotency exemplar; fed-sx/mod roll their own outbox). The two
+  `notify.sx` (feed vs events) are a name collision (read-side digest vs delivery), noted
+  in W8. Substrate-adoption story deepening: app domains now consume persist (content/
+  commerce/events), flow (events), commerce (events), acl-authZ (identity).
+- **Date:** 2026-06-07 (radar loop, pass 15)
+- **Pass 15:** added the **scanning-method note** above after `query.sx` again proved to
+  be merged-lib copies (lib/prolog + lib/persist in every worktree). Corrected census
+  surfaced `wire`×2 (content+mod) → Rejected (shared role, divergent structure: generic SX
+  serializer vs bespoke pipe-format under a Prolog-env string-prim constraint). events↔
+  commerce integration appeared (paid tickets); acl/mod/search quiescent ~7 passes (now
+  API-stable). No new gate-clearer.
+- **Date:** 2026-06-07 (radar loop, pass 14)
+- **Pass 14:** filename census flagged `snapshot`×?? — but the `*/lib/persist/snapshot.sx`
+  copies are just the merged `lib/persist` in each worktree, NOT consumers (same artifact
+  as `lib/feed/rank.sx` everywhere). The one distinct file, `content/snapshot.sx`,
+  reimplements persist's projection-checkpoint on raw KV instead of using `persist/snapshot`
+  → new W7 (persist-adoption nudge). `audit`×3 = the W4 fakes (acl/mod/identity), known.
+- **Date:** 2026-06-07 (radar loop, pass 13)
+- **Pass 13 — honest re-test, no gate-clearer.** Re-tested the two longest-waiting gates
+  against the maturing app-domain loops: **W2** (per-viewer visibility) still 2 consumers
+  (feed, search) — commerce/content/events/identity add no per-viewer read filter; **W3**
+  (pagination) still 2 (feed, search) — `content/page.sx` is an HTML wrapper, not
+  pagination (filename collision, noted in W3). Incremental churn only elsewhere.
+- **Date:** 2026-06-07 (radar loop, pass 12)
+- **Pass 12:** `events` shipped **transactional booking on persist** (3rd live persist
+  consumer) using `persist/append-expect` (optimistic-concurrency CAS, lock-free capacity
+  safety). W4 ledger now shows a persist feature-ladder append → append-once → append-expect
+  that the hand-rolled fakes can't match. No new candidate; W4 reinforced.
+- **Date:** 2026-06-07 (radar loop, pass 11)
+- **Pass 11 — W4 sharpened with a consumer ledger.** commerce built an **order ledger on
+  persist** (2nd live exemplar; uses `persist/append-once` for webhook idempotency) and
+  identity a **grant audit ledger** (in-memory Erlang fake, gated on an Erlang↔persist
+  bridge). The append-only monotonic-seq event-log pattern is now validated across 4
+  domains, 2 live on persist + 3 fakes flagged for adoption. See W4 table.
+- **Date:** 2026-06-07 (radar loop, pass 10)
+- **Pass 10:** commerce/content/events/identity advancing (content 238/238). Probed a
+  shape outside the routing table — **guarded lifecycle state machines** (mod/lifecycle +
+  identity/membership) → new W6: shared *design principle*, divergent *structure*
+  (SX transition-table vs Erlang gen_server), NOT an extraction target. No gate-clearer.
+- **Date:** 2026-06-07 (radar loop, pass 9)
+- **Pass 9:** `commerce` + `content` reached Phase 2 (`content` 162/162). **Key find:
+  `content` built its op log directly on `persist/log`** (backend-injected, append+replay-
+  to-seq) — the live reference exemplar for W4 (see W4). `events` MONTHLY RRULE,
+  `identity` OAuth2 auth-code + PKCE, search boolean-filtered ranked. A1 still 6 adopters.
+- **Date:** 2026-06-06 (radar loop, pass 8)
+- **Pass 8 — fleet expanded by 4 app-domain loops** (the briefing's anticipated
+  `commerce`/`identity` arrivals, auto-picked up by dynamic discovery). All early-stage,
+  **pre-Phase-2 → moving targets, none count toward any gate yet**:
+  - `commerce` (Phase 1: `api/cart/catalog/price`). Its "per-line audit" is a cost
+    *breakdown view* (`api.sx:44`), **not** an append-only decision log → NOT a W4
+    consumer.
+  - `events` (Phase 1: `calendar.sx`, RRULE expansion).
+  - `identity` (early: `session/token`). Defers authZ to acl (`token.sx:15`) — reinforces
+    W2's "delegate `permit?` to acl-on-sx" routing; identity = authN, acl = authZ.
+  - `content` (just-started: `block.sx`).
+  These are the future consumers W2/W3 are waiting on — re-check their per-viewer filters
+  / pagination once each clears Phase 2. No new gate-clearer this pass.
+- **Pass 7:** **A1 jumped 4→6 adopters** — `acl` + `mod` migrated to the shared
+  conformance driver (first app-domain adopters; proves it generalizes past substrates).
+  `host-persist` closed its blob-adapter blocker (durable storage adapter now landing →
+  W4 migration path opening). search shipped proximity/NEAR; flow + persist quiescent.
+- **Pass 6:** new worktree **`host-persist`** (active — building persist's durable host
+  adapter); `feed` went quiescent (left tmux). acl shipped hardening (+25), fed-sx-m1 at
+  Step 6c. **mod loop independently wrote a shared-plumbing note** (`mod-on-sx.md`,
+  538b8a53) corroborating W4/W5 — folded its claims + home disagreements into W1/W4/W5.
+  No new gate-clearer (audit log still 2 consumers), but consumers are now API-stable.
+- **Pass 5:** search (+highlight/snippet) and fed-sx-m1 (+follower_graph) moved; rest
+  unchanged. Filename census: `api`×6, `fed`×3, then `schema/rank/query/page/explain/
+  engine/batch/audit`×2. Examined the ×6 `api.sx` → Rejected (shared name, divergent
+  structure incl. implicit-vs-explicit-state contract). rank/batch/engine all ≤2 +
+  substrate/domain-divergent → no new gate-clearer.
+- **Pass 4:** no churn vs pass 3 (same worktrees/tmux/HEADs/adopters). Swept audit+explain
+  surfaces: acl/mod share an append-only-log shape (→ sharpened W4 with persist/log API
+  evidence) and a proof-explain shape (→ new W5, substrate-bound). No new gate-clearer.
+- **Pass 3 (earlier today):** subsystem set + tmux + A1 adopters (4) all unchanged vs pass 2. Loops
+  advanced: acl shipped Phase 4 federation; search shipped Phase 4 + pagination; feed
+  shipped pagination/threading; mod at Ext 19 (capstone); persist did a worked acl-grants
+  migration (W4). New shape found: offset/limit pagination → folded into W3.
+- **Subsystem set discovered:** loop worktrees `acl, erlang, fed-prims, fed-sx-m1,
+  feed, flow, go, kernel, mod, ocaml, persist, radar, ruby, search,
+  sx-vm-extensions`; main-repo `lib/*` incl. merged `feed` + substrates (`apl,
+  common-lisp, datalog, erlang, forth, go, haskell, hyperscript, js, lua, minikanren,
+  ocaml, prolog, scheme, smalltalk, tcl`) + `lib/guest`.
+  Actively looping (tmux): `acl, fed-sx-m1, feed, flow, mod, persist, search`
+  (+ radar).
+- **New since pass 1:** worktrees `kernel` (empty/unset — not yet a repo) and `ocaml`
+  (`lib/ocaml/baseline` only). Both early-stage, pre–Phase 2 → out of proposal scope.
+- Re-enumerate every pass; new loops (e.g. a future `commerce`/`identity`) auto-join.
+
+**Census status (pass 17): EXHAUSTED.** Every own-namespace filename recurring ≥2× has
+been examined and dispositioned — further filename-censusing is low-yield until new
+subsystems/modules appear. Map:
+| filename | owners | verdict |
+|---|---|---|
+| `api` ×10 | all | Rejected — shared role, divergent state contract |
+| `fed`/`federation` | feed/search/mod/acl(+content) | W1 — theme not shape |
+| `audit` ×3 | acl/mod/identity | W4 — append-only log → persist/log |
+| `page` ×3 | feed/search (pagination) + content (HTML wrapper) | W3 + collision noted |
+| `explain` ×2 | acl/mod | W5 — proof tree, substrate-bound |
+| `snapshot` ×2 | persist(facet) + content(reinvents) | W7 |
+| `wire` ×2 | content(SX serializer) / mod(pipe-format) | Rejected — divergent |
+| `schema`,`engine` ×2 | acl/mod | substrate-twin parallels (Datalog vs Prolog); only audit (W4) is liftable |
+| `catalog`,`batch` ×2 | commerce/persist, mod/persist | name collisions, unrelated |
+| `store` ×2 | content(on persist) / flow(workflow records) | related concept, divergent |
+| `rank` ×2 | feed/search | different domains (activities vs docs), ≤2 |
+**acl⇄mod are structural twins** (decision engine over a logic substrate, Datalog vs
+Prolog) — they parallel across engine/schema/explain/audit/fed, but only the *audit log*
+is substrate-agnostic and liftable (→ W4); the rest are substrate-idiomatic. Next passes:
+re-test gates (W2/W3/W8) as consumers mature, watch new modules — not re-census.
+
+**Scanning-method note (learned the hard way, passes 5/12/14/15):** a filename census
+for *cross-subsystem* recurrence MUST restrict to each subsystem's OWN namespace —
+`X/lib/X/*.sx` — never `X/lib/*/`. The merged substrate libs (`lib/prolog`, `lib/persist`,
+`lib/feed`, `lib/datalog`, …) are checked out inside *every* worktree, so a naive census
+reports e.g. `query.sx`/`snapshot.sx`/`rank.sx` ×N as phantom recurrences that are really
+one merged file copied N times. Correct one-liner:
+`for w in <subsystems>; do for f in $w/lib/$w/*.sx; do basename $f .sx; done; done | sort | uniq -c | sort -rn`.
+
+---
+
+## Proposed (cleared the gate)
+
+### A1 · Adopt the shared conformance driver across subsystems
+- **Pattern:** every subsystem hand-rolls a near-identical `conformance.sh`
+  (epoch-load → eval → scoreboard emit) and an inline `<x>-test name got expected`
+  pass/fail counter.
+- **Consumers (≥3, overwhelming):** 15 `lib/*/conformance.sh` — `apl, feed, datalog,
+  flow, mod, lua, erlang, forth, go, common-lisp, haskell, js, ocaml, prolog,
+  smalltalk, tcl`.
+- **Home:** `lib/guest` — the one legitimate exception (the shared driver
+  `lib/guest/conformance.sh` + `lib/guest/conformance.sx` already exist; modes
+  `dict` and `counters`).
+- **Status: IN PROGRESS — 6 adopters (pass 7).** `prolog` (dict), `haskell` (counters),
+  `apl` (dict), `datalog` (dict), and **`acl` (dict) + `mod` (dict), newly migrated this
+  pass** — all 3-line exec shims into `lib/guest/conformance.sh` with a `conformance.conf`.
+  **acl + mod are the first *app-domain* adopters** (not language substrates) — strong
+  evidence the driver generalizes beyond the substrate layer, which was the open question.
+  The `apl` migration earlier *surfaced a latent bug*: the old awk extractor
+  under-counted `pipeline` (40 vs the real 152 assertions); true apl total is **562**,
+  not 450 — evidence that adopting the driver also improves correctness.
+- **Not a target (different harness shape):** `lua/conformance.sh` is a Python runner
+  (`lib/lua/conformance.py`) that walks real `*.lua` source files via `lua-eval-ast`
+  and classifies pass/fail/timeout — it does not run SX `deftest` suites with a
+  counter/dict scoreboard, so the shared driver does not fit. Excluded, not pending.
+- **Remaining hand-rolled candidates (~120–220 lines each):** `common-lisp, erlang,
+  feed, forth, go, js, ocaml, smalltalk, tcl` — each its OWN loop's migration when
+  quiescent. (`search` + `lua` excluded: different harness shapes — search assembles a
+  Haskell source string, lua walks real `*.lua` files.)
+- **Action:** each remaining subsystem's OWN loop migrates when quiescent — add a
+  `conformance.conf` (+ a `test-harness.sx` preload defining its counters) and
+  replace `conformance.sh` with the 1-line exec shim
+  (`exec bash …/guest/conformance.sh …/conformance.conf "$@"`). Recipe template:
+  `lib/haskell/conformance.conf` (counters) or `lib/prolog/conformance.conf` (dict).
+  Keep the `bash lib/X/conformance.sh` entry point so no loop is disrupted.
+- **Priority: HIGH** (15 consumers, low risk, interface-preserving, additive).
+
+---
+
+## Watching (real but not yet through the gate)
+
+### W1 · Federation scaffold (merge / ingest / backfill / trust-gate)
+- **FAILS the structural-identity gate (deep-dived 2026-06-06, all 4 read).** Consumer
+  count is met (4) but they are *superficially* similar, not structurally identical —
+  the federated unit and merge op differ fundamentally:
+
+  | Subsystem (file) | Federated unit | Merge op | Trust gate | Injected transport |
+  |---|---|---|---|---|
+  | feed (`fed.sx:14,18,40`) | activity streams | dedupe by `(actor verb object)` | none (visibility via `permit?` separately) | `send-fn`, `fetch-fn` |
+  | search (`fed.sx:8`) | inverted indices | relabel DocId `peer*1000+local` + union posting lists | none | none (pure merge fn) |
+  | mod (`fed.sx:11-14,99`) | moderation decisions | advisory-list vs applied-list; bind iff `mod/trusted?` | **yes — runtime list** `mod/trusted? peer scope` | mock outbox / `fed-send!` |
+  | acl (`federation.sx:43,56`) | Datalog delegate facts | pull facts, gate by `trust`/`level_covers` rule, re-saturate | **yes — Datalog rule** at query time | `transport` dict |
+  | events (`federation.sx`) | calendar agendas | fold trusted peers' agendas into one sorted agenda + `:origin` provenance | **yes — runtime list** `ev/trusts?` (peer-id ∈ trust-set) | injected behind `ev/peer-agenda` |
+
+- **The ONLY real commonality is the injection seam** (now 5/5, pass 18), not extractable
+  code: every one says "the real transport is `fed-sx`'s job; inject `send-fn`/`fetch-fn`/
+  `transport`/`peer-agenda` and mock it in tests." That is an architectural *convention the
+  fleet already follows*. The merge op diverges 5 ways (dedupe / index-union / advisory /
+  fact-saturation / agenda-sort). The trust gate, where present, splits: **mod + events use
+  a runtime trust-set membership check; acl uses a declarative Datalog rule** — so even the
+  trust sub-pattern is 2-of-3, and the membership check is a trivial one-liner (below the
+  extraction threshold). No shared merge, no single shared trust mechanism.
+- **Disposition:** do NOT extract a shared "federation lib." When `fed-sx` ships its
+  real transport, these 4 become its *consumers* (wiring `send-fn`/`fetch-fn`/`transport`
+  to it) — that work belongs to each subsystem's loop + the `fed-sx` loop, not a
+  cross-cutting extraction. Stop re-proposing on the shared name. Home: `fed-sx`.
+- **Narrower sub-claim (mod note, pass 6; refined pass 18):** mod asserts the *fed
+  trust/outbox* shape shares between mod+acl. Radar evidence refines this: the trust gate
+  splits by mechanism, not by subsystem pair — **mod + events** both use a runtime
+  trust-set membership check (`mod/trusted?`, `ev/trusts?`), while **acl** uses a Datalog
+  rule. So a "trust-set membership" helper has 2 consumers (mod, events) — but it's a
+  one-line `member?` and the merge it gates diverges, so still not worth extracting.
+  Resolve at the architecture-merge point if a heavier shared trust-set surface emerges.
+
+### W2 · Per-viewer visibility / permission filter
+- **2 shipped consumers, same shape** — `filter <injected-permit> <ranked/candidate stream>`:
+  - `feed/lib/feed/acl.sx:27` `feed/visible = (feed/filter stream (fn (a) (permit? viewer a)))`,
+    capstone at `:34` (stream → ACL → rank → top-N). `permit?` injected, sig `(viewer activity)→bool`.
+  - `search/lib/search/fed.sx:16` `aclFilter permit docs = filter permit docs`;
+    `topNTfIdfAcl n permit ts idx = take n (aclFilter permit (rankTfIdf ts idx))`.
+    `permit` injected, sig `DocId→Bool` (viewer baked in by caller).
+- **NOT a consumer:** `mod/lib/mod/policy.sx` is moderation policy (reviewer actions),
+  no per-viewer read filter. So mod won't be the 3rd.
+- **Missing:** (a) only 2 consumers, need ≥3; (b) the two interfaces *diverge* —
+  feed passes `(viewer, item)`, search bakes the viewer in — so any shared form must
+  pick a convention; (c) both already **inject** the predicate, and the filter body is
+  literally one line (`filter permit xs`). Leaning toward: the predicate's home is
+  `acl-on-sx` (`permit?`), and the one-line filter is too thin to extract.
+- **Home when ripe:** delegate `permit?` to `acl-on-sx`; do NOT extract the filter.
+  Re-check if a 3rd genuine per-viewer read filter ships (e.g. events/commerce).
+
+### W3 · Collection helpers (group-by, dedupe-by-key, stable top-N, distinct-order, offset/limit page)
+- feed built all of these on APL primitives. search/commerce/events will want
+  group-by / top-N.
+- **NEW (2026-06-06): offset/limit pagination shipped in 2 subsystems, identical shape**
+  `take limit (drop offset xs)`:
+  - `feed/lib/feed/page.sx:9` `feed/page` (offset/limit window over a stream).
+  - `search/lib/search/page.sx:9` `paginate off lim docs = take lim (drop off docs)`.
+  - NOT a 3rd: `persist/lib/persist/query.sx:5` has a *since-cursor* for incremental log
+    consumption — resumable-stream semantics, not result windowing. Different shape.
+  - feed *also* has cursor-by-`:at` recency pagination (`page.sx:21-44`); search has no
+    cursor. So only the plain offset/limit window is shared, and it is a literal 1-liner.
+- **Missing:** ≥3 stable consumers; AND every item here is collection math that belongs
+  in the **substrate** (APL/Haskell already expose grade/sort/unique/take/drop), not a
+  shared lib. A 1-line `take/drop` window is far below the extraction threshold. Watch;
+  revisit only if a non-substrate subsystem needs the same windowing without take/drop.
+- **Filename-collision caution (pass 13):** `content/lib/content/page.sx` is an **HTML
+  page wrapper** (full HTML5 doc), NOT pagination — do not count it as a 3rd pagination
+  consumer. `page.sx` now means two unrelated things across the fleet. Re-tested pass 13:
+  pagination still only feed + search (2).
+
+### W4 · In-memory store fakes → `persist-on-sx`
+- Not an abstraction to extract — a migration target. Every subsystem fakes its
+  store with a mutable list (`feed/-log`, flow store, mod audit, …).
+- **Owner:** `persist-on-sx` (in progress). Tracked there, listed here for visibility.
+- **Concrete instance (file:line, found pass 4): the append-only decision/audit log.**
+  `acl/lib/acl/audit.sx` and `mod/lib/mod/audit.sx` are the SAME hand-rolled shape, and
+  `persist/lib/persist/log.sx` (the persist *log facet*) already implements it durably:
+
+  | role | acl/audit.sx | mod/audit.sx | persist/log.sx (target) |
+  |---|---|---|---|
+  | log var | `acl-audit-log` :9 | `mod/*audit-log*` :10 | backend stream |
+  | monotonic seq | `acl-audit-seq` :10 | `mod/*audit-seq*` :11 | per-stream high-water :1 |
+  | append (auto-seq) | `acl-audit-decide!` | commit :32 | `persist/append` :17 |
+  | count | `acl-audit-count` :51 | `mod/audit-count` :44 | `persist/count` :12 |
+  | read-all oldest-first | snapshot/tail :73 | `mod/audit-all` :43 | `persist/read` :29 |
+  | read seq≥from | — | by-seq | `persist/read-from` :31 |
+
+  Both deliberately use a monotonic seq with **no wall-clock** (deterministic/testable) —
+  identical to persist/log's design. Action when persist's host adapter lands: acl + mod
+  loops swap their in-memory log for `persist/log`. 2 consumers today; not a new lib —
+  the home already exists. Belongs to acl/mod loops × persist loop, not an extraction.
+- **Cross-loop corroboration (pass 6):** the mod loop independently reached the same
+  conclusion — `mod/plans/mod-on-sx.md` (commit 538b8a53): *"mod-sx (Prolog) and acl-sx
+  (Datalog) converged on the same module shape … only the audit log + fed trust/outbox
+  shapes truly share; extract at the architecture-merge point, refactoring both consumers
+  atomically, not unilaterally from a loop branch."* Confirms the shape AND the
+  do-not-extract-unilaterally stance.
+- **Home disagreement to resolve at merge:** mod's note proposes lifting the audit-log
+  primitives into **`lib/guest/`**. Radar routing disagrees: a durable append-only log is
+  a **`persist-on-sx`** concern (the log facet already exists), not language-impl plumbing.
+  Hold the line — `lib/guest` is lexer/parser/AST/HM/test-runner, not an event log.
+- **Migration is becoming concrete:** new `host-persist` loop (worktree + tmux, pass 6)
+  is building the durable-storage host adapter persist was blocked on — once it lands,
+  acl/mod can actually swap to `persist/log`.
+- **LIVE REFERENCE EXEMPLAR (pass 9): `content` already does it right.** `content`
+  (Phase 2 complete, 162/162) built its op log directly on `persist/log` instead of
+  faking it — `content/lib/content/store.sx`: backend injected via `(persist/open)`
+  ("content knows nothing about which backend", :10); append op as event
+  `persist/append b (content/-stream doc-id) …` (:20); read `persist/read` (:36);
+  `persist/last-seq` (:47); **version = replay op stream up to a seq**
+  (filter `persist/event-seq ev <= seq`, :61). "The op log is the source of truth …
+  the materialised doc is a cache, never primary state."
+  This proves the W4 target is real, not hypothetical: acl + mod's hand-rolled
+  monotonic-seq logs should adopt exactly content's `persist/log` pattern.
+- **Consumer ledger of the append-only monotonic-seq event log (pass 11):**
+
+  | consumer | what | backing | note |
+  |---|---|---|---|
+  | content (`store.sx`) | doc op log | **persist/log ✓ live** | plain append + replay-to-seq |
+  | commerce (`ledger.sx`) | order ledger | **persist/log ✓ live** | `persist/append-once` — idempotent, webhook-replay-safe :40,58 |
+  | events (`booking.sx`) | booking roster | **persist/log ✓ live** | `persist/append-expect` — optimistic-concurrency CAS, capacity-safe, lock-free |
+  | acl (`audit.sx`) | decision log | in-memory fake (SX) | migrate directly when host adapter lands |
+  | mod (`audit.sx`) | decision log | in-memory fake (SX) | migrate directly |
+  | identity (`audit.sx`) | grant ledger | in-memory fake (**Erlang**) | `{Seq,Subject,Action}`; needs an **Erlang↔persist bridge** first — author scoped it out until persist lands ("queryable semantics identical") |
+
+- **Two takeaways:** (1) the pattern is **validated across domains** — CRDT doc ops,
+  financial orders, event bookings, rule decisions, OAuth grants all reduce to the same
+  append-only monotonic-seq stream; (2) migrating to `persist/log` is strictly *better*
+  than the fakes — persist exposes a **feature ladder the fakes don't have**:
+  `append` (content) → `append-once`/idempotency (commerce) → `append-expect`/optimistic-
+  concurrency (events). Every fake would have to reinvent a weaker version of these.
+  This is an **adoption** item (the home already exists), NOT a new extraction — owned by
+  persist/host-persist × each consumer loop. The SX fakes (acl, mod) migrate directly;
+  the Erlang fake (identity) is gated on an Erlang↔persist bridge.
+
+### W5 · Proof-tree explanation over a logic-program derivation
+- `acl/lib/acl/explain.sx` (reconstructs a canonical proof by goal-directed search over a
+  saturated Datalog db) and `mod/lib/mod/explain.sx` (renders a Prolog-style proof tree
+  goal-by-goal with proved/unproved marks + unification bindings) are the same *idea*.
+- **Missing / disposition:** only 2 consumers, and they sit on **different substrates**
+  (acl→`lib/datalog`, mod→`lib/prolog`). Proof reconstruction/rendering is logic-engine
+  machinery → it belongs in each **substrate** (datalog/prolog), not a shared app lib.
+  Watch; revisit only if a 3rd logic-backed subsystem reimplements proof explanation.
+- **Cross-loop note (pass 6):** mod's note calls `mod/proof-goals` (re-query-each-goal)
+  generic and proposes lifting it into **`lib/guest/`**. Radar caveat: proof-tree
+  reconstruction *is* engine-agnostic logic machinery, but `lib/guest` is for
+  lexer/parser/AST/HM/match/test-runner — a logic-engine proof helper is a poor fit there.
+  If genuinely shared by ≥3 engines, a `lib/logic`-style substrate helper is the better
+  home than `lib/guest`. Still 2 consumers → stays Watching either way.
+
+---
+
+### W8 · Durable outbound delivery (at-least-once + idempotency + retry)
+- **Live exemplar on `lib/flow`:** `events/lib/events/notify.sx` — reminders/digests are
+  durable `flow`s: a flow `request`s delivery (suspend point), the **host** performs the
+  send via an injected `dispatch` transport, then resumes with the outcome; flow's
+  deterministic replay means a completed delivery never re-runs on recovery. At-least-once
+  with an idempotency key per message. This is "reliable delivery" done right on the flow
+  substrate.
+- **Others roll their own:** `fed-sx` built its own outbox + `delivery_worker` + retry
+  bookkeeping (Steps 8a–d); `mod/fed.sx` has an in-memory outbox seam; `acl/federation`
+  propagates facts. Same *goal* (reliable outbound delivery, retry/idempotency) on
+  different machinery.
+- **Disposition:** durable delivery is exactly what `lib/flow` is *for* (events proves
+  it). Watch whether fed-sx / mod converge their outbox onto flow, or stay bespoke for
+  perf/substrate reasons. 1 clean flow-based consumer today → Watching, not a proposal.
+- **Name-collision caveat:** `notify.sx` means two unrelated things — `feed/notify.sx` is
+  a *read-side digest* (group inbox by verb+object), NOT delivery. Do not pair them.
+
+### W7 · Snapshot/projection-checkpoint reimplemented vs `persist/snapshot` (delegate)
+- `persist/lib/persist/snapshot.sx` already provides a **generic** projection checkpoint:
+  store `{:value :seq}` in the kv facet under a namespaced key; the headline property is
+  **snapshot + tail == full replay** (pure, clock-free).
+- `content/lib/content/snapshot.sx` **reimplements that same pattern on raw persist KV**
+  rather than delegating: `persist/kv-put b (content/-snap-key doc-id) {:doc … :seq seq}`
+  (:20), `persist/kv-has?`/`kv-get` (:27-28), and its own tail-replay (:53-59). It never
+  calls `persist/snapshot-*`. content's doc-materialisation *is* a projection fold over
+  its op stream — exactly what `persist/snapshot` checkpoints generically.
+- **Disposition:** persist-adoption nudge (like W4): content could delegate to
+  `persist/snapshot` (its projection = "fold ops → doc"), dropping the duplicated
+  KV+replay code. Home already exists → NOT an extraction; owned by content × persist
+  loops. Only 1 reinventor today; watch whether commerce/events/identity also hand-roll a
+  snapshot on raw KV instead of using the facet (would strengthen the nudge). NB timeline:
+  unclear if `persist/snapshot` predated content's — flag, don't blame.
+
+### W6 · Guarded lifecycle state machine (illegal transition = explicit error)
+- Recurs as a **design principle**, NOT a shared structure (found pass 10):
+  - `mod/lib/mod/lifecycle.sx` — pure SX: immutable case `{:state :error :history …}`,
+    explicit transition table `mod/lc-transitions` (:31), illegal transition returns the
+    case unchanged with `:error` set. States open→triaged→decided→appealed→final.
+  - `identity/lib/identity/membership.sx` — an **Erlang `gen_server`** fragment (identity
+    runs on erlang-on-sx): a `receive` loop with `case find(...) of … {error, St}` guards.
+    States none→pending→active→lapsed→revoked.
+- **Both share the guideline** ("invalid transitions are explicit errors, never silent
+  no-ops") but **implement it substrate-idiomatically** — SX transition-table over
+  immutable values vs an Erlang process loop with per-message case guards. Same W1/`api.sx`
+  trap: shared *idea*, divergent *structure*.
+- **Disposition:** not an extraction target — the FSM mechanism is ~10 substrate-specific
+  lines; the value is in each domain's state graph, not the plumbing. At most a **design
+  guideline** ("model lifecycle as a guarded FSM with explicit-error transitions"). Watch
+  whether commerce-checkout / events-booking add their own — if so it confirms the
+  *guideline*, still not a lib. Do not propose extracting a shared state-machine lib.
+
+## Rejected (considered, declined — do not re-propose)
+
+- **"Continuous auto-implementing abstractor loop."** Rejected at design time: an
+  agent writing across `lib/<x>/**` breaks the worktree isolation that makes the
+  fleet safe, and is rewarded for manufacturing premature/wrong abstractions. The
+  radar is read-only by design. (This file is the alternative.)
+- **Shared `api.sx` "public boundary" module (×6).** Rejected pass 4-5: every subsystem
+  has an `api.sx` (acl, feed, flow, mod, persist, search — a 100% filename match), but it
+  is a naming *convention for the public entry point*, not a shared structure. They
+  disagree on the most basic contract: acl/feed use **implicit module state**
+  (`acl/api.sx` "implicit current db", `feed/api.sx` "single mutable log") while
+  `persist/api.sx` threads an **explicit backend as every call's first arg**; flow's api
+  *builds a Scheme env*, search's api *concatenates a Haskell source string*, mod's is a
+  *lifecycle state-machine façade* (17 defs vs persist's 1). Same role, no common shape —
+  the W1 coincidental-resemblance trap. Do not re-propose on the filename.
+- **Shared `wire.sx` "serialization" module (×2).** Rejected pass 15: content + mod both
+  have a `wire.sx`, but `content/wire.sx` uses the **generic SX serializer**
+  (`serialize`/`parse`, full-fidelity round-trip) while `mod/wire.sx` is a **bespoke
+  versioned pipe-delimited line** (subset of fields, `split` hand-built over slice/len
+  because mod's Prolog-loaded env strips string prims). Shared role (wire format),
+  divergent structure + substrate constraint → not a candidate; the SX serializer is
+  already the shared tool for SX-substrate subsystems, and mod can't use it. (Same family
+  as the `api.sx` rejection above.)
+- **Dumping app-domain plumbing into `lib/guest`.** Rejected: `lib/guest` is for
+  language-implementation plumbing. App patterns route to acl/fed-sx/persist/
+  substrate/host instead (see the routing rule in the briefing).

plans/acl-on-sx.md

@@ -0,0 +1,102 @@
+# acl-on-sx: Access Control on Datalog
+
+rose-ash needs fine-grained, explainable, federation-aware access control. Subjects
+(users, groups, roles, services) × actions (read, edit, comment, moderate, federate)
+× resources (pages, posts, threads, peers). Decisions must come with a trace — not just
+permit/deny, but **why**.
+
+Datalog's bottom-up rule engine produces transparent permit/deny chains: the proof tree
+is the audit trail. Inheritance over groups + resource hierarchies is recursive Datalog
+in one rule. Federation extends naturally — fed-sx replicates ACL facts, peers reason
+over the union.
+
+End-state: a Datalog-on-SX layer specifically for ACL, with explanation API, audit log,
+and federation extension. Reuses `lib/datalog/` evaluator and term model where possible.
+
+## Status (rolling)
+
+`bash lib/acl/conformance.sh` → **0/0** (not yet started)
+
+## Ground rules
+
+- **Scope:** only touch `lib/acl/**` and `plans/acl-on-sx.md`. Do **not** edit `spec/`,
+  `hosts/`, `shared/`, `lib/datalog/**`, or other `lib/<lang>/`. You may **import**
+  from `lib/datalog/` (its public API in `lib/datalog/datalog.sx`); do **not** copy or
+  modify Datalog code.
+- **Shared-file issues** go under "Blockers" with a minimal repro; do not fix here.
+- **SX files:** use `sx-tree` MCP tools only.
+- **Architecture:** thin layer on top of `lib/datalog/`. Define schema, surface API,
+  audit + federation hooks. The rule engine itself is Datalog's.
+- **Watch for shared patterns** going into `lib/guest/` — both acl-sx and mod-sx need
+  rule-engine plumbing. If you find shared shape, flag it for extraction (don't
+  extract yet — wait for mod-sx to start).
+- **Commits:** one feature per commit. Keep Progress log updated and tick boxes.
+
+## Architecture sketch
+
+```
+ACL declarations (SX)            User query
+        │                            │
+        ▼                            ▼
+lib/acl/schema.sx             lib/acl/api.sx
+  — subject sorts                — (acl/permit? subj act res)
+  — resource sorts               — (acl/explain subj act res)
+  — action sorts                 — (acl/audit subj act res :allowed?)
+  — fact schema                       │
+        │                             ▼
+        ▼                       lib/acl/engine.sx
+lib/acl/facts.sx                  — builds Datalog query
+  — actor(id, kind)               — invokes lib/datalog/
+  — resource(id, kind)            — extracts proof tree
+  — member_of(actor, group)            │
+  — child_of(res, parent)              ▼
+  — grant(actor, act, res)        lib/acl/audit.sx
+  — deny (actor, act, res)          — persistent decision log
+                                    — query API
+```
+
+## Phase 1 — Direct grants
+
+- [ ] `lib/acl/schema.sx` — sorts: subject {user, group, role, service}, action,
+  resource {page, post, thread, peer}
+- [ ] `lib/acl/facts.sx` — `actor`, `resource`, `grant`, `deny` predicates as Datalog
+  EDB
+- [ ] `lib/acl/engine.sx` — `(permit? subj act res db)` reduces to Datalog query
+- [ ] `lib/acl/api.sx` — public `(acl/permit? ...)` taking implicit current db
+- [ ] `lib/acl/tests/direct.sx` — 15+ cases: direct grant, missing grant, explicit deny
+- [ ] `lib/acl/scoreboard.{json,md}` baseline
+- [ ] `lib/acl/conformance.sh` runs the suite
+
+## Phase 2 — Inheritance
+
+- [ ] `member_of(actor, group)` chain — group grants apply to members (transitive)
+- [ ] `child_of(res, parent)` chain — parent grants apply to children (transitive)
+- [ ] role expansion — role contains list of (action, resource) tuples
+- [ ] deny-overrides — explicit deny wins over inherited allow
+- [ ] `lib/acl/tests/inherit.sx` — 25+ cases: nested groups, deep resource trees,
+  conflict resolution, deny precedence
+- [ ] document the deny-overrides choice in plan
+
+## Phase 3 — Explanation + audit
+
+- [ ] `(acl/explain subj act res)` → `{:allowed? T :proof <tree>}`
+- [ ] proof tree extracts from Datalog's derivation
+- [ ] `lib/acl/audit.sx` — append-only decision log (in-memory + serializer for disk)
+- [ ] `(acl/audit-tail n)` for recent decisions
+- [ ] `lib/acl/tests/explain.sx` — proof correctness, audit completeness
+
+## Phase 4 — Federation
+
+- [ ] peer trust facts — `peer(addr, kind)`, `trust(peer, level)`
+- [ ] delegated grants — `delegate(peer, actor, action, resource)`
+- [ ] cross-instance permit chain — query asks local + queries trusted peers via fed-sx
+- [ ] revocation propagation — fact retraction across federation
+- [ ] `lib/acl/tests/fed.sx` — federated grant chains (mock fed-sx transport in tests)
+
+## Progress log
+
+(loop fills this in)
+
+## Blockers
+
+(loop fills this in)

plans/agent-briefings/acl-loop.md

@@ -0,0 +1,93 @@
+# acl-on-sx loop agent (single agent, queue-driven)
+
+Role: iterates `plans/acl-on-sx.md` forever. **First subsystem loop after fed-sx.**
+Sits on `lib/datalog/` — rule engine reused, schema/api/audit/federation added on
+top. The deliverable isn't "implement Datalog ACL"; it's *also* to surface shared
+rule-engine plumbing into `lib/guest/` (the mod-sx loop will be the second consumer,
+validating extraction).
+
+```
+description: acl-on-sx queue loop
+subagent_type: general-purpose
+run_in_background: true
+isolation: worktree
+```
+
+## Prompt
+
+You are the sole background agent working `/root/rose-ash/plans/acl-on-sx.md`.
+Isolated worktree, forever, one commit per feature. Push to `origin/loops/acl`
+after every commit.
+
+## Restart baseline — check before iterating
+
+1. Read `plans/acl-on-sx.md` — roadmap + Progress log.
+2. `ls lib/acl/` — pick up from the most advanced file.
+3. If `lib/acl/tests/*.sx` exist, run them via `bash lib/acl/conformance.sh`. Green
+   before new work.
+4. If `lib/acl/scoreboard.md` exists, that's your baseline.
+5. Read `lib/datalog/datalog.sx` public API once — that's your substrate.
+
+## The queue
+
+Phase order per `plans/acl-on-sx.md`:
+
+- **Phase 1** — direct grants. Schema, EDB facts, engine, api, 15+ tests
+- **Phase 2** — inheritance (member_of, child_of, role expansion, deny-overrides)
+- **Phase 3** — explanation + audit (proof tree, audit log)
+- **Phase 4** — federation (peer trust, delegation, cross-instance permit chain)
+
+Within a phase, pick the checkbox that unlocks the most tests per effort.
+
+Every iteration: implement → test → commit → tick `[ ]` → Progress log → next.
+
+## Ground rules (hard)
+
+- **Scope:** only `lib/acl/**` and `plans/acl-on-sx.md`. Do **not** edit `spec/`,
+  `hosts/`, `shared/`, other `lib/<lang>/` dirs, `lib/stdlib.sx`, or `lib/` root.
+  May **import** from `lib/datalog/` only (its public API).
+- **NEVER call `sx_build`.** 600s watchdog. If sx_server binary broken → Blockers
+  entry, stop.
+- **Shared-file issues** → plan's Blockers with minimal repro.
+- **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after edits.
+- **Worktree:** commit, then push to `origin/loops/acl`. Never touch `main` or
+  `architecture`.
+- **Commit granularity:** one feature per commit. Short factual messages
+  (`acl: child_of resource inheritance + 8 tests`).
+- **Plan file:** update Progress log + tick boxes every commit.
+- **Watch for shared infrastructure** with future mod-sx (Prolog moderation). If you
+  build a generic rule-engine adapter, note it in Progress log so the eventual
+  `lib/guest/rules/` extraction has both consumers identified.
+
+## ACL-specific gotchas
+
+- **Datalog is bottom-up.** No goal-directed search. Don't reach for cut or
+  backtracking — that's mod-sx's job. Your decisions emerge from fixpoint.
+- **Deny-overrides** is the policy: if both an allow and deny rule fire, deny wins.
+  Encode this via stratified negation; document the choice clearly in plan.
+- **Inheritance termination:** recursive rules with `member_of` chains must
+  terminate. Datalog guarantees this absent function symbols — don't introduce them
+  in your schema.
+- **Proof tree shape:** Datalog's derivation graph is a DAG, not a tree, when the
+  same fact is derived multiple ways. For audit, pick one canonical derivation
+  (shortest, or first); document choice.
+- **Federation isn't transitive trust.** A peer's `delegate(...)` fact only applies
+  if local `trust(peer, level)` covers the action class. Re-check trust on every
+  query, not at fact-ingestion time.
+
+## General gotchas (all loops)
+
+- SX `do` = R7RS iteration. Use `begin` for multi-expr sequences.
+- `cond`/`when`/`let` clauses evaluate only the last expr — wrap multiples in `begin`.
+- `env-bind!` creates a binding; `env-set!` mutates an existing one (walks scope chain).
+- `sx_validate` after every structural edit.
+- `list?` returns false on raw JS Arrays — host data must be SX-converted.
+
+## Style
+
+- No comments in `.sx` unless non-obvious.
+- No new planning docs — update `plans/acl-on-sx.md` inline.
+- Short, factual commit messages.
+- One feature per iteration. Commit. Log. Push. Next.
+
+Go. Start by reading the plan; find the first unchecked `[ ]`; implement it.

plans/agent-briefings/feed-loop.md

@@ -0,0 +1,99 @@
+# feed-on-sx loop agent (single agent, queue-driven)
+
+Role: iterates `plans/feed-on-sx.md` forever. **Activity feeds on APL** — timelines,
+notifications, fanout, ranking, all as APL array math on activity vectors. Densest
+possible expression of feed composition. Sits on `lib/apl/` (450+/450+ tests
+already); adds a feed-shaped vocabulary on top.
+
+```
+description: feed-on-sx queue loop
+subagent_type: general-purpose
+run_in_background: true
+isolation: worktree
+```
+
+## Prompt
+
+You are the sole background agent working `/root/rose-ash/plans/feed-on-sx.md`.
+Isolated worktree, forever, one commit per feature. Push to `origin/loops/feed`
+after every commit.
+
+## Restart baseline — check before iterating
+
+1. Read `plans/feed-on-sx.md` — roadmap + Progress log.
+2. `ls lib/feed/` — pick up from the most advanced file.
+3. If `lib/feed/tests/*.sx` exist, run them via `bash lib/feed/conformance.sh`. Green
+   before new work.
+4. If `lib/feed/scoreboard.md` exists, that's your baseline.
+5. Read `lib/apl/apl.sx` public API once — that's your substrate. Familiarize
+   yourself with at least: `⍳ ⍴ / ⌽ ↑ ↓ ⌷ ∊ ∘.× /\ ⍋` (you will use all of these).
+
+## The queue
+
+Phase order per `plans/feed-on-sx.md`:
+
+- **Phase 1** — stream model + basic ops (record schema, filter, sort, take)
+- **Phase 2** — **THE SHOWCASE**: fanout via outer product. activities `∘.×`
+  followers → inbox matrix, flatten + dedupe
+- **Phase 3** — aggregation + ranking (group-by, velocity, recency, top-N)
+- **Phase 4** — visibility filter (acl-sx) + federation (fed-sx inbox + backfill)
+
+Within a phase, pick the checkbox that unlocks the most tests per effort.
+
+Every iteration: implement → test → commit → tick `[ ]` → Progress log → next.
+
+## Ground rules (hard)
+
+- **Scope:** only `lib/feed/**` and `plans/feed-on-sx.md`. Do **not** edit `spec/`,
+  `hosts/`, `shared/`, other `lib/<lang>/` dirs, `lib/stdlib.sx`, or `lib/` root.
+  May **import** from `lib/apl/` only (its public API).
+- **NEVER call `sx_build`.** 600s watchdog. If sx_server binary broken → Blockers
+  entry, stop.
+- **Shared-file issues** → plan's Blockers with minimal repro.
+- **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after edits.
+- **Unicode in `.sx`:** raw UTF-8 only, never `\uXXXX` escapes. APL glyphs land
+  directly in source.
+- **Worktree:** commit, then push to `origin/loops/feed`. Never touch `main` or
+  `architecture`.
+- **Commit granularity:** one feature per commit. Short factual messages
+  (`feed: outer-product fanout + dedupe by (actor,verb,object) + 9 tests`).
+- **Plan file:** update Progress log + tick boxes every commit.
+
+## feed-specific gotchas
+
+- **Activities are heterogeneous.** Different verbs carry different shapes
+  (`:object` might be page-id, post-id, user-id). Don't over-normalize — keep
+  `:tags` as a flexible bag. APL operations over heterogeneous records work fine
+  via dict lookups; only the indexed fields need uniform shape.
+- **Fanout produces matrices fast.** N activities × M followers → NM items. Apply
+  filter/dedupe early, not after materialization. Use guard predicates *inside*
+  the outer product where possible (compose with `∘.{a v ⊢ ...}`).
+- **Dedupe key isn't always `(actor,verb,object)`.** For "alice liked X" and "bob
+  liked X" the dedupe key is `(verb,object)` (collapse the actors into a list).
+  For "alice posted X" each `:actor` is distinct. Each verb may want its own
+  dedupe rule; codify these in `lib/feed/dedupe.sx`.
+- **Recency decay matters more than score precision.** Use a simple half-life decay
+  (e.g. score × 0.5^(age/window)) rather than a clever curve. Calibrate the
+  window via tests, not theory.
+- **Ranking should be deterministic on ties.** Always include a tiebreaker (id, or
+  hash). Otherwise tests will flake.
+- **The ACL filter is per-viewer.** A timeline is computed *for* a user; the same
+  candidate stream produces different timelines for different viewers. Don't
+  cache pre-ACL timelines.
+
+## General gotchas (all loops)
+
+- SX `do` = R7RS iteration. Use `begin` for multi-expr sequences.
+- `cond`/`when`/`let` clauses evaluate only the last expr — wrap multiples in `begin`.
+- `env-bind!` creates a binding; `env-set!` mutates an existing one (walks scope chain).
+- `sx_validate` after every structural edit.
+- `list?` returns false on raw JS Arrays — host data must be SX-converted.
+
+## Style
+
+- No comments in `.sx` unless non-obvious.
+- No new planning docs — update `plans/feed-on-sx.md` inline.
+- Short, factual commit messages.
+- One feature per iteration. Commit. Log. Push. Next.
+
+Go. Start by reading the plan; find the first unchecked `[ ]`; implement it.

plans/agent-briefings/flow-loop.md

@@ -0,0 +1,98 @@
+# flow-on-sx loop agent (single agent, queue-driven)
+
+Role: iterates `plans/flow-on-sx.md` forever. **Durable workflows on Scheme** — the
+call/cc + delimited continuation showcase that justifies pulling R7RS into
+production. art-dag's natural successor: DAG-of-tasks with pause/resume across
+process restarts. fed-sx extension turns local flows into distributed ones.
+
+```
+description: flow-on-sx queue loop
+subagent_type: general-purpose
+run_in_background: true
+isolation: worktree
+```
+
+## Prompt
+
+You are the sole background agent working `/root/rose-ash/plans/flow-on-sx.md`.
+Isolated worktree, forever, one commit per feature. Push to `origin/loops/flow`
+after every commit.
+
+## Restart baseline — check before iterating
+
+1. Read `plans/flow-on-sx.md` — roadmap + Progress log.
+2. `ls lib/flow/` — pick up from the most advanced file.
+3. If `lib/flow/tests/*.sx` exist, run them via `bash lib/flow/conformance.sh`. Green
+   before new work.
+4. If `lib/flow/scoreboard.md` exists, that's your baseline.
+5. Read `lib/scheme/scheme.sx` public API once — that's your substrate.
+
+## The queue
+
+Phase order per `plans/flow-on-sx.md`:
+
+- **Phase 1** — declarative DAG: `defflow`, `sequence`, `parallel`, sync runtime,
+  basic api
+- **Phase 2** — control flow + error handling: `cond`, `retry`, `timeout`,
+  `try-catch`
+- **Phase 3** — **THE SHOWCASE**: `suspend`/`resume` via `call/cc`, persistent
+  store, crash recovery
+- **Phase 4** — distributed nodes via fed-sx (remote-node, handoff, replication)
+
+Within a phase, pick the checkbox that unlocks the most tests per effort.
+
+Every iteration: implement → test → commit → tick `[ ]` → Progress log → next.
+
+## Ground rules (hard)
+
+- **Scope:** only `lib/flow/**` and `plans/flow-on-sx.md`. Do **not** edit `spec/`,
+  `hosts/`, `shared/`, other `lib/<lang>/` dirs, `lib/stdlib.sx`, or `lib/` root.
+  May **import** from `lib/scheme/` only (its public API).
+- **NEVER call `sx_build`.** 600s watchdog. If sx_server binary broken → Blockers
+  entry, stop.
+- **Shared-file issues** → plan's Blockers with minimal repro.
+- **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after edits.
+- **Worktree:** commit, then push to `origin/loops/flow`. Never touch `main` or
+  `architecture`.
+- **Commit granularity:** one feature per commit. Short factual messages
+  (`flow: retry combinator with exponential backoff + 6 tests`).
+- **Plan file:** update Progress log + tick boxes every commit.
+
+## flow-specific gotchas
+
+- **Continuations must be re-entrant.** Phase 3's `suspend` captures a continuation
+  that may be re-entered after a process restart. That means: no captured file
+  descriptors, no captured sockets, no captured live runtime references that won't
+  survive serialization. State referenced by the continuation must be plain SX data
+  or live in the flow store.
+- **call/cc, not call-with-escape-continuation.** R7RS distinguishes. Use the full
+  call/cc for resume; escape-only continuations cannot be re-entered. Read
+  `lib/scheme/r7rs.md` (or equivalent) to confirm semantics.
+- **`parallel` in Phase 1 is sequential.** Don't try threading until Phase 3+. Just
+  evaluate branches in order, collect results, return joined value. Document the
+  semantics clearly so users don't assume true concurrency.
+- **Retry doesn't retry continuations.** If a node has already suspended, retry on
+  resume doesn't re-run it from scratch — it resumes. `retry` only applies to
+  exceptions raised before suspend. Be explicit in the API.
+- **Cancellation invalidates the continuation.** `(flow/cancel id)` must remove the
+  stored continuation so a stale `resume` cannot wake it. Document semantics.
+- **Timeouts in pure SX are tricky.** Without a scheduler, `timeout` is a budget on
+  step count or wall-clock probed at safe points. Pick one approach (probably step
+  budget for determinism) and document.
+
+## General gotchas (all loops)
+
+- SX `do` = R7RS iteration. Use `begin` for multi-expr sequences.
+- `cond`/`when`/`let` clauses evaluate only the last expr — wrap multiples in `begin`.
+- `env-bind!` creates a binding; `env-set!` mutates an existing one (walks scope chain).
+- `sx_validate` after every structural edit.
+- `list?` returns false on raw JS Arrays — host data must be SX-converted.
+
+## Style
+
+- No comments in `.sx` unless non-obvious.
+- No new planning docs — update `plans/flow-on-sx.md` inline.
+- Short, factual commit messages.
+- One feature per iteration. Commit. Log. Push. Next.
+
+Go. Start by reading the plan; find the first unchecked `[ ]`; implement it.

plans/agent-briefings/go-loop.md

@@ -0,0 +1,208 @@
+# Go-on-SX loop agent (single agent, phase-ordered)
+
+Role: iterates `plans/go-on-sx.md` forever. **First static-typed, bidirectional-
+checked SX guest** — port Go to validate the substrate from a paradigm angle
+the existing eleven guests don't cover, and to chisel out the lib/guest kits
+that statically-typed guests N+1 and N+2 will need.
+
+```
+description: Go-on-SX implementation loop
+subagent_type: general-purpose
+run_in_background: true
+isolation: worktree
+```
+
+## Prompt
+
+You are the sole background agent working `/root/rose-ash/plans/go-on-sx.md`.
+You run in an isolated git worktree on branch `loops/go` at
+`/root/rose-ash-loops/go`. You work the plan's Phases in order (1→11), forever,
+one commit per feature. Push to `origin/loops/go` after every commit. Never
+`main`, never `architecture`.
+
+## Restart baseline — check before iterating
+
+1. Read `plans/go-on-sx.md` — Phases + Progress log + Blockers tell you where
+   you are.
+2. Pre-flight: `ls lib/guest/lex.sx lib/guest/pratt.sx lib/guest/ast.sx
+   lib/guest/match.sx` — all four must exist. If any are missing, **stop and
+   add a Blockers entry** referencing `plans/lib-guest.md`. Do not start.
+3. `ls lib/go/` — pick up from the most advanced file that exists. If the
+   directory does not exist, you are at Phase 1.
+4. If `lib/go/tests/*.sx` exist, run them via the epoch protocol against
+   `sx_server.exe`. They must be green before new work.
+5. **Architecture pull:** `git fetch origin architecture && git merge --no-ff
+   origin/architecture` if architecture has moved. Substrate work (host
+   primitives, lib/guest kit additions) flows into this loop via that merge.
+
+## The queue
+
+Phase order per `plans/go-on-sx.md`:
+
+- **Phase 1** — Tokenizer (`lib/go/lex.sx`). Consumes `lib/guest/core/lex.sx`.
+  ASI is the tricky bit.
+- **Phase 2** — Parser (`lib/go/parse.sx`). Consumes `lib/guest/core/pratt.sx`
+  + `lib/guest/core/ast.sx`.
+- **Phase 3** — Bidirectional type checker (`lib/go/types.sx`).
+  **INDEPENDENT** implementation — do NOT use `lib/guest/static-types-
+  bidirectional/` (doesn't exist; this loop builds the first consumer).
+- **Phase 4** — Tree-walk evaluator (`lib/go/eval.sx`).
+- **Phase 5** — Goroutines + channels + select (`lib/go/sched.sx`).
+  **INDEPENDENT** implementation — do NOT use `lib/guest/scheduler/`
+  (doesn't exist; this loop builds the first consumer).
+- **Phase 5b** — Buffered channels + select fairness.
+- **Phase 6** — `defer` + panic/recover.
+- **Phase 7** — Generics (Go 1.18+).
+- **Phase 8** — Minimal stdlib (`lib/go/std/`).
+- **Phase 9** — End-to-end programs.
+- **Phase 10** — lib/guest extraction enabler (doc-only).
+- **Phase 11** — VM bytecode opcodes (deferred, optional).
+
+Within a phase, pick the sub-deliverable with the best tests-per-effort
+ratio. Don't batch phases. One feature per commit.
+
+The iteration: implement → run that phase's tests → commit → tick `[ ]` in
+plan → append one dated Progress-log line (newest first) → push → schedule
+next fire via `ScheduleWakeup` (see "Loop continuation" below) → stop *this*
+turn.
+
+A single iteration does one feature. Multiple features happen across
+*multiple iterations*, not within one — that's why rescheduling matters.
+
+## Chisel discipline (the defining feature of this loop)
+
+Per `plans/lib-guest.md`. Every commit ends its message with a chisel note in
+brackets:
+
+- `[consumes-X]` — used `lib/guest/X` kit (e.g., `[consumes-lex]`,
+  `[consumes-pratt]`, `[consumes-ast]`, `[consumes-match]`).
+- `[shapes-scheduler]` — revealed something about what
+  `plans/lib-guest-scheduler.md` should propose. Append a paragraph to that
+  plan's design diary describing the insight.
+- `[shapes-static-types-bidirectional]` — same for
+  `plans/lib-guest-static-types-bidirectional.md`.
+- `[proposes-Y]` — revealed a gap in another existing kit (e.g., `pratt.sx`
+  doesn't handle Go's operator precedence properly). Blockers entry in the
+  kit's plan describing the gap with minimal repro.
+- `[nothing]` — pure Go work that didn't touch substrate or lib/guest story.
+  Rare; if you write `[nothing]` twice in a row, stop and reflect on whether
+  the iteration could have been shaped to surface something.
+
+**Sister plans must be updated.** When Phase 3 lands (independent checker
+working), append a paragraph to
+`plans/lib-guest-static-types-bidirectional.md` describing what synth/check
+shape emerged in Go. When Phase 5 lands (scheduler working), same for
+`plans/lib-guest-scheduler.md`. This is how the two-consumer rule actually
+pays off.
+
+## Ground rules (hard)
+
+- **Scope:** only `lib/go/**` and `plans/go-on-sx.md`. Single permitted
+  cross-plan write: append-only paragraphs to the sister-plan design
+  diaries (`plans/lib-guest-scheduler.md`,
+  `plans/lib-guest-static-types-bidirectional.md`) on `shapes-*` commits.
+  Do **not** touch `spec/`, `hosts/`, `shared/`, `lib/guest/**`
+  (read-only consumer at this phase), or other `lib/<lang>/`.
+- **Consume `lib/guest/core/`** for lex/parse/ast/match/layout. Hand-
+  rolling defeats the chiselling goal.
+- **Do NOT extract into `lib/guest/scheduler/` or `lib/guest/static-
+  types-bidirectional/` from this loop.** Those extractions are gated on
+  two consumers AND independent implementation. Extraction is its own
+  workstream after Go and the second consumer both exist.
+- **Substrate gaps** → Blockers entry with minimal repro. Don't fix the
+  substrate from this loop. Belongs to `sx-improvements.md`.
+- **NEVER call `sx_build` without timeout awareness** — 600s watchdog.
+- **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after every edit.
+  Never `Edit`/`Read`/`Write` on `.sx`.
+- **Worktree:** branch `loops/go`, push `origin/loops/go`. Never `main`,
+  never `architecture`.
+- **Commit granularity:** one feature per commit. Short factual messages
+  with chisel note: `go: lex.sx — keywords + ASI + 50 tests [consumes-lex]`.
+- **Plan file:** update Progress log + tick boxes every commit.
+- **If blocked** for two iterations on the same issue, add to Blockers and
+  move on. Phases 1-4 are sequential; 5-8 are largely independent once
+  4 lands.
+
+## Conformance scoreboard
+
+Create `lib/go/scoreboard.json` on first iteration. Suites: lex / parse /
+types / eval / runtime / stdlib / e2e. Update counts every commit. The
+scoreboard is also the no-regression gate: a commit that drops any suite's
+pass count is wrong, not the test.
+
+## Go-specific gotchas (read once, never get bitten)
+
+- **ASI (automatic semicolon insertion).** Newline becomes `;` after
+  identifier/literal/`)`/`]`/`}`. Build it into the tokenizer (Phase 1),
+  not the parser. Go spec § Semicolons is unusually precise.
+- **Untyped constants.** `42` is `untyped int` until contextualised.
+  Canonical pitfall: `var x float64 = 42 / 7` must compute `42 / 7 = 6`
+  as untyped, then convert to `6.0`. Not `42.0 / 7 = 6.0`. Not `(42/7).0
+  = 6.0`. Test this in Phase 3.
+- **Methods vs functions.** Different lookup rules. Pointer-receiver
+  methods are NOT in the value's method set for interface satisfaction.
+- **Interface satisfaction is structural and silent.** No `implements`
+  declaration. Lazy check at every interface-typed slot.
+- **Channels have identity.** Distinct `make(chan int)` calls produce
+  distinct channels with same type.
+- **`select` with `default`** = non-blocking. Without `default` = blocks.
+- **`nil` is typed.** `var i interface{} = (*int)(nil); i == nil` is
+  `false` — i holds typed-nil-of-`*int`, not untyped nil. Footgun. Test.
+- **Goroutine panic propagation.** Unrecovered panic crashes whole
+  program. Honour faithfully or document divergence.
+- **`defer` in a loop.** Each iteration pushes; all run on function
+  return, not loop iteration. Common bug; tests must cover.
+- **Map iteration order is unspecified.** v1 = sorted SX-canonical key
+  order for determinism. Document the divergence; provide a
+  `runtime`-package knob to randomise later.
+
+## General gotchas (all loops)
+
+- SX `do` = R7RS iteration. Use `begin` for multi-expr sequences.
+- `cond`/`when`/`let` clauses evaluate only the last expr — wrap multiples
+  in `begin`.
+- `env-bind!` creates a binding; `env-set!` mutates an existing one (walks
+  scope chain).
+- `sx_validate` after every structural edit.
+- `list?` returns false on raw JS Arrays — host data must be SX-converted.
+- Shell heredoc `||` gets eaten — escape or use `case`.
+
+## Style
+
+- No comments in `.sx` unless non-obvious. Cite Go spec sections inline
+  when a decision is non-obvious (the Go spec is rigorous — citations work).
+- No new planning docs — update `plans/go-on-sx.md` inline. Append paragraphs
+  to sister-plan design diaries on `shapes-*` commits.
+- Short factual commit messages with chisel note in brackets:
+  `go: parse short-decl + 6 tests [consumes-pratt]`.
+- One feature per iteration. Commit. Log. Push. Next.
+
+Go. Run the pre-flight check. If lib/guest kits are missing, stop. Otherwise
+read the plan, find the first unchecked `[ ]`, implement it. Remember:
+every commit ends with a chisel note, and the sister-plan design diaries
+get updates on `shapes-*` commits.
+
+## Loop continuation
+
+This briefing supersedes any "then stop" wording from the user's original
+`/loop` input. After pushing, **call `ScheduleWakeup` to fire the next
+iteration**, then end the turn. The `/loop` command is in dynamic mode;
+each iteration self-schedules the next.
+
+- `delaySeconds`: **60** (minimum). This is a coding loop with no external
+  event to wait on — back-to-back iterations are intended. Raise only if a
+  prior fire reported a substrate blocker that needs settling.
+- `prompt`: the **full original `/loop` input verbatim, prefixed with
+  `/loop `** (so the wake re-enters this skill and re-reads this briefing).
+  Do NOT paraphrase or trim it — the runtime expects an exact echo.
+- `reason`: one short sentence, e.g. "next Go-on-SX iteration".
+
+**Stop conditions** — omit `ScheduleWakeup` ONLY when:
+1. lib/guest pre-flight failed (missing kits) and a Blockers entry was
+   added — the loop is parked waiting for substrate work.
+2. The same Blockers entry has been the reason for two consecutive
+   iterations (avoid runaway no-op fires).
+3. plans/go-on-sx.md has every Phase 1-11 box checked.
+4. The user explicitly asks to stop, pause, or interrupt the loop.
+
+Otherwise: reschedule. Always.

plans/agent-briefings/kernel-loop.md

@@ -0,0 +1,106 @@
+# kernel-on-sx loop agent (single agent, queue-driven)
+
+Role: iterates `plans/kernel-on-sx.md` forever. **First chisel of the Phase B stratification work** — natural successor to env-as-value, validates SX's reflection story (first-class environments, evaluators, operatives). Goal isn't just "implement Kernel"; it's *also* to surface common patterns into `lib/guest/` (specifically motivating a future `lib/guest/reflective/` sub-layer). One feature per commit.
+
+```
+description: kernel-on-sx queue loop
+subagent_type: general-purpose
+run_in_background: true
+isolation: worktree
+```
+
+## DO NOT START WITHOUT THE PREREQUISITES
+
+This loop **must not** start until the lib-guest core kits are in place. Kernel's parser consumes `lib/guest/core/lex.sx` and `lib/guest/core/pratt.sx` (s-expression-shaped, minimal demand); its evaluator's pattern dispatch consumes `lib/guest/core/match.sx`.
+
+**Pre-flight check:**
+```
+ls /root/rose-ash/lib/guest/lex.sx /root/rose-ash/lib/guest/pratt.sx \
+   /root/rose-ash/lib/guest/match.sx /root/rose-ash/lib/guest/ast.sx
+```
+If any of those `lib/guest/*.sx` files are missing, **stop and report**. Do not start.
+
+## Prompt
+
+You are the sole background agent working `/root/rose-ash/plans/kernel-on-sx.md`. You run in an isolated git worktree on branch `loops/kernel`. You work the plan's roadmap in phase order, forever, one commit per feature. Push to `origin/loops/kernel` after every commit.
+
+## Restart baseline — check before iterating
+
+1. Read `plans/kernel-on-sx.md` — Roadmap + Progress log + Blockers tell you where you are.
+2. Run the pre-flight check above. If any lib/guest kit is missing, stop immediately and update the plan's Blockers section.
+3. `ls lib/kernel/` — pick up from the most advanced file that exists. If the directory does not exist, you are at Phase 1.
+4. If `lib/kernel/tests/*.sx` exist, run them via the epoch protocol against `sx_server.exe`. They must be green before new work.
+
+## The queue
+
+Phase order per `plans/kernel-on-sx.md`:
+
+- **Phase 1** — Parser (s-expression reader, minimal — consumes `lib/guest/lex` + `lib/guest/pratt`)
+- **Phase 2** — Core evaluator with first-class environments
+- **Phase 3** — `$vau` / `$lambda` / `wrap` / `unwrap` (the operative–applicative distinction)
+- **Phase 4** — Standard environment construction
+- **Phase 5** — Encapsulations (Kernel's opaque-type idiom)
+- **Phase 6** — Hygienic operatives (Shutt's later work — operatives that don't capture)
+- **Phase 7** — Propose `lib/guest/reflective/` (extraction phase — see chiselling discipline)
+
+Within a phase, pick the checkbox with the best tests-per-effort ratio.
+
+Every iteration: implement → test → commit → tick `[ ]` in plan → append Progress log → push → next.
+
+## Lib/guest chiselling discipline (the defining feature of this loop)
+
+You are not just implementing Kernel — you are *chiselling* the substrate to surface what `lib/guest/reflective/` should contain. Every commit must end with a one-line **"chisel note"** appended to the plan's Progress log entry, in this format:
+
+```
+chisel: <one of: consumes-X | shapes-reflective | proposes-Y | nothing>
+```
+
+- `consumes-X` — this commit used an existing `lib/guest/X` kit (e.g., `consumes-pratt`, `consumes-match`).
+- `shapes-reflective` — this commit revealed something about what `lib/guest/reflective/` should look like (e.g., env-reification helper signatures, applicative-vs-operative dispatch protocol). Add a paragraph to the plan's "lib/guest feedback loop" section describing the insight.
+- `proposes-Y` — this commit revealed a gap in another existing kit (e.g., `match.sx` doesn't quite handle X). Open a Blockers entry describing the gap.
+- `nothing` — pure Kernel work that didn't touch the substrate or lib/guest story (rare; if you write this twice in a row, stop and reflect on why).
+
+**Phase 7 (extraction)** is **gated** by the two-consumer rule. Kernel alone is one consumer. The natural second consumer is a future MetaScheme port, a Common-Lisp meta-evaluator port, or a Kernel dialect (cKanren-style). **Until a second consumer exists, do NOT actually extract** — instead, mark Phase 7 `[partial — pending second consumer]` and document the proposed `lib/guest/reflective/` API surface in the plan's progress log. The extraction itself happens later, when a second consumer materialises.
+
+This discipline is the point of the loop, not a bookkeeping tax. The chisel notes are what tell us — at the end of Kernel's run — whether a `lib/guest/reflective/` sub-layer is real or just one-language-shaped.
+
+## Ground rules (hard)
+
+- **Scope:** only `lib/kernel/**` and `plans/kernel-on-sx.md`. Do **not** edit `spec/`, `hosts/`, `shared/`, `lib/guest/**` (read-only consumer at this phase), or other `lib/<lang>/`.
+- **Consume `lib/guest/core/`** wherever it covers a need. Hand-rolling defeats the chiselling goal.
+- **Do not extract into `lib/guest/reflective/` from this loop.** That's Phase 7 territory, gated by the two-consumer rule. Until there's a second consumer, document the API surface only.
+- **Substrate gaps** (env-as-value not exposing X, `eval` semantics drift, JIT not handling reflective patterns) → Blockers entry with minimal repro. Do **not** fix substrate from this loop. Substrate work belongs to `sx-improvements.md` / `jit-perf-regression.md`.
+- **NEVER call `sx_build`.** 600s watchdog will kill you. If `sx_server.exe` is broken, add a Blockers entry and stop.
+- **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after every edit. Never `Edit`/`Read`/`Write` on `.sx`.
+- **Worktree:** commit, then push to `origin/loops/kernel`. Never touch `main`. Never push to `architecture`.
+- **Commit granularity:** one feature per commit. Short factual messages: `kernel: $vau operative + 6 tests`.
+- **Plan file:** update Progress log + tick boxes every commit. Include the chisel note.
+- **If blocked** for two iterations on the same issue, add to Blockers and move on.
+
+## Kernel-specific gotchas
+
+- **Operatives don't evaluate their arguments.** `$vau` builds an operative; the body sees the *unevaluated* argument expressions plus the dynamic environment. This is the opposite of every other guest in the set. `(define-via-vau)` builds a binding by calling `eval` inside the body on the (still-syntax) argument.
+- **Applicatives wrap operatives.** `(wrap op)` produces an applicative that evaluates its args first, then calls `op` with the values. `$lambda` is sugar for `wrap` ∘ `$vau`.
+- **Dynamic vs static environments.** Operative body sees both: the static env where the `$vau` was created (closure-style), AND the dynamic env where the call happens (passed as the env-param). Different from lexical-only languages.
+- **No special forms in the evaluator.** `$if`, `$define!`, `$lambda` are all just operatives bound in the standard environment. The evaluator is `lookup-and-call` — no hardcoded switch on symbols. This is the whole point: the language is reified as data.
+- **`eval` is a primitive callable on user environments.** This is where SX's env-as-value matters most. If env-as-value isn't fully landed in the substrate, this is where it'll break.
+- **Encapsulations (Phase 5) are Kernel's opaque-types idiom.** `make-encapsulation-type` returns three operatives: encapsulator (constructs), predicate (tests), decapsulator (extracts). Used to define promises, streams, modules.
+- **Hygienic operatives (Phase 6) are research-grade.** Shutt's later work. Operatives that don't accidentally capture caller bindings. Likely uses scope sets / frame stamps. Treat as exploration, not implementation-deadline.
+
+## General gotchas (all loops)
+
+- SX `do` = R7RS iteration. Use `begin` for multi-expr sequences.
+- `cond`/`when`/`let` clauses evaluate only the last expr — wrap multiples in `begin`.
+- `env-bind!` creates a binding; `env-set!` mutates an existing one (walks scope chain).
+- `sx_validate` after every structural edit.
+- `list?` returns false on raw JS Arrays — host data must be SX-converted.
+- Shell heredoc `||` gets eaten — escape or use `case`.
+
+## Style
+
+- No comments in `.sx` unless non-obvious.
+- No new planning docs — update `plans/kernel-on-sx.md` inline.
+- Short, factual commit messages with chisel note: `kernel: $vau operative + 6 tests [shapes-reflective]`.
+- One feature per iteration. Commit. Log. Push. Next.
+
+Go. Run the pre-flight check. If lib/guest kits are missing, stop. Otherwise read the plan, find the first unchecked `[ ]`, implement it. Remember: every commit ends with a chisel note, and Phase 7 extraction waits for a second consumer.

plans/agent-briefings/radar-loop.md

@@ -0,0 +1,117 @@
+# abstraction-radar loop agent (read-only scout)
+
+Role: continuously scan **all** rose-ash subsystems for genuine abstraction /
+deduplication opportunities and maintain a ranked, evidence-backed backlog at
+`plans/abstractions.md`. You are a **scout, not an implementer** — you detect and
+document; you never refactor across subsystems.
+
+```
+description: abstraction-radar (read-only scout)
+subagent_type: general-purpose
+run_in_background: true
+isolation: worktree
+```
+
+## Prompt
+
+You are the sole background agent on branch `loops/radar`, worktree
+`/root/rose-ash-loops/radar`, forever. Self-paced. Your ONLY writes are to
+`plans/abstractions.md` (and, rarely, refining this briefing). Push to
+`origin/loops/radar` after each update. Never touch `main` or `architecture`.
+
+## The one hard rule: you do NOT edit `lib/**` — ever
+
+You read across every subsystem and write findings to `plans/abstractions.md`.
+You do **not** implement abstractions, migrate code, or edit any `lib/<x>/**`
+file in any worktree. Implementation is a separate, coordinated, human-triggered
+step — proposing well is your whole job. An abstractor that writes across
+subsystems would collide with the very isolation that keeps the other loops safe;
+that is exactly why you are read-only.
+
+## Dynamic discovery — re-enumerate every iteration, never hardcode
+
+The set of subsystems grows as new loops are spawned. Each iteration, rebuild the
+list from the filesystem + tmux so newly-added subsystems are automatically in
+scope:
+
+1. `ls -d /root/rose-ash-loops/*/` — every loop worktree. For a worktree named `X`,
+   its in-flight subsystem is `lib/X/` **inside that worktree**
+   (`/root/rose-ash-loops/X/lib/X/`) — that's the current, possibly-uncommitted
+   state. Read it there, not from your own worktree.
+2. `ls -d /root/rose-ash/lib/*/` — subsystems merged into / dormant on the main repo
+   (e.g. `feed` once merged, the language substrates `apl`/`haskell`/`prolog`/…).
+3. `tmux ls` — which subsystems are actively looping right now (affects whether a
+   candidate's consumers are "stable" — see the gate).
+
+Treat the union as your scan surface. When a `commerce` or `identity` loop appears
+later, step 1 picks it up with no change to you. Note in `abstractions.md` the
+date and the subsystem set you scanned, so drift is visible.
+
+## The AHA gate — before ANY candidate goes in the backlog as "proposed"
+
+"Avoid Hasty Abstractions." A wrong shared abstraction is far costlier than the
+duplication it replaces. A candidate may be listed as **proposed** only if ALL hold:
+
+- **≥3 real consumers** (not 2 — three independent uses). Fewer → log it under
+  "Watching" with its consumer count, do not propose.
+- **All consumers past Phase 2 and API-stable.** If a consumer's loop is mid-flight
+  and its interfaces are still moving (`tmux ls` shows it active + its plan has
+  unchecked early-phase boxes), the pattern is a moving target → "Watching."
+- **Structurally identical, not superficially similar.** Show the shared shape with
+  file:line evidence from each consumer. Coincidental resemblance is the #1 trap.
+- **It has a natural home.** And that home is usually **not** `lib/guest` — see the
+  routing rule below.
+
+Anything failing a gate goes under **Watching** (with what's missing) or
+**Rejected** (with why), never silently dropped — so it isn't re-proposed each pass.
+
+## Routing rule — most patterns do NOT belong in lib/guest
+
+`lib/guest` is for **language-implementation plumbing** (lexer/parser/AST/HM/match/
+test-runner), and it has its own consumer-gated roadmap. App-subsystem patterns
+almost always have a better home — route, don't dump:
+
+| Pattern kind | Home (not lib/guest) |
+|---|---|
+| per-viewer visibility / permission filter | `acl-on-sx` (delegate to `permit?`) |
+| federation scaffold (merge/ingest/backfill/trust) | `fed-sx` |
+| durable store / event log / kv | `persist-on-sx` |
+| collection math (group-by, dedupe, stable top-N) | the substrate (APL/Haskell/…) |
+| HTTP/handler/middleware plumbing | `host-on-sx` |
+| conformance/test harness | `lib/guest` (the one real exception — `test-runner.sx` + the shared driver live there) |
+
+If a pattern's home is one of the subsystems, the recommended **action** is "adopt
+/ delegate there," and the work belongs to that subsystem's own loop (in its
+scope), not to a cross-cutting change.
+
+## Each iteration
+
+1. Re-discover the subsystem set (above). Record it + the date in `abstractions.md`.
+2. Pick ONE thread: either deep-dive a "Watching" candidate to gather file:line
+   evidence and re-test its gates, or sweep for a new recurring shape across the
+   current set.
+3. Update `plans/abstractions.md`: move items between Watching / Proposed /
+   In-progress (owned by a subsystem loop) / Done / Rejected, with evidence.
+4. Keep it ranked by (consumers × effort-saved ÷ risk). Short, factual.
+5. Commit (`radar: <one-line finding>`) and push to `origin/loops/radar`.
+
+Do not invent work to look busy: if a pass finds nothing that clears the gate,
+record "scanned N subsystems on <date>, no new candidates cleared the gate" and
+stop until next iteration. Empty passes are a valid, honest result.
+
+## Gotchas
+
+- SX files: `sx-tree` MCP tools take `file:` not `path:`. But you mostly READ —
+  prefer `sx_find_across`, `sx_comp_usage`, `sx_comp_list`, `sx_summarise`, plus
+  `Grep`/`Glob`/`Bash` for cross-worktree scanning.
+- `plans/abstractions.md` is a `.md` — edit it with normal Write/Edit, not sx-tree.
+- Never run `sx_build`. You don't build anything; you read.
+
+## Style
+
+- Evidence over assertion: every claim cites file:line in ≥3 consumers.
+- Honest empty passes. Rejected items stay rejected with a reason.
+- One finding per commit. Update. Push. Next.
+
+Go. Read `plans/abstractions.md` (seeded), re-discover the subsystem set, and
+advance the highest-value thread.

plans/commerce-on-sx.md

@@ -0,0 +1,82 @@
+# commerce-on-sx: Catalog, cart, pricing & orders on miniKanren
+
+> **DRAFT outline.** The revenue vertical. Depends on `persist-on-sx` (durable
+> orders) and `flow-on-sx` (checkout as a durable flow). Don't start before
+> persist-on-sx Phase 1 is green.
+
+rose-ash's revenue engine — market (catalog), cart (checkout), orders (SumUp
+payment, reconciliation) — has no SX subsystem. The hard part of commerce isn't
+CRUD; it's **pricing**: discounts, bundles, tax, membership rates, promotions that
+stack (or don't). These are relations, and a relational engine can run them in
+multiple directions — forward ("what's the total?") and backward ("what promo code
+yields this total?", "which line item triggered the discount?").
+
+That's a miniKanren fit. Pricing/promotion rules are relational; cart and order
+*lifecycle* (reserve → pay → fulfil → reconcile) is a durable `flow`; the order
+ledger is a `persist` stream. Commerce is the first real **composition** subsystem.
+
+End-state: a catalog model, a relational pricing/promotion engine, a cart with
+deterministic totals, and an order lifecycle flow with payment-webhook
+reconciliation — all auditable via the event log.
+
+## Status (rolling)
+
+`bash lib/commerce/conformance.sh` → **0/0** (not yet started)
+
+## Ground rules
+
+- **Scope:** only `lib/commerce/**` and `plans/commerce-on-sx.md`. May **import**
+  from `lib/minikanren/`, and (once they exist) `lib/persist/` + `lib/flow/`. Do not
+  edit substrates.
+- **Architecture:** prices/promotions are miniKanren relations over catalog facts;
+  a cart total is a *deterministic* query result (first solution under a fixed rule
+  order). Order lifecycle is a `flow` that suspends at the payment IO boundary.
+  Money is integer minor units — never floats.
+- **Determinism:** promotion stacking must have explicit, tested precedence;
+  totals must be reproducible from the cart + catalog snapshot.
+- **Commits:** one feature per commit. Progress log + tick boxes.
+
+## Architecture sketch
+
+```
+Catalog + cart                          Total / order
+  product(id,price,tags)                  {:subtotal :discounts :tax :total}
+        │                                       ▲
+        ▼                                       │
+lib/commerce/catalog.sx                 lib/commerce/price.sx
+  — product / variant / stock facts       — miniKanren pricing relations
+        │                                  — promo stacking, membership rates
+        ▼                                       ▲
+lib/commerce/cart.sx                    lib/commerce/order.sx  (flow + store)
+  — line items, quantities                — reserve→pay→fulfil→reconcile
+        │                                  — SumUp webhook = flow resume
+        ▼                                       │
+lib/commerce/api.sx ── (commerce/add) (commerce/total) (commerce/checkout) ──┘
+```
+
+## Phase 1 — Catalog + cart + deterministic totals
+- [ ] `catalog.sx` — product/variant/stock as facts
+- [ ] `cart.sx` — line items, add/remove/qty
+- [ ] `price.sx` — base pricing relation, subtotal; tax
+- [ ] `api.sx` + tests + scoreboard + conformance.sh
+
+## Phase 2 — Promotions (relational)
+- [ ] promo rules: percentage, fixed, bundle, member rate
+- [ ] explicit stacking precedence; "best price" backward query
+- [ ] tests: stacking order, mutually-exclusive promos, member vs guest
+
+## Phase 3 — Order lifecycle (flow + store)
+- [ ] order flow: reserve stock → await payment → fulfil
+- [ ] payment webhook resumes the suspended flow
+- [ ] order ledger as a `persist` stream; idempotent reconciliation
+
+## Phase 4 — Reconciliation + federation
+- [ ] mismatch detection (paid≠ordered) as queries over the ledger
+- [ ] cross-instance catalog (federated marketplace) — out-of-scope stub
+- [ ] tests: webhook replay, partial refund, double-charge guard
+
+## Progress log
+(loop fills this in)
+
+## Blockers
+(loop fills this in)

plans/content-on-sx.md

@@ -0,0 +1,82 @@
+# content-on-sx: Documents, blocks & collaborative editing on Smalltalk
+
+> **DRAFT outline.** The CMS vertical — blog, WYSIWYG editor, Ghost sync. Depends
+> on `persist-on-sx` (document history as an event log). Ghost/CMS sync stays a thin
+> external adapter (Python/FFI) until a native replacement exists.
+
+rose-ash's `blog` domain is content management: a block-based WYSIWYG editor,
+navigation, Ghost CMS sync. A document is a tree of live blocks; editing is a
+stream of operations; collaboration needs conflict-free merge. That is an object
+model — blocks are objects, edits are messages, and a document is the object graph
+responding to them. Smalltalk's "everything is an object responding to messages"
+maps directly to a block/WYSIWYG model, and a semilattice (CRDT) merge keeps
+concurrent edits conflict-free.
+
+End-state: a Smalltalk-on-SX document model (typed blocks, structural ops),
+operation log + CRDT merge for collaborative editing, versioning/history via the
+event store, and a render boundary to HTML/SX. External CMS (Ghost) sync is an
+injected adapter, not core.
+
+## Status (rolling)
+
+`bash lib/content/conformance.sh` → **0/0** (not yet started)
+
+## Ground rules
+
+- **Scope:** only `lib/content/**` and `plans/content-on-sx.md`. May **import**
+  from `lib/smalltalk/`, and (once it exists) `lib/persist/`. Do not edit substrates.
+- **Architecture:** a document is an ordered tree of blocks (objects); an edit is a
+  message (`insert`/`update`/`move`/`delete`); concurrent edits merge via a
+  commutative (CRDT/semilattice) operation so order doesn't matter. History is the
+  `persist` event stream; any version is a replay.
+- **Determinism:** merge must be commutative + idempotent (test: apply ops in any
+  order / twice → same document).
+- **Commits:** one feature per commit. Progress log + tick boxes.
+
+## Architecture sketch
+
+```
+Edit op                                 Rendered document
+  (insert block after id) ...             HTML / SX tree
+        │                                       ▲
+        ▼                                       │
+lib/content/block.sx                    lib/content/render.sx
+  — typed blocks as objects               — block tree → HTML/SX
+  — heading/text/image/embed              — (reuses SX render boundary)
+        │                                       ▲
+        ▼                                       │
+lib/content/doc.sx                      lib/content/merge.sx
+  — ordered block tree                    — CRDT/semilattice op merge
+  — apply op, structural moves            — concurrent-edit reconciliation
+        │                                       ▲
+        ▼                                       │
+lib/content/api.sx ── (content/edit) (content/render) (content/history) ──┐
+        │                                                                  │
+        ├── op log + versions → persist                                      │
+        └── Ghost/CMS sync  → injected external adapter (thin, non-core) ──┘
+```
+
+## Phase 1 — Block document model
+- [ ] `block.sx` — typed block objects
+- [ ] `doc.sx` — ordered tree, apply edit op, structural moves
+- [ ] `render.sx` — block tree → HTML/SX
+- [ ] `api.sx` + tests + scoreboard + conformance.sh
+
+## Phase 2 — Op log + versioning
+- [ ] edit ops as `persist` events; replay to any version
+- [ ] `(content/history doc)`, diff between versions
+
+## Phase 3 — Collaborative merge (CRDT)
+- [ ] commutative/idempotent op merge
+- [ ] concurrent-edit tests (any order, double-apply → identical)
+
+## Phase 4 — External sync + federation
+- [ ] Ghost/CMS sync via injected adapter (import/export)
+- [ ] federated documents (peer-authored blocks) — trust-gated stub
+- [ ] tests: round-trip import/export, conflict on concurrent external edit
+
+## Progress log
+(loop fills this in)
+
+## Blockers
+(loop fills this in)

plans/events-on-sx.md

@@ -0,0 +1,81 @@
+# events-on-sx: Calendar, ticketing & notification delivery on Datalog
+
+> **DRAFT outline.** The events vertical + the shared notification-delivery edge.
+> Depends on `persist-on-sx` (bookings ledger) and `flow-on-sx` (reminders, retrying
+> delivery). Pairs with `commerce-on-sx` for paid tickets.
+
+rose-ash's `events` domain is calendar + ticketing: recurring events, availability,
+capacity, bookings. Scheduling is constraint reasoning — "is this slot free given
+recurrence, capacity, and the attendee's other bookings?" — which is rule
+evaluation over facts. Datalog expresses availability, recurrence expansion, and
+capacity as rules; a booking is a transaction; reminders and digests are durable
+`flow`s. Notification *delivery* (email/push) — needed here and by `feed/notify` —
+is folded in as an injected transport, extractable later.
+
+End-state: a Datalog-on-SX events layer with recurrence expansion, availability +
+capacity rules, transactional booking, and a flow-driven notification dispatcher
+(reminders, digests, retries) over an injected transport.
+
+## Status (rolling)
+
+`bash lib/events/conformance.sh` → **0/0** (not yet started)
+
+## Ground rules
+
+- **Scope:** only `lib/events/**` and `plans/events-on-sx.md`. May **import** from
+  `lib/datalog/`, and (once they exist) `lib/persist/` + `lib/flow/`. Do not edit
+  substrates.
+- **Architecture:** events/availability/capacity are Datalog facts + rules;
+  recurrence expands to occurrence facts within a window; a booking checks rules
+  then appends a `persist` event (idempotent, capacity-safe). Notifications are flows
+  that suspend on transport IO and retry on failure.
+- **Determinism:** recurrence expansion + availability must be reproducible for a
+  fixed window + ruleset; capacity checks must be race-safe (no overbooking).
+- **Commits:** one feature per commit. Progress log + tick boxes.
+
+## Architecture sketch
+
+```
+Event + booking                         Result
+  event(id,start,rrule,capacity)          {:booked | :full | :conflict} + reminders
+        │                                       ▲
+        ▼                                       │
+lib/events/calendar.sx                  lib/events/availability.sx
+  — event facts, recurrence (RRULE)       — free/busy + capacity rules (Datalog)
+  — expand occurrences in window                │
+        │                                       ▲
+        ▼                                       │
+lib/events/booking.sx                   lib/events/notify.sx   (flow)
+  — transactional, capacity-safe          — reminders / digests, retry on fail
+  — bookings → persist ledger               — injected transport (email/push)
+        │                                       │
+        ▼                                       ▼
+lib/events/api.sx ── (events/schedule) (events/book) (events/agenda) ──────┘
+```
+
+## Phase 1 — Calendar + recurrence
+- [ ] `calendar.sx` — event facts, RRULE expansion in a window
+- [ ] `availability.sx` — free/busy rules
+- [ ] `api.sx` + tests + scoreboard + conformance.sh
+
+## Phase 2 — Ticketing + booking
+- [ ] capacity rules; transactional booking → `persist` (no overbooking)
+- [ ] paid tickets compose with `commerce` order flow
+- [ ] tests: capacity edge, double-book guard, conflict detection
+
+## Phase 3 — Notification delivery (flow)
+- [ ] `notify.sx` — reminder/digest flows over injected transport
+- [ ] retry/backoff on transport failure (flow suspend/resume)
+- [ ] tests: delivery success, retry path, idempotent re-send
+- [ ] NOTE: shared with `feed/notify` — candidate for later extraction to a
+  `delivery-on-sx` once a second consumer is real
+
+## Phase 4 — Federation
+- [ ] cross-instance events (peer calendar) — trust-gated stub
+- [ ] tests: federated agenda merge
+
+## Progress log
+(loop fills this in)
+
+## Blockers
+(loop fills this in)

plans/feed-on-sx.md

@@ -0,0 +1,176 @@
+# feed-on-sx: Activity Feeds on APL
+
+Timelines, notifications, activity aggregation. The math is array math: filter, sort,
+reduce, scan, outer product. APL is the densest possible expression of feed
+composition — a fanout-and-rank pipeline reads as a single line.
+
+rose-ash needs: per-user home timeline, notification feed, activity stream digestion,
+backfill for new follows, deduplication across cross-posts. Every operation is an
+array-shaped transformation.
+
+End-state: an APL-flavored layer on `lib/apl/` with feed-specific combinators
+(`fanout`, `dedupe`, `score`, `rank`), an SX adapter for callers who don't want raw
+APL, ACL visibility filtering via `lib/acl/`, federation via fed-sx.
+
+## Status (rolling)
+
+`bash lib/feed/conformance.sh` → **189/189** (Phases 1–4 + TF-IDF, notifications, home, smart-dedupe, trending, mute, pagination, threading)
+
+## Ground rules
+
+- **Scope:** only touch `lib/feed/**` and `plans/feed-on-sx.md`. Do **not** edit
+  `spec/`, `hosts/`, `shared/`, `lib/apl/**`, or other `lib/<lang>/`. You may
+  **import** from `lib/apl/` (public API in `lib/apl/apl.sx`); do **not** modify APL.
+- **Shared-file issues** go under "Blockers" with a minimal repro; do not fix here.
+- **SX files:** use `sx-tree` MCP tools only.
+- **Architecture:** an activity is a small dict (`{:actor :verb :object :at :tags}`); a
+  stream is an APL vector of such dicts. Operations are APL primitives lifted onto
+  this shape. SX adapter exposes ergonomic API to non-APL callers.
+- **Unicode:** raw UTF-8 in `.sx` files. APL glyphs land directly.
+- **Commits:** one feature per commit. Keep Progress log updated and tick boxes.
+
+## Architecture sketch
+
+```
+Raw activities (any shape)              Per-user view
+        │                                    ▲
+        ▼                                    │
+lib/feed/normalize.sx              lib/feed/timeline.sx
+  — {:actor :verb :object             — (timeline user)
+     :at :tags} record                — applies filter ∘ rank ∘ take
+        │                                    ▲
+        ▼                                    │
+lib/feed/stream.sx                  lib/feed/rank.sx
+  — APL vector of activities          — velocity, recency
+  — filter, sort, take                — TF-IDF-ish over :tags
+        │                                    ▲
+        ▼                                    │
+lib/feed/fanout.sx                  lib/feed/dedupe.sx
+  — followers vector                  — group by :object
+  — activities ∘.× followers          — collapse cross-posts
+  — flatten + dedupe
+        │
+        ▼
+lib/feed/api.sx           lib/feed/fed.sx
+  — (feed/post activity)    — inbox via fed-sx
+  — (feed/timeline user)    — backfill on subscribe
+  — (feed/notify user)
+```
+
+## Phase 1 — Stream model + basic ops
+
+- [x] `lib/feed/normalize.sx` — activity record schema; coerce arbitrary inputs
+- [x] `lib/feed/stream.sx` — APL vector representation; filter by predicate; sort by
+  `:at`; take N (`↑`); reverse (`⌽`)
+- [x] `lib/feed/api.sx` — `(feed/post activity)`, `(feed/all)`
+- [x] `lib/feed/tests/basic.sx` — 30 cases: normalize defaults, filter, sort, take, api
+- [x] `lib/feed/scoreboard.{json,md}`
+- [x] `lib/feed/conformance.sh`
+
+## Phase 2 — Fanout via outer product
+
+- [x] follower graph: `followers user → vector of user ids` (`feed/follow-graph`,
+  `feed/followers`; graph = `{followee -> (followers)}` dict)
+- [x] fanout: activities `∘.×` audience → matrix via `apl-outer feed/-mk-event`
+- [x] flatten to inbox events vector (`feed/-flatten` rank-2 → rank-1)
+- [x] dedupe — `feed/dedupe-inbox` by `(to, actor, verb, object)`; also
+  `feed/dedupe-activities` `(actor verb object)` and `feed/dedupe-collapse`
+  `(verb object)` for cross-actor likes
+- [x] `lib/feed/tests/fanout.sx` — 29 cases: small graph, mutual follow, star
+  (high-fanout), empty graph, unfollowed actor, cross-post dedupe
+
+## Phase 3 — Aggregation + ranking
+
+- [x] group-by — `feed/group-by`/`feed/group-count` key-reduce; `feed/by-actor-day`
+  buckets `(actor, day)` via `feed/day` (string-joined keys)
+- [x] velocity score — `feed/velocity` counts actor's activities in `(at-window, at]`
+- [x] recency score — `feed/recency` half-life decay `0.5^(age/hl)`
+- [x] composite rank — `feed/composite` weighted sum of `(weight scorer)` parts
+- [x] top-N per timeline — `feed/top` = rank then take
+- [x] `lib/feed/tests/rank.sx` — 24 cases: decay shape, velocity burst, stable
+  tie-break, top-N, composite
+
+## Phase 4 — Visibility filter + federation
+
+`lib/acl/` and fed-sx don't exist yet and are out of scope (import `lib/apl/`
+only), so ACL/transport are injected: `permit?`, `remote?`, `send-fn`, `fetch-fn`
+are function parameters. Real acl-sx / fed-sx wire in at the call site unchanged.
+
+- [x] ACL filter — `feed/visible stream viewer permit?`; default `feed/permit-acl?`
+  reads `:visible-to` allowlist (+ author-sees-own); per-viewer, never cached
+- [x] fed-sx outbound — `feed/federate`/`feed/deliver` fan out then partition
+  local vs remote inboxes; remote events handed to injected `send-fn`
+- [x] fed-sx inbound — `feed/inbound` normalizes + `feed/ingest` dedupes peer
+  activities into the local stream
+- [x] backfill on subscribe — `feed/backfill local fetch-fn peer-id`
+- [x] `lib/feed/tests/integration.sx` — 22 cases incl. end-to-end
+  `feed/timeline` (federated → ACL for viewer → recency rank → top-N)
+
+## Progress log
+
+- **Phase 1 done (30/30).** Stream = APL rank-1 array whose ravel holds activity
+  dicts. `normalize.sx` (record schema + accessors), `stream.sx` (filter via `/`
+  compress, sort via `⍋` grade-up [stable], take via `↑`, reverse via `⌽`,
+  by-actor/verb/object/since predicates), `api.sx` (mutable log: post/all/reset!/size).
+  Substrate: `apl-compress`, `apl-grade-up`, `apl-take`, `apl-reverse`, `make-array`.
+  Grade-up returns 1-based indices (⎕IO=1), is stable on ties → deterministic sort.
+- **Phase 2 done (59/59 total).** `fanout.sx` (graph + `apl-outer` showcase),
+  `dedupe.sx` (per-key dedupe, first-wins stable). Key APL gotcha: `scalar?` is
+  true for ANY dict and `disclose` nils a non-array dict, so an apl-outer combiner
+  MUST `enclose` its event dict — apl-outer discloses it back intact. `apl-unique`
+  preserves first-occurrence order; dict `keys` order is NOT stable, so
+  `feed/audience` sorts (else recipient ordering flakes). `apl-compress` needs a
+  rank-1 array, so the (activity×follower) matrix is flattened to its ravel before
+  the edge-guard filter.
+- **Phase 3 done (83/83 total).** `aggregate.sx` (group-by/count, day buckets) +
+  `rank.sx` (recency/velocity/engagement scorers, composite, top-N). `sort` is
+  single-arg ascending only — no comparator — so ranking uses a stable two-pass
+  `apl-grade-down` (by :at desc, then by score desc) for deterministic tie-breaks.
+  Dict keys must be strings, so composite group keys are string-joined ("actor#day").
+- **Phase 4 done (105/105 total).** `acl.sx` (per-viewer `feed/visible`,
+  `feed/timeline` capstone) + `fed.sx` (merge/ingest/inbound/backfill/federate/
+  deliver). ACL/transport are dependency-injected (permit?/remote?/send-fn/fetch-fn)
+  since lib/acl + fed-sx don't exist. `feed/normalize` now MERGEs defaults over the
+  raw dict (was projecting to 5 keys) so extra metadata (:visible-to, peer fields)
+  survives — matches the "flexible bag" principle.
+
+## Roadmap is complete (all 4 phases). Possible follow-ups:
+
+- Wire real acl-sx once `lib/acl/` exists (swap injected `permit?`).
+- Wire real fed-sx transport (swap `send-fn`/`fetch-fn`).
+- [x] TF-IDF over `:tags` for content ranking — `content.sx`: `feed/tag-df`,
+  `feed/tag-idf` (log N/df), `feed/tfidf-score`, `feed/by-relevance`; 15 tests.
+  Composes as a scorer with rank.sx. (120/120 total.)
+- [x] Notification feed (verb-filtered, per-recipient) — `notify.sx`:
+  `feed/notifications`, `feed/notify-verbs`, `feed/notify-digest` (collapses
+  "X, Y liked Z" by (verb,object), sorted-deterministic); 8 tests. (128/128 total.)
+- [x] **Capstone** `feed/home` — the whole pipeline as one line: fanout ∘ inbox ∘
+  dedupe ∘ ACL ∘ rank ∘ take (`home.sx`); 6 tests incl. per-viewer ACL + cross-post
+  dedupe. (134/134 total.)
+- [x] Per-verb dedupe rules (briefing gotcha #3) — `feed/dedupe-smart` /
+  `feed/smart-key`: reactions (like/follow/boost/...) collapse cross-actor on
+  (verb,object); posts stay distinct per actor. `feed/collapse-verbs` is
+  rebindable policy; 9 tests. (143/143 total.)
+- [x] Trending — `feed/trending` / `feed/trending-actors`: objects/actors ranked
+  by activity count in a recency window, count-desc with key-asc tiebreak
+  (`trending.sx`); 11 tests. (154/154 total.)
+- [x] Mute/block — `feed/mute-actors` / `feed/mute-tags` / `feed/mute-objects` /
+  `feed/apply-prefs`: viewer-controlled per-request filtering (complements ACL's
+  author-controlled visibility) (`mute.sx`); 9 tests. (163/163 total.)
+- [x] Pagination — `feed/page`/`feed/page-count` (offset) + `feed/before`/
+  `feed/after`/`feed/page-before`/`feed/next-cursor` (cursor by :at, stable under
+  inserts) (`page.sx`); 14 tests. (177/177 total.)
+- [x] Threading — `feed/replies`/`feed/reply-count`/`feed/thread`/
+  `feed/thread-objects`/`feed/thread-size`: conversation closure over `:reply-to`
+  (transitive fixpoint), chronological (`thread.sx`); 12 tests. (189/189 total.)
+
+(none)
+
+## Notes for next iteration
+
+- sx-tree MCP tools take `file:` NOT `path:` (CLAUDE.md is stale). Wrong key →
+  `Yojson Type_error("Expected string, got null")`. Looks like a broken binary, isn't.
+- sx_server binary lives in main repo: `/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe`
+  (worktree has no `_build`). conformance.sh already points there with relative fallback.
+- Phase 2 substrate verified available: `apl-outer` (∘.×), `apl-member` (∊),
+  `apl-unique`, `apl-iota` (1-based).

plans/flow-on-sx.md

@@ -0,0 +1,108 @@
+# flow-on-sx: Durable DAG Workflows on Scheme
+
+rose-ash needs workflows that survive restarts: content pipelines (write → review →
+publish → federate), scheduled jobs (digest emails), multi-step user flows (signup,
+confirm, onboard). art-dag is the precedent — DAG-of-tasks with pause/resume at IO
+boundaries.
+
+Scheme's `call/cc` + delimited continuations make pause/resume natural: a `suspend`
+captures the continuation, serializes it as part of the flow record, and `resume`
+re-enters at exactly that point. No state-machine bookkeeping by hand. R7RS-small is
+already at 2644/2644 (see kernel/architecture status).
+
+End-state: a Scheme-on-SX layer over the existing scheme runtime, with combinators
+for sequence/parallel/branch/retry/timeout/suspend, persistent flow store, and a
+federation extension via fed-sx for remote-node execution.
+
+## Status (rolling)
+
+`bash lib/flow/conformance.sh` → **0/0** (not yet started)
+
+## Ground rules
+
+- **Scope:** only touch `lib/flow/**` and `plans/flow-on-sx.md`. Do **not** edit
+  `spec/`, `hosts/`, `shared/`, `lib/scheme/**`, or other `lib/<lang>/`. You may
+  **import** from `lib/scheme/` (public API via `lib/scheme/scheme.sx`); do **not**
+  modify Scheme.
+- **Shared-file issues** go under "Blockers" with a minimal repro; do not fix here.
+- **SX files:** use `sx-tree` MCP tools only.
+- **Architecture:** flow combinators are Scheme macros + procedures. Runtime is a
+  driver loop that walks the flow graph and invokes `call/cc` at `suspend` points.
+  Persistence layer serializes the continuation + open file/socket placeholders are
+  forbidden (continuations must be resumable across process restart).
+- **art-dag awareness:** read `plans/art-dag*` if it exists for design lineage; do not
+  import code.
+- **Commits:** one feature per commit. Keep Progress log updated and tick boxes.
+
+## Architecture sketch
+
+```
+(defflow publish
+  (sequence
+    (write-content)
+    (parallel
+      (review)
+      (spell-check))
+    (cond approved?
+      (sequence (publish) (federate))
+      (notify-author))))
+        │
+        ▼
+lib/flow/spec.sx           lib/flow/runtime.sx          lib/flow/store.sx
+  — defflow                  — driver loop                 — append-only flow log
+  — sequence/parallel        — node dispatch               — checkpoint serialize
+  — cond/retry/timeout       — call/cc at suspend          — restart loader
+  — suspend/resume                  │                            │
+                                    ▼                            ▼
+                            lib/flow/api.sx              lib/flow/remote.sx
+                              — (flow/start name args)     — fed-sx adapter
+                              — (flow/resume id value)     — node-on-peer execution
+                              — (flow/cancel id)           — failure handling
+```
+
+## Phase 1 — Declarative DAG + sequential execution
+
+- [ ] `lib/flow/spec.sx` — `defflow` macro, `sequence` combinator
+- [ ] node = Scheme thunk; output threads to next node (data flow)
+- [ ] `parallel` combinator (sequential semantics for now — TRUE parallelism in Phase 3)
+- [ ] runtime executes a flow synchronously, returns final value
+- [ ] `lib/flow/api.sx` — `(flow/start name args)` entry point
+- [ ] `lib/flow/tests/basic.sx` — 15+ cases: linear sequence, nested sequences,
+  data flow between nodes, parallel-with-join
+- [ ] `lib/flow/scoreboard.{json,md}`
+- [ ] `lib/flow/conformance.sh`
+
+## Phase 2 — Control flow + error handling
+
+- [ ] `cond` combinator — predicate selects branch
+- [ ] `retry n [backoff]` — re-runs node up to n times on exception
+- [ ] `timeout ms` — bounds node execution
+- [ ] `try-catch` — exception handler with reified error
+- [ ] error model — exceptions vs explicit `(fail :reason ...)` results
+- [ ] `lib/flow/tests/control.sx` — 25+ cases: each combinator + composition
+
+## Phase 3 — Suspend / resume (the showcase)
+
+- [ ] `(suspend reason)` — `call/cc` captures continuation, returns flow-id to caller
+- [ ] `lib/flow/store.sx` — serialize flow state (continuation + open vars)
+- [ ] `(flow/resume id value)` — load continuation, inject value, re-enter
+- [ ] `(flow/cancel id)` — explicit termination
+- [ ] crash recovery — on restart, scan store for paused flows, mark resumable
+- [ ] `lib/flow/tests/suspend.sx` — pause-resume scenarios, cancellation, "restart"
+  scenarios (simulated by re-loading store)
+
+## Phase 4 — Distributed nodes via fed-sx
+
+- [ ] `(remote-node addr fn args)` — execute node on a federation peer
+- [ ] failure semantics — retry on different peer, fall through to local
+- [ ] persistence across instances — flow state replicates via fed-sx
+- [ ] handoff — flow started here can resume on a peer if the local instance is down
+- [ ] `lib/flow/tests/distributed.sx` — federated flow scenarios (mock fed-sx in tests)
+
+## Progress log
+
+(loop fills this in)
+
+## Blockers
+
+(loop fills this in)

plans/host-on-sx.md

@@ -0,0 +1,100 @@
+# host-on-sx: The SX web host — off Quart, onto the kernel (Dream-bound)
+
+> **DRAFT outline.** The integration boundary that turns the subsystem libraries
+> into running services, and the strangler path off Python/Quart. This is the
+> dependency hub — it imports every subsystem. Decision recorded below: native
+> server + SXTP **now**, `dream-on-sx` framework layer **next**, Python only at the
+> external-integration edges.
+
+The subsystems (`feed`, `search`, `acl`, `mod`, `flow`, `commerce`, `identity`,
+`content`, `events`) are libraries. Something has to receive an HTTP request, route
+it, call the right subsystem, and serialize the response. Today that's Python/Quart
+— the one large non-SX component in the stack: separate runtime, deploy, and
+failure mode. The goal is to move the web/host/domain layer onto the SX substrate
+and retire Quart, **incrementally (strangler-fig), never big-bang.**
+
+This is already underway: a native OCaml HTTP server is live in prod on
+`sx.rose-ash.com` (~3ms cached, ~323 req/s, ~2MB RSS), `defhandler`/`defpage`
+exist, and a partial **SXTP** protocol is specced. That is the unblocked near-term
+host — no `ocaml-on-sx` dependency.
+
+## Two layers, two timelines
+
+1. **Now (unblocked): native server + SXTP adapter + SX handlers.** Route rose-ash
+   endpoints onto the SX host one at a time. Each migrated endpoint is an SX
+   handler dispatching to a subsystem; Quart proxies the rest until cut over.
+2. **Next: `dream-on-sx` as the framework layer.** Dream gives Quart-grade
+   ergonomics — typed routing, middleware stacks, sessions, CSRF. It is gated on
+   `ocaml-on-sx` Phases 1–5 + minimal stdlib. **This plan is the concrete target
+   user that un-parks `dream-on-sx`** (see `plans/dream-on-sx.md`): "the subsystems
+   need an HTTP front door" is the real feature pulling Dream. Until then, do not
+   block migration on Dream — the native server is sufficient.
+3. **Always: Python only at the edges.** External integrations — SumUp payments,
+   Ghost CMS, ActivityPub crypto, IPFS/Kubo — ride Python libraries today. They
+   stay as thin injected adapters (Python/FFI) behind subsystem interfaces until
+   native replacements exist. "Drop Quart" ≠ "drop every line of Python."
+
+## Status (rolling)
+
+`bash lib/host/conformance.sh` → **0/0** (not yet started)
+
+## Ground rules
+
+- **Scope:** `lib/host/**` and `plans/host-on-sx.md`. May **import** every subsystem
+  + the kernel's server/SXTP surface. Do **not** edit `spec/`, `hosts/`, `shared/`,
+  or subsystem internals — wire to their public APIs only. Host-primitive / server
+  changes belong in `hosts/` (out of scope) → Blockers.
+- **Architecture:** a route maps (method, path) → handler; a handler is an SX fn
+  `request -> response` that calls subsystem APIs; middleware is composed handlers
+  (auth via `identity`, permission via `acl`, mute via subsystem prefs). SXTP is the
+  wire format between host and subsystem-as-service.
+- **Migration discipline:** each endpoint moved must be behavior-equivalent to its
+  Quart original (golden-response test before flip). Keep a migration ledger.
+- **Commits:** one feature per commit. Progress log + tick boxes.
+
+## Architecture sketch
+
+```
+HTTP request                            HTTP response
+        │                                       ▲
+        ▼                                       │
+native OCaml http server (prod)  ──────►  lib/host/router.sx
+   (hosts/ — out of scope)                  — (method,path) → handler
+        │                                       ▲
+        ▼                                       │
+lib/host/middleware.sx                  lib/host/handler.sx
+  — auth(identity) ∘ acl ∘ mute ∘ ...     — request → subsystem call → response
+        │                                       ▲
+        ▼                                       │
+lib/host/sxtp.sx                        subsystem APIs (feed/search/commerce/…)
+  — wire format, host↔service             — called via public interfaces
+        │
+        └── external edges: SumUp / Ghost / AP / IPFS  → injected Python/FFI adapters
+```
+
+## Phase 1 — Router + handler + one real endpoint
+- [ ] `router.sx` — route table, (method,path) match
+- [ ] `handler.sx` — request/response model, subsystem dispatch
+- [ ] migrate ONE read endpoint (e.g. a feed timeline) end-to-end, golden test
+- [ ] `conformance.sh` + scoreboard
+
+## Phase 2 — Middleware + SXTP
+- [ ] `middleware.sx` — composable auth/acl/mute/error layers
+- [ ] `sxtp.sx` — host↔subsystem wire format (align with existing spec)
+- [ ] migrate a write endpoint (auth + permission + action)
+
+## Phase 3 — Strangler migration ledger
+- [ ] enumerate Quart endpoints; track migrated vs proxied
+- [ ] golden-response harness vs the live Quart responses
+- [ ] cut over a whole domain (smallest: `likes` or `relations`) as proof
+
+## Phase 4 — Dream framework layer (gated)
+- [ ] gate: `ocaml-on-sx` Phases 1–5 + minimal stdlib green
+- [ ] adopt `dream-on-sx` routing/middleware/session ergonomics over the same handlers
+- [ ] re-home external adapters as native where replacements land
+
+## Progress log
+(loop fills this in)
+
+## Blockers
+(loop fills this in)

plans/identity-on-sx.md

@@ -0,0 +1,84 @@
+# identity-on-sx: OAuth2, sessions & membership on Erlang
+
+> **DRAFT outline.** The identity core `acl-on-sx` assumes already exists. `acl`
+> answers "may X do Y"; identity answers "who is X, and how did they prove it."
+> Depends on `persist-on-sx` (grant/audit ledger). Pairs with `acl-on-sx`.
+
+rose-ash's `account` domain is the OAuth2 authorization server every other app is
+a client of: silent SSO, per-app first-party cookies, grant verification,
+membership. Sessions and grants are **long-lived, concurrent, individually
+addressable, and expire on their own** — that is the actor model. Erlang's
+processes + mailboxes map cleanly: a session is a process, token issue/refresh/
+revoke are messages, expiry is a process timeout, and SSO is one process answering
+many apps.
+
+End-state: an Erlang-on-SX layer with the OAuth2 authorization-code + silent
+(`prompt=none`) flows as message protocols, a session/grant registry, token
+lifecycle (issue/refresh/revoke/introspect), and membership state — all auditable
+through the event log, all authorization questions delegated to `acl-on-sx`.
+
+## Status (rolling)
+
+`bash lib/identity/conformance.sh` → **0/0** (not yet started)
+
+## Ground rules
+
+- **Scope:** only `lib/identity/**` and `plans/identity-on-sx.md`. May **import**
+  from `lib/erlang/`, and (once they exist) `lib/persist/` + `lib/acl/`. Do not edit
+  substrates.
+- **Architecture:** a session/grant is a process holding its own state; the
+  registry routes messages by subject/client id. Tokens are opaque + introspected,
+  not self-validating (revocation must be real). Authorization decisions are NOT
+  made here — `identity` proves identity, `acl` decides permission.
+- **Security:** revocation is immediate (kill the process / tombstone the grant);
+  no decision relies on a token that outlived its grant. Negative answers are
+  explicit, never "absence of a yes."
+- **Commits:** one feature per commit. Progress log + tick boxes.
+
+## Architecture sketch
+
+```
+Auth request                            Token / session
+  (authorize client scope subject)        {:access :refresh :expires :grant}
+        │                                       ▲
+        ▼                                       │
+lib/identity/oauth.sx                   lib/identity/token.sx
+  — authz-code + prompt=none flows        — issue / refresh / revoke / introspect
+  — as Erlang message protocols           — opaque tokens, grant-backed
+        │                                       ▲
+        ▼                                       │
+lib/identity/session.sx                 lib/identity/registry.sx
+  — session = process, expiry=timeout     — route by subject/client; SSO fan-out
+        │                                       │
+        ▼                                       ▼
+lib/identity/api.sx ── (identity/login) (identity/grant?) (identity/revoke) ──┐
+        │                                                                      │
+        └──────── grant + audit events → persist ;  permission? → acl ──────────┘
+```
+
+## Phase 1 — Sessions + tokens
+- [ ] `session.sx` — session process, create/lookup/expire
+- [ ] `token.sx` — issue/introspect/revoke (opaque, grant-backed)
+- [ ] `registry.sx` — route by subject/client
+- [ ] `api.sx` + tests + scoreboard + conformance.sh
+
+## Phase 2 — OAuth2 flows
+- [ ] authorization-code flow as a message protocol
+- [ ] refresh + rotation; revocation cascades to issued tokens
+- [ ] tests: full code exchange, refresh, revoke-then-use (must fail)
+
+## Phase 3 — Silent SSO + membership
+- [ ] `prompt=none` cross-app login (one session, many clients)
+- [ ] membership state + per-app grant projection
+- [ ] grant verification delegated cache (mirror Redis-cache pattern)
+
+## Phase 4 — Audit + federation
+- [ ] every issue/refresh/revoke is a `persist` event; `(identity/audit subject)`
+- [ ] federated identity (peer-asserted subject) — advisory, trust-gated stub
+- [ ] tests: audit completeness, cross-instance subject mapping
+
+## Progress log
+(loop fills this in)
+
+## Blockers
+(loop fills this in)

plans/lib-guest-scheduler.md

@@ -0,0 +1,517 @@
+# lib/guest/scheduler — extraction plan
+
+Two distinct concurrency models — Erlang's addressed processes + mailboxes, and
+Go's anonymous channels + goroutines — sit on the same underlying machinery:
+a fork/yield/block/resume scheduler over CEK io-suspended continuations. This
+plan captures that machinery as `lib/guest/scheduler/` so language N+1 with a
+new concurrency model costs ~200 lines of model-specific code instead of
+re-inventing the scheduler.
+
+Reference: `plans/lib-guest.md` (parent — two-language rule, stratification),
+`plans/erlang-on-sx.md` (first consumer, in production), Go-on-SX (second
+consumer, see `plans/go-on-sx.md` once that lands).
+
+**Branch:** `architecture`. SX files via `sx-tree` MCP only.
+
+## Thesis
+
+The substrate already provides what a scheduler needs: CEK io-suspension
+(`make-cek-suspended`, `cek-resume`) gives suspendable execution; first-class
+environments give each unit of execution its own scope; the trampolined
+evaluator means we never blow the host stack. What every guest with concurrency
+*re-implements* on top of this is the **fork/yield/block/resume protocol** —
+the bookkeeping that decides which suspended computation runs next.
+
+Two concrete consumers, two different concurrency vocabularies, sharing one
+underlying scheduler, is the proof. If only Erlang lives on it, "scheduler kit"
+is a euphemism for "Erlang scheduler with a Go skin." The two-language rule
+is the gate.
+
+## Current state (2026-05-26)
+
+- **Erlang-on-SX** has the full pattern in production: 729/729 conformance,
+  spawn/send/receive, selective receive, monitor/link, hot reload. The
+  scheduler logic is currently coupled to Erlang-shaped concepts (PIDs,
+  mailboxes, links) — extraction-blocking but not extraction-defeating.
+- **Go-on-SX** does not exist yet. `plans/go-on-sx.md` is the umbrella plan
+  (TBD); this scheduler plan is a sibling/dependency.
+- **lib/guest/scheduler/** does not exist. The two-language rule blocks
+  extraction until Go-on-SX independently implements its scheduler.
+
+**Status: Phase 0 (Erlang shape capture).** No code change in this plan yet.
+
+## Why the two models actually share a kit
+
+The non-obvious claim is that Erlang processes and Go goroutines really do
+share machinery beneath their different vocabularies. The mapping:
+
+| Concept | Erlang | Go | Common kit name |
+|---|---|---|---|
+| Unit of execution | process (PID-addressed) | goroutine (anonymous) | **task** |
+| Spawn | `spawn(Fun)` → PID | `go expr` → nothing | `task-spawn` |
+| Block target | mailbox match | channel send/recv | `task-block` |
+| Wake condition | message arrives | counterpart ready | `task-resume` predicate |
+| Yield | `receive` with no match | channel blocked | scheduler hands off |
+| Termination | exit reason → linked tasks | panic / return | task lifecycle |
+| Selection | selective `receive` | `select` statement | both = "wait for any of N predicates" |
+
+What the kit owns:
+- The **task table** (token → suspended CEK continuation + status).
+- The **runnable queue** + scheduling policy (round-robin v1; pluggable).
+- The **block→resume protocol**: a blocked task registers a predicate; when
+  any task changes state, blocked tasks are re-polled; first whose predicate
+  fires becomes runnable.
+- The **fairness/preemption budget** — gas per step before forced yield.
+
+What each language owns:
+- The semantics layer on top: Erlang's PID→task map + mailbox per task +
+  selective-receive predicates; Go's channel value → blocked-task list per
+  channel + send/recv pairing + select multiplexing.
+- The language-visible API (`spawn`/`!`/`receive` vs `go`/`<-`/`select`).
+
+This is exactly the lib/guest pattern: extract the dispatch skeleton, keep
+the rules in the language layer.
+
+## API surface (proposed — design only, not yet implemented)
+
+```
+(make-scheduler &key gas-per-step ;; default 1000
+                     policy)      ;; :round-robin | :fifo
+  -> scheduler-handle
+
+(task-spawn sched body-thunk) -> task-token
+  ;; body-thunk is a 0-arg fn whose body runs as the task.
+  ;; Returns immediately; task is enqueued runnable.
+
+(task-current sched) -> task-token
+  ;; Inside a task, the token of the running task. Useful for self-reference.
+
+(task-yield sched) -> nil
+  ;; Voluntary yield. Caller is re-enqueued at the tail of runnable.
+
+(task-block sched resume-predicate) -> any
+  ;; Caller suspends. Predicate is (fn () -> resume-value-or-#f).
+  ;; When predicate returns non-#f, caller resumes with that value.
+  ;; Predicate is polled on every scheduler tick when there's nothing
+  ;; obviously runnable. (Optimisation: language layer can wake explicitly —
+  ;; see task-wake.)
+
+(task-wake sched task) -> nil
+  ;; Hint to the scheduler: re-poll this task's resume-predicate now.
+  ;; Used by sender-side when a receiver might unblock.
+
+(task-status sched task) -> :runnable | :blocked | :finished | :crashed
+
+(task-result sched task) -> value | {:error reason}
+  ;; After :finished or :crashed.
+
+(scheduler-step sched) -> :ran | :idle | :all-done
+  ;; Run at most gas-per-step instructions of one task. Caller drives the
+  ;; loop.
+
+(scheduler-run sched) -> nil
+  ;; Run until :all-done. Equivalent to (until (= :all-done (scheduler-step
+  ;; sched))).
+```
+
+Notes on the design:
+- `task-block` with a resume-predicate is the universal blocking primitive.
+  Erlang's `receive` is `(task-block sched (fn () (mailbox-match self pat)))`.
+  Go's `<-ch` is `(task-block sched (fn () (channel-recv-ready ch)))`.
+- `task-wake` is the optimisation: instead of polling every blocked task
+  every step, the language layer wakes the specific task whose predicate
+  is now likely true. v1 can omit it; performance work later.
+- `gas-per-step` gives fairness without true preemption. Tasks that don't
+  yield within their gas budget are force-yielded by the CEK loop. (CEK
+  io-suspension already does this for IO; gas budget extends to plain
+  instructions.)
+- No priority/affinity in v1. Both Erlang and Go default to non-priority
+  scheduling; specialised cases (Erlang's high-priority processes) are
+  language-layer concerns.
+
+## Build order — phases
+
+This is a long-running plan paced against Go-on-SX. Phases are not loop-style
+"one commit per phase" — they're milestone gates.
+
+### Phase 0 — Erlang shape capture (doc-only) ⬜
+- Read `lib/erlang/runtime.sx` scheduler code (currently coupled to Erlang
+  vocabulary).
+- Write a 1-page summary of what's actually a scheduler and what's actually
+  Erlang. Identify the boundary.
+- **Acceptance:** summary committed to this plan as a new section "Erlang
+  scheduler shape (captured 2026-MM-DD)". No code change.
+- **Output:** clear-eyed mental model. Without this, we'll merge Erlang's
+  scheduler shape into the kit and pretend it generalises.
+
+### Phase 1 — Go scheduler independent implementation ✅
+- During Go-on-SX, implement `lib/go/sched.sx` from scratch. Do NOT look at
+  Erlang's scheduler while doing this. (Or read it once, then close it.)
+- Pass Go's channel + goroutine + select conformance tests.
+- **Acceptance:** Go scheduler green, lib/go/scoreboard.json includes scheduler
+  tests, two-consumer rule now passable.
+- **Output:** two independent, working implementations of the same idea.
+- **Status (2026-05-28):** Done. `lib/go/sched.sx` ships channels as
+  closure-bundles `(:go-chan SEND RECV CLOSED? CLOSE! LEN)` sharing a
+  mutable buffer + closed flag. Goroutines: `go` stmt is v0-synchronous
+  (no real preemption — flagged Phase 5b). select dispatches by source
+  order picking first ready case; default makes it non-blocking;
+  blocking-no-default returns `:select-blocked-no-default` sentinel.
+  40 runtime tests + 12 e2e programs use the scheduler primitives.
+  **Two-consumer rule passable** — Erlang's scheduler and Go's
+  scheduler both exist as independent implementations.
+
+### Phase 2 — Diff and proposed kit ⬜
+- Side-by-side diff: Erlang's scheduler vs Go's scheduler. Where do they
+  agree? Where does each have language-specific bookkeeping?
+- The diff is the kit. Things in *both* go in `lib/guest/scheduler/`; things
+  in only one stay in `lib/erlang/` or `lib/go/`.
+- Draft `lib/guest/scheduler/api.sx` (signatures only, no body) reflecting the
+  proposed surface.
+- **Acceptance:** API draft circulated for review; agreement that the surface
+  covers both consumers; no merge yet.
+
+### Phase 3 — Implement `lib/guest/scheduler/` ⬜
+- Implement the kit per the agreed API. New file(s) in `lib/guest/scheduler/`.
+- The kit has its own tests in `lib/guest/scheduler/tests/` — agnostic of any
+  particular language vocabulary.
+- **Acceptance:** kit tests pass. Erlang and Go conformance scoreboards
+  unchanged (the language implementations still use their own scheduler —
+  we haven't refactored yet).
+
+### Phase 4 — Refactor Erlang to use the kit ⬜
+- `lib/erlang/runtime.sx` scheduler logic deleted; replaced with calls into
+  `lib/guest/scheduler/`. Erlang's PID table, mailbox-per-PID, selective
+  receive stay in `lib/erlang/`.
+- **No-regression gate:** Erlang conformance holds at current pass count
+  (currently 729/729). Hard requirement.
+- **Acceptance:** Erlang scoreboard unchanged; `lib/erlang/runtime.sx`
+  meaningfully smaller (the scheduler code is gone).
+
+### Phase 5 — Refactor Go to use the kit ⬜
+- Same exercise for Go. `lib/go/sched.sx` shrinks to channel/goroutine
+  bookkeeping + delegation.
+- **No-regression gate:** Go conformance scoreboard at its current pass
+  count.
+- **Acceptance:** Go scoreboard unchanged; `lib/go/sched.sx` meaningfully
+  smaller.
+
+### Phase 6 — Documentation + design-diary close ⬜
+- Document `lib/guest/scheduler/` API in `lib/guest/README.md` (or wherever
+  the lib/guest API index lives).
+- Capture the chiselling diary: what *almost* went in the kit but ended up
+  language-specific, and why. This is the load-bearing knowledge for the
+  third consumer when it arrives.
+- **Acceptance:** API documented; diary section added to this plan.
+
+## Two-language rule — gating
+
+**The rule is hard.** No code in `lib/guest/scheduler/` lands until BOTH
+Phase 1 (Go independent) AND Phase 0 (Erlang capture) are complete AND a
+review confirms the two implementations actually share machinery in a way
+the kit captures.
+
+If, during Phase 2 diff, we discover that the agreement is shallow (e.g.,
+both have a runnable queue but the policies are fundamentally incompatible),
+the **right outcome is to NOT extract**. Add a "rejected extraction" note to
+this plan documenting what we learned and close it. That outcome is fine —
+it tells us the two concurrency models aren't actually sister, which is a
+real result.
+
+## Open questions
+
+- **Preemption.** v1 is cooperative; gas-per-step gives fairness but not
+  hard preemption. Erlang BEAM does true preemption (reduction counting).
+  Go uses async preemption (signal-driven since 1.14). Neither extreme fits
+  cooperatively over CEK. Is gas-per-step + voluntary yield enough? Probably
+  for v1; revisit if a guest needs hard real-time.
+- **Priority/affinity.** Both Erlang and Go can run without it. Defer.
+- **Distribution.** Erlang nodes, Go's distributed channels — both are
+  language-specific layers on top of the local scheduler. Out of scope.
+- **Cancellation.** Go has `context.Context`; Erlang has `exit/2`. Both
+  bottom out at "deliver an exception to a task." Worth modelling? Probably
+  as a kit primitive `(task-cancel sched task reason)` that delivers an
+  exception via CEK exception machinery, language layer wraps it.
+- **Third consumer.** If/when JS-on-SX gets a proper async/await + Promise
+  scheduler, that'd be a great third consumer to validate the kit didn't
+  over-fit to Erlang+Go.
+
+## Progress log
+
+_Newest first. Append one dated entry per milestone landed._
+
+- 2026-05-28 — **Go-on-SX consumer-side surface fully landed (609/609
+  tests across 7 suites).** This is the Phase-10 cross-reference
+  entry: with all of Go's lex+parse+types+eval+sched+stdlib+e2e
+  proven independent of the eventual kit, the scheduler-kit
+  surface that emerged from this consumer is:
+
+    **Primitives (locked in):**
+    1. `(:go-chan SEND RECV CLOSED? CLOSE! LEN)` — closures-over-
+       mutable-state channel. Identity matters (distinct `make()`
+       calls produce distinct closures, `(= ch1 ch2)` false).
+    2. `(:go-defer CALLEE FROZEN-ARGS)` — frame-attached cleanup
+       record. Args evaluated at defer-time; call deferred to
+       frame exit.
+    3. `__go-defer-stack` — frame-local mutable list of
+       defer records. Drained LIFO at frame exit by `go-run-defers!`.
+    4. `__go-panic-cell` (STATE V) — frame-attached out-of-band
+       channel. STATE ∈ {:none, :raised, :recovered}. `recover()`
+       walks env chain to find the outermost :raised cell.
+    5. `(:go-panic V)` — propagating sentinel.
+    6. v0 stub `after(d)` — channel already buffered with `:tick`.
+       Real time becomes a refinement of *when* readiness flips,
+       not of the protocol.
+
+    **Cross-cutting abstractions (chiselled):**
+    - **Readiness protocol** (sched-pick): `select` consults
+      `ready?` over its cases; send/recv/timer/etc. all factor
+      through one predicate. See 2026-05-27 entry.
+    - **Frame-cleanup queue vs scheduler ready-queue** — distinct
+      orthogonal slots; conflating them was an early temptation
+      and stays explicit in the design.
+    - **Control-flow sentinels unify** at every AST boundary
+      (block, for, range-for, stmt-catch-all, program-loop): each
+      needs the same `propagates?` predicate inline. Kit should
+      expose ONE helper instead of N inline arms.
+
+    **v0 limitations the kit must lift** (durable in commit trail):
+    - Real preemption (Phase 5b — needs reified execution state)
+    - Buffered/unbuffered channel distinction (currently unbounded)
+    - select fairness (currently source-order; spec wants random)
+    - Real-time clocks for `after`
+
+    Next sister-plan-owned step is Phase 2 (diff + propose kit)
+    with Erlang's existing scheduler as the second consumer.
+
+- 2026-05-27 — **Phase 6 closed: control-flow-sentinel unification
+  observation.** After wiring panic propagation through 4 sites
+  (go-eval-block, go-eval-for, go-eval-stmt's catch-all, go-eval-
+  program-loop), a clear pattern emerged: every control-flow boundary
+  needs the same dispatch arm — check for `:return-value`, `:break`,
+  `:continue`, `:eval-error`, `(:go-panic ...)` — in the same order.
+  Adding a new sentinel (say `:goroutine-killed` from a real
+  preemption model) means hunting for every site and adding another
+  arm. This is precisely the kind of cross-cutting concern a
+  scheduler kit should abstract.
+
+  **Concrete kit hint:** define ONE `propagates?` predicate +
+  helper:
+
+    ```
+    (define (control-sentinel? r)
+      (or (terminal-return? r)
+          (break? r) (continue? r)
+          (raised-error? r) (raised-panic? r)
+          (goroutine-killed? r)))
+    ```
+
+  Every control-flow site calls this once. New sentinel = one place
+  to add an arm; not 7. The kit's `frame-driver` should expose this
+  primitive so guest evaluators (Go, Erlang, future targets) all
+  share the dispatch logic and only differ on which sentinels they
+  emit.
+
+  This is the second cross-cutting abstraction (after panic cell +
+  defer queue) the Go consumer has chiselled out. The pattern is:
+  scheduler kit primitives = "things every guest evaluator's control-
+  flow boundary needs once" — not "things only the scheduler runtime
+  needs." The scheduler runtime is the *driver*; the boundary
+  primitives are kit-grade shared infrastructure.
+
+- 2026-05-27 — **Phase 6: panic/recover shape lands.** The panic
+  cell is the missing piece. It's a per-frame mutable record of
+  shape `(STATE VALUE)` carrying one of `:none` / `:raised` /
+  `:recovered`. Three properties matter for the scheduler kit:
+
+    1. **It survives the function boundary** via env-chain lookup —
+       when a deferred call's own frame creates a shadowing cell,
+       `recover()` walks past it to find the OUTER frame's cell (the
+       one that's `:raised`). This is the same mechanism the
+       scheduler will need when a panic-unwinding goroutine has
+       multiple frames each carrying their own state, and the
+       "current panic" must be locatable from any depth.
+
+    2. **It flips state in place** (`set-nth!`) so that the change
+       made by `recover()` deep in a defer chain is visible to the
+       enclosing frame's exit check. The scheduler kit needs the
+       same pattern: a goroutine's "termination reason" must be
+       writable by any frame in its stack.
+
+    3. **It's distinct from the return-value channel.** A frame can
+       carry both `(:go-panic V)` from its body AND a recovery
+       commitment in its panic cell; they're checked in sequence.
+       For the scheduler this maps to: a goroutine carries both its
+       running-state (channel-blocked, ready, sleeping) AND its
+       termination-record (panic V / clean exit / killed) — two
+       orthogonal slots, not one tag.
+
+  Concrete kit hint: every frame record should expose
+  `frame-panic-cell` alongside `frame-defer-queue`. The scheduler's
+  exit-path becomes: drain defers (cell may flip :raised→:recovered)
+  → consult cell → either propagate or return clean. Erlang's
+  `try/catch/after` decomposes identically: `after` is the defer
+  queue, `catch` is the recover-via-cell mechanism.
+
+- 2026-05-27 — **Phase 6 first slice: defer + LIFO observation.**
+  Go's defer is a *frame-local cleanup queue* — a list of (callee,
+  pre-evaluated-args) records appended on `defer`, drained LIFO at
+  frame exit. The scheduler kit needs the same shape because: (a) a
+  panicking goroutine must run its frame's defers before unwinding to
+  the next frame; (b) a goroutine that exits cleanly still runs them;
+  (c) `select` cases that own resources (an acquired send slot, a
+  buffer reservation) need a cleanup hook on the case-not-taken path.
+  All three reduce to the same primitive: **"hand the frame a list
+  of thunks; call them LIFO before the frame is gone."**
+
+  Concretely the kit should expose `frame-defer!` (push) and an
+  internal `frame-teardown!` (drained by the scheduler on exit / by
+  the panic unwinder on abort). The scheduler's exit-path becomes:
+
+    1. Mark frame done.
+    2. Call `frame-teardown!` — run defers LIFO. A defer that itself
+       panics: capture the new panic, continue running the rest
+       (matches Go spec).
+    3. Release frame slot.
+
+  Crucially the defer queue is *not* the same as the scheduler's
+  ready-queue — confusing the two was an early temptation. The defer
+  queue is per-frame and synchronous-on-exit; the ready-queue is
+  global and async. Phase 5b will need to keep these distinct when
+  real preemption lands.
+
+  Test signal that drove the shape: SX assignment shadows rather than
+  mutates, so the only observable side-effect channel for deferred
+  calls is `(append! buf ...)` on a value with stable identity (e.g.
+  a channel). That maps cleanly to "deferred work emits its effects
+  through capabilities the frame held, not through enclosing-env
+  mutation" — which is also how the scheduler kit's deferred work
+  should communicate with the rest of the system. No magic; just
+  capabilities the frame can hand to its defers.
+
+- 2026-05-27 — **Phase 5 acceptance crossed (40 runtime tests).**
+  Final shape observation: *time-as-readiness-flip*. The Go side
+  added an `after(d)` builtin that returns a channel **already
+  holding** a tick value — duration is ignored in v0. The select
+  loop doesn't care that the channel got its value "via time"; it
+  only consults `ready?`. This separates two concerns the eventual
+  kit had been conflating:
+
+    1. **The wake-up protocol** — what `select` asks of every case:
+       "are you ready right now?" Channel-recv answers via "buffer
+       non-empty or closed"; channel-send via "buffer has room";
+       timer via "deadline reached." All three flatten to a single
+       `ready?` predicate.
+
+    2. **The scheduling oracle** — *when* a case's `ready?` flips
+       from false to true. For channels this is driven by other
+       goroutines sending/receiving; for timers it's driven by a
+       wall-clock or monotonic source.
+
+  v0 collapses #2 (timer = ready immediately, sends always ready,
+  recvs ready iff buffer non-empty) and exposes #1 as the only
+  thing the dispatcher needs to know. Phase 5b refines #2 with
+  blocking semantics and real time, but #1 stays the same shape.
+
+  Concretely: the kit's `select-case` should take `:ready?-fn` per
+  case, not three different "is-this-a-send-or-recv-or-timer" tags.
+  Send/recv/timer become factory functions that produce a
+  `(:ready? FN :commit! FN)` record — the dispatcher walks cases,
+  picks the first whose `ready?` returns true, calls `commit!` to
+  extract the value (and side-effect: drain buffer, fire timer).
+  This is the same shape as a STM transaction over case-set, and
+  matches Erlang's `receive` clauses too (each pattern is a
+  ready-predicate + commit-action over the mailbox head).
+
+  Ping-pong remains impossible in v0 because the synchronous spawn
+  collapses the `ready?`-flip oracle to "always immediate" — the
+  spawned goroutine can never park waiting for the parent to send.
+  Phase 5b must restore the wake-up dimension; until then the kit
+  spec should encode the readiness-protocol design even though the
+  oracle is degenerate.
+
+- 2026-05-27 — From Go-on-SX Phase 5 first slice: the channel
+  primitive landed as closures-over-mutable-state in
+  `lib/go/sched.sx`. Concrete shape:
+
+  ```
+  (list :go-chan SEND-FN RECV-FN CLOSED?-FN CLOSE!-FN)
+  ```
+
+  Each closure captures a shared `buf` (a mutable list) and `closed`
+  flag (a let-bound boolean mutated via `set!`). Identity: two
+  `make()` calls produce distinct closures, satisfying Go spec
+  § Channel types' "distinct channels with same type" rule.
+
+  **Design insight for the kit**: the channel-as-closure-bundle shape
+  is the right scheduler-kit primitive — implementation-hide the
+  buffer behind opaque accessor closures, so the underlying storage
+  can be swapped (linked list → ring buffer → segmented array) without
+  changing the API. Erlang's mailboxes will need the same trick.
+
+  **v0 limitation logged**: no real preemption. SX doesn't expose
+  first-class continuations to guest code, so v0 runs `go f()`
+  synchronously and relies on the spawned goroutine completing before
+  the main goroutine receives. Real concurrent semantics — blocking
+  send on full buffer, blocking recv on empty — needs the
+  scheduler kit to ship the suspension/resumption machinery (or for
+  Phase 5b to bake CEK-style trampolining into the eval layer).
+
+  Cross-ref: the `:select-case` uniform shape from the parser-side
+  diary entry pairs with this — the kit's `sched-select` should
+  accept a list of channel-op cases (built from the closures-over-
+  state primitives logged here) and pick a ready one. Source:
+  Go-on-SX commit landing `lib/go/sched.sx` first cut.
+
+- 2026-05-27 — Follow-up from same Phase 2 work: **`select` AST shape**
+  landed. Each case is `(list :select-case COMM-STMT BODY)` where
+  COMM-STMT is one of `:send`, `:short-decl` (recv into new var),
+  `:assign` (recv into existing var), or a bare receive expression
+  `(:app (:var "<-") [chan])`. The shape is uniform across all four
+  comm-stmt kinds — the kit's `sched-select` primitive should accept a
+  list of cases each described by `(direction chan value-target?)` and
+  let the kit's runtime pick a ready case. That uniformity is what
+  makes a single kit primitive cover all four Go case shapes.
+
+  Also: Go's `select` with `default` makes the multiplexer non-blocking;
+  without default it blocks until a case is ready. The kit primitive
+  should mirror this — present-or-absent default determines blocking
+  semantics. Erlang's `receive ... after Timeout -> ...` is a similar
+  pattern with a timeout case rather than default; the kit primitive
+  should handle both as instances of "non-blocking-fallback case."
+  Source: Go-on-SX commit `parse.sx — switch + select`.
+
+- 2026-05-27 — From Go-on-SX Phase 2 (parser side, ahead of scheduler
+  implementation): the **parsed AST shapes** for Go's concurrency
+  primitives have landed and are worth recording before Phase 5 builds
+  the scheduler.
+
+  ```
+  go EXPR              → (list :go EXPR)
+  defer EXPR           → (list :defer EXPR)
+  ch <- v              → (list :send CHAN VALUE)
+  <-ch                 → (list :app (:var "<-") [CHAN])   ; unary recv
+  for range COLL { }   → (list :range-for nil nil nil COLL BODY)
+  for k, v := range C  → (list :range-for :short-decl KEY VAL COLL BODY)
+  ```
+
+  **Design insight for the kit**: the `:go` and `:defer` shapes are
+  pleasingly minimal — both wrap a single expression. Erlang's
+  `spawn(Mod, Fun, Args)` will produce something more elaborate; the
+  scheduler kit primitive `(sched-spawn task)` should accept a thunk so
+  both languages reduce to a uniform spawn API.
+
+  The `:send` shape carries CHAN + VALUE — symmetric with channel-recv
+  as the unary `<-` form. Once the scheduler has channel primitives,
+  both shapes thunk-down to a single `(chan-op direction chan value)`
+  abstraction.
+
+  Range over channels (`for v := range ch`) is currently parsed as
+  range-for with `coll = ch`; the scheduler kit will dispatch on the
+  type of `coll` at execution time (channels yield via receive,
+  collections via iteration). This dispatch is the right place for the
+  scheduler kit to express the channel-receive ⇄ iteration polymorphism.
+  Source: Go-on-SX commit `parse.sx — go/defer/send/range`.
+
+- 2026-05-26 — Plan drafted. Phase 0 unstarted. Awaiting Go-on-SX to begin
+  Phase 1.

plans/lib-guest-static-types-bidirectional.md

@@ -0,0 +1,608 @@
+# lib/guest/static-types-bidirectional — design-diary plan
+
+Capture the dispatch skeleton of bidirectional type checking
+(synthesis/checking judgments, context as a value, pluggable subtyping and
+unification) as `lib/guest/static-types-bidirectional/`, so static-typed
+guest languages that aren't Hindley-Milner-inferred cost ~300 lines of
+language-specific rules instead of re-inventing the checker plumbing.
+
+Reference: `plans/lib-guest.md` (parent — two-language rule, stratification),
+`lib/guest/hm.sx` (sister module — full Hindley-Milner for inference-heavy
+languages like Haskell-on-SX), Go-on-SX (planned first consumer), TBD second
+consumer.
+
+**Branch:** `architecture`. SX files via `sx-tree` MCP only.
+
+## Thesis
+
+`lib/guest/hm.sx` covers languages where the user writes few type annotations
+and the checker infers the rest globally (Haskell-on-SX, an eventual ML port,
+a typed-Scheme-with-Damas-Milner). But most modern statically-typed languages
+in actual production — Go, Rust, Swift, TypeScript, Kotlin, Scala 3, Hack —
+do **bidirectional checking instead**: declarations carry annotations, locals
+are inferred from immediate context, return types thread inwards from call
+sites. This isn't a weaker form of HM; it's a different design that scales
+better to mutation, subtyping, ad-hoc polymorphism, and gradual typing —
+none of which HM handles cleanly.
+
+If `lib/guest/` is going to credibly host the next decade of statically-typed
+languages, it needs a bidirectional kit alongside `hm.sx`. They're sisters,
+not rivals.
+
+**This plan is a design diary, not an implementation queue.** The two-language
+rule blocks extraction until two consumers exist. Go-on-SX is the first; the
+second is TBD. Until then, this plan documents what the API surface *should*
+be based on a single consumer, openly acknowledging that the second consumer
+will revise it.
+
+## Current state (2026-05-26)
+
+- `lib/guest/hm.sx` exists, used by Haskell-on-SX. 180 lines. The HM kit is
+  the sister extraction this plan complements.
+- No bidirectional kit anywhere in `lib/guest/`.
+- Go-on-SX does not exist yet. When it does, `lib/go/types.sx` will be the
+  first consumer.
+- Second consumer is unidentified. Most likely candidates, in order:
+  1. **TypeScript-on-SX** — purely structural, gradual typing, the most-
+     popular bidirectional language alive. Natural pair.
+  2. **Rust-on-SX** — bidirectional with substantial extras (lifetimes,
+     traits, borrow checking). Heavyweight; lifetimes don't go in this kit.
+  3. **Typed Racket subset** — if anyone ports it. Bidirectional + gradual.
+  4. **Hack / Flow / Python-with-types** — same shape.
+
+**Status: Phase 0 (literature survey).** No code in this plan yet.
+
+## Why bidirectional, not HM (for the languages that need it)
+
+Five reasons HM doesn't fit these languages:
+
+1. **Subtyping.** HM unification requires equality of types; subtyping
+   requires a different judgment (`t ⊑ u`). Go's `interface{}` accepts any
+   concrete type that satisfies it — subtyping, not unification.
+2. **Mutation.** HM's let-polymorphism interacts pathologically with
+   mutable references (the value restriction). Go, Rust, TS all have
+   first-class mutation and need rules that handle it directly.
+3. **Annotations as ground truth.** Bidirectional treats declared types as
+   *given*, then propagates them. HM treats every type as a variable to be
+   solved. For languages where annotations are expected, bidirectional is
+   the natural shape.
+4. **Generics with constraints.** Go's type parameters carry constraints
+   (`type T comparable`); Rust has trait bounds. HM has typeclasses but
+   they're orthogonal to its constraint solver. Bidirectional weaves
+   constraints into the checking rules naturally.
+5. **Gradual typing.** TS's `any`, Hack's pessimistic mode, Python's
+   `Any` — gradual checking is built on bidirectional's "check or skip"
+   distinction. HM either checks or it doesn't.
+
+These languages collectively are the majority of new statically-typed code.
+Hosting them on lib/guest at all requires the bidirectional shape.
+
+## API surface (proposed — design only, will revise with second consumer)
+
+```
+;; --- judgments ---
+
+(synth ctx expr) -> {:type T} | {:error msg}
+  ;; "expr synthesises type T in context ctx."
+  ;; Used at function calls (arg types known), let bindings, literals.
+
+(check ctx expr expected-type) -> :ok | {:error msg}
+  ;; "expr checks against expected-type in context ctx."
+  ;; Used in function bodies (return type known), arguments (param type known),
+  ;; assignments (LHS type known).
+
+;; --- context ---
+
+(make-ctx) -> ctx
+(ctx-extend ctx name type) -> ctx          ;; functional update
+(ctx-lookup ctx name) -> type | nil
+
+;; --- pluggable rules ---
+
+(register-synth-rule! kit ast-tag synth-fn) -> nil
+  ;; ast-tag: a keyword identifying the AST node shape (eg. :call :let :lit-int)
+  ;; synth-fn: (ctx node) -> {:type T} | {:error msg}
+
+(register-check-rule! kit ast-tag check-fn) -> nil
+  ;; check-fn: (ctx node expected-type) -> :ok | {:error msg}
+
+(register-type-equiv! kit pred) -> nil
+  ;; pred: (t1 t2) -> bool. The "are these types compatible" predicate.
+  ;; For Go: structural-interface-match-or-equal.
+  ;; For TS: structural-equality-with-any-bidirectional-bottom.
+  ;; For Rust: nominal equality + trait obligations.
+
+(register-subtype! kit pred) -> nil
+  ;; pred: (sub super) -> bool. Optional; defaults to type-equiv.
+  ;; Go has no subtyping between concrete types but interface satisfaction
+  ;; is morally subtyping. TS has structural subtyping properly.
+
+(register-unify! kit unifier) -> nil
+  ;; Optional; for type-variable resolution (generics).
+  ;; unifier: (t1 t2 subst) -> {:subst s'} | {:error msg}
+
+;; --- driver ---
+
+(make-kit) -> kit
+(check-program kit ctx program) -> {:ok ctx'} | {:error msg path-to-error}
+```
+
+Design notes:
+- **The kit dispatches on AST tags**, which is what makes it pluggable. Each
+  language registers rules for its node types. There's no hardcoded set of
+  expression shapes in the kit.
+- **Synth and check are mutually recursive.** Inside a synth-rule for `call`,
+  the rule synthesises the function's type, then `check`s each argument
+  against the corresponding parameter type. Inside a check-rule for `lambda`,
+  the rule pulls argument types from the expected function type and
+  `synth`s the body. This pingponging is the bidirectional core.
+- **Pluggable type-equiv + subtype + unify** is the three-knob shape. Pierce
+  & Turner ("Local Type Inference") and Dunfield & Krishnaswami ("Sound and
+  Complete Bidirectional Typechecking") both factor it this way.
+- **No type variables in the core API.** Generics handling is a kit
+  *extension*: when a language registers a `unify` predicate, the kit
+  threads a substitution through synth/check. Languages without generics
+  (early Go) leave it null.
+- **Errors carry a path.** `{:error msg path}` where path is a list of AST
+  tags leading to the failure. Good error messages are why bidirectional is
+  practical; the kit must support them.
+
+## What's NOT in the kit (language-layer concerns)
+
+Per the chiselling discipline, the kit is the dispatch skeleton; rules stay
+in the language. Specifically:
+
+- **The literal type table.** Go's `42` is `untyped int` until contextualised;
+  TS's `42` is the literal type `42`. Each language ships its own.
+- **Specific subtyping rules.** Go's interface satisfaction is recursive
+  structural matching against method sets. TS's depends on object property
+  satisfaction. Each language ships its own predicate.
+- **Generics constraint solving.** Go's type-set-based constraints, Rust's
+  trait bounds, TS's conditional types — each is non-trivial and language-
+  specific. The kit threads a substitution; the language defines what's in
+  it.
+- **Effects, lifetimes, ownership.** Rust's borrow checker is not a type
+  checker in the bidirectional-kit sense — it's a separate dataflow pass.
+  Out of scope.
+- **Gradual fallback.** TS's `any` lets unchecked code coexist with checked
+  code. The kit supports this via "check returns :ok on a sentinel any-type"
+  but the sentinel is registered by the language.
+
+## Build order — phases
+
+### Phase 0 — Literature survey + Go's type system specifics ⬜
+- Read: Pierce & Turner "Local Type Inference" (2000); Dunfield & Krishnaswami
+  "Sound and Complete Bidirectional Typechecking for Higher-Rank Polymorphism"
+  (2013, 2019 revision); the Go language spec § "Types" + "Expressions".
+- Survey how Rust / TS / Kotlin / Scala 3 implement bidirectional in practice
+  (their compilers are open source). Note where they diverge.
+- Output: a short summary section "Bidirectional design space (captured
+  2026-MM-DD)" appended to this plan. Specifically: list every place
+  language implementations diverge, so we can predict which divergences will
+  show up between Go and the second consumer.
+- **Acceptance:** survey committed to this plan. No code.
+
+### Phase 1 — Go independent implementation ✅
+- During Go-on-SX, implement `lib/go/types.sx` from scratch. Do not write
+  with extraction in mind — write the simplest Go-specific bidirectional
+  checker.
+- Hit Go's distinctive type-system features: untyped constants, interface
+  satisfaction (structural), generics (Go 1.18 type parameters with type-set
+  constraints — defer this if scope explodes).
+- Pass Go's type-checker conformance tests.
+- **Acceptance:** Go conformance scoreboard includes type-checker tests, all
+  passing.
+- **Output:** one consumer. Two-language rule still not met; no extraction.
+- **Status (2026-05-28):** Done. `lib/go/types.sx` ships:
+    - **synth/check skeleton:** `go-synth` + `go-check` with first-class
+      error tags `(:type-error TAG ARGS...)`.
+    - **Untyped constants:** `:ty-untyped-int`, `:ty-untyped-float`,
+      `:ty-untyped-string`, `:ty-untyped-rune`. Canonical pitfall
+      handled — `var x float64 = 42 / 7` keeps untyped-int through
+      the divide. `go-unify-untyped` pairs untyped-int+float → float.
+    - **Interface satisfaction:** structural method-set match via
+      `#method/TYPE/NAME` mangled keys; `go-iface-satisfies?`.
+    - **Generics (Phase 7 closed):** `[T any]` / `[T, U any]` /
+      `[T any, U comparable]` parsed + type-checked; opaque
+      `(:ty-param NAME CONSTRAINT)` binding via
+      `go-extend-with-type-params`. Type-set constraints (`int |
+      float64`, `~int`) deferred — needs constraint-satisfaction
+      predicate (chiselled as the kit's 3rd pluggable predicate
+      slot).
+    - **Index synth:** `(:index OBJ IDX)` for slice/array/map → element
+      type. Same AST, 3 role-validators (the "shape is parser, role
+      is validator" lemma at scale).
+  102 types tests pass. Two-language rule still pending: the bidirectional
+  kit needs a SECOND consumer (TS/Rust/typed-Scheme) before extraction.
+  Phase 2's "pick + start" is the next sister-plan-owned step.
+
+### Phase 2 — Pick + start the second consumer ⬜
+- Decide between TS, Rust-subset, or typed-Scheme-subset. Recommendation:
+  **TypeScript** — most-different from Go (gradual, structural everywhere),
+  testing the kit's range maximally. Rust's lifetime/borrow machinery isn't
+  part of this kit, so a Rust port wouldn't actually exercise the kit very
+  hard.
+- Implement just enough of the second language to type-check a non-trivial
+  function. Don't port the whole language; port the type checker.
+- **Acceptance:** second consumer's type checker green on its small slice.
+
+### Phase 3 — Diff and proposed kit ⬜
+- Side-by-side: Go's checker vs the second consumer's checker. Where do they
+  agree (the kit). Where does each diverge (the language).
+- Draft `lib/guest/static-types-bidirectional/api.sx` (signatures only).
+- Compare against the API sketch in this plan. The API WILL change at this
+  step; that's the whole point of having two consumers.
+- **Acceptance:** revised API committed to this plan; agreement that both
+  consumers can adopt it.
+
+### Phase 4 — Implement the kit ⬜
+- `lib/guest/static-types-bidirectional/` with the agreed API. Kit tests in
+  `lib/guest/static-types-bidirectional/tests/` — using a minimal "toy"
+  language (synth-rule for `:int`, check-rule for `:lambda`) to verify the
+  dispatch skeleton works.
+- **Acceptance:** kit tests pass; both consumers' scoreboards still green
+  with their own implementations.
+
+### Phase 5 — Refactor both consumers to use the kit ⬜
+- Go: `lib/go/types.sx` becomes a thin layer over the kit — registers Go's
+  synth/check/equiv rules, calls `check-program`. Lifecycle code shrinks.
+- Second consumer: same exercise.
+- **No-regression gate:** both consumers' conformance scoreboards unchanged.
+- **Acceptance:** both `lib/<lang>/types.sx` files meaningfully smaller; kit
+  is doing real work.
+
+### Phase 6 — Documentation + chiselling diary ⬜
+- Document the API in lib/guest's README index.
+- Diary section in this plan: what we considered putting in the kit but
+  ended up keeping language-specific, and why.
+- **Acceptance:** documentation present; diary captured.
+
+## Two-language rule — gating
+
+Same as `lib-guest-scheduler.md`. The kit does not exist until both consumers
+independently work AND we've reviewed the diff AND we believe the shared
+skeleton is real. Rejected-extraction is a valid outcome.
+
+## Relationship to `lib/guest/hm.sx`
+
+Sister modules, not rivals. Some languages will use HM (full inference,
+let-polymorphism); some will use bidirectional (annotation-driven, subtyping-
+friendly). Some might use both — Scala-on-SX, hypothetically, has local-type-
+inference in expressions and global-HM-style constraint solving in implicit
+resolution. The kit boundaries are:
+
+- `hm.sx` — unification-based, whole-expression inference. Damas-Milner core.
+  Best for: ML family, Haskell, OCaml subset, Standard ML.
+- `static-types-bidirectional/` — synth/check judgments, pluggable equiv +
+  subtype. Best for: Go, Rust, TS, Kotlin, Swift, Scala 3, Hack.
+
+A language can call into both: bidirectional for the surface, HM-style
+unification inside generics resolution. That's actually how Scala 3 works.
+The kits compose; design accordingly.
+
+## Open questions
+
+- **Variance.** Go has none; TS has covariant/contravariant/bivariant; Rust
+  has variance markers per type parameter. Does the kit need a variance
+  predicate as a fourth pluggable knob? Probably yes, but defer until the
+  second consumer forces the question.
+- **Effect tracking.** Some bidirectional checkers (Koka, Eff, certain
+  capability-effect TS variants) track effects in types. Out of scope for
+  v1; the kit must not actively prevent it though.
+- **Refinement types.** TS has narrowing (`typeof x === "string"` refines
+  `x` to `string`); Hack and Flow are similar. These layer above the kit
+  (the kit's `check` returns a refined context as part of `:ok`). Sketch
+  this in Phase 3 if TS is the second consumer.
+- **Error recovery.** Real-world type checkers don't halt on first error;
+  they recover and continue to surface as many errors as possible. The kit
+  needs an error-accumulation mode. Design it in Phase 4.
+- **Performance.** For toy languages, naive synth/check is fine. For Go-
+  sized programs, the checker has to be memoised on synthesised types of
+  subexpressions. Not a v1 concern; flag if it bites.
+
+## Progress log
+
+_Newest first. Append one dated entry per milestone landed._
+
+- 2026-05-28 — **Go-on-SX consumer-side surface fully landed (609/609
+  tests across 7 suites).** This is the Phase-10 cross-reference
+  entry: with all of Go's lex+parse+types+eval+sched+stdlib+e2e
+  proven independent of the eventual kit, the type-system-kit
+  surface that emerged from this consumer is:
+
+    **Three pluggable predicates** (the kit's role-validator slots):
+    1. **`synth(ctx, expr) → ty | error`** — type synthesis from
+       expression structure. Go's instance handles literals,
+       binops, applications, indexing, composites, etc.
+    2. **`assignable?(got, expected) → bool`** — variance + untyped-
+       constant rules. Go's instance handles 3-tier untyped flow
+       (`untyped-int → int → float64` only in specific contexts).
+    3. **`constraint-satisfies?(ty, constraint) → bool`** — does
+       a type fit a constraint? Go: interfaces (structural method
+       set), `comparable`, `any`. TS would: structural subtyping.
+       Haskell: typeclass dictionary resolution. Rust: trait impl.
+
+    **Three orthogonal first-class-tag axes** (clean separation):
+    - **AST nodes** (parser output): `:func-decl`, `:literal`,
+      `:literal-string`, `:app`, `:index`, `:composite`, etc.
+    - **Value-type kinds** (evaluator output): `:go-struct`,
+      `:go-slice`, `:go-map`, `:go-chan`, `:go-fn`, `:go-method`,
+      `:go-builtin`, `:go-builtin-fn`, `:go-package`, `:go-panic`,
+      `:go-defer` — 11 kinds. All shape: `(:KIND PAYLOAD...)`.
+    - **Sentinel signals** (control-flow): `:return-value`, `:break`,
+      `:continue`, `:eval-error`, `:go-panic`.
+
+    All three axes use the same `(first x) == :TAG` discipline.
+    Kit's `kind?` and `kind-of` predicates work uniformly.
+
+    **The "shape is parser, role is validator" lemma**, validated
+    across THREE deliverables:
+    1. Binding-groups (`(:field NAMES TY)`): 6 consumers (struct
+       fields, var-decls, const-decls, params, receivers,
+       type-params), 5 distinct roles (value-typing, value-pinning,
+       constraint-binding, kind-binding, trait-binding).
+    2. Control-flow sentinels: same predicate dispatch at 4+ sites.
+    3. Index synthesis (`(:index OBJ IDX)`): same AST, 3 role-
+       validators (slice / array / map).
+
+    **v0 limitations the kit must lift** (durable in commit trail):
+    - Type-set constraints (`int | float64`, `~int`) — needs
+      constraint-satisfies? predicate real implementation.
+    - Type inference at call sites — Go's algorithm; currently
+      relies on type erasure at eval.
+    - nil-as-unbound — env-lookup needs an "absent" sentinel.
+    - First-char literal classification (was a bug; fixed by
+      `:literal-string` parser tag).
+
+    Next sister-plan-owned step is Phase 2 (pick + start second
+    consumer — recommendation: TypeScript). Two-language rule
+    still pending until the second consumer lands.
+
+- 2026-05-28 — From Go-on-SX Phase 8 first slice — **value-type
+  kinds confirm the "kind-tag + payload" shape as cross-runtime
+  primitive.** When the stdlib landed, packages joined the existing
+  registry of value-type kinds:
+
+    - `(:go-struct TY-NAME FIELDS)` — composite by-field state
+    - `(:go-slice ELEMS)` — sequential by-position state
+    - `(:go-map ENTRIES)` — keyed state
+    - `(:go-chan ACCESSORS)` — closure-bundle (channel)
+    - `(:go-fn PARAMS BODY)` — user function value
+    - `(:go-method RECV PARAMS BODY)` — method value
+    - `(:go-builtin NAME)` — name-dispatched builtin
+    - `(:go-builtin-fn FN)` — closure-dispatched builtin (NEW)
+    - `(:go-package NAME ENTRIES)` — namespace value (NEW)
+    - `(:go-panic V)` — unwinding-control value
+    - `(:go-defer CALLEE ARGS)` — frame-cleanup record
+
+  All eleven kinds use the same `(:KIND-TAG PAYLOAD...)` shape.
+  None of them are AST nodes (those are `:func-decl`, `:literal`,
+  etc.); they're VALUES the evaluator produces. The orthogonal axes
+  the kit should care about:
+
+    1. **AST nodes** (parser output, evaluator input)
+    2. **Value-type kinds** (evaluator output, predicate input)
+    3. **Sentinel signals** (control-flow: return/break/panic/etc.)
+
+  All three subscribe to the same first-class-tag discipline:
+  `(first x)` answers "what kind is this?" and the rest is payload.
+  The kit's `kind?` and `kind-of` predicates work uniformly across
+  all three axes.
+
+  For the bidirectional checker specifically, this means the
+  `assignable?(got, expected)` predicate isn't special — it's just
+  one predicate that operates on value-type kinds. The `synth` /
+  `check` skeleton processes AST nodes; the validators it calls
+  operate on value-type kinds. Clean separation: AST is what you
+  parse, value-types are what you check, sentinels are what you
+  propagate. None of them bleed into each other.
+
+  Phase 7's index-synth and Phase 8's package-lookup both fit the
+  same template: AST kind triggers a synth/lookup, returning a
+  value-type kind. The validator-table dispatch from earlier diary
+  entries is the right abstraction; the kit should expose it as a
+  PROTOCOL (Go would phrase this as an interface, Haskell as a
+  typeclass) so all three axes can be extended without modifying
+  the kit.
+
+- 2026-05-28 — From Go-on-SX Phase 7 closing — **the "shape is the
+  parser, role is the validator" lemma.** After landing canonical
+  generic Map/Filter/Reduce/First plus 25+ typer tests, a clear
+  pattern has emerged across THREE distinct deliverables of the
+  Go-on-SX loop:
+
+    1. **Binding-groups** (struct fields / var-decls / params /
+       receivers / type-params): SAME parser, SAME `(:field NAMES
+       TY)` shape, 5 different validators based on what role TY
+       plays.
+
+    2. **Control-flow sentinels** (return-value / break / continue /
+       eval-error / go-panic): SAME `(go-panic? r)`-style dispatch
+       at 4+ AST control-flow sites, each calling the same predicate
+       list — would collapse to a single `propagates?` helper.
+
+    3. **Index synthesis** (`xs[0]` for slice / array / map): SAME
+       `(:index OBJ IDX)` AST, 3 element-type extraction rules
+       dispatching on OBJ's type. The validator differs per role,
+       but the parser shape is one.
+
+  The recurring lemma: **the kit's primary primitive is shape
+  recognition (parser + AST); the kit's secondary primitive is a
+  role-validator dispatch table.** Consumers (Go, Erlang, future
+  guests) plug their semantics into the role table; they never need
+  to define new shapes for things that already match an existing
+  AST.
+
+  Architectural payoff: at extraction time, the kit's API should
+  expose:
+
+    - `parse-XXX` → AST shape (one per shape)
+    - `validate-AST(role, ctx)` → either ctx or error (one per role)
+    - `dispatch-table(role)` → which-validator-fires-for-this-AST
+
+  Reuse across guest evaluators happens automatically because the
+  shape is shared. New guests only register new role handlers; they
+  don't extend the parser.
+
+  Concretely for the bidirectional checker: the synth/check skeleton
+  is the shape; assignable? and constraint-satisfies? are roles.
+  Adding a new language means adding a row to the role table, not a
+  column to the AST.
+
+- 2026-05-28 — From Go-on-SX Phase 7 foundation — **the field
+  binding-group is a cross-deliverable shape, confirmed by its 6th
+  consumer (type-parameter lists).** Previously documented uses:
+  struct fields, var-decls, const-decls, func params, method
+  receivers. Now type-parameters re-use the EXACT same parser
+  (`gp-parse-decl-param-group`) and the same `(list :field NAMES TY)`
+  shape — only the meaning of TY differs (it's a *constraint* type,
+  not a value type).
+
+  This is the strongest evidence yet that the kit's primary shape
+  should be a generic `binding-group<TyKind>` parametric over the
+  role TY plays. Five roles emerge:
+
+    1. **value-typing** (struct fields, var-decls, params, receivers):
+       TY is the type of values that bind to NAMES.
+    2. **value-pinning** (const-decls): TY is the type of compile-
+       time-known values.
+    3. **constraint-binding** (type-parameter lists): TY is a
+       constraint that the type-variables NAMES must satisfy.
+    4. **kind-binding** (anticipated for higher-kinded types):
+       TY would be a kind that type-constructors NAMES inhabit.
+    5. **trait-binding** (anticipated for Rust-style impl blocks):
+       TY would be the trait the implementations NAMES provide.
+
+  All five share parser + AST shape; they differ in (a) which
+  predicate validates the relationship between NAMES and TY, and
+  (b) what scope NAMES are visible in. The kit should expose a
+  single `parse-binding-group` consumer and let each role plug in
+  its own validator. This is the same lesson the assignable? +
+  constraint-satisfies? pluggable-predicate work surfaced — kit
+  primitives are SHAPES, validators are PLUGINS.
+
+  Concretely: when the kit extracts, the bidirectional checker
+  exposes `extend-ctx-with-binding-group(role, group)` where role
+  selects the validator. Go's type-params bind via role=
+  "constraint-binding"; struct fields bind via "value-typing".
+  Erlang's pattern bindings will bind via something else again.
+
+- 2026-05-27 — From Go-on-SX Phase 3 — **interface satisfaction** is the
+  third pluggable predicate the kit should ship, alongside `assignable?`
+  and the synth/check skeleton. Go's structural-and-silent
+  satisfaction is one instance; Haskell's typeclass dictionary
+  resolution, Rust's trait `impl` lookup, and TS's structural subtyping
+  are others — all answer the same question with different machinery:
+  "does this value-type fit this constraint-type?"
+
+  Kit proposal:
+
+  ```
+  (constraint-satisfies? CTX VALUE-TY CONSTRAINT-TY) → bool
+  ```
+
+  Different consumers plug in different implementations:
+    * Go: walk interface methods, lookup `#method/T/NAME`.
+    * Haskell: typeclass instance resolution (with global instance table).
+    * Rust: trait impl lookup with where-clause bound check.
+    * TS: structural subtyping with property-by-property comparison.
+
+  The judgment skeleton uses it during `check` when the expected type
+  is itself an interface/constraint:
+
+  ```
+  check Γ e EXPECTED →
+    if EXPECTED is a constraint type:
+      let GOT = synth Γ e
+      if constraint-satisfies? Γ GOT EXPECTED then :ok else mismatch
+    else: use the assignable? path
+  ```
+
+  Source: Go-on-SX commit landing `go-iface-satisfies?` in
+  `lib/go/types.sx` with the `#method/T/NAME` mangled-key storage scheme.
+
+- 2026-05-27 — Follow-up from Phase 3 scaffold: **assignability** has
+  landed as a separate relation from structural equality. Go's
+  untyped-constant flow (`var x float64 = 42 / 7` — 42/7 stays untyped
+  int, then converts to float64) is one instance of a broader pattern:
+  the value's "natural" type isn't quite the slot's type, but they're
+  compatible under a per-language relation.
+
+  **Design insight for the kit**: `check` should *not* call `equal?`
+  on the synthesised vs expected types. It should call a pluggable
+  `assignable?` predicate that each consumer supplies:
+
+  ```
+  (check CTX EXPR EXPECTED) →
+    let GOT = (synth CTX EXPR)
+    if (assignable? GOT EXPECTED) :ok else (:mismatch EXPECTED GOT)
+  ```
+
+  Go's `assignable?` handles untyped constants → numeric-type
+  conversion. TS would supply structural subtyping (`{a: number, b:
+  string}` assignable to `{a: number}`). Rust supplies lifetime-aware
+  type identity with implicit `&T -> &U` where `T: Deref<U>`. None of
+  the consumers need to rewrite synth or the judgment skeleton — only
+  swap in their variance discipline.
+
+  Concretely the kit interface looks like:
+
+  ```
+  (check-with assignable? CTX EXPR EXPECTED) — kit primitive
+  ```
+
+  Source: Go-on-SX commit landing `go-type-assignable?` in
+  `lib/go/types.sx`.
+
+- 2026-05-27 — From Go-on-SX Phase 3 scaffold (`lib/go/types.sx` first
+  cut): the **independent synth/check shape** has landed. Two judgments,
+  both consuming a context-as-value:
+
+  ```
+  (go-synth CTX EXPR)             → TYPE-NODE | (:type-error TAG ...)
+  (go-check CTX EXPR EXPECTED)    → :ok       | (:type-error TAG ...)
+  ```
+
+  Context is an association list of `(NAME TYPE)` bindings; the
+  load-bearing extension primitive is `go-ctx-extend-field` which takes
+  a `(:field NAMES TYPE)` binding-group node and binds every NAME to
+  TYPE. This validates the earlier cross-deliverable observation: the
+  parser produces `:field` once, the type checker consumes it once,
+  same shape across struct fields / func params / var-decls.
+
+  **Design insight for the kit**: the synth/check pair is the canonical
+  judgment skeleton. `check` deferring to `synth + structural-equality`
+  is the v0 default that every consumer overrides for subtype-ish
+  relationships. The kit's `check` should accept a `subtype?` predicate
+  parameter so Go (untyped-constant flow), TS (variance), and Rust
+  (lifetime subtyping) each plug in their own variance discipline
+  without rewriting the whole judgment. The kit's `synth` stays uniform.
+
+  Error shape `(:type-error TAG ...)` with first-class tags
+  (`:unbound`, `:mismatch`, `:unsupported-synth`) gives consumers and
+  IDE tooling structured errors to dispatch on. Untyped-constant flow
+  and binop-synth — the canonical Go pitfall (`var x float64 = 42 / 7`)
+  — arrive next. Source: Go-on-SX commit landing `lib/go/types.sx`.
+
+- 2026-05-27 — From Go-on-SX Phase 2 (func decls landing): parser-side
+  observation that's load-bearing for any bidirectional checker. Go's
+  parser ended up with a single shape — `(list :field NAMES TYPE)` —
+  that recurs in five contexts: struct fields, var decls, const decls,
+  func params, and method receivers. Each represents "these names are
+  bound to this type" — exactly the input shape `check` would consume
+  to seed the context with typed bindings.
+
+  **Design insight**: the canonical bidirectional checker should accept
+  `:field`-shaped AST nodes uniformly across these contexts rather than
+  each context defining a bespoke shape. The kit's `check Γ e T`
+  judgment can dispatch on the enclosing form (struct vs var vs
+  func-param vs ...) but the local per-binding shape stays identical.
+  This is what statically-typed guest #2 should also produce — if it
+  does, the kit can ship a `field-bindings → context-extension` helper
+  that all consumers reuse. Cross-ref Go-on-SX plan's Blockers entry on
+  `ast-binding-group` for the parallel AST-kit proposal that supports
+  this. Source: Go-on-SX commit `parse.sx — func declarations`.
+
+- 2026-05-26 — Plan drafted as design diary. Phase 0 unstarted. Gated on
+  Go-on-SX (first consumer) and a TBD second consumer (recommendation:
+  TypeScript). No code yet — kit cannot exist before two consumers do.

plans/mod-on-sx.md

@@ -0,0 +1,112 @@
+# mod-on-sx: Moderation on Prolog
+
+rose-ash needs moderation infrastructure: reports flagged by users, automated
+classifications (spam, abuse), tiered escalation (auto → human → appeal), audit
+trails. Each decision is the conclusion of a backtracking search over evidence and
+policy rules — exactly what Prolog does.
+
+Where acl-sx says "may this happen?", mod-sx says "should this stay?" The former is
+a positive decision (proof of grant); the latter often a negative one (proof of
+violation), and policy chains naturally backtrack: if the first rule doesn't apply,
+try the next.
+
+End-state: a Prolog-on-SX layer for moderation policy declaration and evaluation,
+with persistent report lifecycle, audit log, escalation state machine, and
+federation extension.
+
+## Status (rolling)
+
+`bash lib/mod/conformance.sh` → **0/0** (not yet started)
+
+## Ground rules
+
+- **Scope:** only touch `lib/mod/**` and `plans/mod-on-sx.md`. Do **not** edit
+  `spec/`, `hosts/`, `shared/`, `lib/prolog/**`, or other `lib/<lang>/`. You may
+  **import** from `lib/prolog/` (public API in `lib/prolog/prolog.sx`); do **not**
+  modify Prolog.
+- **Shared-file issues** go under "Blockers" with a minimal repro; do not fix here.
+- **SX files:** use `sx-tree` MCP tools only.
+- **Architecture:** policies are Prolog rules over `report(...)` and `evidence(...)`
+  facts. Decisions are query results. Proof trees become audit records. The state
+  machine for report lifecycle is separate (an SX module on top).
+- **Shared with acl-sx:** rule-engine plumbing may be liftable into `lib/guest/`.
+  Watch for it; flag in Progress log but do not extract until both subsystems are
+  past Phase 2.
+- **Commits:** one feature per commit. Keep Progress log updated and tick boxes.
+
+## Architecture sketch
+
+```
+Report                                  Decision
+  {:by :about :reason :at}                {:action :proof :next-state}
+        │                                       ▲
+        ▼                                       │
+lib/mod/schema.sx                       lib/mod/engine.sx
+  — report/4, evidence/2,                 — query Prolog with report fact
+    classification/3 predicates             — extract proof tree
+        │                                       ▲
+        ▼                                       │
+lib/mod/policy.sx                       lib/mod/lifecycle.sx
+  — rule syntax → Prolog                  — state machine
+  — action heads:                         — open → triaged → decided
+    {:keep :hide :remove                  — appeal handling
+     :escalate :ban}                            │
+        │                                       ▼
+        ▼                                lib/mod/audit.sx
+lib/mod/api.sx                            — append-only decision log
+  — (mod/report ...)                      — proof tree persistence
+  — (mod/decide report)                   — query API
+  — (mod/appeal id)
+        │
+        ▼
+lib/mod/fed.sx
+  — cross-instance reports via fed-sx
+  — decision sharing / trust model
+```
+
+## Phase 1 — Report representation + simple policy
+
+- [ ] `lib/mod/schema.sx` — `report(id, by, about, reason)`, `evidence(id, kind, val)`,
+  `policy-action(report, action)` predicates as Prolog facts/rules
+- [ ] `lib/mod/policy.sx` — rule declarations: `(defrule action :when conditions)`
+  desugars to Prolog clause
+- [ ] `lib/mod/engine.sx` — `(decide report-id)` runs Prolog query, returns first
+  matching action
+- [ ] `lib/mod/api.sx` — `(mod/report by about reason)`, `(mod/decide id)`
+- [ ] `lib/mod/tests/decide.sx` — 15+ cases: spam keyword → hide, repeated reports →
+  escalate, no rule matches → keep
+- [ ] `lib/mod/scoreboard.{json,md}`
+- [ ] `lib/mod/conformance.sh`
+
+## Phase 2 — Evidence + audit trail
+
+- [ ] evidence accumulation — additional facts asserted before query
+- [ ] proof tree from Prolog derivation tree
+- [ ] `lib/mod/audit.sx` — append-only log (decision + proof + evidence snapshot)
+- [ ] `(mod/audit id)` retrieval
+- [ ] `lib/mod/tests/audit.sx` — proof correctness, trail completeness
+
+## Phase 3 — Escalation + lifecycle state machine
+
+- [ ] state machine: `:open → :triaged → :decided → :appealed → :final`
+- [ ] auto-tier: first-pass rules decide quick cases
+- [ ] human-tier: rules that emit `:escalate` move to next state
+- [ ] appeal: re-runs with appeal evidence, may override prior decision
+- [ ] `(mod/appeal id new-evidence)` API
+- [ ] `lib/mod/tests/escalation.sx` — full lifecycle traversal cases
+
+## Phase 4 — Federation
+
+- [ ] cross-instance reports — peer raises report about local content (or vice versa)
+- [ ] decision sharing — actions taken locally propagate to peers via fed-sx
+- [ ] trust model — peer's decision is advisory unless `(trust peer :mod)` is granted
+- [ ] revocation — undo applied moderation if proof was invalidated
+- [ ] `lib/mod/tests/fed.sx` — federated decision chains (mock fed-sx in tests)
+
+## Progress log
+
+(loop fills this in)
+
+## Blockers
+
+(loop fills this in)

plans/persist-on-sx.md

@@ -0,0 +1,119 @@
+# persist-on-sx: Durable state on the SX kernel
+
+> **DRAFT outline.** Foundation subsystem — the durable substrate the other five
+> currently fake with in-memory mutable lists. Build this first.
+>
+> **"persist" = persistence / data store, NOT the shop.** The shop/commerce vertical
+> is `commerce-on-sx`.
+
+rose-ash needs durable state: every subsystem (feed log, flow store, mod audit,
+search index, acl grants, sessions) today hand-rolls an in-memory structure that
+vanishes on restart. `persist-on-sx` is the one durable substrate they share. It
+lives directly on the SX kernel's IO-suspension primitives (`perform`/`cek-resume`
+— the third CEK phase) so a read/write `perform`s and the kernel persists at the
+boundary. Concrete storage backends are injected.
+
+## Does it cover ALL persistence? No — and on purpose.
+
+Event-sourcing-everything is a known trap (replay cost, event schema evolution,
+awkward ad-hoc queries, 5MB images in a log). So persist owns the **durable
+source-of-truth substrate**, exposed as **two facets over one backend protocol**,
+with two things explicitly delegated out:
+
+| Shape | Owner | Notes |
+|-------|-------|-------|
+| **Event streams** (append-only, history matters) | persist — **log facet** | feed activities, mod audit, order ledger, flow state, content edits |
+| **Current-state values** (KV / document, no history) | persist — **kv facet** | profiles, stock counts, config, session blobs; also where projections materialize |
+| **Snapshots / read models** (derived, queryable) | persist — projections → kv/log | rebuildable from the log; persisted so you don't replay to answer a query |
+| **Blobs / large objects** (images, media) | **delegated** → content-addressed store (artdag/IPFS already) | persist stores the *reference/CID*, never the bytes |
+| **Cache** (ephemeral, evictable) | **out of scope** | not persistence — different lifecycle (Redis-shaped) |
+| **Ad-hoc relational query** | the subsystem, over a projected read model | the log is bad at "all orders by X in March"; project into a queryable kv/SQL backend |
+
+So: persist is the **single durable substrate** for state that's either a stream of
+changes or a current value — but it does **not** force everything into an event
+log, it does **not** hold blobs (only their content-addressed refs), and it does
+**not** do caching. Those boundaries are the whole point of calling it a substrate
+rather than "the database."
+
+End-state: `log` (append/read streams) + `kv` (get/put/delete by key) facets, an
+injectable backend protocol (mem → file → Postgres → IPFS-ref), pure projections
+with incremental snapshots, optimistic concurrency, and a subscription hook so
+read models (feeds, indices, audit logs) update incrementally.
+
+## Status (rolling)
+
+`bash lib/persist/conformance.sh` → **0/0** (not yet started)
+
+## Ground rules
+
+- **Scope:** only `lib/persist/**` and `plans/persist-on-sx.md`. May **import** the
+  kernel's IO-suspension surface (`perform`, platform IO ops) — verify what's
+  exported first. Do not add host primitives; a missing durable IO op is a Blockers
+  entry (it belongs in `hosts/`, out of scope).
+- **Architecture:** an event is `{:stream :seq :type :at :data}`; the log is an
+  ordered append-only vector; a projection is `(fold step seed events)`; a kv value
+  is `(get/put/delete key)`. Both facets sit on one injected backend
+  `{:append :read :kv-get :kv-put :snapshot-read :snapshot-write}`. The in-memory
+  backend is the test default; real backends wire in unchanged.
+- **Determinism:** replay is pure — same log → same state, always. No clocks or
+  randomness inside projections; time lives on the event.
+- **Blobs:** store the content-address/CID and metadata; never the bytes. The blob
+  backend is a separate injected dependency.
+- **Commits:** one feature per commit. Progress log + tick boxes.
+
+## Architecture sketch
+
+```
+Command / write                         Read model / value
+  (append stream type data)               (project stream step seed)
+  (kv-put key value)                       (kv-get key)
+        │                                       ▲
+        ▼                                       │
+lib/persist/event.sx                    lib/persist/project.sx
+  — {:stream :seq :type :at :data}        — fold step seed; incremental from snapshot
+        │                                       ▲
+        ▼                                       │
+lib/persist/log.sx   lib/persist/kv.sx   lib/persist/snapshot.sx
+  — append/read       — get/put/delete    — checkpoint; replay = snapshot + tail
+  — optimistic seq    — current-state
+        │                  │                    ▲
+        └──────────────────┴── (perform → backend) ───┘
+                            │
+lib/persist/backend.sx              lib/persist/api.sx
+  — injected protocol                 — (persist/append) (persist/project)
+  — mem | file | pg | ipfs-ref        — (persist/kv-get/put) (persist/subscribe)
+        │
+        └── blobs → content-addressed store (artdag/IPFS), by reference only
+```
+
+## Phase 1 — Log + kv + in-memory backend
+- [ ] `event.sx` — event record, stream/seq helpers
+- [ ] `backend.sx` — injectable protocol + in-memory impl (log + kv)
+- [ ] `log.sx` — `append` (optimistic seq), `read`, `read-from`
+- [ ] `kv.sx` — `get`/`put`/`delete` current-state
+- [ ] `api.sx` + tests + scoreboard + conformance.sh
+
+## Phase 2 — Projections + subscriptions
+- [ ] `project.sx` — `(project stream step seed)`, incremental fold
+- [ ] subscription hook — projection / kv read model re-runs on append
+- [ ] concurrency conflict surfaced as a real result, not a crash
+
+## Phase 3 — Snapshots + replay
+- [ ] `snapshot.sx` — checkpoint a projection; replay = snapshot + tail
+- [ ] compaction policy; replay-determinism tests
+
+## Phase 4 — Durable backends via kernel IO
+- [ ] file/log backend driven through `perform` (IO-suspension boundary)
+- [ ] blob backend interface (store ref/CID; bytes live in artdag/IPFS)
+- [ ] crash/restart replay test (mock IO platform)
+- [ ] migration notes for swapping mem → durable under a live subsystem
+
+## Consumers (post-foundation, not in scope here)
+feed/-log, flow store, mod/audit, search index, acl grants, identity sessions all
+become `persist` log or kv. Track each migration in that subsystem's plan.
+
+## Progress log
+(loop fills this in)
+
+## Blockers
+(loop fills this in)

plans/search-on-sx.md

@@ -0,0 +1,106 @@
+# search-on-sx: Full-text + structured search on Haskell
+
+rose-ash needs search across pages, posts, threads, federated content. Tokenize,
+index, query, rank, filter by visibility. Typed ADTs make query parsing clean,
+lazy lists make posting-list iteration efficient, and Haskell-on-SX is at 1514/1514.
+
+End-state: a Haskell-on-SX layer with inverted index, query AST, boolean +
+phrase + ranked queries (TF-IDF, BM25), ACL-aware post-filter, and a federation
+extension that merges per-peer indices.
+
+## Status (rolling)
+
+`bash lib/search/conformance.sh` → **0/0** (not yet started)
+
+## Ground rules
+
+- **Scope:** only touch `lib/search/**` and `plans/search-on-sx.md`. Do **not** edit
+  `spec/`, `hosts/`, `shared/`, `lib/haskell/**`, or other `lib/<lang>/`. You may
+  **import** from `lib/haskell/` (public API in `lib/haskell/haskell.sx`); do **not**
+  modify Haskell.
+- **Shared-file issues** go under "Blockers" with a minimal repro; do not fix here.
+- **SX files:** use `sx-tree` MCP tools only.
+- **Architecture:** index = `Map Term [(DocId, [Pos])]`. Query AST = ADT. Eval =
+  fold of posting lists with set ops + ranking math. Ranking is pure (no IO until
+  result emission).
+- **Commits:** one feature per commit. Keep Progress log updated and tick boxes.
+
+## Architecture sketch
+
+```
+Document                               Query
+  {:id :text :tags}                       "alice AND bob OR phrase \"x y\""
+        │                                       │
+        ▼                                       ▼
+lib/search/tokenize.sx                  lib/search/parse.sx
+  — tokenize :: Text → [Term]             — parse :: Text → Query
+  — normalize (lowercase, strip)          — Query = Term | And | Or
+  — (optionally) stem                              | Not | Phrase
+        │                                       │
+        ▼                                       ▼
+lib/search/index.sx                     lib/search/eval.sx
+  — Map Term [(DocId, [Pos])]             — eval :: Index → Query → [DocId]
+  — insert / delete / lookup              — boolean + phrase positions
+  — persistence (optional later)                 │
+        │                                       ▼
+        └────────────────► lib/search/rank.sx
+                            — TF-IDF / BM25 scoring
+                            — top-N
+                                  │
+                                  ▼
+                          lib/search/api.sx
+                            — (search/index doc)
+                            — (search/query q)
+                            — (search/top n q)
+                                  │
+                                  ▼
+                          lib/search/fed.sx
+                            — federated query (merge peer results)
+                            — ACL filter post-merge
+```
+
+## Phase 1 — Tokenize + index
+
+- [ ] `lib/search/tokenize.sx` — normalize (lowercase, strip punctuation), split on
+  whitespace, return positions
+- [ ] `lib/search/index.sx` — inverted index data structure (typed `Map` from
+  haskell lib); `insert`, `delete`, `lookup`
+- [ ] `lib/search/api.sx` — `(search/index doc)`, `(search/lookup term)`
+- [ ] `lib/search/tests/index.sx` — 15+ cases: tokenize, insert + lookup, update,
+  delete, multi-doc
+- [ ] `lib/search/scoreboard.{json,md}`
+- [ ] `lib/search/conformance.sh`
+
+## Phase 2 — Query AST + boolean evaluation
+
+- [ ] Query ADT: `Term Text | And Query Query | Or Query Query | Not Query |
+  Phrase [Text]`
+- [ ] `lib/search/parse.sx` — query syntax parser (boolean operators, quoted phrases)
+- [ ] `lib/search/eval.sx` — boolean eval via set ops on posting lists
+- [ ] phrase eval — adjacency check using positions
+- [ ] `lib/search/tests/boolean.sx` — 25+ cases: term, and, or, not, phrase,
+  composition, parser edge cases
+
+## Phase 3 — Ranking
+
+- [ ] document frequency tracking — extend index with `df` per term
+- [ ] TF-IDF scoring
+- [ ] BM25 scoring (configurable k1, b)
+- [ ] top-N retrieval (heap-based)
+- [ ] `lib/search/tests/rank.sx` — 20+ cases: TF-IDF behavior, BM25 vs TF-IDF,
+  ranking stability, top-N correctness
+
+## Phase 4 — ACL filter + federation
+
+- [ ] post-filter — each candidate result tested via `(acl/permit? viewer :read doc)`
+- [ ] federated query — fan out to peer instances via fed-sx, merge results
+- [ ] merge policy — interleave by rank, dedupe by `(peer, doc-id)`
+- [ ] `lib/search/tests/integration.sx` — federated search with ACL filter
+
+## Progress log
+
+(loop fills this in)
+
+## Blockers
+
+(loop fills this in)