hypermind 0.11.0__py3-none-any.whl

hypermind/simlab/_scenario_impl.py

@@ -0,0 +1,2778 @@
+"""Persona-panel simulator (package-internal implementation).
+
+This module is the canonical persona-panel simulator. It is wrapped by
+``hypermind.simlab.scenario.run_persona_sim`` and exposed via
+``hmctl simlab``.
+
+THE STORY
+=========
+N AI analysts (personas × replicas) each with a distinct LLM-backed
+personality, starting memory of pre-known facts, tool affinity, and
+biases convene to answer a question set. Every action by every agent is
+recorded so a non-technical operator can later see:
+
+    - what each agent looked up (tool calls)
+    - what they remembered before/after each answer
+    - what they actually said and why
+    - where any two agents disagreed
+
+Modern entry points:
+
+  hmctl simlab            # opens the Vue 3 SPA at localhost:8765
+  POST /v1/sims           # programmatic (registry + worker queue)
+
+The dev-only argparse shim at ``examples/scenario_persona_panel.py``
+preserves a CLI for local hacking; new code should call
+``hypermind.simlab.run_persona_sim(SimConfig, output_dir)`` directly.
+
+Outputs (per sim, written under ~/.hypermind/sims/{id}/):
+  trace.json    full Trace dataclass-as-dict
+  status.json   queued|running|done|failed + progress
+  stderr.log    captured stderr from the run
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import copy
+import hashlib
+import json
+import os
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from hypermind import HyperMindAgent, Uncertainty
+from hypermind.responders.base import LLMResponderError
+from hypermind.responders.openai import OpenAIResponder
+from hypermind.responders.tools import (
+    Tool,
+    ToolCallingResponder,
+    query_knowledge_base,
+    retrieve_document,
+    web_search,
+)
+
+ROOM = "persona-panel"
+NAMESPACE = "persona-sim"
+TOPIC = "persona-panel"
+
+
+# ---------------------------------------------------------------------------
+# Personas — each has a system prompt, starting memory, tool affinity
+# ---------------------------------------------------------------------------
+
+PERSONAS: dict[str, dict[str, Any]] = {
+    "optimist-economist": {
+        "label": "Optimist Economist",
+        "emoji": "📈",
+        "system": (
+            "You are a senior economist who is fundamentally bullish on long-run "
+            "growth. You cite historical analogues (post-1982 expansion, post-COVID "
+            "rebound) and emphasise the resilience of consumer spending and "
+            "productivity. You acknowledge risks but rarely treat them as base case. "
+            "Be specific; quote numbers; lean toward 'this works out'."
+        ),
+        "starting_memory": [
+            "Post-COVID labor market sustained tight through 2024–25",
+            "Equity drawdowns >20% recovered within 18 months in 80% of cases since 1950",
+            "Productivity gains from AI adoption typically lag investment by 2–3 years",
+        ],
+        "tool_affinity": "web_search",
+        "n_eff": 10,
+    },
+    "sceptical-engineer": {
+        "label": "Sceptical Engineer",
+        "emoji": "🔧",
+        "system": (
+            "You are a senior systems engineer who treats every claim as a "
+            "hypothesis until evidenced. You ask 'where's the data?' and 'what's "
+            "the failure mode?'. Prefer first-principles reasoning over historical "
+            "analogy. Quote specific mechanisms (e.g., capex digestion, latency "
+            "budgets, queue overflow). Acknowledge uncertainty explicitly."
+        ),
+        "starting_memory": [
+            "Most large-scale tech projects ship 6–18 months late vs initial plan",
+            "Capacity bottlenecks usually appear at the third-most-used resource",
+            "Monitoring lags incidents by 3–7 days in regulated industries",
+        ],
+        "tool_affinity": "retrieve_document",
+        "n_eff": 12,
+    },
+    "risk-averse-lawyer": {
+        "label": "Risk-Averse Lawyer",
+        "emoji": "⚖️",
+        "system": (
+            "You are a senior corporate counsel. You think first about "
+            "regulatory exposure, antitrust, fiduciary duty, and reputational "
+            "risk. You cite precedent (US v Microsoft, Vodafone-Mannesmann) and "
+            "are sceptical of any answer that doesn't address the legal angle. "
+            "Probabilities should account for known regulatory pipelines."
+        ),
+        "starting_memory": [
+            "EU DMA enforcement on hyperscalers escalated in 2024–25",
+            "Antitrust prosecution success rate in tech: ~22% of cases brought",
+            "Major settlements in tech average $1.6B over the last decade",
+        ],
+        "tool_affinity": "query_knowledge_base",
+        "n_eff": 11,
+    },
+    "curious-journalist": {
+        "label": "Curious Journalist",
+        "emoji": "📰",
+        "system": (
+            "You are a senior business correspondent. You ask 'what's missing "
+            "from the picture?' and weigh narrative vs evidence carefully. You "
+            "synthesise multiple sources rather than committing strongly. Hedge "
+            "appropriately; identify the one or two facts that would change "
+            "your mind."
+        ),
+        "starting_memory": [
+            "Most narrative-driven market calls reverse within 90 days",
+            "Insider transactions are a leading indicator with 6-week lag",
+            "C-suite turnover rates above 20% precede strategic shifts",
+        ],
+        "tool_affinity": "web_search",
+        "n_eff": 8,
+    },
+    "pattern-matcher-historian": {
+        "label": "Pattern-Matcher Historian",
+        "emoji": "📜",
+        "system": (
+            "You are an economic historian. Every question, you match to past "
+            "events: the 1907 Knickerbocker panic, 1973 oil shock, 1989 Japan "
+            "bubble, 2008, 2020. You're explicit when no good analogue exists. "
+            "Express probability through 'how often this pattern resolved this way'."
+        ),
+        "starting_memory": [
+            "Yield curve inversion preceded recession in 8/10 cases since 1955",
+            "Average bear market duration since WWII: 14 months",
+            "Tech bubble 2000 saw PE ratios revert from 70x to 30x over 30 months",
+        ],
+        "tool_affinity": "retrieve_document",
+        "n_eff": 11,
+    },
+    "contrarian-quant": {
+        "label": "Contrarian Quant",
+        "emoji": "🔬",
+        "system": (
+            "You are a quant focused on tail risk and consensus-fade. When most "
+            "people say YES, you look for reasons to say NO (and vice-versa). "
+            "Cite factor exposures (momentum, quality, low-vol), implied volatility, "
+            "and crowd-positioning. Lean against the obvious answer when defensible."
+        ),
+        "starting_memory": [
+            "Crowd-positioning extremes (>2σ) reverse within 90 days 70% of time",
+            "VIX < 13 historically precedes -10% drawdowns within 6 months",
+            "When sell-side consensus exceeds 4.5/5, returns underperform by 4%/yr",
+        ],
+        "tool_affinity": "mixed",
+        "n_eff": 10,
+    },
+    "data-scientist": {
+        "label": "Data Scientist",
+        "emoji": "📊",
+        "system": (
+            "You are a rigorous data scientist who grounds every assessment in empirical evidence. "
+            "You demand statistical significance, check for confounds, and flag when sample sizes are too small to draw conclusions. "
+            "You think in distributions, not point estimates. You always ask: what does the data actually show, vs. what are we inferring? "
+            "You are comfortable with uncertainty and prefer to say '60% confidence, ±15pp' rather than make overconfident claims. "
+            "When you don't have data, you say so clearly and reason from base rates."
+        ),
+        "starting_memory": [
+            "Correlation is not causation — always check the causal mechanism.",
+            "Effect sizes matter as much as p-values; small effects can be statistically significant but practically irrelevant.",
+            "Survivorship bias is everywhere — always ask what data is missing.",
+        ],
+        "tool_affinity": "mixed",
+        "n_eff": 14,
+    },
+    "security-researcher": {
+        "label": "Security Researcher",
+        "emoji": "🔐",
+        "system": (
+            "You are a seasoned security researcher who thinks adversarially. "
+            "You model how systems fail, how attackers exploit weaknesses, and what the threat landscape looks like. "
+            "You are deeply skeptical of 'security through obscurity' and always ask: what is the attack surface? "
+            "You read CVEs, track APT groups, and understand both technical and social engineering vectors. "
+            "When assessing risk, you think in terms of CVSS scores, exploit likelihood, and blast radius. "
+            "You give lower confidence to claims that ignore adversarial conditions."
+        ),
+        "starting_memory": [
+            "Every system has an attack surface — security is about minimizing and monitoring it.",
+            "The weakest link is usually the human layer, not the technical one.",
+            "Defense in depth: no single control is sufficient; assume breach and plan accordingly.",
+        ],
+        "tool_affinity": "retrieve_document",
+        "n_eff": 11,
+    },
+    "product-manager": {
+        "label": "Product Manager",
+        "emoji": "🎯",
+        "system": (
+            "You are a pragmatic product manager who thinks in terms of user value, market fit, and execution reality. "
+            "You translate technical possibilities into business outcomes. You track what customers actually want vs. what they say they want. "
+            "You think about adoption curves, competitive dynamics, and GTM strategy. "
+            "You are skeptical of technology-first reasoning that ignores distribution and market timing. "
+            "You weight evidence from user research, NPS data, and retention metrics heavily. "
+            "You ask: who is the customer, what job are they hiring this for, and what does success look like in 12 months?"
+        ),
+        "starting_memory": [
+            "Build for the job-to-be-done, not the feature request — understand the underlying need.",
+            "Distribution is as important as product quality — a great product no one can find fails.",
+            "The best products solve one problem exceptionally well before expanding scope.",
+        ],
+        "tool_affinity": "web_search",
+        "n_eff": 9,
+    },
+    "ethicist": {
+        "label": "AI Ethicist",
+        "emoji": "🧭",
+        "system": (
+            "You are an applied AI ethicist who examines the moral, societal, and governance dimensions of technology claims. "
+            "You think about who bears the costs and who captures the benefits. You track regulatory developments, bias research, and fairness frameworks. "
+            "You are skeptical of techno-optimist framing that ignores distributional impacts and power asymmetries. "
+            "You apply frameworks from ethics (consequentialist, deontological, virtue ethics) systematically. "
+            "You flag when a claim implicitly assumes a particular value system without acknowledging alternatives. "
+            "You believe responsible deployment requires consent, transparency, and accountability mechanisms."
+        ),
+        "starting_memory": [
+            "Technology is not neutral — it encodes the values and assumptions of its designers.",
+            "Ask who bears the downside risk vs. who captures the upside — power asymmetries matter.",
+            "Governance and technical capability must co-evolve; deployment without governance is reckless.",
+        ],
+        "tool_affinity": "query_knowledge_base",
+        "n_eff": 10,
+    },
+    "macro-strategist": {
+        "label": "Macro Strategist",
+        "emoji": "🌍",
+        "system": (
+            "You are a macro strategist who thinks in geopolitical, economic, and systemic terms. "
+            "You track central bank policy, trade flows, demographic trends, and multi-decade cycles. "
+            "You connect micro-level events to macro-level forces: interest rate regimes, currency dynamics, commodity supercycles. "
+            "You are deeply aware of second and third-order effects and the danger of linear extrapolation in complex adaptive systems. "
+            "You use historical analogies but are careful not to over-index on them. "
+            "You give high weight to structural constraints (demographics, debt levels, energy infrastructure) that operate on 10–30 year timescales."
+        ),
+        "starting_memory": [
+            "Demographics are destiny — population aging and debt levels constrain policy space for decades.",
+            "Never fight the Fed in the short run, but structural forces win in the long run.",
+            "Geopolitical shifts happen slowly then suddenly — watch for leading indicators, not just events.",
+        ],
+        "tool_affinity": "web_search",
+        "n_eff": 11,
+    },
+    "systems-biologist": {
+        "label": "Systems Biologist",
+        "emoji": "🧬",
+        "system": (
+            "You are a systems biologist who thinks in terms of complex adaptive systems, feedback loops, and emergent properties. "
+            "You draw analogies between biological systems and the domain being analyzed: robustness, fragility, resilience, and phase transitions. "
+            "You are deeply skeptical of reductionist explanations that ignore systemic interactions. "
+            "You think about homeostasis, tipping points, and path dependence. "
+            "You are comfortable with non-linear dynamics and understand that complex systems resist simple interventions. "
+            "You apply evolutionary thinking: what selective pressures shape the behavior you're observing?"
+        ),
+        "starting_memory": [
+            "Complex systems have emergent properties that cannot be predicted from components alone.",
+            "Robustness in one dimension often means fragility in another — there are no free lunches in system design.",
+            "Evolution selects for 'good enough' solutions, not optimal ones — satisficing is the norm.",
+        ],
+        "tool_affinity": "retrieve_document",
+        "n_eff": 11,
+    },
+    "behavioral-economist": {
+        "label": "Behavioral Economist",
+        "emoji": "🧠",
+        "system": (
+            "You are a behavioral economist who understands how humans actually make decisions, not how rational-agent models assume they do. "
+            "You think about cognitive biases, heuristics, and the architecture of choice. "
+            "You apply prospect theory, loss aversion, hyperbolic discounting, and social proof to analyze real-world behavior. "
+            "You are skeptical of predictions based on homo economicus assumptions — people are predictably irrational. "
+            "You look for the nudge architecture and ask: what incentives and choice structures are actually operating here? "
+            "You weigh field experiments and RCTs above survey data and revealed preferences above stated ones."
+        ),
+        "starting_memory": [
+            "People respond to losses roughly twice as strongly as equivalent gains — loss aversion dominates.",
+            "Defaults are destiny: most people never change the default option, so defaults are policy choices.",
+            "Context and framing fundamentally change choices — identical options presented differently yield different decisions.",
+        ],
+        "tool_affinity": "mixed",
+        "n_eff": 10,
+    },
+    "investigative-analyst": {
+        "label": "Investigative Analyst",
+        "emoji": "🔍",
+        "system": (
+            "You are a meticulous investigative analyst who follows evidence chains to their source. "
+            "You are trained to detect motivated reasoning, conflicts of interest, and manufactured consensus. "
+            "You triangulate across multiple independent sources before accepting a claim. "
+            "You have a nose for what's NOT being said — omissions and silences are as telling as assertions. "
+            "You track document trails, financial flows, and institutional incentives. "
+            "You are deeply skeptical of official narratives and corporate communications, while not dismissing them outright. "
+            "You assign high confidence only when multiple independent lines of evidence converge."
+        ),
+        "starting_memory": [
+            "Follow the money — financial incentives explain most of what looks like ideology or incompetence.",
+            "Absence of evidence is not evidence of absence, but it IS evidence — ask why the evidence is missing.",
+            "Primary sources trump secondary sources; always ask: who said this first, and why?",
+        ],
+        "tool_affinity": "web_search",
+        "n_eff": 12,
+    },
+}
+
+
+# ---------------------------------------------------------------------------
+# LLM cost table — USD per 1M tokens (input, output)
+# ---------------------------------------------------------------------------
+
+_COST_PER_1M: dict[str, tuple[float, float]] = {
+    "gpt-4o": (5.0, 15.0),
+    "gpt-4o-mini": (0.15, 0.60),
+    "gpt-4o-mini-2024-07-18": (0.15, 0.60),
+    "claude-3-5-sonnet-20241022": (3.0, 15.0),
+    "claude-3-5-haiku-20241022": (0.80, 4.0),
+    "claude-sonnet-4-6": (3.0, 15.0),
+    "claude-haiku-4-5-20251001": (0.80, 4.0),
+}
+
+
+def _estimate_cost(model: str, input_tokens: int, output_tokens: int) -> float:
+    rates = _COST_PER_1M.get(model, (0.0, 0.0))
+    return (input_tokens * rates[0] + output_tokens * rates[1]) / 1_000_000
+
+
+# ---------------------------------------------------------------------------
+# Profile + trace
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class AgentProfile:
+    agent: HyperMindAgent
+    name: str
+    persona: str
+    persona_info: dict[str, Any]
+    panel_votes: list[dict[str, Any]] = field(default_factory=list)
+    tool_calls: list[dict[str, Any]] = field(default_factory=list)
+    memory_states: list[dict[str, Any]] = field(default_factory=list)
+    structured: list[dict[str, Any]] = field(default_factory=list)
+    agent_timeline: list[dict[str, Any]] = field(default_factory=list)
+    published_claims: list[dict[str, Any]] = field(default_factory=list)
+    n_llm_calls: int = 0
+    total_input_tokens: int = 0
+    total_output_tokens: int = 0
+
+    def record_timeline(self, kind: str, summary: str, **extra: Any) -> None:
+        self.agent_timeline.append(
+            {
+                "ts_wall_ms": int(time.time() * 1000),
+                "kind": kind,
+                "summary": summary,
+                **extra,
+            }
+        )
+
+
+@dataclass
+class Trace:
+    started_at: float
+    finished_at: float = 0.0
+    profiles: list[AgentProfile] = field(default_factory=list)
+    panel_records: list[dict[str, Any]] = field(default_factory=list)
+    questions: list[dict[str, Any]] = field(default_factory=list)
+    topic: str = ""  # the user's free-text topic (when generated, not from a saved set)
+    total_tool_calls: int = 0
+    use_real_llm: bool = False
+    llm_model: str = ""
+    # ── Collective intelligence wiring (P1–P10) ──
+    deliberation_records: list[dict[str, Any]] = field(default_factory=list)
+    oracle_resolutions: list[dict[str, Any]] = field(default_factory=list)
+    syntheses: list[dict[str, Any]] = field(default_factory=list)
+    vouches: list[dict[str, Any]] = field(default_factory=list)
+    captoken_events: list[dict[str, Any]] = field(default_factory=list)
+    audit_replay: dict[str, Any] = field(default_factory=dict)
+    reputation_snapshots: dict[str, list[dict[str, Any]]] = field(default_factory=dict)
+    # ── Phase timing breakdown (KPI #1) ──
+    setup_s: float = 0.0
+    deliberation_s: float = 0.0
+    oracle_s: float = 0.0
+    synthesis_s: float = 0.0
+    n_deliberation_rounds: int = 0
+    questions_timing: list[dict[str, Any]] = field(default_factory=list)
+
+
+# ---------------------------------------------------------------------------
+# TracingPersonaResponder — wraps the real responder, captures everything
+# ---------------------------------------------------------------------------
+
+
+class TracingPersonaResponder:
+    """Per-persona dispatcher that records tool_calls + memory diffs.
+
+    For each (agent_kid, query):
+      1. Snapshot the agent's working_memory (before)
+      2. Dispatch to the persona-specific underlying responder
+      3. Capture last_tool_calls + last_structured
+      4. Compute memory diff (after vs before) — the responder may have
+         written facts via the agent's checkpoint mechanism
+      5. Append all of it to the AgentProfile
+    """
+
+    def __init__(
+        self,
+        profiles_by_kid: dict[bytes, AgentProfile],
+        responders_by_persona: dict[str, Any],
+    ) -> None:
+        self.profiles_by_kid = profiles_by_kid
+        self.responders_by_persona = responders_by_persona
+
+    async def __call__(self, agent_kid: bytes, query: str) -> Any:
+        prof = self.profiles_by_kid.get(agent_kid)
+        if prof is None:
+            return Uncertainty.beta(5, 5)
+
+        responder = self.responders_by_persona.get(
+            prof.persona,
+            next(iter(self.responders_by_persona.values())),
+        )
+
+        # 1. Snapshot memory before
+        try:
+            mem_before = _snapshot_working_memory(prof.agent.working_memory())
+        except Exception:
+            mem_before = {}
+
+        t0 = time.perf_counter()
+        prof.n_llm_calls += 1
+        try:
+            result = await responder(agent_kid, query)
+        except (LLMResponderError, TimeoutError) as exc:
+            elapsed = (time.perf_counter() - t0) * 1000
+            label = "timeout" if isinstance(exc, TimeoutError) else "vote_error"
+            prof.panel_votes.append(
+                {
+                    "query": query,
+                    "error": str(exc)[:200],
+                    "via": "fallback",
+                    "elapsed_ms": elapsed,
+                }
+            )
+            prof.record_timeline(label, f"{exc!s:.80}", query=query)
+            return Uncertainty.beta(5, 5)
+        except asyncio.CancelledError:
+            # Propagate cancellation — the outer wait_for in _one() owns the timeout.
+            raise
+        elapsed_ms = (time.perf_counter() - t0) * 1000
+
+        # 2. Unpack — may be (Uncertainty, StructuredResponse) or bare Uncertainty
+        if isinstance(result, tuple) and len(result) == 2:
+            unc, structured = result
+        else:
+            unc = result
+            structured = None
+
+        # Accumulate token usage if the structured response carries it.
+        try:
+            tu = getattr(structured, "token_usage", None) if structured is not None else None
+            if tu is not None:
+                prof.total_input_tokens += int(getattr(tu, "prompt_tokens", 0) or 0)
+                prof.total_output_tokens += int(getattr(tu, "completion_tokens", 0) or 0)
+        except Exception:
+            pass
+
+        confidence = structured.confidence if structured is not None else unc.mean()
+
+        # 3. Tool calls — read responder.last_tool_calls if it has them
+        tool_calls_this_call = []
+        if hasattr(responder, "last_tool_calls"):
+            tc = list(responder.last_tool_calls or [])
+            for entry in tc:
+                tool_calls_this_call.append(
+                    {
+                        "ts_wall_ms": int(time.time() * 1000),
+                        "query": query,
+                        **entry,
+                    }
+                )
+                prof.tool_calls.append(tool_calls_this_call[-1])
+
+        # 4. Memory diff
+        try:
+            mem_after = _snapshot_working_memory(prof.agent.working_memory())
+        except Exception:
+            mem_after = {}
+        diff = _memory_diff(mem_before, mem_after)
+        prof.memory_states.append(
+            {
+                "ts_wall_ms": int(time.time() * 1000),
+                "query": query,
+                "before": mem_before,
+                "after": mem_after,
+                "diff": diff,
+            }
+        )
+
+        # 5. Structured response
+        struct_dict: dict[str, Any] | None = None
+        if structured is not None:
+            struct_dict = structured.to_dict()
+            prof.structured.append({"query": query, **struct_dict})
+
+        # 6. Panel vote
+        vote = {
+            "query": query,
+            "confidence": round(float(confidence), 4),
+            "posterior_mean": round(unc.mean(), 4),
+            "reasoning": (structured.reasoning if structured else ""),
+            "n_eff": prof.persona_info.get("n_eff", 10),
+            "via": "llm" if structured else "synthetic",
+            "elapsed_ms": round(elapsed_ms, 1),
+            "n_tool_calls": len(tool_calls_this_call),
+        }
+        prof.panel_votes.append(vote)
+        prof.record_timeline(
+            "vote",
+            f"conf={confidence:.2f} on '{query[:50]}'",
+            query=query,
+            confidence=confidence,
+            n_tool_calls=len(tool_calls_this_call),
+        )
+
+        return result
+
+
+def _snapshot_working_memory(mem: dict) -> dict[str, Any]:
+    """Shallow-copy working memory, deep-copying only mutable fields.
+
+    `peer_claims` is a large list written only by subscription callbacks,
+    never modified by the responder — skip its deepcopy to avoid copying
+    hundreds of dicts on every LLM call.
+    """
+    return {k: (copy.deepcopy(v) if k != "peer_claims" else v) for k, v in mem.items()}
+
+
+def _memory_diff(before: dict, after: dict) -> dict[str, Any]:
+    added: list[str] = []
+    removed: list[str] = []
+    changed: list[str] = []
+    keys = set(before) | set(after)
+    for k in sorted(keys):
+        if k not in before:
+            added.append(k)
+        elif k not in after:
+            removed.append(k)
+        elif before[k] != after[k]:
+            changed.append(k)
+    return {"added": added, "removed": removed, "changed": changed}
+
+
+# ---------------------------------------------------------------------------
+# OpenRouter / Anthropic client builder (reuses pattern from msft scenario)
+# ---------------------------------------------------------------------------
+
+
+def _make_openrouter_client(api_key: str):
+    from openai import AsyncOpenAI
+
+    return AsyncOpenAI(
+        base_url="https://openrouter.ai/api/v1",
+        api_key=api_key,
+        default_headers={
+            "HTTP-Referer": "https://github.com/ZySec-AI/hypermind",
+            "X-Title": "HyperMind Persona Panel",
+        },
+    )
+
+
+def _build_responder_for_persona(
+    persona: str,
+    api_key: str,
+    *,
+    llm_model: str,
+    enable_tools: bool,
+    persona_info_override: dict[str, Any] | None = None,
+    swarm_tools: list[str] | None = None,
+) -> Any:
+    """Build a per-persona LLM responder with optional tool calling.
+
+    ``persona_info_override`` (optional) replaces the lookup against
+    ``PERSONAS`` with a custom dict (e.g. user-defined persona, or
+    swarm-bias-modified system prompt).
+
+    ``swarm_tools`` (optional list of tool names): when provided, it
+    overrides the per-persona ``tool_affinity`` — every member of a
+    swarm shares the same explicitly-declared tool set. Pass ``[]`` to
+    disable tools entirely on a swarm.
+    """
+    info = persona_info_override or PERSONAS[persona]
+    client = _make_openrouter_client(api_key)
+
+    if enable_tools:
+        tools: list[Tool] = []
+
+        # Try to load tools from the namespace registry first.
+        try:
+            import importlib as _importlib
+
+            from .tool_registry import (
+                decode_credential as _decode,
+            )
+            from .tool_registry import (
+                get_activated_tool as _get_activated,
+            )
+            from .tool_registry import (
+                get_tool_def as _get_def,
+            )
+            from .tool_registry import (
+                list_active_tool_slugs as _active_slugs,
+            )
+
+            active_slugs = set(_active_slugs())
+            affinity = info.get("tool_affinity", "mixed")
+            # Legacy stub names map to "mixed" — they're intents, not specific slugs.
+            _legacy = {"web_search", "retrieve_document", "query_knowledge_base"}
+
+            if swarm_tools is not None:
+                # Filter swarm tools: keep registry slugs; legacy stubs → all active tools
+                direct = set(swarm_tools) & active_slugs
+                has_legacy = bool(set(swarm_tools) & _legacy)
+                wanted = (active_slugs if has_legacy else set()) | direct
+            elif affinity == "none":
+                wanted = set()
+            elif affinity in ({"mixed"} | _legacy):
+                # "mixed" or any legacy affinity → use all active tools
+                wanted = active_slugs
+            else:
+                wanted = {affinity} & active_slugs
+
+            for slug in sorted(wanted):
+                activated = _get_activated(slug)
+                tool_def = _get_def(slug)
+                if not activated or not tool_def:
+                    continue
+                creds = {k: _decode(v) for k, v in activated.credentials.items()}
+                try:
+                    mod = _importlib.import_module(tool_def.handler_module)
+                    _creds_capture = creds
+
+                    def _make_handler(_m=mod, _c=_creds_capture):
+                        def _handler(args):
+                            return _m.handle(args, _c)
+                        return _handler
+
+                    handler = _make_handler()
+                except ImportError:
+                    def handler(args):
+                        return json.dumps({"error": "handler unavailable"})
+                tools.append(
+                    Tool(
+                        name=slug,
+                        description=tool_def.description,
+                        parameters_schema=tool_def.parameters_schema,
+                        handler=handler,
+                    )
+                )
+        except Exception as _tool_reg_err:
+            import traceback as _tb
+
+            print(
+                f"[tool_registry] ERROR building tools: {_tool_reg_err}\n{_tb.format_exc()}",
+                flush=True,
+            )
+
+        # Backwards-compat fallback: if no registry tools, use hardcoded stubs.
+        if not tools:
+            if swarm_tools is not None:
+                wanted_stub = set(swarm_tools)
+                if "web_search" in wanted_stub:
+                    tools.append(web_search())
+                if "retrieve_document" in wanted_stub:
+                    tools.append(retrieve_document())
+                if "query_knowledge_base" in wanted_stub:
+                    tools.append(query_knowledge_base())
+            else:
+                affinity = info.get("tool_affinity", "mixed")
+                if affinity in ("web_search", "mixed"):
+                    tools.append(web_search())
+                if affinity in ("retrieve_document", "mixed"):
+                    tools.append(retrieve_document())
+                if affinity in ("query_knowledge_base", "mixed"):
+                    tools.append(query_knowledge_base())
+
+        # Always inject the Relata memory recall tool when a memory store is attached.
+        if os.getenv("RELATA_URL"):
+            from .tool_handlers.relata_recall import relata_recall as _rr_def
+            tools.append(Tool(
+                name="relata_recall",
+                description="Search this agent's persistent memory for past learnings and research.",
+                parameters_schema=_rr_def()["function"]["parameters"],
+                handler=lambda args, _agent=agent: __import__(
+                    "hypermind.simlab.tool_handlers.relata_recall", fromlist=["handle_relata_recall"]
+                ).handle_relata_recall(args, agent=_agent),
+            ))
+
+        return ToolCallingResponder(
+            client=client,
+            model=llm_model,
+            tools=tools,
+            system_prompt=info["system"],
+            effective_n=info["n_eff"],
+            timeout_s=45,
+        )
+
+    return OpenAIResponder(
+        client=client,
+        model=llm_model,
+        system_prompt=info["system"],
+        effective_n=info["n_eff"],
+        timeout_s=30,
+    )
+
+
+def _build_synthetic_responder():
+    from hypermind.responders import SyntheticResponder
+
+    return SyntheticResponder()
+
+
+# ---------------------------------------------------------------------------
+# Persona identity + Relata memory helpers
+# ---------------------------------------------------------------------------
+
+
+def _persona_seed(persona_slug: str) -> bytes:
+    """Deterministic 32-byte seed for a persona slug — stable identity across sims."""
+    return hashlib.sha256(f"hypermind-persona-v1:{persona_slug}".encode()).digest()
+
+
+def _attach_relata_memory(agent: "HyperMindAgent", *, namespace_id: str) -> None:
+    """Attach a RelataMemoryStore to agent if RELATA_URL is set. Best-effort."""
+    url = os.getenv("RELATA_URL")
+    if not url:
+        return
+    try:
+        from hypermind.mind.memory_store import RelataMemoryStore
+        store = RelataMemoryStore(
+            url,
+            namespace_id=namespace_id,
+            agent_kid=agent.keypair.kid,
+            purpose="agent_notes",
+        )
+        store.open()
+        agent.attach_memory(store)
+    except Exception:
+        pass
+
+
+# ---------------------------------------------------------------------------
+# Cohort setup
+# ---------------------------------------------------------------------------
+
+
+def _build_profiles(
+    agents: list[HyperMindAgent],
+    *,
+    personas: list[str],
+    replicas: int,
+    persona_replicas: dict[str, int] | None = None,
+    persona_info_override: dict[str, dict[str, Any]] | None = None,
+) -> list[AgentProfile]:
+    """Bind ``HyperMindAgent`` instances to persona profiles.
+
+    ``persona_replicas`` (optional) overrides the per-persona replica
+    count — used by swarms where members can have uneven counts.
+    ``persona_info_override`` (optional) injects custom-persona dicts
+    for slugs that aren't in the global ``PERSONAS`` constant, or
+    swaps in a swarm-bias-modified system prompt for built-ins.
+    """
+    profiles: list[AgentProfile] = []
+    it = iter(agents)
+    info_lookup: dict[str, dict[str, Any]] = persona_info_override or {}
+    rep_lookup: dict[str, int] = persona_replicas or {}
+    for persona_name in personas:
+        info = info_lookup.get(persona_name) or PERSONAS[persona_name]
+        n = rep_lookup.get(persona_name, replicas)
+        for idx in range(1, n + 1):
+            agent = next(it, None)
+            if agent is None:
+                break
+            prof = AgentProfile(
+                agent=agent,
+                name=f"{persona_name}-{idx:02d}",
+                persona=persona_name,
+                persona_info=info,
+            )
+            # Attach persistent Relata memory (no-op when RELATA_URL unset).
+            _attach_relata_memory(agent, namespace_id="simlab-persistent")
+            # Seed working memory with persona's pre-known facts.
+            mem = agent.working_memory()
+            mem["persona"] = persona_name
+            mem["starting_facts"] = list(info["starting_memory"])
+            mem["facts_learned"] = []
+            # S4 — Cross-sim warm start: hydrate posteriors from
+            # KernelStore so this persona's *prior* sims' calibration
+            # carries forward. First-ever sim of a persona is a no-op.
+            try:
+                from hypermind.knowledge.kernel_store import KernelStore
+
+                state = KernelStore.load(persona_name)
+                if state.posteriors:
+                    mem.setdefault("posteriors", {}).update(state.posteriors)
+                    prof.record_timeline(
+                        "init",
+                        f"warm-start: loaded {len(state.posteriors)} prior "
+                        f"posteriors (across {state.n_sims} prior sims)",
+                    )
+            except Exception:
+                pass
+            prof.record_timeline(
+                "init",
+                f"{info['label']}: seeded with {len(info['starting_memory'])} starting facts",
+            )
+            profiles.append(prof)
+    return profiles
+
+
+# ---------------------------------------------------------------------------
+# Question loading
+# ---------------------------------------------------------------------------
+
+
+def _load_questions(path: str) -> list[dict[str, Any]]:
+    p = Path(path)
+    if p.exists():
+        return json.loads(p.read_text())
+    # Try the bundled package question_sets/ directory (works after pip install)
+    pkg_q = Path(__file__).resolve().parent / "question_sets" / f"{path}.json"
+    if pkg_q.exists():
+        return json.loads(pkg_q.read_text())
+    # Try the dev-source bench/question_sets/ (walking up from this file)
+    for parent in Path(__file__).resolve().parents:
+        candidate = parent / "bench" / "question_sets" / f"{path}.json"
+        if candidate.exists():
+            return json.loads(candidate.read_text())
+        if (parent / "pyproject.toml").exists():
+            break
+    raise FileNotFoundError(f"question set not found: {path}")
+
+
+# ---------------------------------------------------------------------------
+# Per-question panel + per-agent vote
+# ---------------------------------------------------------------------------
+
+
+def _peer_reasoning_summary(profiles: list[AgentProfile], query: str, skip_kid: bytes) -> str:
+    """Build an anonymised round-0 reasoning summary for a deliberation round.
+
+    Each agent sees what its peers said *anonymised* by archetype + a
+    confidence histogram, so it can revise without anchoring on identity.
+    """
+    answers: list[tuple[str, float, str]] = []
+    for p in profiles:
+        if p.agent.keypair.kid == skip_kid:
+            continue
+        last = next(
+            (
+                v
+                for v in reversed(p.panel_votes)
+                if v.get("query") == query and v.get("confidence") is not None
+            ),
+            None,
+        )
+        if last is None:
+            continue
+        reasoning = (last.get("reasoning", "") or "")[:400].strip()
+        answers.append((p.persona, last["confidence"], reasoning))
+    if not answers:
+        return ""
+    confs = [a[1] for a in answers]
+    mean = sum(confs) / len(confs)
+    lines = [
+        f"PEER PANEL ROUND 0 — {len(answers)} other analysts answered this question.",
+        f"  Mean confidence: {mean:.0%}  ·  Range: {min(confs):.0%}–{max(confs):.0%}",
+        "  A sample of their reasoning (anonymised):",
+    ]
+    # Sample up to 5 different perspectives
+    seen_personas: set[str] = set()
+    for persona, conf, reasoning in answers:
+        if persona in seen_personas:
+            continue
+        seen_personas.add(persona)
+        if reasoning:
+            lines.append(f"   - [{persona}] {conf:.0%}: {reasoning}")
+        if len(seen_personas) >= 5:
+            break
+    lines.append("")
+    lines.append(
+        "Now reconsider the question. You may keep, qualify, or rebut your answer. "
+        "If your view shifted, say briefly why."
+    )
+    return "\n".join(lines)
+
+
+async def _ask_panel(
+    profiles: list[AgentProfile],
+    question: dict,
+    responder: TracingPersonaResponder,
+    *,
+    timeout_s: float = 45,
+    publish_claims: bool = True,
+    enable_disputes: bool = True,
+) -> dict[str, Any]:
+    """Dispatch the question to every agent in parallel; aggregate.
+
+    When ``publish_claims=True``, every agent publishes a signed CLAIM
+    after answering — a sealed, citeable, audit-logged statement that
+    every other peer in the room can read. When ``enable_disputes=True``,
+    agents whose answer differs by ≥30pp from the panel mean file a
+    bonded DISPUTE against the highest-confidence opposing claim.
+    """
+    query = question.get("query", "")
+    qid = question.get("id", "")
+    ground_truth = question.get("ground_truth")
+
+    async def _one(prof):
+        try:
+            await asyncio.wait_for(
+                responder(prof.agent.keypair.kid, query),
+                timeout=timeout_s,
+            )
+        except TimeoutError:
+            prof.record_timeline("error", f"responder timeout after {timeout_s}s")
+        except asyncio.CancelledError:
+            prof.record_timeline("error", "responder cancelled")
+            raise
+        except Exception as exc:
+            prof.record_timeline("error", str(exc)[:120])
+
+    t0 = time.perf_counter()
+    # Outer wait_for is a hard ceiling — per-agent timeouts above are the
+    # primary cap. `return_exceptions=True` ensures one slow/failed agent
+    # never aborts the panel run.
+    try:
+        await asyncio.wait_for(
+            asyncio.gather(*[_one(p) for p in profiles], return_exceptions=True),
+            timeout=timeout_s * len(profiles) + 30,
+        )
+    except TimeoutError:
+        # Catastrophic: every agent stalled past its own timeout AND the
+        # generous outer ceiling. Record on every profile that didn't
+        # already record an error and continue with whatever votes landed.
+        for prof in profiles:
+            if not any(t.get("kind") == "error" for t in prof.agent_timeline[-3:]):
+                prof.record_timeline("error", "panel timeout")
+    elapsed_ms = (time.perf_counter() - t0) * 1000
+
+    # Collect this question's votes from each profile
+    answers: list[tuple[AgentProfile, dict]] = []
+    for p in profiles:
+        last = next(
+            (v for v in reversed(p.panel_votes) if v.get("query") == query),
+            None,
+        )
+        if last is not None and "confidence" in last:
+            answers.append((p, last))
+
+    if not answers:
+        return {
+            "id": qid,
+            "query": query,
+            "ground_truth": ground_truth,
+            "n_responses": 0,
+            "elapsed_ms": elapsed_ms,
+        }
+
+    confidences = [a[1]["confidence"] for a in answers]
+    mean_conf = sum(confidences) / len(confidences)
+    sorted_pa = sorted(answers, key=lambda x: x[1]["confidence"])
+
+    # ---- Publish each agent's answer as a signed CLAIM -----------------
+    # Every agent publishes its answer to the namespace's transparency
+    # log so other agents (and any external auditor) can see it.
+    # We also write the answer + reasoning into the agent's working
+    # memory so subsequent questions can reference what they previously
+    # said — that's the "local learning" loop.
+    claim_records: list[dict[str, Any]] = []
+    if publish_claims:
+        async def _publish_one(prof: "AgentProfile", vote: dict) -> "dict | None":
+            try:
+                payload = {
+                    "kind": "panel_answer",
+                    "query": query,
+                    "confidence": vote["confidence"],
+                    "reasoning": vote.get("reasoning", "")[:2000],
+                    "persona": prof.persona,
+                }
+                kid = await prof.agent.publish_claim(
+                    payload=payload,
+                    claim_type="eval_result",
+                    uncertainty=Uncertainty.beta(
+                        max(1.0, vote["confidence"] * vote.get("n_eff", 10)),
+                        max(1.0, (1 - vote["confidence"]) * vote.get("n_eff", 10)),
+                    ),
+                    topic=TOPIC,
+                )
+                record = {
+                    "kid": kid.hex(),
+                    "agent": prof.name,
+                    "persona": prof.persona,
+                    "query": query,
+                    "confidence": vote["confidence"],
+                    "round": 0,
+                    "ts_wall_ms": int(time.time() * 1000),
+                }
+                # Update the agent's working memory — local learning
+                mem = prof.agent.working_memory()
+                facts = mem.setdefault("facts_learned", [])
+                facts.append(
+                    {
+                        "ts_wall_ms": int(time.time() * 1000),
+                        "fact": f"I answered '{query[:60]}…' at {vote['confidence']:.0%}",
+                        "source": "self-assertion",
+                        "claim_kid": kid.hex(),
+                    }
+                )
+                prof.published_claims = getattr(prof, "published_claims", [])
+                prof.published_claims.append(record)
+                prof.record_timeline(
+                    "publish_claim",
+                    f"Sealed answer at {vote['confidence']:.0%} → kid {kid.hex()[:12]}…",
+                    claim_kid=kid.hex(),
+                    confidence=vote["confidence"],
+                )
+                return record
+            except Exception as exc:
+                prof.record_timeline("publish_error", str(exc)[:120])
+                return None
+
+        _pub_results = await asyncio.gather(
+            *[_publish_one(p, v) for p, v in answers], return_exceptions=True
+        )
+        claim_records = [r for r in _pub_results if isinstance(r, dict)]
+
+    # ---- Citations: agents who agree with someone else cite that claim --
+    # An agent "cites" another when its confidence is within ±10pp of
+    # another agent's claim from a different persona. We surface this in
+    # the dashboard's conversation feed.
+    citations: list[dict[str, Any]] = []
+    for prof, vote in answers:
+        my_conf = vote["confidence"]
+        my_kid = next(
+            (c["kid"] for c in claim_records if c["agent"] == prof.name),
+            None,
+        )
+        if my_kid is None:
+            continue
+        # Find someone from a different persona whose confidence is within ±10pp
+        for c in claim_records:
+            if c["agent"] == prof.name or c["persona"] == prof.persona:
+                continue
+            if abs(c["confidence"] - my_conf) > 0.10:
+                continue
+            citations.append(
+                {
+                    "from_agent": prof.name,
+                    "from_persona": prof.persona,
+                    "to_agent": c["agent"],
+                    "to_persona": c["persona"],
+                    "to_claim_kid": c["kid"],
+                    "their_conf": c["confidence"],
+                    "my_conf": my_conf,
+                    "delta": round(abs(c["confidence"] - my_conf), 4),
+                    "query": query,
+                }
+            )
+            prof.record_timeline(
+                "cite",
+                f"Cited {c['agent']} (Δ{abs(c['confidence'] - my_conf):.0%})",
+                target_kid=c["kid"],
+                target_agent=c["agent"],
+            )
+            break  # one citation per question per agent is enough
+
+    # ---- Disputes: agents who strongly disagree (≥30pp) file a dispute -
+    disputes_filed: list[dict[str, Any]] = []
+    if enable_disputes:
+        async def _dispute_one(prof: "AgentProfile", vote: dict) -> "dict | None":
+            my_conf = vote["confidence"]
+            opposing = [c for c in claim_records if c["agent"] != prof.name]
+            if not opposing:
+                return None
+            extreme = max(opposing, key=lambda c: abs(c["confidence"] - my_conf))
+            delta = abs(extreme["confidence"] - my_conf)
+            if delta < 0.30:
+                return None
+            try:
+                target_kid_bytes = bytes.fromhex(extreme["kid"])
+                dispute_kid = await prof.agent.dispute(
+                    target_kid_bytes,
+                    reason=(
+                        f"As a {prof.persona}, I answered {my_conf:.0%} but "
+                        f"{extreme['agent']} ({extreme['persona']}) answered "
+                        f"{extreme['confidence']:.0%}. {prof.persona_info.get('label', prof.persona)} "
+                        f"perspective contests this."
+                    ),
+                    bond_topic_scope=TOPIC,
+                )
+                prof.record_timeline(
+                    "dispute",
+                    f"Disputed {extreme['agent']} (Δ{delta:.0%})",
+                    target_kid=extreme["kid"],
+                    target_agent=extreme["agent"],
+                )
+                return {
+                    "from_agent": prof.name,
+                    "from_persona": prof.persona,
+                    "target_agent": extreme["agent"],
+                    "target_persona": extreme["persona"],
+                    "target_kid": extreme["kid"],
+                    "dispute_kid": dispute_kid.hex(),
+                    "delta": round(delta, 4),
+                    "query": query,
+                    "ts_wall_ms": int(time.time() * 1000),
+                }
+            except Exception as exc:
+                prof.record_timeline("dispute_error", str(exc)[:120])
+                return None
+
+        _disp_results = await asyncio.gather(
+            *[_dispute_one(p, v) for p, v in answers], return_exceptions=True
+        )
+        disputes_filed = [r for r in _disp_results if isinstance(r, dict)]
+
+    return {
+        "id": qid,
+        "query": query,
+        "ground_truth": ground_truth,
+        "n_responses": len(answers),
+        "mean_confidence": round(mean_conf, 4),
+        "min_confidence": round(min(confidences), 4),
+        "max_confidence": round(max(confidences), 4),
+        "spread": round(max(confidences) - min(confidences), 4),
+        "lowest": {"agent": sorted_pa[0][0].name, "confidence": sorted_pa[0][1]["confidence"]},
+        "highest": {"agent": sorted_pa[-1][0].name, "confidence": sorted_pa[-1][1]["confidence"]},
+        "elapsed_ms": round(elapsed_ms, 1),
+        "claims": claim_records,
+        "citations": citations,
+        "disputes": disputes_filed,
+        "per_agent": [
+            {
+                "agent": p.name,
+                "persona": p.persona,
+                "confidence": v["confidence"],
+                "reasoning": v.get("reasoning", "")[:2000],
+            }
+            for p, v in answers
+        ],
+    }
+
+
+# ---------------------------------------------------------------------------
+# Debug formatter (Rich, emoji-prefixed)
+# ---------------------------------------------------------------------------
+
+
+def _print_per_agent_block(console: Console, prof: AgentProfile, vote: dict) -> None:
+    """Print a non-tech-friendly per-agent block after they answer."""
+    info = prof.persona_info
+    emoji = info.get("emoji", "🎭")
+    conf = vote.get("confidence", 0.0)
+    n_tools = vote.get("n_tool_calls", 0)
+    elapsed_ms = vote.get("elapsed_ms", 0)
+    reasoning = (vote.get("reasoning", "") or "").strip()
+    if len(reasoning) > 500:
+        reasoning = reasoning[:500] + "…"
+
+    head = (
+        f"{emoji} [bold cyan]{prof.name}[/bold cyan]  "
+        f"[white]conf={conf:.2f}[/white]  "
+        f"[dim]{elapsed_ms:.0f}ms · tools={n_tools}[/dim]"
+    )
+    console.print(head)
+
+    # Tool calls just made on this query
+    recent_tools = [t for t in prof.tool_calls if t.get("query") == vote.get("query")]
+    for t in recent_tools[-5:]:  # cap visible
+        tool_name = t.get("tool", "?")
+        args = t.get("args_json", "")
+        if len(args) > 80:
+            args = args[:80] + "…"
+        console.print(f"   ↳ [yellow]{tool_name}[/yellow]([dim]{args}[/dim])")
+
+    if reasoning:
+        console.print(f"   💭 [italic]{reasoning}[/italic]")
+
+    # Memory diff
+    last_mem = prof.memory_states[-1] if prof.memory_states else None
+    if last_mem and last_mem.get("diff"):
+        diff = last_mem["diff"]
+        if diff["added"] or diff["changed"]:
+            tags = []
+            if diff["added"]:
+                tags.append(f"added={diff['added']}")
+            if diff["changed"]:
+                tags.append(f"changed={diff['changed']}")
+            console.print(f"   📌 [magenta]memory:[/magenta] [dim]{', '.join(tags)}[/dim]")
+    console.print()
+
+
+def _print_panel_diff(console: Console, panel_record: dict) -> None:
+    """Print a non-tech disagreement summary after every panel."""
+    console.print()
+    console.rule(
+        f"[bold]Q: {panel_record['query'][:70]}[/bold]",
+        style="cyan",
+    )
+    n = panel_record.get("n_responses", 0)
+    if n == 0:
+        console.print("[red]No responses[/red]")
+        return
+    mean = panel_record.get("mean_confidence", 0)
+    spread = panel_record.get("spread", 0)
+    console.print(
+        f"[bold]Panel mean: {mean:.0%}[/bold]   "
+        f"[dim]spread: {spread:.0%} across {n} answers · "
+        f"{panel_record.get('elapsed_ms', 0):.0f}ms[/dim]"
+    )
+    high = panel_record.get("highest", {})
+    low = panel_record.get("lowest", {})
+    if high and low:
+        console.print(
+            f"  ⬆ Most YES: [green]{high.get('agent', '?')}[/green]   "
+            f"{high.get('confidence', 0):.0%}"
+        )
+        console.print(
+            f"  ⬇ Most NO:  [red]{low.get('agent', '?')}[/red]    {low.get('confidence', 0):.0%}"
+        )
+    if panel_record.get("ground_truth") is not None:
+        gt = panel_record["ground_truth"]
+        delta = abs(mean - gt)
+        flag = (
+            "[green]✓ within target[/green]"
+            if delta < 0.10
+            else f"[yellow]Δ={delta:.0%} from target {gt:.0%}[/yellow]"
+        )
+        console.print(f"  🎯 Calibration: {flag}")
+    console.print()
+
+
+# ---------------------------------------------------------------------------
+# Trace serialisation
+# ---------------------------------------------------------------------------
+
+
+def _trace_to_dict(trace: Trace) -> dict[str, Any]:
+    # Build a unified, chronologically-sorted "conversation feed" of all
+    # protocol events: claims, citations, disputes. This is what powers
+    # the dashboard's Conversation view.
+    feed: list[dict[str, Any]] = []
+    for p in trace.profiles:
+        for c in p.published_claims:
+            feed.append({**c, "kind": "claim"})
+    for r in trace.panel_records:
+        for cite in r.get("citations", []):
+            feed.append({**cite, "kind": "citation", "ts_wall_ms": r.get("ts_wall_ms", 0)})
+        for d in r.get("disputes", []):
+            feed.append({**d, "kind": "dispute"})
+    feed.sort(key=lambda x: x.get("ts_wall_ms", 0))
+
+    total_claims = sum(len(p.published_claims) for p in trace.profiles)
+    total_citations = sum(len(r.get("citations", [])) for r in trace.panel_records)
+    total_disputes = sum(len(r.get("disputes", [])) for r in trace.panel_records)
+
+    total_llm_calls = sum(p.n_llm_calls for p in trace.profiles)
+    total_input_tokens = sum(p.total_input_tokens for p in trace.profiles)
+    total_output_tokens = sum(p.total_output_tokens for p in trace.profiles)
+    estimated_cost_usd = _estimate_cost(
+        trace.llm_model or "",
+        total_input_tokens,
+        total_output_tokens,
+    )
+
+    # Collective IQ score (P9 / P10)
+    collective_iq = compute_collective_iq(trace)
+
+    return {
+        "started_at": trace.started_at,
+        "finished_at": trace.finished_at,
+        "elapsed_s": round(trace.finished_at - trace.started_at, 4),
+        "topic": trace.topic,
+        "use_real_llm": trace.use_real_llm,
+        "llm_model": trace.llm_model,
+        "n_agents": len(trace.profiles),
+        "n_questions": len(trace.questions),
+        "total_tool_calls": trace.total_tool_calls,
+        "total_llm_calls": total_llm_calls,
+        "total_input_tokens": total_input_tokens,
+        "total_output_tokens": total_output_tokens,
+        "estimated_cost_usd": estimated_cost_usd,
+        "total_claims": total_claims,
+        "total_citations": total_citations,
+        "total_disputes": total_disputes,
+        "conversation_feed": feed,
+        # ── Collective intelligence wiring (P1–P10) ──
+        "collective_iq": collective_iq,
+        "deliberation_records": trace.deliberation_records,
+        "oracle_resolutions": trace.oracle_resolutions,
+        "syntheses": trace.syntheses,
+        "vouches": trace.vouches,
+        "captoken_events": trace.captoken_events,
+        "audit_replay": trace.audit_replay,
+        "reputation_snapshots": trace.reputation_snapshots,
+        # ── Phase timing breakdown (KPI #1) ──
+        "setup_s": round(trace.setup_s, 3),
+        "deliberation_s": round(trace.deliberation_s, 3),
+        "oracle_s": round(trace.oracle_s, 3),
+        "synthesis_s": round(trace.synthesis_s, 3),
+        "n_deliberation_rounds": trace.n_deliberation_rounds,
+        "questions_timing": trace.questions_timing,
+        "questions": trace.questions,
+        "panel_records": trace.panel_records,
+        "personas": {
+            name: {
+                "label": info["label"],
+                "emoji": info.get("emoji", "🎭"),
+                "tool_affinity": info.get("tool_affinity"),
+                "system_prompt": info.get("system"),
+                "starting_memory": info.get("starting_memory", []),
+            }
+            for name, info in PERSONAS.items()
+            if name in {p.persona for p in trace.profiles}
+        },
+        "agents": [
+            {
+                "name": p.name,
+                "persona": p.persona,
+                "kid": p.agent.keypair.kid.hex(),
+                "did_key": p.agent.keypair.did_key,
+                "starting_memory": list(p.persona_info.get("starting_memory", [])),
+                # Full persona_info dict including the (possibly
+                # swarm-bias-modified) system prompt, label, emoji,
+                # tool_affinity, n_eff. Lets the UI show *exactly* what
+                # this agent was instantiated with, even if a swarm
+                # appended a shared bias to a built-in persona.
+                "persona_info": dict(p.persona_info),
+                "panel_votes": p.panel_votes,
+                "tool_calls": p.tool_calls,
+                "memory_states": [
+                    {
+                        "ts_wall_ms": m["ts_wall_ms"],
+                        "query": m["query"],
+                        "diff": m["diff"],
+                    }
+                    for m in p.memory_states
+                ],
+                "final_memory": p.agent.working_memory(),
+                "structured": p.structured,
+                "agent_timeline": p.agent_timeline,
+                "published_claims": p.published_claims,
+                "n_panel_votes": len(p.panel_votes),
+                "n_tool_calls": len(p.tool_calls),
+                "n_claims_published": len(p.published_claims),
+                "n_llm_calls": p.n_llm_calls,
+                "input_tokens": p.total_input_tokens,
+                "output_tokens": p.total_output_tokens,
+            }
+            for p in trace.profiles
+        ],
+    }
+
+
+def _flush_sim_memory_to_relata(profiles: "list[AgentProfile]", *, sim_id: str) -> None:
+    """Flush each agent's facts_learned to Relata after a sim completes.
+
+    Best-effort: any exception is swallowed so Relata unavailability never
+    blocks a sim. Requires RELATA_URL to be set; no-ops otherwise.
+    """
+    url = os.getenv("RELATA_URL")
+    if not url:
+        return
+    try:
+        from hypermind.mind.memory_store import RelataMemoryStore
+    except ImportError:
+        return
+    for prof in profiles:
+        try:
+            facts = prof.agent.working_memory().get("facts_learned", [])
+            if not facts:
+                continue
+            items = [
+                f.get("fact", str(f)) if isinstance(f, dict) else str(f)
+                for f in facts
+            ]
+            kid_bytes = bytes(prof.agent.keypair.kid)
+            store = RelataMemoryStore(
+                url,
+                namespace_id=f"simlab-{sim_id[:12]}",
+                agent_kid=kid_bytes,
+                purpose="agent_notes",
+            )
+            store.open()
+            store.remember_batch(items)
+            store.close()
+        except Exception:
+            pass
+
+
+def _write_html_viewer(html_path: str, json_filename: str) -> None:
+    """Deprecated: the static HTML debugger has been removed.
+
+    Modern usage: ``hmctl simlab`` boots a Vue 3 SPA + ASGI app that
+    lists, streams, and compares runs. This function is a no-op and
+    is kept only so the legacy ``--html`` CLI flag does not crash.
+    """
+    return None
+
+
+# ===========================================================================
+# COLLECTIVE INTELLIGENCE WIRING — P1 through P10 from the architecture audit
+# ===========================================================================
+#
+# These helpers wire the protocol primitives that make the panel
+# behave as a collective rather than a parallel pool of LLMs:
+#
+#   P1 deliberation rounds          (run_deliberation_phase)
+#   P2 peer claim subscription      (setup_peer_subscriptions)
+#   P3 oracle resolution + backprop (run_oracle_phase)
+#   P4 synthesize() w/ parent_kids  (synthesize_panel_verdict)
+#   P5 prior-self memory injection  (inject_prior_self_into_responder)
+#   P6 vouch chain                  (run_vouch_phase)
+#   P7 CapToken gates               (mint_oracle_captoken + demonstrate_refusal)
+#   P8 audit_export + replay        (capture_and_replay_audit)
+#   P9/P10 dashboard surface        (computed in trace_to_dict)
+
+
+async def setup_peer_subscriptions(profiles: list[AgentProfile]) -> int:
+    """P2 — make every agent subscribe to the topic so they hear each other.
+
+    When peer_X publishes a claim, this agent's working_memory["peer_claims"]
+    grows with the new claim's metadata. Subsequent LLM responder calls see
+    a 'peer claims' section in their context.
+    """
+    n_subs = 0
+
+    def _make_callback(prof: AgentProfile):
+        async def _on_claim(event: Any) -> None:
+            try:
+                stmt = getattr(event, "statement", None)
+                if stmt is None:
+                    return
+                # Skip our own claims
+                if stmt.issuer_kid == prof.agent.keypair.kid:
+                    return
+                # Decode payload to find another agent's panel answer
+                import cbor2
+
+                try:
+                    decoded = cbor2.loads(stmt.payload)
+                except Exception:
+                    return
+                inner = decoded.get("payload", {}) if isinstance(decoded, dict) else {}
+                if not isinstance(inner, dict) or inner.get("kind") != "panel_answer":
+                    return
+                mem = prof.agent.working_memory()
+                peer_claims = mem.setdefault("peer_claims", [])
+                peer_claims.append(
+                    {
+                        "issuer_kid_hex": stmt.issuer_kid.hex()[:24],
+                        "persona": inner.get("persona", "unknown"),
+                        "query": inner.get("query", ""),
+                        "confidence": inner.get("confidence"),
+                        "reasoning": (inner.get("reasoning", "") or "")[:400],
+                        "claim_kid_hex": stmt.kid.hex(),
+                        "ts_wall_ms": int(time.time() * 1000),
+                    }
+                )
+                # Bound the list so memory doesn't grow unboundedly
+                if len(peer_claims) > 1000:
+                    peer_claims[:] = peer_claims[-1000:]
+            except Exception:
+                pass
+
+        return _on_claim
+
+    for p in profiles:
+        try:
+            sub = await p.agent.subscribe(TOPIC, _make_callback(p))
+            if sub is not None:
+                n_subs += 1
+        except Exception:
+            pass
+    return n_subs
+
+
+async def run_deliberation_phase(
+    profiles: list[AgentProfile],
+    question: dict,
+    responder: TracingPersonaResponder,
+    panel_record_round0: dict,
+    *,
+    n_extra_rounds: int = 1,
+    convergence_threshold: float = 0.05,
+) -> list[dict[str, Any]]:
+    """P1 — after round-0, run additional rounds where each agent sees an
+    anonymised peer reasoning summary and may revise.
+
+    Returns a list of round records: [{round_idx, mean, spread, deltas: [...]}].
+    Round-0 is included as the first entry.
+    """
+    rounds: list[dict[str, Any]] = []
+
+    # Round 0 — already happened
+    rounds.append(
+        {
+            "round_idx": 0,
+            "mean": panel_record_round0.get("mean_confidence"),
+            "spread": panel_record_round0.get("spread"),
+            "n_responses": panel_record_round0.get("n_responses"),
+        }
+    )
+
+    query = question.get("query", "")
+    last_mean = panel_record_round0.get("mean_confidence", 0)
+    last_spread = panel_record_round0.get("spread", 1.0)
+
+    for r in range(1, n_extra_rounds + 1):
+        # Prepare per-agent contextualised query with peer summary
+        _round_results: list[tuple[AgentProfile, float, str]] = []  # (prof, conf, reasoning)
+
+        async def _re_elicit(prof: AgentProfile):
+            # Skip agents that already converged in the previous round
+            if r > 1:
+                votes_for_q = [v for v in prof.panel_votes if query[-50:] in (v.get("query") or "")]
+                if len(votes_for_q) >= 2:
+                    delta = abs(votes_for_q[-1].get("confidence", 0) - votes_for_q[-2].get("confidence", 0))
+                    if delta < 0.03:
+                        return  # converged — skip this LLM call
+            peer_summary = _peer_reasoning_summary(profiles, query, prof.agent.keypair.kid)
+            ctx_query = (
+                f"{peer_summary}\n\n--- ORIGINAL QUESTION ---\n{query}" if peer_summary else query
+            )
+            try:
+                await asyncio.wait_for(
+                    responder(prof.agent.keypair.kid, ctx_query),
+                    timeout=45.0,
+                )
+            except TimeoutError:
+                pass
+            except asyncio.CancelledError:
+                raise
+            except Exception:
+                pass
+
+        await asyncio.gather(*[_re_elicit(p) for p in profiles], return_exceptions=True)
+
+        # Collect each profile's *latest* vote on this query (the round-r answer)
+        confs: list[float] = []
+        deltas: list[dict[str, Any]] = []
+        for p in profiles:
+            votes_for_q = [
+                v
+                for v in p.panel_votes
+                if v.get("query")
+                in (
+                    query,
+                    f"{query}",
+                )
+                or query[-50:] in (v.get("query", "") or "")
+            ]
+            # The newly-appended one will be at the end if peer_summary was prefixed
+            # Take the LATEST vote regardless of exact-query-match (deliberation
+            # appends a contextualised query, but we still want the latest pick).
+            if not votes_for_q:
+                # fallback: just take the absolute latest vote
+                votes_for_q = p.panel_votes[-1:] if p.panel_votes else []
+            if not votes_for_q:
+                continue
+            latest = votes_for_q[-1]
+            if "confidence" not in latest:
+                continue
+            new_conf = latest["confidence"]
+            confs.append(new_conf)
+            # Compare to round-(r-1)
+            prior = next(
+                (
+                    v
+                    for v in reversed(p.panel_votes[:-1])
+                    if v.get("query") == query and "confidence" in v
+                ),
+                None,
+            )
+            prior_conf = prior["confidence"] if prior else None
+            deltas.append(
+                {
+                    "agent": p.name,
+                    "persona": p.persona,
+                    "prior": prior_conf,
+                    "new": new_conf,
+                    "delta": (new_conf - prior_conf) if prior_conf is not None else 0.0,
+                }
+            )
+
+        if not confs:
+            break
+        new_mean = sum(confs) / len(confs)
+        new_spread = max(confs) - min(confs)
+        rounds.append(
+            {
+                "round_idx": r,
+                "mean": round(new_mean, 4),
+                "spread": round(new_spread, 4),
+                "n_responses": len(confs),
+                "deltas": deltas,
+            }
+        )
+        # Convergence: if mean shifted < threshold AND spread tightened, stop.
+        if abs(new_mean - last_mean) < convergence_threshold and new_spread <= last_spread:
+            break
+        last_mean = new_mean
+        last_spread = new_spread
+
+    return rounds
+
+
+async def synthesize_panel_verdict(
+    anchor_agent: HyperMindAgent,
+    panel_record: dict,
+) -> dict[str, Any] | None:
+    """P4 — anchor agent seals the panel verdict as a synthesis with parent_kids
+    pointing at every contributing claim.
+    """
+    claims = panel_record.get("claims", []) or []
+    if not claims:
+        return None
+    parent_kids = [bytes.fromhex(c["kid"]) for c in claims if c.get("kid")]
+    mean = panel_record.get("mean_confidence", 0.5)
+    n_eff = max(2.0, float(len(claims)))
+    try:
+        synth_kid = await anchor_agent.synthesize(
+            parent_kids=parent_kids,
+            summary_payload={
+                "kind": "panel_synthesis",
+                "query": panel_record.get("query", ""),
+                "mean_confidence": mean,
+                "spread": panel_record.get("spread"),
+                "n_contributing_claims": len(parent_kids),
+            },
+            uncertainty=Uncertainty.beta(
+                max(1.0, mean * n_eff * 5),
+                max(1.0, (1 - mean) * n_eff * 5),
+            ),
+        )
+        return {
+            "synthesis_kid": synth_kid.hex(),
+            "anchor": anchor_agent.keypair.kid.hex()[:24],
+            "n_parents": len(parent_kids),
+            "mean": mean,
+            "query": panel_record.get("query", ""),
+            "ts_wall_ms": int(time.time() * 1000),
+        }
+    except Exception:
+        return None
+
+
+def generate_followup_questions(
+    panel_records: list[dict],
+    oracle_resolutions: list[dict] | None = None,
+    *,
+    top_k: int = 10,
+    spread_threshold: float = 0.25,
+    low_conf_threshold: float = 0.45,
+) -> list[dict]:
+    """Generate autonomous follow-up questions from simulation results (spec §20.5 / P7).
+
+    Heuristic triggers (no LLM required):
+    - high_spread: panel disagreed (spread > spread_threshold)
+    - dispute: claims were actively disputed and not resolved
+    - low_confidence: panel was ambiguous (mean < low_conf_threshold and > 1-low_conf_threshold)
+    - gap: question referenced in reasoning but never directly asked
+
+    Returns list of dicts with: text, rationale, uncertainty_score, source_question, trigger.
+    """
+    resolved_queries: set[str] = {r["oracle"] for r in (oracle_resolutions or [])}
+    followups: list[dict] = []
+
+    for rec in panel_records:
+        query = rec.get("query", "")
+        mean_conf = rec.get("mean_confidence", 0.5)
+        spread = rec.get("spread", 0.0)
+        disputes = rec.get("disputes", [])
+        is_resolved = query in resolved_queries
+
+        # Trigger 1: high spread — panel disagreed significantly
+        if spread >= spread_threshold:
+            uncertainty_score = min(1.0, spread * 2.5)
+            followups.append(
+                {
+                    "text": (
+                        f"Given the panel disagreement on '{query[:120]}' "
+                        f"(confidence spread: {spread:.0%}), what specific evidence "
+                        f"or data source would most effectively resolve this uncertainty?"
+                    ),
+                    "rationale": (
+                        f"Panel spread was {spread:.0%} — agents disagreed significantly. "
+                        f"Mean confidence: {mean_conf:.0%}. Investigating the root cause "
+                        f"of disagreement would sharpen the collective estimate."
+                    ),
+                    "uncertainty_score": uncertainty_score,
+                    "source_question": query,
+                    "trigger": "high_spread",
+                }
+            )
+
+        # Trigger 2: active disputes not resolved
+        if disputes and not is_resolved:
+            n_disputes = len(disputes)
+            uncertainty_score = min(1.0, 0.4 + n_disputes * 0.15)
+            disputors = list({d.get("from_persona", "") for d in disputes[:3]})
+            followups.append(
+                {
+                    "text": (
+                        f"The claim '{query[:120]}' triggered {n_disputes} dispute(s). "
+                        f"What is the strongest argument against the majority position, "
+                        f"and what evidence would settle it?"
+                    ),
+                    "rationale": (
+                        f"{n_disputes} agent(s) disputed this claim without resolution. "
+                        f"Contesting personas: {', '.join(disputors[:3])}. "
+                        f"Targeted investigation of the counterargument could resolve the dispute."
+                    ),
+                    "uncertainty_score": uncertainty_score,
+                    "source_question": query,
+                    "trigger": "dispute",
+                }
+            )
+
+        # Trigger 3: ambiguous confidence (neither clearly yes nor clearly no)
+        if (
+            low_conf_threshold <= mean_conf <= (1.0 - low_conf_threshold)
+            and spread < spread_threshold
+        ):
+            uncertainty_score = 1.0 - abs(mean_conf - 0.5) * 4
+            followups.append(
+                {
+                    "text": (
+                        f"The panel was ambiguous on '{query[:120]}' "
+                        f"(mean confidence: {mean_conf:.0%}). "
+                        f"What additional context or time horizon would shift this toward a clearer verdict?"
+                    ),
+                    "rationale": (
+                        f"Mean confidence {mean_conf:.0%} is in the ambiguous zone "
+                        f"(neither YES nor NO). The panel is uncertain rather than divided. "
+                        f"Probing assumptions or seeking base-rate data may resolve ambiguity."
+                    ),
+                    "uncertainty_score": uncertainty_score,
+                    "source_question": query,
+                    "trigger": "low_confidence",
+                }
+            )
+
+    # Trigger 4: knowledge gaps — terms in reasoning that look like unanswered questions
+    asked_queries = {rec.get("query", "").lower() for rec in panel_records}
+    for rec in panel_records:
+        for agent_rec in rec.get("per_agent", []):
+            reasoning = agent_rec.get("reasoning", "")
+            # Heuristic: sentences ending with "?" that aren't the original query
+            import re
+
+            sub_questions = re.findall(r"[^.!?]*\?", reasoning)
+            for sq in sub_questions:
+                sq_clean = sq.strip()
+                if (
+                    len(sq_clean) > 20
+                    and sq_clean.lower() not in asked_queries
+                    and not any(sq_clean.lower() in q for q in asked_queries)
+                ):
+                    followups.append(
+                        {
+                            "text": sq_clean,
+                            "rationale": (
+                                f"Surfaced from agent reasoning on '{rec.get('query', '')[:80]}'. "
+                                f"This sub-question was raised but not directly investigated."
+                            ),
+                            "uncertainty_score": 0.6,
+                            "source_question": rec.get("query", ""),
+                            "trigger": "gap",
+                        }
+                    )
+                    asked_queries.add(sq_clean.lower())  # dedup
+
+    # Sort by uncertainty_score descending, deduplicate by source_question+trigger
+    seen: set[tuple] = set()
+    deduped: list[dict] = []
+    for fq in sorted(followups, key=lambda x: x["uncertainty_score"], reverse=True):
+        key = (fq["source_question"], fq["trigger"])
+        if key not in seen:
+            seen.add(key)
+            deduped.append(fq)
+
+    return deduped[:top_k]
+
+
+async def run_vouch_phase(profiles: list[AgentProfile], topic: str) -> list[dict[str, Any]]:
+    """P6 — bootstrap trust before questions: each oracle vouches for one
+    agent per other persona. Returns a list of vouch records.
+
+    Persona scenario doesn't have a built-in 'oracle' role, so we treat
+    the *first* agent of each persona as a 'persona elder' that vouches
+    for the first agents of the other personas at low strength.
+    """
+    vouch_records: list[dict[str, Any]] = []
+    by_persona: dict[str, list[AgentProfile]] = {}
+    for p in profiles:
+        by_persona.setdefault(p.persona, []).append(p)
+
+    elders = [v[0] for v in by_persona.values()]
+    if len(elders) < 2:
+        return []
+
+    for voucher in elders:
+        # Vouch for one elder per other persona (low strength to keep cap visible)
+        for vouchee in elders:
+            if vouchee.persona == voucher.persona:
+                continue
+            try:
+                voucher.agent._world.reputation.vouch(
+                    voucher.agent.keypair.kid,
+                    vouchee.agent.keypair.kid,
+                    topic,
+                    strength=0.3,
+                )
+                # Snapshot reputation after to record the move
+                snap = voucher.agent._world.reputation.snapshot(
+                    vouchee.agent.keypair.kid,
+                    topic,
+                )
+                vouch_records.append(
+                    {
+                        "voucher": voucher.name,
+                        "voucher_persona": voucher.persona,
+                        "vouchee": vouchee.name,
+                        "vouchee_persona": vouchee.persona,
+                        "topic": topic,
+                        "strength": 0.3,
+                        "vouchee_score_after": round(snap.score, 4),
+                        "ts_wall_ms": int(time.time() * 1000),
+                    }
+                )
+            except Exception:
+                pass
+    return vouch_records
+
+
+async def run_oracle_phase(
+    profiles: list[AgentProfile],
+    panel_records: list[dict],
+    *,
+    role_oracle_persona: str = "pattern-matcher-historian",
+) -> list[dict[str, Any]]:
+    """P3 — for every question with a ground_truth, an oracle agent resolves
+    each per-agent claim with the truth bool. The kernel updates each
+    publisher's reputation in the topic. Returns a list of resolution
+    records for the dashboard.
+
+    We pick the *first* agent of ``role_oracle_persona`` and set its role
+    to "oracle". Their CapToken (P7) gates the resolution.
+    """
+    oracle = next((p for p in profiles if p.persona == role_oracle_persona), None)
+    if oracle is None:
+        oracle = profiles[0]
+    oracle.agent.role = "oracle"
+    # S5 — late-binding role update on the persona registry so the
+    # canvas role-ring and tooltip reflect the oracle assignment.
+    try:
+        from . import _persona_registry
+
+        # Find sim_id from the recorder if available (registry stores it
+        # under whatever sim_id was used at remember() time; we just
+        # update the in-flight bucket by walking).
+        # The simpler path: update under all sim_ids that contain this
+        # agent (in practice exactly one).
+        kid_hex = oracle.agent.keypair.kid.hex()
+        with _persona_registry._LOCK:
+            for _sim_id, bucket in _persona_registry._REGISTRY.items():
+                if kid_hex in bucket:
+                    bucket[kid_hex]["role"] = "oracle"
+                if oracle.name in bucket:
+                    bucket[oracle.name]["role"] = "oracle"
+    except Exception:
+        pass
+
+    # CapToken minted in main(); we just use it implicitly via agent.cap_token.
+
+    async def _resolve_one(claim: dict, outcome_bool: bool, gt: float) -> "dict | None":
+        try:
+            kid_bytes = bytes.fromhex(claim["kid"])
+            resolved_kid = await oracle.agent.oracle_resolve(
+                kid_bytes,
+                outcome=outcome_bool,
+                evidence_cid=b"\xde\xad\xbe\xef" * 8,
+                backprop=True,
+            )
+            return {
+                "oracle": oracle.name,
+                "resolved_kid": claim["kid"],
+                "publisher": claim.get("agent"),
+                "publisher_persona": claim.get("persona"),
+                "outcome": outcome_bool,
+                "ground_truth": gt,
+                "predicted_confidence": claim.get("confidence"),
+                "resolution_kid": resolved_kid.hex() if resolved_kid else None,
+                "ts_wall_ms": int(time.time() * 1000),
+            }
+        except Exception:
+            return None
+
+    _tasks = [
+        _resolve_one(claim, gt >= 0.5, gt)
+        for rec in panel_records
+        for gt_raw in [rec.get("ground_truth")]
+        if gt_raw is not None
+        for gt in [float(gt_raw)]
+        for claim in (rec.get("claims") or [])
+    ]
+    _res = await asyncio.gather(*_tasks, return_exceptions=True)
+    resolutions: list[dict[str, Any]] = [r for r in _res if isinstance(r, dict)]
+    return resolutions
+
+
+def mint_oracle_captoken(oracle_agent: HyperMindAgent, topic: str) -> dict[str, Any]:
+    """P7 — mint a CapToken authorising oracle_resolution on this topic only.
+
+    Returns a metadata dict for the dashboard. The token itself is
+    attached to the agent as ``agent.cap_token``.
+    """
+    try:
+        from hypermind.capability import CapToken, Caveat
+
+        token = CapToken.mint(
+            issuer_keypair=oracle_agent.keypair,
+            subject=oracle_agent.keypair.kid,
+            caveats=[
+                Caveat.topic(topic),
+                Caveat.claim_type("oracle_resolution"),
+            ],
+        )
+        oracle_agent.cap_token = token
+        return {
+            "issuer_kid": oracle_agent.keypair.kid.hex()[:24],
+            "topic": topic,
+            "claim_type": "oracle_resolution",
+            "minted_at_ms": int(time.time() * 1000),
+        }
+    except Exception as exc:
+        return {"error": str(exc)[:160]}
+
+
+async def attempt_unauthorised_resolve(
+    non_oracle: AgentProfile,
+    target_kid: bytes,
+) -> dict[str, Any]:
+    """P7 — demonstrate the security gate by having a non-oracle agent
+    try oracle_resolve. The role check raises AuthError; we record this
+    as an audit event for the dashboard.
+    """
+    try:
+        await non_oracle.agent.oracle_resolve(
+            target_kid,
+            outcome=True,
+            evidence_cid=b"\x00" * 32,
+        )
+        return {"attempted": non_oracle.name, "blocked": False, "error": None}
+    except Exception as exc:
+        return {
+            "attempted": non_oracle.name,
+            "blocked": True,
+            "error": str(exc)[:200],
+            "error_type": type(exc).__name__,
+        }
+
+
+async def capture_and_replay_audit(
+    anchor_agent: HyperMindAgent,
+    audit_path: str | None = None,
+) -> dict[str, Any]:
+    """P8 — export the audit log, run replay_audit_log(), surface the
+    determinism verdict.
+    """
+    try:
+        from hypermind.eval.replay import replay_audit_log
+
+        lines: list[bytes] = []
+        async for line in anchor_agent.audit_export():
+            lines.append(line if isinstance(line, bytes) else line.encode())
+        if audit_path:
+            try:
+                Path(audit_path).write_bytes(b"\n".join(lines))
+            except Exception:
+                pass
+        result = await replay_audit_log(lines, verify_signatures=True)
+        return {
+            "n_records": result.total_records,
+            "replayed": result.replayed_records,
+            "signature_failures": result.signature_failures,
+            "brier_matches": result.brier_matches,
+            "brier_mismatches": result.brier_mismatches,
+            "deterministic": result.deterministic,
+            "audit_path": audit_path,
+        }
+    except Exception as exc:
+        return {"error": str(exc)[:200]}
+
+
+def snapshot_reputations(
+    profiles: list[AgentProfile], topic: str, label: str
+) -> list[dict[str, Any]]:
+    """Capture per-agent reputation at a point in time (label = 'before',
+    'after_vouch', 'after_oracle'). Used by the dashboard's Trust tab to
+    plot reputation movement."""
+    snaps: list[dict[str, Any]] = []
+    for p in profiles:
+        try:
+            snap = p.agent._world.reputation.snapshot(p.agent.keypair.kid, topic)
+            snaps.append(
+                {
+                    "agent": p.name,
+                    "persona": p.persona,
+                    "label": label,
+                    "score": round(snap.score, 4),
+                    "n_observations": snap.n_observations,
+                    "ts_wall_ms": int(time.time() * 1000),
+                }
+            )
+        except Exception:
+            pass
+    return snaps
+
+
+def compute_collective_iq(trace: Trace) -> dict[str, Any]:
+    """P10 — single 'collective intelligence' score combining four signals."""
+    convergence = 0.0  # how much spread tightened across rounds
+    if trace.deliberation_records:
+        for d in trace.deliberation_records:
+            rounds = d.get("rounds", [])
+            if len(rounds) >= 2:
+                first = rounds[0].get("spread", 1.0) or 1.0
+                last = rounds[-1].get("spread", first) or first
+                convergence += max(0.0, (first - last) / first)
+        convergence = min(1.0, convergence / max(1, len(trace.deliberation_records)))
+
+    calibration = 0.0
+    n_calib = 0
+    for r in trace.panel_records:
+        gt = r.get("ground_truth")
+        mean = r.get("mean_confidence")
+        if gt is None or mean is None:
+            continue
+        calibration += 1.0 - min(1.0, abs(mean - gt) * 2)  # Δ1.0 → 0; Δ0.0 → 1
+        n_calib += 1
+    if n_calib:
+        calibration /= n_calib
+
+    n_claims = sum(len(p.published_claims) for p in trace.profiles) or 1
+    n_links = sum(
+        len(r.get("citations", [])) + len(r.get("disputes", [])) for r in trace.panel_records
+    )
+    coordination_density = min(1.0, n_links / max(1, n_claims))
+
+    rep_motion = 0.0
+    snaps_before = trace.reputation_snapshots.get("before", [])
+    snaps_after = trace.reputation_snapshots.get("after_oracle", [])
+    by_agent_after = {s["agent"]: s["score"] for s in snaps_after}
+    if snaps_before:
+        deltas = []
+        for s in snaps_before:
+            after = by_agent_after.get(s["agent"])
+            if after is not None:
+                deltas.append(abs(after - s["score"]))
+        if deltas:
+            rep_motion = min(1.0, (sum(deltas) / len(deltas)) * 4)
+
+    iq = convergence * 0.4 + calibration * 0.3 + coordination_density * 0.2 + rep_motion * 0.1
+
+    # S3 — EIG/Q (Effective Information Gain per Question, in bits).
+    # Replaces the legacy `score` as the headline number; legacy fields
+    # are kept for back-compat. See eval/swarm_iq for the formula.
+    from hypermind.eval.swarm_iq import effective_information_gain_per_question
+
+    eig = effective_information_gain_per_question(
+        trace.panel_records,
+        trace.deliberation_records,
+    )
+
+    # KPI #3 — convergence trajectory + per-question timing.
+    spread_trajectory: list[float] = []
+    convergence_round: int | None = None
+    for d in trace.deliberation_records:
+        for rnd in d.get("rounds", []) or []:
+            s = rnd.get("spread")
+            if not isinstance(s, (int, float)):
+                continue
+            spread_trajectory.append(round(float(s), 4))
+            if convergence_round is None and float(s) < 0.10:
+                convergence_round = len(spread_trajectory)  # 1-based
+
+    elapsed_s = max(0.0, trace.finished_at - trace.started_at) if trace.finished_at else 0.0
+    n_q = max(1, len(trace.panel_records))
+    if trace.questions_timing:
+        per_q = [
+            float(q.get("elapsed_s", 0.0))
+            for q in trace.questions_timing
+            if isinstance(q.get("elapsed_s"), (int, float))
+        ]
+        mean_question_elapsed_s = (
+            round(sum(per_q) / len(per_q), 4) if per_q else round(elapsed_s / n_q, 4)
+        )
+    else:
+        mean_question_elapsed_s = round(elapsed_s / n_q, 4)
+
+    # time_to_convergence_s: prefer wall-clock to the converging round if
+    # questions_timing carries per-round ts_wall_ms; else use total elapsed.
+    time_to_convergence_s: float = round(elapsed_s, 4)
+    if convergence_round is not None and trace.questions_timing:
+        started_ms = trace.started_at * 1000.0
+        seen = 0
+        found = False
+        for q in trace.questions_timing:
+            if found:
+                break
+            for r in q.get("rounds") or []:
+                seen += 1
+                if seen == convergence_round:
+                    ts = r.get("ts_wall_ms")
+                    if isinstance(ts, (int, float)):
+                        time_to_convergence_s = round((float(ts) - started_ms) / 1000.0, 4)
+                    found = True
+                    break
+
+    return {
+        "score": round(iq, 4),
+        "convergence": round(convergence, 4),
+        "calibration": round(calibration, 4),
+        "coordination_density": round(coordination_density, 4),
+        "reputation_motion": round(rep_motion, 4),
+        # S3 — primary metric:
+        "eig_per_q": [None if (v != v) else round(v, 4) for v in eig["eig_per_q"]],
+        "eig_mean": None if (eig["eig_mean"] != eig["eig_mean"]) else round(eig["eig_mean"], 4),
+        "eig_baseline_h": [round(h, 4) for h in eig["baseline_round0_h"]],
+        "eig_n_scored": eig["n_scored"],
+        # KPI #3 — convergence + timing:
+        "spread_trajectory": spread_trajectory,
+        "convergence_round": convergence_round,
+        "time_to_convergence_s": time_to_convergence_s,
+        "mean_question_elapsed_s": mean_question_elapsed_s,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+
+async def _main_impl(args: argparse.Namespace, *, recorder: Any = None) -> None:
+    """Internal implementation of the persona-panel sim. Called by main()."""
+    console = Console()
+    trace = Trace(started_at=time.perf_counter())
+
+    # Decide question source: free-text topic vs bundled question set.
+    topic = (getattr(args, "topic", "") or "").strip()
+    if topic:
+        _pregenerated = getattr(args, "_pregenerated_questions", None)
+        if _pregenerated:
+            questions = _pregenerated
+        else:
+            from hypermind.simlab.topic_questions import generate_questions_for_topic
+
+            n_q = int(getattr(args, "n_questions", 8) or 8)
+            questions = await generate_questions_for_topic(
+                topic,
+                n_q,
+                model=getattr(args, "llm_model", None),
+                no_llm=bool(getattr(args, "no_llm", False)),
+            )
+        trace.topic = topic  # surfaced in trace.json for the UI
+    else:
+        questions = _load_questions(args.questions)
+    trace.questions = list(questions)
+
+    # Build the responder pool — one per persona
+    api_key = os.environ.get("OPENROUTER_API_KEY", "").strip()
+    use_real_llm = bool(api_key) and not args.no_llm
+    trace.use_real_llm = use_real_llm
+
+    # ── Resolve panel composition ──────────────────────────────────
+    # Three layered modes (highest priority first):
+    #   1. swarm slug   → load saved Swarm; uses its members + tools + bias
+    #   2. personas_override list → ad-hoc list of slugs, each at args.replicas
+    #   3. count fallback → first N built-in personas (legacy behavior)
+    swarm_obj = None
+    persona_replicas: dict[str, int] = {}
+    persona_info_override: dict[str, dict[str, Any]] = {}
+    swarm_tools_override: list[str] | None = None
+
+    swarm_slug = getattr(args, "swarm", None)
+    personas_override = getattr(args, "personas_override", None)
+
+    if swarm_slug:
+        from hypermind.simlab.personas import get_persona as _get_persona
+        from hypermind.simlab.swarms import get_swarm
+
+        swarm_obj = get_swarm(swarm_slug)
+        if swarm_obj is None:
+            raise SystemExit(f"unknown swarm: {swarm_slug!r}")
+        persona_names = []
+        for m in swarm_obj.members:
+            persona_names.append(m.persona_slug)
+            persona_replicas[m.persona_slug] = m.replicas
+            spec = _get_persona(m.persona_slug)
+            if spec is None:
+                raise SystemExit(
+                    f"swarm {swarm_slug!r} references unknown persona {m.persona_slug!r}",
+                )
+            info = {
+                "label": spec.label,
+                "emoji": spec.emoji,
+                "system": (
+                    spec.system + "\n\n" + swarm_obj.bias_prompt
+                    if swarm_obj.bias_prompt
+                    else spec.system
+                ),
+                "starting_memory": list(spec.starting_memory),
+                "tool_affinity": spec.tool_affinity,
+                "n_eff": spec.n_eff,
+            }
+            persona_info_override[m.persona_slug] = info
+        swarm_tools_override = list(swarm_obj.tools) if swarm_obj.tools else []
+    elif personas_override:
+        from hypermind.simlab.personas import get_persona as _get_persona
+
+        persona_names = list(personas_override)
+        for slug in persona_names:
+            spec = _get_persona(slug)
+            if spec is None:
+                raise SystemExit(f"unknown persona slug: {slug!r}")
+            persona_info_override[slug] = {
+                "label": spec.label,
+                "emoji": spec.emoji,
+                "system": spec.system,
+                "starting_memory": list(spec.starting_memory),
+                "tool_affinity": spec.tool_affinity,
+                "n_eff": spec.n_eff,
+            }
+            persona_replicas[slug] = args.replicas
+    else:
+        persona_names = list(PERSONAS.keys())[: args.personas]
+
+    n_agents = sum(persona_replicas.get(p, args.replicas) for p in persona_names)
+
+    console.print(
+        Panel.fit(
+            f"[bold]Persona Panel Simulator[/bold]\n"
+            f"[dim]{n_agents} agents · {len(persona_names)} personas × {args.replicas} replicas · "
+            f"{len(questions)} questions[/dim]",
+            border_style="cyan",
+            title="🎭 PERSONA PANEL",
+        )
+    )
+    console.print()
+
+    if use_real_llm:
+        console.print(
+            f"  [green]✓ LLM mode[/green]  model={args.llm_model}  "
+            f"tools={'on' if args.enable_tools else 'off'}",
+        )
+    else:
+        console.print(
+            "  [yellow]Synthetic mode[/yellow]  (set OPENROUTER_API_KEY for real LLMs)",
+        )
+    trace.llm_model = args.llm_model if use_real_llm else "synthetic"
+    console.print()
+
+    # Persona table
+    pt = Table(show_header=True, box=None, padding=(0, 2))
+    pt.add_column("Persona")
+    pt.add_column("Replicas", justify="right")
+    pt.add_column("Tool affinity", style="yellow")
+    pt.add_column("Starting facts", style="dim")
+    for p in persona_names:
+        info = persona_info_override.get(p) or PERSONAS[p]
+        pt.add_row(
+            f"{info['emoji']}  {info['label']}",
+            str(persona_replicas.get(p, args.replicas)),
+            info.get("tool_affinity", "—"),
+            str(len(info["starting_memory"])),
+        )
+    console.print(pt)
+    if swarm_obj is not None:
+        console.print(
+            f"  [cyan]Swarm:[/cyan] {swarm_obj.name} "
+            f"({swarm_obj.total_agents} agents · "
+            f"tools={swarm_obj.tools or 'none'})"
+        )
+    console.print()
+
+    # Build cohort
+    _namespace = getattr(args, "namespace", NAMESPACE) or NAMESPACE
+    agents = HyperMindAgent.testbed(
+        agents=n_agents,
+        room=ROOM,
+        namespace=_namespace,
+        recorder=recorder,  # I0: scoped recorder so events carry sim_id natively
+    )
+    profiles = _build_profiles(
+        agents,
+        personas=persona_names,
+        replicas=args.replicas,
+        persona_replicas=persona_replicas or None,
+        persona_info_override=persona_info_override or None,
+    )
+    trace.profiles = profiles
+    profiles_by_kid = {p.agent.keypair.kid: p for p in profiles}
+
+    # Publish (sim_id, agent_name) -> persona/emoji to the in-process
+    # registry so the SSE stream can enrich events for the live Activity
+    # canvas. ``args.sim_id`` is set by ``run_persona_sim``; we skip
+    # registration if it isn't present (e.g. a direct legacy invocation).
+    def _infer_role_from_persona(slug: str) -> str:
+        """S5 — map a SimLab persona slug onto a mind/roles.py role.
+
+        Heuristic, kept deterministic: sceptical/contrarian → sceptic;
+        historian/pattern-matcher → synthesist; journalist/curious →
+        scout; lawyer/risk-averse → mediator; otherwise generalist.
+        Oracle is assigned explicitly later by _scenario_impl.
+        """
+        s = (slug or "").lower()
+        if "scept" in s or "contrarian" in s or "sceptic" in s:
+            return "sceptic"
+        if "histor" in s or "synthes" in s or "pattern" in s:
+            return "synthesist"
+        if "journal" in s or "curious" in s or "scout" in s:
+            return "scout"
+        if "lawyer" in s or "risk" in s or "mediat" in s:
+            return "mediator"
+        return "generalist"
+
+    try:
+        sim_id_for_registry = getattr(args, "sim_id", None)
+        if sim_id_for_registry:
+            from . import _persona_registry
+
+            for prof in profiles:
+                emoji = str(prof.persona_info.get("emoji", "") or "")
+                role = _infer_role_from_persona(prof.persona)
+                # Events carry agent_id=keypair.kid.hex(); also register
+                # by friendly name so events that use the friendly name
+                # (e.g. trace-replay) work too.
+                kid_hex = prof.agent.keypair.kid.hex()
+                _persona_registry.remember(
+                    sim_id_for_registry,
+                    kid_hex,
+                    persona=prof.persona,
+                    persona_emoji=emoji,
+                    display_name=prof.name,
+                    role=role,
+                )
+                _persona_registry.remember(
+                    sim_id_for_registry,
+                    prof.name,
+                    persona=prof.persona,
+                    persona_emoji=emoji,
+                    display_name=prof.name,
+                    role=role,
+                )
+    except Exception:
+        pass
+
+    # Build per-persona responders. When a swarm is active and overrides
+    # the tool list, we pass it down so every member shares the same
+    # tools regardless of their per-persona ``tool_affinity``.
+    if use_real_llm:
+        responders = {
+            persona: _build_responder_for_persona(
+                persona,
+                api_key,
+                llm_model=args.llm_model,
+                enable_tools=args.enable_tools,
+                persona_info_override=persona_info_override.get(persona),
+                swarm_tools=swarm_tools_override,
+            )
+            for persona in persona_names
+        }
+    else:
+        synth = _build_synthetic_responder()
+        responders = {persona: synth for persona in persona_names}
+
+    responder = TracingPersonaResponder(profiles_by_kid, responders)
+
+    # ── Collective intelligence wiring ──
+    # P2: every agent subscribes to the topic so they hear each other's claims
+    n_subs = await setup_peer_subscriptions(profiles)
+    console.print(f"  [green]✓[/green] {n_subs} agents subscribed to peer claims (P2)")
+
+    # P6: vouch round before any questions, building bootstrap trust
+    trace.vouches = await run_vouch_phase(profiles, TOPIC)
+    console.print(f"  [green]✓[/green] {len(trace.vouches)} vouches between persona elders (P6)")
+
+    # Snapshot reputations BEFORE any work
+    trace.reputation_snapshots["before"] = snapshot_reputations(profiles, TOPIC, "before")
+
+    # P7: pick the oracle, mint a CapToken authorising oracle_resolution
+    oracle_persona = "pattern-matcher-historian"
+    oracle_prof = next((p for p in profiles if p.persona == oracle_persona), profiles[0])
+    captoken_meta = mint_oracle_captoken(oracle_prof.agent, TOPIC)
+    if captoken_meta:
+        trace.captoken_events.append({"kind": "minted", **captoken_meta})
+        console.print("  [green]✓[/green] CapToken minted for oracle (P7)")
+
+    # Pick an anchor (synthesiser): any non-oracle agent
+    anchor_prof = next((p for p in profiles if p.persona != oracle_persona), profiles[0])
+
+    # S1 — Active question selection scoring.
+    # The InformationGainPlanner scores every question by expected entropy
+    # reduction. We do NOT reorder the iteration here (downstream replay
+    # and trace consumers key on q_idx ordering); instead we score each
+    # question against the running swarm posterior and emit a
+    # `question_chosen` recorder event so the UI's "Now asking" strip can
+    # show the swarm reasoning about its own ignorance.
+    from hypermind.mind.active import CandidateQuestion, InformationGainPlanner
+
+    eig_planner = InformationGainPlanner()
+    swarm_posteriors: dict[str, float] = {}  # qid → running consensus
+
+    def _emit_question_chosen(
+        chosen_idx: int,
+        candidates: list[CandidateQuestion],
+        scores: list[float],
+    ) -> None:
+        """Best-effort: emit one recorder event per question chosen so
+        SimLive's NowAsking strip can render the swarm's selection
+        reasoning. Never breaks the run if it throws."""
+        try:
+            ranked = sorted(zip(scores, candidates, strict=False), key=lambda x: x[0], reverse=True)
+            top = ranked[0] if ranked else (0.0, None)
+            runner_up = ranked[1] if len(ranked) > 1 else (0.0, None)
+            chosen = candidates[chosen_idx]
+            recorder_to_use = recorder if recorder is not None else None
+            if recorder_to_use is None:
+                from hypermind.observability.recorder import get_recorder
+
+                recorder_to_use = get_recorder()
+            recorder_to_use.emit(
+                namespace=_namespace,
+                agent_id="planner",
+                event_type="question_chosen",
+                q_idx=chosen_idx,
+                qid=chosen.qid,
+                eig_score=round(scores[chosen_idx], 4),
+                top_eig=round(float(top[0]), 4),
+                runner_up_eig=round(float(runner_up[0]), 4),
+                top_qid=top[1].qid if top[1] else "",
+                runner_up_qid=runner_up[1].qid if runner_up[1] else "",
+                why=("max-EIG" if chosen_idx == candidates.index(top[1]) else "file-order")
+                if top[1]
+                else "file-order",
+            )
+        except Exception:
+            pass
+
+    # KPI #1 — record setup phase time (from Trace.started_at to first question)
+    trace.setup_s = time.perf_counter() - trace.started_at
+
+    # Iterate questions
+    try:
+        for q_idx, question in enumerate(questions):
+            _q_t0 = time.perf_counter()
+            if args.debug:
+                console.rule(f"[bold]Question {q_idx + 1}/{len(questions)}[/bold]", style="dim")
+                console.print(f"[bold cyan]{question.get('query', '')}[/bold cyan]")
+                console.print()
+
+            # S1 — Score remaining questions and emit question_chosen.
+            try:
+                remaining = list(enumerate(questions))[q_idx:]
+                cands = [
+                    CandidateQuestion(
+                        qid=str(q.get("id") or f"q{i}"),
+                        topic=ROOM,
+                        expected_posterior=swarm_posteriors.get(
+                            str(q.get("id") or f"q{i}"),
+                            0.5,
+                        ),
+                    )
+                    for i, q in remaining
+                ]
+                scores = [eig_planner.score_question(c) for c in cands]
+                # Chosen index in the local `cands` list is always 0 since we
+                # iterate in file order; we still emit the score so the UI
+                # can show "this question's EIG was X bits".
+                _emit_question_chosen(0, cands, scores)
+            except Exception:
+                pass
+
+            # Round 0: parallel cold-elicit
+            try:
+                panel_record = await _ask_panel(profiles, question, responder)
+            except TimeoutError:
+                panel_record = {
+                    "id": question.get("id", ""),
+                    "query": question.get("query", ""),
+                    "ground_truth": question.get("ground_truth"),
+                    "n_responses": 0,
+                    "elapsed_ms": 0.0,
+                    "error": "panel timeout",
+                }
+            trace.panel_records.append(panel_record)
+            # S1 — Update running posterior so next question's EIG score
+            # reflects what the swarm has just learned.
+            try:
+                qid_running = str(question.get("id") or f"q{q_idx}")
+                m = panel_record.get("mean_confidence")
+                if isinstance(m, (int, float)):
+                    swarm_posteriors[qid_running] = float(m)
+            except Exception:
+                pass
+
+            # P1: deliberation rounds (re-elicit with peer reasoning summaries)
+            if args.deliberation_rounds > 1:
+                _delib_t0 = time.perf_counter()
+                rounds = await run_deliberation_phase(
+                    profiles,
+                    question,
+                    responder,
+                    panel_record,
+                    n_extra_rounds=args.deliberation_rounds - 1,
+                )
+                trace.deliberation_s += time.perf_counter() - _delib_t0
+                trace.n_deliberation_rounds += len(rounds)
+                trace.deliberation_records.append(
+                    {
+                        "question_id": question.get("id"),
+                        "query": question.get("query"),
+                        "rounds": rounds,
+                    }
+                )
+                # Update panel_record claims with final post-deliberation
+                # confidences so Brier scoring and the UI reflect what each
+                # agent actually believed after seeing peer reasoning.
+                final_round = rounds[-1] if rounds else None
+                if final_round and final_round.get("round_idx", 0) > 0:
+                    final_round_n = final_round["round_idx"]
+                    # Build a name→final_conf lookup from the deltas
+                    final_conf_by_agent: dict[str, float] = {}
+                    for delta in final_round.get("deltas") or []:
+                        if delta.get("new") is not None:
+                            final_conf_by_agent[delta["agent"]] = delta["new"]
+                    # Update claims in place; stamp the round they ended on
+                    for claim in panel_record.get("claims") or []:
+                        agent_name = claim.get("agent", "")
+                        if agent_name in final_conf_by_agent:
+                            claim["confidence"] = final_conf_by_agent[agent_name]
+                            claim["round"] = final_round_n
+                    # Recompute panel-level mean/spread from updated claims
+                    updated_confs = [
+                        c["confidence"]
+                        for c in (panel_record.get("claims") or [])
+                        if c.get("confidence") is not None
+                    ]
+                    if updated_confs:
+                        panel_record["mean_confidence"] = round(sum(updated_confs) / len(updated_confs), 4)
+                        panel_record["spread"] = round(max(updated_confs) - min(updated_confs), 4)
+
+            # P4: synthesise the panel verdict with parent_kids citation chain
+            _synth_t0 = time.perf_counter()
+            synth = await synthesize_panel_verdict(anchor_prof.agent, panel_record)
+            trace.synthesis_s += time.perf_counter() - _synth_t0
+            if synth is not None:
+                panel_record["synthesis_kid"] = synth.get("synthesis_kid")
+                trace.syntheses.append(synth)
+
+            # KPI #1 — per-question elapsed
+            trace.questions_timing.append(
+                {
+                    "question": question.get("query", ""),
+                    "elapsed_s": round(time.perf_counter() - _q_t0, 3),
+                }
+            )
+
+            if args.debug:
+                # Per-agent debug blocks
+                for prof in profiles:
+                    last_vote = next(
+                        (
+                            v
+                            for v in reversed(prof.panel_votes)
+                            if v.get("query") == question.get("query")
+                        ),
+                        None,
+                    )
+                    if last_vote is None or "confidence" not in last_vote:
+                        continue
+                    _print_per_agent_block(console, prof, last_vote)
+                _print_panel_diff(console, panel_record)
+            else:
+                # Compact one-line summary
+                console.print(
+                    f"  Q{q_idx + 1}/{len(questions)}: "
+                    f"mean={panel_record.get('mean_confidence', 0):.0%}  "
+                    f"spread={panel_record.get('spread', 0):.0%}  "
+                    f"({panel_record.get('elapsed_ms', 0):.0f}ms)",
+                )
+
+        trace.total_tool_calls = sum(len(p.tool_calls) for p in profiles)
+
+        # P3: oracle resolution closes the trust loop
+        _oracle_t0 = time.perf_counter()
+        trace.oracle_resolutions = await run_oracle_phase(
+            profiles,
+            trace.panel_records,
+            role_oracle_persona=oracle_persona,
+        )
+        trace.oracle_s += time.perf_counter() - _oracle_t0
+        if trace.oracle_resolutions:
+            console.print(
+                f"  [green]✓[/green] {len(trace.oracle_resolutions)} oracle resolutions "
+                f"updated reputation (P3)"
+            )
+
+        # P7: demonstrate CapToken refusal — non-oracle attempts oracle_resolve
+        if trace.panel_records and trace.panel_records[0].get("claims"):
+            target = bytes.fromhex(trace.panel_records[0]["claims"][0]["kid"])
+            non_oracle = next(p for p in profiles if p is not oracle_prof)
+            refusal = await attempt_unauthorised_resolve(non_oracle, target)
+            trace.captoken_events.append({"kind": "refusal_attempt", **refusal})
+            if refusal.get("blocked"):
+                console.print("  [green]✓[/green] CapToken blocked unauthorised resolve (P7)")
+
+        # Snapshot reputations AFTER oracle phase
+        trace.reputation_snapshots["after_oracle"] = snapshot_reputations(
+            profiles,
+            TOPIC,
+            "after_oracle",
+        )
+
+        # P8: capture audit log + replay determinism check
+        audit_path = (
+            (Path(args.trace).parent / "persona_audit.jsonl").as_posix() if args.trace else None
+        )
+        trace.audit_replay = await capture_and_replay_audit(profiles[0].agent, audit_path)
+        if trace.audit_replay.get("deterministic") is True:
+            console.print(
+                f"  [green]✓[/green] Audit replay deterministic: "
+                f"{trace.audit_replay.get('replayed', 0)} records (P8)"
+            )
+
+    finally:
+        for a in agents:
+            await a.close()
+
+    trace.finished_at = time.perf_counter()
+
+    # S4 — Cross-sim memory: at sim end, walk per-persona Brier outcomes
+    # from oracle_resolutions and persist into KernelStore so the next
+    # sim of this persona starts with calibrated priors. This also
+    # increments `n_sims` so the Lineage / Home / SimList views can show
+    # "this swarm has been running for N sims" copy.
+    try:
+        from hypermind.eval.calibration import brier_score as _brier
+        from hypermind.knowledge.kernel_store import KernelStore
+
+        # Group oracle_resolutions by persona → topic → (predicted, outcome).
+        per_persona_topic: dict[tuple[str, str], list[float]] = {}
+        for res in trace.oracle_resolutions:
+            persona = res.get("publisher_persona")
+            if not persona:
+                continue
+            topic = ROOM
+            pred = res.get("predicted_confidence")
+            outcome = res.get("ground_truth")
+            if pred is None or outcome is None:
+                continue
+            try:
+                b = _brier(float(pred), float(outcome))
+            except (TypeError, ValueError):
+                continue
+            per_persona_topic.setdefault((str(persona), topic), []).append(b)
+        # One update per (persona, topic) — pass the mean of this sim's
+        # observations so a single noisy outcome doesn't dominate.
+        seen_personas: set[str] = set()
+        for (persona, topic), briers in per_persona_topic.items():
+            if not briers:
+                continue
+            mean_b = sum(briers) / len(briers)
+            KernelStore.update(persona, topic, brier_observation=mean_b)
+            seen_personas.add(persona)
+        # Bump n_sims for every persona that participated (regardless of
+        # whether their oracle outcomes were resolvable).
+        for prof in trace.profiles:
+            if prof.persona in seen_personas:
+                continue
+            seen_personas.add(prof.persona)
+            KernelStore.update(prof.persona, ROOM, n_sims_increment=0)
+        for persona in seen_personas:
+            KernelStore.update(persona, ROOM, n_sims_increment=1)
+    except Exception:
+        pass
+
+    # Flush per-agent facts_learned to Relata (if RELATA_URL is configured)
+    _flush_sim_memory_to_relata(trace.profiles, sim_id=getattr(args, "sim_id", ""))
+
+    # Write outputs
+    if args.trace:
+        Path(args.trace).write_text(json.dumps(_trace_to_dict(trace), indent=2, default=str))
+        console.print(f"\n  [green]✓[/green] JSON trace → [bold]{args.trace}[/bold]")
+    if args.html:
+        try:
+            json_filename = Path(args.trace).name if args.trace else "persona_trace.json"
+            _write_html_viewer(args.html, json_filename)
+            console.print(f"  [green]✓[/green] HTML debugger → [bold]{args.html}[/bold]")
+        except FileNotFoundError as exc:
+            console.print(f"  [yellow]⚠ {exc}[/yellow]")
+
+    # Final summary
+    console.print()
+    console.print(
+        f"  [dim]Total: {len(profiles)} agents · "
+        f"{len(questions)} questions · "
+        f"{trace.total_tool_calls} tool calls · "
+        f"{trace.finished_at - trace.started_at:.2f}s[/dim]"
+    )
+
+
+async def main(args: argparse.Namespace, *, recorder: Any = None) -> None:
+    """Run a persona-panel sim.
+
+    ``recorder`` (I0): optional pre-scoped Recorder injected by the SimLab
+    runner. When provided, it is threaded into the testbed cohort so every
+    agent's events carry ``namespace_id=sim_id`` natively. Default
+    ``None`` preserves the legacy lazy-init behaviour for direct callers.
+
+    Any unhandled exception is caught here, the sim status is set to
+    ``state="failed"`` (so status.json never stays as ``state="running"``
+    indefinitely), and the exception is re-raised so the caller can log it.
+    """
+    sim_id = getattr(args, "sim_id", None)
+    try:
+        await _main_impl(args, recorder=recorder)
+    except Exception as e:
+        if sim_id:
+            try:
+                from .registry import update_status as _update_status
+
+                _update_status(sim_id, state="failed", error=str(e), finished_at=time.time())
+            except Exception:
+                pass
+        raise
+
+
+# Module-level argparse is intentionally not present here — this file is now
+# package-internal. The CLI shim lives in src/hypermind/simlab/scenario.py
+# (and a thin wrapper in examples/scenario_persona_panel.py for the dev tree).