awdecide 0.3.0__py3-none-any.whl

awdecide/__init__.py

@@ -0,0 +1,38 @@
+"""awdecide -- Aither World Decide.
+
+One typed-decision contract -- choice / score / bool with a probability -- over
+a ladder of backends you already run (rules, any local model as a callable, an
+OpenAI-wire model's logprobs), fail-closed (decided=False is an answer), with a
+Brier ledger that resolves every decision against its outcome and reports
+whether the probabilities carry information beyond the base rate.
+
+    from awdecide import Question, Ladder, RulesBackend, Ledger
+
+    q = {"category": Question.choice(["billing", "technical", "sales"]),
+         "urgent": Question.bool(min_confidence=0.7)}
+    answers = Ladder([RulesBackend([(r"refund|invoice", "billing")])]).decide(state, q)
+    answers["category"].value, answers["category"].probability, answers["urgent"].decided
+
+Stdlib only. Nothing here sends the state anywhere you did not name.
+"""
+from .backends import (
+    Backend,
+    CallableBackend,
+    Ladder,
+    LogprobBackend,
+    RulesBackend,
+    default_ladder,
+    parse_question_spec,
+)
+from .contract import Decision, Question, from_probabilities, normalize, undecided
+from .door import DoorBackend, decision_from_door, door_request
+from .ledger import Ledger
+from .loop import ChatBackend, Loop
+
+__version__ = "0.3.0"
+__all__ = [
+    "Backend", "CallableBackend", "Ladder", "LogprobBackend", "RulesBackend",
+    "default_ladder", "parse_question_spec", "Decision", "Question",
+    "from_probabilities", "normalize", "undecided", "Ledger", "DoorBackend",
+    "decision_from_door", "door_request", "ChatBackend", "Loop", "__version__",
+]

awdecide/__main__.py

@@ -0,0 +1,7 @@
+"""python -m awdecide"""
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

awdecide/_doctor.py

