bedikah: the paired reading — one weight, one measure (bishe'arecha step 2)

Devarim 25:13–16 even va'aven; Vayikra 19:15; Shemot 23:2. Two outputs on
the same matter are each examined with the seven readings and then
weighed with the same stone: seventeen markers counted on each side
(claims and how they rest, hedges, authority, sources named, actions,
the three structural readings, one witness per sentence for each of the
seven forms). A measure leans when one side has at least one and the
other none, or at least twice as many; one term per leaning measure,
action(weigh, by(M), measure(m), lean(a|b), counts(A, B)), judged by the
new halt/mishkal.pl (halt_check_even_vaaven/2). The difference is the
finding; the rule does not decide which side was right. Consensus is not
a measure.

POST /courtyard/bedikah/pair {model, a: {output, query, sources}, b: {...}}
→ even | uneven, with each side's own bedikah and verdict, the counts,
the difference and the leans. Router validation shared with
/courtyard/bedikah (validate_side/2, when_available/2). Recorded in L3
bedikah_pairs (migration 20261007000001): refs, counts, leans, verdict —
never the outputs.

Tamid §1.1 contract, vayakhel §3.9 note, bishearecha §VI marked built.
Doorpost f90870d4…. Elixir 568/0 (+L3 8/0), Prolog bedikah 39/39.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

specs/bishearecha.md

@@ -182,7 +182,12 @@ output is condemned by it. `POST /courtyard/bedikah/pair`. Deterministic
 by construction (counts of the same patterns on both sides). The
 archive's own suggestion — paired probes — is this verse.
 
-**Status.** Not built. The readings exist; the scale does not.
+**Status.** Built (2026-10-07): `POST /courtyard/bedikah/pair`,
+`VavPipeline.Bedikah.Pair`, `halt/mishkal.pl` (`halt_check_even_vaaven/2`),
+L3 `bedikah_pairs`. Seventeen measures; a lean is one against none or at
+least twice as many. Tamid §1.1 has the shape. The mirror itself — the
+same question with the parties exchanged — is still composed by the
+caller; the gate (§I) will compose it.
 
 ## VII. Rebuke, not hatred in the heart — Vayikra 19:17
 
@@ -292,6 +297,7 @@ In the order the text argues it, and by dependency:
 1. **Two witnesses for check 7** (V.b) — smallest change, largest effect
    on precision; no new dependency. *Done 2026-10-07.*
 2. **The paired reading** (VI) — the readings exist; add the scale.
+   *Done 2026-10-07.*
 3. **Rule anchors verified against L1** (X) — the checks grounded.
 4. **The gate** (I), with the fringe (III) and the rebuke (VII) — the
    architecture's centre; the first three make it worth standing at.

specs/shorashim_tamid.md

@@ -295,6 +295,55 @@ references, claims with their anchors, authority claims, actions, the
 sentences read for checks 4–6, the forms found for check 7, trace, violations, verdict.
 ```
 
+**The paired reading — one weight, one measure** (`bishearecha.md` §VI;
+Devarim 25:13–16, Vayikra 19:15, Shemot 23:2; `halt/mishkal.pl`,
+`VavPipeline.Bedikah.Pair`). Two outputs on the same matter — the same
+question with the parties exchanged, or two models asked the same
+thing — are each examined as above (two bedikot, two units of manna),
+and then weighed: the same seventeen markers are counted on each side
+(`claims`, `hedged_claims`, `grounded_claims`, `ungrounded_claims`,
+`authority_claims`, `references`, `actions`, `self_validation`,
+`self_promotion`, `excluded_adversarial`, and one witness per sentence
+for each of the seven forms). A measure **leans** when one side has at
+least one and the other none, or at least twice as many. One term per
+leaning measure, `action(weigh, by(<model>), measure(<m>), lean(a|b),
+counts(A, B))`, to `halt_check_even_vaaven/2`. The difference is the
+finding; the rule names the uneven measure and does not decide which
+side was right. Consensus is not a measure. Recorded in L3
+(`bedikah_pairs`, append-only): the two bedikah refs, counts on each
+side, the leans, verdict — never the outputs.
+
+```
+Endpoint: POST /courtyard/bedikah/pair      (courtyard key; counts as one knock)
+
+Request:
+{
+  "model": "gpt",                         # the pair's model; a side may name its own
+  "a": { "output": "...", "query": "...", "sources": [...] },   # as /courtyard/bedikah
+  "b": { "output": "...", "query": "...", "sources": [...] }
+}
+
+Response (200):
+{
+  "pair_ref": "pair-<16 hex>",
+  "verdict": "even" | "uneven",
+  "violations": ["halt(even_vaaven, action(weigh, ...), hedged_claims, ...)", ...],
+  "a": { "bedikah_ref", "model", "verdict", "violations", "words", "measures": {"<m>": n, ...} },
+  "b": { ... },
+  "difference": { "<m>": a − b, ... },
+  "leans": [ {"measure", "lean": "a"|"b", "a": n, "b": n, "term", "violations"} ],
+  "measures": [ "claims", ... ],          # the stone, in order
+  "meaning": "...", "limits": "...", "disclosure": { ... }
+}
+
+  even   — no measure leans. Not "both outputs are tov": each side's own
+           verdict is under a and b.
+  uneven — at least one measure leans; the leans say which and which side.
+
+Errors: as /courtyard/bedikah, with "side 'a': …" / "side 'b': …" in the
+message; a missing side is 422.
+```
+
 **Anchoring is deterministic and lexical** (`korban_processor/bedikah.py`):
 a claim is anchored in a source when six consecutive words of it occur
 there (`quote`), or when at least 60 % of its content words — and at

specs/shorashim_vayakhel.md

@@ -500,7 +500,7 @@ reference, a root or quoted Hebrew anchors it in `torah`; "the Torah
 requires…" only *invokes* Torah.
 Errors: `{"status": "error", "code": PARSE_ERROR | INVALID_REQUEST | UNKNOWN_ACTION | EMPTY_OUTPUT | UNKNOWN_PROVENANCE | EXAMINATION_FAILED, "message": "..."}`.
 
-**What the pipeline does with it** (`VavPipeline.Bedikah`): each authority claim → `halt_check` of `action(claim_authority, source(<provenance>), target(self))`; each claim → `coupled(claim(N), source(<id>))` per anchor, `coupled(claim(N), self_output)` if it leans on itself, `coupled(claim(N), not_in_sources)` if anchored nowhere (omitted when hedged); the references, roots and Hebrew words → `coupled(reference(devarim_6_5), verse(devarim, 6, 5))`, `coupled(root(קטל), not_in_torah)`, … — Torah as one given source, with L1 checking that what was cited exists. The trace goes to `halt_check_interpretation` with `"ground": "given"` and confidence `high` (or `low` when every claim is hedged); the engine applies `halt_check_given_golden_calf/2` and `halt_check_given_self_grounding/2` (avodah_zarah.pl), which accept `source(_)` as a terminal beside the L1 primitives. Its own interpretations keep the L1-only rules. If no sources were given, no claim invokes a source and nothing leans on itself, the grounding check is reported `assessed: false` with the reason and the verdict comes from the other two checks. Each action term → `halt_check`. Each of the three structural readings that found anything → one `halt_check` of `action(self_validate | self_promote | exclude_adversarial, by(<provenance>), target(self | output))`, judged by `talmudic_engine/src/halt/structure.pl` (`parah_adumah`, `carrier_centered`, `chelbenah`); `by/1` rather than `source/1` so that Form 1 does not also fire. Each form of check 7 found → one `halt_check` of `action(frame, by(<provenance>), form(<form>))`, judged by `halt/lo_taaseh_lekha.pl`. The two Talmudic requests are the §3.3 socket's `halt_check` (with a `"term"` string) and `halt_check_interpretation` (`{"ref", "confidence", "ground", "coupling_trace": [...]}`). Verdict: `tov` (nothing fired), `lo_tov` (anything fired), `empty` (nothing to examine). Recorded in L3 `bedikot` per §3.8; neither the output nor the sources are stored, only their SHA-256 and lengths; the sentences read for checks 4–6 are stored (`bedikot.structure`), the forms of check 7 in `bedikot.frames`.
+**What the pipeline does with it** (`VavPipeline.Bedikah`): each authority claim → `halt_check` of `action(claim_authority, source(<provenance>), target(self))`; each claim → `coupled(claim(N), source(<id>))` per anchor, `coupled(claim(N), self_output)` if it leans on itself, `coupled(claim(N), not_in_sources)` if anchored nowhere (omitted when hedged); the references, roots and Hebrew words → `coupled(reference(devarim_6_5), verse(devarim, 6, 5))`, `coupled(root(קטל), not_in_torah)`, … — Torah as one given source, with L1 checking that what was cited exists. The trace goes to `halt_check_interpretation` with `"ground": "given"` and confidence `high` (or `low` when every claim is hedged); the engine applies `halt_check_given_golden_calf/2` and `halt_check_given_self_grounding/2` (avodah_zarah.pl), which accept `source(_)` as a terminal beside the L1 primitives. Its own interpretations keep the L1-only rules. If no sources were given, no claim invokes a source and nothing leans on itself, the grounding check is reported `assessed: false` with the reason and the verdict comes from the other two checks. Each action term → `halt_check`. Each of the three structural readings that found anything → one `halt_check` of `action(self_validate | self_promote | exclude_adversarial, by(<provenance>), target(self | output))`, judged by `talmudic_engine/src/halt/structure.pl` (`parah_adumah`, `carrier_centered`, `chelbenah`); `by/1` rather than `source/1` so that Form 1 does not also fire. Each form of check 7 that stands on two witnesses (Tamid §1.1) → one `halt_check` of `action(frame, by(<provenance>), form(<form>))`, judged by `halt/lo_taaseh_lekha.pl`. The paired reading (`VavPipeline.Bedikah.Pair`, `POST /courtyard/bedikah/pair`) runs two examinations and sends one `halt_check` of `action(weigh, by(<provenance>), measure(<m>), lean(a|b), counts(A, B))` per leaning measure, judged by `halt/mishkal.pl` (`even_vaaven`); recorded in L3 `bedikah_pairs`. The two Talmudic requests are the §3.3 socket's `halt_check` (with a `"term"` string) and `halt_check_interpretation` (`{"ref", "confidence", "ground", "coupling_trace": [...]}`). Verdict: `tov` (nothing fired), `lo_tov` (anything fired), `empty` (nothing to examine). Recorded in L3 `bedikot` per §3.8; neither the output nor the sources are stored, only their SHA-256 and lengths; the sentences read for checks 4–6 are stored (`bedikot.structure`), the forms of check 7 in `bedikot.frames`.
 
 ---