hypermind 1.8.2__tar.gz → 1.8.3__tar.gz

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

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hypermind"
-version = "1.8.2"
+version = "1.8.3"
 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.2 → hypermind-1.8.3}/src/hmctl/cli.py

@@ -496,7 +496,9 @@ 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.[/]")
+    console.print(
+        "\n[dim]To use HyperMind in Claude Desktop:  [bold]hmctl mcp install[/]  then restart Claude.[/]"
+    )
 
 
 def _doctor_check_clock() -> None:
@@ -3159,7 +3161,11 @@ def skill() -> None:
 
 
 def _skill_store() -> object:
-    """Return the active skill store: RelataBackend if RELATA_URL set, else SkillFileStore."""
+    """Return the active skill store: RelataBackend if RELATA_URL set, else SkillFileStore.
+
+    #793: RelataBackend.open() is wrapped in a try/except so a misconfigured
+    RELATA_URL produces a clear error rather than an unhandled exception.
+    """
     import os
 
     from hypermind.mind.skills import SkillFileStore
@@ -3169,7 +3175,13 @@ def _skill_store() -> object:
         from hypermind.storage.relata import RelataBackend
 
         b = RelataBackend(relata_url)
-        b.open()
+        try:
+            b.open()
+        except Exception as exc:
+            raise click.ClickException(
+                f"Could not connect to Relata at {relata_url!r}: {exc}. "
+                "Check RELATA_URL and RELATA_BEARER_TOKEN, or unset RELATA_URL to use local storage."
+            ) from exc
         return b
     return SkillFileStore()
 
@@ -3180,11 +3192,17 @@ 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
+    from hypermind.mind.skills import _parse_frontmatter, _validate_skill_id
 
-    text = open(path).read()
+    # #808: use explicit utf-8 encoding instead of platform default.
+    text = open(path, encoding="utf-8").read()
     meta, code = _parse_frontmatter(text)
     skill_id = meta.get("skill_id") or os.path.splitext(os.path.basename(path))[0]
+    # #751: validate skill_id from frontmatter before passing to the store.
+    try:
+        _validate_skill_id(skill_id)
+    except ValueError as exc:
+        raise click.ClickException(f"Invalid skill_id {skill_id!r}: {exc}") from exc
     description = meta.get("description", "")
     tags = meta.get("tags", "")
     store = _skill_store()
@@ -3194,8 +3212,12 @@ def skill_upload(path: str) -> None:
 
 
 @skill.command("list")
-@click.option("--candidates", is_flag=True, default=False,
-              help="Show skill candidates surfaced from deliberator work history.")
+@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/.
 
