hypermind 0.16.0__tar.gz → 0.17.0__tar.gz

{hypermind-0.16.0 → hypermind-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypermind
-Version: 0.16.0
+Version: 0.17.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.16.0 → hypermind-0.17.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hypermind"
-version = "0.16.0"
+version = "0.17.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.16.0 → hypermind-0.17.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.16.0"
+__version__ = "0.17.0"
 
 #: SLSA build-provenance level committed for every release artefact.
 #: Cosign keyless signing + slsa-github-generator + PEP 740 attestations

{hypermind-0.16.0 → hypermind-0.17.0}/src/hypermind/orgs/sim.py

@@ -19,7 +19,9 @@ live model or server.
 
 from __future__ import annotations
 
+import asyncio
 import inspect
+from collections import deque
 from collections.abc import Callable
 from dataclasses import dataclass, field
 from statistics import pvariance
@@ -114,6 +116,7 @@ class OrgSim:
         interventions: list[Any] | None = None,
         context_builder: Any = None,
         on_event: Callable[[dict[str, Any]], Any] | None = None,
+        max_concurrency: int = 16,
         members: int | None = None,
     ) -> None:
         self.model = model.scaled(members) if members is not None else model
@@ -154,6 +157,12 @@ class OrgSim:
         self._decisions: list[dict[str, Any]] = []  # deliberator-mode decision trace
         self._studied: bool = False
         self._study_topic: str | None = None
+        self._max_concurrency = max(1, max_concurrency)
+        # 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)
+        self._member_by_kid: dict[bytes, Member] = {}  # O(1) resolve lookups
+        self._observe_top_k = 12  # deliberator: observe only the top-k peers
 
     async def _emit(self, kind: str, **data: Any) -> None:
         """Fire a structured event to the on_event sink (async or sync)."""
@@ -202,18 +211,18 @@ class OrgSim:
         if not self._studied:
             await self.study(topic or question, rounds=study_rounds)
 
-        responses: list[dict[str, Any]] = []
-        for m in self._members:
-            post, reasoning, _tools = await self._think(m, question)
-            responses.append(
-                {
-                    "label": m.label,
-                    "role": m.role,
-                    "reputation": self._member_reputation(m),
-                    "confidence": post.mean(),
-                    "reasoning": reasoning,
-                }
-            )
+        # Members answer the question concurrently (network-bound).
+        thoughts = await self._gather_think(self._members, question)
+        responses: list[dict[str, Any]] = [
+            {
+                "label": m.label,
+                "role": m.role,
+                "reputation": self._member_reputation(m),
+                "confidence": post.mean(),
+                "reasoning": reasoning,
+            }
+            for m, post, reasoning, _tools in thoughts
+        ]
         return aggregate_answer(question, responses)
 
     async def inquire(
@@ -272,20 +281,22 @@ class OrgSim:
                 bearer_token=self.relata_token,
                 memory_factory=self._relata_memory_factory,
             )
-            memory.open()
-            agent.attach_memory(memory)
+            agent.attach_memory(memory)  # opened concurrently below
 
             allowed = self._grants.get(slot.label, frozenset())
             responder = self._build_member_responder(slot, allowed)
-            self._members.append(
-                Member(
-                    agent=agent,
-                    slot=slot,
-                    responder=responder,
-                    memory=memory,
-                    tools=allowed,
-                )
+            member = Member(
+                agent=agent,
+                slot=slot,
+                responder=responder,
+                memory=memory,
+                tools=allowed,
             )
+            self._members.append(member)
+            self._member_by_kid[member.kid] = member  # O(1) resolve lookups
+
+        # Open all private notebooks concurrently (network I/O), bounded.
+        await self._gather_io(m.memory.open for m in self._members if m.memory)
 
     def _build_member_responder(self, slot: Slot, allowed: frozenset[str]) -> Any:
         tool_objs = [build_tool(name, **self._tool_context) for name in sorted(allowed)]
@@ -305,15 +316,47 @@ class OrgSim:
         )
 
     async def _teardown(self) -> None:
+        # Close private notebooks concurrently (blocking I/O), agents sequentially
+        # (they share one in-process world; close mutates its registries).
+        await self._gather_io(m.memory.close for m in self._members if m.memory)
         for m in self._members:
-            if m.memory is not None:
-                m.memory.close()
             await m.agent.close()
         if self._backend is not None:
             self._backend.close()
 
     # ---- the loop ------------------------------------------------------
 