@@ -0,0 +1,190 @@
+"""Stack-aware `doctor` for awdecide.
+
+GENERATED BY gen_aw_doctor.py -- DO NOT EDIT.
+Regenerate it with the generator named above; a hand-edit here is reverted by
+the next run and fails the parity gate.
+
+Why a doctor exists at all: the aw* bricks are designed to COMPOSE, so the
+interesting failures live BETWEEN them. "awdecide is installed" is not the useful
+fact -- "awdecide is installed and the thing it pairs with is not" is. This reports
+the whole stack, not just itself.
+
+stdlib only, on purpose: a diagnostic that cannot run because a dependency is
+missing is worthless precisely when you need it.
+"""
+from __future__ import annotations
+
+import importlib.util
+import os
+import shutil
+import sys
+
+#: Frozen from the Aither World registry at generation time. A shipped
+#: package cannot read the registry, and a doctor that guessed at the family
+#: would go stale in silence. Regenerate to update.
+SELF = 'awdecide'
+FAMILY = ['awask', 'awavatar', 'awbac', 'awbrain', 'awbrowse', 'awclassify', 'awdeck', 'awdelphi', 'awdit', 'awembed', 'awevolve', 'awfind', 'awflow', 'awfocus', 'awgit', 'awgraph', 'awgym', 'awiam', 'awkno', 'awm', 'awmail', 'awmine', 'awnboard', 'awnest', 'awnet', 'awnode', 'awpool', 'awpredict', 'awprism', 'awprove', 'awreason', 'awrecover', 'awrecurse', 'awrelay', 'awrena', 'awrepl', 'awreport', 'awresearch', 'awrise', 'awrouter', 'awrtifact', 'awrun', 'awscreen', 'awseal', 'awsettings', 'awshare', 'awsprite', 'awstorage', 'awswarm', 'awtax', 'awtoll', 'awtunnel', 'awvision', 'awvoice', 'awwall', 'gawbbonet']
+PAIRS_WITH = ['awclassify', 'adk', 'awgraph', 'awpredict', 'awprove', 'awrepl', 'awtoll']
+
+#: This brick's OWN config, read out of its source at generation time.
+#: ENV_REQUIRED is `os.environ["X"]` -- absent, that is a KeyError the moment
+#: the line runs. ENV_OPTIONAL is `os.getenv("X")`, which returns None and lets
+#: the caller cope. Only this brick's namespace is listed: reporting the
+#: platform-wide vars it also touches would be noise, and a doctor that floods
+#: gets ignored.
+ENV_REQUIRED = []
+ENV_OPTIONAL = ['AWDECIDE_DB']
+
+
+def _installed(mod: str) -> "str | None":
+    """Version if importable, else None. Never raises -- a broken sibling must
+    not take the diagnostic down with it."""
+    try:
+        if importlib.util.find_spec(mod) is None:
+            return None
+    except (ImportError, ValueError):
+        return None
+    try:
+        from importlib.metadata import PackageNotFoundError, version
+        try:
+            return version(mod)
+        except PackageNotFoundError:
+            return "installed"
+    except Exception:
+        return "installed"
+
+
+def report(out=None) -> int:
+    """Print the stack picture. 0 = this brick and its pairs are present."""
+    out = out or sys.stdout
+    print(f"{SELF} doctor", file=out)
+
+    mine = _installed(SELF)
+    print(f"  self       {SELF} {mine or 'NOT IMPORTABLE'}", file=out)
+    shim = shutil.which(SELF)
+    print(f"  command    {shim or 'not on PATH'}", file=out)
+
+    # The stack. Siblings this brick pairs with are called out separately,
+    # because a missing pair is a REASON, while a missing unrelated brick is
+    # just a fact about your machine.
+    missing_pairs, present = [], []
+    for name in FAMILY:
+        v = _installed(name)
+        if v:
+            present.append(name)
+        elif name in PAIRS_WITH:
+            missing_pairs.append(name)
+    print(f"  stack      {len(present)}/{len(FAMILY)} aw* packages installed",
+          file=out)
+    if present:
+        print(f"             {' '.join(sorted(present))}", file=out)
+
+    missing_req = [v for v in ENV_REQUIRED if not os.environ.get(v)]
+    if ENV_REQUIRED or ENV_OPTIONAL:
+        have = sum(1 for v in ENV_REQUIRED + ENV_OPTIONAL if os.environ.get(v))
+        total = len(ENV_REQUIRED) + len(ENV_OPTIONAL)
+        print(f"  config     {have}/{total} of this brick's own vars set", file=out)
+        if missing_req:
+            # Not a preference. os.environ[...] raises the moment it runs.
+            print(f"             MISSING REQUIRED: {' '.join(missing_req)}", file=out)
+
+    local = _local_checks()
+    for line in local:
+        print(f"  {line}", file=out)
+    problems, unjudged = _local_verdict()
+
+    if mine is None:
+        print(f"\nverdict: {SELF} itself is not importable. Reinstall it before "
+              f"anything else here means much.", file=out)
+        return 1
+    if missing_req:
+        print(f"\nverdict: {SELF} is missing required config "
+              f"({', '.join(missing_req)}). Those are read with os.environ[...], "
+              f"so the code path that needs them raises rather than degrades.",
+              file=out)
+        return 1
+    # A measured NO outranks a missing optional pair: awrise printed
+    # "nothing wakes run-due" and still exited 0 because the missing-pairs
+    # branch returned first (measured 2026-09-20).
+    if problems:
+        for p in problems:
+            print(f"\nverdict: {p}", file=out)
+        return 1
+    if unjudged:
+        for u in unjudged:
+            print(f"\nverdict: UNJUDGED -- could not judge: {u}", file=out)
+        return 2
+    if missing_pairs:
+        print(f"\nverdict: {SELF} works, but pairs with "
+              f"{', '.join(sorted(missing_pairs))} which "
+              f"{'is' if len(missing_pairs) == 1 else 'are'} not installed. "
+              f"That is a capability you are missing, not an error.", file=out)
+        return 0
+    print(f"\nverdict: {SELF} and everything it pairs with are present.", file=out)
+    return 0
+
+
+def _local_verdict() -> tuple:
+    """The brick's OWN verdict, folded into the exit code.
+
+    Without this the local lines are DECORATION. Measured 2026-09-20: awrise
+    printed "hostclock NOT INSTALLED -- nothing wakes run-due" and "last tick
+    never", then exited 0 -- teaching an operator that a doctor exit code
+    carries no information. A brick opts in with `_doctor_local_verdict()`
+    returning (problems, unjudged); a brick without one is unaffected.
+    """
+    try:
+        mod = importlib.import_module(f"{SELF}.doctor_local")
+        problems, unjudged = mod._doctor_local_verdict()
+    except Exception:                              # noqa: BLE001
+        return [], []
+    return list(problems or []), list(unjudged or [])
+
+
+def _local_checks() -> "list[str]":
+    """Per-brick checks, if this package defines them.
+
+    Kept as a HOOK rather than generated guesses: the generator knows the family
+    from the registry, but it does not know what awdecide needs at runtime, and a
+    doctor that invented config requirements would be confidently wrong. A
+    package supplies `_doctor_local()` returning display lines; absent, the
+    stack picture above still stands on its own.
+    """
+    try:
+        mod = importlib.import_module(f"{SELF}.doctor_local")
+    except Exception:
+        return []
+    try:
+        return list(mod._doctor_local())
+    except Exception as exc:                       # noqa: BLE001
+        return [f"local     checks raised {type(exc).__name__}: {exc}"]
+
+
+def main(argv: "list[str] | None" = None) -> int:
+    # --self-test delegates to a SIBLING module when one exists.
+    #
+    # This file is generated and a fresh run replaces it, so a self-test
+    # written HERE is deleted by the next regeneration. awdelphi learned that
+    # the expensive way: 125 lines exercising four real failure paths --
+    # convergence, roster anonymization, resume, gateway-down -- lived in this
+    # file and were destroyed by a routine regeneration, silently, leaving a
+    # --self-test flag that reported PASS while asserting nothing.
+    #
+    # So the seam is a separate module the generator never writes. A package
+    # with real machinery to prove puts it in _selftest.py; everything else
+    # keeps the honest answer below rather than a self-test that only ever
+    # passes.
+    argv = list(argv if argv is not None else __import__("sys").argv[1:])
+    if "--self-test" in argv:
+        try:
+            from . import _selftest as _st
+        except Exception:
+            print("no _selftest module: this doctor reports the stack, and has",
+                  "no machinery of its own to prove")
+            return 0
+        return int(_st.run())
+    return report()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

