hypermind 1.4.7__tar.gz → 1.4.8__tar.gz

{hypermind-1.4.7 → hypermind-1.4.8}/PKG-INFO

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

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

{hypermind-1.4.7 → hypermind-1.4.8}/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__ = "1.4.7"
+__version__ = "1.4.8"
 
 #: SLSA build-provenance level committed for every release artefact.
 #: Cosign keyless signing + slsa-github-generator + PEP 740 attestations

{hypermind-1.4.7 → hypermind-1.4.8}/src/hypermind/integrations/client.py

@@ -85,6 +85,10 @@ class HyperMindClient:
             _os.makedirs(_os.path.dirname(_os.path.abspath(expanded)), exist_ok=True)
             self._db = SqliteBackend(expanded)
             self._db.open()
+            # Reload text index from previous session so hm_retrieve/hm_recall
+            # and all autonomous tools work immediately after restart.
+            for entry in self._db.load_claims_meta():
+                self._claims.append(entry)
 
     # ---- construction --------------------------------------------------
     @classmethod
@@ -152,6 +156,11 @@ class HyperMindClient:
         if ttl_days is not None:
             claim_entry["ttl_days"] = ttl_days
         self._claims.append(claim_entry)
+        if self._db is not None:
+            try:
+                self._db.append_claim_meta(claim_entry)
+            except Exception:
+                pass
         parents = [p for p in (cites, corroborates) if p is not None]
         if parents:
             self._citation_graph.add(kid, parents)

{hypermind-1.4.7 → hypermind-1.4.8}/src/hypermind/integrations/mcp_tools.py

@@ -1985,15 +1985,25 @@ def register_hypermind_tools(
                     "feature": "relata",
                     "status": "degraded",
                     "detail": (
-                        "No durable ledger — claims are in-process only (lost on restart). "
-                        "hm_retrieve uses lexical scan; hm_related cannot traverse the citation graph."
+                        "RelataDB not connected — BM25 hybrid search, graph traversal, "
+                        "and cross-namespace federation are limited. "
+                        "Claims persist locally via SQLite. "
+                        "RelataDB unlocks the full knowledge graph. → https://www.relatadb.dev"
                     ),
-                    "affects": ["hm_retrieve", "hm_related", "hm_research_start", "hm_learn"],
+                    "affects": [
+                        "hm_retrieve (BM25)",
+                        "hm_related (graph)",
+                        "hm_research_start",
+                        "hm_federate (cross-ns)",
+                    ],
                     "fix": (
-                        "1. Deploy RelataDB:  bash deploy/relata-serve.sh\n"
-                        "2. Add to ~/.hypermind/env:\n"
-                        "   RELATA_URL=http://localhost:5432\n"
-                        "3. Restart hmctl mcp serve"
+                        "RelataDB is the recommended durable backend for production use.\n"
+                        "Docs + cloud signup: https://www.relatadb.dev\n\n"
+                        "Self-hosted quick start:\n"
+                        "  bash deploy/relata-serve.sh\n"
+                        "Then add to ~/.hypermind/env:\n"
+                        "  RELATA_URL=http://localhost:5432\n"
+                        "  # Restart:  hmctl mcp serve"
                     ),
                 }
             )
@@ -2023,14 +2033,17 @@ def register_hypermind_tools(
                 }
             )
 
-        # SQLite local cache
-        if db_path:
+        # SQLite local cache — check actual client._db, not just env var
+        # (auto-activated at ~/.hypermind/cache.db when RELATA_URL is unset)
+        active_db = getattr(client, "_db", None)
+        active_db_path = getattr(active_db, "path", None) or db_path
+        if active_db is not None or db_path:
             features.append(
                 {
                     "feature": "sqlite_cache",
                     "status": "ok",
-                    "detail": db_path,
-                    "affects": ["hm_retrieve (persistent across restarts without Relata)"],
+                    "detail": f"Durable local storage at {active_db_path or '~/.hypermind/cache.db'} — claims persist across restarts.",
+                    "affects": ["hm_retrieve", "hm_recall"],
                 }
             )
         else:
