Coordinator, not arbiter — who handles failure

Parent: recursive-harness

root-protocol's clause 5 says fail loudly — but loudly to whom? Does the tree need a standing arbiter/coordinator role for failures? The answer, adapted from the architecture SAT solvers converged on: the function is necessary; a standing intelligent arbiter is an anti-pattern.

The prior art: DPLL(T)'s division of labor

In an SMT solver (llm-as-fallible-theory-solver), the SAT core is the coordinator: it owns the assignment, the learned-clause store, and the backjump computation — all mechanical. Theory solvers only validate or report conflicts. Nobody "arbitrates" with judgment; the architecture makes arbitration a graph computation.

Why the function is necessary — two things no single node owns

1. The no-good store must be global. A learned conflict ("this decomposition shape collapses, because X") locked inside the failing parent lets sibling subtrees walk the same dead end. Per conflict-learning-and-backjumping: assignments backtrack locally, but knowledge is monotone and global.
2. Backjump targets are cross-subtree. The culprit behind a failing child may be the grandparent's architecture decision, or a SIBLING subtree's artifact reaching in through a shared interface. Passing failures up parent-by-parent is chronological backtracking — every intermediate level wastes budget retrying local fixes while the real culprit sits three levels up. The backjump target must be computed from the conflict, not from the tree shape.

The key adaptation: implication graph = provenance graph

CDCL's conflict analysis is mechanical because the implication graph is recorded. The harness equivalent: root-protocol clause 4 already makes every step declare its inputs and heading — record "which decisions fed which artifact" as dependency edges (round-tree-flight-recorder) and conflict analysis becomes graph traversal: purely mechanical. The lesson of CDCL is not "have an arbiter"; it is "record provenance so that arbitration needs no intelligence."

Why NOT a standing LLM arbiter

The arbitration seat decides where the whole search jumps next — it is the highest-leverage position in the system. Installing a fallible component (its own ε, its own α) at maximum leverage turns the honest-caveats amplifier to full: a wrong backjump wastes entire subtrees, and a Goodharted arbiter steers the whole search. So:

• Coordinator = the mechanical kernel: no-good store + provenance graph + the B/α ledgers of root-protocol + backjump computation. Deterministic, auditable, zero-α. (Concretely: the state-machine-plus-sqlite harness kernel — the SAT-core isotope.)
• Semantic conflict diagnosis, when provenance is not enough ("these two sibling artifacts are incompatible — whose fault?") is NOT a standing role but one more gated fallible move: it produces an artifact (the diagnosed no-good / conflict clause) that passes a gate like everything else.

The closing loop: legible checks pre-localize conflicts

coupling-to-the-learner's principle — checks emit gradients, not verdicts — pays again here: a conflict that arrives already localized (which assertion, which input, expected vs got) needs no semantic arbitration at all. The more legible the gates, the more mechanical the coordination.

Failure handling needs a bookkeeper, not a judge — record provenance and the judging reduces to graph traversal; where judgment remains, it is one more gated move, never a throne.