REPL-Driven Compliance: Multi-Language Gate Pipeline Development

elfeed (Elisp)          ─┐
tech-crawler (Clojure)  ─┤── same feeds, same Walsh-Research/1.2 UA
@walsh/research (TS)    ─┤── same robots.txt compliance (RFC 9309)
compliance-harness (29) ─┘── same gate pipeline, verified via access log

One spec (walsh-research-compliance/v1.3). One production access log. 29 implementations that must all produce the same observable behavior.

The pre-request gate pipeline is the core invariant. Order is normative and non-commutative:

R3 (blocklist) → R2 (robots.txt) → R4 (throttle) → fetch (R5 backoff)

First gate to DENY stops the request. No HTTP request is made for denied URLs. This ordering is the same across all 29 implementations.

For each language with a genuine interactive evaluator, the implementation grew from a working 10-line REPL session:

For compiled languages (Go, Rust, Java, Swift), the REPL is the compile-run cycle. The methodology still applies: write the smallest thing that fetches a URL, observe the result, then grow the gate pipeline around it.

Every implementation tags its compliance fixture requests with R13:

GET /bot/?impl=walsh/compliance-harness/python&sha=7a01aea&spec=walsh-research-compliance/v1.3

The production access log is the single source of truth. After gmake test-all, gmake logs shows which languages checked in:

c chez clojure d deno elisp elixir erlang go guile haskell janet
java julia kotlin lua nim perl php python racket ruby rust sbcl
scala swift tcl typescript zig

No mocks. No local assertions about what the server saw. The real server saw it or it did not.

Each implementation follows the CPRR cycle:

1. Conjecture: open a REPL, fetch /robots.txt, parse it
2. Proof: write the gate pipeline (<200 lines), commit
3. Refinement: run against production, check access log
4. Refutation: if it fails, git notes add documents why

29 progressive feat(lang) commits (one per language) plus scaffold/docs; 30 git notes as the failure ledger. Bugs found by *running*, not reading: Tcl SHA float coercion (~6062e32 → 6.062e+35) and return-inside-catch swallowing the blocklist; Erlang's fold dropping the final (Walsh-Research) group and illegal regex escapes; a Zig use-after-free where robots patterns pointed into a freed body; and three in the --spider path live (finditer shape, robots-at-target-scheme, and transport-error fail-open — clarification C5).

• Tcl coerces 6062e32 to 6.062e+35 (scientific notation). No unit test catches this because the test input would need to be a real git SHA that happens to look like a float.
• Chez Scheme has no native HTTP/TLS. The REPL session reveals this in 10 seconds. A CI pipeline reveals it in 10 minutes.
• Guile's (web request) module requires GnuTLS, which has a different CA path on macOS vs FreeBSD. The REPL shows the TLS handshake error immediately.

The REPL compresses the feedback loop from "write 200 lines, run tests, read error" to "evaluate one expression, observe, adjust."

Three implementations that stress the spec's assumptions about what "native HTTP" means:

Realized in the 29-language corpus:

• libcurl-FFI tier — Chez, SBCL, Janet have no native HTTP/TLS, so they link libcurl through FFI (a 7-line C shim once, for the variadic ~curl_easy_setopt ABI). Not a subprocess: the honest answer to "is FFI-to-libcurl still native?"
• No runtime safety net — Zig and C; manual memory exposed a use-after-free the GC'd languages hid. Zig's 0.16 Io-based std.http.Client was the most churn.
• Different control model — Erlang/Elixir on OTP (gates kept deliberately sequential, not a supervision tree); Haskell's monadic IO making the DENY short-circuit structurally safe (no early-return footgun).

Still genuinely future: WASM/WASI-HTTP (fetch from the runtime), Make (the gate pipeline as a dependency graph), and a post-fetch X-Robots-Tag=/Content-Signal gate (R14) — see the harness's =spec-clarifications.org.

• REPL-Driven Flight Tracking — the methodology applied to data exploration
• CPRR Methodology — the lifecycle model
• Walsh-Research Compliance Spec (v1.3) — the normative contract
• Orchestrator Pattern — multi-agent decomposition
• walsh/compliance-harness — the 29-language implementation
• Experience report — per-language compliant-fetching notes (this corpus)
• kanaka/mal — prior art: same Lisp, 97 languages

Four Lisp-family implementations exercised in parallel tmux sessions (repl-sbcl, repl-ecl, repl-clisp, repl-fennel) against the v1.3 harness on FreeBSD 15.0 / nexus.lan.