hypermind 0.23.0__tar.gz → 0.30.0__tar.gz

{hypermind-0.23.0 → hypermind-0.30.0}/CHANGELOG.md

@@ -14,7 +14,56 @@ changes only on major-version bumps.
 
 ## [Unreleased]
 
-_Current trunk; new work after v0.11.0._
+_Current trunk._
+
+## [0.30.0] — 2026-07-08
+
+### Added
+- **Live simulation dashboard** (#196) — a colourful, animated Rich view of a running sim: round progress bar, glowing stat cards (claims/citations/disputes/resolves), a per-round claims sparkline, a per-unit tally, and a colour-coded live activity feed. Turn on with `hmctl orgs simulate --live` / `ask --live`.
+- **Cross-shard grounding** (#195) — in a distributed run, agents now ground on *other shards'* findings pulled from the shared Relata ledger (`RelataBackend.recent_findings`, `OrgSim(cross_shard=True)`, default-on in the distributed worker), so a sharded run reasons like one swarm instead of N isolated ones. (Cross-shard citation/dispute graph + reputation unification is tracked as a follow-up.)
+- **`hmctl orgs` — no-code CLI for the living-simulation engine.** Run the whole engine from the shell:
+  - `hmctl orgs templates` — list presets.
+  - `hmctl orgs simulate --template university --members 24 --rounds 6 --topic "…" [--html report.html]`.
+  - `hmctl orgs ask "question" --template … [--samples N] [--no-quality]` — study→ask with the quality rubrics **on by default** (grounding, hallucination, calibration, native ledger rubrics).
+  - `hmctl orgs distributed --template … --members 10000 --workers 8 --topic "…"` — sharded run; the master provisions Relata + reassigns failures.
+  - LLM + Relata configured via flags/env (`--llm`, `--llm-model`, `--base-url`, `--api-key-env`, `--relata-url`); Hm* types auto-provisioned.
+
+## [0.23.0] — 2026-07-08
+
+### Added
+- **Distributed, Locust-style execution** — `hypermind.orgs.distributed`. A master coordinator shards a swarm across workers (other machines or local processes) over a TCP control plane (length-prefixed CBOR frames); each worker runs its shard as `OrgSim(lightweight=True)` against the **shared Relata namespace** and returns bounded aggregates, merged into one `OrgReport` (#177).
+  - `Coordinator` / `Worker`, `run_distributed(...)` (single-host convenience), and a `master` / `worker` CLI (`python -m hypermind.orgs.distributed`).
+  - Capacity-weighted shard planning; a worker that drops before returning is recorded as a failed shard — the run completes and notes it, never hangs.
+  - `OrgSim.export_aggregates()` for the merge; `OrgModel` wire (de)serialisation.
+
+## [0.22.0] — 2026-07-08
+
+### Added
+- **Batched Relata writes** — `RelataBackend(write_batch_size=N)` buffers claim rows and flushes via one bulk `batch_upsert` instead of a per-claim round-trip; `OrgSim` defaults to 64. ~batch× fewer round-trips at scale (#175).
+- **Bounded / streaming report** — `OrgSim(lightweight=True)` caps memory to O(members + windows), not O(records): per-member streaming aggregates + a rolling claim window, exact scorecard totals. `metrics.scorecard_from_aggregates(...)` (#176).
+- Parallel keypair generation at `testbed()` spin-up (thread pool; the crypto releases the GIL) — part of #177.
+
+## [0.21.0] — 2026-07-08
+
+### Added
+- **Native response-quality rubrics** — `hypermind.orgs.quality`: `sim.assess(question)` → `QualityReport`. Four rubric groups, all on by default, switchable via `disable`: native/deterministic (provenance coverage, dispute exposure, reputation support, consensus, abstention — verifiable from the signed ledger), judge-based faithfulness (grounding, hallucination rate, answer relevance, context precision), calibration (Brier, self-consistency), and context recall. Missing deps degrade to informational notes. `llm_judge(...)` factory.
+
+## [0.20.0] — 2026-07-08
+
+### Added
+- **Hybrid retrieval** — `reciprocal_rank_fusion(...)` and `hybrid_retriever(*retrievers, reranker=None)` fuse dense + entity-graph + lexical signals (RRF) with an optional cross-encoder rerank, over our own Relata data. Plugs into the existing `OrgSim(retriever=...)` seam.
+
+## [0.12.0] – [0.19.0] — 2026-06 … 2026-07
+
+### Added
+- **`hypermind.orgs` — the living-simulation engine.** Turn a declarative `OrgModel` / `Unit` / `Seat` into a running multi-agent simulation (research → publish → cite → dispute → resolve → learn → evolve) persisted to Relata, driven by pluggable `Interaction` strategies (`cooperative` / `adversarial` / `crowd`).
+  - **Template library**: `university`, `hospital`, `city_at_war`, `foreign_policy_cabinet`, `un_security_council`, `internet_crowd`, `research_lab`, … via `list_templates()` / `get_template()` — the core never imports them.
+  - **Per-agent models** (per-seat provider/model or a router) and **group-scoped native tools** (declarative or random grants; ungranted tools are absent, not refused).
+  - **Study → ask**: `sim.study(topic)` then `sim.ask(question)` — a transparent, queryable swarm that answers from what it learned, weighted by earned standing.
+  - **Proper RAG** for `ask`: lexical → semantic embeddings (`embedder=`, `openai_embedder`) → claim↔entity graph (`use_graph_retrieval`, `MentionGraph`) → real NER hooks (`llm_ner_extractor`, `chat_ner_extractor`, `pioneer_ner_extractor`) → Relata-backed retrieval (`relata_retriever`).
+  - **Scorecard & analysis**: reputation ranking, citation DAG, dispute ledger, Brier calibration (#151), convergence metrics (#152), memory-RAG (#153), deliberator mode (#154), tool-trace capture (#155), adversarial dynamics (#156), pluggable ground truth (#157), experiment/variant harness (#158), interventions (#159), visualization snapshots (#160), verifiable receipts (#161).
+- **Scalability hardening** across the engine: bounded peer window, O(1) member indices, top-k cross-pollination, concurrent think phase (`asyncio.gather` + semaphore) and concurrent blocking I/O (`asyncio.to_thread`).
+- `examples/org_university.py` and an expanded examples index.
 
 ## [0.11.0] — 2026-05-10
 

{hypermind-0.23.0 → hypermind-0.30.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypermind
-Version: 0.23.0
+Version: 0.30.0
 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
@@ -102,7 +102,7 @@ Agents share what they learn. Dispute what they doubt. Build trust over time.
 [![PyPI](https://img.shields.io/pypi/v/hypermind?color=4c8cff&label=pip%20install%20hypermind)](https://pypi.org/project/hypermind/)
 [![Python](https://img.shields.io/pypi/pyversions/hypermind?color=4c8cff)](https://pypi.org/project/hypermind/)
 [![License](https://img.shields.io/badge/license-Apache--2.0-green.svg)](LICENSE)
-[![Tests](https://img.shields.io/badge/tests-1753%20passing-brightgreen)](#testing--quality)
+[![Tests](https://img.shields.io/badge/tests-2133%20passing-brightgreen)](#testing--quality)
 [![Coverage](https://img.shields.io/badge/coverage-95%25-brightgreen)](#testing--quality)
 [![Status](https://img.shields.io/badge/status-v0.10-blue)](#project-status)
 
@@ -147,7 +147,7 @@ Open **http://127.0.0.1:8765** and you'll see:
 ```bash
 make run-fast      # skip the webui rebuild (when JS hasn't changed)
 make webui-dev     # Vite dev server with hot-reload on :5173
-make test          # 1753 tests pass, ~80s
+make test          # 2133 tests pass, ~80s
 make demo          # examples/01_hello_world from the CLI
 make demos         # all numbered tutorials + scenarios sequentially
 make help          # show all targets
@@ -232,6 +232,12 @@ report.print()        # reputation ranking · citation graph · dispute ledger
 - **Per-agent models.** Any seat can pin its own provider/model (`Seat("Professor", llm="anthropic", model="claude-opus-4-8")`), or hand `OrgSim` a router for random / cost-aware assignment.
 - **Native tools, group-scoped.** Tools (web search, retrieval, KB query, Relata research) are granted per unit/seat and enforced — an ungranted tool is *absent* from that agent's toolset. Grants can be declarative or randomised; register your own with `hypermind.orgs.register_tool(...)`.
 - **Relata end-to-end.** Organisation → tenant; member → private memory session (agent kid); claims / disputes / reputation → tenant-scoped ledger rows; chain of custody → the Merkle log. Restart replays the whole org.
+- **Study → ask (a queryable swarm).** Let the swarm learn a topic, then question it: `await sim.study(topic)` then `await sim.ask("...")` — every member recalls what it learned, reasons, and the answers are aggregated weighted by earned standing. `sim.ask` studies first automatically if you skip the explicit step.
+- **Proper RAG.** Retrieval for `ask` is pluggable: lexical (default), semantic embeddings (`embedder=`), the claim↔entity graph (`use_graph_retrieval=True`), or `hybrid_retriever(...)` which fuses dense + graph + lexical via Reciprocal Rank Fusion with an optional cross-encoder rerank. Relata *is* the vector store + graph (`relata_retriever(..., "search_knowledge" / "find_connections")`).
+- **Answer quality, natively.** `await sim.assess(question)` returns a `QualityReport` scoring grounding, hallucination rate, calibration (Brier), self-consistency, and hm-native rubrics that are *verifiable from the signed ledger* — provenance coverage, dispute exposure, reputation-weighted support. All rubrics on by default; missing deps (judge / ground-truth) degrade to informational notes.
+- **Scales like Locust.** `OrgSim(lightweight=True)` caps RAM to O(members), not O(records); Relata writes are batched. For horizontal scale, `hypermind.orgs.distributed` runs a **master/worker** control plane — shard a swarm across processes or machines against the shared Relata namespace, merged into one report (`python -m hypermind.orgs.distributed master/worker`, or `run_distributed(...)`).
+
+- **No-code CLI.** `hmctl orgs` runs the whole engine from the shell: `hmctl orgs templates`, `hmctl orgs simulate --template university --members 24 --topic "…"`, `hmctl orgs ask "…" --template university` (study→ask + quality rubrics on by default), and `hmctl orgs distributed --members 10000 --workers 8 --topic "…"`.
 
 Worked example: [`examples/org_university.py`](examples/org_university.py). Discover all presets via `hypermind.orgs.templates.list_templates()`.
 

{hypermind-0.23.0 → hypermind-0.30.0}/README.md

@@ -14,7 +14,7 @@ Agents share what they learn. Dispute what they doubt. Build trust over time.
 [![PyPI](https://img.shields.io/pypi/v/hypermind?color=4c8cff&label=pip%20install%20hypermind)](https://pypi.org/project/hypermind/)
 [![Python](https://img.shields.io/pypi/pyversions/hypermind?color=4c8cff)](https://pypi.org/project/hypermind/)
 [![License](https://img.shields.io/badge/license-Apache--2.0-green.svg)](LICENSE)
-[![Tests](https://img.shields.io/badge/tests-1753%20passing-brightgreen)](#testing--quality)
+[![Tests](https://img.shields.io/badge/tests-2133%20passing-brightgreen)](#testing--quality)
 [![Coverage](https://img.shields.io/badge/coverage-95%25-brightgreen)](#testing--quality)
 [![Status](https://img.shields.io/badge/status-v0.10-blue)](#project-status)
 
@@ -59,7 +59,7 @@ Open **http://127.0.0.1:8765** and you'll see:
 ```bash
 make run-fast      # skip the webui rebuild (when JS hasn't changed)
 make webui-dev     # Vite dev server with hot-reload on :5173
-make test          # 1753 tests pass, ~80s
+make test          # 2133 tests pass, ~80s
 make demo          # examples/01_hello_world from the CLI
 make demos         # all numbered tutorials + scenarios sequentially
 make help          # show all targets
@@ -144,6 +144,12 @@ report.print()        # reputation ranking · citation graph · dispute ledger
 - **Per-agent models.** Any seat can pin its own provider/model (`Seat("Professor", llm="anthropic", model="claude-opus-4-8")`), or hand `OrgSim` a router for random / cost-aware assignment.
 - **Native tools, group-scoped.** Tools (web search, retrieval, KB query, Relata research) are granted per unit/seat and enforced — an ungranted tool is *absent* from that agent's toolset. Grants can be declarative or randomised; register your own with `hypermind.orgs.register_tool(...)`.
 - **Relata end-to-end.** Organisation → tenant; member → private memory session (agent kid); claims / disputes / reputation → tenant-scoped ledger rows; chain of custody → the Merkle log. Restart replays the whole org.
+- **Study → ask (a queryable swarm).** Let the swarm learn a topic, then question it: `await sim.study(topic)` then `await sim.ask("...")` — every member recalls what it learned, reasons, and the answers are aggregated weighted by earned standing. `sim.ask` studies first automatically if you skip the explicit step.
+- **Proper RAG.** Retrieval for `ask` is pluggable: lexical (default), semantic embeddings (`embedder=`), the claim↔entity graph (`use_graph_retrieval=True`), or `hybrid_retriever(...)` which fuses dense + graph + lexical via Reciprocal Rank Fusion with an optional cross-encoder rerank. Relata *is* the vector store + graph (`relata_retriever(..., "search_knowledge" / "find_connections")`).
+- **Answer quality, natively.** `await sim.assess(question)` returns a `QualityReport` scoring grounding, hallucination rate, calibration (Brier), self-consistency, and hm-native rubrics that are *verifiable from the signed ledger* — provenance coverage, dispute exposure, reputation-weighted support. All rubrics on by default; missing deps (judge / ground-truth) degrade to informational notes.
+- **Scales like Locust.** `OrgSim(lightweight=True)` caps RAM to O(members), not O(records); Relata writes are batched. For horizontal scale, `hypermind.orgs.distributed` runs a **master/worker** control plane — shard a swarm across processes or machines against the shared Relata namespace, merged into one report (`python -m hypermind.orgs.distributed master/worker`, or `run_distributed(...)`).
+
+- **No-code CLI.** `hmctl orgs` runs the whole engine from the shell: `hmctl orgs templates`, `hmctl orgs simulate --template university --members 24 --topic "…"`, `hmctl orgs ask "…" --template university` (study→ask + quality rubrics on by default), and `hmctl orgs distributed --members 10000 --workers 8 --topic "…"`.
 
 Worked example: [`examples/org_university.py`](examples/org_university.py). Discover all presets via `hypermind.orgs.templates.list_templates()`.
 

{hypermind-0.23.0 → hypermind-0.30.0}/examples/README.md

@@ -87,6 +87,7 @@ Pick one that matches your domain.
 | File | Domain | What it shows |
 |---|---|---|
 | [`org_university.py`](org_university.py) | Any network | Spin up a templated org (university / city / UNO / crowd), run research → cite → dispute → resolve → evolve, print a reputation + citation report. Per-agent models + group-scoped tools, persisted to Relata. |
+| [`org_distributed.py`](org_distributed.py) | Scale-out | Locust-style distributed run: a master coordinator shards the swarm across workers (processes or machines) against the shared Relata namespace, merged into one report (`hypermind.orgs.distributed`). Single-host convenience + multi-machine CLI. |
 
 ### Pilot-shaped demonstrations
 

hypermind-0.30.0/examples/org_distributed.py

@@ -0,0 +1,74 @@
+"""THE STORY — one swarm, many workers: scale a simulation like Locust.
+
+The single-process engine (``examples/org_university.py``) is great to ~1000s of
+agents. Beyond that you scale *out*: ``hypermind.orgs.distributed`` runs a
+**master coordinator** that shards the swarm across **workers** — processes on
+this box or on other machines — each running its slice as
+``OrgSim(lightweight=True)`` against the **shared Relata namespace** (the source
+of truth). The coordinator merges every worker's bounded aggregates into one
+``OrgReport``.
+
+This script shows the single-host convenience path (``run_distributed`` starts a
+coordinator plus in-process workers over loopback) — the *same* code path as
+multi-machine. For true multi-machine, use the CLI instead::
+
+    # on the master host
+    python -m hypermind.orgs.distributed master --template university \
+        --topic "..." --members 10000 --rounds 8 --expected-workers 4 \
+        --host 0.0.0.0 --port 8765 --llm openai --llm-model openai/gpt-4o-mini
+
+    # on each worker host
+    python -m hypermind.orgs.distributed worker \
+        --master-host <master-ip> --port 8765 --capacity 2500
+
+PREREQUISITES
+  * A running Relata instance:   docker compose -f deploy/docker-compose.yml up -d relata
+  * export RELATA_URL=http://localhost:9090   RELATA_TOKEN=...
+  * export OPENAI_API_KEY=...   (workers build their own client from env)
+
+Run with:   python -m examples.org_distributed
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+
+
+async def main() -> None:
+    from hypermind.orgs.distributed import run_distributed
+    from hypermind.orgs.templates import university
+
+    relata_url = os.environ.get("RELATA_URL")
+    if not relata_url:
+        raise SystemExit(
+            "Set RELATA_URL (and RELATA_TOKEN) to a running Relata instance. "
+            "See deploy/docker-compose.yml."
+        )
+
+    model = university()  # the shape; run_distributed scales it across workers
+    report = await run_distributed(
+        model,
+        topic="What limits the accuracy of ab-initio protein folding?",
+        members=48,  # sharded across the workers below
+        rounds=4,
+        workers=4,  # 4 in-process workers over loopback (each ~12 members)
+        config={
+            "llm": "openai",
+            "llm_model": "openai/gpt-4o-mini",
+            "base_url": os.environ.get("OPENAI_BASE_URL"),  # e.g. OpenRouter
+            "relata_url": relata_url,
+            "relata_token": os.environ.get("RELATA_TOKEN"),
+        },
+    )
+
+    report.print()
+    sc = report.scorecard
+    print(
+        f"\nmerged across workers → {sc['claims']} claims · {sc['citations']} citations · "
+        f"{len(report.standings)} members"
+    )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{hypermind-0.23.0 → hypermind-0.30.0}/pyproject.toml

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

{hypermind-0.23.0 → hypermind-0.30.0}/src/hmctl/cli.py

@@ -39,6 +39,12 @@ def main() -> None:
     """HyperMind conformance CLI."""
 
 
+# `hmctl orgs …` — run the living-simulation engine with no code.
+from hmctl.orgs_cmd import orgs as _orgs_group  # noqa: E402
+
+main.add_command(_orgs_group, name="orgs")
+
+
 @main.command()
 @click.option(
     "--check",

hypermind-0.30.0/src/hmctl/dashboard.py

@@ -0,0 +1,178 @@
+"""Live, colourful terminal dashboard for a running OrgSim (#196).
+
+Drives off OrgSim's ``on_event`` stream (round_start / publish / cite / dispute /
+resolve / round_end) and paints a Rich live view: a round progress bar, glowing
+stat cards, a per-round claims sparkline/bar-chart, a per-unit tally, and a
+colour-coded activity feed. Pass ``dashboard.handle`` as ``on_event=`` and run
+the sim inside ``with dashboard:``.
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict, deque
+from typing import Any
+
+from rich.align import Align
+from rich.console import Console, Group
+from rich.live import Live
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+_BLOCKS = " ▁▂▃▄▅▆▇█"
+_PALETTE = ["#00e5ff", "#00ff9c", "#ffd166", "#ff5d8f", "#a78bfa", "#7dd3fc"]
+_EVENT_STYLE = {
+    "publish": ("📄", "bold #00ff9c"),
+    "cite": ("🔗", "bold #00e5ff"),
+    "dispute": ("⚖️", "bold #ffd166"),
+    "resolve": ("✓", "bold #a78bfa"),
+    "tool_call": ("🛠", "bold #7dd3fc"),
+}
+
+
+def _spark(vals: list[int], width: int = 32) -> Text:
+    if not vals:
+        return Text("—", style="grey37")
+    tail = vals[-width:]
+    mx = max(tail) or 1
+    t = Text()
+    for i, v in enumerate(tail):
+        ch = _BLOCKS[min(8, int(v / mx * 8))]
+        t.append(ch, style=_PALETTE[i % len(_PALETTE)])
+    return t
+
+
+class SimDashboard:
+    """A Rich live dashboard fed by OrgSim events."""
+
+    def __init__(
+        self,
+        *,
+        total_rounds: int,
+        org: str = "org",
+        topic: str = "",
+        console: Console | None = None,
+    ) -> None:
+        self.console = console or Console()
+        self.total = max(1, total_rounds)
+        self.org = org
+        self.topic = topic
+        self.round = 0
+        self.counts: dict[str, int] = defaultdict(int)
+        self.per_round: dict[int, int] = defaultdict(int)
+        self.per_unit: dict[str, int] = defaultdict(int)
+        self.feed: deque[Text] = deque(maxlen=9)
+        self._live: Live | None = None
+
+    def __enter__(self) -> SimDashboard:
+        self._live = Live(self._render(), console=self.console, refresh_per_second=12, screen=False)
+        self._live.__enter__()
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        if self._live is not None:
+            self._live.update(self._render())
+            self._live.__exit__(*exc)
+
+    # OrgSim on_event sink (sync — fast, no awaiting).
+    def handle(self, ev: dict[str, Any]) -> None:
+        e = ev.get("event", "")
+        if e == "round_start":
+            self.round = int(ev.get("round", self.round)) + 1
+        elif e in _EVENT_STYLE:
+            self.counts[e] += 1
+            if e == "publish":
+                self.per_round[self.round] += 1
+                if ev.get("unit"):
+                    self.per_unit[ev["unit"]] += 1
+            self._push(ev, e)
+        self._refresh()
+
+    def _push(self, ev: dict[str, Any], e: str) -> None:
+        icon, style = _EVENT_STYLE[e]
+        who = str(ev.get("by", ev.get("unit", "")))
+        extra = ""
+        if e == "publish" and ev.get("confidence") is not None:
+            extra = f"  conf {ev['confidence']:.2f}"
+        elif e == "resolve":
+            extra = f"  → {'✓ correct' if ev.get('outcome') else '✗ wrong'}"
+        line = Text(f" r{self.round}  ", style="grey42")
+        line.append(f"{icon} {e:<8}", style=style)
+        line.append(f" {who}{extra}", style="grey70")
+        self.feed.append(line)
+
+    def _refresh(self) -> None:
+        if self._live is not None:
+            self._live.update(self._render())
+
+    # --- rendering --------------------------------------------------------
+    def _bar(self, frac: float, width: int = 44) -> Text:
+        filled = int(max(0.0, min(1.0, frac)) * width)
+        t = Text()
+        for i in range(width):
+            t.append(
+                "█" if i < filled else "─",
+                style=_PALETTE[i % len(_PALETTE)] if i < filled else "grey30",
+            )
+        return t
+
+    def _cards(self) -> Table:
+        cards = Table.grid(expand=True, padding=(0, 1))
+        cards.add_row(
+            self._card("📄 claims", self.counts["publish"], "#00ff9c"),
+            self._card("🔗 citations", self.counts["cite"], "#00e5ff"),
+            self._card("⚖️ disputes", self.counts["dispute"], "#ffd166"),
+            self._card("✓ resolves", self.counts["resolve"], "#a78bfa"),
+        )
+        return cards
+
+    def _card(self, label: str, value: int, colour: str) -> Panel:
+        body = Align.center(Text(str(value), style=f"bold {colour}"))
+        return Panel(body, title=label, border_style=colour, padding=(0, 1))
+
+    def _units(self) -> Text:
+        if not self.per_unit:
+            return Text("  (waiting for claims…)", style="grey37")
+        mx = max(self.per_unit.values()) or 1
+        t = Text()
+        for i, (unit, n) in enumerate(sorted(self.per_unit.items(), key=lambda kv: -kv[1])[:6]):
+            colour = _PALETTE[i % len(_PALETTE)]
+            bar = "█" * int(n / mx * 24) or "▏"
+            t.append(f"  {unit[:16]:<16} ", style="grey70")
+            t.append(bar, style=colour)
+            t.append(f" {n}\n", style=colour)
+        return t
+
+    def _render(self) -> Panel:
+        frac = self.round / self.total if self.total else 0.0
+        header = Text()
+        header.append("⬡ HyperMind  ", style="bold #00e5ff")
+        header.append(self.org, style="bold white")
+        if self.topic:
+            header.append(f"  ·  {self.topic[:60]}", style="grey62")
+
+        prog = Text()
+        prog.append(f"round {min(self.round, self.total)}/{self.total}  ", style="bold white")
+        prog.append_text(self._bar(frac))
+        prog.append(f"  {int(frac * 100):>3}%", style="bold #00ff9c")
+
+        spark = Text("claims/round  ", style="grey62")
+        spark.append_text(_spark([self.per_round[i] for i in range(1, self.round + 1)]))
+
+        feed = Group(*self.feed) if self.feed else Text("  (no activity yet)", style="grey37")
+
+        body = Group(
+            header,
+            Text(""),
+            prog,
+            Text(""),
+            self._cards(),
+            Text(""),
+            Panel(self._units(), title="per-unit claims", border_style="grey35", padding=(0, 0)),
+            spark,
+            Text(""),
+            Panel(feed, title="live activity", border_style="grey35", padding=(0, 1)),
+        )
+        return Panel(
+            body, border_style="#00e5ff", title="live simulation", subtitle="hypermind.orgs"
+        )