feat(reads): :claims op — daemon-first CLI reads (thread 019f2190)

Kill the per-process cold fold: read verbs fetch the coordinator's
already-folded live view instead of re-folding the whole log per CLI
invocation (~700ms of every read on the 11k-line tern log).

- cnf_coord_daemon: new :claims op — whole live view as [l p r] wire
  triples IN FOLD EMISSION ORDER (contract), cached per version, served
  after maybe-reload! so it is exactly as fresh as the flat log; :log
  echo lets a client refuse a mismatched daemon.
- fold: refold-order — re-key a set-equal live view into fold's hash-map
  emission order (bb and the JVM share PersistentHashMap, so daemon
  order == CLI order; byte-identical downstream output).
- rt: coord-live-claims client — asks {:fmt :json} (bb decodes the ~2MB
  payload 12x faster than EDN); returns [] on daemon-down / unknown-op /
  log-mismatch, the whole capability handshake (callers fall back cold).
- kernel: single? via map membership (ran once per assertion in every
  fold/refold — the vec scan was a measurable slice of the read path).
- main: cmd-show reads through live-claims; prefix resolution over the
  index (O(subjects x claims) flat scan was ~2s -> ~40ms), byte-identical
  match order.

Measured (10.8k-claim live-size copy, isolated daemon :7999): fram show
744ms -> 160ms full-id, 2.2s -> 208ms prefix; all read verbs byte-
identical warm vs cold; out-of-band appends visible warm; clean cold
fallback with daemon down / old daemon / wrong log. Drop-in gate: torn-
tail freshness check fails identically on unmodified main (pre-existing).

Author: tompassarelli

cnf_coord_daemon.clj

@@ -33,6 +33,7 @@
 (def co (atom nil))                  ; {:store :log :lock} — reified canonical (v2 log)
 (def flat-log (atom nil))            ; the flat log, now a PROJECTION the cold CLI folds
 (def cache (atom {:index nil :version -1}))
+(def claims-wire-cache (atom {:version -1 :triples nil}))  ; :claims op — fold-ordered [l p r] wire triples, per version
 (def subscribers (atom []))
 (def dlock (Object.))                ; serializes reload + writes + reads (drop-in mode)
 (def flat-mtime (atom nil))          ; last-seen flat-log stamp (to detect external edits)
@@ -1257,6 +1258,28 @@
                      :inc-triples (count (:triples (:idx inc))) :fresh-triples (count (:triples fidx))
                      :version (current-seq @co)})
       :status   {:version (current-seq @co) :claims (count (c/current-claims (:store @co))) :log (or @flat-log (:log @co))}
+      ;; :claims — the WHOLE live view as flat [l p r] triples IN FOLD EMISSION ORDER
+      ;; (fram.fold/refold-order), for daemon-first CLI reads (thread 019f2190): the
+      ;; client feeds these straight into its kernel index instead of paying the
+      ;; per-process cold fold. Ordering here is part of the op's CONTRACT — the
+      ;; client renders byte-identical output without re-ordering, and bb shares
+      ;; clojure.lang.PersistentHashMap with the JVM so the hash order agrees.
+      ;; Computed AFTER maybe-reload! above (exactly as fresh as the flat log at
+      ;; request time) and cached per version — a read storm re-serializes, never
+      ;; re-orders. :log echoes which log this daemon serves so a client can refuse
+      ;; a mismatched daemon (fram.rt/coord-live-claims checks it). Clients ask with
+      ;; {:fmt :json} — bb decodes the ~2MB payload ~12x faster as JSON than as EDN.
+      :claims   (let [v (current-seq @co)
+                      cc @claims-wire-cache
+                      triples (if (= v (:version cc))
+                                (:triples cc)
+                                (let [ts (mapv (fn [c] [(:l c) (:p c) (:r c)])
+                                               (fold/refold-order (reified->claims @co)))]
+                                  (reset! claims-wire-cache {:version v :triples ts})
+                                  ts))]
+                  {:version v
+                   :log (or @flat-log (:log @co))
+                   :claims triples})
       ;; thread 019f100f-7fff — snapshot/compaction surface:
       ;; :snapshot writes a checkpoint (dump-log! image + @snapshot:<seq> claims);
       ;; :snapshot-reconcile is the gate (live store == from-scratch whole migrate).

out/fram/fold.clj

@@ -60,3 +60,6 @@
 
 (defn fold-latest [asserts]
   (filterv (fn [v] (= (:op v) "assert")) (vec (vals (keyed-latest asserts)))))
