fractal-engine.render — net.clojars.deadmeme5441/fractal-engine 0.1.1

Pure text rendering of the projection/provenance substrate for the agent CLI. Every function returns a string; nothing prints or exits (that's cli). The surface is designed for recursive reading: the tree shows every node's address, and a node view ends with the exact inspect --node <addr> commands to drill into its children — so navigating a run is following printed addresses inward.

Color is a tasteful default on a TTY and off otherwise (and always off for piped or --json output), so captured output is stable and agents parse clean text.

*color* clj

c clj

(c style s)

clip clj

(clip s n)

cost-str clj

(cost-str root-dir {:keys [run exe]})

Spend breakdown for a run: tree total plus per-child cost, read from the boundary-materialized usage projection (cost is inherently a turn-boundary aggregate). Visibility, not a cap.

deep-verify-str clj

(deep-verify-str address checks verify-run base)

Render deep verify: the free grep floor verdict plus the engine's adversarial verdict per claim (the engine chose child-vs-leaves itself). The deep run is named so it's inspectable like any other.

node-arg clj

(node-arg address)

The CLI-friendly node token for an address: root stays root, root/child-0001 becomes child-0001 (the leading root/ is implied), so drill commands read like fractal show <run> child-0001 — positional, copy-paste, beads-style.

node-str clj

(node-str node {:keys [step leaves? final? exe run] :as opts})

Detailed view of one node, ending with the drill commands for its children — the recursive-read affordance. Opts: :step (one step full), :leaves?, :final?, :exe (program name, default "fractal"), :run (the run token the user typed).

prime-str clj

(prime-str root-dir {:keys [exe run]})

A compact orientation: what this run is, its shape, and where to drill — the read-side analogue of bd prime. run is the token the user typed.

progress-counts clj

(progress-counts dir)

Light tally of a session's journal for the live ◐ thinking… line: children spawned, steps run, leaves judged. Reads events directly (cheaper than a full ref-resolving load) and tolerates concurrent appends — the journal reader drops a half-written trailing line.

progress-line clj

(progress-line {:keys [steps children leaves]})

tree-str clj

(tree-str root-dir)

Render the whole run as an addressable tree. Each line: status glyph, the node's last address segment, and [steps leaves children] counts, indented by depth.

turn-summary-str clj

(turn-summary-str root-node result {:keys [exe run]})

What chat (and run) print after a turn settles: the ● result line, the compact final, the spend, and 1–2 'look inside' drill commands into the nodes this turn produced — so the conversation stays readable and depth is one command away.

verify-str clj

(verify-str address final)

(verify-str address final base)

Render claim-vs-evidence for a node's FINAL value: per-claim verdict, the cited file, and which identifiers landed vs went missing — so a reader can judge a confabulation flag rather than trust one boolean. base resolves relative citations against the repo root the run worked on.