@@ -3204,8 +3226,10 @@ def skill_list(candidates: bool) -> None:
     """
     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:
@@ -3218,7 +3242,9 @@ def skill_list(candidates: bool) -> None:
                 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")
+            click.echo(
+                "no skill candidates yet — run agents with a Deliberator to accumulate work history"
+            )
         return
     rows = _skill_store().load_skills()
     if not rows:

{hypermind-1.8.2 → hypermind-1.8.3}/src/hypermind/agent.py

@@ -16,11 +16,13 @@ This class implements:
 from __future__ import annotations
 
 import asyncio
+import collections
 import hashlib
 import json
 import logging
 import os
 import secrets
+import threading
 import time
 import warnings
 from collections.abc import AsyncIterator, Awaitable, Callable, Sequence
@@ -106,6 +108,10 @@ ClaimType = Literal[
 # A caller that passes panel_size > MAX_PANEL_SIZE is silently clamped; a
 # warning is emitted so operators can see the clamping in logs.
 MAX_PANEL_SIZE: int = 50
+# Maximum number of entries in _NamespaceWorld.panel_votes before LRU eviction (#770).
+_PANEL_VOTES_MAX_ENTRIES: int = 1000
+# Maximum number of claims to restore from storage at startup (#753).
+_RESTORE_CLAIMS_MAX: int = int(os.environ.get("HYPERMIND_RESTORE_CLAIMS_MAX", "50000"))
 
 _logger = logging.getLogger(__name__)
 
@@ -247,15 +253,20 @@ class _DraftEntry:
 # Process-global registry of in-process namespaces (ROADMAP §0.4.1).
 # Used by cross-namespace federated CONSULT to discover sibling worlds
 # without callers having to thread `_NamespaceWorld` references manually.
+# Guarded by _NAMESPACE_REGISTRY_LOCK to prevent data races on concurrent
+# sandbox/testbed construction in multi-threaded callers (#803).
 _NAMESPACE_REGISTRY: dict[bytes, _NamespaceWorld] = {}
+_NAMESPACE_REGISTRY_LOCK: threading.Lock = threading.Lock()
 
 
 def _register_namespace(world: _NamespaceWorld) -> None:
-    _NAMESPACE_REGISTRY[bytes(world.namespace_id)] = world
+    with _NAMESPACE_REGISTRY_LOCK:
+        _NAMESPACE_REGISTRY[bytes(world.namespace_id)] = world
 
 
 def _lookup_namespace(namespace_id: bytes) -> _NamespaceWorld | None:
-    return _NAMESPACE_REGISTRY.get(bytes(namespace_id))
+    with _NAMESPACE_REGISTRY_LOCK:
+        return _NAMESPACE_REGISTRY.get(bytes(namespace_id))
 
 
 @dataclass
@@ -279,7 +290,9 @@ class _NamespaceWorld:
     # (ROADMAP §0.3.2). Map claim_kid → list of (voter_kid, vote_bool,
     # topic). Used by `oracle_resolve(..., backprop=True)` to reward
     # voters who agreed with the oracle.
-    panel_votes: dict[Kid, list[tuple[bytes, bool, str]]] = field(default_factory=dict)
+    # Capped at _PANEL_VOTES_MAX_ENTRIES via LRU eviction so resolved
+    # dedup keys don't grow unboundedly (#770).
+    panel_votes: collections.OrderedDict = field(default_factory=collections.OrderedDict)
     # rooms map name → {min reputation to publish, members}
     rooms: dict[str, dict[str, Any]] = field(default_factory=dict)
     #: Signalled whenever a new dispute is added to self.disputes.
@@ -438,9 +451,31 @@ class _NamespaceWorld:
 
         Idempotent: safe to call multiple times; later calls are no-ops
         once state is materialised.
+
+        The world starts in a degraded state when restore fails — never silently
+        broken (#744, #670). Each failure path logs at ERROR level and emits a
+        structured warning so operators can detect partial-restore with
+        ``hmctl doctor``.
         """
+        # --- Phase 1: Claims (bounded iteration, #753) ---
+        _claims_restored = 0
         try:
             for stmt in self.storage.load_claims():
+                if _claims_restored >= _RESTORE_CLAIMS_MAX:
+                    _logger.error(
+                        "restore_from_storage: hit HYPERMIND_RESTORE_CLAIMS_MAX=%d; "
+                        "stopping claim restore early. Run hmctl doctor to diagnose.",
+                        _RESTORE_CLAIMS_MAX,
+                    )
+                    self.recorder.emit(
+                        namespace=self.namespace,
+                        agent_id="world",
+                        event_type="restore_claims_truncated",
+                        severity="warning",
+                        rule_id="HM-RESTORE-CAP-001",
+                        claims_max=_RESTORE_CLAIMS_MAX,
+                    )
+                    break
                 # Verify signature before admitting to sealed ledger.
                 # from_bytes() enforces A-ALG-BOUND + canonical encoding;
                 # verify() additionally checks the Ed25519/composite signature
@@ -461,24 +496,86 @@ class _NamespaceWorld:
                     )
                     continue
                 self.sealed.setdefault(stmt.kid, stmt)
+                _claims_restored += 1
+        except (OSError, ValueError, KeyError, RuntimeError) as _exc:
+            _logger.error(
+                "restore_from_storage: claim restore failed after %d claims: %r. "
+                "World will start with partial claims. Run hmctl doctor.",
+                _claims_restored,
+                _exc,
+            )
+            self.recorder.emit(
+                namespace=self.namespace,
+                agent_id="world",
+                event_type="restore_claims_failed",
+                severity="error",
+                rule_id="HM-RESTORE-ERR-001",
+                claims_restored=_claims_restored,
+                error=str(_exc),
+            )
+
+        # --- Phase 2: Disputes ---
+        try:
             for kid, dispute in self.storage.load_disputes().items():
                 self.disputes.setdefault(kid, dispute)
+        except (OSError, ValueError, KeyError, RuntimeError) as _exc:
+            _logger.error(
+                "restore_from_storage: dispute restore failed: %r. "
+                "World will start with no disputes. Run hmctl doctor.",
+                _exc,
+            )
+
+        # --- Phase 3: Reputation ---
+        try:
             for kid, topic, alpha, beta, last_ms in self.storage.load_reputation():
                 p = self.reputation._get(kid, topic)
                 p.alpha = alpha
                 p.beta = beta
                 p.last_update_ms = last_ms
