hypermind 0.21.0__tar.gz → 0.22.0__tar.gz

{hypermind-0.21.0 → hypermind-0.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypermind
-Version: 0.21.0
+Version: 0.22.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

{hypermind-0.21.0 → hypermind-0.22.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hypermind"
-version = "0.21.0"
+version = "0.22.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.21.0 → hypermind-0.22.0}/src/hypermind/__init__.py

@@ -73,7 +73,7 @@ open = HyperMindAgent.open
 #: is held until the §External & human gates clear (IETF I-D, IANA,
 #: third-party audit, OpenSSF acceptance, ≥3 pilots) — at that point we
 #: cut ``1.0.0`` GA. See ROADMAP.md §Status snapshot.
-__version__ = "0.21.0"
+__version__ = "0.22.0"
 
 #: SLSA build-provenance level committed for every release artefact.
 #: Cosign keyless signing + slsa-github-generator + PEP 740 attestations

{hypermind-0.21.0 → hypermind-0.22.0}/src/hypermind/agent.py

@@ -18,9 +18,11 @@ from __future__ import annotations
 import asyncio
 import hashlib
 import json
+import os
 import secrets
 import time
 from collections.abc import AsyncIterator, Awaitable, Callable, Sequence
+from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass, field
 from datetime import timedelta
 from typing import Any, Literal
@@ -853,9 +855,19 @@ class HyperMindAgent:
         world.ts.witness_keypairs = [Keypair.generate(alg=kp_alg) for _ in range(3)]
         world.ts.min_witness_quorum = 1  # sandbox quorum
 
+        # #177 (spin-up ceiling): keygen is CPU-bound but the crypto releases
+        # the GIL, so generating N keypairs in a thread pool cuts spin-up of
+        # large swarms (measured ~3× Ed25519, ~1.5× ML-DSA). World mutations
+        # below stay single-threaded; ex.map preserves order so the roster is
+        # unchanged. Small swarms skip the pool (thread setup isn't worth it).
+        if agents >= 8:
+            with ThreadPoolExecutor(max_workers=min(32, (os.cpu_count() or 4))) as ex:
+                keypairs = list(ex.map(lambda _: Keypair.generate(alg=kp_alg), range(agents)))
+        else:
+            keypairs = [Keypair.generate(alg=kp_alg) for _ in range(agents)]
+
         agents_list: list[HyperMindAgent] = []
-        for _ in range(agents):
-            kp = Keypair.generate(alg=kp_alg)
+        for kp in keypairs:
             agent = HyperMindAgent(
                 keypair=kp,
                 namespace=namespace,

{hypermind-0.21.0 → hypermind-0.22.0}/src/hypermind/orgs/metrics.py

@@ -66,25 +66,27 @@ def _brier(confidence: float, outcome: bool) -> float:
     return (float(confidence) - (1.0 if outcome else 0.0)) ** 2
 
 
-def compute_scorecard(
+def scorecard_from_aggregates(
     *,
     per_round_posteriors: list[dict[str, float]],
     member_units: dict[str, str],
-    claims: list[dict[str, Any]],
-    citations: list[tuple[str, str]],
-    reputations: dict[str, float],
+    brier_sums: dict[str, tuple[float, int]],
+    influence: dict[str, float],
+    publishers: set[str],
+    claims_count: int,
+    citations_count: int,
     disputes_count: int,
     convergence_threshold: float = 0.02,
 ) -> ScoreCard:
-    """Compute the scorecard from a run's tracked data.
+    """Build a ScoreCard from **streaming aggregates** (bounded by member count,
+    not record count). Lets ``OrgSim(lightweight=True)`` produce the same
+    scorecard without holding every claim/citation in RAM (#176).
 
-    ``per_round_posteriors`` — one ``{member_label: posterior_mean}`` dict per round.
-    ``member_units`` — every member's unit (denominator for participation).
-    ``claims`` — dicts with keys ``kid_hex, label, unit, confidence, outcome``.
-    ``citations`` — ``(citer_label, target_kid_hex)`` pairs.
-    ``reputations`` — final ``{member_label: score}``.
+    ``brier_sums`` — per member ``{label: (sum_of_brier, n_resolved)}``.
+    ``influence`` — per member the reputation-weighted citation in-degree.
+    ``publishers`` — labels that published at least one claim.
     """
-    # --- consensus / convergence ---
+    # --- consensus / convergence (per-round, already bounded) ---
     var_by_round = [
         pvariance(list(p.values())) if len(p) > 1 else 0.0 for p in per_round_posteriors
     ]
@@ -102,31 +104,15 @@ def compute_scorecard(
     unit_means = [mean(v) for v in unit_vals.values()]
     unit_polarization = (max(unit_means) - min(unit_means)) if len(unit_means) > 1 else 0.0
 
-    # --- calibration (Brier) over resolved claims ---
-    resolved = [
-        (c["label"], float(c.get("confidence", 0.0)), c["outcome"])
-        for c in claims
-        if c.get("outcome") is not None
-    ]
-    brier_all = [_brier(conf, out) for _, conf, out in resolved]
-    brier_mean = mean(brier_all) if brier_all else None
-    by_member: dict[str, list[float]] = defaultdict(list)
-    for label, conf, out in resolved:
-        by_member[label].append(_brier(conf, out))
-    brier_by_member = {k: mean(v) for k, v in by_member.items()}
-
-    # --- influence: reputation-weighted citation in-degree ---
-    kid2label = {c["kid_hex"]: c["label"] for c in claims if "kid_hex" in c}
-    influence: dict[str, float] = defaultdict(float)
-    for citer, target_hex in citations:
-        tgt = kid2label.get(target_hex)
-        if tgt is not None:
-            influence[tgt] += reputations.get(citer, 0.5)
-    influence = dict(influence)
-    top_influencer = max(influence, key=lambda k: influence[k]) if influence else None
+    # --- calibration (Brier) from per-member sums ---
+    total_sum = sum(s for s, _n in brier_sums.values())
+    total_n = sum(n for _s, n in brier_sums.values())
+    brier_mean = (total_sum / total_n) if total_n else None
+    brier_by_member = {k: s / n for k, (s, n) in brier_sums.items() if n}
+
+    infl = dict(influence)
+    top_influencer = max(infl, key=lambda k: infl[k]) if infl else None
 
-    # --- activity ---
-    publishers = {c["label"] for c in claims}
     total_members = len(member_units)
     participation = len(publishers) / total_members if total_members else 0.0
 
@@ -139,10 +125,57 @@ def compute_scorecard(
         unit_polarization=unit_polarization,
         brier_mean=brier_mean,
         brier_by_member=brier_by_member,
-        influence=influence,
+        influence=infl,
         top_influencer=top_influencer,
-        claims=len(claims),
+        claims=claims_count,
         disputes=disputes_count,
-        citations=len(citations),
+        citations=citations_count,
         participation_rate=participation,
     )
+
+
+def compute_scorecard(
+    *,
+    per_round_posteriors: list[dict[str, float]],
+    member_units: dict[str, str],
+    claims: list[dict[str, Any]],
+    citations: list[tuple[str, str]],
+    reputations: dict[str, float],
+    disputes_count: int,
+    convergence_threshold: float = 0.02,
+) -> ScoreCard:
+    """Compute the scorecard from a run's fully-retained data (default mode).
+
+    ``per_round_posteriors`` — one ``{member_label: posterior_mean}`` dict per round.
+    ``member_units`` — every member's unit (denominator for participation).
+    ``claims`` — dicts with keys ``kid_hex, label, unit, confidence, outcome``.
+    ``citations`` — ``(citer_label, target_kid_hex)`` pairs.
+    ``reputations`` — final ``{member_label: score}``.
+    """
+    # Aggregate the full lists, then delegate to the streaming builder so both
+    # paths share one scorecard definition.
+    brier_sums: dict[str, tuple[float, int]] = {}
+    for c in claims:
+        if c.get("outcome") is None:
+            continue
+        s, n = brier_sums.get(c["label"], (0.0, 0))
+        brier_sums[c["label"]] = (s + _brier(float(c.get("confidence", 0.0)), c["outcome"]), n + 1)
+
+    kid2label = {c["kid_hex"]: c["label"] for c in claims if "kid_hex" in c}
+    influence: dict[str, float] = defaultdict(float)
+    for citer, target_hex in citations:
+        tgt = kid2label.get(target_hex)
+        if tgt is not None:
+            influence[tgt] += reputations.get(citer, 0.5)
+
+    return scorecard_from_aggregates(
+        per_round_posteriors=per_round_posteriors,
+        member_units=member_units,
+        brier_sums=brier_sums,
+        influence=dict(influence),
+        publishers={c["label"] for c in claims},
+        claims_count=len(claims),
+        citations_count=len(citations),
+        disputes_count=disputes_count,
+        convergence_threshold=convergence_threshold,
+    )

{hypermind-0.21.0 → hypermind-0.22.0}/src/hypermind/orgs/sim.py

@@ -36,7 +36,7 @@ from hypermind.mind.memory_store import RelataMemoryStore
 from hypermind.orgs.context import default_context_builder
 from hypermind.orgs.groundtruth import GroundTruth, as_ground_truth
 from hypermind.orgs.interaction import ClaimRec, Interaction, get_interaction
-from hypermind.orgs.metrics import compute_scorecard
+from hypermind.orgs.metrics import compute_scorecard, scorecard_from_aggregates
 from hypermind.orgs.model import OrgModel, Slot
 from hypermind.orgs.report import MemberStanding, OrgReport
 from hypermind.orgs.tools import (
@@ -118,6 +118,9 @@ class OrgSim:
         context_builder: Any = None,
         on_event: Callable[[dict[str, Any]], Any] | None = None,
         max_concurrency: int = 16,
+        write_batch_size: int = 64,
+        lightweight: bool = False,
+        claims_window: int = 4096,
         retrieval_k: int = 5,
         retriever: Callable[[str, int], list[tuple[str, str]]] | None = None,
         use_graph_retrieval: bool = False,
@@ -150,9 +153,24 @@ class OrgSim:
 
         self._members: list[Member] = []
         self._backend: RelataBackend | None = None
+        # #176: in lightweight mode, don't retain every record in RAM. Keep a
+        # rolling window of recent claims (bounded, covers the cite/dispute/
+        # resolve horizon + RAG) and per-member running aggregates (bounded by
+        # member count, not record count). The full mode keeps everything.
+        self._lightweight = bool(lightweight)
+        # Never evict below one round's worth of claims — cite/dispute/resolve
+        # target the current round, and eviction drops oldest-first, so a cap
+        # ≥ 2× the roster keeps the active horizon intact for any swarm size.
+        self._claims_cap = max(claims_window, 2 * len(self.model.roster()))
         self._claims: dict[str, _ClaimInfo] = {}
-        self._citations: list[tuple[str, str]] = []
-        self._disputes: list[dict[str, Any]] = []
+        _hist = 512 if self._lightweight else None
+        self._citations: deque[tuple[str, str]] = deque(maxlen=_hist)
+        self._disputes: deque[dict[str, Any]] = deque(maxlen=_hist)
+        # Streaming aggregates for the scorecard (only populated when lightweight).
+        self._agg: dict[str, dict[str, Any]] = {}
+        self._n_claims = 0
+        self._n_citations = 0
+        self._n_disputes = 0
         self._grants: dict[str, frozenset[str]] = {}
         self._round_posteriors: list[dict[str, float]] = []  # per-round {label: mean}
         self._stop_reason: str = "fixed"
@@ -164,6 +182,10 @@ class OrgSim:
         self._studied: bool = False
         self._study_topic: str | None = None
         self._max_concurrency = max(1, max_concurrency)
+        # #175: mirror claims to Relata in bulk (one /ingest per batch, not per
+        # claim). Safe because the sim keeps its working set in memory and only
+        # reads the ledger back on restart-replay, after teardown has flushed.
+        self._write_batch_size = max(1, write_batch_size)
         # Scale: a bounded window of recent findings (label, unit, conf, text)
         # so peer-grounding is O(window), never a full scan of all claims.
         self._recent_findings: deque[tuple[str, str, float, str]] = deque(maxlen=256)
@@ -358,6 +380,7 @@ class OrgSim:
             namespace_id=self.model.namespace,
             bearer_token=self.relata_token,
             client_factory=self._relata_client_factory,
+            write_batch_size=self._write_batch_size,
         )
         backend.open()
         agents[0].attach_storage(backend)
@@ -770,6 +793,14 @@ class OrgSim:
             finding=reasoning,
             tool_calls=tool_calls,
         )
+        self._n_claims += 1
+        if self._lightweight:
+            a = self._agg_for(m.label)
+            a["claims"] += 1
+            a["publisher"] = True
+            # Evict oldest claims beyond the window (dicts keep insertion order).
+            while len(self._claims) > self._claims_cap:
+                self._claims.pop(next(iter(self._claims)))
         if reasoning:
             self._recent_findings.append((m.label, m.unit, post.mean(), reasoning))
             self._mentions.add(kid.hex(), reasoning)  # grow the entity graph
@@ -790,9 +821,16 @@ class OrgSim:
         )
         for t in targets:
             self._citations.append((m.label, t.hex()))
+            self._n_citations += 1
             info = self._claims.get(t.hex())
             if info is not None:
                 info.citations_received += 1
+                if self._lightweight:
+                    a = self._agg_for(info.label)
+                    a["citations_received"] += 1
+                    # Streaming influence: weight by the citer's reputation now
+                    # (full mode uses final reputation; this is the bounded proxy).
+                    a["influence"] += self._member_reputation(m)
 
     async def _dispute(self, m: Member, rec: ClaimRec, r: int) -> None:
         await m.agent.dispute(
@@ -809,9 +847,12 @@ class OrgSim:
                 "round": r,
             }
         )
+        self._n_disputes += 1
         info = self._claims.get(rec.kid.hex())
         if info is not None:
             info.disputes_received += 1
+        if self._lightweight:
+            self._agg_for(rec.member_label)["disputes_received"] += 1
 
     async def _resolve(
         self,
@@ -852,6 +893,10 @@ class OrgSim:
                 info = self._claims.get(rec.kid.hex())
                 if info is not None:
                     info.outcome = outcome
+                if self._lightweight:
+                    a = self._agg_for(rec.member_label)
+                    a["brier_sum"] += (rec.confidence - (1.0 if outcome else 0.0)) ** 2
+                    a["brier_n"] += 1
                 await self._emit("resolve", by=rec.member_label, unit=unit, outcome=outcome)
                 # Evolve signal: publisher earns/loses floor headroom (O(1) lookup).
                 pub = self._member_by_kid.get(rec.member_kid)
@@ -882,7 +927,24 @@ class OrgSim:
 
     # ---- report --------------------------------------------------------
 
+    def _agg_for(self, label: str) -> dict[str, Any]:
+        a = self._agg.get(label)
+        if a is None:
+            a = {
+                "claims": 0,
+                "citations_received": 0,
+                "disputes_received": 0,
+                "influence": 0.0,
+                "brier_sum": 0.0,
+                "brier_n": 0,
+                "publisher": False,
+            }
+            self._agg[label] = a
+        return a
+
     def _build_report(self, topic: str, rounds: int) -> OrgReport:
+        if self._lightweight:
+            return self._build_report_light(topic, rounds)
         world = self._members[0].agent._world if self._members else None
         # Index claims by author once (O(claims)) instead of scanning per member.
         by_label: dict[str, list[_ClaimInfo]] = {}
@@ -929,3 +991,57 @@ class OrgSim:
             interaction_state=self.interaction.state(),
             decisions=list(self._decisions),
         )
+
+    def _build_report_light(self, topic: str, rounds: int) -> OrgReport:
+        """Assemble the report from streaming aggregates (#176).
+
+        Memory here is O(members + windows), not O(records): standings and the
+        scorecard come from ``self._agg`` + running counts; the claim/citation/
+        dispute payloads are the bounded recent windows (a sample, not the full
+        history — the accurate totals live in the scorecard)."""
+        world = self._members[0].agent._world if self._members else None
+        standings: list[MemberStanding] = []
+        for m in self._members:
+            a = self._agg.get(m.label, {})
+            score = world.reputation.snapshot(m.kid, m.unit).score if world else 0.0
+            standings.append(
+                MemberStanding(
+                    label=m.label,
+                    unit=m.unit,
+                    role=m.role,
+                    reputation=score,
+                    claims=a.get("claims", 0),
+                    citations_received=a.get("citations_received", 0),
+                    disputes_received=a.get("disputes_received", 0),
+                    tools=sorted(m.tools),
+                )
+            )
+        standings.sort(key=lambda s: s.reputation, reverse=True)
+        scorecard = scorecard_from_aggregates(
+            per_round_posteriors=self._round_posteriors,
+            member_units={m.label: m.unit for m in self._members},
+            brier_sums={
+                lbl: (a["brier_sum"], a["brier_n"]) for lbl, a in self._agg.items() if a["brier_n"]
+            },
+            influence={lbl: a["influence"] for lbl, a in self._agg.items() if a["influence"]},
+            publishers={lbl for lbl, a in self._agg.items() if a["publisher"]},
+            claims_count=self._n_claims,
+            citations_count=self._n_citations,
+            disputes_count=self._n_disputes,
+        )
+        return OrgReport(
+            org=self.model.name,
+            topic=topic,
+            rounds=rounds,
+            interaction=self.interaction.name,
+            standings=standings,
+            claims=[c.__dict__ for c in self._claims.values()],  # bounded window sample
+            citations=list(self._citations),
+            disputes=list(self._disputes),
+            tool_grants={label: sorted(t) for label, t in self._grants.items()},
+            scorecard=scorecard.to_dict(),
+            stop_reason=self._stop_reason,
+            events=list(self._events),
+            interaction_state=self.interaction.state(),
+            decisions=list(self._decisions),
+        )

{hypermind-0.21.0 → hypermind-0.22.0}/src/hypermind/storage/relata.py

@@ -59,6 +59,7 @@ class RelataBackend:
         bearer_token: str | None = None,
         purpose: str = _PURPOSE,
         client_factory: ClientFactory | None = None,
+        write_batch_size: int = 1,
     ) -> None:
         self._url = base_url
         self._ns = namespace_id
@@ -69,6 +70,12 @@ class RelataBackend:
         self._log: Any = None
         self._obj: Any = None
         self._seq = 1
+        # #175: buffer claim rows and flush via one bulk /ingest instead of a
+        # per-claim HTTP round-trip. Default 1 = unchanged (immediate durability);
+        # >1 trades a small durability lag for ~batch× fewer round-trips at scale.
+        # Buffered claims are flushed on close() and before any claim read.
+        self._batch = max(1, write_batch_size)
+        self._claim_buf: list[dict[str, Any]] = []
         # ponytail: in-memory set gives read-your-writes consistency for the test-and-set;
         # the durable upsert covers the restart-replay defence.
         self._seen_transcripts: set[str] = set()
@@ -103,6 +110,8 @@ class RelataBackend:
         self._seq = (int(rows[0]["seq"]) + 1) if rows else 1
 
     def close(self) -> None:
+        if self._obj is not None:
+            self.flush_claims()  # never drop buffered claims on shutdown
         for client in (self._log, self._obj, self._c):
             if client is not None:
                 client.close()
@@ -119,20 +128,30 @@ class RelataBackend:
     # ---- Claims (immutable, append-ordered) -----------------------------
 
     def append_claim(self, stmt: SignedStatement) -> None:
-        self._obj.upsert(
-            "HmClaim",
-            bytes(stmt.kid).hex(),
-            {
-                "seq": self._seq,
-                "wire_b64": base64.b64encode(stmt.to_bytes()).decode("ascii"),
-                "created_ms": int(time.time() * 1000),
-            },
-        )
+        fields = {
+            "seq": self._seq,
+            "wire_b64": base64.b64encode(stmt.to_bytes()).decode("ascii"),
+            "created_ms": int(time.time() * 1000),
+        }
         self._seq += 1
+        if self._batch == 1:
+            self._obj.upsert("HmClaim", bytes(stmt.kid).hex(), fields)
+            return
+        # Buffer + bulk-flush (#175). batch_upsert requires an `id` per row.
+        self._claim_buf.append({"id": bytes(stmt.kid).hex(), **fields})
+        if len(self._claim_buf) >= self._batch:
+            self.flush_claims()
+
+    def flush_claims(self) -> None:
+        """Bulk-write any buffered claims. Idempotent; call before claim reads."""
+        if self._claim_buf:
+            self._obj.batch_upsert("HmClaim", self._claim_buf)
+            self._claim_buf = []
 
     def load_claims(self) -> list[SignedStatement]:
         from hypermind.wire import SignedStatement
 
+        self.flush_claims()
         rows = self._rows("SELECT wire_b64, seq FROM HmClaim ORDER BY seq ASC")
         return [SignedStatement.from_bytes(base64.b64decode(r["wire_b64"])) for r in rows]
 
@@ -233,6 +252,8 @@ class RelataBackend:
     # ---- Health ---------------------------------------------------------
 
     def stats(self) -> dict[str, int]:
+        self.flush_claims()
+
         def count(table: str) -> int:
             return int(self._rows(f"SELECT COUNT(*) AS n FROM {table}")[0]["n"])
 

hypermind-0.22.0/tests/orgs/test_lightweight.py

@@ -0,0 +1,196 @@
+"""#176 — bounded/streaming report: OrgSim(lightweight=True) caps RAM to
+O(members + windows), not O(records), while the scorecard totals stay exact.
+"""
+
+from __future__ import annotations
+
+import pytest
+from _fakes import FakeMemory, FakeStore, client_factory
+
+from hypermind.orgs import (
+    DynamicsConfig,
+    OrgModel,
+    OrgSim,
+    Seat,
+    StaticGroundTruth,
+    Unit,
+)
+from hypermind.orgs.metrics import compute_scorecard, scorecard_from_aggregates
+from hypermind.responders.base import confidence_to_uncertainty
+from hypermind.responders.structured import StructuredResponse
+
+
+def _model() -> OrgModel:
+    return OrgModel(
+        name="lw",
+        namespace="lw",
+        units=(
+            Unit(
+                "a",
+                seats=(
+                    Seat("O", role="oracle", authority=0.9),
+                    Seat("S", role="scout", authority=0.5, headcount=3),
+                ),
+            ),
+        ),
+        # publish everything, resolve everything → claims + Brier both exercised.
+        dynamics=DynamicsConfig(rounds=2, publish_floor=0.0, oracle_resolve_frac=1.0),
+    )
+
+
+def _factory():
+    def factory(slot, tools):
+        async def _resp(kid, query):
+            return (
+                confidence_to_uncertainty(0.8, effective_n=10.0),
+                StructuredResponse(confidence=0.8, reasoning="a finding about frost"),
+            )
+
+        return _resp
+
+    return factory
+
+
+def _sim(**kw) -> OrgSim:
+    return OrgSim(
+        _model(),
+        relata_url="http://fake",
+        responder_factory=_factory(),
+        relata_client_factory=client_factory(FakeStore()),
+        relata_memory_factory=FakeMemory,
+        ground_truth=StaticGroundTruth(
+            {"a/O#1": True, "a/S#1": True, "a/S#2": False, "a/S#3": True}
+        ),
+        **kw,
+    )
+
+
+@pytest.mark.asyncio
+async def test_lightweight_bounds_claims_but_counts_all():
+    # 4 members → cap = max(window, 2*4) = 8. 3 rounds → 12 claims published, so
+    # the window must evict while the scorecard still counts all 12.
+    sim = _sim(lightweight=True, claims_window=1)
+    assert sim._claims_cap == 8
+    report = await sim.simulate("frost", rounds=3)
+    assert len(sim._claims) <= 8  # window bounded (12 published, ≤8 retained)
+    assert report.scorecard["claims"] == 12  # every publish counted
+    assert report.scorecard["claims"] == sim._n_claims
+    assert len(report.standings) == 4
+    assert sum(s.claims for s in report.standings) == 12
+
+
+@pytest.mark.asyncio
+async def test_lightweight_scorecard_has_brier_from_stream():
+    sim = _sim(lightweight=True)
+    report = await sim.simulate("frost", rounds=2)
+    # Oracle resolved claims → Brier accumulated online (not from a claims list).
+    assert report.scorecard["brier_mean"] is not None
+    assert report.scorecard["brier_by_member"]  # per-member sums populated
+
+
+@pytest.mark.asyncio
+async def test_lightweight_aggregates_bounded_by_members_not_records():
+    sim = _sim(lightweight=True, claims_window=2)
+    await sim.simulate("frost", rounds=2)
+    # _agg is keyed by member label → at most #members entries, regardless of
+    # how many claims were published.
+    assert len(sim._agg) <= 4
+    assert sim._n_claims == 8
+
+
+@pytest.mark.asyncio
+async def test_full_mode_unchanged_retains_everything():
+    sim = _sim(lightweight=False)
+    report = await sim.simulate("frost", rounds=2)
+    # Full mode keeps every claim; report claims list == total.
+    assert len(sim._claims) == 8
+    assert report.scorecard["claims"] == 8
+    assert len(report.claims) == 8
+
+
+@pytest.mark.asyncio
+async def test_lightweight_streams_dispute_aggregates():
+    # A sceptic that reasons far from its peers triggers disputes; lightweight
+    # mode must accumulate disputes_received per author online.
+    model = OrgModel(
+        name="lw2",
+        namespace="lw2",
+        units=(
+            Unit(
+                "a",
+                seats=(
+                    Seat("O", role="oracle", authority=0.9),
+                    Seat("P", role="scout", authority=0.6),
+                    Seat("K", role="sceptic", authority=0.6),
+                ),
+            ),
+        ),
+        dynamics=DynamicsConfig(
+            rounds=2, publish_floor=0.0, oracle_resolve_frac=1.0, dispute_gap=0.3
+        ),
+    )
+
+    def factory(slot, tools):
+        conf = 0.15 if slot.seat.role == "sceptic" else 0.9
+
+        async def _resp(kid, query):
+            return (
+                confidence_to_uncertainty(conf, effective_n=10.0),
+                StructuredResponse(confidence=conf, reasoning="a finding"),
+            )
+
+        return _resp
+
+    sim = OrgSim(
+        model,
+        relata_url="http://fake",
+        responder_factory=factory,
+        relata_client_factory=client_factory(FakeStore()),
+        relata_memory_factory=FakeMemory,
+        ground_truth=StaticGroundTruth({"a/O#1": True}),
+        lightweight=True,
+    )
+    report = await sim.simulate("frost", rounds=2)
+    assert sim._n_disputes >= 1
+    assert report.scorecard["disputes"] == sim._n_disputes
+    # A disputed author accrued disputes_received in the streaming aggregate.
+    assert any(a["disputes_received"] >= 1 for a in sim._agg.values())
+
+
+def test_scorecard_from_aggregates_matches_compute_scorecard():
+    # Same underlying data via both entry points → identical scorecard (except
+    # influence, which the full path weights by citer reputation).
+    per_round = [{"a": 0.8, "b": 0.6}, {"a": 0.82, "b": 0.62}]
+    units = {"a": "u", "b": "u"}
+    claims = [
+        {"kid_hex": "k1", "label": "a", "unit": "u", "confidence": 0.8, "outcome": True},
+        {"kid_hex": "k2", "label": "b", "unit": "u", "confidence": 0.6, "outcome": False},
+        {"kid_hex": "k3", "label": "a", "unit": "u", "confidence": 0.9, "outcome": None},
+    ]
+    citations = [("b", "k1")]
+    full = compute_scorecard(
+        per_round_posteriors=per_round,
+        member_units=units,
+        claims=claims,
+        citations=citations,
+        reputations={"a": 1.0, "b": 1.0},
+        disputes_count=1,
+    )
+    light = scorecard_from_aggregates(
+        per_round_posteriors=per_round,
+        member_units=units,
+        brier_sums={"a": ((0.8 - 1.0) ** 2, 1), "b": ((0.6 - 0.0) ** 2, 1)},
+        influence={"a": 1.0},  # b cited a's k1 with rep 1.0
+        publishers={"a", "b"},
+        claims_count=3,
+        citations_count=1,
+        disputes_count=1,
+    )
+    assert light.brier_mean == full.brier_mean
+    assert light.brier_by_member == full.brier_by_member
+    assert light.claims == full.claims == 3
+    assert light.citations == full.citations == 1
+    assert light.disputes == full.disputes == 1
+    assert light.participation_rate == full.participation_rate
+    assert light.influence == full.influence
+    assert light.top_influencer == full.top_influencer == "a"