+
+(defn refold-order [claims]
+  (vec (vals (reduce (fn [m c] (assoc m (key-of (->Assertion 0 "assert" (:l c) (:p c) (:r c) "live")) c)) {} claims))))

out/fram/kernel.clj

@@ -24,8 +24,10 @@
 (defn ^String vocab-fingerprint []
   (str "single=" (sorted-join single-valued) " |terminal=" (sorted-join terminal-preds) " |withdrawn=" (sorted-join withdrawn-preds)))
 
+(def single-valued-set (reduce (fn [m p] (assoc m p true)) {} single-valued))
+
 (defn ^Boolean single? [^String p]
-  (or (vec-contains? single-valued p) (and (string? p) (str/starts-with? p "emoji_"))))
+  (or (some? (get single-valued-set p)) (and (string? p) (str/starts-with? p "emoji_"))))
 
 (defrecord Claim [l p r])
 

out/fram/main.clj

@@ -12,6 +12,10 @@
 (defn- ^String short-id [^String te]
   (if (str/starts-with? te "@") (subs te 1) te))
 
+(defn- live-claims [^String log]
+  (let [warm (fram.rt/coord-live-claims (fram.rt/coord-port) log)]
+  (if (empty? warm) (:claims (fold/fold (fram.rt/read-log log))) warm)))
+
 (defn- ^String claim-sig [c]
   (str (:l c) "|" (:p c) "|" (:r c)))
 
@@ -56,11 +60,10 @@
   (println (str "\n" (count problems) " violation(s)."))))))
 
 (defn cmd-show [^String log ^String id]
-  (let [f (fold/fold (fram.rt/read-log log))
-   claims (:claims f)
+  (let [claims (live-claims log)
    te (str "@" id)
    exact (k/q-by-l claims te)
-   matches (if (or (not (empty? exact)) (str/blank? id)) [] (filterv (fn [t] (str/starts-with? (short-id t) id)) (k/thread-ids claims)))]
+   matches (if (or (not (empty? exact)) (str/blank? id)) [] (filterv (fn [t] (str/starts-with? (short-id t) id)) (k/thread-ids-i (k/build-index claims))))]
   (cond
   (not (empty? exact)) (doseq [c exact]
   (println (str "  " (:p c) "  " (:r c))))

out/fram/rt.clj

@@ -10,7 +10,8 @@
             [clojure.edn :as edn]
             [clojure.java.io :as io]
             [cheshire.core :as cheshire]
-            [fram.fold :as fold]))
+            [fram.fold :as fold]
+            [fram.kernel :as kernel]))
 
 ;; Serialize any value (records serialize as objects keyed by field name; vectors
 ;; as arrays) to JSON — the engine's structured-output path for the MCP edge.
