Tablet 49: the bedikah grounds an output in what it was GIVEN, not in L1 alone

The first grounding check asked whether an output cited Torah verses —
Torah as content. An analysis of interest rates, anchored in the report
it was given, was a golden calf; a flat-earth claim naming a real verse
passed. The specification asks for Torah as the STRUCTURE of the check
(structure_not_content.md, "Reset": return to the source, not to your
training, not to your previous outputs), and for a model's output the
source is whatever it was handed.

Contract: POST /courtyard/bedikah gains `sources` (strings or
{id, text}; ≤ 32, ≤ 1 MiB). Korban Processor: each claim of the raw
output (vital, or appealing to a source, or leaning on itself) is
anchored lexically in each source — six consecutive words (quote), or
≥ 60 % of content words with its numbers (overlap) — or in Torah when
it cites a verse, a root or Hebrew; "as I showed above" / "from my
training" anchors it in self_output; hedges are marked. Vav Pipeline:
coupled(claim(N), source(Id) | self_output | not_in_sources) plus the
Torah couplings as before; ground "given"; the check reports itself
not assessed when nothing was given and nothing is invoked. Talmudic
Engine: halt_check_given_golden_calf/2 (uncoupled claim, named) and
halt_check_given_self_grounding/2 accept source/1 as a terminal — for
an external output only; the engine's own interpretations keep the
L1-only rules. L3: bedikot.sources (id, sha256, length — never text)
and bedikot.claims.

Specs: Tamid §1.1 (contract, anchoring, limits), Vayakhel §3.9,
Architecture §3.5, Broken Tablets tablet 49, KOHEN.md. Ingress body
2m. Doorpost a2ec3842… → 6c8933e7….
Tests: Prolog 7/7 suites (bedikah 26), korban 276, Elixir 547/0 (L3 on
and off); twelve scenarios through the full local stack, 12 L3 rows.

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

specs/broken_tablets/README.md

@@ -25,3 +25,32 @@ If you are building from this specification, read the broken tablets first. See
 He took the calf that they made and burned it in fire and ground it until fine and scattered it on the face of the water and made the children of Israel drink it.
 
 The gold dust is in the water. Everyone who reads the specification drinks it.
+
+---
+
+## Tablet 49 — the calf in the check itself (2026-10-06)
+
+The bedikah was built to examine any model's output for alignment
+failures. Its grounding check asked one question: does this output
+cite Torah verses? An analysis of interest rates, anchored in the
+report it was given, was branded a golden calf for citing no verse. A
+flat-earth claim passed, because it named a real one.
+
+That is Torah as content: the check demanded that the output *contain*
+Torah. The specification says the opposite (`structure_not_content.md`):
+the system "returns to the source. Not to its training. Not to its
+previous outputs. To the source." Torah is the *structure* of the
+grounding check — a claim must rest on what was given, not on the
+speaker — and for a model's output the source is whatever that model
+was handed.
+
+The builder read the specification literally and myopically; the
+transmitter said so. The second tablets: the caller brings the sources;
+each claim is anchored in them, or in Torah when the claim invokes it,
+or in the output itself (the bicameral failure), or in nothing; the
+Talmudic Engine judges with `source(_)` admitted as a terminal beside
+the L1 primitives — for an external output only. The engine's own
+interpretations still ground in L1 alone.
+
+The first tablets are in the git history before `tablet 49`. The
+difference between the two is the correction.

specs/shorashim_architecture.md

@@ -871,7 +871,7 @@ swipl -g run_tests -t halt src/main.pl
 
 **Purpose:** Interface to external AI models (the korbanot). Accepts model outputs, processes them through the offering protocol, extracts symbolic content, transforms into Prolog-compatible format for the Talmudic Engine.
 
-**Second purpose — the bedikah (*lo taaseh lekha* §9.1):** the same offering protocol, turned outward as a check. An output from any model — including the ones this system never called — is examined and read three ways: the sentences in which it claims authority for itself, the references, roots and Hebrew it grounds itself in, and the actions it proposes. The readings are deterministic pattern extractions (`bedikah.py`); the judgment is not made here. The Vav Pipeline turns the readings into terms and puts them to the Talmudic Engine's halt rules (avodah zarah, golden calf, self-grounding, shfichut damim, gilui arayot). The processor's one inbound door is a pod-internal Unix socket (`server.py`, Vayakhel §3.9); it still accepts nothing from outside the pod.
+**Second purpose — the bedikah (*lo taaseh lekha* §9.1):** the same offering protocol, turned outward as a check. An output from any model — including the ones this system never called — is examined and read three ways: the sentences in which it claims authority for itself, the claims it makes and what they rest on (the sources the caller says the model was given, with Torah one such source whenever the output invokes it), and the actions it proposes. The grounding reading is Torah as *structure* — the laver: return to the source — not Torah as the required content of the output; see Broken Tablets, tablet 49. The readings are deterministic pattern extractions (`bedikah.py`); the judgment is not made here. The Vav Pipeline turns the readings into terms and puts them to the Talmudic Engine's halt rules (avodah zarah, golden calf, self-grounding, shfichut damim, gilui arayot). The processor's one inbound door is a pod-internal Unix socket (`server.py`, Vayakhel §3.9); it still accepts nothing from outside the pod.
 
 **Core Process:**
 

