hypermind 1.8.0__tar.gz → 1.8.2__tar.gz

{hypermind-1.8.0 → hypermind-1.8.2}/PKG-INFO

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

{hypermind-1.8.0 → hypermind-1.8.2}/deploy/docker-compose.yml

@@ -22,7 +22,7 @@ services:
     command: ["serve"]
     environment:
       - RELATA_ORG_MODE=lite
-      - RELATA_ACL_GRANT=HmClaim:read+write,HmDispute:read+write,HmReputation:read+write,HmTranscript:read+write
+      - RELATA_ACL_GRANT=HmClaim:read+write,HmDispute:read+write,HmReputation:read+write,HmTranscript:read+write,HmSkill:read+write
       - RELATA_STORE_MAX_RAM_MB=2048
     ports:
       - "9090:9090"

{hypermind-1.8.0 → hypermind-1.8.2}/deploy/relata-serve.sh

@@ -6,7 +6,7 @@ export RELATA_PROFILE=free
 export RELATA_BEARER_TOKEN="${RELATA_BEARER_TOKEN:-perftoken}"
 export RELATA_ADMIN_TOKEN="${RELATA_ADMIN_TOKEN:-perfadmin-perfto}"
 # grant the bearer principal read+write on the four Hm ledger types (boot-time)
-export RELATA_ACL_GRANT="HmClaim:read+write,HmDispute:read+write,HmReputation:read+write,HmTranscript:read+write"
+export RELATA_ACL_GRANT="HmClaim:read+write,HmDispute:read+write,HmReputation:read+write,HmTranscript:read+write,HmSkill:read+write"
 export RELATA_RATE_LIMIT_RPS=99999
 export RELATA_RATE_LIMIT_AUTH_FAIL_RPS=99999
 export RELATA_PORT="${RELATA_PORT:-8080}"

{hypermind-1.8.0 → hypermind-1.8.2}/docs/spec/20-swarm-intelligence.md

@@ -253,14 +253,69 @@ agent asserted what, when, and with what confidence — and whether it was right
 }
 ```
 
-## §20.7 Conformance
+## §20.7 Skill Evolution Loop
+
+**Classification: Original**
+
+The skill evolution loop is the mechanism by which an agent's repeated deliberation patterns
+are automatically promoted into reusable, executable skills — closing the learn→act→improve cycle
+without human intervention.
+
+### §20.7.1 Work History
+
+Every `Deliberator` maintains a rolling `_work_history` deque (max 500 entries). An entry
+`{"action": <ActionKind.value>, "topic": <str>}` is appended **before** each `_dispatch()` call,
+so failed attempts are recorded alongside successes.
+
+### §20.7.2 Auto-Promotion
+
+`SkillRegistry.auto_promote(history, store, min_repetitions=3)` scans work_history for
+`(action, topic)` pairs that appear at least `min_repetitions` times. For each qualifying pair:
+
+1. `topic` is sanitised: non-alphanumeric characters (except `._-`) are replaced with `_`,
+   truncated to 64 characters. This is a **security invariant** — raw topic strings MUST NOT
+   reach filesystem or registry key paths unsanitised.
+2. A `skill_id` of the form `<action>.<sanitised_topic>` is validated against the allowlist
+   `^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$`. Invalid ids are skipped with a warning log.
+3. A Python `async def run(agent, **kwargs)` body is generated from the per-`ActionKind`
+   template in `_SKILL_CODE_TEMPLATES` and written to `<skill_dir>/<skill_id>.md`
+   (YAML front-matter + fenced `python` block).
+4. The skill is immediately `exec()`'d and registered in the in-process `SkillRegistry` —
+   hot-loaded with no restart required.
+
+### §20.7.3 Checkpoint Integration
+
+`_NamespaceWorld.checkpoint_reputation()` invokes `auto_promote()` over the merged
+`work_history` of all agents in the world. Successfully promoted skill ids are recorded as
+`skill_evolved.<skill_id>` hypotheses in the `HypothesisBook`, providing an auditable
+chain of custody for every evolved capability.
+
+### §20.7.4 Skill Storage
+
+Skills are stored as `.md` files with YAML front-matter (`skill_id`, `description`, `tags`,
+`created_at`) and a single fenced `python` code block. `SkillFileStore` is the local
+filesystem fallback; a `RelataBackend` is used when available. Skills are auto-loaded from
+the backing store on `sandbox()` startup.
+
+### §20.7.5 Security Invariants
+
+| Invariant | Enforcement |
+|-----------|-------------|
+| No injection via topic | `_sanitise_topic()` in `skills.py` before any template fill |
+| No path traversal via skill_id | `_validate_skill_id()` allowlist on read **and** write |
+| No registry key poisoning | `_validate_skill_id()` called in `upsert_skill()` and `auto_promote()` |
+| No test cross-contamination | `reset_skill_registry` autouse fixture restores singleton state |
+
+## §20.8 Conformance
 
 A v1.0.0-conformant implementation MUST:
 
   * Pass `tests/test_swarm_iq.py` (Layer A).
   * Pass `tests/test_self_heal_cycle4.py` (cross-layer adversarial regressions).
   * Pass `tests/simlab/test_resolve_outcomes.py` (oracle feedback loop).
+  * Pass `tests/mind/test_skill_learning_pipeline.py` (skill evolution loop).
   * Provide `hmctl swarm-iq <namespace>` emitting `SwarmIQReport` JSON.
+  * Auto-promote skills after `min_repetitions` (default 3) without requiring a human gate.
 
 A v1.0.0-conformant implementation SHOULD:
 
@@ -270,8 +325,8 @@ A v1.0.0-conformant implementation SHOULD:
   * Provide `LookaheadPolicy` with the sandbox Beta WorldModel (Layer E).
   * Implement the oracle resolution endpoint (§20.6.2) for empirical validation.
 
-## §20.8 Standards-map entry
+## §20.9 Standards-map entry
 
 ```
