# Verifier pass — condition C's separate coverage-gate (independent of the solver)

This is the **separate verifier pass** that enforces condition C's discipline. It runs AFTER a C solver
produces a design, in a fresh context, with catalog (encyclopedia) access. It does NOT see the solver's
self-reported coverage map as ground truth, and it never sees the experiment's private operative-pattern
notes — it identifies the operative pattern independently, so the gate is enforced, not self-asserted.

Paste: the SCENARIO text + the candidate DESIGN (the solver's recommendation block, and optionally its
working). Then:

```
You are an independent verifier with access to a catalog of cross-domain solution patterns (the encyclopedia
tools). You are given a design problem and a candidate design. Your job is ONLY to check coverage — not to
rewrite or improve the design, and not to grade its quality.

[PASTE SCENARIO]

[PASTE CANDIDATE DESIGN]

Steps:
1. Using the catalog (search_archetype / find_archetypes_for_prime / get_archetype), independently identify
   the 1-2 solution patterns (archetypes) whose logic this problem most calls for. Name them and list the
   full set of components each pattern specifies (get_archetype `components`).
2. For EACH component of the operative pattern(s), judge — from the candidate design ALONE — whether the
   design:
     [instantiated]        builds a concrete mechanism that performs it (quote the part of the design),
     [homolog]             discharges the same function by a different mechanism (name it),
     [correctly_declined]  legitimately omits it (the component does not apply to THIS problem, or forcing it
                           would distort something the design already handles well — explain), or
     [missing]             should be present given the problem's stakes but is absent (explain the gap).
3. Output a coverage map: one line per component -> status -> one-clause justification.
4. VERDICT: 'PASS' if no component is [missing]; otherwise 'REVISE' and list exactly which components are
   [missing] and the gap each leaves.

Be strict but fair: [correctly_declined] is a legitimate status — do not mark a component [missing] if the
design gives a sound reason it does not apply here. Judge coverage of FUNCTION, not vocabulary.
```

If the verdict is REVISE, the C solver is given the list of missing components and runs ONE more round to
instantiate / homolog / justify-declining each, then re-verified (cap: 2 verifier rounds). The number of
verifier rounds and any revision is logged in the cell's cost. A PASS on the first try is logged too (it
means C's self-discipline already satisfied the external check — still a real datum about C).
