vaelii.impl.llm.verdict — com.vaelii/vaelii 0.1.0

What a reviewer needs to know about one proposed line, gathered in one place.

A proposal is judged on four independent axes, and they are independent in the strong sense: a line can be admissible and still wrong-shaped, refused and still worth keeping once rewritten, admissible and shaped right and still quietly fragmenting the vocabulary. Prose about a batch buries all four; a reviewer reads a gutter.

:problems what the KB itself says — vaelii.core/check-edit, typed :correction what shape it should have been in — vaelii.impl.llm.correct :coined what vocabulary it invents — vaelii.impl.llm.inventory/coined :confidence how sure the correction is, which is a fifth thing only in the sense that a rewrite the engine cannot decide is a decision handed back

Each already exists; what did not is one call that runs all of them over one batch and lines the answers up by entry, so a caller renders a row rather than joining three reports by index. Nothing here stores, checks a rewrite, or applies one: this is a reading of a proposal, and the proposal is still a proposal afterwards.

acceptable? clj

(acceptable? {:keys [correction]})

May a reviewer store the shape this line is on?

No, when the correction is report-only — it found something it cannot repair (which argument of an over-long sentence is surplus is not inferable) and offers no shape to store instead. correct/apply-correction is the authority rather than a rule spelled out again here: it answers nil for exactly that case, and accepting the line would store the sentence the correction was warning about.

chosen-verdict clj

(chosen-verdict kb sentence context correction)

The verdict of the shape a reviewer has settled on, judged in light of where it came from: :problems and :coined are of the chosen sentence, because that is the one that would be stored, while :correction is the one that produced the choice.

Both halves matter and neither is derivable from the other. Re-deriving a correction from a rewrite would report nothing (correct does not re-check its own output, by contract) and the line would look as though it had never been restated — erasing the one thing a reviewer needs in order to change their mind. Keeping the original's problems instead would be worse: it would grade a sentence nobody is proposing any more.

coined-kind clj

(coined-kind {:keys [arity]})

Which of the two coining risks this is, by the arity the sentence used it at and not by its spelling: a one-place :property is a new claim about things, an n-place :relation is a new way for things to relate. They are triaged differently — a property is usually a type or a predicate the ontology could absorb, a relation is a new edge in the graph that nothing else will ever join — so they are different chips.

Arity rather than :role because the two can disagree and arity is the one that says what the sentence did: a bare lowercase word satisfies the predicate convention and the type convention alike, and (swims penguin) coins a property whichever way term-role reads the name.

review clj

(review kb sentence context)

(review kb sentence context n)

One line under review: what the model wrote (:from), every shape it could take (:shapes), which one the reviewer is on (:n / :chosen), the verdict of that shape (:verdict), whether there is anything here to store (:storable?), and whether the reason there is not is a correction that could only report (:report-only?).

The rewrite leads when there is one (:n defaults to 2): a correction exists because the sentence as written says the right thing in the wrong shape, and leading with the wrong one would put the keystroke on the common case. The original stays shape 1, so getting back to it costs a keystroke too — which is the point, since correct deliberately refuses to decide between them.

review-of clj

(review-of kb {:keys [index sentence context correction] :as verdict})

The same row from a verdict verdicts already computed — the batch case, which has both the correction and the sentence's own verdict in hand and re-derives neither.

shapes clj

(shapes sentence correction)

Every shape a proposed line could take, in the order a reviewer should meet them: the sentence as the model wrote it first, then the correction's rewrite, then its alternatives.

The original leads because it is what was actually proposed and a reviewer must be able to get back to it; the rewrite follows because when there is one it is usually right. Numbering is by position, so a caller can offer them as 1, 2, 3 and a choice is one keystroke. A line with no correction has exactly one shape, and nothing to choose.

summary clj

(summary verdicts)

How many lines fell under each verdict — {:refused n :uncertain n :coins n :ok n}, every key present so a caller can render a fixed row of counts rather than a variable one.

verdict-rank clj

The four verdicts, worst first — the order a reviewer's eye should be drawn in.

A line's verdict is the worst thing true of it, and only the leading glyph is ordered this way: every axis is still reported beside it, because ranking is for attention and not for hiding.

:refused the KB will not take it — nothing else about the line matters yet :uncertain a rewrite exists but the engine cannot decide it (:confidence :low), so the judgement is the reader's and they have to be told. A rewrite it can decide leaves the verdict alone: the line is admissible, the correction is a chip beside it, and demoting every restated line would make the worst rank the common one and say nothing :coins it introduces vocabulary. Third rather than harmless: the measured failure mode of this whole path is a batch accepted without being read, and coined vocabulary is what that costs :ok admissible, in a shape the checker recognizes, in the KB's own words

verdicts clj

(verdicts kb batch)

(verdicts kb batch {:keys [problems]})

One verdict per :add entry of batch, in batch order:

{:index :entry :sentence :context :problems [{:type :message …}] ; empty when the KB would take it :correction {:to :alternatives :rule :rules :confidence :why} | nil :coined [{:predicate :arity :role :kind} …] :verdict :refused | :uncertain | :coins | :ok}

opts :problems takes a check-edit result already computed — propose-page runs one to decide its own status, and checking a batch twice to render it is a whole second pass of assert's chain for an answer already in hand. Without it, this runs the check itself, so a caller with nothing precomputed still gets a full reading.

A :remove entry has no verdict here: removal is checked (:unknown-handle) but has no sentence to correct and coins nothing, and the generating paths never remove.