hypermind 2.4.2__tar.gz → 2.4.3__tar.gz

{hypermind-2.4.2 → hypermind-2.4.3}/CHANGELOG.md

@@ -16,6 +16,28 @@ changes only on major-version bumps.
 
 (nothing yet)
 
+## [2.4.3] — 2026-08-24
+
+### Fixed
+Live-validated against the 2026-08-24 relata-db upstream build (pulled the
+same day; its read plane regressed versus the 2026-08-10 build that 2.4.2 was
+validated against). Tracked upstream as
+[relatadb/RelataDB#4629](https://github.com/relatadb/RelataDB/issues/4629).
+
+- **Relata reads broke again on the newer upstream build (RELATA-DESC-RULE).**
+  On the 2026-08-24 relata-db build, *unordered* `SELECT`s return rows that
+  have lost every projected column except `id`, `ORDER BY … ASC` returns tiny
+  row subsets, and `SELECT *` returns 0 rows — while `ORDER BY <col> DESC`
+  returns full columns and correct counts on **both** builds
+  (live-observed 2026-08-24: canvas showed claims=0/disputes=0/reputation=0
+  against a seeded ledger). Every `Hm*` read in `RelataBackend` now carries an
+  explicit ≥2-column projection plus `ORDER BY … DESC` — `load_claims`
+  (`ORDER BY seq DESC`), `load_disputes` (`ORDER BY updated_ms DESC`),
+  `load_reputation` (`ORDER BY last_update_ms DESC`, replacing `SELECT *`) —
+  and each collapses bi-temporal version duplicates client-side by id.
+  `COUNT(*)` and the object-API `get()` point lookup are unaffected and keep
+  their existing shapes.
+
 ## [2.4.2] — 2026-08-24
 
 ### Fixed

{hypermind-2.4.2 → hypermind-2.4.3}/CLAUDE.md

@@ -250,9 +250,9 @@ When changing a public verb, check that every example in `examples/` still runs
 
 ## Active milestone
 
-As of 2026-08-24, the SDK is at **2.4.2** on the **engineering GA** line (engineering GA shipped 2026-07-09 as 1.0.0; SemVer is binding). The protocol core, the full swarm-intelligence / mind layer, the `hypermind.orgs` deep-research engine (decomposition + self-refine, reasoning strategies + structured outcome parsing, hypothesis lifecycle with prediction-matching, architecture-native metrics, evidence retention + citations, cross-sim learned-fit persistence via KernelStore, streaming query, full-run replay, real Relata ledger + TCP federation, PDF/site-crawl discovery + RelataDB `document_ingest` alignment, goal-driven charter-decomposed swarms), and the independent Rust second-language port (`rust/`) have all landed. Remaining gates are **ecosystem, not code** — IETF I-D submission, IANA early-allocation, OpenSSF Sandbox/Incubating acceptance, third-party security audit, full Tamarin/ProVerif proofs, NLnet/Alpha-Omega awards, ≥2 non-ZySec maintainers, ≥3 pilot MOUs, 7-day chaos-test green run, side-channel CT 30d-green. See [`docs/project/roadmap.md`](docs/project/roadmap.md) for item-numbered status.
+As of 2026-08-24, the SDK is at **2.4.3** on the **engineering GA** line (engineering GA shipped 2026-07-09 as 1.0.0; SemVer is binding). The protocol core, the full swarm-intelligence / mind layer, the `hypermind.orgs` deep-research engine (decomposition + self-refine, reasoning strategies + structured outcome parsing, hypothesis lifecycle with prediction-matching, architecture-native metrics, evidence retention + citations, cross-sim learned-fit persistence via KernelStore, streaming query, full-run replay, real Relata ledger + TCP federation, PDF/site-crawl discovery + RelataDB `document_ingest` alignment, goal-driven charter-decomposed swarms), and the independent Rust second-language port (`rust/`) have all landed. Remaining gates are **ecosystem, not code** — IETF I-D submission, IANA early-allocation, OpenSSF Sandbox/Incubating acceptance, third-party security audit, full Tamarin/ProVerif proofs, NLnet/Alpha-Omega awards, ≥2 non-ZySec maintainers, ≥3 pilot MOUs, 7-day chaos-test green run, side-channel CT 30d-green. See [`docs/project/roadmap.md`](docs/project/roadmap.md) for item-numbered status.
 
-> **Recent releases.** v2.0.0 (SemVer-major consolidation: wire-version 3 supported, deprecated-API removal, libp2p first-class transport binding, TAL v0.2 wire messages, Sealed/Citeable lattice, second-language port in progress). v2.1.0–v2.1.5 (2026-07-27): Rust port landed (`rust/`), L1–L5 autonomy stack, FTS5 storage, MoA endpoint, IEEE-defensible eval benchmark, dark-theme HTML report. v2.2.0 (2026-07-28): autonomy pass (#983) — SSRF redirect/hostname hardening, deployment `profiles`, `coevolution`, `silent_failures`/`health`, `reputation_store`, `CachingResponder`/`DifficultyRouter`, hybrid SQLite search, active grounding gates (defaults changed, API-compatible). v2.2.1 (2026-07-29): CAP_REVOKE gossip + canonical-CBOR gate (#943 P1), TAL v0.2 signed wire messages (#943 P2), bi-temporal recall + cross-namespace Merkle citation proofs (#942), streamable-HTTP MCP gateway (#1013). v2.3.0 (2026-07-31): PDF/site-crawl discovery (#1018), RelataDB `document_ingest` alignment (#1019), goal-driven charter swarms (#1020), intra-expert research probe gate (#1021). v2.4.0 (2026-08-24): `hmctl show` live network canvas (`hypermind.viz`), ledger tenancy onboarding (`hmctl setup` + `hypermind.storage.tenancy`), admin-key handling contract, `mcp serve --namespace`, doctor ledger checks, live-validated Relata read fixes (sentinel rows, projection quirk). v2.4.1 (2026-08-24): drop `AS OF CURRENT` from all Relata reads (new server build returns sentinel-only). v2.4.2 (2026-08-24): three more live-validated Relata durability/correctness fixes — synchronous bulk writes for disputes/citations, ≥2-column projections (1-column SELECTs return 0 rows), bi-temporal version collapse on reads; macOS virtiofs data-loss deployment note (upstream relatadb/RelataDB#4627–#4630). The 2026-07-25 security-hardening fixes (issues #839-#844) shipped in 2.0 Phase 0. See [`CHANGELOG.md`](CHANGELOG.md) and [`docs/project/v2.0-plan.md`](docs/project/v2.0-plan.md).
+> **Recent releases.** v2.0.0 (SemVer-major consolidation: wire-version 3 supported, deprecated-API removal, libp2p first-class transport binding, TAL v0.2 wire messages, Sealed/Citeable lattice, second-language port in progress). v2.1.0–v2.1.5 (2026-07-27): Rust port landed (`rust/`), L1–L5 autonomy stack, FTS5 storage, MoA endpoint, IEEE-defensible eval benchmark, dark-theme HTML report. v2.2.0 (2026-07-28): autonomy pass (#983) — SSRF redirect/hostname hardening, deployment `profiles`, `coevolution`, `silent_failures`/`health`, `reputation_store`, `CachingResponder`/`DifficultyRouter`, hybrid SQLite search, active grounding gates (defaults changed, API-compatible). v2.2.1 (2026-07-29): CAP_REVOKE gossip + canonical-CBOR gate (#943 P1), TAL v0.2 signed wire messages (#943 P2), bi-temporal recall + cross-namespace Merkle citation proofs (#942), streamable-HTTP MCP gateway (#1013). v2.3.0 (2026-07-31): PDF/site-crawl discovery (#1018), RelataDB `document_ingest` alignment (#1019), goal-driven charter swarms (#1020), intra-expert research probe gate (#1021). v2.4.0 (2026-08-24): `hmctl show` live network canvas (`hypermind.viz`), ledger tenancy onboarding (`hmctl setup` + `hypermind.storage.tenancy`), admin-key handling contract, `mcp serve --namespace`, doctor ledger checks, live-validated Relata read fixes (sentinel rows, projection quirk). v2.4.1 (2026-08-24): drop `AS OF CURRENT` from all Relata reads (new server build returns sentinel-only). v2.4.2 (2026-08-24): three more live-validated Relata durability/correctness fixes — synchronous bulk writes for disputes/citations, ≥2-column projections (1-column SELECTs return 0 rows), bi-temporal version collapse on reads; macOS virtiofs data-loss deployment note (upstream relatadb/RelataDB#4627–#4630). v2.4.3 (2026-08-24): RELATA-DESC-RULE — every Hm* read carries an explicit projection + `ORDER BY … DESC` (the 2026-08-24 upstream build regressed: unordered SELECTs drop projected columns, ASC subsets, `SELECT *` → 0 rows); claims/disputes/reputation reads had silently returned empty against the new image. The 2026-07-25 security-hardening fixes (issues #839-#844) shipped in 2.0 Phase 0. See [`CHANGELOG.md`](CHANGELOG.md) and [`docs/project/v2.0-plan.md`](docs/project/v2.0-plan.md).
 
 > **Note on doc locations (2026-07-25):** `CHARTER.md`, `GOVERNANCE.md`, `MAINTAINERS.md`, `ROADMAP.md`, and `REPO_MAP.md` were moved from the repo root into [`docs/project/`](docs/project/) (renamed lowercase). Root retains only the GitHub platform files (`README`, `LICENSE`, `SECURITY`, `CODE_OF_CONDUCT`, `CONTRIBUTING`, `CHANGELOG`, `CODEOWNERS`) plus `CLAUDE.md`. See [`docs/INDEX.md`](docs/INDEX.md) for the full doc map.
 

{hypermind-2.4.2 → hypermind-2.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hypermind
-Version: 2.4.2
+Version: 2.4.3
 Summary: Federated agent intelligence — reference SDK for the HyperMind SCITT contested-claims profile
 Project-URL: Homepage, https://github.com/ZySec-AI/hypermind
 Project-URL: Documentation, https://github.com/ZySec-AI/hypermind/tree/main/docs

{hypermind-2.4.2 → hypermind-2.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hypermind"
-version = "2.4.2"
+version = "2.4.3"
 description = "Federated agent intelligence — reference SDK for the HyperMind SCITT contested-claims profile"
 readme = "README.md"
 requires-python = ">=3.12,<3.15"

{hypermind-2.4.2 → hypermind-2.4.3}/src/hypermind/storage/relata.py

@@ -364,11 +364,16 @@ class RelataBackend:
         from hypermind.wire import SignedStatement
 
         self.flush_claims()
-        # RELATA-1COL-BUG: single-column projections deterministically return
-        # 0 rows on this build (live-observed 2026-08-24: `SELECT wire_b64 …`
-        # → 0 rows while `SELECT id, wire_b64 …` → all rows, same session) —
-        # always project at least two columns and read the one we need.
-        rows = self._rows("SELECT id, wire_b64 FROM HmClaim ORDER BY seq ASC")
+        # RELATA-DESC-RULE (live-observed 2026-08-24 across two upstream
+        # builds): every Hm* table read MUST carry `ORDER BY <col> DESC` —
+        # builds differ in *which* violation they exhibit, but DESC works on
+        # both: (a) unordered SELECTs drop all projected columns except `id`
+        # on the 2026-08-24 build (and star-SELECTs return sentinel columns
+        # only); (b) `ASC` ordering returns a tiny row subset on that build;
+        # (c) single-column projections return 0 rows on the 2026-08-10
+        # build. Fetch DESC (newest first), reverse, and dedupe client-side.
+        rows = self._rows("SELECT id, wire_b64 FROM HmClaim ORDER BY seq DESC")
+        rows.reverse()  # → oldest first, the original publish order
         out: list[SignedStatement] = []
         seen_ids: set[str] = set()
         for r in rows:
@@ -453,15 +458,21 @@ class RelataBackend:
         )
 
     def load_disputes(self) -> dict[Kid, Dispute]:
-        out: dict[bytes, Dispute] = {}
-        # explicit ≥2-column projection (see load_claims). Plain SELECT
-        # returns every bi-temporal version; ordered ASC by updated_ms so the
-        # dict's last-write-wins keeps the LATEST dispute state per kid.
-        for r in self._rows("SELECT claim_kid, payload_b64 FROM HmDispute ORDER BY updated_ms ASC"):
+        out: dict[Kid, Dispute] = {}
+        # explicit ≥2-column projection + DESC ordering (see load_claims for
+        # the RELATA-DESC-RULE). Rows arrive newest-first; plain SELECT
+        # returns every bi-temporal version, so first-seen-per-kid wins and
+        # keeps the LATEST dispute state.
+        seen: set[str] = set()
+        for r in self._rows(
+            "SELECT claim_kid, payload_b64 FROM HmDispute ORDER BY updated_ms DESC"
+        ):
+            kid_hex = r.get("claim_kid") or ""
+            if kid_hex in seen:
+                continue
+            seen.add(kid_hex)
             try:
-                out[bytes.fromhex(r["claim_kid"])] = _cbor_to_dispute(
-                    base64.b64decode(r["payload_b64"])
-                )
+                out[bytes.fromhex(kid_hex)] = _cbor_to_dispute(base64.b64decode(r["payload_b64"]))
             except Exception:
                 continue
         return out
@@ -490,17 +501,33 @@ class RelataBackend:
         )
 
     def load_reputation(self) -> list[tuple[bytes, str, float, float, int]]:
-        # GAP-SNAP-REP-10: filter by namespace in Python (Relata client has no parameterized
-        # queries) so cross-org rows from the same table are never imported into the wrong sim.
-        # SELECT * + local projection (see load_claims for the server quirk).
-        rows = self._rows("SELECT * FROM HmReputation")
+        # SW-003 strict namespace filter + GAP-SNAP-REP-10 (no parameterized
+        # queries server-side). RELATA-DESC-RULE (see load_claims): explicit
+        # projection + ORDER BY … DESC; newest-first, so first-seen-per-id
+        # keeps the LATEST posterior.
+        seen: set[str] = set()
         _ns = self._ns
-        # SW-003: strict filter — legacy null-namespace rows must NOT match _ns
-        rows = [r for r in rows if r.get("namespace") == _ns]
-        return [
-            (bytes.fromhex(r["agent_hex"]), r["topic"], r["alpha"], r["beta"], r["last_update_ms"])
-            for r in rows
-        ]
+        out: list[tuple[bytes, str, float, float, int]] = []
+        for r in self._rows(
+            "SELECT id, agent_hex, topic, namespace, alpha, beta, "
+            "last_update_ms FROM HmReputation ORDER BY last_update_ms DESC"
+        ):
+            # Legacy null-namespace rows must NOT match _ns.
+            if r.get("namespace") == _ns and r.get("id") not in seen:
+                seen.add(r["id"])
+                try:
+                    out.append(
+                        (
+                            bytes.fromhex(r["agent_hex"]),
+                            r["topic"],
+                            r["alpha"],
+                            r["beta"],
+                            r["last_update_ms"],
+                        )
+                    )
+                except Exception:
+                    continue
+        return out
 
     # ---- Merkle leaves → Relata's durable ordered log -------------------
 

{hypermind-2.4.2 → hypermind-2.4.3}/tests/integrations/test_verifiable_rag.py

@@ -316,9 +316,6 @@ async def test_relata_backend_hybrid_search_like_fallback():
             if "COUNT(*)" in sql:
                 table = sql.split("FROM ")[1].split()[0]
                 return _FakeResult([{"n": len(objs.get(table, {}))}])
-            if "ORDER BY seq DESC" in sql:
-                seqs = [f["seq"] for f in objs.get("HmClaim", {}).values()]
-                return _FakeResult([{"seq": max(seqs)}] if seqs else [])
             if "FROM HmClaim" in sql and "LIKE" in sql:
                 # Return all stored claims that match any LIKE term
                 all_claims = list(objs.get("HmClaim", {}).values())
@@ -343,8 +340,17 @@ async def test_relata_backend_hybrid_search_like_fallback():
                     ]
                 )
             if "FROM HmClaim" in sql:
-                rows = sorted(objs.get("HmClaim", {}).values(), key=lambda f: f["seq"])
-                return _FakeResult([{"wire_b64": f["wire_b64"], "seq": f["seq"]} for f in rows])
+                # RELATA-DESC-RULE reads arrive newest-first, like the live server.
+                rows = sorted(
+                    objs.get("HmClaim", {}).values(), key=lambda f: f["seq"], reverse=True
+                )
+                if "LIMIT 1" in sql:  # seq high-water init (open)
+                    return _FakeResult(
+                        [{"id": rows[0]["id"], "seq": rows[0]["seq"]}] if rows else []
+                    )
+                return _FakeResult(
+                    [{"id": f["id"], "wire_b64": f["wire_b64"], "seq": f["seq"]} for f in rows]
+                )
             if "FROM HmDispute" in sql:
                 return _FakeResult([])
             if "FROM HmReputation" in sql:

{hypermind-2.4.2 → hypermind-2.4.3}/tests/orgs/test_sim.py

@@ -81,12 +81,14 @@ class _FakeClient:
         if "COUNT(*)" in sql:
             table = sql.split("FROM ")[1].split()[0]
             return _FakeResult([{"n": len(objs.get(table, {}))}])
-        if "ORDER BY seq DESC" in sql:
-            seqs = [f["seq"] for f in objs.get("HmClaim", {}).values()]
-            return _FakeResult([{"seq": max(seqs)}] if seqs else [])
         if "FROM HmClaim" in sql:
-            rows = sorted(objs.get("HmClaim", {}).values(), key=lambda f: f["seq"])
-            return _FakeResult([{"wire_b64": f["wire_b64"], "seq": f["seq"]} for f in rows])
+            # RELATA-DESC-RULE reads arrive newest-first, like the live server.
+            rows = sorted(objs.get("HmClaim", {}).values(), key=lambda f: f["seq"], reverse=True)
+            if "LIMIT 1" in sql:  # seq high-water init (open)
+                return _FakeResult([{"id": rows[0]["id"], "seq": rows[0]["seq"]}] if rows else [])
+            return _FakeResult(
+                [{"id": f["id"], "wire_b64": f["wire_b64"], "seq": f["seq"]} for f in rows]
+            )
         if "FROM HmDispute" in sql:
             return _FakeResult(
                 [

{hypermind-2.4.2 → hypermind-2.4.3}/tests/storage/test_relata_backend.py

@@ -119,23 +119,52 @@ class _FakeClient:
         if "COUNT(*)" in sql:
             table = sql.split("FROM ")[1].split()[0]
             return _FakeResult([{"n": len(objs.get(table, {}))}])
-        if "ORDER BY seq DESC" in sql:  # seq high-water init (open)
-            seqs = [f["seq"] for f in objs.get("HmClaim", {}).values()]
-            return _FakeResult([{"seq": max(seqs)}] if seqs else [])
         if "FROM HmClaim" in sql:
-            rows = sorted(objs.get("HmClaim", {}).values(), key=lambda f: f["seq"])
-            return _FakeResult(
+            # Every backend read is RELATA-DESC-RULE shaped (ORDER BY … DESC);
+            # mirror the live server's newest-first row order so the backend's
+            # version-collapse dedupe runs against realistic input.
+            rows = sorted(objs.get("HmClaim", {}).values(), key=lambda f: f["seq"], reverse=True)
+            if "LIMIT 1" in sql:  # seq high-water init (open)
+                return _FakeResult([{"id": rows[0]["id"], "seq": rows[0]["seq"]}] if rows else [])
+            if "author_hex" in sql:  # load_claim_stubs (9-column projection)
+                cols = (
+                    "id",
+                    "author_hex",
+                    "label",
+                    "unit",
+                    "role",
+                    "confidence",
+                    "text",
+                    "evidenced",
+                    "topic",
+                )
+                return _FakeResult([{k: f.get(k) for k in cols} for f in rows])
+            if "namespace" in sql:  # recent_findings
+                limit = int(sql.rsplit("LIMIT ", 1)[1])
+                return _FakeResult(
+                    [{"wire_b64": f["wire_b64"], "namespace": f.get("namespace")} for f in rows][
+                        :limit
+                    ]
+                )
+            return _FakeResult(  # load_claims
                 [{"id": f["id"], "wire_b64": f["wire_b64"], "seq": f["seq"]} for f in rows]
             )
         if "FROM HmDispute" in sql:
+            rows = sorted(
+                objs.get("HmDispute", {}).values(),
+                key=lambda f: f.get("updated_ms", 0),
+                reverse=True,
+            )
             return _FakeResult(
-                [
-                    {"claim_kid": f["claim_kid"], "payload_b64": f["payload_b64"]}
-                    for f in objs.get("HmDispute", {}).values()
-                ]
+                [{"claim_kid": f["claim_kid"], "payload_b64": f["payload_b64"]} for f in rows]
             )
         if "FROM HmReputation" in sql:
-            return _FakeResult(list(objs.get("HmReputation", {}).values()))
+            rows = sorted(
+                objs.get("HmReputation", {}).values(),
+                key=lambda f: f.get("last_update_ms", 0),
+                reverse=True,
+            )
+            return _FakeResult(list(rows))
         if "FROM HmTranscript WHERE id" in sql:
             tid = sql.split("'")[1]
             hit = objs.get("HmTranscript", {}).get(tid)
@@ -275,12 +304,9 @@ def test_reads_collapse_bi_temporal_version_duplicates(monkeypatch):
     kid_hex = stmt.kid.hex()
 
     def fake_rows(sql: str):
-        if "ORDER BY seq ASC" in sql:  # load_claims
-            return [
-                {"id": kid_hex, "wire_b64": wire_b64, "seq": 1},
-                {"id": kid_hex, "wire_b64": wire_b64, "seq": 2},
-            ]
-        if "ORDER BY seq DESC" in sql:  # load_claim_stubs
+        # Both reads are RELATA-DESC-RULE shaped (ORDER BY seq DESC) —
+        # disambiguate by projection, exactly like the real SQL.
+        if "author_hex" in sql:  # load_claim_stubs (newest-first)
             return [
                 {
                     "id": kid_hex,
@@ -305,6 +331,11 @@ def test_reads_collapse_bi_temporal_version_duplicates(monkeypatch):
                     "topic": "t",
                 },
             ]
+        if "wire_b64" in sql:  # load_claims (newest-first)
+            return [
+                {"id": kid_hex, "wire_b64": wire_b64, "seq": 2},
+                {"id": kid_hex, "wire_b64": wire_b64, "seq": 1},
+            ]
         return []
 
     monkeypatch.setattr(b, "_rows", fake_rows)

{hypermind-2.4.2 → hypermind-2.4.3}/tests/viz/test_relata.py

@@ -74,25 +74,32 @@ class _FakeClient:
         if "COUNT(*)" in sql:
             table = sql.split("FROM ")[1].split()[0]
             return _FakeResult([{"n": len(objs.get(table, {}))}])
-        if sql.startswith("SELECT id, author_hex, label, unit, role"):
-            # load_claim_stubs(): full rows, newest first
-            rows = sorted(objs.get("HmClaim", {}).values(), key=lambda f: f["seq"], reverse=True)
-            return _FakeResult(rows)
-        if "ORDER BY seq DESC" in sql:
-            seqs = [f["seq"] for f in objs.get("HmClaim", {}).values()]
-            return _FakeResult([{"seq": max(seqs)}] if seqs else [])
         if "FROM HmClaim" in sql:
-            rows = sorted(objs.get("HmClaim", {}).values(), key=lambda f: f["seq"])
+            # All backend reads are RELATA-DESC-RULE shaped (ORDER BY … DESC);
+            # newest-first, like the live server.
+            rows = sorted(objs.get("HmClaim", {}).values(), key=lambda f: f["seq"], reverse=True)
+            if "LIMIT 1" in sql:  # seq high-water init (open)
+                return _FakeResult([{"id": rows[0]["id"], "seq": rows[0]["seq"]}] if rows else [])
+            if sql.startswith("SELECT id, author_hex"):
+                # load_claim_stubs(): full rows, newest first
+                return _FakeResult(rows)
             return _FakeResult([{"wire_b64": f["wire_b64"], "seq": f["seq"]} for f in rows])
         if "FROM HmDispute" in sql:
+            rows = sorted(
+                objs.get("HmDispute", {}).values(),
+                key=lambda f: f.get("updated_ms", 0),
+                reverse=True,
+            )
             return _FakeResult(
-                [
-                    {"claim_kid": f["claim_kid"], "payload_b64": f["payload_b64"]}
-                    for f in objs.get("HmDispute", {}).values()
-                ]
+                [{"claim_kid": f["claim_kid"], "payload_b64": f["payload_b64"]} for f in rows]
             )
         if "FROM HmReputation" in sql:
-            return _FakeResult(list(objs.get("HmReputation", {}).values()))
+            rows = sorted(
+                objs.get("HmReputation", {}).values(),
+                key=lambda f: f.get("last_update_ms", 0),
+                reverse=True,
+            )
+            return _FakeResult(list(rows))
         raise AssertionError(f"fake got unexpected SQL: {sql}")
 
     def close(self) -> None: