Repo-wide: println! output path and non-streaming analyses contradict CLAUDE.md

[copyleftdev]

Two guideline violations that are repo-wide rather than local to any one change. Raised by CodeRabbit on #71; I skipped both there because fixing them in one command would have made it inconsistent with the other eleven, and said I'd file them.

1. println! vs the rendering system

CLAUDE.md line 219: "No println! for output. All user-facing output through the rendering system."

Every command violates this, and there is no general rendering system to route through — the only renderer is vajra-essence's, which is specific to EssenceData:

command	println! calls
cmd_batch	23
cmd_fingerprint	20
cmd_drift	19
cmd_invariants	10
cmd_separation	~20
…	…

So the guideline currently describes a system that does not exist. Either build a general output abstraction over Format and migrate the commands, or amend the guideline to describe what the CLI actually does. Worth noting the cost is real: format handling is duplicated per command, which is why several commands historically drifted (e.g. --format markdown and --format compact-ai mostly fall through to the text branch).

2. separation is not streaming

CLAUDE.md rule 1: "Every algorithm must work at any scale. 1KB, 1GB, 100GB. If it doesn't stream, it doesn't ship."

separation (#60) accumulates the full labelled corpus: quantile cuts need the value distribution and AUC needs per-class value vectors, so neither is computable in one bounded pass. Memory grows with records × fields. This is documented in cmd-separation.md under Scale rather than left implicit.

invariants/relationships has the identical shape for the same reason and has always shipped, so this is a pre-existing pattern, not a new regression — but two commands now violate an emphatic rule.

A streaming variant is tractable: the crate already carries DDSketch for quantiles, and AUC can be estimated from a rank sketch or computed from a binned contingency table rather than raw vectors. That would let both commands honour the rule. Alternatively the rule could acknowledge a bounded class of two-pass analyses.

[copyleftdev]

Partially addressed in #79. Both halves measured; what remains is genuine design work, not cleanup.

Half 1: output path — the user-visible part is fixed

The guideline violation is real but it was the wrong framing. The concrete harm wasn't println! — it was that two of the four advertised formats don't exist:

inspect      text=57dac21c markdown=57dac21c compact-ai=57dac21c   ALL IDENTICAL
stats        text=4edcbfda markdown=4edcbfda compact-ai=4edcbfda   ALL IDENTICAL
anomalies    text=93adb850 markdown=93adb850 compact-ai=93adb850   ALL IDENTICAL
invariants   text=60a36531 markdown=60a36531 compact-ai=60a36531   ALL IDENTICAL

essence      text=ee149926 markdown=399ec2a0 compact-ai=40fc22f6   (real renderer)

Eleven of twelve commands render markdown and compact-ai byte-identically to text. #79 makes that explicit on stderr rather than silent, with stdout unchanged. The lie is gone; the gap is not.

What remains: a general renderer, and 11 commands migrated onto it. That's worth doing precisely because it would fix the format gap structurally rather than per-command — the duplication is why the gap exists. But it's a large mechanical refactor with real regression risk, and it needs a design decision first: what shape does the abstraction take, given the outputs range from flat key/value (fingerprint) to nested arrays with per-row severity (separation, corpus index)?

Suggested sequencing: design the renderer against two commands with maximally different output shapes, land those, then migrate the rest mechanically.

Half 2: streaming — assessed, not attempted

separation and invariants both accumulate the corpus. Neither is fixable by refactoring:

• Quantile cuts need the value distribution. DDSketch is already in the crate and would solve this directly.
• AUC / Cliff's delta needs per-class value vectors. This is the harder half — it needs either a rank sketch, or computing AUC from the binned contingency table instead of raw values, which changes the number slightly and would need a documented accuracy bound.
• Conditional entropy over binned values is already effectively a contingency table, so it streams once binning does.

So the path exists and the primitives are present, but it is a redesign with a numerical-accuracy tradeoff to decide, not a mechanical change. I'd rather leave it open with that assessment than half-implement it.

Third option worth considering: amend rule 1 to acknowledge a bounded class of two-pass analyses. Some questions genuinely require seeing the data twice, and a rule that no shipped code obeys is weaker than one with an explicit, narrow exception.

[copyleftdev]

Progress update. Markdown coverage 7 of 12, compact-ai 3 of 12.

Landed: #80 (renderer + anomalies), #81 (stats, invariants), #82 (fingerprint, separation), #83 (claim-list correction).

markdown:   anomalies cascade essence fingerprint invariants separation stats
compact-ai: cascade essence score

Two findings worth recording, since both were mistakes in the tracking rather than the code:

The original claim lists were wrong in both directions. Built by reading match arms, which missed that cascade hand-rolls all three formats and score hand-rolls compact-ai. Both were warning about renderers they already had — a silent lie replaced with a loud one. Fixed in #83, and the lists are now pinned from both sides by tests that measure output rather than trust the list: one catches claiming a command that only falls through to text, the other catches omitting a command that genuinely renders.

Migration deletes code. separation had a truncate_path helper for fixed-width columns; the renderer computes widths, so it became dead and went. Expect the same for the remaining commands.

Remaining

inspect, cluster, drift, batch, governance, core-team, compare, plus score's markdown.

Each is now mechanical — three steps: build a render::Report instead of println!, add the command to RENDERS_MARKDOWN, add the pair to claimed_renderers_produce_distinct_output. Anything that needs unusual fixtures (compare takes two inputs, governance/core-team need commit-shaped records) is the only real friction.

One caveat carried forward from #82's review: the renderer buffers its rows and then the whole output string. That's the render-side face of this issue's streaming half, not a regression — the previous hand-written code buffered too — but it's now concentrated in one place, which means a streaming renderer would be one change rather than twelve. It needs the same accuracy decision as the streaming analyses, so it stays with that half.