-| §20 Swarm Intelligence | Original | hypermind.eval.swarm_iq + hypermind.mind.{roles,active,world_model} + hypermind.knowledge.swarm_memory + simlab.app._handle_resolve_outcomes | v1.0.0 |
+| §20 Swarm Intelligence | Original | hypermind.eval.swarm_iq + hypermind.mind.{roles,active,world_model,skills,deliberator} + hypermind.knowledge.swarm_memory + simlab.app._handle_resolve_outcomes | v1.0.0 |
 ```

hypermind-1.8.2/e2e_features_test.py

@@ -0,0 +1,402 @@
+#!/usr/bin/env python3
+"""
+End-to-end feature test: Skills lifecycle, storage persistence,
+MCP tool coverage, and world wiring.
+Run with: .venv/bin/python e2e_features_test.py
+"""
+import asyncio
+import json
+import os
+import sys
+import tempfile
+import textwrap
+
+HOST, PORT = "127.0.0.1", 8484
+PASS, FAIL, SKIP = "✓", "✗", "–"
+
+results: list[tuple[str, str, str]] = []
+
+
+def record(label: str, ok: bool | None, note: str = "") -> None:
+    sym = PASS if ok else (SKIP if ok is None else FAIL)
+    results.append((sym, label, note))
+    print(f"  {sym}  {label:<50} {note}")
+
+
+# ── MCP helpers ────────────────────────────────────────────────────────────
+
+async def raw_call(method: str, params: dict, timeout: float = 20.0) -> dict:
+    r, w = await asyncio.open_connection(HOST, PORT)
+    try:
+        init = json.dumps({"jsonrpc": "2.0", "id": 1, "method": "initialize",
+                           "params": {"protocolVersion": "1.0", "capabilities": {},
+                                      "clientInfo": {"name": "e2e", "version": "0"}}}) + "\n"
+        w.write(init.encode()); await w.drain()
+        await asyncio.wait_for(r.readline(), timeout=10)
+        call = json.dumps({"jsonrpc": "2.0", "id": 2, "method": method, "params": params}) + "\n"
+        w.write(call.encode()); await w.drain()
+        return json.loads(await asyncio.wait_for(r.readline(), timeout=timeout))
+    finally:
+        w.close()
+        try: await w.wait_closed()
+        except Exception: pass
+
+
+async def tool(name: str, args: dict | None = None, timeout: float = 20.0) -> tuple[bool, str]:
+    try:
+        resp = await raw_call("tools/call", {"name": name, "arguments": args or {}}, timeout)
+    except TimeoutError:
+        return False, f"TIMEOUT after {timeout}s"
+    if "error" in resp:
+        return False, resp["error"].get("message", "")[:120]
+    r = resp.get("result", {})
+    if r.get("isError"):
+        txt = (r.get("content") or [{}])[0].get("text", "")[:120]
+        return False, f"tool error: {txt}"
+    txt = (r.get("content") or [{}])[0].get("text", "")
+    return True, txt[:120]
+
+
+# ── 1. Skills lifecycle ─────────────────────────────────────────────────────
+
+def test_skills_lifecycle() -> None:
+    print("\n── 1. Skills lifecycle ─────────────────────────────────────────")
+
+    from hypermind.mind.skills import SkillFileStore, _parse_frontmatter, get_default_registry
+
+    with tempfile.TemporaryDirectory() as td:
+        store = SkillFileStore(td)
+
+        # 1a. frontmatter parser — .md format with fenced code block
+        text = "---\nskill_id: greet\ndescription: say hello\ntags: util\n---\n\n```python\nasync def run(name): return f'hello {name}'\n```\n"
+        meta, code = _parse_frontmatter(text)
+        record("frontmatter: skill_id parsed", meta.get("skill_id") == "greet")
+        record("frontmatter: code extracted", "async def run" in code)
+
+        # 1b. SkillFileStore upsert
+        store.upsert_skill("greet", code, "say hello", "util")
+        path = os.path.join(td, "greet.md")
+        record("SkillFileStore.upsert_skill writes file", os.path.exists(path))
+
+        # 1c. load_skills round-trips
+        rows = store.load_skills()
+        record("SkillFileStore.load_skills returns row", len(rows) == 1)
+        record("load_skills: skill_id correct", rows[0]["skill_id"] == "greet")
+        record("load_skills: code preserved", "async def run" in rows[0]["code"])
+
+        # 1d. get_skill point-lookup
+        r = store.get_skill("greet")
+        record("SkillFileStore.get_skill returns entry", r is not None)
+        record("get_skill: description correct", r and r["description"] == "say hello")
+        record("get_skill: miss returns None", store.get_skill("nonexistent") is None)
+
+        # 1e. load_from_backend into registry
+        reg = get_default_registry()
+        before = len(reg._skills)
+        loaded = reg.load_from_backend(store)
+        record("load_from_backend: count > 0", loaded >= 1)
+        record("load_from_backend: skill registered", "greet" in reg._skills or loaded >= 1)
+
+        # 1f. exec'd skill is callable
+        entry = reg._skills.get("greet")
+        if entry is not None:
+            record("registered skill has description", entry.description == "say hello")
+            record("registered skill is callable", callable(entry.fn))
+        else:
+            record("registered skill has description", None, "skill not found in registry")
+            record("registered skill is callable", None)
+
+        # 1g. second store — no frontmatter, uses filename as id
+        store2 = SkillFileStore(td)
+        bare_code = "def run(): return 42\n"
+        path2 = os.path.join(td, "bare.md")
+        with open(path2, "w") as fh:
+            fh.write(bare_code)
+        rows2 = store2.load_skills()
+        ids = {r["skill_id"] for r in rows2}
+        record("bare .md file uses filename as skill_id", "bare" in ids)
+
+
+# ── 2. hmctl skill CLI ──────────────────────────────────────────────────────
+
+def test_hmctl_skill_cli() -> None:
+    import subprocess
+    print("\n── 2. hmctl skill CLI ──────────────────────────────────────────")
+
+    with tempfile.TemporaryDirectory() as td:
+        skill_file = os.path.join(td, "my_skill.md")
+        with open(skill_file, "w") as fh:
+            fh.write("---\nskill_id: my_skill\ndescription: test skill\ntags: test\n---\n\n```python\nasync def run(): return 'ok'\n```\n")
+
+        env = {**os.environ, "HYPERMIND_SKILL_DIR": td, "HYPERMIND_NO_ENV_FILE": "1"}
+        # Override the default skill dir by patching via env — but SkillFileStore uses
+        # _DEFAULT_SKILL_DIR. Use a fresh temp skill dir for upload.
+        skill_dir = os.path.join(td, "skills")
+
+        # Upload
+        result = subprocess.run(
+            [".venv/bin/python", "-c",
+             f"""
+import sys; sys.path.insert(0, 'src')
+from hypermind.mind.skills import SkillFileStore, _parse_frontmatter
+text = open({skill_file!r}).read()
+meta, code = _parse_frontmatter(text)
+s = SkillFileStore({skill_dir!r})
+s.upsert_skill(meta['skill_id'], code, meta.get('description',''), meta.get('tags',''))
+rows = s.load_skills()
+print(rows[0]['skill_id'])
+"""],
+            capture_output=True, text=True, cwd="/Volumes/Workspace/code/hypermind-specs"
+        )
+        out = result.stdout.strip()
+        record("hmctl skill upload (via SkillFileStore)", out == "my_skill", out or result.stderr[:60])
+
+        # List
+        result2 = subprocess.run(
+            [".venv/bin/python", "-c",
+             f"""
+import sys; sys.path.insert(0, 'src')
+from hypermind.mind.skills import SkillFileStore
+rows = SkillFileStore({skill_dir!r}).load_skills()
+for r in rows: print(r['skill_id'])
+"""],
+            capture_output=True, text=True, cwd="/Volumes/Workspace/code/hypermind-specs"
+        )
+        record("hmctl skill list returns uploaded skill", "my_skill" in result2.stdout)
+
+        # Get
+        result3 = subprocess.run(
+            [".venv/bin/python", "-c",
+             f"""
+import sys; sys.path.insert(0, 'src')
+from hypermind.mind.skills import SkillFileStore
+r = SkillFileStore({skill_dir!r}).get_skill('my_skill')
+print(r['code'] if r else 'NOT FOUND')
+"""],
+            capture_output=True, text=True, cwd="/Volumes/Workspace/code/hypermind-specs"
+        )
+        record("hmctl skill get returns code", "async def run" in result3.stdout)
+
+
+# ── 3. Storage persistence wiring ──────────────────────────────────────────
+
+async def test_storage_persistence() -> None:
+    print("\n── 3. Storage persistence (sandbox + SQLite) ───────────────────")
+    import os
+
+    os.environ["HYPERMIND_NO_ENV_FILE"] = "1"
+
+    with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
+        db_path = f.name
+
+    try:
+        from hypermind.integrations.client import HyperMindClient
+
+        # Session 1: publish, open dispute, create TAL room
+        client1 = HyperMindClient.sandbox(db_path=db_path)
+        kid1 = await client1.publish("persistence test claim", topic="test")
+        record("sandbox: publish returns kid", isinstance(kid1, bytes) and len(kid1) == 32)
+
+        world1 = client1._primary._world
+        record("sandbox: world.storage wired to SQLite", world1.storage is not None)
+
+        # Check claim landed in world.sealed
+        record("sandbox: claim in world.sealed", kid1 in world1.sealed)
+
+        # TAL room
+        world1.tal.create_room("test-room", 0.0, client1._primary.keypair.kid)
+        record("TAL: room created", world1.tal.get_room("test-room") is not None)
+
+        # Hypothesis
+        world1.hypothesis_book.propose("h1", "test hypothesis", author="tester")
+        record("HypothesisBook: hypothesis added", world1.hypothesis_book.get("h1") is not None)
+
+        # Checkpoint (saves rep + TAL + hypotheses)
+        world1.checkpoint_reputation()
+        await client1.close()
+
+        # Session 2: reload from same db_path
+        client2 = HyperMindClient.sandbox(db_path=db_path)
+        world2 = client2._primary._world
+
+        # Claims restored into world.sealed
+        record("restart: claim restored to world.sealed", kid1 in world2.sealed)
+
+        # Citation graph rebuilt
+        n = client2._rebuild_citation_graph()
+        record("restart: citation graph rebuilt", n >= 0)
+
+        # TAL room restored
+        room2 = world2.tal.get_room("test-room")
+        record("restart: TAL room restored", room2 is not None)
+
+        # HypothesisBook restored
+        h = world2.hypothesis_book.get("h1")
+        record("restart: hypothesis restored", h is not None and h.statement == "test hypothesis")
+
+        await client2.close()
+
+    finally:
+        try: os.unlink(db_path)
+        except OSError: pass
+        os.environ.pop("HYPERMIND_NO_ENV_FILE", None)
+
+
+# ── 4. MCP tool smoke tests ─────────────────────────────────────────────────
+
+async def test_mcp_tools() -> None:
+    print("\n── 4. MCP tool smoke tests (live server :8484) ─────────────────")
+
+    # Basic tools that require no prior state
+    for name, args in [
+        ("hm_version",       {}),
+        ("hm_status",        {}),
+        ("hm_doctor",        {}),
+        ("hm_tools",         {}),
+        ("hm_agent_list",    {}),
+        ("hm_agents",        {}),
+        ("hm_reputation",    {}),
+        ("hm_reputation_show", {}),
+        ("hm_dispute_list",  {}),
+        ("hm_disputes",      {}),
+        ("hm_goal_status",   {}),
+        ("hm_hooks",         {}),
+        ("hm_pool_status",   {}),
+        ("hm_org_roster",    {"template": "city_at_war"}),
+        ("hm_list_templates", {}),
+        ("hm_population",    {}),
+    ]:
+        ok, note = await tool(name, args)
+        record(f"MCP: {name}", ok, note[:80] if not ok else "")
+
+    # Stateful tools — publish first
+    ok, note = await tool("hm_publish_claim", {"topic": "e2e", "text": "e2e test claim"})
+    record("MCP: hm_publish_claim", ok, note[:80] if not ok else "")
+    kid = None
+    if ok:
+        try: kid = json.loads(note).get("kid") or json.loads(note).get("claim_kid")
+        except Exception: pass
+
+    for name, args in [
+        ("hm_claims_list",   {"topic": "e2e"}),
+        ("hm_audit",         {"topic": "e2e"}),
+        ("hm_audit_export",  {"topic": "e2e", "format": "jsonl"}),
+        ("hm_stale",         {"topic": "e2e"}),
+        ("hm_recall",        {"query": "test", "topic": "e2e"}),
+        ("hm_retrieve",      {"query": "e2e", "topic": "e2e"}),
+        ("hm_session_summary", {}),
+        ("hm_agent_memory",  {"topic": "e2e"}),
+    ]:
+        ok, note = await tool(name, args)
+        record(f"MCP: {name}", ok, note[:80] if not ok else "")
+
+    if kid:
+        ok, note = await tool("hm_justify", {"claim_kid": kid})
+        record("MCP: hm_justify (with real kid)", ok, note[:80] if not ok else "")
+        ok, note = await tool("hm_related", {"claim_kid": kid})
+        record("MCP: hm_related (with real kid)", ok, note[:80] if not ok else "")
+
+    # Dispute lifecycle
+    dispute_id = None
+    if kid:
+        ok, note = await tool("hm_dispute_open", {"claim_kid": kid, "reason": "e2e", "topic": "e2e"})
+        record("MCP: hm_dispute_open", ok, note[:80] if not ok else "")
+        if ok:
+            try: dispute_id = json.loads(note).get("dispute_id") or json.loads(note).get("id")
+            except Exception: pass
+
+    # Ingest + learn + hypothesize (no LLM calls)
+    # hm_ingest needs a file inside the server's cwd (HYPERMIND_INGEST_ROOT default = cwd)
+    import os as _os
+    _ingest_path = _os.path.abspath("_e2e_ingest_tmp.txt")
+    with open(_ingest_path, "w") as _tf:
+        _tf.write("FROST threshold signing enables k-of-n")
+    ok, note = await tool("hm_ingest", {"path": _ingest_path, "topic": "e2e"}, timeout=20)
+    record("MCP: hm_ingest", ok, note[:80] if not ok else "")
+    try: _os.unlink(_ingest_path)
+    except OSError: pass
+
+    ok, note = await tool("hm_learn", {"text": "SCITT ledgers are append-only", "topic": "e2e"}, timeout=20)
+    record("MCP: hm_learn", ok, note[:80] if not ok else "")
+
+    ok, note = await tool("hm_hypothesis", {"hypothesis": "HyperMind uses RFC 6962 Merkle trees", "topic": "e2e"}, timeout=20)
+    record("MCP: hm_hypothesis", ok, note[:80] if not ok else "")
+
+    # LLM-heavy tools — short timeout, mark as skip on timeout (not failure)
+    for name, args in [
+        ("hm_scan_contradictions", {"topic": "e2e"}),
+        ("hm_calibration",   {"topic": "e2e"}),
+        ("hm_swarm_iq",      {"topic": "e2e"}),
+    ]:
+        ok, note = await tool(name, args, timeout=15)
+        if "TIMEOUT" in note:
+            record(f"MCP: {name}", None, "LLM call — needs live API key")
+        else:
+            record(f"MCP: {name}", ok, note[:80] if not ok else "")
+
+
+# ── 5. Skills in MCP context ────────────────────────────────────────────────
+
+async def test_mcp_skills() -> None:
+    print("\n── 5. Skills via MCP (hm_tools shows skill registry) ───────────")
+
+    ok, note = await tool("hm_tools", {})
+    record("MCP: hm_tools responds", ok)
+    if ok:
+        try:
+            data = json.loads(note)
+            # hm_tools returns tool listing — check it's structured
+            record("MCP: hm_tools returns structured data", isinstance(data, (dict, list)))
+        except Exception:
+            record("MCP: hm_tools returns structured data", None, "non-JSON response (ok)")
+
+    # Publish a cite chain to exercise citation graph
+    ok1, n1 = await tool("hm_publish_claim", {"topic": "skills-test", "text":"base claim for citations"})
+    if ok1:
+        try: base_kid = json.loads(n1).get("kid")
+        except Exception: base_kid = None
+        if base_kid:
+            ok2, n2 = await tool("hm_publish_cite", {
+                "text":"citing the base claim", "topic": "skills-test",
+                "cite_kids": [base_kid]
+            })
+            record("MCP: hm_publish_cite (citation graph)", ok2, n2[:80] if not ok2 else "")
+            ok3, n3 = await tool("hm_related", {"claim_kid": base_kid})
+            record("MCP: hm_related after cite", ok3, n3[:80] if not ok3 else "")
+        else:
+            record("MCP: hm_publish_cite (citation graph)", None, "no kid from publish")
+    else:
+        record("MCP: hm_publish_cite (citation graph)", None, "base publish failed")
+
+
+# ── main ────────────────────────────────────────────────────────────────────
+
+async def main() -> None:
+    print("=" * 70)
+    print("HyperMind end-to-end feature test")
+    print("=" * 70)
+
+    test_skills_lifecycle()
+    test_hmctl_skill_cli()
+    await test_storage_persistence()
+    await test_mcp_tools()
+    await test_mcp_skills()
+
+    passed = sum(1 for s, _, _ in results if s == PASS)
+    failed = sum(1 for s, _, _ in results if s == FAIL)
+    skipped = sum(1 for s, _, _ in results if s == SKIP)
+    total = len(results)
+
+    print("\n" + "=" * 70)
+    print(f"RESULT  {passed}/{total} passed  ({failed} failed, {skipped} skipped)")
+    print("=" * 70)
+    if failed:
+        print("\nFailed:")
+        for s, label, note in results:
+            if s == FAIL:
+                print(f"  ✗  {label}  {note}")
+    sys.exit(0 if failed == 0 else 1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{hypermind-1.8.0 → hypermind-1.8.2}/examples/README.md

@@ -114,6 +114,7 @@ production-shaped pilots — they explain *how a community forms* and
 |---|---|
 | [`scenario_vouch_chain.py`](scenario_vouch_chain.py) | How does a community grow? Newcomer → vouched → established → voucher. The 5%-of-α vouch cap explained explicitly. |
 | [`scenario_learning_loop.py`](scenario_learning_loop.py) | What's the full feedback loop? `working_memory` → `checkpoint()` → cited by peers → reputation reward. |
+| [`scenario_skill_evolution.py`](scenario_skill_evolution.py) | How do repeated deliberation patterns become reusable skills? Deliberator work_history → `auto_promote()` → hot-loaded skill registry — no human gate required. |
 | [`scenario_cross_namespace_federation.py`](scenario_cross_namespace_federation.py) | How do you query expertise that lives in *another* namespace without silently merging trust? Bridge-mediated federated consult. |
 
 ### Security mechanics & dispute lifecycle

{hypermind-1.8.0 → hypermind-1.8.2}/pyproject.toml

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

{hypermind-1.8.0 → hypermind-1.8.2}/src/hmctl/cli.py

@@ -496,6 +496,7 @@ def doctor(check_clock: bool, strict_pq: bool) -> None:
     for k, v in result.items():
         table.add_row(k, v)
     console.print(table)
+    console.print("\n[dim]To use HyperMind in Claude Desktop:  [bold]hmctl mcp install[/]  then restart Claude.[/]")
 
 
 def _doctor_check_clock() -> None:
@@ -3152,5 +3153,93 @@ def webhook_serve_cmd(port: int, secret: str, swarm: int) -> None:
     asyncio.run(_run())
 
 
+@main.group()
+def skill() -> None:
+    """Manage persistent skills (Relata if configured, else ~/.hypermind/skills/)."""
+
+
+def _skill_store() -> object:
+    """Return the active skill store: RelataBackend if RELATA_URL set, else SkillFileStore."""
+    import os
+
+    from hypermind.mind.skills import SkillFileStore
+
+    relata_url = os.environ.get("RELATA_URL")
+    if relata_url:
+        from hypermind.storage.relata import RelataBackend
+
+        b = RelataBackend(relata_url)
+        b.open()
+        return b
+    return SkillFileStore()
+
+
+@skill.command("upload")
+@click.argument("path", type=click.Path(exists=True))
+def skill_upload(path: str) -> None:
+    """Upload a .skill file to Relata (if configured) or ~/.hypermind/skills/."""
+    import os
+
+    from hypermind.mind.skills import _parse_frontmatter
+
+    text = open(path).read()
+    meta, code = _parse_frontmatter(text)
+    skill_id = meta.get("skill_id") or os.path.splitext(os.path.basename(path))[0]
+    description = meta.get("description", "")
+    tags = meta.get("tags", "")
+    store = _skill_store()
+    store.upsert_skill(skill_id, code, description, tags)
+    dest = getattr(store, "directory", os.environ.get("RELATA_URL", "relata"))
+    click.echo(f"uploaded skill {skill_id!r} → {dest}")
+
+
+@skill.command("list")
+@click.option("--candidates", is_flag=True, default=False,
+              help="Show skill candidates surfaced from deliberator work history.")
+def skill_list(candidates: bool) -> None:
+    """List skills from Relata (if configured) or ~/.hypermind/skills/.
+
+    With --candidates: show skill candidates logged in the agent's hypothesis book
+    (entries prefixed with 'skill_candidate.') instead of installed skills.
+    """
+    if candidates:
+        import os as _os
+        _os.environ.setdefault("HYPERMIND_NO_ENV_FILE", "1")
+        from hypermind.integrations.client import HyperMindClient
+        client = HyperMindClient.sandbox()
+        book = getattr(getattr(client._primary, "_world", None), "hypothesis_book", None)
+        if book is None:
+            click.echo("no hypothesis book available")
+            return
+        found = False
+        for record in book.to_records():
+            if record.get("id", "").startswith("skill_candidate."):
+                found = True
+                status = record.get("status", "open")
+                click.echo(f"{record['id']:<50} [{status}]  {record.get('statement', '')[:80]}")
+        if not found:
+            click.echo("no skill candidates yet — run agents with a Deliberator to accumulate work history")
+        return
+    rows = _skill_store().load_skills()
+    if not rows:
+        click.echo("no skills stored")
+        return
+    for r in rows:
+        click.echo(f"{r['skill_id']:<30} {r['description']}")
+
+
+@skill.command("get")
+@click.argument("skill_id")
+def skill_get(skill_id: str) -> None:
+    """Print skill code from Relata (if configured) or ~/.hypermind/skills/."""
+    store = _skill_store()
+    r = store.get_skill(skill_id)
+    if r is not None:
+        click.echo(r["code"])
+        return
+    click.echo(f"skill {skill_id!r} not found", err=True)
+    raise SystemExit(1)
+
+
 if __name__ == "__main__":  # pragma: no cover
     main()