-            # Restore TAL state
-            if self.tal is not None:
+        except (OSError, ValueError, KeyError, RuntimeError) as _exc:
+            _logger.error(
+                "restore_from_storage: reputation restore failed: %r. "
+                "World will start with default priors. Run hmctl doctor.",
+                _exc,
+            )
+
+        # --- Phase 4: TAL state (#762, #716) — outside claim iterator, always runs ---
+        if self.tal is not None:
+            try:
                 tal_json = self.storage.get_kv("tal")
                 if tal_json:
                     import json as _json
 
                     from hypermind.tal import TAL as _TAL
 
-                    self.tal = _TAL._from_dict(_json.loads(tal_json), self.reputation)
-            # Restore HypothesisBook
-            if self.hypothesis_book is not None:
+                    _tal_data = _json.loads(tal_json)
+                    # Basic schema validation before calling _from_dict to prevent
+                    # corrupt KV blob from corrupting world state (#716).
+                    if not isinstance(_tal_data, dict):
+                        raise ValueError(
+                            f"TAL KV blob is not a dict (got {type(_tal_data).__name__})"
+                        )
+                    if "rooms" not in _tal_data and "vouch_log" not in _tal_data:
+                        raise ValueError("TAL KV blob missing expected keys 'rooms'/'vouch_log'")
+                    self.tal = _TAL._from_dict(_tal_data, self.reputation)
+            except (OSError, ValueError, KeyError, RuntimeError) as _exc:
+                _logger.error(
+                    "restore_from_storage: TAL restore failed: %r. "
+                    "TAL will start empty. Run hmctl doctor.",
+                    _exc,
+                )
+                self.recorder.emit(
+                    namespace=self.namespace,
+                    agent_id="world",
+                    event_type="restore_tal_failed",
+                    severity="error",
+                    rule_id="HM-RESTORE-TAL-001",
+                    error=str(_exc),
+                )
+
+        # --- Phase 5: HypothesisBook (#768) — outside claim iterator, always runs ---
+        if self.hypothesis_book is not None:
+            try:
                 hyp_json = self.storage.get_kv("hypotheses")
                 if hyp_json:
                     import json as _json
@@ -486,13 +583,80 @@ class _NamespaceWorld:
                     from hypermind.orgs.hypothesis import HypothesisBook as _HB
 
                     self.hypothesis_book = _HB.from_records(_json.loads(hyp_json))
