critic

type Adjudicated struct {
	Finding adh.Finding
	Ran     bool
	Failed  bool

	// Unrunnable says why the artifact did not run, and is meaningful only when Ran
	// is false.
	//
	// §19.2 records that an unchecked finding does not block, on the reasoning that
	// Ran:false covers both *the registered tool is broken* — an honest refusal worth
	// acting on — and *the critic named a tool that never existed*, which is noise,
	// and that blocking on the second would let one bad critic wedge every arc.
	//
	// **The adjudicator already knows which**, and threw the answer away one call up:
	// runDeclaredTool's `found` distinguishes them. Carrying it does not change the
	// blocking rule — that decision stands — it makes the decision revisitable on
	// evidence rather than on the guess that the two are inseparable.
	Unrunnable adh.Unrunnable

	// Measured is the value a meter produced, and HasMeasure whether one did.
	//
	// A bool rather than a sentinel: 0 is a legitimate measurement, and NaN would be a
	// second vocabulary for "absent" beside the one this struct already has.
	Measured   float64
	HasMeasure bool

	// Regressed reports a measurement worse than the spec's baseline that still
	// cleared the acceptance bar. It is the reservation §19.2 had no disposition for:
	// the change is admissible and it cost something, and both facts are true.
	Regressed bool
}

type CoverageEntry struct {
	Arc   string   `json:"arc"`
	Kinds []string `json:"kinds"`
}

type Grounding struct {
	Paths         []string            // the arc's touched repository paths
	Diff          string              // unified diff of the change under review (§19.1)
	AcceptanceBar string              // what the resolution's proof must show (§5.4)
	Proof         []proof.Artifact    // the proof packet the builder left
	Context       []contextstore.Unit // units routed for the arc's labels/paths (§10)
	Tools         []toolreg.Tool      // capabilities available to the stage (§13)
	Coverage      []string            // finding kinds recent critics under-covered (§19)
	Noisy         []string            // finding kinds recent critics over-flagged (§19)

	// Denied is the inputs config says the critic must not receive (§19.4). It is
	// not something the critic sees; it is what the renderer asserts about what it
	// built. Carried here so the assertion reaches the renderer without a policy
	// argument threaded through Emit and Request.
	Denied []adh.CriticInput

	// PriorGaps is what the previous critic declared it did not examine (§19.2), so
	// this one can start where that one stopped. See Inputs.PriorGaps for why this
	// does not contaminate a cold review.
	PriorGaps []finding.Unexamined
}

type Inputs struct {
	AcceptanceBar string
	Diff          string
	Tools         []toolreg.Tool
	Coverage      []string
	Noisy         []string

	// Denied is `[critic] deny` (§19.4), carried through to the Grounding so the
	// renderer can check the view it builds against it. Policy rather than a
	// grounding fact, and it travels here for the reason the type exists: the
	// alternative is a sixth parameter on Request and a seventh on Emit, threaded
	// through two packages to reach one assertion.
	Denied []adh.CriticInput

	// PriorGaps is what the previous critic declared it did not examine (§19.2).
	//
	// **This is the one input the cold split lets through, and the exception is
	// deliberate.** §19.1 withholds exactly one thing, the builder's transcript, and
	// that is what makes the critic cold. A previous critic's *coverage* is neither
	// the builder's reasoning nor a conclusion about the change — it is a record of
	// angles already taken, so feeding it forward steers a fresh critic toward
	// unexamined ground. That is the opposite of the contamination the split prevents.
	PriorGaps []finding.Unexamined
}

type PrecisionEntry struct {
	Arc         string   `json:"arc"`
	Confirmed   []string `json:"confirmed,omitempty"`
	Unconfirmed []string `json:"unconfirmed,omitempty"`
}

type Reply struct {
	Findings   []adh.Finding
	Resolution adh.Resolution
	Text       string

	// Unexamined is what a critic declared it did not look at (§19.2). Advisory by
	// construction: finding.Result.HasBlocking iterates diagnostics only, so a
	// declared gap cannot change a verdict however Dispose is written.
	Unexamined []finding.Unexamined
}

type Verdict struct {
	// Confirmed: the named artifact ran and failed. A real defect; blocks.
	Confirmed []adh.Finding

	// Unconfirmed: the artifact ran and passed. A lesson candidate (§11), and the
	// only bucket that is evidence of a false positive.
	Unconfirmed []adh.Finding

	// Unchecked: the artifact could not run — missing, unbuilt, wrong commit.
	//
	// It does not block, and that is a decision rather than an oversight; see
	// ReturnsToExecution. It is also not a lesson candidate: a lesson is drawn from a
	// finding that was checked and did not reproduce, and this one was not checked.
	Unchecked []adh.Finding

	// Reservations are findings that passed adjudication with a measurement worse
	// than baseline. They do not block — a regression inside the bar is information,
	// and blocking on it would make Fail and Baseline the same threshold — but an arc
	// that advances carrying one has cost something, and that used to be invisible.
	Reservations []adh.Finding

	// Refused is the subset of Unchecked whose artifact was a **registered** tool
	// that could not start, as opposed to a finding naming nothing or naming a tool
	// the repository never declared.
	//
	// The distinction is §19.2's stated blocker: the decision not to block on an
	// unchecked finding rests on the two being inseparable, and they are not. Kept as
	// a subset rather than a fourth bucket so the partition above stays a partition —
	// every finding is still in exactly one of the three.
	Refused []adh.Finding
}