hypermind 2.4.0__tar.gz → 2.4.2__tar.gz

{hypermind-2.4.0 → hypermind-2.4.2}/.github/workflows/release.yml

@@ -40,6 +40,9 @@ jobs:
     name: test (py${{ matrix.python }})
     needs: guard-source-branch
     runs-on: ubuntu-latest
+    # A wedged self-hosted runner would otherwise sit on the 360-min default
+    # (observed 2026-08-24: run tests step stalled 24+ min vs ~6 min baseline).
+    timeout-minutes: 25
     strategy:
       fail-fast: false
       matrix:
@@ -59,6 +62,7 @@ jobs:
   build:
     name: build sdist + wheel
     runs-on: ubuntu-latest
+    timeout-minutes: 15
     needs: test
     outputs:
       hashes: ${{ steps.hash.outputs.hashes }}
@@ -159,6 +163,7 @@ jobs:
   publish-pypi:
     name: publish → PyPI
     runs-on: ubuntu-latest
+    timeout-minutes: 15
     needs: build
     if: startsWith(github.ref, 'refs/tags/v')
     environment:
@@ -232,6 +237,7 @@ jobs:
   docker:
     name: docker — hub.docker.com/openworkbench/hypermind
     runs-on: ubuntu-latest
+    timeout-minutes: 45  # multi-arch (amd64+arm64) QEMU build; observed ~95s warm, ~15 min cold
     needs: build
     if: startsWith(github.ref, 'refs/tags/v')
     permissions:

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

@@ -14,6 +14,96 @@ changes only on major-version bumps.
 
 ## [Unreleased]
 
