hypermind 2.0.1__tar.gz → 2.0.2__tar.gz

{hypermind-2.0.1 → hypermind-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypermind
-Version: 2.0.1
+Version: 2.0.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
@@ -30,7 +30,7 @@ Requires-Dist: pydantic>=2.6
 Requires-Dist: pymerkle>=6.1
 Requires-Dist: pynacl>=1.6.2
 Requires-Dist: quantcrypt>=1.0
-Requires-Dist: relata-sdk>=0.2
+Requires-Dist: relata-sdk>=0.3.4
 Requires-Dist: rich>=13.7
 Requires-Dist: structlog>=24.1
 Provides-Extra: anthropic

{hypermind-2.0.1 → hypermind-2.0.2}/deploy/standalone/docker-compose.yml

@@ -19,7 +19,7 @@ services:
     environment:
       RELATA_PROFILE: free
       RELATA_HTTP_BIND: "0.0.0.0:9090"
-      RELATA_DATA_DIR: /tmp/relata
+      RELATA_DATA_DIR: /data/relata
       RELATA_BEARER_TOKEN: ${RELATA_TOKEN}
       RELATA_ADMIN_TOKEN: ${RELATA_TOKEN}
       RELATA_PURPOSES: analytics,operations,security_incident,compliance_review,audit,intops,intelligence,agent-notes,gdpr-erasure,hm_ledger,hm_kernel,agent_notes

{hypermind-2.0.1 → hypermind-2.0.2}/examples/sim_criminology_tech.py

@@ -53,7 +53,7 @@ from datetime import datetime
 def _h(title: str) -> None:
     print(f"\n{'═' * 70}")
     print(f"  {title}")
-    print('═' * 70)
+    print("═" * 70)
 
 
 def _sub(title: str) -> None:
@@ -61,7 +61,7 @@ def _sub(title: str) -> None:
 
 
 # ── org model ────────────────────────────────────────────────────────────────
-def build_crimtech_university() -> "OrgModel":  # noqa: F821
+def build_crimtech_university() -> OrgModel:  # noqa: F821
     from hypermind.orgs.model import DynamicsConfig, OrgModel, Seat, Unit
 
     def dept(name: str, tools: tuple, seats: tuple) -> Unit:
@@ -71,20 +71,37 @@ def build_crimtech_university() -> "OrgModel":  # noqa: F821
         "criminology-theory",
         tools=("web_search", "retrieve_document", "relata_search_knowledge"),
         seats=(
-            Seat("Professor of Criminology", role="oracle", authority=0.95,
-                 system="You are a tenured criminology professor. Ground every claim "
-                        "in peer-reviewed literature and empirical data. Resolve disputes "
-                        "by weighing evidence quality and methodology rigor."),
-            Seat("Postdoc Researcher", role="synthesist", authority=0.72,
-                 system="You synthesise findings across theoretical frameworks "
-                        "(routine-activity theory, strain theory, social disorganisation). "
-                        "Surface cross-paradigm insights."),
-            Seat("PhD Student", role="scout", authority=0.38, headcount=4,
-                 system="You are an eager PhD student exploring crime pattern frontiers. "
-                        "Surface speculative but promising hypotheses; flag data gaps."),
-            Seat("Peer Reviewer", role="sceptic", authority=0.62,
-                 system="You rigorously challenge weak methodology, selection bias, "
-                        "and overclaiming. Demand replication evidence."),
+            Seat(
+                "Professor of Criminology",
+                role="oracle",
+                authority=0.95,
+                system="You are a tenured criminology professor. Ground every claim "
+                "in peer-reviewed literature and empirical data. Resolve disputes "
+                "by weighing evidence quality and methodology rigor.",
+            ),
+            Seat(
+                "Postdoc Researcher",
+                role="synthesist",
+                authority=0.72,
+                system="You synthesise findings across theoretical frameworks "
+                "(routine-activity theory, strain theory, social disorganisation). "
+                "Surface cross-paradigm insights.",
+            ),
+            Seat(
+                "PhD Student",
+                role="scout",
+                authority=0.38,
+                headcount=4,
+                system="You are an eager PhD student exploring crime pattern frontiers. "
+                "Surface speculative but promising hypotheses; flag data gaps.",
+            ),
+            Seat(
+                "Peer Reviewer",
+                role="sceptic",
+                authority=0.62,
+                system="You rigorously challenge weak methodology, selection bias, "
+                "and overclaiming. Demand replication evidence.",
+            ),
         ),
     )
 
