@@ -3158,7 +3158,7 @@ discharged:
     barrier: "DISCHARGED 2026-06-17 — cl-format is COMPLETE on the minimal cl-run (no upstream architecture rewrite needed). chunk1 ~C/~&, chunk2 ~P/~*/~T, chunk3 ~$/~E/~G (full CLtL Steele), chunk4a ~[~;~] conditional (nesting-aware via cl-close-nested + cl-clauses), chunk4b ~<~;~> justification (full ~mincol,colinc,minpad,padchar< + :/@ + ~^ drop). All clj-oracle byte-matched; e2e phase14_cl_format 82 cases + clj_corpus/cl_format_float.txt 13 pins. Remaining gaps are documented divergences that RAISE cleanly: the `V`/`#` runtime-valued directive params (D-458) and the ~<…~:;…~> pretty-print column mode (needs a column-tracking writer cljw's pr-alias pprint lacks). cljw pprint.clj stayed a minimal cl-run reimpl throughout — the prior 'ADR-level full port' assessment was wrong."
     last_reviewed: "2026-06-17"
   - id: "D-374"
-    status: "DISCHARGED 2026-06-16 (gaps/bugs sweep). cljw now unrolls a top-level `(do …)`: each child is analyzed+evaluated IN SEQUENCE, so an effect in an earlier child (`(import …)` / `(defmacro …)`) is visible to a later child's ANALYSIS — `(do (defmacro m [] 42) (m))` → 42 (was a 'macro Var not callable' analyze error), `(do (import …) (instance? … x))` matches clj. Impl: driver.zig `topLevelDoChildren(form)` detector + `evalTopLevelForm` (recursive; do's value = last child, empty `(do)`→nil) routed through ALL form-loading paths — runner.zig (`-e`/main), loader.zig (file load/require; per-leaf chunk to the `cljw build` sink so replay order is preserved), evaluator.zig (`--compare` dual-backend oracle, backend-parameterized twin), driver.evalValue (so `(eval '(do …))` unrolls), bootstrap.zig (consistency; no-op for hand-written core). e2e phase14_eval (5 new cases: defmacro-then-use / def-then-use / value-is-last / nested-do / eval-of-do) + smoke green (diff oracle ×2 + corpus 3206 + zlinter). RESIDUAL (narrow, not re-filed): a MACRO expanding to a top-level `(do …)` is not unrolled (only a LITERAL `do` head is matched); clj macroexpands first. No real case hits it (declare→do-of-defs needs no effect-sequencing). ORIGINAL: open (2026-06-10, surfaced by the D-373 corpus). cljw does NOT unroll a top-level `(do …)` — it analyzes the whole form before evaluating, so a side-effecting form and a later form that depends on its effect cannot share one compilation unit. Concretely: `(do (import 'java.io.BufferedReader) (instance? BufferedReader x))` → cljw NameError (BufferedReader resolved at analyze time, before the import effect ran); clj → true (clj treats each top-level-`do` child as if a separate top-level form, compiling+evaluating in sequence). This was MASKED for instance? until D-373: the old macro quoted the class symbol so it resolved at EVAL time (after import). The REALISTIC forms — `(ns … (:import …))` then use, OR separate top-level forms — both work in cljw and match clj (verified). Only the single-`-e`-`(do (import …) (use …))` bundle diverges. Removed the artifact corpus line (io_stream_class.txt:25) that depended on the old late-binding; the divergence is a bug scheduled for fix when top-level-do-unrolling lands."
+    status: "CORRECTION 2026-08-12 (Discussion #14): the discharge below claimed the unroll was 'routed through ALL form-loading paths' and listed five. It was not — `src/app/eval_session.zig` (backing BOTH `cljw repl` and `cljw nrepl`) and `src/app/builder.zig` (two loops, backing `cljw build` and the bundled-.clj AOT) each kept their own analyze-then-eval loop, so a top-level `(do (require …) (use …))` failed in the REPL, over nREPL, and at build time while `-e` worked. An external user hit it (three entry points diverging) rather than the gate. This is the D-177 false-positive-discharge class — coverage was LISTED, not probed. Now genuinely closed: eval_session routes through `driver.evalTopLevelForm` (74db35d0, contributor fix), builder enumerates via the new `driver.topLevelLeaves` (fd5f0449), and the claim is now MECHANICAL rather than narrative — `scripts/check_entrypoint_surface.sh` fails if any of the four form-stream sites stops calling the shared driver, and `test/e2e/entrypoint_eval_parity.sh` diffs 8 programs across all six entry points with no expected values written down. ORIGINAL DISCHARGE (2026-06-16, gaps/bugs sweep). cljw now unrolls a top-level `(do …)`: each child is analyzed+evaluated IN SEQUENCE, so an effect in an earlier child (`(import …)` / `(defmacro …)`) is visible to a later child's ANALYSIS — `(do (defmacro m [] 42) (m))` → 42 (was a 'macro Var not callable' analyze error), `(do (import …) (instance? … x))` matches clj. Impl: driver.zig `topLevelDoChildren(form)` detector + `evalTopLevelForm` (recursive; do's value = last child, empty `(do)`→nil) routed through ALL form-loading paths — runner.zig (`-e`/main), loader.zig (file load/require; per-leaf chunk to the `cljw build` sink so replay order is preserved), evaluator.zig (`--compare` dual-backend oracle, backend-parameterized twin), driver.evalValue (so `(eval '(do …))` unrolls), bootstrap.zig (consistency; no-op for hand-written core). e2e phase14_eval (5 new cases: defmacro-then-use / def-then-use / value-is-last / nested-do / eval-of-do) + smoke green (diff oracle ×2 + corpus 3206 + zlinter). RESIDUAL (narrow, not re-filed): a MACRO expanding to a top-level `(do …)` is not unrolled (only a LITERAL `do` head is matched); clj macroexpands first. No real case hits it (declare→do-of-defs needs no effect-sequencing). ORIGINAL: open (2026-06-10, surfaced by the D-373 corpus). cljw does NOT unroll a top-level `(do …)` — it analyzes the whole form before evaluating, so a side-effecting form and a later form that depends on its effect cannot share one compilation unit. Concretely: `(do (import 'java.io.BufferedReader) (instance? BufferedReader x))` → cljw NameError (BufferedReader resolved at analyze time, before the import effect ran); clj → true (clj treats each top-level-`do` child as if a separate top-level form, compiling+evaluating in sequence). This was MASKED for instance? until D-373: the old macro quoted the class symbol so it resolved at EVAL time (after import). The REALISTIC forms — `(ns … (:import …))` then use, OR separate top-level forms — both work in cljw and match clj (verified). Only the single-`-e`-`(do (import …) (use …))` bundle diverges. Removed the artifact corpus line (io_stream_class.txt:25) that depended on the old late-binding; the divergence is a bug scheduled for fix when top-level-do-unrolling lands."
     category: "eval-semantics"
     barrier: |-
       cljw lacks top-level-`do` unrolling (clj compiles+evals each child of a
 
@@ -18,36 +18,18 @@
   lookbehind / `\A\z\Z` / class algebra, multidim aget/aset, and the GC
   stops taxing long-running programs 2-4x — D-571/573/446/447 discharged).
   CHANGELOG is the release-history SSOT.
