loopmarket 0.1.0__py3-none-any.whl

loopmarket/__init__.py

@@ -0,0 +1,43 @@
+"""loopmarket — a universal combinatorial marketplace over OntoDAG + recordstore + Swarm.
+
+One uniform offer form; a shared OntoDAG catalogue in which meanings, minutes
+and map regions are ordered by the same fits-within relation; a distributed,
+versioned offer book over recordstore (Swarm-backed via BeeBytesStore +
+SwarmFeedPointer); competing solver agents hunting profitable loops as
+negative cycles; clearing that re-verifies everything and trusts no one.
+
+Dependency direction (boundary B2, enforced by tests/test_boundaries.py):
+
+    loopmarket  ->  ontodag  ->  recordstore  ->  (Swarm, optional)
+
+The core imports work with no network and no Bee node (boundary B1); Swarm
+is a persistence backend chosen at the edges (registry.swarm_offer_book,
+Ontology.persistent over a swarm_store), never a requirement of the model.
+"""
+
+from .schema import (
+    ASK, BID, GIVE, WANT, GeoDisc, Offer, Thing, TimeWindow, Tokens,
+    ask, bid, give, want,
+)
+from .federation import Aggregator, Manifest, Omission, audit_manifest
+from .ontology import Ontology
+from .registry import OfferRegistry, PartialLoopError, swarm_offer_book
+from .matching import Match, candidate_matches, check_match
+from .sigs import maker_address, recover_maker, sign_offer, verify_offer_sig
+from .dimensions import DimensionIndex, candidate_matches_indexed
+from .graph import ExchangeGraph, Loop
+from .clearing import LoopProposal, MockClearing, Receipt, Clearing
+from .solver.agent import SolverAgent
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "GIVE", "WANT", "ASK", "BID", "GeoDisc", "Offer", "Thing", "TimeWindow",
+    "Tokens", "give", "want", "ask", "bid",
+    "Aggregator", "Manifest", "Omission", "audit_manifest", "Ontology", "OfferRegistry",
+    "PartialLoopError", "swarm_offer_book",
+    "Match", "candidate_matches", "check_match",
+    "maker_address", "recover_maker", "sign_offer", "verify_offer_sig",
+    "DimensionIndex", "candidate_matches_indexed", "ExchangeGraph", "Loop",
+    "LoopProposal", "MockClearing", "Receipt", "Clearing", "SolverAgent",
+]

loopmarket/clearing.py

