fix(eval): cljs-eval-wire throws :cljs-eval-empty on blank-with-no-error response

Closes #6 (defensive layer; root-cause investigation still requires
the live fixture).

The bug: \`scripts/eval-cljs.sh '(+ 1 2)'\` returned
{:ok? true, :value nil, :rfp.wire/value-fits? true, :reinjected? true}.
The {:ok? true} field is a false trust signal — there is no error,
but the actual return value is silently dropped.

Root cause path: shadow-cljs's nREPL response carries a blank :value
(no :err, no :ex), parse-cljs-eval-response correctly returns nil for
blank, cljs-eval-wire takes the trivial-passthrough branch and
synthesizes {:value nil :rfp.wire/value-fits? true}, eval-op emits
{:ok? true :value nil}. Each layer is locally correct; the stack
loses the distinction between "form returned nil" and "shadow gave
us no value at all."

Fix: in cljs-eval-wire, when parse returns nil AND the underlying
response has blank :value AND no :err AND no :ex, throw a structured
ex-info {:reason :cljs-eval-empty :raw-response <res> :hint ...}.
eval-op's existing try/catch surfaces it as
{:ok? false :reason :cljs-eval-empty :data {:raw-response ...}}.

Why surgical (in cljs-eval-wire, not parse-cljs-eval-response): the
sentinel probe (\`runtime-already-injected?\`) and other internal
callers legitimately treat nil-from-blank as "not present" — changing
parse-cljs-eval-response would ripple through every cljs-eval-value
call site.

Legitimate-nil shape (e.g. \`(prn :hi)\`) is unaffected — shadow
encodes that as :value "nil" (the EDN string), which parses to nil
without tripping the blank check.

4 deftests cover: blank-no-error → :cljs-eval-empty; legitimate
:value "nil" → passes through; blank with :ex set → existing
:eval-error path; blank with nil :err and nil :ex (the headline #6
shape) → :cljs-eval-empty.

Note: this closes the false-trust gap and surfaces \`:raw-response\`
for debugging, but does not identify *why* shadow returns blank for
the affected forms. Likely candidates flagged in the original report
(shadow 2.20.11 result-shape change; wire/return! per-shape behavior)
need verification against a live fixture and may be follow-ups.

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

Author: mike-thompson-day8

scripts/ops.clj

@@ -426,6 +426,20 @@
   ([conn build-id form-str opts]
    (let [res    (cljs-eval conn build-id form-str opts)
          parsed (parse-cljs-eval-response res)]
+     ;; Distinguish "form returned nil" from "shadow returned an
+     ;; empty response with no error". A legitimate nil result is
+     ;; encoded as :value "nil" (the EDN string), not as a blank
+     ;; :value. Blank :value with no :err and no :ex is a transport-
+     ;; or wrap-level failure that previously surfaced as the
+     ;; misleading {:ok? true :value nil} (issue #6).
+     (when (and (nil? parsed)
+                (str/blank? (str (:value res)))
+                (str/blank? (str (:err res)))
+                (nil? (:ex res)))
+       (throw (ex-info "shadow-cljs returned an empty cljs-eval response"
+                       {:reason :cljs-eval-empty
+                        :raw-response res
+                        :hint  "shadow-cljs's nREPL response carried no :value, :err, or :ex — neither a returned value nor an error. Common causes: a shadow-cljs version returning a value shape parse-cljs-eval-response doesn't recognize; the wire/return! wrapper evaluated but produced no transport output; the runtime ns is partially loaded (sentinel may say present but wire fns aren't bound). Re-run scripts/discover-app.sh to confirm runtime health."})))
      (if (wire-shape? parsed)
        (cond-> {:value                 (:rfp.wire/value parsed)
                 :rfp.wire/cursor       (:rfp.wire/cursor parsed)

tests/ops_smoke.bb

@@ -1023,6 +1023,48 @@
         (is (= {:counter 42} (#'ops/cljs-eval-value :app "(any-form)"))
             "wire shape unwrapped; existing callers see the inner value")))))
 
+;; ---------------------------------------------------------------------------
+;; Tests for issue #6: cljs-eval-wire must distinguish "form returned nil"
+;; from "shadow returned a blank response with no error" — the latter used
+;; to surface as the misleading {:ok? true :value nil}.
+;; ---------------------------------------------------------------------------
+
+(deftest cljs-eval-wire-throws-on-blank-no-error-response
+  (testing "blank :value with no :err and no :ex throws :cljs-eval-empty (eval-op surfaces as {:ok? false ...})"
+    (with-redefs [ops/cljs-eval (fn [& _] {:value "" :err "" :ex nil :status #{:done}})]
+      (let [thrown (try (#'ops/cljs-eval-wire nil :app "(+ 1 2)" {})
+                        (catch clojure.lang.ExceptionInfo e
+                          {:msg (.getMessage e) :data (ex-data e)}))]
+        (is (= :cljs-eval-empty (-> thrown :data :reason))
+            ":cljs-eval-empty distinguishes empty from legitimate-nil")
+        (is (contains? (:data thrown) :raw-response)
+            ":raw-response carried for debugging")
+        (is (str/includes? (-> thrown :data :hint) "discover-app"))))))
+
+(deftest cljs-eval-wire-passes-through-legitimate-nil-value
+  (testing "shadow returning :value \"nil\" (the EDN string) is a real nil result, not an empty response"
+    (with-redefs [ops/cljs-eval (fn [& _] {:value (pr-str {:results [(pr-str nil)]})
+                                            :status #{:done}})]
+      (let [result (#'ops/cljs-eval-wire nil :app "(prn :hi)" {})]
+        (is (nil? (:value result)) "legitimate nil passes through as :value nil")
+        (is (true? (:rfp.wire/value-fits? result)) "no error surfaced")))))
+
+(deftest cljs-eval-wire-blank-with-err-keeps-existing-eval-error-path
+  (testing "blank :value WITH :err set is an eval error, not :cljs-eval-empty (parse-cljs-eval-response throws first)"
+    (with-redefs [ops/cljs-eval (fn [& _] {:value "" :err "" :ex "compile error somewhere"})]
+      (let [thrown (try (#'ops/cljs-eval-wire nil :app "(broken)" {})
+                        (catch clojure.lang.ExceptionInfo e
+                          (ex-data e)))]
+        (is (= :eval-error (:reason thrown)) "throws :eval-error from parse-cljs-eval-response, not :cljs-eval-empty")))))
+
+(deftest cljs-eval-wire-blank-with-only-err-string-still-throws-cljs-eval-empty
+  (testing "blank :value with empty :err string but no :ex falls into :cljs-eval-empty (the headline #6 shape)"
+    (with-redefs [ops/cljs-eval (fn [& _] {:value "" :err nil :ex nil :status #{:done}})]
+      (let [thrown (try (#'ops/cljs-eval-wire nil :app "(+ 1 2)" {})
+                        (catch clojure.lang.ExceptionInfo e
+                          (ex-data e)))]
+        (is (= :cljs-eval-empty (:reason thrown)))))))
+
 ;; ---------------------------------------------------------------------------
 ;; Tests for issue #7: inject failures must surface as :inject-failed, not
 ;; pass through silently as nil from downstream ops.