-            # Restore BetaWorldModel for each deliberator in the namespace
-            # (best-effort: deliberators are created lazily after this point)
-        except Exception:
-            # Restore is best-effort: a corrupt row should not prevent
-            # process startup. Operators should run `hmctl doctor` to
-            # diagnose. Real production code paths would log here.
-            pass
+            except (OSError, ValueError, KeyError, RuntimeError) as _exc:
+                _logger.error(
+                    "restore_from_storage: HypothesisBook restore failed: %r. "
+                    "HypothesisBook will start empty. Run hmctl doctor.",
+                    _exc,
+                )
+
+        # --- Phase 6: BetaWorldModel (#680) — best-effort, deliberators created lazily ---
+        try:
+            world_kv_raw = self.storage.get_kv("world_state")
+            if world_kv_raw:
+                import json as _json
+
+                _world_kv = _json.loads(world_kv_raw)
+                if isinstance(_world_kv, dict) and "beta_world_model" in _world_kv:
+                    try:
+                        from hypermind.mind.world_model import BetaWorldModel as _BWM
+
+                        _bwm = _BWM()
+                        _bwm.import_state(_world_kv["beta_world_model"])
+                        # Attach to any existing deliberators (best-effort).
+                        for _agent in self.agents.values():
+                            _delib = getattr(_agent, "_deliberator", None)
+                            if _delib is not None and hasattr(_delib, "world_model"):
+                                _delib.world_model = _bwm
+                    except Exception as _bwm_exc:
+                        _logger.error(
+                            "restore_from_storage: BetaWorldModel import_state failed: %r",
+                            _bwm_exc,
+                        )
+        except (OSError, ValueError, KeyError, RuntimeError) as _exc:
+            _logger.error(
+                "restore_from_storage: world_state KV restore failed: %r. "
+                "Continuing with empty state. Run hmctl doctor.",
+                _exc,
+            )
+
+        # --- Phase 7: Brier calibration (#669) ---
+        try:
+            _cal_json = self.storage.get_kv("calibration")
+            if _cal_json:
+                import json as _json
+
+                _cal_data = _json.loads(_cal_json)
+                if isinstance(_cal_data, dict):
+                    # Restore calibration weights.
+                    for _kid_hex, _weight in (_cal_data.get("calibration") or {}).items():
+                        try:
+                            self.reputation._calibration[bytes.fromhex(_kid_hex)] = float(_weight)
+                        except Exception:
+                            pass
+                    # Restore Brier summaries into the tracker via restore_calibration().
+                    _bt_summaries = _cal_data.get("brier_summaries") or []
+                    if _bt_summaries:
+                        try:
+                            _bt = self.reputation.brier_tracker
+                            for _s in _bt_summaries:
+                                _bt.restore_calibration(
+                                    agent_kid=bytes.fromhex(_s["kid"]),
+                                    topic=str(_s["topic"]),
+                                    brier_mean=float(_s["brier_mean"]),
+                                    n_obs=int(_s["n_obs"]),
+                                )
+                        except Exception as _bt_exc:
+                            _logger.error(
+                                "restore_from_storage: BrierScoreTracker restore failed: %r",
+                                _bt_exc,
+                            )
+        except (OSError, ValueError, KeyError, RuntimeError) as _exc:
+            _logger.error(
+                "restore_from_storage: calibration restore failed: %r. "
+                "Continuing with default calibration weights.",
+                _exc,
+            )
 
     def persist_claim(self, stmt: SignedStatement) -> None:
         """Mirror a sealed claim to durable storage if attached. Best-effort.
@@ -547,13 +711,18 @@ class _NamespaceWorld:
     def checkpoint_reputation(self) -> None:
         """Snapshot every Beta posterior to storage. Call before close().
 
