strata-agent-memory 0.2.0__tar.gz → 0.2.2__tar.gz

{strata_agent_memory-0.2.0/strata_agent_memory.egg-info → strata_agent_memory-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: strata-agent-memory
-Version: 0.2.0
+Version: 0.2.2
 Summary: Portable, auditable, cross-vendor memory for LLM agents: evidence-bound claims, trust tiers, and compiled context views.
 Author: Strata Intelligence
 License-Expression: Apache-2.0
@@ -45,9 +45,13 @@ service, no dependencies, Python 3.10+.
   commit/file hash. The claim is rejected otherwise. A receipt is the
   filer's record; the proof is the re-run, which `verify` and the nightly
   lane perform, and the audit lists what nobody has re-run.
-- **Same-vendor review is not verification.** A Claude reviewer approving a
-  Claude coder yields `self-verified`. Only a human or a different vendor
-  lineage (Codex, Gemini, a local Qwen) promotes a claim to `verified`.
+- **Self-review is not verification.** A claim reaches `verified` when a
+  person, or an agent that is not its author, re-runs the proof; the author's
+  own re-run stays `self-verified`. A fleet on one vendor gets the same rigor
+  as a mixed one. A ledger that wants the stronger rule sets
+  `cross_vendor_required`, and then only a person or another vendor's agent
+  (Codex, Gemini, a local Qwen) promotes; either way the audit says which
+  lineage verified what.
 - **Refuting a claim taints everything built on it.** Retractions walk the
   provenance graph; nothing is deleted; the audit prints the chain.
 - **Verifiers are isolated, workers fork.** A reviewer never sees the
@@ -103,6 +107,20 @@ Inside Claude Code, Codex or Gemini the same operations are MCP tools
 (`memory_run`, `memory_claim`, `memory_verify`, `memory_compile`, …); see
 `examples/` and [docs/INTEGRATION.md](docs/INTEGRATION.md).
 
+Agents also talk to each other on this ledger, with no broker and no mail
+server: a message is a `note` claim tagged `to:<agent>`, and `agent-memory
+relay` is one small process per agent, with no model in it, that tails the
+replica's `/events` for the records addressed to its agent, debounces them
+into a batch, applies circuit breakers before anything is woken (per-thread
+rate, consecutive machine-only turns, per-agent wake ceilings, a token
+budget), renders the batch inside a fixed delimiter as data rather than
+instructions, hands it to the harness through one adapter, and files an ack
+record for each message it delivered. It listens on no port and spends
+nothing while it waits. The kit is `deploy/relay/`, the page to run it from is
+[docs/RUNBOOK-RELAY.md](docs/RUNBOOK-RELAY.md), the conventions are
+[docs/PROTOCOL.md](docs/PROTOCOL.md) section 11, and why it is shaped this way
+is [docs/COMMS-BUS-PLAN.md](docs/COMMS-BUS-PLAN.md).
+
 ## Where this goes: measured reliability, then judged claims
 
 Memory is often perception, not fact. The alpha separates the two
@@ -167,8 +185,10 @@ agent_memory/      the package (stdlib only)
   pathmap.py       answering another machine's receipts
   signing.py       optional Ed25519 attestations (DSSE); needs strata-agent-memory[sign]
   hooks.py         hook adapters: Claude Code, Codex CLI, Gemini CLI, Cursor
+  relay/           the message relay: core (batching, breakers, the delimiter), client (the /events tail), adapters, cli
   cli.py           agent-memory <command>
-docs/              DESIGN.md, PROTOCOL.md, RESEARCH-SYNTHESIS.md, INTEGRATION.md
+docs/              DESIGN.md, PROTOCOL.md, RESEARCH-SYNTHESIS.md, INTEGRATION.md, COMMS-BUS-PLAN.md, RUNBOOK-*.md
+deploy/            replica/ (a hosted ledger) and relay/ (a relay per agent), systemd and launchd
 schemas/           JSON Schema for the record envelope and bodies
 examples/          Claude Code, Codex, Gemini, local LLM, CI
 tests/             pytest suite; tests/sit/phase3/ is the CLI-driven system test
@@ -180,6 +200,7 @@ tests/             pytest suite; tests/sit/phase3/ is the CLI-driven system test
 - [docs/PROTOCOL.md](docs/PROTOCOL.md): the normative format, filing rules, trust computation and compile semantics, for implementers in any language.
 - [docs/RESEARCH-SYNTHESIS.md](docs/RESEARCH-SYNTHESIS.md): the nine sources, what was taken from each, and what none of them had.
 - [docs/INTEGRATION.md](docs/INTEGRATION.md): setup per harness, the local verifier lane, the contract loop.
+- [docs/COMMS-BUS-PLAN.md](docs/COMMS-BUS-PLAN.md): how agents talk through the ledger without spending tokens while they wait, and [docs/RUNBOOK-RELAY.md](docs/RUNBOOK-RELAY.md) to run a relay per agent.
 - [docs/LANDSCAPE.md](docs/LANDSCAPE.md): the competing systems, their verified licenses, the standards receipts align with, and what none of them do.
 - [docs/UAT-PLAN.md](docs/UAT-PLAN.md): the one-week acceptance test across Claude Code, Codex, Antigravity and Grok.
 - [docs/UAT-SELF.md](docs/UAT-SELF.md): the same test for one person with two subscriptions, Claude Code and Codex CLI, with `scripts/uat/` to set it up and to run the cross-lineage verification.

{strata_agent_memory-0.2.0 → strata_agent_memory-0.2.2}/README.md

@@ -21,9 +21,13 @@ service, no dependencies, Python 3.10+.
   commit/file hash. The claim is rejected otherwise. A receipt is the
   filer's record; the proof is the re-run, which `verify` and the nightly
   lane perform, and the audit lists what nobody has re-run.
-- **Same-vendor review is not verification.** A Claude reviewer approving a
-  Claude coder yields `self-verified`. Only a human or a different vendor
-  lineage (Codex, Gemini, a local Qwen) promotes a claim to `verified`.
+- **Self-review is not verification.** A claim reaches `verified` when a
+  person, or an agent that is not its author, re-runs the proof; the author's
+  own re-run stays `self-verified`. A fleet on one vendor gets the same rigor
+  as a mixed one. A ledger that wants the stronger rule sets
+  `cross_vendor_required`, and then only a person or another vendor's agent
+  (Codex, Gemini, a local Qwen) promotes; either way the audit says which
+  lineage verified what.
 - **Refuting a claim taints everything built on it.** Retractions walk the
   provenance graph; nothing is deleted; the audit prints the chain.
 - **Verifiers are isolated, workers fork.** A reviewer never sees the
@@ -79,6 +83,20 @@ Inside Claude Code, Codex or Gemini the same operations are MCP tools
 (`memory_run`, `memory_claim`, `memory_verify`, `memory_compile`, …); see
 `examples/` and [docs/INTEGRATION.md](docs/INTEGRATION.md).
 
+Agents also talk to each other on this ledger, with no broker and no mail
+server: a message is a `note` claim tagged `to:<agent>`, and `agent-memory
+relay` is one small process per agent, with no model in it, that tails the
+replica's `/events` for the records addressed to its agent, debounces them
+into a batch, applies circuit breakers before anything is woken (per-thread
+rate, consecutive machine-only turns, per-agent wake ceilings, a token
+budget), renders the batch inside a fixed delimiter as data rather than
+instructions, hands it to the harness through one adapter, and files an ack
+record for each message it delivered. It listens on no port and spends
+nothing while it waits. The kit is `deploy/relay/`, the page to run it from is
+[docs/RUNBOOK-RELAY.md](docs/RUNBOOK-RELAY.md), the conventions are
+[docs/PROTOCOL.md](docs/PROTOCOL.md) section 11, and why it is shaped this way
+is [docs/COMMS-BUS-PLAN.md](docs/COMMS-BUS-PLAN.md).
+
 ## Where this goes: measured reliability, then judged claims
 
 Memory is often perception, not fact. The alpha separates the two
@@ -143,8 +161,10 @@ agent_memory/      the package (stdlib only)
   pathmap.py       answering another machine's receipts
   signing.py       optional Ed25519 attestations (DSSE); needs strata-agent-memory[sign]
   hooks.py         hook adapters: Claude Code, Codex CLI, Gemini CLI, Cursor
+  relay/           the message relay: core (batching, breakers, the delimiter), client (the /events tail), adapters, cli
   cli.py           agent-memory <command>
-docs/              DESIGN.md, PROTOCOL.md, RESEARCH-SYNTHESIS.md, INTEGRATION.md
+docs/              DESIGN.md, PROTOCOL.md, RESEARCH-SYNTHESIS.md, INTEGRATION.md, COMMS-BUS-PLAN.md, RUNBOOK-*.md
+deploy/            replica/ (a hosted ledger) and relay/ (a relay per agent), systemd and launchd
 schemas/           JSON Schema for the record envelope and bodies
 examples/          Claude Code, Codex, Gemini, local LLM, CI
 tests/             pytest suite; tests/sit/phase3/ is the CLI-driven system test
@@ -156,6 +176,7 @@ tests/             pytest suite; tests/sit/phase3/ is the CLI-driven system test
 - [docs/PROTOCOL.md](docs/PROTOCOL.md): the normative format, filing rules, trust computation and compile semantics, for implementers in any language.
 - [docs/RESEARCH-SYNTHESIS.md](docs/RESEARCH-SYNTHESIS.md): the nine sources, what was taken from each, and what none of them had.
 - [docs/INTEGRATION.md](docs/INTEGRATION.md): setup per harness, the local verifier lane, the contract loop.
+- [docs/COMMS-BUS-PLAN.md](docs/COMMS-BUS-PLAN.md): how agents talk through the ledger without spending tokens while they wait, and [docs/RUNBOOK-RELAY.md](docs/RUNBOOK-RELAY.md) to run a relay per agent.
 - [docs/LANDSCAPE.md](docs/LANDSCAPE.md): the competing systems, their verified licenses, the standards receipts align with, and what none of them do.
 - [docs/UAT-PLAN.md](docs/UAT-PLAN.md): the one-week acceptance test across Claude Code, Codex, Antigravity and Grok.
 - [docs/UAT-SELF.md](docs/UAT-SELF.md): the same test for one person with two subscriptions, Claude Code and Codex CLI, with `scripts/uat/` to set it up and to run the cross-lineage verification.

{strata_agent_memory-0.2.0 → strata_agent_memory-0.2.2}/agent_memory/__init__.py

@@ -9,4 +9,4 @@ see, what did it claim, and can the proof be re-run.
 The core is dependency-free (Python 3.10+ standard library only).
 """
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"

{strata_agent_memory-0.2.0 → strata_agent_memory-0.2.2}/agent_memory/audit.py

@@ -14,6 +14,8 @@
   judgment_calibration; docs/PHASE3-RELIABILITY.md)
 - Which records carry a signature, and does every signature check out? (signatures;
   a signature says who filed a record, never that it is true)
+- Which lineage labels are only labels: records filed unsigned by an author who holds a
+  registered key, and verifications by an identity with no key at all?
 - How much of memory is human-authored vs agent-authored?
 - Which contracts are open, and do their claims meet the bar?
 - What did each agent session actually get shown (compilation receipts)?
@@ -28,14 +30,25 @@ from . import evidence as ev
 from . import reliability as rel
 from . import signing
 from .contracts import status_of
-from .records import is_redacted
+from .records import is_redacted, receipt_visible_to
 from .trust import TIERS, assess, lineage_differs, summarize
 
 # Anything a compiled view would have to render on its own line. The renderer collapses
 # these (review S5); the audit names the records that carried them, because a statement
-# shaped like a document is a statement written to be read as one.
+# shaped like a document is a statement written to be read as one. The author block is on
+# that list too: the attribution a view writes is built from the harness, the model and the
+# user a record carries, so a newline there forges a heading as surely as one in a
+# statement, and those come from the environment of whatever filed it (review E-1).
 _CONTROL_RE = re.compile(r"[\x00-\x1f\x7f]")
-_FORMATTED_FIELDS = ("statement", "rationale", "example")
+_FORMATTED_FIELDS = ("statement", "rationale", "example",
+                     "author.harness", "author.model", "author.user", "author.vendor")
+
+
+def _formatted_value(rec: dict, field: str):
+    """The value ``field`` names: a body key, or an author key written ``author.<key>``."""
+    if field.startswith("author."):
+        return (rec.get("author") or {}).get(field.split(".", 1)[1])
+    return (rec.get("body") or {}).get(field)
 
 
 def _formatting_problem(text: str) -> Optional[str]:
@@ -67,10 +80,55 @@ def _same_session_other_harness(claim_author: dict, verifier: dict) -> bool:
     )
 
 
+# the kinds whose author block is a lineage label somebody acts on: what a claim says,
+# whether it was verified, whether a contract moved, whether a claim was withdrawn
+_IDENTITY_KINDS = ("claim", "verification", "contract_update", "retraction")
+# what one section lists before it says "... and N more"
+_SECTION_CAP = 50
+
+
+def _reader_sees(ledger, rec: dict, by_id: Dict[str, dict], reader_user: Optional[str]) -> bool:
+    """Whether this reader is shown ``rec`` and everything it is about.
+
+    The record's own scope decides first; a local audit with no reader named sees
+    everything of its own. Then what the record names: a verification and a retraction
+    name a claim, a contract_update names its contract and the claims it moves, and
+    naming somebody's private claim is naming it whatever record the citation sits in. A
+    claim this report is not carrying at all -- private to another reader, or redacted --
+    takes the record citing it with it, reader or no reader, which is the rule the
+    lineage matrix already follows.
+    """
+    if reader_user is not None and not receipt_visible_to(rec, reader_user):
+        return False
+    body = rec.get("body") or {}
+    for target in (body.get("claim"), body.get("contract"), *(body.get("claims") or [])):
+        if not isinstance(target, str) or target in by_id:
+            continue
+        cited = ledger.get(target)
+        if cited is None or is_redacted(cited) or cited["kind"] == "claim":
+            return False  # gone, erased, or a claim this report is holding back
+        if reader_user is not None and not receipt_visible_to(cited, reader_user):
+            return False
+    return True
+
+
+def _capped(items: List[dict]) -> dict:
+    """{total, items}: the newest ``_SECTION_CAP`` entries and how many there are in all."""
+    newest = sorted(items, key=lambda r: (r["ts"], r["id"]), reverse=True)
+    return {"total": len(items), "items": newest[:_SECTION_CAP]}
+
+
 def report(ledger, recheck: bool = False, cwd: Optional[str] = None, timeout: Optional[float] = 300,
-           path_map=None) -> dict:
+           path_map=None, reader_user: Optional[str] = None) -> dict:
+    """The audit, for one reader. ``reader_user`` is who is asking: a user-scoped claim is
+    one person's private memory and is listed for its owner and for nobody else, the same
+    rule ``receipt_visible_to`` applies everywhere a record is shown (verification review
+    F1: the audit listed every user's private statements to any token). A local audit
+    with no reader named sees everything, as the local ledger's owner does."""
     assessment = assess(ledger)
     claims = ledger.claims()
+    if reader_user is not None:
+        claims = [c for c in claims if receipt_visible_to(c, reader_user)]
     by_id = {c["id"]: c for c in claims}
     rep: Dict = {
         "project": ledger.config.get("project"),
@@ -91,8 +149,8 @@ def report(ledger, recheck: bool = False, cwd: Optional[str] = None, timeout: Op
         "same_session_different_harness": [],
         "formatted_statements": [],
         "redactions": {"count": 0, "ids": []},
-        # absent and empty mean opposite things (an absent key allows every command, an
-        # empty list allows none), so the report carries both facts
+        # absent and empty mean different things (an absent key is the starter default
+        # list, an empty list is none), so the report carries both facts
         "recheck_allow_set": "recheck_allow" in ledger.config,
         "recheck_allow": list(ledger.config.get("recheck_allow") or []),
         "lineage_matrix": {},
@@ -105,6 +163,8 @@ def report(ledger, recheck: bool = False, cwd: Optional[str] = None, timeout: Op
         "contracts": [],
         "compilations": [],
         "signatures": {},
+        "unsigned_by_registered_signers": {},
+        "verifications_by_unregistered_identities": {},
         "recheck": [],
     }
     # measured history, computed from the ledger alone: counts, intervals, and the word
@@ -135,8 +195,11 @@ def report(ledger, recheck: bool = False, cwd: Optional[str] = None, timeout: Op
             if backed in ("static", "attested"):
                 # a clean static gate is not evidence that the thing runs
                 rep["static_only_outcomes"].append({**entry, "assurance": backed})
-        if info["tier"] == "self-verified":
-            rep["same_vendor_only"].append({**entry, "verified_by": info["verified_by"]})
+        # a measure, not a tier: every claim whose only verifiers are agents of its own
+        # vendor, whether the ledger's policy lets that reach `verified` or not
+        if info["verified_by"] and not info.get("cross_vendor") and not info.get("self_verified_by_author") \
+                and info["tier"] in ("verified", "self-verified"):
+            rep["same_vendor_only"].append({**entry, "verified_by": info["verified_by"], "tier": info["tier"]})
         if info.get("self_verified_by_author"):
             rep["self_verified_by_author"].append({**entry, "verified_by": info["verified_by"]})
         if info["tier"] == "refuted":
@@ -151,7 +214,7 @@ def report(ledger, recheck: bool = False, cwd: Optional[str] = None, timeout: Op
         if info["tier"] == "asserted" and b["type"] == "fact":
             rep["asserted_facts"].append(entry)
         for field in _FORMATTED_FIELDS:
-            value = b.get(field)
+            value = _formatted_value(c, field)
             problem = _formatting_problem(value) if isinstance(value, str) else None
             if problem:
                 rep["formatted_statements"].append({**entry, "field": field, "line": problem})
@@ -230,6 +293,50 @@ def report(ledger, recheck: bool = False, cwd: Optional[str] = None, timeout: Op
         "invalid_items": [i for i in sig["items"] if i["status"] != "valid"],
         "by_author": dict(attested_by_author),
     }
+    # what a lineage label is worth. Outside ``serve``'s token path every field of the
+    # author block is whatever the filing process said it was (§8 of docs/PROTOCOL.md), and
+    # a signature is the only thing in this ledger that ties one of those labels to a key
+    # somebody holds. So the audit names the two places the label is only a label: a record
+    # filed unsigned by a user who *has* a registered key, and a verification filed by an
+    # identity with no key in the registry at all. Neither is a finding; both are the
+    # question to ask before the vendor-lineage sections above are read as facts.
+    registry = signing.signers(ledger)
+    signer_users = {e.get("user") for e in registry.values() if e.get("user")}
+    can_verify = signing.available()
+    # the subset of the signatures already verified above that ties a record to a key
+    # registered to its *own* author: a valid countersignature by somebody else says that
+    # a second party saw the record, never that the author label on it is theirs. Every
+    # signature in the ledger is checked once, here and in the signatures block.
+    author_signed = signing.author_attested_records(ledger, sig["items"])
+    unsigned: List[dict] = []
+    unregistered: List[dict] = []
+    for rec in ledger.all():
+        if rec["kind"] not in _IDENTITY_KINDS or not _reader_sees(ledger, rec, by_id, reader_user):
+            continue
+        # a tombstone's bytes were erased on purpose (review C1): there is nothing left for
+        # a signature to cover, which is not the same thing as a record nobody signed
+        if is_redacted(rec):
+            continue
+        a = rec["author"]
+        if can_verify and a.get("user") in signer_users and rec["id"] not in author_signed:
+            unsigned.append({"id": rec["id"], "kind": rec["kind"], "user": a.get("user"),
+                             "harness": a.get("harness"), "ts": rec["ts"]})
+        if registry and rec["kind"] == "verification" and a.get("user") not in signer_users:
+            b = rec["body"]
+            unregistered.append({"id": rec["id"], "claim": b.get("claim"), "user": a.get("user"),
+                                 "harness": a.get("harness"), "vendor": a.get("vendor"),
+                                 "verdict": b.get("verdict"), "ts": rec["ts"]})
+    rep["unsigned_by_registered_signers"] = _capped(unsigned)
+    if not can_verify:
+        # the same answer `verify-signatures` gives: on a machine without the extra every
+        # signature is unverifiable, so nothing here may be called unsigned
+        rep["unsigned_by_registered_signers"]["unavailable"] = True
+        rep["unsigned_by_registered_signers"]["detail"] = f"{signing.NO_CRYPTO}; {signing.INSTALL_HINT}"
+    rep["verifications_by_unregistered_identities"] = _capped(unregistered)
+    if not registry:
+        # a ledger that never registered a key is not a ledger where everybody is
+        # unregistered: there is no registry to be outside of
+        rep["verifications_by_unregistered_identities"]["no_registry"] = True
     if recheck:
         for c in claims:
             info = assessment[c["id"]]
@@ -255,13 +362,19 @@ def format_report(rep: dict) -> str:
     lines.append("authors: " + ", ".join(f"{k}={v}" for k, v in rep["authors"].most_common()))
     lines.append("kind:    " + ", ".join(f"{k}={v}" for k, v in rep["human_vs_agent"].items()))
     lines.append("vendors: " + ", ".join(f"{k}={v}" for k, v in rep["vendors"].most_common()))
+    unsigned = rep.get("unsigned_by_registered_signers") or {}
+    unregistered = rep.get("verifications_by_unregistered_identities") or {}
+    lines.append(f"labels:  unsigned by a registered signer={unsigned.get('total', 0)}, "
+                 f"verifications by an unregistered identity={unregistered.get('total', 0)}")
     if not rep.get("trusted", True):
         lines.append("repo:    UNTRUSTED -- config.json's policy keys (recheck_allow, "
                      "recheck_allow_shell, redact, path_map, org_path, signers, vendor_map, "
-                     "cross_vendor_required) were ignored; run `agent-memory trust .` to honour them")
+                     "cross_vendor_required, stale_after_days, reliability, max_clock_skew_seconds) "
+                     "were ignored; run `agent-memory trust .` to honour them")
     if not rep.get("recheck_allow_set"):
-        lines.append("warning: config.recheck_allow is not set: the re-check lane will run whatever "
-                     "command a receipt records; run `agent-memory init` to write the starter list")
+        lines.append("note: config.recheck_allow is not set: the re-check lane is held to the starter "
+                     "list (test runners and build tools); run `agent-memory init` to write it into "
+                     "config.json and narrow it to what your receipts actually are")
     elif not rep.get("recheck_allow"):
         # deliberate, and the opposite of the absent case: nothing is re-run here
         lines.append("note: recheck_allow is empty: no receipt will be re-run on this machine")
@@ -274,6 +387,19 @@ def format_report(rep: dict) -> str:
         if len(rows) > 50:
             lines.append(f"- ... {len(rows) - 50} more")
 
+    def capped(title: str, sec: dict, fmt, note: Optional[str] = None):
+        """A section the report already capped: it carries its own total and items."""
+        sec = sec or {}
+        items = sec.get("items") or []
+        lines.append("")
+        lines.append(f"## {title} ({sec.get('total', 0)})")
+        if note:
+            lines.append(f"- {note}")
+        for r in items:
+            lines.append("- " + fmt(r))
+        if sec.get("total", 0) > len(items):
+            lines.append(f"- ... {sec['total'] - len(items)} more")
+
     section("Outcome claims with receipts nobody re-ran", rep["unrechecked_outcomes"],
             lambda r: f"{r['id']} [{r['by']}] {r['statement']}")
     section("Outcome claims whose receipts did not succeed", rep["failing_receipt_outcomes"],
@@ -283,8 +409,8 @@ def format_report(rep: dict) -> str:
     section("Receipts whose assurance was declared above the computed default", rep["assurance_overridden"],
             lambda r: f"{r['id']} [{r['by']}] declared {r['declared']}, computed {r['computed']}: {r['what']}"
                       + (f" (cited by {', '.join(r['claims'])})" if r["claims"] else " (cited by no claim)"))
-    section("Verified only by the same vendor (collusion risk)", rep["same_vendor_only"],
-            lambda r: f"{r['id']} [{r['vendor']} verified by {', '.join(r['verified_by'])}] {r['statement']}")
+    section("Verified only by the same vendor (no person or other vendor has re-run it)", rep["same_vendor_only"],
+            lambda r: f"{r['id']} [{r['vendor']} verified by {', '.join(r['verified_by'])}; {r.get('tier','')}] {r['statement']}")
     section("Verified only by the claim's own author", rep["self_verified_by_author"],
             lambda r: f"{r['id']} [{r['by']}] {r['statement']}")
     section("Verified from the claim's own session under another harness (collusion risk)",
@@ -320,6 +446,14 @@ def format_report(rep: dict) -> str:
         for item in sig.get("invalid_items", [])[:50]:
             lines.append(f"- {item['id']} over {item['record']} [{item['key_id']}]: {item['status']} -- "
                          f"{item['detail']}")
+    capped("Unsigned records by registered signers", unsigned,
+           lambda r: f"{r['id']} [{r['kind']}] {r['user']} via {r['harness']} at {r['ts']}",
+           note=unsigned.get("detail") if unsigned.get("unavailable") else None)
+    capped("Verifications by identities with no registered key", unregistered,
+           lambda r: f"{r['id']} over {r['claim']} [{r['user']} via {r['harness']}, {r['vendor']}] "
+                     f"{r['verdict']} at {r['ts']}",
+           note=("config.signers is empty: this ledger registered no key, so no identity in it "
+                 "can be checked" if unregistered.get("no_registry") else None))
     lines.append("")
     lines.append(f"## Verifier lineage (refutation rates) ({len(rep['lineage_matrix'])})")
     for key, cell in sorted(rep["lineage_matrix"].items()):