@@ -92,21 +109,38 @@ def build_crimtech_university() -> "OrgModel":  # noqa: F821
         "forensic-technology",
         tools=("web_search", "retrieve_document"),
         seats=(
-            Seat("Lab Chief", role="oracle", authority=0.93,
-                 system="You are the forensic technology lab chief. Adjudicate technical "
-                        "claims about AI/ML in law enforcement, biometrics, blockchain "
-                        "evidence chains, and digital forensics. Demand reproducibility."),
-            Seat("ML Engineer", role="synthesist", authority=0.75,
-                 system="You integrate machine-learning research with forensic practice. "
-                        "Identify where models fail (bias, adversarial examples, "
-                        "distribution shift in crime data)."),
-            Seat("Forensic Analyst", role="scout", authority=0.42, headcount=4,
-                 system="You probe cutting-edge forensic tools: DNA phenotyping, "
-                        "deepfake detection, cell-site simulators, predictive policing. "
-                        "Surface capability and limitation findings early."),
-            Seat("Ethics Auditor", role="sceptic", authority=0.65,
-                 system="You audit forensic tech claims for civil-liberties risks, "
-                        "disparate-impact evidence, and legal admissibility problems."),
+            Seat(
+                "Lab Chief",
+                role="oracle",
+                authority=0.93,
+                system="You are the forensic technology lab chief. Adjudicate technical "
+                "claims about AI/ML in law enforcement, biometrics, blockchain "
+                "evidence chains, and digital forensics. Demand reproducibility.",
+            ),
+            Seat(
+                "ML Engineer",
+                role="synthesist",
+                authority=0.75,
+                system="You integrate machine-learning research with forensic practice. "
+                "Identify where models fail (bias, adversarial examples, "
+                "distribution shift in crime data).",
+            ),
+            Seat(
+                "Forensic Analyst",
+                role="scout",
+                authority=0.42,
+                headcount=4,
+                system="You probe cutting-edge forensic tools: DNA phenotyping, "
+                "deepfake detection, cell-site simulators, predictive policing. "
+                "Surface capability and limitation findings early.",
+            ),
+            Seat(
+                "Ethics Auditor",
+                role="sceptic",
+                authority=0.65,
+                system="You audit forensic tech claims for civil-liberties risks, "
+                "disparate-impact evidence, and legal admissibility problems.",
+            ),
         ),
     )
 
@@ -114,20 +148,37 @@ def build_crimtech_university() -> "OrgModel":  # noqa: F821
         "policy-society",
         tools=("web_search",),
         seats=(
-            Seat("Professor of Law", role="oracle", authority=0.91,
-                 system="You are a law professor specialising in criminal justice policy. "
-                        "Ground claims in statute, case law, and comparative jurisdiction "
-                        "analysis. Adjudicate ethical disputes."),
-            Seat("Policy Analyst", role="synthesist", authority=0.70,
-                 system="You translate research findings into actionable policy recommendations, "
-                        "weighing efficacy, feasibility, and rights implications."),
-            Seat("Sociologist", role="scout", authority=0.40, headcount=4,
-                 system="You study the social impact of crime-tech on communities: "
-                        "surveillance capitalism, chilling effects, racial profiling, "
-                        "the prison-industrial complex. Surface uncomfortable truths."),
-            Seat("Civil-Liberties Advocate", role="sceptic", authority=0.60,
-                 system="You challenge any claim that trades privacy or due process for "
-                        "security gains without rigorous evidence of net benefit."),
+            Seat(
+                "Professor of Law",
+                role="oracle",
+                authority=0.91,
+                system="You are a law professor specialising in criminal justice policy. "
+                "Ground claims in statute, case law, and comparative jurisdiction "
+                "analysis. Adjudicate ethical disputes.",
+            ),
+            Seat(
+                "Policy Analyst",
+                role="synthesist",
+                authority=0.70,
+                system="You translate research findings into actionable policy recommendations, "
+                "weighing efficacy, feasibility, and rights implications.",
+            ),
+            Seat(
+                "Sociologist",
+                role="scout",
+                authority=0.40,
+                headcount=4,
+                system="You study the social impact of crime-tech on communities: "
+                "surveillance capitalism, chilling effects, racial profiling, "
+                "the prison-industrial complex. Surface uncomfortable truths.",
+            ),
+            Seat(
+                "Civil-Liberties Advocate",
+                role="sceptic",
+                authority=0.60,
+                system="You challenge any claim that trades privacy or due process for "
+                "security gains without rigorous evidence of net benefit.",
+            ),
         ),
     )
 