+        Acquires the reputation lock before reading _posteriors to prevent
+        races with concurrent record_outcome/vouch calls (#764).
+
         See :meth:`persist_claim` for the observability contract.
         """
         if self.storage is None:
             return
+        # Acquire the reputation lock before reading _posteriors (#764).
         rows: list[tuple[bytes, str, float, float, int]] = []
-        for (kid, topic), p in self.reputation._posteriors.items():
-            rows.append((kid, topic, p.alpha, p.beta, p.last_update_ms))
+        with self.reputation._lock:
+            for (kid, topic), p in self.reputation._posteriors.items():
+                rows.append((kid, topic, p.alpha, p.beta, p.last_update_ms))
         try:
             self.storage.snapshot_reputation(rows)
         except Exception as exc:
@@ -592,12 +761,80 @@ class _NamespaceWorld:
                 "hypermind_storage_write_failures_total",
                 op="checkpoint_world",
             )
+        # Snapshot Brier calibration data so calibration weights survive restart (#669).
+        try:
+            import json as _json
+
+            _cal = getattr(self.reputation, "_calibration", None)
+            _bt = getattr(self.reputation, "_brier_tracker", None)
+            _cal_snap: dict = {}
+            if _cal:
+                # Calibration weights: {kid_hex → float}
+                _cal_snap["calibration"] = {
+                    (k.hex() if isinstance(k, (bytes, bytearray)) else k): float(v)
+                    for k, v in _cal.items()
+                }
+            if _bt is not None:
+                # BrierScoreTracker._history: {(kid_bytes, topic) → list[BrierEntry]}.
+                # Serialize as compact per-key summaries (brier_mean + n_obs) so restore
+                # can call restore_calibration() without keeping the full observation log.
+                _bt_summaries: list[dict] = []
+                for (_kid_b, _topic), _entries in getattr(_bt, "_history", {}).items():
+                    if not _entries:
+                        continue
+                    try:
+                        _mean_b = sum(e.brier_score for e in _entries) / len(_entries)
+                        _bt_summaries.append(
+                            {
+                                "kid": (
+                                    _kid_b.hex()
+                                    if isinstance(_kid_b, (bytes, bytearray))
+                                    else str(_kid_b)
+                                ),
+                                "topic": str(_topic),
+                                "brier_mean": float(_mean_b),
+                                "n_obs": len(_entries),
+                            }
+                        )
+                    except Exception:
+                        pass
+                if _bt_summaries:
+                    _cal_snap["brier_summaries"] = _bt_summaries
+            if _cal_snap:
+                self.storage.set_kv("calibration", _json.dumps(_cal_snap))
+        except Exception as exc:
+            _logger.warning("checkpoint_reputation: failed to persist calibration data: %r", exc)
+        # Snapshot TransparencyService Merkle tree root (#649).
+        try:
+            import json as _json
+
+            _ts_root = getattr(self.ts, "root", None)
+            _ts_size = getattr(self.ts, "tree_size", None)
+            _ts_leaves = getattr(self.ts, "_leaves", None)
+            if _ts_root is not None:
+                _ts_snap: dict = {
+                    "root": _ts_root.hex() if isinstance(_ts_root, bytes) else _ts_root
+                }
+                if _ts_size is not None:
+                    _ts_snap["tree_size"] = _ts_size
+                if _ts_leaves is not None:
+                    # Store raw leaf bytes (hex-encoded) so they can be replayed.
+                    _ts_snap["leaves"] = [
+                        lf.hex() if isinstance(lf, (bytes, bytearray)) else lf for lf in _ts_leaves
+                    ]
+                self.storage.set_kv("ts_merkle", _json.dumps(_ts_snap))
+        except Exception as exc:
+            _logger.warning(
+                "checkpoint_reputation: failed to persist TransparencyService Merkle state: %r",
+                exc,
+            )
         # Auto-promote repeated (action, topic) patterns from deliberator work_history
         # directly into live skills — no human gate. Patterns meeting min_repetitions
         # get a generated .md file written to the skill store and are hot-loaded into
         # the registry immediately so subsequent ticks can invoke them by name.
         try:
             import hypermind.mind.skills as _skills_mod
+
             _history: list[dict] = []
             for _agent in self.agents.values():
                 _delib = getattr(_agent, "_deliberator", None)
@@ -617,6 +854,18 @@ class _NamespaceWorld:
                             f"Skill auto-promoted from work history: {_sid}",
                             author="system",
                         )
+                # #810: emit observability event for each promoted skill so
+                # monitors and tests can observe auto_promote firing.
+                for _sid in _promoted:
+                    try:
+                        self.recorder.emit(
+                            namespace=self.namespace,
+                            agent_id="world",
+                            event_type="skill_promoted",
+                            skill_id=_sid,
+                        )
+                    except Exception:
+                        pass  # never let recorder failure abort evolution
         except Exception:
             pass  # evolution is best-effort, never block checkpoint
 
@@ -1310,13 +1559,17 @@ class HyperMindAgent:
             if not self._world.agents:
                 # Last agent out — flush reputation before dropping the world
                 # when non-default posteriors exist (avoids no-op writes).
+                # checkpoint_reputation() does synchronous file I/O; wrap in
+                # asyncio.to_thread() so we don't block the event loop (#682).
                 if self._world.storage is not None:
                     rep = self._world.reputation
                     if getattr(rep, "_posteriors", None):
-                        self._world.checkpoint_reputation()
+                        _world_ref = self._world
+                        await asyncio.to_thread(_world_ref.checkpoint_reputation)
                 # Stop the proactive decay background task (#519).
                 self._world.stop_decay_task()
-                _NAMESPACE_REGISTRY.pop(bytes(self._world.namespace_id), None)
+                with _NAMESPACE_REGISTRY_LOCK:
+                    _NAMESPACE_REGISTRY.pop(bytes(self._world.namespace_id), None)
         self._closed = True
 
     # ---- placement (T5-02) ---------------------------------------------
@@ -1384,6 +1637,22 @@ class HyperMindAgent:
 
         self._require_cap("publish_claim", topic=topic)
 
+        # #733: Mediator role (publishes_primary=False) must not publish primary claims.
+        # Synthesis and oracle_resolution claim types are permitted; raw primary claims
+        # are the footgun that this gate closes.
+        _PRIMARY_BLOCKED_ROLES: frozenset[str] = frozenset({"mediator"})
+        if self.role in _PRIMARY_BLOCKED_ROLES and claim_type not in (
+            "synthesis",
+            "oracle_resolution",
+        ):
+            from hypermind.errors import AuthError as _AuthError
+
+            raise _AuthError(
+                f"agent role {self.role!r} cannot publish primary claims "
+                f"(claim_type={claim_type!r}); only synthesis claims are permitted.",
+                failed_caveat="claim_type",
+            )
+
         # MIND-009: validate leverage_factor if present — must be in [0.0, 1.0].
         if isinstance(payload, dict) and "leverage_factor" in payload:
             lf = payload["leverage_factor"]
@@ -2926,9 +3195,16 @@ class HyperMindAgent:
         if self._world is None:
             raise RuntimeError("record_panel_vote() requires a world")
         topic = topic or (self.rooms[0] if self.rooms else "default")
-        self._world.panel_votes.setdefault(claim_kid, []).append(
-            (bytes(voter_kid), bool(vote), topic)
-        )
+        pv = self._world.panel_votes
+        if claim_kid not in pv:
+            # Evict oldest entry when cap is reached (LRU — OrderedDict insertion order).
+            while len(pv) >= _PANEL_VOTES_MAX_ENTRIES:
+                pv.popitem(last=False)
+            pv[claim_kid] = []
+        else:
+            # Move to end so recently-touched entries survive eviction longest.
+            pv.move_to_end(claim_kid)
+        pv[claim_kid].append((bytes(voter_kid), bool(vote), topic))
 
     async def oracle_resolve(
         self,
@@ -3034,9 +3310,15 @@ class HyperMindAgent:
                 newly_credited.append((voter, vote, vote_topic))
                 already_set.add(key)
             if newly_credited:
-                self._world.panel_votes.setdefault(b"_resolved:" + claim_kid, []).extend(
-                    newly_credited
-                )
+                _resolved_key = b"_resolved:" + claim_kid
+                pv = self._world.panel_votes
+                if _resolved_key not in pv:
+                    while len(pv) >= _PANEL_VOTES_MAX_ENTRIES:
+                        pv.popitem(last=False)
+                    pv[_resolved_key] = []
+                else:
+                    pv.move_to_end(_resolved_key)
+                pv[_resolved_key].extend(newly_credited)
 
         # Spec §20 / HypothesisBook lifecycle: oracle verdict is authoritative —
         # transition the hypothesis riding on this claim from 'contested' (or any
@@ -3103,7 +3385,16 @@ class HyperMindAgent:
                     # _verify_witness_cosign always validates with ALG_ED25519, so
                     # the witness keypair must be a pure Ed25519 key regardless of
                     # the oracle's own (potentially composite) signing algorithm.
-                    _ed_witness_kp = Keypair.from_seed(_oracle_agent.keypair.secret_bytes[:32])
+                    # Extract exactly the first 32 bytes (Ed25519 seed) and validate
+                    # that they are present before passing to from_seed (#766).
+                    _oracle_secret = _oracle_agent.keypair.secret_bytes
+                    if len(_oracle_secret) < 32:
+                        raise ValueError(
+                            f"oracle_resolve: keypair secret_bytes is only "
+                            f"{len(_oracle_secret)} bytes; expected at least 32 "
+                            f"(Ed25519 seed). Key material is non-standard."
+                        )
+                    _ed_witness_kp = Keypair.from_seed(_oracle_secret[:32])
                     _cosign = make_witness_cosign(
                         _ed_witness_kp,
                         dispute_id=_dispute_id,
@@ -3794,13 +4085,33 @@ class HyperMindAgent:
         if self.cap_token is None:
             return
 
-        self.cap_token.authorize(
-            action=action,
-            topic=topic or "",
-            tool=tool or "",
-            revocation_store=self._world.revocation_store if self._world else None,
-            hlc=(self._hlc.logical_ms, self._hlc.counter),
-        )
+        # For delegated tokens (parent_sig != b""), verify the full chain first,
+        # then call authorize() with require_chain=False (#675/#771).
+        if self.cap_token.parent_sig != b"":
+            if not self.cap_token.verify_chain_full(
+                revocation_store=self._world.revocation_store if self._world else None,
+                hlc=(self._hlc.logical_ms, self._hlc.counter),
+            ):
+                raise AuthError(
+                    "delegated capability chain verification failed",
+                    failed_caveat="signature",
+                )
+            self.cap_token.authorize(
+                action=action,
+                topic=topic or "",
+                tool=tool or "",
+                revocation_store=self._world.revocation_store if self._world else None,
+                hlc=(self._hlc.logical_ms, self._hlc.counter),
+                require_chain=False,
+            )
+        else:
+            self.cap_token.authorize(
+                action=action,
+                topic=topic or "",
+                tool=tool or "",
+                revocation_store=self._world.revocation_store if self._world else None,
+                hlc=(self._hlc.logical_ms, self._hlc.counter),
+            )
 
         # P1-03: enforce rate caveat if present on this token.