+    async def _gather_io(self, sync_calls) -> None:
+        """Run blocking I/O callables (Relata open/close) concurrently in a
+        thread pool, bounded — so spin-up/teardown of thousands of agents
+        doesn't serialise thousands of blocking HTTP round-trips."""
+        sem = asyncio.Semaphore(self._max_concurrency)
+
+        async def one(fn):
+            async with sem:
+                await asyncio.to_thread(fn)
+
+        await asyncio.gather(*(one(fn) for fn in sync_calls))
+
+    async def _gather_think(
+        self, members: list[Member], topic: str
+    ) -> list[tuple[Member, Uncertainty, str, list]]:
+        """Run every member's think() concurrently (bounded).
+
+        The per-member LLM calls are independent and network-bound, so this is
+        the big speed-up: a round's think phase costs ~max(latency) instead of
+        sum(latency). Results are returned in member order (gather is ordered),
+        so downstream publish/track logic stays deterministic.
+        """
+        sem = asyncio.Semaphore(self._max_concurrency)
+
+        async def one(m: Member) -> tuple[Member, Uncertainty, str, list]:
+            async with sem:
+                post, reasoning, tool_calls = await self._think(m, topic)
+            return m, post, reasoning, tool_calls
+
+        return list(await asyncio.gather(*(one(m) for m in members)))
+
     async def run(self, topic: str, *, rounds: int | None = None) -> OrgReport:
         """Run the loop.
 
@@ -353,21 +396,25 @@ class OrgSim:
         for r in range(rounds):
             await self._emit("round_start", round=r, members=len(self._members))
             posteriors: dict[str, float] = {}
-            for m in self._members:
-                post, _reasoning, _tools = await self._think(m, topic)
+            for m, post, _reasoning, _tools in await self._gather_think(self._members, topic):
                 posteriors[m.label] = post.mean()
                 m.agent.working_memory().setdefault("posteriors", {})[m.unit] = post.mean()
-            # Cross-pollinate: each member observes its peers' posteriors.
+            # Cross-pollinate: each member observes the TOP-K peers by reputation,
+            # not every peer — O(members·k) instead of O(members²), so this
+            # stays tractable at thousands of agents.
+            k = min(len(self._members) - 1, self._observe_top_k)
+            ranked = sorted(self._members, key=lambda p: self._member_reputation(p), reverse=True)[
+                : k + 1
+            ]
             for m in self._members:
-                for peer in self._members:
+                for peer in ranked:
                     if peer.label == m.label:
                         continue
-                    rep = self._member_reputation(peer)
                     delibs[m.label].observe(
                         {
                             "topic": m.unit,
                             "posterior": posteriors[peer.label],
-                            "reputation": rep,
+                            "reputation": self._member_reputation(peer),
                             "kid": peer.kid,
                         }
                     )
@@ -419,11 +466,12 @@ class OrgSim:
             if getattr(iv, "round", None) == r:
                 await iv.apply(self)
         await self._emit("round_start", round=r, members=len(self._members))
-        # 1+2+3: recall → think → publish.
+        # 1+2: recall → think, run concurrently across members (network-bound).
+        thoughts = await self._gather_think(self._members, topic)
+        # 3: publish — sequential (mutates shared ledger + tracking, deterministic).
         published: list[tuple[Member, bytes, Uncertainty]] = []
         posteriors: dict[str, float] = {}
-        for m in self._members:
-            post, reasoning, tool_calls = await self._think(m, topic)
+        for m, post, reasoning, tool_calls in thoughts:
             posteriors[m.label] = post.mean()
             floor = self.interaction.publish_floor(role=m.role, base_floor=dyn.publish_floor)
             floor = min(1.0, max(0.0, floor + m.floor_adj))
@@ -505,11 +553,12 @@ class OrgSim:
         return post, reasoning, tool_calls
 
     def _recent_peer_findings(self, m: Member, *, limit: int = 3) -> list[str]:
-        """Top peer findings on the shared ledger — same unit first, by
-        confidence — so reasoning is grounded in what others have claimed."""
-        peers = [c for c in self._claims.values() if c.label != m.label and c.finding]
-        peers.sort(key=lambda c: (c.unit == m.unit, c.confidence), reverse=True)
-        return [f"{c.label}: {c.finding}" for c in peers[:limit]]
+        """Top peer findings from a **bounded window** of recent claims — same
+        unit first, by confidence. O(window), never a full scan of all claims,
+        so this stays flat as the ledger grows into the millions."""
+        peers = [f for f in self._recent_findings if f[0] != m.label]
+        peers.sort(key=lambda f: (f[1] == m.unit, f[2]), reverse=True)
+        return [f"{label}: {text}" for label, _unit, _conf, text in peers[:limit]]
 
     async def _publish(
         self,
@@ -544,6 +593,8 @@ class OrgSim:
             finding=reasoning,
             tool_calls=tool_calls,
         )
+        if reasoning:
+            self._recent_findings.append((m.label, m.unit, post.mean(), reasoning))
         if tool_calls:
             await self._emit(
                 "tool_call",
@@ -624,8 +675,8 @@ class OrgSim:
                 if info is not None:
                     info.outcome = outcome
                 await self._emit("resolve", by=rec.member_label, unit=unit, outcome=outcome)
-                # Evolve signal: publisher earns/loses floor headroom.
-                pub = next((m for m in self._members if m.kid == rec.member_kid), None)
+                # Evolve signal: publisher earns/loses floor headroom (O(1) lookup).
+                pub = self._member_by_kid.get(rec.member_kid)
                 if pub is not None:
                     pub.floor_adj += -0.03 if outcome else 0.05
 
@@ -655,10 +706,14 @@ class OrgSim:
 
     def _build_report(self, topic: str, rounds: int) -> OrgReport:
         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]] = {}
+        for c in self._claims.values():
+            by_label.setdefault(c.label, []).append(c)
         standings: list[MemberStanding] = []
         for m in self._members:
             score = world.reputation.snapshot(m.kid, m.unit).score if world else 0.0
-            authored = [c for c in self._claims.values() if c.label == m.label]
+            authored = by_label.get(m.label, [])
             standings.append(
                 MemberStanding(
                     label=m.label,

hypermind-0.17.0/tests/orgs/test_concurrency.py

@@ -0,0 +1,101 @@
+"""Concurrent think phase — parallel LLM calls, bounded, order-preserving."""
+
+from __future__ import annotations
+
+import asyncio
+
+import pytest
+from _fakes import FakeMemory, FakeStore, client_factory
+
+from hypermind.orgs import DynamicsConfig, OrgModel, OrgSim, Seat, Unit
+from hypermind.responders.base import confidence_to_uncertainty
+
+
+def _model(members=12) -> OrgModel:
+    base = OrgModel(
+        name="c",
+        namespace="c",
+        units=(
+            Unit(
+                "a",
+                seats=(
+                    Seat("O", role="oracle", authority=0.9),
+                    Seat("S", role="scout", authority=0.5, headcount=3),
+                ),
+            ),
+        ),
+        dynamics=DynamicsConfig(rounds=1),
+    )
+    return base.scaled(members)
+
+
+def _make(responder_factory, **kw) -> OrgSim:
+    return OrgSim(
+        _model(),
+        relata_url="http://fake",
+        responder_factory=responder_factory,
+        relata_client_factory=client_factory(FakeStore()),
+        relata_memory_factory=FakeMemory,
+        **kw,
+    )
+
+
+@pytest.mark.asyncio
+async def test_think_phase_runs_concurrently():
+    # Track how many responder calls are in-flight at once.
+    state = {"live": 0, "peak": 0}
+
+    def factory(slot, tools):
+        async def _resp(kid, query):
+            state["live"] += 1
+            state["peak"] = max(state["peak"], state["live"])
+            await asyncio.sleep(0.02)  # simulate network latency
+            state["live"] -= 1
+            return confidence_to_uncertainty(0.8, effective_n=10.0)
+
+        return _resp
+
+    await _make(factory).simulate("t", rounds=1)
+    # With 12 members and a sequential loop, peak would be 1. Concurrency lifts it.
+    assert state["peak"] > 1
+
+
+@pytest.mark.asyncio
+async def test_concurrency_cap_is_respected():
+    state = {"live": 0, "peak": 0}
+
+    def factory(slot, tools):
+        async def _resp(kid, query):
+            state["live"] += 1
+            state["peak"] = max(state["peak"], state["live"])
+            await asyncio.sleep(0.02)
+            state["live"] -= 1
+            return confidence_to_uncertainty(0.8, effective_n=10.0)
+
+        return _resp
+
+    await _make(factory, max_concurrency=3).simulate("t", rounds=1)
+    assert state["peak"] <= 3  # never exceeds the cap
+
+
+@pytest.mark.asyncio
+async def test_results_stay_deterministic_and_ordered():
+    # Confidence keyed by member label; concurrency must not scramble attribution.
+    order: list[str] = []
+
+    def factory(slot, tools):
+        async def _resp(kid, query):
+            # Finish out of submission order to stress ordering.
+            await asyncio.sleep(0.01 if slot.seat.role == "scout" else 0.03)
+            return confidence_to_uncertainty(
+                0.9 if slot.seat.role == "oracle" else 0.6, effective_n=10.0
+            )
+
+        return _resp
+
+    report = await _make(factory).simulate("t", rounds=1)
+    # Oracle (0.9) outranks scouts (0.6) — attribution preserved despite races.
+    top = report.standings[0]
+    assert report.summary()["claims"] > 0
+    assert all(0.0 <= s.reputation <= 1.0 for s in report.standings)
+    assert top.reputation >= min(s.reputation for s in report.standings)

hypermind-0.17.0/tests/orgs/test_scale.py

@@ -0,0 +1,139 @@
+"""Scalability guards — bounded peer window, O(1) indices, concurrent I/O."""
+
+from __future__ import annotations
+
+import pytest
+from _fakes import FakeStore, client_factory
+
+from hypermind.orgs import DynamicsConfig, OrgModel, OrgSim, Seat, Unit
+from hypermind.responders.base import confidence_to_uncertainty
+
+
+def _model(members=8, mode="scripted") -> OrgModel:
+    base = OrgModel(
+        name="s",
+        namespace="s",
+        units=(
+            Unit(
+                "a",
+                seats=(
+                    Seat("O", role="oracle", authority=0.9),
+                    Seat("G", role="generalist", authority=0.6, headcount=3),
+                ),
+            ),
+        ),
+        dynamics=DynamicsConfig(rounds=2, mode=mode),
+    )
+    return base.scaled(members)
+
+
+class _OpenCloseMemory:
+    """Memory that records open/close so we can assert they ran."""
+
+    opened = 0
+    closed = 0
+
+    def __init__(self):
+        pass
+
+    def add(self, content, *, confidence=1.0, memory_class="semantic"):
+        return "m"
+
+    def add_batch(self, items, *, session_id=None):
+        return ["m" for _ in items]
+
+    def search(self, q, *, top_k=5, as_of=None):
+        return []
+
+    def justify(self, mid):
+        return {}
+
+    def close(self):
+        type(self).closed += 1
+
+
+def _factory(slot, tools):
+    async def _resp(kid, query):
+        return confidence_to_uncertainty(0.8, effective_n=10.0)
+
+    return _resp
+
+
+def _sim(**kw):
+    return OrgSim(
+        _model(**kw.pop("model_kw", {})),
+        relata_url="http://fake",
+        responder_factory=_factory,
+        relata_client_factory=client_factory(FakeStore()),
+        **kw,
+    )
+
+
+def test_recent_findings_window_is_bounded():
+    sim = _sim(relata_memory_factory=lambda: _OpenCloseMemory())
+    # The peer-grounding window has a hard cap — never grows with total claims.
+    assert sim._recent_findings.maxlen == 256
+
+
+@pytest.mark.asyncio
+async def test_member_by_kid_index_built_and_used():
+    sim = _sim(relata_memory_factory=lambda: _OpenCloseMemory())
+    async with sim:
+        assert len(sim._member_by_kid) == len(sim._members)
+        # Every member is reachable by kid in O(1).
+        for m in sim._members:
+            assert sim._member_by_kid[m.kid] is m
+
+
+@pytest.mark.asyncio
+async def test_peer_findings_lookup_reads_only_the_window():
+    sim = _sim(relata_memory_factory=lambda: _OpenCloseMemory())
+    async with sim:
+        # Seed the window past its cap; lookup must stay bounded + exclude self.
+        for i in range(500):
+            sim._recent_findings.append((f"other/{i}", "a", 0.9, f"finding {i}"))
+        m = sim._members[0]
+        out = sim._recent_peer_findings(m, limit=3)
+        assert len(out) == 3
+        assert all(not o.startswith(m.label) for o in out)
+
+
+@pytest.mark.asyncio
+async def test_memory_opened_and_closed_concurrently():
+    _OpenCloseMemory.closed = 0
+    sim = _sim(relata_memory_factory=lambda: _OpenCloseMemory())
+    async with sim:
+        n = len(sim._members)
+    # Every member's notebook was closed on teardown (via the concurrent path).
+    assert _OpenCloseMemory.closed == n
+
+
+@pytest.mark.asyncio
+async def test_gather_io_runs_concurrently_and_bounded():
+    sim = _sim(relata_memory_factory=lambda: _OpenCloseMemory(), max_concurrency=4)
+    state = {"live": 0, "peak": 0}
+
+    def blocking():
+        state["live"] += 1
+        state["peak"] = max(state["peak"], state["live"])
+        # tiny spin; to_thread runs these on the pool
+        import time as _t
+
+        _t.sleep(0.01)
+        state["live"] -= 1
+
+    await sim._gather_io([blocking for _ in range(12)])
+    assert state["peak"] > 1  # ran concurrently
+    assert state["peak"] <= 4  # respected the cap
+
+
+@pytest.mark.asyncio
+async def test_deliberator_observes_only_top_k_peers():
+    sim = _sim(
+        model_kw={"members": 20, "mode": "deliberator"},
+        relata_memory_factory=lambda: _OpenCloseMemory(),
+    )
+    sim._observe_top_k = 5
+    report = await sim.simulate("t", rounds=1)
+    # Runs at 20 agents in deliberator mode without O(n^2) blow-up.
+    assert report.decisions