+(nothing yet)
+
+## [2.4.2] — 2026-08-24
+
+### Fixed
+All three fixes below are live-validated workarounds for relata-db 2.0.0
+(build 2026-08-10) server bugs, filed upstream as
+[relatadb/RelataDB#4627](https://github.com/relatadb/RelataDB/issues/4627)–[#4629](https://github.com/relatadb/RelataDB/issues/4629).
+
+- **Relata disputes and citation counters silently lost (`/ingest` async queue).**
+  The relata server's single-row `upsert` endpoint (`POST /ingest`) returns an
+  *async task receipt* — the write only becomes query-visible when the
+  server's background ingest queue drains, and is dropped entirely if the
+  server stops first. `RelataBackend.append_dispute` and
+  `increment_citations` used that path, so disputes filed late in a run
+  vanished on restart and citation counts lagged indefinitely
+  (live-observed 2026-08-24). Both now route through `batch_upsert`
+  (`POST /ingest/bulk`), which commits synchronously — read-after-write
+  holds and a stop can no longer drop the write.
+- **Relata reads return every bi-temporal version, not current state.**
+  A plain relata `SELECT` on the 2026-08-10 build returns all versions of a
+  row (live-observed 2026-08-24: re-appending the same kid under
+  `on_conflict=skip` left seq-1 and seq-2 rows, and both came back), so
+  restore/replay double-counted re-published claims. `load_claims` and
+  `load_claim_stubs` now collapse duplicates by kid (first / newest version
+  respectively); `load_disputes` orders by `updated_ms` so last-write-wins
+  keeps the latest dispute state.
+- **Relata single-column `SELECT`s return 0 rows.** On the 2026-08-10
+  relata-db build, a single-column projection (`SELECT wire_b64 FROM HmClaim`,
+  `SELECT seq FROM HmClaim … LIMIT 1`) deterministically returns 0 rows while
+  adding any second column returns every row (live-observed 2026-08-24, same
+  session, same data). `load_claims` came back empty (blank `hmctl show`
+  canvases from Relata) and the `open()` high-water probe silently reset the
+  sequence counter, breaking append order across restarts. Both now project
+  two columns and read the one they need; the other reads were already
+  multi-column.
+
+### Deployment notes
+- **macOS hosts: do not put the relata data dir on a virtiofs bind mount.**
+  The server's WAL-mirror sync fails continuously under virtiofs
+  (`ETag mismatch`) and seal-time compaction then silently loses the entire
+  ledger — across restarts *and* mid-session (live-observed 2026-08-24, filed
+  upstream as
+  [#4627](https://github.com/relatadb/RelataDB/issues/4627)). The Apple
+  `container` runtime path in hypermind-deploy's `start.sh` now runs
+  hm-relatadb on the container's own disk; see that repo for details and the
+  Docker-compose caveat.
+
+## [2.4.1] — 2026-08-24
+
+### Fixed
+- **Relata read path broken by relata-db ≥2026-08-10 builds (`AS OF CURRENT`).**
+  Every `RelataBackend` read (`load_claims`, `load_claim_stubs`, head-seq,
+  recent-findings) carried a bi-temporal `AS OF CURRENT` clause; on the
+  2026-08-10 server build that filter reduces `HmClaim` queries to the
+  table's internal sentinel rows only (live-validated 2026-08-24: 1
+  sentinel row returned vs 411 claims without the clause), so every
+  Relata-backed read — restore-on-startup, `hmctl show --relata-url`,
+  replay — silently came back empty. A plain `SELECT` is already
+  current-state semantics and works on every build; the clause is removed
+  from all four read sites.
+- **`from_relata()` node labels.** DB-sourced canvases showed bare hex ids;
+  the per-author label is now harvested from the GAP-R10 claim stubs
+  alongside unit/role.
+- **`hmctl show` community/unit mapping (org structure was invisible).**
+  Communities detected from cite/vouch affinity were labelled anonymously
+  ("community 1/2/…") and org structure (e.g. a university template's
+  departments) leaked into the *topic* filter instead. The canvas now:
+  - names each community after its members' dominant `unit` (nodes carry
+    `community`; `meta.communities` lists them; clusters with no unit info
+    keep the stable generic label);
+  - ships a dedicated **community filter** (`#hm-community`) across the
+    agents / conversation / claims panes, and the cluster legend uses the
+    real names;
+  - `from_relata()` harvests per-author unit/role from the GAP-R10 claim
+    stub columns, so DB-sourced canvases carry attribution without a live
+    world;
+  - `RelataBackend.append_claim()` derives `label`/`unit`/`role` from the
+    claim payload when the caller passes none (GAP-R10 parity for the bare
+    agent path — `world.persist_claim` → `append_claim(stmt)` used to
+    persist empty attribution for every plain `publish_claim()`).
+  Regression-pinned in `tests/viz/` (naming, fallback label, from_relata
+  enrichment, filter markup).
+- **`HyperMindAgent.cite()` default-uncertainty crash.** The no-`uncertainty=`
+  branch built `Uncertainty(alpha=9.0, beta=1.0)` against the current
+  `(kind, params)` constructor, so every cite without an explicit
+  `Uncertainty` raised `TypeError`. Found live during tenant-onboarding
+  validation (2026-08-24); regression-pinned in
+  `tests/test_agent_cite_default.py`.
+
 ## [2.4.0] — 2026-08-24
 
 ### Added

{hypermind-2.4.0 → hypermind-2.4.2}/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.0** 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.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.
 
-> **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). 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). 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.0 → hypermind-2.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hypermind
-Version: 2.4.0
+Version: 2.4.2
 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.0 → hypermind-2.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hypermind"
-version = "2.4.0"
+version = "2.4.2"
 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.0 → hypermind-2.4.2}/src/hypermind/agent.py

@@ -3173,7 +3173,7 @@ class HyperMindAgent:
         # Publish the citation record so it is sealed and auditable.
         from hypermind.uncertainty import Uncertainty as _Uncertainty
 