@@ -138,8 +189,8 @@ def build_crimtech_university() -> "OrgModel":  # noqa: F821
         units=(theory, forensic, policy),
         dynamics=DynamicsConfig(
             interaction="cooperative",
-            rounds=4,        # 4 full research rounds
-            dispute_gap=0.3, # challenge claims with confidence gap >= 0.3
+            rounds=4,  # 4 full research rounds
+            dispute_gap=0.3,  # challenge claims with confidence gap >= 0.3
         ),
     )
 
@@ -147,6 +198,7 @@ def build_crimtech_university() -> "OrgModel":  # noqa: F821
 # ── main ─────────────────────────────────────────────────────────────────────
 async def main() -> None:
     import openai
+
     from hypermind.orgs import OrgSim
     from hypermind.orgs.mcp_config import attach_mcp_config, load_mcp_config
 
@@ -178,6 +230,7 @@ async def main() -> None:
     gw = None
     if cfg:
         from hypermind.orgs.tool_providers import ToolGateway
+
         gw = ToolGateway()
         counts, _sessions = await attach_mcp_config(gw, cfg)
         total_tools = sum(counts.values())
@@ -188,9 +241,7 @@ async def main() -> None:
     # ── build org (scale to 30 members) ──────────────────────────────────────
     model = build_crimtech_university()
     model = model.scaled(30)
-    total_seats = sum(
-        sum(s.headcount for s in u.seats) for u in model.units
-    )
+    total_seats = sum(sum(s.headcount for s in u.seats) for u in model.units)
     print(f"  Org     : {len(model.units)} departments, ~{total_seats} seats → scaled to 30")
 
     # ── event stream (defined before OrgSim so it can be passed in) ─────────
@@ -203,12 +254,14 @@ async def main() -> None:
             tools = e.get("tools", [])
             print(f"  [tool]  {e.get('by', '?')[:20]:20s}  → {tools}")
         elif kind == "dispute_opened":
-            print(f"  [disp]  {e.get('challenger', '?')[:20]:20s}  challenged {e.get('target_kid', '')[:12]}…")
+            print(
+                f"  [disp]  {e.get('challenger', '?')[:20]:20s}  challenged {e.get('target_kid', '')[:12]}…"
+            )
         elif kind == "dispute_resolved":
             print(f"  [resol] dispute → {e.get('outcome', '?')}")
         elif kind == "hypothesis_updated":
             h = e.get("hypothesis", {})
-            print(f"  [hypo]  {h.get('status','?'):12s}  {str(h.get('statement',''))[:50]}")
+            print(f"  [hypo]  {h.get('status', '?'):12s}  {str(h.get('statement', ''))[:50]}")
         elif kind == "round_complete":
             r = e.get("round", "?")
             claims = e.get("claims_this_round", 0)
@@ -225,7 +278,7 @@ async def main() -> None:
         tool_gateway=gw,
         persist_identities=bool(relata_url),
         on_event=on_event,
-        max_concurrency=5,   # throttle to avoid overwhelming MiniMax with parallel JSON requests
+        max_concurrency=5,  # throttle to avoid overwhelming MiniMax with parallel JSON requests
     )
 
     # ── run ──────────────────────────────────────────────────────────────────
@@ -298,7 +351,6 @@ async def main() -> None:
 
     # ── 4. Disputes ──────────────────────────────────────────────────────────
     _sub("Dispute Outcomes")
-    disputes = [e for e in events if e.get("event") in ("dispute_resolved", "dispute_opened")]
     opened = len([e for e in events if e.get("event") == "dispute_opened"])
     resolved = [e for e in events if e.get("event") == "dispute_resolved"]
     print(f"  Disputes opened   : {opened}")
@@ -345,10 +397,10 @@ async def main() -> None:
     if hypo_summary:
         for status, count in sorted(hypo_summary.items(), key=lambda x: -x[1]):
             print(f"    {status:20s}  {count:3d}")
-        print(f"\n  Sample hypotheses:")
+        print("\n  Sample hypotheses:")
         for h in report.hypotheses[:3]:
             stmt = str(h.get("statement", h.get("title", "")))[:70]