@@ -2442,7 +2455,13 @@ def build_mcp_server(
     from hypermind.mcp.provenance import compute_cap_token_root
 
     relata_url = os.environ.get("RELATA_URL")
-    db_path = os.environ.get("HYPERMIND_DB")
+    # Auto-activate SQLite when neither RELATA_URL nor HYPERMIND_DB is set —
+    # gives durable local storage out of the box without any config.
+    # Disabled in test environments via HYPERMIND_NO_ENV_FILE=1 (conftest).
+    _no_env = os.environ.get("HYPERMIND_NO_ENV_FILE") == "1"
+    db_path = os.environ.get("HYPERMIND_DB") or (
+        None if (relata_url or _no_env) else os.path.expanduser("~/.hypermind/cache.db")
+    )
     population_name = os.environ.get("HYPERMIND_POPULATION")
     client = HyperMindClient.sandbox(
         swarm=swarm,

{hypermind-1.4.7 → hypermind-1.4.8}/src/hypermind/storage/sqlite.py

@@ -58,6 +58,16 @@ CREATE TABLE IF NOT EXISTS claims (
 );
 CREATE INDEX IF NOT EXISTS idx_claims_seq ON claims(seq);
 
+CREATE TABLE IF NOT EXISTS claims_meta (
+    kid BLOB PRIMARY KEY,
+    text TEXT NOT NULL,
+    topic TEXT NOT NULL,
+    confidence REAL NOT NULL,
+    author BLOB,
+    published_at_ms INTEGER,
+    ttl_days INTEGER
+);
+
 CREATE TABLE IF NOT EXISTS disputes (
     claim_kid BLOB PRIMARY KEY,
     payload BLOB NOT NULL,
@@ -145,6 +155,54 @@ class SqliteBackend:
             )
             self._next_seq += 1
 
+    def append_claim_meta(self, entry: dict) -> None:
+        """Persist the text/topic/confidence index entry alongside the wire claim."""
+        kid = bytes(entry["kid"]) if isinstance(entry["kid"], (bytes, bytearray)) else entry["kid"]
+        author = entry.get("author")
+        if isinstance(author, (bytes, bytearray)):
+            author = bytes(author)
+        with self._lock:
+            conn = self._require()
+            conn.execute(
+                "INSERT OR IGNORE INTO claims_meta "
+                "(kid, text, topic, confidence, author, published_at_ms, ttl_days) "
+                "VALUES (?, ?, ?, ?, ?, ?, ?)",
+                (
+                    kid,
+                    entry.get("text", ""),
+                    entry.get("topic", "default"),
+                    float(entry.get("confidence", 0.7)),
+                    author,
+                    entry.get("published_at_ms"),
+                    entry.get("ttl_days"),
+                ),
+            )
+
+    def load_claims_meta(self) -> list[dict]:
+        """Load the text index for rebuilding _claims on startup."""
+        with self._lock:
+            conn = self._require()
+            rows = conn.execute(
+                "SELECT kid, text, topic, confidence, author, published_at_ms, ttl_days "
+                "FROM claims_meta ORDER BY rowid ASC"
+            ).fetchall()
+        result = []
+        for kid, text, topic, conf, author, pub_ms, ttl in rows:
+            entry: dict = {
+                "kid": bytes(kid),
+                "text": text,
+                "topic": topic,
+                "confidence": conf,
+            }
+            if author is not None:
+                entry["author"] = bytes(author)
+            if pub_ms is not None:
+                entry["published_at_ms"] = pub_ms
+            if ttl is not None:
+                entry["ttl_days"] = ttl
+            result.append(entry)
+        return result
+
     def load_claims(self) -> list[SignedStatement]:
         from hypermind.wire import SignedStatement
 

{hypermind-1.4.7 → hypermind-1.4.8}/tests/integrations/test_autonomous.py

@@ -339,3 +339,51 @@ async def test_hm_publish_claim_with_ttl():
         assert any(c.get("ttl_days") == 180 for c in client._claims)
     finally:
         await client.close()
+
+
+# ── SQLite persistence / auto-activate ──────────────────────────────────────
+
+
+def test_sqlite_claims_meta_roundtrip(tmp_path):
+    """append_claim_meta / load_claims_meta survive a close+reopen."""
+    from hypermind.storage.sqlite import SqliteBackend
+
+    db = SqliteBackend(str(tmp_path / "test.db"))
+    db.open()
+    entry = {
+        "kid": b"\x01" * 32,
+        "text": "SQLite roundtrip test",
+        "topic": "testing",
+        "confidence": 0.88,
+        "author": b"\x02" * 32,
+        "published_at_ms": 1_700_000_000_000,
+        "ttl_days": 365,
+    }
+    db.append_claim_meta(entry)
+    db.close()
+
+    db2 = SqliteBackend(str(tmp_path / "test.db"))
+    db2.open()
+    rows = db2.load_claims_meta()
+    db2.close()
+
+    assert len(rows) == 1
+    r = rows[0]
+    assert r["text"] == "SQLite roundtrip test"
+    assert r["topic"] == "testing"
+    assert abs(r["confidence"] - 0.88) < 1e-9
+    assert r["ttl_days"] == 365
+    assert r["published_at_ms"] == 1_700_000_000_000
+
+
+def test_sqlite_claims_meta_no_duplicate(tmp_path):
+    from hypermind.storage.sqlite import SqliteBackend
+
+    db = SqliteBackend(str(tmp_path / "test.db"))
+    db.open()
+    entry = {"kid": b"\xaa" * 32, "text": "dedup", "topic": "t", "confidence": 0.5}
+    db.append_claim_meta(entry)
+    db.append_claim_meta(entry)  # second insert should be ignored
+    rows = db.load_claims_meta()
+    db.close()
+    assert len(rows) == 1