awdecide/_selftest.py

@@ -0,0 +1,284 @@
+"""`awdecide --self-test` — the contract must be able to FAIL.
+
+Arms (each prints one line; the run exits 0 only when all pass):
+  1 rules rung answers a choice at p=1.0 and the answer is decided
+  2 an empty ladder answers decided=False with a reason -- fail-closed, never a guess
+  3 min_confidence turns a weak callable answer into decided=False and keeps the evidence
+  4 the logprob rung turns a real OpenAI-wire logprobs payload into a distribution
+    over the option labels only (served by an in-process HTTP server -- no network)
+  5 the ledger records, resolves, and reports: a calibrated set beats the base rate,
+    an overconfident set does not; an undecided answer is never recorded
+  6 the CLI grammar parses every primitive and rejects a malformed spec
+  7 the world-model door as a rung: choice/score/bool map onto choice/score/yesno,
+    the door's CALIBRATED probability survives the ladder unrenormalized,
+    source=none ABSTAINS (never the door's placeholder option), resolve() posts the
+    outcome back; and the bridge lands a door journal in the ledger idempotently,
+    skipping confidence-only legacy rows (fake in-process HTTP door -- no network)
+"""
+from __future__ import annotations
+
+import json
+import random
+import tempfile
+import threading
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from pathlib import Path
+from typing import List
+
+from .backends import CallableBackend, Ladder, LogprobBackend, RulesBackend, parse_question_spec
+from .contract import Question
+from .ledger import Ledger
+
+
+def _arm(results: List[str], name: str, ok: bool, detail: str = "") -> None:
+    results.append(f"  arm {name}: {'OK' if ok else 'FAIL'}{(' -- ' + detail) if detail else ''}")
+
+
+class _FakeLLM(BaseHTTPRequestHandler):
+    """Answers every chat completion with a logprobs payload over 'billing'/'sales'."""
+
+    def do_POST(self) -> None:  # noqa: N802 - http.server API
+        n = int(self.headers.get("Content-Length", "0"))
+        self.rfile.read(n)
+        body = {"choices": [{"message": {"content": "billing"}, "logprobs": {"content": [{
+            "token": "billing", "logprob": -0.2231,
+            "top_logprobs": [
+                {"token": "billing", "logprob": -0.2231},   # 0.80
+                {"token": "sales", "logprob": -1.8971},     # 0.15
+                {"token": "The", "logprob": -2.9957},       # 0.05 -> not an option, dropped
+            ]}]}}]}
+        data = json.dumps(body).encode("utf-8")
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(data)))
+        self.end_headers()
+        self.wfile.write(data)
+
+    def log_message(self, *a: object) -> None:  # silence
+        pass
+
+
+def run_self_test() -> int:
+    res: List[str] = []
+    rnd = random.Random(11)
+
+    # 1 rules
+    q = Question.choice(["billing", "technical", "sales"])
+    d = Ladder([RulesBackend([(r"refund|invoice", "billing")])]).decide_one(
+        "Customer asks about a refund on invoice 4411", q)
+    _arm(res, "1 rules", d.decided and d.value == "billing" and d.probability == 1.0
+         and d.backend == "rules", d.to_dict()["value"] or "undecided")
+
+    # 2 empty ladder -> fail-closed
+    d = Ladder([]).decide_one("anything", q)
+    _arm(res, "2 fail-closed", (not d.decided) and d.value is None and d.probability == 0.0
+         and any("no backends" in r for r in d.reasons), "; ".join(d.reasons))
+
+    # 3 min_confidence
+    weak = CallableBackend(lambda s, qq: {"billing": 0.4, "technical": 0.35, "sales": 0.25}, "weak")
+    q7 = Question.choice(["billing", "technical", "sales"], min_confidence=0.7)
+    d = Ladder([weak]).decide_one("x", q7)
+    _arm(res, "3 min_confidence", (not d.decided) and abs(d.probabilities["billing"] - 0.4) < 1e-9
+         and any("< min_confidence" in r for r in d.reasons))
+
+    # 4 logprob rung over a fake OpenAI-wire server
+    srv = HTTPServer(("127.0.0.1", 0), _FakeLLM)
+    t = threading.Thread(target=srv.serve_forever, daemon=True)
+    t.start()
+    try:
+        lb = LogprobBackend(f"http://127.0.0.1:{srv.server_port}", "fake")
+        d = Ladder([lb]).decide_one("Customer asks about a refund", q)
+        ok = (d.decided and d.value == "billing" and abs(d.probability - 0.8 / 0.95) < 1e-3
+              and abs(sum(d.probabilities.values()) - 1.0) < 1e-9
+              and d.probabilities["technical"] == 0.0)
+        _arm(res, "4 logprob", ok, json.dumps(d.to_dict()["probabilities"]))
+    finally:
+        srv.shutdown()
+        srv.server_close()
+
+    # 5 ledger
+    with tempfile.TemporaryDirectory() as td:
+        led = Ledger(Path(td) / "awdecide.db")
+        led.record("k", "s", Ladder([]).decide_one("s", q))  # undecided -> not recorded
+        skipped_ok = led.pending() == 0
+        # calibrated: outcome drawn at the stated probability
+        for _ in range(300):
+            p = rnd.choice([0.55, 0.7, 0.85, 0.95])
+            dd = CallableBackend(lambda s, qq, _p=p: {"billing": _p, "sales": 1 - _p}, "cal")
+            ans = Ladder([dd]).decide_one("s", Question.choice(["billing", "sales"]))
+            did = led.record("k", "s", ans)
+            led.resolve(did, correct=rnd.random() < ans.probability)
+        rep = led.reliability()
+        cal_ok = rep["beats_base_rate"] and rep["resolved"] == 300
+        # overconfident, fresh ledger
+        led2 = Ledger(Path(td) / "over.db")
+        for _ in range(200):
+            dd = CallableBackend(lambda s, qq: {"billing": 0.95, "sales": 0.05}, "over")
+            ans = Ladder([dd]).decide_one("s", Question.choice(["billing", "sales"]))
+            led2.resolve(led2.record("k", "s", ans), correct=rnd.random() < 0.5)
+        rep2 = led2.reliability()
+        over_ok = not rep2["beats_base_rate"]
+        exported = led.export_platform_jsonl(Path(td) / "predictions.jsonl")
+        led.close()
+        led2.close()
+        _arm(res, "5 ledger", skipped_ok and cal_ok and over_ok and exported == 300,
+             f"cal brier={rep.get('brier')} clim={rep.get('climatology')} "
+             f"over brier={rep2.get('brier')} clim={rep2.get('climatology')}")
+
+    # 6 CLI grammar
+    try:
+        k1, q1 = parse_question_spec("category:choice=billing,technical@0.6")
+        k2, q2 = parse_question_spec("urgency:score=low,mid,high")
+        k3, q3 = parse_question_spec("urgent:bool")
+        try:
+            parse_question_spec("nope:maybe=1")
+            bad_rejected = False
+        except ValueError:
+            bad_rejected = True
+        _arm(res, "6 grammar", q1.kind == "choice" and q1.min_confidence == 0.6
+             and q2.kind == "score" and q2.options == ("low", "mid", "high")
+             and q3.kind == "bool" and q3.options == ("yes", "no") and bad_rejected)
+    except Exception as e:  # pragma: no cover
+        _arm(res, "6 grammar", False, repr(e))
+
+    # 7 door rung + bridge, against a fake door
+    try:
+        _arm(res, "7 door", *_door_arm())
+    except Exception as e:  # pragma: no cover
+        _arm(res, "7 door", False, repr(e))
+
+    print("awdecide --self-test")
+    print("\n".join(res))
+    ok = all(": OK" in r for r in res)
+    print("RESULT:", "OK" if ok else "FAIL")
+    return 0 if ok else 2
+
+
+class _FakeDoor(BaseHTTPRequestHandler):
+    """A door that answers from a table keyed on the request kind, and records
+    outcomes. Shapes copied from decide.py Decider.decide / outcome."""
+
+    seen: List[dict] = []
+    outcomes: List[dict] = []
+
+    def do_POST(self) -> None:  # noqa: N802 - http.server API
+        n = int(self.headers.get("Content-Length", "0"))
+        body = json.loads(self.rfile.read(n) or b"{}")
+        if self.path.endswith("/decide/outcome"):
+            _FakeDoor.outcomes.append({**body, "auth": self.headers.get("X-WM-Token")})
+            reply = {"ok": True, "reward": body.get("reward")}
+        else:
+            _FakeDoor.seen.append(body)
+            kind = body.get("kind")
+            if kind == "yesno":
+                reply = {"decision_id": "d-yes", "answer": "yes", "confidence": 0.6,
+                         "source": "engine", "probabilities": {"yes": 0.7},
+                         "probability": 0.7, "probability_source": "outcomes", "p_yes": 0.7,
+                         "learned_from": 3}
+            elif kind == "score":
+                reply = {"decision_id": "d-score", "answer": "high", "confidence": 0.5,
+                         "source": "neighbor", "probabilities": {"low": 0.2, "high": 0.65},
+                         "probability": 0.65, "probability_source": "outcomes"}
+            elif body.get("state") == "cold":
+                reply = {"decision_id": "d-none", "answer": body["options"][0],
+                         "confidence": 0.0, "source": "none", "probability": None,
+                         "probability_source": "none"}
+            else:
+                # per-option calibrated P(right): does NOT sum to 1 on purpose
+                reply = {"decision_id": "d-choice", "answer": "orchestrator", "confidence": 0.8,
+                         "source": "engine",
+                         "probabilities": {"orchestrator": 0.9, "fast-local": 0.3},
+                         "probability": 0.9, "probability_source": "outcomes",
+                         "learned_from": 8}
+        data = json.dumps(reply).encode("utf-8")
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(data)))
+        self.end_headers()
+        self.wfile.write(data)
+
+    def log_message(self, *a: object) -> None:
+        pass
+
+
+def _door_arm() -> "tuple[bool, str]":
+    from . import bridge
+    from .door import DoorBackend
+
+    srv = HTTPServer(("127.0.0.1", 0), _FakeDoor)
+    t = threading.Thread(target=srv.serve_forever, daemon=True)
+    t.start()
+    notes: List[str] = []
+    try:
+        door = DoorBackend(f"http://127.0.0.1:{srv.server_port}", token="t0k", fork="router")
+        lad = Ladder([door])
+        c = lad.decide_one("kind:code", Question.choice(["fast-local", "orchestrator"]))
+        s = lad.decide_one("x", Question.score(["low", "mid", "high"]))
+        b = lad.decide_one("x", Question.bool())
+        none = lad.decide_one("cold", Question.choice(["a", "b"]))
+        strict = lad.decide_one("kind:code", Question.choice(["fast-local", "orchestrator"],
+                                                             min_confidence=0.95))
+        kinds = [r.get("kind") for r in _FakeDoor.seen[:3]]
+        ok_map = kinds == ["choice", "score", "yesno"] and \
+            _FakeDoor.seen[0]["domain"] == "decide.router"
+        ok_choice = c.decided and c.value == "orchestrator" and c.probability == 0.9 \
+            and c.backend == "door:engine" and c.id == "d-choice" \
+            and c.probabilities["fast-local"] == 0.3  # unrenormalized
+        ok_score = s.decided and s.value == "high" and s.probability == 0.65 \
+            and s.backend == "door:neighbor"
+        ok_bool = b.decided and b.value == "yes" and b.probability == 0.7 \
+            and abs(b.probabilities["no"] - 0.3) < 1e-9
+        ok_none = (not none.decided) and none.value is None and none.backend == "none" \
+            and any("door:none" in r for r in none.reasons)
+        ok_strict = (not strict.decided) and strict.probabilities["orchestrator"] == 0.9
+        notes.append(f"map={ok_map} choice={ok_choice} score={ok_score} bool={ok_bool} "
+                     f"none={ok_none} strict={ok_strict}")
+        with tempfile.TemporaryDirectory() as td:
+            led = Ledger(Path(td) / "door.db")
+            did = led.record("route", "kind:code", c)
+            r = door.resolve(did, correct=True, ledger=led)
+            ok_resolve = did == "d-choice" and r["door"] == {"ok": True, "reward": 1.0} \
+                and abs(r["brier"] - 0.01) < 1e-9 and _FakeDoor.outcomes[-1]["auth"] == "t0k"
+            # bridge: a door journal with 2 proper pairs, 1 legacy, 1 none, 1 unresolved
+            ck = Path(td) / "ckpt"
+            ck.mkdir()
+            rows = [
+                {"kind": "decision", "decision_id": "j1", "domain": "decide.live.r", "state": "s",
+                 "answer": "a", "confidence": 0.6, "probability": 0.8,
+                 "probability_source": "outcomes", "question_kind": "choice",
+                 "source": "engine", "ts": 1.0},
+                {"kind": "outcome", "decision_id": "j1", "reward": 1.0, "ts": 2.0},
+                {"kind": "decision", "decision_id": "j2", "domain": "decide.live.r", "state": "s",
+                 "answer": "yes", "probability": 0.4, "question_kind": "yesno",
+                 "source": "prior", "ts": 3.0},
+                {"kind": "outcome", "decision_id": "j2", "reward": -1.0, "ts": 4.0},
+                {"kind": "outcome", "decision_id": "j2", "reward": 1.0, "ts": 5.0},  # 2nd ignored
+                {"kind": "decision", "decision_id": "j3", "domain": "decide.live.r", "state": "s",
+                 "answer": "a", "confidence": 0.9, "source": "engine", "ts": 6.0},  # legacy
+                {"kind": "outcome", "decision_id": "j3", "reward": 1.0, "ts": 7.0},
+                {"kind": "decision", "decision_id": "j4", "domain": "decide.live.r", "state": "s",
+                 "answer": "a", "probability": None, "source": "none", "ts": 8.0},
+                {"kind": "outcome", "decision_id": "j4", "reward": 1.0, "ts": 9.0},
+                {"kind": "decision", "decision_id": "j5", "domain": "decide.live.r", "state": "s",
+                 "answer": "a", "probability": 0.5, "source": "llm", "ts": 10.0},  # unresolved
+                {"kind": "outcome", "decision_id": None, "reward": 1.0, "ts": 11.0},  # teach row
+            ]
+            with (ck / "decisions.jsonl").open("w", encoding="utf-8") as f:
+                for row in rows:
+                    f.write(json.dumps(row) + "\n")
+                f.write("{torn\n")
+            r1 = bridge.ingest_journal(ck, led, label="t")
+            r2 = bridge.ingest_journal(ck, led, label="t")
+            rep = led.reliability()
+            ok_bridge = (r1["ingested"], r1["legacy_confidence_only"], r1["source_none"],
+                         r1["matched"]) == (2, 1, 1, 4) \
+                and r2["ingested"] == 0 and r2["already_present"] == 2 \
+                and rep["resolved"] == 3 and rep["by_backend"]["door:prior"]["n"] == 1 \
+                and abs(rep["by_backend"]["door:prior"]["brier"] - 0.16) < 1e-9
+            led.close()
+        notes.append(f"resolve={ok_resolve} bridge={ok_bridge}")
+        return (ok_map and ok_choice and ok_score and ok_bool and ok_none and ok_strict
+                and ok_resolve and ok_bridge), " ".join(notes)
+    finally:
+        srv.shutdown()
+        srv.server_close()