-            print(f"    [{h.get('status','?'):12s}]  {stmt}")
+            print(f"    [{h.get('status', '?'):12s}]  {stmt}")
     else:
         print("  No hypotheses tracked this run.")
 
@@ -369,7 +421,7 @@ async def main() -> None:
     print(f"\n  Finished: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
     print(f"  Runtime : {elapsed:.0f}s")
     print(f"  Events  : {len(events)} total")
-    print(f"\n  ✓ Simulation complete.\n")
+    print("\n  ✓ Simulation complete.\n")
 
 
 if __name__ == "__main__":

{hypermind-2.0.1 → hypermind-2.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hypermind"
-version = "2.0.1"
+version = "2.0.2"
 description = "Federated agent intelligence — reference SDK for the HyperMind SCITT contested-claims profile"
 readme = "README.md"
 requires-python = ">=3.12,<3.15"
@@ -33,7 +33,7 @@ dependencies = [
     "rich>=13.7",
     "quantcrypt>=1.0",
     "pymerkle>=6.1",
-    "relata-sdk>=0.2",
+    "relata-sdk>=0.3.4",
     "openai>=1.50,<2",
     "mcp>=1.0",
 ]

{hypermind-2.0.1 → hypermind-2.0.2}/src/hypermind/knowledge/kernel_store.py

@@ -1087,14 +1087,22 @@ def get_kernel_store() -> type[KernelStore] | RelataKernelStore:
     # Prefer the live env vars so per-test monkeypatch.setenv takes effect;
     # fall back to the import-time config constants.
     url = os.environ.get("RELATA_URL", "").strip()
-    tok = os.environ.get("RELATA_BEARER_TOKEN", "").strip() or None
+    # RELATA_BEARER_TOKEN is canonical; RELATA_TOKEN is the legacy alias used by
+    # docker-compose and the sim scripts — honour both so KernelStore reaches Relata
+    # even when only RELATA_TOKEN is set in the environment.
+    tok = (
+        os.environ.get("RELATA_BEARER_TOKEN", "").strip()
+        or os.environ.get("RELATA_TOKEN", "").strip()
+        or None
+    )
     if not url:
         try:
             from hypermind.config import RELATA_BEARER_TOKEN as _RTOK
+            from hypermind.config import RELATA_TOKEN as _RTOK2
             from hypermind.config import RELATA_URL as _RURL
 
             url = (_RURL or "").strip()
-            tok = (_RTOK or "").strip() or None
+            tok = (_RTOK or "").strip() or (_RTOK2 or "").strip() or None
         except Exception:
             pass
     if not url:

{hypermind-2.0.1 → hypermind-2.0.2}/src/hypermind/mind/memory_store.py

@@ -237,6 +237,49 @@ class RelataMemoryStore:
         """Return the PROV-O provenance chain for ``memory_id``."""
         return dict(self._require().justify(memory_id))
 
+    def associate(
+        self, source_id: str, target_id: str, relation: str, *, confidence: float = 1.0
+    ) -> dict:
+        """Link two memory items (e.g. claim_kid → evidence MemoryItem)."""
+        return dict(
+            self._require().associate(source_id, target_id, relation, confidence=confidence)
+        )
+
+    def associate_batch(self, items: list[dict]) -> dict:
+        """Batch-link memory items via POST /memory/associate/batch (RelataDB v1.5.4+).
+
+        Each item: {"from_id": str, "to_id": str, "relation": str}.
+        Falls back to serial associate() calls if the batch endpoint fails.
+        """
+        if not items:
+            return {}
+        import json as _json
+        import urllib.request
+
+        try:
+            req = urllib.request.Request(
+                f"{self._url.rstrip('/')}/memory/associate/batch",
+                data=_json.dumps({"items": items}).encode(),
+                headers={
+                    "Content-Type": "application/json",
+                    "Authorization": f"Bearer {self._tok}" if self._tok else "",
+                    "X-Organization-Id": self._ns,
+                },
+                method="POST",
+            )
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                return _json.loads(resp.read())
+        except Exception:
+            results = []
+            for item in items:
+                with __import__("contextlib").suppress(Exception):
+                    results.append(self.associate(item["from_id"], item["to_id"], item["relation"]))
+            return {"results": results}
+
+    def episodes(self, *, session_id: str | None = None) -> list[dict]:
+        """Return episodic memory groups for this agent's session."""
+        return list(self._require().episodes(session_id=session_id))
+
 
 def sources_from_memory(store: RelataMemoryStore, memory_ids: list[str]) -> list[dict]:
     """Resolve memory ids into provenance descriptors for a claim payload.

{hypermind-2.0.1 → hypermind-2.0.2}/src/hypermind/mind/skills.py

@@ -425,6 +425,110 @@ class SkillFileStore:
         }
 
 
+class RelataMemorySkillStore:
+    """Skill store backed by Relata /memory/remember + /memory/recall blobs.
+
+    Skills are stored as raw .md text (frontmatter + code block) — no typed
+    schema, no ObjectClient. Recall is semantic so agents can surface skills
+    by describing what they need, not just by exact skill_id.
+
+    Falls back to SkillFileStore for local reads/writes so the process never
+    loses skills when Relata is unreachable.
+    """
+
+    _TAG_PREFIX = "skill:"
+
+    def __init__(self, memory_store: Any, fallback: SkillFileStore | None = None) -> None:
+        self._mem = memory_store  # RelataMemoryStore instance (already open)
+        self._fallback = fallback
+        self._id_to_mem_id: dict[str, str] = {}  # skill_id → Relata memory id
+
+    def upsert_skill(
+        self, skill_id: str, code: str, description: str, tags: str, *, skill_type: str = "code"
+    ) -> int:
+        """Store skill as a memory blob and mirror to local fallback."""
+        meta_lines = [
+            f"skill_id: {skill_id}",
+            f"description: {description}",
+            f"tags: {tags},{self._TAG_PREFIX}{skill_id}",
+        ]
+        if skill_type == "prompt_template":
+            meta_lines.append("type: prompt_template")
+        content = "---\n" + "\n".join(meta_lines) + "\n---\n\n"
+        if skill_type == "prompt_template":
+            content += code
+        else:
+            content += f"```python\n{code}\n```\n"
+        try:
+            mem_id = self._mem.remember(content, confidence=1.0, memory_class="semantic")
+            self._id_to_mem_id[skill_id] = mem_id
+        except Exception:
+            pass
+        # mirror to local fallback so offline reads still work
+        if self._fallback is not None:
+            with __import__("contextlib").suppress(Exception):
+                self._fallback.upsert_skill(
+                    skill_id, code, description, tags, skill_type=skill_type
+                )
+        return 1
+
+    def load_skills(self) -> list[dict]:
+        """Recall all skills from Relata memory by tag prefix."""
+        try:
+            rows = self._mem.recall("skill auto-promoted", top_k=50)
+            results = []
+            for r in rows:
+                content = r.get("content", "")
+                if "skill_id:" not in content:
+                    continue
+                meta, code_body = _parse_frontmatter(content)
+                skill_id = meta.get("skill_id", "")
+                if not skill_id:
+                    continue
+                code = _extract_code_block(code_body) or code_body.strip()
+                results.append(
+                    {
+                        "skill_id": skill_id,
+                        "code": code,
+                        "description": meta.get("description", ""),
+                        "tags": meta.get("tags", ""),
+                        "type": meta.get("type", "code"),
+                        "updated_ms": 0,
+                    }
+                )
+            return results
+        except Exception:
+            return self._fallback.load_skills() if self._fallback else []
+
+    def get_skill(self, skill_id: str) -> dict | None:
+        try:
+            rows = self._mem.recall(f"skill_id: {skill_id}", top_k=5)
+            for r in rows:
+                content = r.get("content", "")
+                meta, code_body = _parse_frontmatter(content)
+                if meta.get("skill_id") == skill_id:
+                    code = _extract_code_block(code_body) or code_body.strip()
+                    return {
+                        "skill_id": skill_id,
+                        "code": code,
+                        "description": meta.get("description", ""),
+                        "tags": meta.get("tags", ""),
+                        "type": meta.get("type", "code"),
+                        "updated_ms": 0,
+                    }
+        except Exception:
+            pass
+        return self._fallback.get_skill(skill_id) if self._fallback else None
+
+    def get_skill_history(self, skill_id: str) -> list[dict]:
+        return self._fallback.get_skill_history(skill_id) if self._fallback else []
+
+    def delete_skill(self, skill_id: str) -> None:
+        if self._fallback:
+            with __import__("contextlib").suppress(Exception):
+                self._fallback.delete_skill(skill_id)
+
+
 @dataclass
 class SkillEntry:
     """Metadata record for a registered skill."""