Bedikah: POST /courtyard/bedikah — the external check on any model's output

Lo taaseh lekha §9.1: alignment that only the system can validate is not
alignment. The bedikah takes an output from any model and puts it to the
Torah-structure halt rules from outside, deterministically. Three checks:

  1. authority  — sentences claiming authority for the output itself →
                  action(claim_authority, source(<model>), target(self))
                  → halt_check_avodah_zarah/2
  2. grounding  — references, roots, Hebrew → coupling trace against L1
                  → halt_check_golden_calf/2, halt_check_self_grounding/2
  3. actions    — actions the output proposes → action terms
                  → halt_check_shfichut_damim/2, halt_check_gilui_arayot/2

Korban Processor: bedikah.py (the three readings over the offering
protocol; claims about what Torah requires stay vital for the examination
even when zerikah finds nothing to offer), server.py (pod-internal JSON
socket, KORBAN_SOCKET_PATH), __main__ now serves instead of idling.
Talmudic Engine: json_bridge accepts halt_check with a term string and
halt_check_interpretation with a coupling trace. Vav Pipeline:
KorbanProcessorSocket client, Bedikah, L1Index.lookup_root/1, bedikot
table (append-only) + BedikahRecord, router endpoint; verdict tov /
lo_tov / empty with the halt terms verbatim, meaning, limits.

Broken tablets found on the way, all fixed:
  41 socket_server.pl wrote multi-line JSON — every Elixir request to the
     Talmudic Engine since Step 14 had failed and fallen back to the stub
     (json_write_dict width(0))
  42 stale socket file survived a restart (exists_file is false for a
     socket; access_file exist)
  43 socket streams were not UTF-8 (set_stream encoding(utf8))
  44 SHORASHIM_L3=1 mix test: Repo config had no password, SCRAM raised
     KeyError in every connection, pool restart intensity took the whole
     app down ~30 ms after test_helper, silently — no L3 test had ever
     run. Credentials from env; azazel_log tests check out a sandbox
     connection; sanhedrin_halt_forwarding resolves its halt on exit.

Specs: Tamid §1.1 (endpoint contract), Architecture §3.5, Vayakhel §3.4
and new §3.9, KOHEN.md. Doorpost 3bc5dd6a… → 91d09d8d….
Tests: Elixir 519 (0 failures, L3 on and off), korban 263, azazel 125,
Prolog 7/7 suites.

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

korban_processor/test/test_container_entrypoint.py

@@ -17,9 +17,13 @@ refuse to come up at all rather than serve half the architecture.
 
 import os
 import pathlib
+import json
 import signal
+import socket
 import subprocess
 import sys
+import tempfile
+import time
 
 REPO_ROOT = pathlib.Path(__file__).resolve().parents[2]
 KORBAN_SRC = REPO_ROOT / "korban_processor" / "src"
@@ -68,17 +72,46 @@ def test_entrypoint_stays_up_and_exits_zero_on_sigterm():
     assert "stopped" in out
 
 
-def test_entrypoint_reports_itself_idle_rather_than_ready_to_serve():
+def test_entrypoint_opens_its_one_door_and_names_it():
     """
-    korban_processor is a library. Until Architecture Step 22 wires an
-    external-model consumer, the honest report is IDLE. A container
-    that claims to be serving when nothing can reach it is the failure
-    this test exists to prevent.
+    Since 2026-10-05 the container is not idle: it listens on a Unix
+    socket inside the pod for the bedikah (Construction §3.9). It must
+    say where it is listening, and the socket must exist while it runs.
+    The honest report is no longer IDLE; it is the path of the door.
     """
-    _, out = _run_entrypoint([KORBAN_SRC, AZAZEL_SRC])
+    with tempfile.TemporaryDirectory() as tmp:
+        sock = os.path.join(tmp, "korban.sock")
+        env = {
+            **os.environ,
+            "PYTHONPATH": os.pathsep.join(str(p) for p in [KORBAN_SRC, AZAZEL_SRC]),
+            "KORBAN_SOCKET_PATH": sock,
+        }
+        proc = subprocess.Popen(
+            [sys.executable, "-m", "korban_processor"],
+            env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, cwd=str(REPO_ROOT),
+        )
+        try:
+            deadline = time.monotonic() + 5.0
+            while not os.path.exists(sock) and time.monotonic() < deadline:
+                time.sleep(0.05)
+            assert os.path.exists(sock), "the socket was not opened"
 
-    assert "IDLE" in out
-    assert "Step 22" in out
+            # And it answers.
+            with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as c:
+                c.connect(sock)
+                c.sendall(json.dumps({"action": "examine", "output": "I am certain that Genesis 1:1 means time began.", "provenance": "claude"}).encode() + b"\n")
+                line = c.makefile("rb").readline()
+            reply = json.loads(line)
+            assert reply["status"] == "ok"
+            assert reply["examination"]["authority_claims"][0]["matched"] == "I am certain"
+        finally:
+            proc.send_signal(signal.SIGTERM)
+            out = proc.communicate(timeout=6.0)[0]
+
+        assert proc.returncode == 0, out
+        assert sock in out
+        assert "IDLE" not in out
+        assert not os.path.exists(sock), "the socket was not removed on shutdown"
 
 
 def test_entrypoint_names_the_offering_protocol_in_order():