-        _unc = uncertainty if uncertainty is not None else _Uncertainty(alpha=9.0, beta=1.0)
+        _unc = uncertainty if uncertainty is not None else _Uncertainty("beta", (9.0, 1.0))
         return await self.publish_claim(
             {
                 "claim_type": "cite",

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

@@ -140,7 +140,15 @@ class RelataBackend:
         # Initialise next_seq from the high-water mark so append order survives
         # restart. Relata's SQL subset rejects COALESCE(MAX(...)); use ORDER BY
         # DESC LIMIT 1 instead (verified against the live server).
-        rows = self._rows("SELECT seq FROM HmClaim AS OF CURRENT ORDER BY seq DESC LIMIT 1")
+        # NOTE: deliberately no `AS OF CURRENT` — the relata-db 2026-08-10
+        # build's bi-temporal filter reduces `SELECT * … AS OF CURRENT` to
+        # the table's internal sentinel rows only (live-validated 2026-08-24:
+        # 1 sentinel row vs 411 claims without the clause). A plain SELECT is
+        # already current-state semantics, and works on every build.
+        # RELATA-1COL-BUG: never project a single column — `SELECT seq …`
+        # returns 0 rows on this build (see load_claims), which would silently
+        # reset the sequence counter and break append order.
+        rows = self._rows("SELECT id, seq FROM HmClaim ORDER BY seq DESC LIMIT 1")
         # Sentinel rows share the table and carry no seq (see load_claims).
         self._seq = (int(rows[0]["seq"]) + 1) if rows and rows[0].get("seq") is not None else 1
 
@@ -203,6 +211,14 @@ class RelataBackend:
             confidence = float(user.get("confidence", 0.7))
             if topic is None:
                 topic = user.get("topic") or None
+            # GAP-R10 parity for the bare agent path: ``world.persist_claim``
+            # calls ``append_claim(stmt)`` with no attribution kwargs, which
+            # left label/unit/role empty for every plain ``publish_claim()``.
+            # Derive from the payload exactly like text/topic so DB-backed
+            # canvases can name communities by unit.
+            label = label or str(user.get("label", "") or "")
+            unit = unit or str(user.get("unit", "") or "")
+            role = role or str(user.get("role", "") or "")
             source_url = str(user.get("source_url", "") or "")
             source_type = str(user.get("source_type", "") or "")
             arxiv_id = str(user.get("arxiv_id", "") or "")
@@ -302,7 +318,10 @@ class RelataBackend:
             try:
                 existing = self._obj.get("HmClaim", kid_hex) or {}
                 count = int(existing.get("citations_received") or 0) + 1
-                self._obj.upsert("HmClaim", kid_hex, {"citations_received": count})
+                # RELATA-ASYNC-INGEST: batch_upsert commits synchronously (see
+                # append_dispute) — single upsert would only queue the counter
+                # write and lose it on server shutdown.
+                self._obj.batch_upsert("HmClaim", [{"id": kid_hex, "citations_received": count}])
             except Exception as _sf_exc:
                 _record_suppressed("storage.relata.increment_citations", _sf_exc)
 
@@ -321,7 +340,7 @@ class RelataBackend:
         self.flush_claims()
         # RELATA-005: include namespace column so cross-sim claim bleed is filtered.
         rows = self._rows(
-            f"SELECT wire_b64, namespace FROM HmClaim AS OF CURRENT ORDER BY created_ms DESC LIMIT {int(max(1, limit))}"
+            f"SELECT wire_b64, namespace FROM HmClaim ORDER BY created_ms DESC LIMIT {int(max(1, limit))}"
         )
         _ns = self._ns
         out: list[tuple[str, str]] = []
@@ -345,12 +364,23 @@ class RelataBackend:
         from hypermind.wire import SignedStatement
 
         self.flush_claims()
-        # SELECT * — some Relata builds intermittently return a tiny subset of
-        # rows for multi-column projections while SELECT * returns them all
-        # (observed live 2026-08-24); read all columns and project here.
-        rows = self._rows("SELECT * FROM HmClaim AS OF CURRENT ORDER BY seq ASC")
+        # 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")
         out: list[SignedStatement] = []
+        seen_ids: set[str] = set()
         for r in rows:
+            # Plain SELECT returns every bi-temporal version, not just current
+            # state (live-observed 2026-08-24: re-appending the same kid under
+            # on_conflict=skip still leaves seq 1 and seq 2 rows). Collapse to
+            # the first version — the original publish order.
+            _id = r.get("id")
+            if _id:
+                if _id in seen_ids:
+                    continue
+                seen_ids.add(_id)
             wire = r.get("wire_b64")
             if not wire:
                 # Server builds keep internal sentinel objects in the HmClaim
@@ -367,42 +397,67 @@ class RelataBackend:
         survives restarts without a full CBOR decode.
         """
         self.flush_claims()
-        rows = self._rows("SELECT * FROM HmClaim AS OF CURRENT ORDER BY seq DESC")
-        return [
-            {
-                "kid_hex": r.get("id", ""),
-                "author_hex": r.get("author_hex", ""),
-                "label": r.get("label", ""),
-                "unit": r.get("unit", ""),
-                "role": r.get("role", ""),
-                "confidence": float(r.get("confidence") or 0.7),
-                "finding": str(r.get("text") or ""),
-                "evidenced": bool(r.get("evidenced")),
-                "topic": r.get("topic", ""),
-            }
-            for r in rows[:limit]
-        ]
+        # ≥2-column projection (1-col SELECTs return 0 rows — see load_claims).
+        # Rows are seq DESC → first row per id is the newest version; collapse
+        # the bi-temporal duplicates.
+        rows = self._rows(
+            "SELECT id, author_hex, label, unit, role, confidence, "
+            "text, evidenced, topic FROM HmClaim ORDER BY seq DESC"
+        )
+        stubs: list[dict[str, Any]] = []
+        seen: set[str] = set()
+        for r in rows:
+            kid_hex = r.get("id") or ""
+            if kid_hex in seen:
+                continue
+            seen.add(kid_hex)
+            stubs.append(
+                {
+                    "kid_hex": kid_hex,
+                    "author_hex": r.get("author_hex", ""),
+                    "label": r.get("label", ""),
+                    "unit": r.get("unit", ""),
+                    "role": r.get("role", ""),
+                    "confidence": float(r.get("confidence") or 0.7),
+                    "finding": str(r.get("text") or ""),
+                    "evidenced": bool(r.get("evidenced")),
+                    "topic": r.get("topic", ""),
+                }
+            )
+            if len(stubs) >= limit:
+                break
+        return stubs
 
     # ---- Disputes (upsert by claim kid) ---------------------------------
 
     def append_dispute(self, kid: Kid, dispute: Dispute) -> None:
         payload = _dispute_to_cbor(dispute)
-        self._obj.upsert(
+        kid_hex = bytes(kid).hex()
+        # RELATA-ASYNC-INGEST: the single-row `upsert` (`POST /ingest`) returns
+        # an async task receipt (rows_queued/task_id) — the write only becomes
+        # query-visible when the server's background ingest queue drains, and
+        # is LOST if the server stops first (live-observed 2026-08-24: seeded
+        # disputes vanished on container restart). `/ingest/bulk`
+        # (batch_upsert) commits synchronously, so route the one-row write
+        # through it — read-after-write holds and shutdown can't drop it.
+        self._obj.batch_upsert(
             "HmDispute",
-            bytes(kid).hex(),
-            {
-                "claim_kid": bytes(kid).hex(),
-                "payload_b64": base64.b64encode(payload).decode("ascii"),
-                "updated_ms": int(time.time() * 1000),
-            },
+            [
+                {
+                    "id": kid_hex,
+                    "claim_kid": kid_hex,
+                    "payload_b64": base64.b64encode(payload).decode("ascii"),
+                    "updated_ms": int(time.time() * 1000),
+                }
+            ],
         )
 
     def load_disputes(self) -> dict[Kid, Dispute]:
         out: dict[bytes, Dispute] = {}
-        # SELECT * — some Relata builds return 0 rows for a multi-column
-        # projection on HmDispute while SELECT * returns the same rows
-        # (observed live 2026-08-24); read all columns and project here.
-        for r in self._rows("SELECT * FROM HmDispute"):
+        # 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"):
             try:
                 out[bytes.fromhex(r["claim_kid"])] = _cbor_to_dispute(
                     base64.b64decode(r["payload_b64"])

{hypermind-2.4.0 → hypermind-2.4.2}/src/hypermind/viz/canvas_html.py

@@ -300,6 +300,7 @@ def render_canvas_html(
   <div class="filters" id="hm-filters">
     <input id="hm-search" type="search" placeholder="Search agents, findings, reasons…" autocomplete="off">
     <select id="hm-topic" aria-label="filter by topic"><option value="">all topics</option></select>
+    <select id="hm-community" aria-label="filter by community"><option value="">all communities</option></select>
     <label class="toggle"><input type="checkbox" checked data-edge="cites"><span class="key cites"></span>cites</label>
     <label class="toggle"><input type="checkbox" checked data-edge="vouches"><span class="key vouches"></span>vouches</label>
     <label class="toggle"><input type="checkbox" checked data-edge="disputes"><span class="key disputes"></span>disputes</label>
@@ -538,7 +539,7 @@ _JS = """
   function edgeColor(t) { return (EDGE_COLOR[t] || OTHER)[dark ? 1 : 0]; }
 
   // ---- state ----------------------------------------------------------
-  var state = { tab: 'graph', search: '', topic: '', edgeTypes: { cites: true, vouches: true, disputes: true }, cursor: 0, sort: { key: null, dir: 1 } };
+  var state = { tab: 'graph', search: '', topic: '', community: '', edgeTypes: { cites: true, vouches: true, disputes: true }, cursor: 0, sort: { key: null, dir: 1 } };
 
   var nodeById = {};
   var clusterColor = {}, clusterLabel = {};
@@ -553,9 +554,17 @@ _JS = """
     var sizes = {};
     nodes.forEach(function (n) { var c = n.cluster == null ? 0 : n.cluster; sizes[c] = (sizes[c] || 0) + 1; });
     var order = Object.keys(sizes).sort(function (a, b) { return sizes[b] - sizes[a] || (+a) - (+b); });
+    // Prefer the backend-provided community name (dominant unit of the
+    // cluster's members — e.g. a university template's departments); fall
+    // back to the anonymous slot label when the source has no unit info.
+    var nameByCluster = {};
+    nodes.forEach(function (n) {
+      var c = String(n.cluster == null ? 0 : n.cluster);
+      if (n.community && !(c in nameByCluster)) nameByCluster[c] = n.community;
+    });
     clusterLabel = {};
     order.forEach(function (c, i) {
-      clusterLabel[c] = i < CATEGORICAL.length ? 'community ' + (+c + 1) : 'other';
+      clusterLabel[c] = i < CATEGORICAL.length ? (nameByCluster[c] || 'community ' + (+c + 1)) : 'other';
     });
     return sizes;
   }
@@ -582,6 +591,19 @@ _JS = """
     });
     sel.value = (prevTopic === '' || topics[prevTopic]) ? prevTopic : '';
     state.topic = sel.value;