@@ -310,6 +311,35 @@
 (defn coord-callers  [port te]      (warm-read port {:op :callers :te te}))   ; -> {:callers [...]} | nil
 (defn coord-resolved [port te pred] (warm-read port {:op :resolved :te te :p pred})) ; -> {:value :members :ambiguous? :values} | nil — surfaces multiplicity (#3)
 
+;; :claims — the daemon's WHOLE live view as [l p r] triples: the daemon-first read
+;; path (thread 019f2190). The CLI rebuilds its kernel index from this instead of
+;; paying the per-process cold fold (read-log EDN parse + fold ≈ 700ms on the 11k-line
+;; tern log). The daemon serves the triples IN FOLD EMISSION ORDER (its contract —
+;; fram.fold/refold-order, cached per version), so the records returned here feed
+;; build-index directly and every listing stays byte-identical to the cold fold's.
+;; Asked with {:fmt :json} DELIBERATELY: bb parses the ~2MB payload ~12x faster as
+;; JSON (cheshire, native) than as EDN (measured 15ms vs 186ms).
+;; Returns a (Vec kernel/Claim), or [] when the warm path is unavailable — daemon
+;; down, an older daemon without the op (its {"error" ...} reply has no "claims"),
+;; or a daemon serving a DIFFERENT log than the caller's (the :log echo mismatches —
+;; never silently read another store). [] is safe as the sentinel: a real log always
+;; folds to a non-empty view (an empty log has no daemon serving it worth trusting).
+;; Callers fall back to the cold fold on [].
+(defn coord-live-claims [port log]
+  (try
+    (with-open [s (coord-socket (connect-host) port)]
+      (let [w (io/writer (.getOutputStream s))
+            r (io/reader (.getInputStream s))]
+        (.write w (str (pr-str {:op :claims :fmt :json}) "\n"))
+        (.flush w)
+        (let [resp (cheshire/parse-string (.readLine r))]
+          (if (and (map? resp)
+                   (= log (get resp "log"))
+                   (vector? (get resp "claims")))
+            (mapv (fn [t] (kernel/->Claim (nth t 0) (nth t 1) (nth t 2))) (get resp "claims"))
+            []))))
+    (catch Exception _ [])))
+
 ;; subscribe + stream commit events (one EDN line each) until disconnect
 (defn coord-watch [port]
   (with-open [s (coord-socket (connect-host) port)]   ; honors FRAM_CONNECT + mTLS like coord-rt

src/fram/fold.bclj

@@ -76,3 +76,22 @@
 (defn fold-latest [asserts :- (Vec Assertion)] :- (Vec Latest)
   (filterv (fn [v :- Latest] :- Bool (= (:op v) "assert"))
            (vec (vals (keyed-latest asserts)))))
+
+;; Reconstruct fold's emission ORDER from a set-equal live view. The coordinator's
+;; :claims op serves its warm store through this (cached per version), so the CLI's
+;; daemon-first read path renders byte-identically to the cold fold. fold emits
+;; (vals keyed-latest) — hash-map iteration order over the key-of strings — and
+;; downstream output order (build-index subjects, every projection listing)
+;; inherits it. Re-keying a set-equal claim vec through the SAME key-of yields the
+;; same relative order: an entry's position in a persistent hash map is a function
+;; of its own key hash, not of insertion order; the cold map's extra retract-latest
+;; keys (skipped when fold emits claims) don't reorder the surviving entries; and
+;; bb + the JVM share clojure.lang.PersistentHashMap, so daemon-computed order ==
+;; CLI-computed order. (The synthetic Assertion exists only to reuse key-of
+;; verbatim — same \001 separator bytes.)
+(defn refold-order [claims :- (Vec k/Claim)] :- (Vec k/Claim)
+  (vec (vals (reduce
+              (fn [m :- (Map String k/Claim) c :- k/Claim] :- (Map String k/Claim)
+                (assoc m (key-of (->Assertion 0 "assert" (:l c) (:p c) (:r c) "live")) c))
+              {}
+              claims))))

src/fram/kernel.bclj

@@ -89,13 +89,21 @@
        " |terminal=" (sorted-join terminal-preds)
        " |withdrawn=" (sorted-join withdrawn-preds)))
 
+;; Map-backed membership for single?: it runs once per assertion in every
+;; fold/refold (and per claim in the daemon's migrate/tail-fold), so the
+;; vec-contains? linear scan over the ~23-pred vocab was a measurable slice of
+;; the whole read path (~40ms of a 10.7k-claim refold on bb).
+(def single-valued-set :- (Map String Bool)
+  (reduce (fn [m :- (Map String Bool) p :- String] :- (Map String Bool) (assoc m p true))
+          {} single-valued))
+
 ;; `emoji_*` are presentation-config predicates (e.g. @ui emoji_blocked "🧱") —
 ;; single-valued by prefix so re-configuring replaces, with no per-key listing.
 (defn single? [p :- String] :- Bool
   ;; (string? p) guards str/starts-with? against a non-string p — defense in depth
   ;; so a stray/torn record can't NPE the whole cold-read path (fold already drops
   ;; torn lines; this is the belt to that suspenders).
-  (or (vec-contains? single-valued p) (and (string? p) (str/starts-with? p "emoji_"))))
+  (or (some? (get single-valued-set p)) (and (string? p) (str/starts-with? p "emoji_"))))
 
 ;; --- the claim -------------------------------------------------------------
 

src/fram/main.bclj

@@ -27,6 +27,7 @@
 (declare-extern fram.rt/coord-retract [Int String String String Int -> String])
 (declare-extern fram.rt/coord-port [-> Int])
 (declare-extern fram.rt/coord-status [Int -> String])
+(declare-extern fram.rt/coord-live-claims [Int String -> (Vec k/Claim)])
 (declare-extern fram.rt/coord-watch [Int -> Nil])
 (declare-extern fram.rt/history [String String -> Nil])
 (declare-extern fram.rt/parse-edn [String -> Any])
@@ -36,6 +37,18 @@
 (defn- short-id [te :- String] :- String
   (if (str/starts-with? te "@") (subs te 1) te))
 