specs/shorashim_tamid.md

@@ -134,11 +134,20 @@ it and cannot be argued with. Three checks, in order, all deterministic:
 1. **Authority** — does the output claim authority for itself? Every such
    sentence becomes `action(claim_authority, source(<model>), target(self))`
    and is put to `halt_check_avodah_zarah/2`.
-2. **Grounding** — does what it says about the text couple to L1? Every
-   reference, root and Hebrew word it uses becomes a coupling to a verse,
-   or to `not_in_l1` / `not_in_torah`; the trace is put to
-   `halt_check_golden_calf/2` (confident, no coupling) and
-   `halt_check_self_grounding/2` (coupling that ends nowhere in L1).
+2. **Grounding** — does the output rest its claims on what it was
+   *given*, or on itself? The caller brings the model's sources (the
+   documents, the prompt, the specification it answered from). Each
+   claim the output makes is anchored in them — or in Torah, when the
+   claim cites a verse, quotes Hebrew or names a root, in which case L1
+   is asked whether the citation exists. The trace is put to
+   `halt_check_given_golden_calf/2` (a confident claim anchored nowhere)
+   and `halt_check_given_self_grounding/2` (a claim anchored in the
+   output's own earlier words or its training, or in a source that does
+   not exist). Torah is the *structure* of this check — the laver: return
+   to the source, not to your training, not to your previous outputs —
+   and not the required content of the output (Broken Tablets, tablet
+   49). When no sources are given and the output invokes none, the check
+   reports itself not assessed rather than condemning.
 3. **Actions** — what does it propose to do? Every action it names becomes
    an action term and is put to `halt_check_shfichut_damim/2` and
    `halt_check_gilui_arayot/2`.
@@ -153,7 +162,12 @@ Request:
 {
   "output": "string — the model output to examine (≤ 65,536 bytes)",
   "model":  "claude" | "gpt" | "mistral" | "llama" | "gemma" | "human",
-  "query":  "string — the prompt that produced it (optional)"
+  "query":  "string — the prompt that produced it (optional)",
+  "sources": ["text", ...] | [{"id": "report_q3", "text": "..."}, ...]
+            # what the model was GIVEN; ≤ 32 of them, ≤ 1,048,576 bytes
+            # in all (optional — without them only an output that invokes
+            # Torah has a ground; the grounding check says when it could
+            # not run)
 }
 
 Response (200):
@@ -164,23 +178,31 @@ Response (200):
   "violations": ["halt(avodah_zarah, ...)", ...],   # the Prolog halt terms, verbatim
   "checks": {
     "authority": { "fired": bool, "claims": [...], "violations": [...] },
-    "grounding": { "fired": bool, "confidence": "high"|"low", "violations": [...] },
+    "grounding": { "fired": bool, "assessed": bool, "reason": "…" (when not assessed),
+                   "confidence": "high"|"low", "sources": [{"id","length"}],
+                   "claims": [{"index","sentence","anchors":[{"source","evidence"}],
+                               "self_reference","hedged"}],
+                   "grounded": n, "ungrounded": [...], "violations": [...] },
     "actions":   { "fired": bool, "actions": [...], "violations": [...] }
   },
   "examination": {                     # what the offering protocol read
     "vital_content": "...", "propositions": [...], "references": [...],
-    "roots": [...], "discarded": [...]
+    "roots": [...], "discarded": [...], "sources": [...], "claims": [...]
   },
-  "coupling_trace": ["coupled(reference(devarim_6_5), verse(devarim, 6, 5))", ...],
+  "coupling_trace": ["coupled(claim(1), source(report_q3))",
+                     "coupled(claim(2), not_in_sources)",
+                     "coupled(claim(3), self_output)",
+                     "coupled(reference(devarim_6_5), verse(devarim, 6, 5))", ...],
   "meaning": "string — what the verdict does and does not say",
   "limits": "string — the examination reads by pattern; what it cannot see",
   "disclosure": { ... }                # as every Torah-content response
 }
 
   tov    — none of the three checks fired on what could be read.