+    // Community filter options rebuilt the same way; a selection survives
+    // only if the community still exists.
+    var csel = document.getElementById('hm-community');
+    var prevCommunity = csel.value;
+    var communities = {};
+    nodes.forEach(function (n) { if (n.community) communities[n.community] = 1; });
+    csel.textContent = '';
+    var call = el('option'); call.value = ''; call.textContent = 'all communities'; csel.appendChild(call);
+    Object.keys(communities).sort().forEach(function (c) {
+      var o = el('option'); o.value = c; o.textContent = c; csel.appendChild(o);
+    });
+    csel.value = (prevCommunity === '' || communities[prevCommunity]) ? prevCommunity : '';
+    state.community = csel.value;
     // Tab badges + header stat tiles follow the new data.
     var counts = { agents: nodes.length, conversation: events.length, claims: claims.length, disputes: disputes.length, research: hypotheses.length + evidence.length };
     document.querySelectorAll('#hm-tabs .tab').forEach(function (b) {
@@ -610,6 +632,12 @@ _JS = """
   document.getElementById('hm-topic').addEventListener('change', function () {
     var sel = document.getElementById('hm-topic'); state.topic = sel.value; renderAll();
   });
+  document.getElementById('hm-community').addEventListener('change', function () {
+    var csel = document.getElementById('hm-community'); state.community = csel.value; renderAll();
+  });
+  // Community of an event/claim/dispute actor: falls back to '' (matches
+  // no community filter) when the actor isn't a known node.
+  function communityOf(id) { var n = nodeById[id]; return n ? (n.community || '') : ''; }
   function n_topic_scan() {
     var ts = [];
     claims.forEach(function (c) { if (c.topic) ts.push(c.topic); });
@@ -937,6 +965,7 @@ _JS = """
     var rows = nodes.filter(function (n) {
       if (visible && !visible[n.id]) return false;
       if (state.topic && !(n.reputation || {})[state.topic]) return false;
+      if (state.community && (n.community || '') !== state.community) return false;
       return true;
     });
     if (!rows.length) { host.appendChild(el('div', 'empty', 'no agents match the current filters')); return; }
@@ -1014,6 +1043,7 @@ _JS = """
     var visible = matchesSearch();
     var rows = events.filter(function (ev) {
       if (state.topic && ev.topic !== state.topic) return false;
+      if (state.community && communityOf(ev.actor) !== state.community) return false;
       if (visible && !(ev.actor && visible[ev.actor]) && !(ev.target && visible[ev.target])) return false;
       if (state.search) {
         var hay = ((ev.text || '') + ' ' + (ev.detail || '') + ' ' + (ev.topic || '')).toLowerCase();
@@ -1064,6 +1094,7 @@ _JS = """
     host.textContent = '';
     var rows = claims.filter(function (c) {
       if (state.topic && c.topic !== state.topic) return false;
+      if (state.community && communityOf(c.author) !== state.community) return false;
       if (state.search) {
         var hay = ((c.finding || '') + ' ' + (c.claim_type || '') + ' ' + (c.author || '') + ' ' + labelOf(c.author)).toLowerCase();
         if (hay.indexOf(state.search) === -1) return false;

{hypermind-2.4.0 → hypermind-2.4.2}/src/hypermind/viz/snapshot.py

@@ -26,6 +26,7 @@ from __future__ import annotations
 
 import base64
 import json
+from collections import Counter
 from dataclasses import dataclass, field
 from typing import Any
 
@@ -116,6 +117,23 @@ def _finish(
     clusters = _detect_communities(nodes, edges)
     for node_id, cluster_id in clusters.items():
         nodes[node_id]["cluster"] = cluster_id
+    # Name each community by the dominant `unit` of its members so org
+    # structure (e.g. a university template's departments) is legible
+    # instead of an anonymous "community N". Interaction-derived clusters
+    # with no unit info keep the generic label.
+    unit_tally: dict[int, Counter[str]] = {}
+    for node in nodes.values():
+        unit = node.get("unit")
+        if unit:
+            unit_tally.setdefault(node["cluster"], Counter())[unit] += 1
+    community_names: dict[int, str] = {}
+    for cluster_id in set(clusters.values()):
+        tally = unit_tally.get(cluster_id)
+        community_names[cluster_id] = (
+            tally.most_common(1)[0][0] if tally else f"community {cluster_id + 1}"
+        )
+    for node in nodes.values():
+        node["community"] = community_names[node["cluster"]]
     node_list = sorted(nodes.values(), key=lambda n: n["id"])
     return NetworkSnapshot(
         nodes=node_list,
@@ -131,6 +149,7 @@ def _finish(
             "n_edges": len(edges),
             "n_events": len(events),
             "n_clusters": len(set(clusters.values())),
+            "communities": sorted(set(community_names.values())),
             "source": source,
         },
     )
@@ -438,11 +457,40 @@ def from_relata(url: str, *, namespace: str, token: str | None = None) -> Networ
             {"kid": kid.hex(), "topic": topic, "alpha": alpha, "beta": beta}
             for kid, topic, alpha, beta, _last_update_ms in backend.load_reputation()
         ]
+        stubs = backend.load_claim_stubs()
     finally:
         backend.close()
 
+    # Per-author attribution from the GAP-R10 claim columns: the majority
+    # unit/role/label across each author's claims. from_live_world gets this
+    # from the live agent objects; a Relata deployment only has what was
+    # persisted on claims — without this, DB-sourced canvases have no unit
+    # info (communities fall back to anonymous labels) and every node shows
+    # a bare hex id instead of a human label.
+    unit_tally: dict[str, Counter[str]] = {}
+    role_tally: dict[str, Counter[str]] = {}
+    label_tally: dict[str, Counter[str]] = {}
+    for s in stubs:
+        author = s.get("author_hex") or ""
+        if s.get("unit"):
+            unit_tally.setdefault(author, Counter())[s["unit"]] += 1
+        if s.get("role"):
+            role_tally.setdefault(author, Counter())[s["role"]] += 1
+        if s.get("label"):
+            label_tally.setdefault(author, Counter())[s["label"]] += 1
+    agents_meta = {
+        author: {
+            "role": role_tally[author].most_common(1)[0][0] if author in role_tally else None,
+            "unit": unit_tally[author].most_common(1)[0][0] if author in unit_tally else None,
+            "label": label_tally[author].most_common(1)[0][0] if author in label_tally else None,
+            "namespace": namespace,
+            "rooms": [],
+        }
+        for author in set(role_tally) | set(unit_tally) | set(label_tally)
+    }
+
     return _build_from_native(
-        agents_meta={},
+        agents_meta=agents_meta,
         sealed=sealed,
         disputes=disputes,
         rep_rows=rep_rows,

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

@@ -124,7 +124,9 @@ class _FakeClient:
             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])
+            return _FakeResult(
+                [{"id": f["id"], "wire_b64": f["wire_b64"], "seq": f["seq"]} for f in rows]
+            )
         if "FROM HmDispute" in sql:
             return _FakeResult(
                 [
@@ -246,6 +248,73 @@ def test_dispute_round_trip():
     b.close()
 
 
+def test_reads_collapse_bi_temporal_version_duplicates(monkeypatch):
+    """A plain relata SELECT returns every bi-temporal version, not just
+    current state (live-observed 2026-08-24 on relata-db 2026-08-10:
+    re-appending the same kid under on_conflict=skip left seq-1 and seq-2
+    rows; both came back). The read paths must collapse duplicates so
+    restore/replay never double-counts a claim."""
+    from hypermind.crypto.hlc import HLC
+    from hypermind.crypto.signing import Keypair
+    from hypermind.wire import SignedStatement
+
+    b = _backend()
+    b.open()
+    kp = Keypair.generate()
+    stmt = SignedStatement.sign(
+        keypair=kp,
+        record_type="SEAL",
+        namespace_id=b"\x00" * 16,
+        hlc=HLC(logical_ms=1, counter=0, node_id=b"\x00" * 8),
+        payload=b"versioned",
+    )
+    wire = stmt.to_bytes()
+    import base64 as _b64
+
+    wire_b64 = _b64.b64encode(wire).decode("ascii")
+    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
+            return [
+                {
+                    "id": kid_hex,
+                    "author_hex": kp.kid.hex(),
+                    "label": "",
+                    "unit": "u",
+                    "role": "",
+                    "confidence": 0.9,
+                    "text": "v2",
+                    "evidenced": 0,
+                    "topic": "t",
+                },
+                {
+                    "id": kid_hex,
+                    "author_hex": kp.kid.hex(),
+                    "label": "",
+                    "unit": "u",
+                    "role": "",
+                    "confidence": 0.5,
+                    "text": "v1",
+                    "evidenced": 0,
+                    "topic": "t",
+                },
+            ]
+        return []
+
+    monkeypatch.setattr(b, "_rows", fake_rows)
+    assert len(b.load_claims()) == 1
+    stubs = b.load_claim_stubs()
+    assert len(stubs) == 1
+    assert stubs[0]["finding"] == "v2"  # newest version wins
+    b.close()
+
+
 # --------------------------------------------------------------------------
 # Agent integration — publish persists, and a fresh backend restores
 # --------------------------------------------------------------------------

hypermind-2.4.2/tests/test_agent_cite_default.py

@@ -0,0 +1,24 @@
+"""Regression: `cite()` with no explicit uncertainty must not crash.
+
+The default branch once built `Uncertainty(alpha=9.0, beta=1.0)` against a
+constructor that takes `(kind, params)` — found live while onboarding a tenant
+(2026-08-24). Every other path passed an explicit Uncertainty, so only the
+default was broken.
+"""
+
+from hypermind import HyperMindAgent, Uncertainty
+
+
+async def test_cite_without_explicit_uncertainty_uses_beta_default() -> None:
+    async with HyperMindAgent.sandbox(room="cite-default") as alice:
+        first = await alice.publish_claim(
+            {"finding": "ground truth for the citation"},
+            uncertainty=Uncertainty.beta(7, 3),
+        )
+        second = await alice.publish_claim(
+            {"finding": "the citing claim"},
+            uncertainty=Uncertainty.beta(5, 5),
+        )
+        # No `uncertainty=` — exercises the default-branch constructor.
+        cite_kid = await alice.cite(second, first)
+        assert cite_kid.hex() != first.hex()