+;; --- daemon-first read (thread 019f2190) -------------------------------------
+;; The current claim set: the coordinator's warm live view when a daemon serves
+;; THIS log (served in fold emission order — the :claims op contract — so
+;; downstream output is byte-identical to the cold fold's), else the cold fold.
+;; [] from coord-live-claims is the whole capability handshake — daemon down /
+;; old daemon / different log.
+(defn- live-claims [log :- String] :- (Vec k/Claim)
+  (let [warm (fram.rt/coord-live-claims (fram.rt/coord-port) log)]
+    (if (empty? warm)
+      (:claims (fold/fold (fram.rt/read-log log)))
+      warm)))
+
 ;; --- claim-set signatures (divergence detection for the import/export guards) -
 (defn- claim-sig [c :- k/Claim] :- String (str (:l c) "|" (:p c) "|" (:r c)))
 (defn- sig-set [claims :- (Vec k/Claim)] :- (Vec String) (vec (sort (mapv claim-sig claims))))
@@ -114,14 +127,18 @@
 ;; (it would match every thread), and an ambiguous prefix lists the candidates and
 ;; picks none.
 (defn cmd-show [log :- String id :- String] :- Nil
-  (let [f (fold/fold (fram.rt/read-log log))
-        claims (:claims f)
+  (let [claims (live-claims log)
         te (str "@" id)
         exact (k/q-by-l claims te)
         matches (if (or (not (empty? exact)) (str/blank? id))
                   []
+                  ;; prefix resolution over the INDEX: (k/thread-ids claims) is a
+                  ;; flat one-per-subject scan — O(subjects × claims), ~2s on the
+                  ;; 10.7k-claim log — while thread-ids-i over build-index is
+                  ;; O(claims). Same subjects, same uniq claim order, so the match
+                  ;; list (and the ambiguous-prefix listing) is byte-identical.
                   (filterv (fn [t :- String] :- Bool (str/starts-with? (short-id t) id))
-                           (k/thread-ids claims)))]
+                           (k/thread-ids-i (k/build-index claims))))]
     (cond
       [(not (empty? exact))
        (doseq [c exact] (println (str "  " (:p c) "  " (:r c))))]

src/fram/rt.clj

@@ -10,7 +10,8 @@
             [clojure.edn :as edn]
             [clojure.java.io :as io]
             [cheshire.core :as cheshire]
-            [fram.fold :as fold]))
+            [fram.fold :as fold]
+            [fram.kernel :as kernel]))
 
 ;; Serialize any value (records serialize as objects keyed by field name; vectors
 ;; as arrays) to JSON — the engine's structured-output path for the MCP edge.
@@ -310,6 +311,35 @@
 (defn coord-callers  [port te]      (warm-read port {:op :callers :te te}))   ; -> {:callers [...]} | nil
 (defn coord-resolved [port te pred] (warm-read port {:op :resolved :te te :p pred})) ; -> {:value :members :ambiguous? :values} | nil — surfaces multiplicity (#3)
 
+;; :claims — the daemon's WHOLE live view as [l p r] triples: the daemon-first read
+;; path (thread 019f2190). The CLI rebuilds its kernel index from this instead of
+;; paying the per-process cold fold (read-log EDN parse + fold ≈ 700ms on the 11k-line
+;; tern log). The daemon serves the triples IN FOLD EMISSION ORDER (its contract —
+;; fram.fold/refold-order, cached per version), so the records returned here feed
+;; build-index directly and every listing stays byte-identical to the cold fold's.
+;; Asked with {:fmt :json} DELIBERATELY: bb parses the ~2MB payload ~12x faster as
+;; JSON (cheshire, native) than as EDN (measured 15ms vs 186ms).
+;; Returns a (Vec kernel/Claim), or [] when the warm path is unavailable — daemon
+;; down, an older daemon without the op (its {"error" ...} reply has no "claims"),
+;; or a daemon serving a DIFFERENT log than the caller's (the :log echo mismatches —
+;; never silently read another store). [] is safe as the sentinel: a real log always
+;; folds to a non-empty view (an empty log has no daemon serving it worth trusting).
+;; Callers fall back to the cold fold on [].
+(defn coord-live-claims [port log]
+  (try
+    (with-open [s (coord-socket (connect-host) port)]
+      (let [w (io/writer (.getOutputStream s))
+            r (io/reader (.getInputStream s))]
+        (.write w (str (pr-str {:op :claims :fmt :json}) "\n"))
+        (.flush w)
+        (let [resp (cheshire/parse-string (.readLine r))]
+          (if (and (map? resp)
+                   (= log (get resp "log"))
+                   (vector? (get resp "claims")))
+            (mapv (fn [t] (kernel/->Claim (nth t 0) (nth t 1) (nth t 2))) (get resp "claims"))
+            []))))
+    (catch Exception _ [])))
+
 ;; subscribe + stream commit events (one EDN line each) until disconnect
 (defn coord-watch [port]
   (with-open [s (coord-socket (connect-host) port)]   ; honors FRAM_CONNECT + mTLS like coord-rt