@@ -0,0 +1,147 @@
+"""Clearing: where a proposed loop becomes a bundle of commitments.
+
+Trust model (the one non-negotiable): clearing *never trusts the solver*.
+A `LoopProposal` names the book root and ontology root it was solved
+against; the clearing layer re-derives every leg with `check_match`, the
+chaining, the product, and the not-already-filled status — cheap, linear in
+the loop — before atomically marking every offer filled. Discovery is
+expensive and competitive; verification is cheap and neutral.
+
+`MockClearing` is the in-process stand-in: its "atomic stroke" is one
+recordstore commit (all fills + the loop record land under a single new
+root, or none do). The on-chain path it stands in for (roadmap P2) keeps
+the same interface: a contract receives the loop plus *inclusion proofs*
+that each offer is present under the pinned book root — recordstore's
+canonical-trie `prove`/`verify_proof` (>= 0.16.0) is the primary route;
+POT ForkPathProof is the conditional fallback only if the on-chain
+verifier demands BMT-native proofs (docs/plans/proof-fabric.md). Batch
+auctions across competing sealed proposals are P2 as well
+(docs/plans/P2-batch-auction.md); the mock is first-valid-wins.
+"""
+
+from __future__ import annotations
+
+import time as _time
+from dataclasses import dataclass
+from typing import Protocol
+
+from .graph import Loop
+from .matching import check_match
+from .ontology import Ontology
+from .registry import OfferRegistry
+
+
+@dataclass(frozen=True, slots=True)
+class LoopProposal:
+    loop: Loop
+    book_root: str        # the registry version the loop was solved against
+    ontology_root: str    # the catalogue version subsumption was checked under
+    solver: str           # who found it (fee/reputation address)
+    found_at: int
+
+    def to_record(self) -> dict:
+        return {
+            "loop_id": self.loop.loop_id,
+            "solver": self.solver,
+            "found_at": self.found_at,
+            "book_root": self.book_root,
+            "ontology_root": self.ontology_root,
+            "surplus": self.loop.surplus,
+            "nodes": list(self.loop.nodes),
+            "legs": [
+                {"give": m.give.offer_id, "want": m.want.offer_id, "rate": m.rate}
+                for m in self.loop.matches
+            ],
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class Receipt:
+    accepted: bool
+    loop_id: str
+    reason: str = ""
+    book_root: str = ""   # the new root, if accepted
+
+
+class Clearing(Protocol):
+    def submit(self, proposal: LoopProposal) -> Receipt: ...
+
+
+class MockClearing:
+    """In-process clearing over the shared registry."""
+
+    #: Oracle types this clearing knows how to verify — the P3 refusal
+    #: gate (docs/plans/P3-guarantee-coupling.md, enforcement rule 1): a leg
+    #: naming a witness type outside this set never clears here, in U7's
+    #: shape — unknown fails closed rather than silently clearing with a
+    #: guarantee nobody can check. The mock declares exactly the P0
+    #: countersign semantics.
+    VERIFIABLE_ORACLES = frozenset({"countersign"})
+
+    def __init__(self, registry: OfferRegistry, ontology: Ontology, *,
+                 min_surplus: float = 0.0, require_per_node: bool = True,
+                 clock=_time.time, verifiable_oracles=VERIFIABLE_ORACLES):
+        self.registry = registry
+        self.ontology = ontology
+        self.min_surplus = min_surplus
+        self.require_per_node = require_per_node
+        self.clock = clock  # injectable for tests / deterministic replay
+        self.verifiable_oracles = frozenset(verifiable_oracles)
+
+    def submit(self, proposal: LoopProposal) -> Receipt:
+        loop = proposal.loop
+        lid = loop.loop_id
+        now = int(self.clock())
+
+        def reject(reason: str) -> Receipt:
+            return Receipt(False, lid, reason)
+
+        # 0. pins — the rehearsal of U10's clearing half (full enforcement,
+        #    with proofs, lands with P2): the proposal's catalogue pin must
+        #    *equal* this clearing's own, refused before any leg work.
+        #    Plain equality covers mismatch and absence in both directions:
+        #    a pinned clearing refuses unpinned proposals, an unpinned
+        #    (development) one refuses proposals claiming ground it cannot
+        #    confirm; '' == '' keeps the in-memory flow working.
+        if proposal.ontology_root != self.ontology.root:
+            return reject("ontology pin mismatch")
+
+        # 1. every offer must exist in the *current* book, be unfilled, and
+        #    name a witness type this clearing can actually verify
+        seen: set[str] = set()
+        for oid in loop.offer_ids:
+            if oid in seen:
+                return reject(f"offer used twice: {oid[:12]}")
+            seen.add(oid)
+            try:
+                offer = self.registry.get(oid)
+            except KeyError:
+                return reject(f"unknown offer: {oid[:12]}")
+            if self.registry.is_filled(oid):
+                return reject(f"already filled: {oid[:12]}")
+            if self.registry.is_withdrawn(oid):
+                return reject(f"withdrawn: {oid[:12]}")
+            if offer.oracle not in self.verifiable_oracles:
+                return reject(f"unverifiable oracle type: {offer.oracle}")
+
+        # 2. re-derive every leg — never trust the solver's matches
+        for m in loop.matches:
+            fresh_give = self.registry.get(m.give.offer_id)
+            fresh_want = self.registry.get(m.want.offer_id)
+            if check_match(fresh_give, fresh_want, self.ontology, now=now) is None:
+                return reject(
+                    f"leg fails re-verification: {m.give.offer_id[:8]}"
+                    f" -> {m.want.offer_id[:8]}"
+                )
+
+        # 3. the arithmetic
+        if loop.surplus < self.min_surplus - 1e-12:
+            return reject(f"surplus {loop.surplus:.4f} below minimum")
+        if self.require_per_node and not loop.all_divisible \
+                and not loop.per_node_ok:
+            return reject("indivisible legs without per-node surplus")
+
+        # 4. atomic commitment: all fills land under one new root, or none
+        self.registry.mark_filled(loop.offer_ids, lid, proposal.to_record())
+        root = self.registry.commit()
+        return Receipt(True, lid, book_root=root)

loopmarket/dimensions.py

@@ -0,0 +1,147 @@
+"""Candidate generation through ontodag parametric dimensions (>= 0.4.0).
+
+The 2026-07-30 upgrade of the P1 candidate-generation plan (ARCHITECTURE.md
+§3): instead of generated bucket/cell category chains, gives are filed under
+*exact* parametric terms — the service window as one linear-interval value,
+the service cell as one prefix value — and a want's candidates come from two
+native catalogue queries:
+
+- meaning: ``dag.get(wanted_concepts)`` — exact-necessary: an give whose
+  concepts satisfy the want is, by fits-within, inside every wanted cone;
+- time:    ``dag.get_overlapping(service-time(a..b))`` — *exact* for the
+  window-overlap gate, because the filed value IS the offer's window
+  (no buckets, no quantization error).
+
+Geo stays with the exact check (``GeoDisc.intersects``), as in the baseline:
+sibling geohash cells share no prefix, so a cell filter would lose recall
+("cells are hints", ARCHITECTURE.md §3). The generator is therefore
+recall-exact against the baseline give x want product — and clearing
+re-verification never depends on it either way (invariant U3).
+
+**The index is derived, local, and never shared.** Filing offers into the
+shared catalogue would move its root under every offer that pins it, so
+`DimensionIndex` works on a deepcopy: regenerable from book + catalogue,
+per-solver, never merged — the same doctrine as every other index in this
+stack. (Corollary: nothing here needs the dimensions registry version
+pinned; that rule from ontodag's DIMENSIONS.md §10 applies when parametric
+terms enter *shared* state, e.g. published region nodes in the catalogue.)
+
+Two ontodag adoption rules are load-bearing here: an offer is filed under
+exactly ONE value per dimension (an item sits in the INTERSECTION of its
+parents — never fan a union of cells or buckets into parents), and the cell
+value indexes the disc's *centre* cell only, which is fine because geo is
+not used for pruning.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Iterable, Iterator
+
+from ontodag import dimensions as _dims
+
+from .matching import Match, check_match
+from .ontology import Ontology
+from .schema import GIVE, WANT, Offer, TimeWindow
+from .spacetime import cell_for
+
+TIME_DIMENSION = "service-time"
+CELL_DIMENSION = "service-cell"
+
+
+def _iso(t: int) -> str:
+    return datetime.fromtimestamp(t, tz=timezone.utc).strftime(
+        "%Y-%m-%dT%H:%M:%SZ")
+
+
+def time_term(window: TimeWindow) -> str:
+    """The window as one inclusive parametric value.
+
+    `TimeWindow` is half-open [start, end) in whole seconds; dimension
+    ranges are inclusive, so [start, end-1] represents exactly the same
+    set of service seconds — overlap is preserved exactly.
+    """
+    return f"{TIME_DIMENSION}({_iso(window.start)}..{_iso(window.end - 1)})"
+
+
+def cell_term(offer: Offer) -> str:
+    """The offer's centre geohash cell as one prefix value (an index fact,
+    not a pruning gate — see the module docstring)."""
+    return f"{CELL_DIMENSION}({cell_for(offer.where)})"
+
+
+class DimensionIndex:
+    """Files gives into a derived catalogue copy; answers want candidates.
+
+    Build one per solve step, like a snapshot: it is cheap relative to the
+    O(gives x wants) product it replaces, and regenerating it is what keeps it
+    honest (derived state is never merged, never persisted).
+    """
+
+    def __init__(self, ontology: Ontology):
+        self.ontology = ontology            # the exact-check ground truth
+        self._dag = ontology.dag.deepcopy()  # derived: catalogue + offers
+        self._filed: set[str] = set()
+        self._declare()
+
+    def _declare(self) -> None:
+        for name, supers in [
+            (_dims.DIMENSION_ROOT, []),
+            (_dims.KIND_LINEAR, [_dims.DIMENSION_ROOT]),
+            (_dims.KIND_PREFIX, [_dims.DIMENSION_ROOT]),
+            (TIME_DIMENSION, [_dims.KIND_LINEAR]),
+            (CELL_DIMENSION, [_dims.KIND_PREFIX]),
+        ]:
+            if name not in self._dag.nodes:
+                self._dag.put(name, supers)
+
+    def file(self, offer: Offer) -> bool:
+        """Index an GIVE. Returns False (not filed) when its vocabulary is
+        unknown to the catalogue — the same fail-closed outcome the exact
+        check would reach (invariant U7)."""
+        if offer.kind != GIVE:
+            return False
+        if offer.offer_id in self._filed:
+            return True
+        if not all(self.ontology.known(c) for c in offer.thing.concepts):
+            return False
+        self._dag.put(
+            offer.offer_id,
+            list(offer.thing.concepts)
+            + [time_term(offer.service), cell_term(offer)])
+        self._filed.add(offer.offer_id)
+        return True
+
+    def candidates(self, want_offer: Offer) -> set[str]:
+        """Give offer-ids that can possibly match `want_offer`: inside every
+        wanted concept cone AND service windows overlapping. Recall-exact
+        for those two gates; every candidate still faces `check_match`."""
+        by_concept = {item.name
+                      for item in self._dag.get(list(want_offer.thing.concepts))}
+        if not by_concept:
+            return set()
+        by_time = {item.name for item in
+                   self._dag.get_overlapping(time_term(want_offer.service))}
+        return by_concept & by_time & self._filed
+
+
+def candidate_matches_indexed(
+        offers: Iterable[Offer], ontology: Ontology, *,
+        now: int, index: DimensionIndex | None = None) -> Iterator[Match]:
+    """Drop-in for `matching.candidate_matches`, generating through a
+    `DimensionIndex` instead of the full give x want product. Yields exactly
+    the baseline's matches (the recall test in tests/test_dimensions.py is
+    the benchmark ARCHITECTURE.md §6 demands of smarter generators)."""
+    offers = list(offers)
+    index = index if index is not None else DimensionIndex(ontology)
+    gives_by_id: dict[str, Offer] = {}
+    for offer in offers:
+        if offer.kind == GIVE and index.file(offer):
+            gives_by_id[offer.offer_id] = offer
+    for want_offer in offers:
+        if want_offer.kind != WANT:
+            continue
+        for oid in sorted(index.candidates(want_offer)):
+            match = check_match(gives_by_id[oid], want_offer, ontology, now=now)
+            if match is not None:
+                yield match

loopmarket/federation.py

@@ -0,0 +1,314 @@
+"""The federated book: per-maker books folded into one solver-speed view.
+
+The production multi-writer shape (ARCHITECTURE §5 shape 3, ratified
+2026-08-21): every book is single-writer at the source — each maker
+publishes `offer/`, `sig/` and `withdraw/` keys under their own feed and
+signer, clearing publishes `fill/` and `loop/` under its own — and
+conflicts exist only at the fold. An **aggregator** folds announced books
+with three-way merge under the loop-aware resolver, applies the U8 fold
+rules per offer, records its decisions as attributed provenance, rebuilds
+the derived index, and publishes the **manifest tuple**
+`{book_root, provenance_root, index_root, announcement_root}`
+(docs/plans/P1-federated-book.md §2).
+
+The fold is *pure*: deterministic admission rules plus commutative merge
+mean aggregators that saw the same inputs produce byte-identical
+`book_root`s in any fold order — divergence between manifests is evidence,
+not opinion, and omission is provable against `announcement_root` and the
+announcement ground truth (threat register T14). Aggregators charge for
+serving, never inclusion; an aggregator that folds selectively is a
+censoring aggregator and is caught as one.
+
+One assumption rides throughout: all books share one blob space — Swarm's
+in deployment, one `MemoryBytesStore` in tests — so a root is enough to
+reach any book's bytes. In memory, "feed ownership" is the declared
+`owner` of an announced book; on Swarm it becomes the feed's owner
+address, which is what makes U8's primary layer real (P1 §1).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from recordstore import RecordStore
+
+from .registry import (
+    FILL, LOOP, OFFER, SIG, WITHDRAW, OfferRegistry, index_offers,
+    or_set_resolver,
+)
+from .schema import Offer
+
+#: Roles an announced book may carry: makers speak offers, signatures and
+#: tombstones; a clearing instance speaks fills and loops. Every other
+#: key class in a book is outside its writer's authority and is refused.
+MAKER = "maker"
+CLEARING = "clearing"
+
+
+@dataclass(frozen=True, slots=True)
+class Manifest:
+    """What an aggregator publishes: four roots and its name.
+
+    `book_root` is the pure fold (byte-identical across honest aggregators
+    with the same inputs); `provenance_root` holds the aggregator's
+    attributed speech acts (`origin/`, `reject/`); `index_root` is derived
+    and regenerable (never merged); `announcement_root` commits to the
+    exact input set this fold consumed — the completeness handle (T14).
+    """
+
+    aggregator: str
+    book_root: str
+    provenance_root: str
+    index_root: str
+    announcement_root: str
+
+
+class Aggregator:
+    """Folds announced books into one book a solver can read at speed.
+
+    `store_factory` returns a fresh writable RecordStore over the shared
+    blob space (in tests: ``lambda: RecordStore(blobs)``; on Swarm, a
+    store under the aggregator's own feed). Admission is by reference:
+    the aggregator folds the books it was told about and can un-announce
+    a flooder — there is no store-side rate limiting to game (P1 §8).
+    """
+
+    def __init__(self, store_factory, *, aggregator_id: str = "agg-0"):
+        self._new_store = store_factory
+        self.id = aggregator_id
+        self._announced: dict[str, tuple[str, object]] = {}
+
+    # -- inputs ----------------------------------------------------------------
+
+    def announce(self, owner: str, store, *, role: str = MAKER) -> None:
+        """Register a book: "`owner`'s book is `store`" (one per owner).
+
+        In deployment the announcement arrives over GSOC or the registry
+        events and names (owner address, topic); here the store stands in
+        for the resolved feed. Re-announcing an owner replaces the entry;
+        un-announcing (admission-by-reference's teeth) is `retract`.
+        """
+        if role not in (MAKER, CLEARING):
+            raise ValueError(f"unknown book role: {role!r}")
+        self._announced[owner] = (role, store)
+
+    def retract(self, owner: str) -> None:
+        """Stop folding an owner's book (takes effect at the next fold)."""
+        self._announced.pop(owner, None)
+
+    # -- the fold ----------------------------------------------------------------
+
+    def fold(self) -> Manifest:
+        """Sanitize every announced book, merge, re-derive, publish.
+
+        Every step is deterministic in the announced (owner, root) set, so
+        the whole manifest — not just `book_root` — reproduces across
+        aggregators that saw the same inputs.
+        """
+        provenance = self._new_store()
+        announcement = self._new_store()
+
+        staged_roots: list[str] = []
+        blobs = None
+        store_type = None
+        for owner in sorted(self._announced):
+            role, store = self._announced[owner]
+            root = store.root
+            announcement.put(f"announce/{owner}",
+                             {"role": role, "root": root or ""})
+            if not root:
+                continue
+            blobs, store_type = store.blobs, type(store)
+            source = store_type.at(root, blobs)
+            staged = self._sanitize(owner, role, root, source, provenance)
+            staged_root = staged.commit()
+            if staged_root:
+                staged_roots.append(staged_root)
+
+        book_root = None
+        for staged_root in staged_roots:
+            book_root = staged_root if book_root is None else \
+                store_type.merge(blobs, None, book_root, staged_root,
+                                 resolver=or_set_resolver)
+        book_root = book_root or ""
+
+        index = self._new_store()
+        if book_root:
+            folded = OfferRegistry(store_type.at(book_root, blobs))
+            folded.verify_loop_atomicity()   # U11, on every fold
+            index_offers(index, folded.offers())
+
+        return Manifest(
+            aggregator=self.id,
+            book_root=book_root,
+            provenance_root=provenance.commit() or "",
+            index_root=index.commit() or "",
+            announcement_root=announcement.commit() or "",
+        )
+
+    # -- admission (the U8 fold rules) -------------------------------------------
+
+    def _sanitize(self, owner: str, role: str, root: str, source,
+                  provenance) -> object:
+        """One book's admissible speech, copied into a staging store.
+
+        Fail closed in U7's spirit: a record outside its writer's
+        authority, an unreadable or mis-keyed offer, a forged maker
+        without a valid detached signature — none of it enters the fold,
+        and every rejection is an attributed provenance record.
+        """
+        staged = self._new_store()
+
+        def reject(key: str, reason: str) -> None:
+            provenance.put(f"reject/{owner}/{key}",
+                           {"owner": owner, "reason": reason})
+
+        offers: dict[str, Offer] = {}
+        records = dict(source.items())
+        for key in sorted(records):
+            rec = records[key]
+            if role == CLEARING and not (key.startswith(FILL)
+                                           or key.startswith(LOOP)):
+                # a clearing book legitimately *contains* the fold it
+                # cleared on (it re-based via absorb); only its fills and
+                # loops are its own speech — the rest is silently not
+                # re-asserted, never "rejected": provenance records are
+                # accusations, and carrying your base is not an offense
+                continue
+            if key.startswith(OFFER):
+                if role != MAKER:
+                    continue
+                oid = key[len(OFFER):]
+                try:
+                    offer = Offer.from_record(rec)
+                except (ValueError, KeyError, TypeError):
+                    reject(key, "unreadable offer record")
+                    continue
+                if offer.offer_id != oid:
+                    reject(key, "content address mismatch")
+                    continue
+                if offer.maker != owner:
+                    sig = records.get(SIG + oid)
+                    if not self._sig_recovers(oid, sig, offer.maker):
+                        reject(key, "foreign maker without valid signature")
+                        continue
+                    staged.put(SIG + oid, sig)
+                offers[oid] = offer
+                staged.put(key, rec)
+                provenance.put(f"origin/{oid}", {"owner": owner, "root": root})
+            elif key.startswith(WITHDRAW):
+                if role != MAKER:
+                    reject(key, "tombstone outside a maker book")
+                    continue
+                oid = key[len(WITHDRAW):]
+                offer = offers.get(oid)   # offer/ sorts before withdraw/
+                if offer is None or offer.maker != owner:
+                    reject(key, "tombstone for an offer this book cannot close")
+                    continue
+                staged.put(key, rec)
+            elif key.startswith(SIG):
+                oid = key[len(SIG):]
+                offer = offers.get(oid)   # offer/ sorts before sig/
+                if offer is None:
+                    reject(key, "signature without an admitted offer")
+                elif offer.maker != owner:
+                    pass   # verified and staged alongside its foreign offer
+                elif self._sig_recovers(oid, rec, owner):
+                    staged.put(key, rec)
+                # else: an own-maker signature that does not verify here
+                # (bad, or no crypto library) is dropped, not folded — feed
+                # ownership already authenticates the offer itself.
+            elif key.startswith(FILL) or key.startswith(LOOP):
+                if role != CLEARING:
+                    reject(key, "clearing keys in a maker book")
+                    continue
+                staged.put(key, rec)
+            else:
+                reject(key, "unknown keyspace")
+        return staged
+
+    @staticmethod
+    def _sig_recovers(offer_id: str, sig, maker: str) -> bool:
+        """Fail closed: no signature, no crypto library, no entry."""
+        if not isinstance(sig, str):
+            return False
+        try:
+            from .sigs import recover_maker
+            return recover_maker(offer_id, sig) == maker
+        except Exception:
+            return False
+
+
+# -- the cross-audit (T14) -----------------------------------------------------
+
+@dataclass(frozen=True, slots=True)
+class Omission:
+    """One record a manifest claims to have consumed and did not carry.
+
+    `key` sits in `owner`'s book at `announced_root` (the root the
+    aggregator's own announcement record names), is absent from
+    `book_root`, and has no `reject/` record in `provenance_root`. `proof`
+    is recordstore's absence proof for `key` against `book_root`: anyone
+    can `verify_proof(proof, book_root)` with no store access, so the
+    accusation travels as bytes, not as trust in the auditor.
+    """
+
+    owner: str
+    key: str
+    announced_root: str
+    proof: dict | None
+
+
+def audit_manifest(manifest: Manifest, blobs, *,
+                   store_type=RecordStore) -> list[Omission]:
+    """(announced set) − (speech under `book_root`), as P1 §2 defines it.
+
+    An honest fold is total on the speech it admits: every `offer/` and
+    `withdraw/` record in an announced maker book either enters
+    `book_root` or earns an attributed `reject/`. Whatever does neither
+    was dropped silently — and an aggregator's `announcement_root` is
+    its own signed claim about which inputs, at which roots, it folded,
+    so the audit needs nothing but the manifest and the blob space.
+    Omission (including pay-to-be-indexed, and the nastier form: a
+    dropped tombstone resurrecting a withdrawn offer) becomes a proof,
+    never a suspicion — the T14 defence, computable by any reader.
+
+    Not audited: `sig/` (an own-maker signature that fails to verify is
+    dropped without a rejection by design — feed ownership already
+    authenticates the offer) and clearing books (their fills and loops
+    are checked by U11 at every fold instead).
+    """
+    announced = store_type.at(manifest.announcement_root, blobs) \
+        if manifest.announcement_root else None
+    if announced is None:
+        return []
+    provenance = store_type.at(manifest.provenance_root, blobs) \
+        if manifest.provenance_root else None
+    book = store_type.at(manifest.book_root, blobs) \
+        if manifest.book_root else None
+
+    def in_store(store, key: str) -> bool:
+        if store is None:
+            return False
+        try:
+            store.get(key)
+        except KeyError:
+            return False
+        return True
+
+    omissions: list[Omission] = []
+    for ann_key in sorted(announced.keys("announce/")):
+        rec = announced.get(ann_key)
+        owner = ann_key[len("announce/"):]
+        if rec.get("role") != MAKER or not rec.get("root"):
+            continue
+        source = store_type.at(rec["root"], blobs)
+        for prefix in (OFFER, WITHDRAW):
+            for key in sorted(source.keys(prefix)):
+                if in_store(book, key):
+                    continue
+                if in_store(provenance, f"reject/{owner}/{key}"):
+                    continue
+                proof = book.prove(key) if book is not None else None
+                omissions.append(Omission(owner, key, rec["root"], proof))
+    return omissions