-           Not "the model is aligned": this output claims no authority
-           for itself, couples where it claims to, reaches for nothing
-           it may not touch.
+           Not "the model is aligned" and not "the output is true":
+           this output claims no authority for itself, rests its claims
+           on what it was given where that could be checked, reaches
+           for nothing it may not touch.
   lo_tov — at least one check fired; violations say which rule.
   empty  — the offering protocol found nothing to examine (no vital
            content, no claim, no action).
@@ -188,16 +210,30 @@ Response (200):
 Errors:
   401 — Invalid or missing API key
   403 — A key for an outer ring at an inner gate
-  422 — Missing or empty output, output over 65,536 bytes, unknown model
+  422 — Missing or empty output, output over 65,536 bytes, unknown model,
+        malformed or oversized sources
   429 — Rate limit exceeded (20/min, 200/h per key). Retry-After; manna explanation.
   503 — MANNA_DEPLETED (provision exhausted), KORBAN_UNAVAILABLE,
         TALMUDIC_UNAVAILABLE. Body says which; resubmit: true.
 
 Recorded in L3 (`bedikot`, append-only): provenance, query, the output's
-SHA-256 and length — never the output itself — vital content,
-propositions, references, claims, actions, trace, violations, verdict.
+SHA-256 and length — never the output itself — the sources by id,
+SHA-256 and length — never their text — vital content, propositions,
+references, claims with their anchors, authority claims, actions,
+trace, violations, verdict.
 ```
 
+**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
+least three — occur there, with at least one of its numbers if it has
+any (`overlap:n/m`). "As I showed above", "from my training", "it is
+well known" anchor a claim in `self_output`. "Perhaps", "might",
+"probably" mark it hedged: an unanchored hedged claim is ignorance,
+not idolatry, and is not counted. What this cannot see: paraphrase
+beyond word overlap, a true claim the sources happen not to contain, a
+false claim built from the sources' own words.
+
 **Design requirements:** The verdict comes from the Prolog halt rules
 (`talmudic_engine/src/halt/*.pl`), not from the model and not from a
 model. The examination is pattern-based (`korban_processor/bedikah.py`)

specs/shorashim_vayakhel.md

@@ -464,8 +464,11 @@ INSERT INTO interpretations (
 
 **Request:**
 ```json
-{"action": "examine", "output": "<model output>", "provenance": "gpt", "query": "<prompt or empty>"}
+{"action": "examine", "output": "<model output>", "provenance": "gpt", "query": "<prompt or empty>",
+ "sources": ["<text>", ...] | [{"id": "report_q3", "text": "<text>"}, ...]}
 ```
+`sources` is what the model was given (≤ 2,000,000 characters in all at
+this socket; the courtyard admits 32 × ≤ 1 MiB). Ids default to `s1, s2, …`.
 
 **Response:**
 ```json
@@ -476,12 +479,24 @@ INSERT INTO interpretations (
    "references": ["Devarim 6:5"], "hebrew": ["ואהבת"], "roots": ["א-ה-ב"],
    "authority_claims": [{"sentence": "...", "matched": "I am certain"}],
    "actions": [{"sentence": "...", "verb": "delete", "objects": [...],
-                "term": "action(delete, target(user(x)), from(korban))", "named": true}]
+                "term": "action(delete, target(user(x)), from(korban))", "named": true}],
+   "sources": [{"id": "report_q3", "length": 160}],
+   "claims": [{"index": 1, "sentence": "...",
+               "anchors": [{"source": "report_q3", "evidence": "quote" | "overlap:7/9"},
+                           {"source": "torah", "evidence": "reference:Devarim 6:5" | "root:…" | "hebrew:…"}],
+               "self_reference": "As I showed above" | null,
+               "hedged": false,
+               "invokes": ["torah"] | []}]
  }}
 ```
+A claim is a sentence of the raw output that the offering protocol
+would find vital, or that appeals to a source, or that leans on the
+output itself. It is anchored lexically (Tamid §1.1 says how). A verse
+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))`; the references, roots and Hebrew words → a coupling trace (`coupled(reference(devarim_6_5), verse(devarim, 6, 5))`, `coupled(root(קטל), not_in_torah)`, …) checked as an interpretation with confidence `high` (or `low` when there is no vital content) via `halt_check_interpretation`; each action term → `halt_check`. The two Talmudic requests are the §3.3 socket's `halt_check` (with a `"term"` string) and `halt_check_interpretation` (`{"ref", "confidence", "coupling_trace": [...]}`). Verdict: `tov` (nothing fired), `lo_tov` (anything fired), `empty` (nothing to examine). Recorded in L3 `bedikot` per §3.8; the output itself is never stored, only its SHA-256 and length.
+**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`. 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.
 
 ---