-- **First task on resume**: the PERF CAMPAIGN continues — D-450's status
-  head is the live brief. State 2026-08-06: ADR-0184 LANDED (Functions are
-  collectable GC cells; the 15.5M-immortal-closure leak is dead), rush-hour
-  17.9 s → **12.3 s** (clj gap 17x → 11.5x), GC share ~7% (inside the
-  ADR-0183 target). O-055 budget-TLV hoist also landed; TraceRef +
-  threshold-multiplier experiments REFUTED (recorded in D-450 — do not
-  re-run). Next step is a RE-PROFILE (the 2026-08-05 attribution is stale)
-  via `sample` on the BFS (`cd ~/Documents/MyProducts/cw-arcade/apps/
-  rush-hour && cljw -e "(require '[rush-hour.generator :as g])
-  (g/generate 7 :medium)"`, `-Dprofile` build), then the lever stack:
-  bindCallFrame copies, ADR-0184 Alt 3 template/closure split, Alt 1
-  epoch-mark, D-386 dispatch. Residual rows: D-574 reify-TD churn, D-575
-  worker fetched-fn class. The 9-target fastest-script list stays a
-  regression fence. ALSO fixed en route: nightly CI red (speed-scaled test
-  bound — budget_thread_ownership promise-gated; `run_remote_ubuntu.sh
-  --parity` reproduces the nightly config), re-extend-never-wins clj
-  parity defect, and the misplaced D-450 re-anchor block (was on D-343).
-  Release-process note worth keeping: **cutting the GitHub release by hand
-  before the tag workflow runs breaks the artifact upload**. zwasm's workflow
-  did an unconditional `gh release create`, which failed on "already exists"
-  and took the upload down with it, so v2.4.1 had notes and no binaries until
-  the release was deleted and the workflow re-run. Fixed to `view || create`
-  then `upload --clobber` (zwasm #160), matching what cljw's has always done.
-  NOTE on history hygiene: commit `673b082b`'s message describes only the
-  gate-parity fix, but its diff ALSO carries the zwasm tag re-pin, `wasm/run`'s
-  `:timeout-ms` axis and D-570's discharge — they were in the tree when the
-  gate went green and rode along. Not amended (already pushed); the v1.8.0
-  CHANGELOG was written from the diff rather than that message.
-- **Unreleased on main**: nothing. v1.8.0 (2026-08-04) carried the whole
-  audit-drain day; CHANGELOG is the SSOT for what it contained.
+- **First task on resume**: the wind-down sequence, NOT a feature unit. In
+  order: zwasm 2.5.0 (user-tagged) → bump the `.zwasm` pin + full gate →
+  cut the final cljw release tag → point cw-arcade / cw-playground /
+  cw-serverless-demo at that tag instead of a PATH `cljw` → post the
+  Discussions announcement (Announcements, pinned; the README already
+  carries the notice). The PERF CAMPAIGN (D-450, rush-hour 12.3 s, next
+  step was a re-profile) is **stopped, not paused** — its findings stay in
+  the row as a record. Release-process note that still applies: cutting a
+  GitHub release BY HAND before the tag workflow runs breaks the artifact
+  upload (zwasm #160 — use `view || create` then `upload --clobber`).
+- **Unreleased on main**: the Discussion #12/#13/#14 fixes + the two new
+  gates. CHANGELOG `[Unreleased]` is the SSOT for what they were.
 - **Forbidden**: bare `zig build test` without `-Dwasm`; bare `zig build` for a
   probe (use ReleaseSafe). The FULL gate runs `--serial-e2e`, ALONE; never a
   concurrent build during a gate. `.claude/**` edits + cross-repo publishes may
@@ -57,17 +39,28 @@
 
 ## Current state (details = CHANGELOG + git log)
 
-- **Issues and PRs are OPEN**; CONTRIBUTING exempts outside contributors from
-  the loop's own conventions. Debug tooling: `scripts/check_*.sh` headers are
-  each their own SSOT — read the script, not a list here.
-- 2026-08-11: Discussions #12/#13 (BuddhiLW) answered in code — both fix
-  branches cherry-picked with authorship preserved; the repr-misread class
-  audited and 3 more live bugs fixed (multimethod isa? at 9 defmethods, http
-  client/server 9-entry headers, error_render context); `cljw repl` gained the
-  shared `[-cp][-A]` surface (D-322 residual closed). Two new smoke-core
-  gates fence both classes: `check_repr_decode.sh` + `check_entrypoint_surface.sh`.
-  Endgame row = D-576. Reply drafts (posting is user-gated):
-  `private/notes/2026-08-11-discussion-replies.md`.
+- **Issues and PRs are DISABLED and always were** (deliberate — the
+  maintainer cannot service them); **Discussions is the one channel**, and
+  outside contributors send branches to cherry-pick. CONTRIBUTING exempts
+  them from the loop's own conventions, so a contributed commit is taken
+  as-is with authorship preserved and any missing `Smell-audited:` line
+  amended in. Debug tooling: `scripts/check_*.sh` headers are each their
+  own SSOT — read the script, not a list here.
+- **2026-08-12: the README declares ClojureWasm no longer maintained**
+  (`1c8a9cbf`); the Sponsors badge, README footer line, and `.github/FUNDING.yml`
+  are gone with it. Issues/PRs were always disabled — Discussions is the one
+  channel. Wind-down context + the surveyed wording/transfer research:
+  memory `clojurewasm-wind-down-plan`, `private/notes/2026-08-11-{sunset-wording,
+  transfer-risk}-survey.md`.
+- 2026-08-11/12: Discussions #12/#13/#14 (BuddhiLW) answered in code — three
+  fix branches cherry-picked with authorship preserved, each one's CLASS then
+  swept and fenced. #12 repr-misread → 3 more live bugs (multimethod isa? at 9
+  defmethods, http client/server 9-entry headers, error_render context) +
+  `check_repr_decode.sh`; #13/#14 entry-point divergence → `cljw repl`'s
+  `[-cp][-A]` surface, `cljw build`'s missing top-level-`do` unroll,
+  `check_entrypoint_surface.sh` + `test/e2e/entrypoint_eval_parity.sh` (a
+  6-entry-point differential oracle). D-374's discharge was a listed-not-probed
+  claim; corrected in place. Endgame row = D-576.
 
 ## Standing units (tracked in .dev/debt.yaml)
 
 
@@ -9,6 +9,21 @@ first stable `1.0.0` tag; pre-1.0 `alpha` / `rc` tags may still change surfaces.
 
 ### Fixed
 
+- **A top-level `(do …)` that requires before it uses now works in every
+  entry point.** `(do (require '[clojure.string :as s]) (s/upper-case
+  "ok"))` returned `"OK"` from `cljw -e` but raised `No namespace: 's'`
+  over nREPL and in `cljw repl`, and failed to compile under `cljw build`:
+  the top-level-`do` unroll, which analyses and evaluates each child in
+  sequence so an earlier `require` or `defmacro` is visible to a later
+  child, had only ever been wired into the script path. Reported,
+  diagnosed and fixed for the REPL engine by @BuddhiLW (Discussion #14;
+  commit cherry-picked with authorship preserved); the `cljw build` half
+  was found by auditing the other callers. A new differential oracle
+  (`test/e2e/entrypoint_eval_parity.sh`) now runs each program through
+  `-e`, a script file, stdin, `repl`, `nrepl`, and `build`+run and
+  requires all six to agree, so this class of entry-point divergence
+  fails the gate instead of reaching users.
+
 - **A set literal of 9+ elements no longer crashes macroexpansion**
   (segfault / index-out-of-bounds / bogus "cannot be re-analysed" —
   three faces of one misread). The analyzer decoded the set's backing
 
@@ -87,7 +87,9 @@ done
 # #13, 2026-08-11 confirmation reply). A help line that stops advertising -cp
 # silently breaks that capability detection even if the flag still works.
 for sc in "${EVAL_SUBCOMMANDS[@]}"; do
-    help_line=$(grep -F "\\  $sc " "$CLI" | head -1 || true)
+    # `sed -n 1p` rather than `head -1`: head closes the pipe on its Nth line,
+    # and grep takes SIGPIPE (check_epipe_head.sh gates this).
+    help_line=$(grep -F "\\  $sc " "$CLI" | sed -n 1p || true)
     if [ -z "$help_line" ] || ! printf '%s' "$help_line" | grep -q -- '-cp'; then
         echo "check_entrypoint_surface: --help line for '$sc' is missing or does not advertise -cp."
         echo "  External integrations probe \`cljw --help\` for -cp capability detection."
 
@@ -40,6 +40,16 @@ BIN="$ROOT/zig-out/bin/cljw"
 
 fail() { echo "FAIL $1" >&2; exit 1; }
 
+# Portable bounded run: GNU `timeout`, else coreutils `gtimeout`, else
+# unbounded (hosted mac runners ship neither) — the same helper the http e2e
+# steps use; check_portable_timeout.sh gates the bare-`timeout` form.
+run_bounded() {
+    local secs="$1"; shift
+    if command -v timeout >/dev/null 2>&1; then timeout "$secs" "$@"
+    elif command -v gtimeout >/dev/null 2>&1; then gtimeout "$secs" "$@"
+    else "$@"; fi
+}
+
 WORK=$(mktemp -d)
 trap 'rm -rf "$WORK"' EXIT
 
@@ -71,38 +81,38 @@ PROGRAMS=(
 # part of what is under test.
 
 run_e_flag() {
-    (cd "$WORK" && CLJW_PATH=src timeout 30 "$BIN" -e "$1" 2>&1)
+    (cd "$WORK" && CLJW_PATH=src run_bounded 30 "$BIN" -e "$1" 2>&1)
 }
 
 run_file() {
     printf '%s\n' "$1" > "$WORK/prog.clj"
-    (cd "$WORK" && CLJW_PATH=src timeout 30 "$BIN" prog.clj 2>&1)
+    (cd "$WORK" && CLJW_PATH=src run_bounded 30 "$BIN" prog.clj 2>&1)
 }
 
 run_stdin() {
-    (cd "$WORK" && printf '%s\n' "$1" | CLJW_PATH=src timeout 30 "$BIN" - 2>&1)
+    (cd "$WORK" && printf '%s\n' "$1" | CLJW_PATH=src run_bounded 30 "$BIN" - 2>&1)
 }
 
 run_repl() {
     # The REPL echoes a banner and `user=>` prompts around the output; strip
     # them so the comparison is on the program's own output.
-    (cd "$WORK" && printf '%s\n' "$1" | timeout 30 "$BIN" repl -cp src 2>&1) \
+    (cd "$WORK" && printf '%s\n' "$1" | run_bounded 30 "$BIN" repl -cp src 2>&1) \
         | sed -e 's/^user=> //' -e '/^Wasm REPL/d' -e '/^user=>$/d' \
         | grep -v '^$' || true
 }
 
 run_build() {
     printf '%s\n' "$1" > "$WORK/prog.clj"
-    (cd "$WORK" && timeout 180 "$BIN" build prog.clj -o prog_bin -cp src >/dev/null 2>&1) || {
+    (cd "$WORK" && run_bounded 180 "$BIN" build prog.clj -o prog_bin -cp src >/dev/null 2>&1) || {
         echo "BUILD-FAILED"; return 0
     }
-    (cd "$WORK" && timeout 30 ./prog_bin 2>&1)
+    (cd "$WORK" && run_bounded 30 ./prog_bin 2>&1)
 }
 
 run_nrepl() {
     local port=$(( 19000 + (RANDOM % 900) ))
     rm -f "$WORK/.nrepl-port"
-    ( cd "$WORK" && timeout 60 "$BIN" nrepl --port "$port" -cp src >/dev/null 2>&1 ) &
+    ( cd "$WORK" && run_bounded 60 "$BIN" nrepl --port "$port" -cp src >/dev/null 2>&1 ) &
     local pid=$!
     local deadline=$((SECONDS + 15))
     while [[ ! -f "$WORK/.nrepl-port" ]] && [[ $SECONDS -lt $deadline ]]; do sleep 0.1; done