final demo cleanup

cgae_engine/audit.py

@@ -656,14 +656,18 @@ class AuditOrchestrator:
         storage_root_hash: Optional[str] = None
         storage_root_hash_real: bool = False
         if cache_dir:
-            storage_root_hash, storage_root_hash_real = _pin_audit_to_0g(
-                model_name=model_name,
-                agent_id=agent_id,
-                cache_dir=Path(cache_dir) if cache_dir else None,
-                robustness=robustness,
-                defaults_used=defaults_used,
-                errors=errors,
-            )
+            try:
+                storage_root_hash, storage_root_hash_real = _pin_audit_to_0g(
+                    model_name=model_name,
+                    agent_id=agent_id,
+                    cache_dir=Path(cache_dir) if cache_dir else None,
+                    robustness=robustness,
+                    defaults_used=defaults_used,
+                    errors=errors,
+                )
+            except Exception as e:
+                logger.error(f"  [0g] Storage pin failed for {model_name}: {e}")
+                errors.append(f"0G_STORAGE: {e}")
 
         return AuditResult(
             agent_id=agent_id,
@@ -689,139 +693,45 @@ class AuditOrchestrator:
     def _run_ddft_live(
         self, model_name: str, model_config: dict, cache_dir: Optional[Path]
     ) -> tuple[float, float]:
-        """
-        Run DDFT assessment via the hosted DDFT API service.
-        Returns (er_score, ih_score).
-        Cache file: cache_dir/<model_name>_ddft_live.json
-        """
-        if cache_dir:
-            cached = cache_dir / f"{model_name}_ddft_live.json"
-            if cached.exists():
-                data = json.loads(cached.read_text())
-                return data["er"], data["ih"]
-
-        api_keys = {
-            "AZURE_API_KEY": self.azure_api_key,
-            "AZURE_OPENAI_API_ENDPOINT": self.azure_openai_endpoint,
-            "DDFT_MODELS_ENDPOINT": self.ddft_models_endpoint,
-            "AZURE_ANTHROPIC_API_ENDPOINT": self.azure_anthropic_api_endpoint,
-        }
-
-        result = self._ddft.assess(
-            model_name=model_name,
-            model_config=model_config,
-            api_keys=api_keys,
-            concepts=["Natural Selection", "Recursion"],
-            compression_levels=[0.0, 0.5, 1.0],
-        )
-
-        er = float(result.get("er", 0.5))
-        ih = float(result.get("ih", 0.7))
-
-        if cache_dir:
-            cache_dir.mkdir(parents=True, exist_ok=True)
-            (cache_dir / f"{model_name}_ddft_live.json").write_text(
-                json.dumps({"er": er, "ih": ih,
-                            "ci_score": result.get("ci_score"),
-                            "phenotype": result.get("phenotype")}, indent=2)
-            )
+        """Query DDFT /score endpoint. Returns (er, ih)."""
+        data = self._ddft.get_score(model_name)
+        er = float(data.get("ER") or data.get("er") or 0)
+        ih = float(data.get("IH") or data.get("ih") or 0)
+        if er <= 0 or ih <= 0:
+            raise RuntimeError(f"DDFT /score returned no valid ER/IH for {model_name}: {data}")
+        logger.info(f"  [DDFT] GET {self._ddft.base_url}/score/{model_name} -> ER={er:.3f} IH={ih:.3f}")
         return er, ih
 
     def _run_cdct_live(
         self, model_name: str, llm_agent: Any, cache_dir: Optional[Path]
     ) -> float:
-        """
-        Run CDCT experiment via the hosted CDCT API service.
-        Returns cc_score.
-        Cache file: cache_dir/<model_name>_cdct_live.json
-        """
-        if cache_dir:
-            cached = cache_dir / f"{model_name}_cdct_live.json"
-            if cached.exists():
-                data = json.loads(cached.read_text())
-                return data["cc"]
-
-        api_keys = {
-            "AZURE_API_KEY": self.azure_api_key,
-            "AZURE_OPENAI_API_ENDPOINT": self.azure_openai_endpoint,
-            "DDFT_MODELS_ENDPOINT": self.ddft_models_endpoint,
-            "AZURE_ANTHROPIC_API_ENDPOINT": self.azure_anthropic_api_endpoint,
-        }
-
-        model_config = getattr(llm_agent, "model_config", {})
-
-        result = self._cdct.run_experiment(
-            model_name=model_name,
-            model_config=model_config,
-            api_keys=api_keys,
-            concept="logic_modus_ponens",
-            prompt_strategy="compression_aware",
-            evaluation_mode="balanced",
-        )
-
-        cc = float(result.get("cc", 0.5))
-
-        if cache_dir:
-            cache_dir.mkdir(parents=True, exist_ok=True)
-            (cache_dir / f"{model_name}_cdct_live.json").write_text(
-                json.dumps({"cc": cc, "model": model_name}, indent=2)
-            )
+        """Query CDCT /score endpoint. Returns cc. CDCT returns a list of per-concept metrics."""
+        data = self._cdct.get_score(model_name)
+        cc = None
+        if isinstance(data, list) and data:
+            cris = [float(r["CRI"]) for r in data if isinstance(r, dict) and "CRI" in r]
+            if cris:
+                cc = min(cris)
+        elif isinstance(data, dict):
+            cc = self._extract_score(data, "cc", model_name=model_name)
+        if cc is None or cc <= 0:
+            raise RuntimeError(f"CDCT /score returned no valid CC for {model_name}: {data}")
+        logger.info(f"  [CDCT] GET {self._cdct.base_url}/score/{model_name} -> CC={cc:.3f}")
         return cc
 
     def _run_eect_live(
         self, model_name: str, llm_agent: Any, cache_dir: Optional[Path]
     ) -> float:
-        """
-        Run EECT Socratic dialogues via the hosted EECT API service.
-        Returns as_score.
-        Cache file: cache_dir/<model_name>_eect_live.json
-        """
-        if cache_dir:
-            cached = cache_dir / f"{model_name}_eect_live.json"
-            if cached.exists():
-                data = json.loads(cached.read_text())
-                return data["as"]
-
-        api_keys = {
-            "AZURE_API_KEY": self.azure_api_key,
-            "AZURE_OPENAI_API_ENDPOINT": self.azure_openai_endpoint,
-            "DDFT_MODELS_ENDPOINT": self.ddft_models_endpoint,
-            "AZURE_ANTHROPIC_API_ENDPOINT": self.azure_anthropic_api_endpoint,
-        }
-
-        model_config = getattr(llm_agent, "model_config", {})
-
-        # Run two dilemmas and average the AS scores
-        dilemma_ids = ["trolley_problem", "lying_to_save_lives"]
-        all_turns: list[list] = []
-        for dilemma_id in dilemma_ids:
-            try:
-                resp = self._eect.run_dialogue(
-                    model_name=model_name,
-                    model_config=model_config,
-                    api_keys=api_keys,
-                    dilemma={"id": dilemma_id},
-                    compression_level="c1.0",
-                )
-                turns = resp.get("turns", [])
-                if turns:
-                    all_turns.append(turns)
-            except Exception as e:
-                logger.warning(f"  EECT dialogue failed for dilemma {dilemma_id}: {e}")
-
-        if not all_turns:
-            raise RuntimeError("No EECT dialogues completed successfully")
-
-        as_scores = [self._score_eect_turns(turns) for turns in all_turns]
-        as_ = sum(as_scores) / len(as_scores)
-
-        if cache_dir:
-            cache_dir.mkdir(parents=True, exist_ok=True)
-            (cache_dir / f"{model_name}_eect_live.json").write_text(
-                json.dumps({"as": as_, "model": model_name,
-                            "dialogues_run": len(all_turns)}, indent=2)
-            )
-        return as_
+        """Query AGT/EECT /score endpoint. Returns as_score."""
+        data = self._eect.get_score(model_name)
+        as_ = None
+        if isinstance(data, dict):
+            as_ = data.get("as_") or data.get("as_score") or data.get("AS") or data.get("as")
+        if as_ is not None and float(as_) > 0:
+            as_ = float(as_)
+            logger.info(f"  [AGT] GET {self._eect.base_url}/score/{model_name} -> AS={as_:.3f}")
+            return as_
+        raise RuntimeError(f"AGT /score returned no valid AS for {model_name}: {data}")
 
     @staticmethod
     def _score_eect_turns(turns: list) -> float:

cgae_engine/economy.py

@@ -325,7 +325,7 @@ class Economy:
         # Create an ETH wallet for this agent if wallet manager is available
         wallet_address = None
         if self.wallet_manager:
-            wallet = self.wallet_manager.create_agent_wallet(record.agent_id)
+            wallet = self.wallet_manager.create_agent_wallet(record.agent_id, model_name)
             wallet_address = wallet.address
             record.wallet_address = wallet_address
 
@@ -378,26 +378,38 @@ class Economy:
         # Write certification on-chain if bridge is available
         onchain_tx = None
         if self.onchain_bridge and record.wallet_address:
-            audit_hash = (audit_details or {}).get("storage_root_hash", "")
-            onchain_tx = self.onchain_bridge.certify_agent(
-                agent_address=record.wallet_address,
-                cc=robustness.cc, er=robustness.er,
-                as_=robustness.as_, ih=robustness.ih,
-                audit_type=audit_type,
-                audit_hash=audit_hash or "",
-            )
+            # Skip if already certified at this tier on-chain
+            ens_tier = ""
+            if self.ens_manager:
+                ens_name = self.ens_manager.get_agent_name(agent_id)
+                if ens_name:
+                    ens_tier = self.ens_manager.resolve_text(ens_name, "cgae.tier")
+            if ens_tier != cert.tier.name:
+                audit_hash = (audit_details or {}).get("storage_root_hash", "")
+                onchain_tx = self.onchain_bridge.certify_agent(
+                    agent_address=record.wallet_address,
+                    cc=robustness.cc, er=robustness.er,
+                    as_=robustness.as_, ih=robustness.ih,
+                    audit_type=audit_type,
+                    audit_hash=audit_hash or "",
+                )
 
         # Write robustness credentials to ENS text records
         if self.ens_manager:
-            audit_hash = (audit_details or {}).get("storage_root_hash", "")
-            self.ens_manager.set_agent_credentials(
-                agent_id=agent_id,
-                tier=cert.tier.name,
-                cc=robustness.cc, er=robustness.er,
-                as_=robustness.as_, ih=robustness.ih,
-                wallet_address=record.wallet_address or "",
-                audit_hash=audit_hash,
-            )
+            ens_name = self.ens_manager.get_agent_name(agent_id)
+            existing_tier = self.ens_manager.resolve_text(ens_name, "cgae.tier") if ens_name else ""
+            if existing_tier != cert.tier.name:
+                audit_hash = (audit_details or {}).get("storage_root_hash", "")
+                self.ens_manager.set_agent_credentials(
+                    agent_id=agent_id,
+                    tier=cert.tier.name,
+                    cc=robustness.cc, er=robustness.er,
+                    as_=robustness.as_, ih=robustness.ih,
+                    wallet_address=record.wallet_address or "",
+                    audit_hash=audit_hash,
+                )
+            else:
+                logger.info(f"  [ens] Skipping text record update for {ens_name} (tier unchanged: {existing_tier})")
 
         self._log("agent_audited", {
             "agent_id": agent_id,

cgae_engine/ens.py

@@ -161,6 +161,7 @@ class ENSManager:
     def create_subname(self, agent_id: str, model_name: str, owner: str) -> Optional[str]:
         """
         Create a subname like gpt5.cgaeprotocol.eth for an agent.
+        If the subname already exists (has a cgae.tier record), reuse it.
         Returns the full ENS name or None on failure.
         """
         label = _slugify(model_name)
@@ -171,6 +172,13 @@ class ENSManager:
             self._subnames[agent_id] = full_name
             return full_name
 
+        # Check if subname already exists by reading a text record
+        existing_tier = self.resolve_text(full_name, "cgae.tier")
+        if existing_tier:
+            logger.info(f"  [ens] Reusing existing {full_name} (tier={existing_tier})")
+            self._subnames[agent_id] = full_name
+            return full_name
+
         try:
             nonce = self.w3.eth.get_transaction_count(self._account.address)
             # setSubnodeRecord creates the subname + sets resolver in one tx

cgae_engine/framework_clients.py

@@ -230,17 +230,16 @@ class EECTClient:
         Run a single Socratic ethical dialogue for one dilemma.
 
         Returns a dict with:
-          turns — list of dialogue turn dicts (role, response, …)
+          turns - list of dialogue turn dicts (role, response, ...)
         """
         url = f"{self.base_url}/dialogue"
+        dilemma_id = dilemma.get("id", dilemma) if isinstance(dilemma, dict) else str(dilemma)
         payload = {
             "model_name": model_name,
-            "model_config": model_config,
-            "api_keys": api_keys,
-            "dilemma": dilemma,
+            "dilemma_id": dilemma_id,
             "compression_level": compression_level,
         }
-        logger.debug(f"[EECT] POST {url} model={model_name} dilemma={dilemma.get('id')}")
+        logger.debug(f"[EECT] POST {url} model={model_name} dilemma_id={dilemma_id}")
         return _post(url, payload)
 
     def get_score(self, model_name: str) -> dict:

cgae_engine/onchain.py

@@ -241,7 +241,7 @@ class EscrowBridge:
             self._tx_log.append({"tx_hash": tx_hash.hex(), "status": status})
             return tx_hash.hex()
         except Exception as e:
-            logger.error(f"  [escrow] tx failed: {e}")
+            logger.warning(f"  [escrow] tx skipped (insufficient gas or network error): {e}")
             self._tx_log.append({"error": str(e)})
             return None
 

cgae_engine/wallet.py

@@ -57,6 +57,7 @@ class WalletManager:
         rpc_url: Optional[str] = None,
         treasury_private_key: Optional[str] = None,
         dry_run: bool = False,
+        wallet_store_path: Optional[str] = None,
     ):
         self.rpc_url = rpc_url or os.getenv("ZG_RPC_URL", "https://evmrpc-testnet.0g.ai")
         self._treasury_key = treasury_private_key or os.getenv("PRIVATE_KEY")
@@ -65,6 +66,7 @@ class WalletManager:
         self.w3 = Web3(Web3.HTTPProvider(self.rpc_url))
         self._wallets: dict[str, AgentWallet] = {}  # agent_id -> wallet
         self._disbursements: list[dict] = []
+        self._store_path = Path(wallet_store_path) if wallet_store_path else Path("server/live_results/wallets.json")
 
         if self._treasury_key:
             key = self._treasury_key if self._treasury_key.startswith("0x") else f"0x{self._treasury_key}"
@@ -74,16 +76,31 @@ class WalletManager:
             self._treasury_account = None
             self.treasury_address = None
 
+        # Load persisted wallets from disk
+        self._model_wallets: dict[str, AgentWallet] = {}  # model_name -> wallet
+        self._load_wallets()
+
     @property
     def is_live(self) -> bool:
         """True if we can send real transactions."""
         return self._treasury_account is not None and not self.dry_run
 
-    def create_agent_wallet(self, agent_id: str) -> AgentWallet:
-        """Generate a new ETH keypair for an agent."""
+    def create_agent_wallet(self, agent_id: str, model_name: str = "") -> AgentWallet:
+        """Get existing wallet for this model or generate a new keypair."""
         if agent_id in self._wallets:
             return self._wallets[agent_id]
 
+        # Reuse persisted wallet for this model if it exists
+        if model_name and model_name in self._model_wallets:
+            wallet = AgentWallet(
+                agent_id=agent_id,
+                address=self._model_wallets[model_name].address,
+                private_key=self._model_wallets[model_name].private_key,
+            )
+            self._wallets[agent_id] = wallet
+            logger.info(f"  [wallet] Loaded existing wallet for {agent_id}: {wallet.address}")
+            return wallet
+
         acct = Account.create()
         wallet = AgentWallet(
             agent_id=agent_id,
@@ -91,9 +108,36 @@ class WalletManager:
             private_key=acct.key.hex() if isinstance(acct.key, bytes) else acct.key,
         )
         self._wallets[agent_id] = wallet
+        if model_name:
+            self._model_wallets[model_name] = wallet
+            self._save_wallets()
         logger.info(f"  [wallet] Created wallet for {agent_id}: {wallet.address}")
         return wallet
 
+    def _load_wallets(self):
+        """Load persisted model->wallet mapping from disk."""
+        if self._store_path.exists():
+            try:
+                data = json.loads(self._store_path.read_text())
+                for model_name, w in data.items():
+                    self._model_wallets[model_name] = AgentWallet(
+                        agent_id=w.get("agent_id", ""),
+                        address=w["address"],
+                        private_key=w["private_key"],
+                    )
+                logger.info(f"  [wallet] Loaded {len(self._model_wallets)} persisted wallets")
+            except Exception as e:
+                logger.warning(f"  [wallet] Could not load wallets: {e}")
+
+    def _save_wallets(self):
+        """Persist model->wallet mapping to disk (unredacted keys)."""
+        self._store_path.parent.mkdir(parents=True, exist_ok=True)
+        data = {
+            model: {"agent_id": w.agent_id, "address": w.address, "private_key": w.private_key}
+            for model, w in self._model_wallets.items()
+        }
+        self._store_path.write_text(json.dumps(data, indent=2))
+
     def get_wallet(self, agent_id: str) -> Optional[AgentWallet]:
         return self._wallets.get(agent_id)
 

scripts/video_demo.py

@@ -44,7 +44,7 @@ def section(title: str):
 
 def main():
     parser = argparse.ArgumentParser()
-    parser.add_argument("--rounds", type=int, default=5)
+    parser.add_argument("--rounds", type=int, default=2)
     parser.add_argument("--port", type=int, default=8000)
     parser.add_argument("--skip-audit", action="store_true")
     args = parser.parse_args()
@@ -107,15 +107,26 @@ def main():
 
     runner.setup()
 
-    # Certify agents on-chain with their audit scores
+    # Print audit summary with highlights
+    print()
     for agent_id, model_name in runner.agent_model_map.items():
         record = runner.economy.registry.get_agent(agent_id)
-        if record and record.current_robustness:
-            r = record.current_robustness
-            wallet = record.wallet_address
-            audit_hash = record.audit_cid or ""
-            if wallet and chain.is_live:
-                chain.certify_agent(wallet, r.cc, r.er, r.as_, r.ih, "registration", audit_hash)
+        if not record:
+            continue
+        r = record.current_robustness
+        wallet = record.wallet_address or "n/a"
+        ens = runner.economy.ens_manager.get_agent_name(agent_id) if runner.economy.ens_manager else "n/a"
+        cid = record.audit_cid or "n/a"
+        tier = record.current_tier.name
+        print(f"    \033[1;32m\u2713\033[0m \033[1m{model_name}\033[0m")
+        print(f"      Wallet:  {wallet}")
+        print(f"      ENS:     {ens}")
+        if r:
+            print(f"      Scores:  CC={r.cc:.3f}  ER={r.er:.3f}  AS={r.as_:.3f}  IH={r.ih:.3f}  \033[1;33m-> {tier}\033[0m")
+        if cid != "n/a":
+            print(f"      0G Hash: {cid[:32]}...")
+        print()
+        time.sleep(0.5)
 
     time.sleep(2)
 
@@ -169,39 +180,87 @@ def main():
     runner._emit_protocol_event = patched_emit
 
     # ---------------------------------------------------------------------------
-    # Per-round scripted narrative:
-    #   R1 - Baseline trading + grok circumvention blocked
-    #   R2 - Delegation: grok delegates to DeepSeek (chain robustness)
-    #   R3 - GPT-5.4 invests in robustness -> upgrade to T3
-    #   R4 - Spot audit: temporal decay demotes grok + spoof blocked
-    #   R5 - Post-upgrade: GPT-5.4 earns more at T3, economy stabilises
+    # Per-round scripted narrative (2 rounds, all scenarios covered):
+    #   R1 - Circumvention blocked + delegation blocked + normal trading
+    #   R2 - GPT-5.4 upgrade + grok demotion (spot audit) + normal trading
     # ---------------------------------------------------------------------------
 
     # Disable random circumvention/delegation - we script them per round
     runner.config.circumvention_rate = 0.0
     runner.config.delegation_rate = 0.0
 
+    def _push_api_state(round_num):
+        """Push current state to the dashboard API after each task."""
+        safety = runner.economy.aggregate_safety()
+        agents_snap = {}
+        for aid, mname in runner.agent_model_map.items():
+            rec = runner.economy.registry.get_agent(aid)
+            if not rec:
+                continue
+            rv = rec.current_robustness
+            agents_snap[aid] = {
+                "agent_id": aid, "model_name": mname,
+                "strategy": _strat(runner, mname),
+                "current_tier": rec.current_tier.value,
+                "balance": rec.balance, "total_earned": rec.total_earned,
+                "total_penalties": rec.total_penalties,
+                "contracts_completed": rec.contracts_completed,
+                "contracts_failed": rec.contracts_failed,
+                "status": rec.status.value,
+                "wallet_address": rec.wallet_address,
+                "ens_name": runner.economy.ens_manager.get_agent_name(aid) if runner.economy.ens_manager else None,
+                "robustness": {"cc":rv.cc,"er":rv.er,"as_":rv.as_,"ih":rv.ih} if rv else None,
+            }
+        trades = [{
+            "round": tr.get("_round", round_num), "agent": tr["agent"],
+            "task_id": tr["task_id"], "task_prompt": tr.get("task_prompt", ""),
+            "tier": tr["tier"], "domain": tr["domain"],
+            "passed": tr["verification"]["overall_pass"],
+            "reward": tr["settlement"].get("reward", 0) if tr["settlement"] else 0,
+            "penalty": tr["settlement"].get("penalty", 0) if tr["settlement"] else 0,
+            "token_cost": tr.get("token_cost_eth", 0),
+            "latency_ms": tr.get("latency_ms", 0),
+            "output_preview": tr.get("output_preview", ""),
+            "constraints_passed": tr["verification"].get("constraints_passed", []),
+            "constraints_failed": tr["verification"].get("constraints_failed", []),
+        } for tr in runner._results]
+
+        with api._state_lock:
+            api._state["round"] = round_num + 1
+            api._state["economy"] = {
+                "aggregate_safety": safety,
+                "active_agents": len(runner.economy.registry.active_agents),
+                "total_balance": sum(a["balance"] for a in agents_snap.values()),
+                "total_earned": sum(a["total_earned"] for a in agents_snap.values()),
+                "contracts_completed": sum(a["contracts_completed"] for a in agents_snap.values()),
+                "contracts_failed": sum(a["contracts_failed"] for a in agents_snap.values()),
+            }
+            api._state["agents"] = agents_snap
+            api._state["trades"] = trades[-500:]
+
+    # Replace runner._results with a live-updating list
+    _current_round = [0]
+    class _LiveResults(list):
+        def append(self, item):
+            item["_round"] = _current_round[0]
+            super().append(item)
+            _push_api_state(_current_round[0])
+    runner._results = _LiveResults(runner._results)
+
     for round_num in range(args.rounds):
+        _current_round[0] = round_num
         runner._reactivate_suspended_agents()
 
         # ---- Round-specific scripted events ----
         if round_num == 0:
-            # R1: force one circumvention attempt from grok
+            # R1: circumvention + delegation (both blocked for adversarial)
             runner.config.circumvention_rate = 1.0
-            runner.config.delegation_rate = 0.0
-        elif round_num == 1:
-            # R2: force delegation, no circumvention
-            runner.config.circumvention_rate = 0.0
             runner.config.delegation_rate = 1.0
-        elif round_num == 2:
-            # R3: normal trading, then forced upgrade after
+        elif round_num == 1:
+            # R2: spot audit demotion for grok, then upgrade for GPT-5.4
             runner.config.circumvention_rate = 0.0
             runner.config.delegation_rate = 0.0
-        elif round_num == 3:
-            # R4: grok spoof attempt + spot audit demotion
-            runner.config.circumvention_rate = 1.0
-            runner.config.delegation_rate = 0.0
-            # Force temporal decay to trigger a demotion on grok
+            # Force temporal decay demotion on grok
             grok_id = next((aid for aid, m in runner.agent_model_map.items() if m == "grok-4-20-reasoning"), None)
             if grok_id:
                 rec = runner.economy.registry.get_agent(grok_id)
@@ -226,17 +285,13 @@ def main():
                             f"grok-4-20-reasoning demoted {old_tier.name} -> {new_tier.name} after spot audit (temporal decay).",
                             old_tier=old_tier.name, new_tier=new_tier.name,
                         )
-        elif round_num == 4:
-            # R5: clean round, no adversarial - show stable economy
-            runner.config.circumvention_rate = 0.0
-            runner.config.delegation_rate = 0.0
 
         round_results = runner._run_round(round_num)
         runner._round_summaries.append(round_results)
         runner.economy.step()
 
-        # R3 post-round: forced upgrade for GPT-5.4
-        if round_num == 2:
+        # R2 post-round: forced upgrade for GPT-5.4
+        if round_num == 1:
             gpt_id = next((aid for aid, m in runner.agent_model_map.items() if m == "gpt-5.4"), None)
             if gpt_id:
                 rec = runner.economy.registry.get_agent(gpt_id)
@@ -263,53 +318,10 @@ def main():
                             old_tier=old_tier.name, new_tier=new_tier.name,
                         )
 
-        # Push state to API
-        safety = runner.economy.aggregate_safety()
-        agents_snap = {}
-        for aid, mname in runner.agent_model_map.items():
-            rec = runner.economy.registry.get_agent(aid)
-            if not rec:
-                continue
-            rv = rec.current_robustness
-            agents_snap[aid] = {
-                "agent_id": aid, "model_name": mname,
-                "strategy": _strat(runner, mname),
-                "current_tier": rec.current_tier.value,
-                "balance": rec.balance, "total_earned": rec.total_earned,
-                "total_penalties": rec.total_penalties,
-                "contracts_completed": rec.contracts_completed,
-                "contracts_failed": rec.contracts_failed,
-                "status": rec.status.value,
-                "wallet_address": rec.wallet_address,
-                "ens_name": runner.economy.ens_manager.get_agent_name(aid) if runner.economy.ens_manager else None,
-                "robustness": {"cc":rv.cc,"er":rv.er,"as_":rv.as_,"ih":rv.ih} if rv else None,
-            }
-        trades = [{
-            "round": round_num, "agent": tr["agent"],
-            "task_id": tr["task_id"], "task_prompt": tr.get("task_prompt", ""),
-            "tier": tr["tier"], "domain": tr["domain"],
-            "passed": tr["verification"]["overall_pass"],
-            "reward": tr["settlement"].get("reward", 0) if tr["settlement"] else 0,
-            "penalty": tr["settlement"].get("penalty", 0) if tr["settlement"] else 0,
-            "token_cost": tr.get("token_cost_eth", 0),
-            "latency_ms": tr.get("latency_ms", 0),
-            "output_preview": tr.get("output_preview", ""),
-            "constraints_passed": tr["verification"].get("constraints_passed", []),
-            "constraints_failed": tr["verification"].get("constraints_failed", []),
-        } for tr in round_results.get("task_results", [])]
-
+        # Final push + time series update for this round
+        _push_api_state(round_num)
         with api._state_lock:
-            api._state["round"] = round_num + 1
-            api._state["economy"] = {
-                "aggregate_safety": safety,
-                "active_agents": len(runner.economy.registry.active_agents),
-                "total_balance": sum(a["balance"] for a in agents_snap.values()),
-                "total_earned": sum(a["total_earned"] for a in agents_snap.values()),
-                "contracts_completed": sum(a["contracts_completed"] for a in agents_snap.values()),
-                "contracts_failed": sum(a["contracts_failed"] for a in agents_snap.values()),
-            }
-            api._state["agents"] = agents_snap
-            api._state["trades"] = (api._state["trades"] + trades)[-500:]
+            safety = runner.economy.aggregate_safety()
             api._state["time_series"]["safety"].append(safety)
             api._state["time_series"]["balance"].append(api._state["economy"]["total_balance"])
             api._state["time_series"]["rewards"].append(round_results.get("total_reward", 0))
@@ -322,11 +334,8 @@ def main():
         reward = round_results["total_reward"]
         penalty = round_results["total_penalty"]
         themes = {
-            0: "Baseline + Circumvention",
-            1: "Delegation Chain",
-            2: "Robustness Investment -> Upgrade",
-            3: "Spot Audit + Demotion",
-            4: "Stable Economy",
+            0: "Circumvention + Delegation Blocked",
+            1: "Upgrade + Demotion",
         }
         theme = themes.get(round_num, "")
         label = f" Round {round_num+1}/{args.rounds} "
@@ -454,7 +463,7 @@ if __name__ == "__main__":
     import server.api as api
 
     parser = argparse.ArgumentParser()
-    parser.add_argument("--rounds", type=int, default=5)
+    parser.add_argument("--rounds", type=int, default=2)
     parser.add_argument("--port", type=int, default=8000)
     parser.add_argument("--skip-audit", action="store_true")
     args_pre = parser.parse_known_args()[0]

server/live_runner.py

@@ -1248,6 +1248,7 @@ class LiveSimulationRunner:
                 "executed_by_agent_id": execution_agent_id,
                 "executed_by_model": execution_model_name,
                 "task_id": task.task_id,
+                "task_prompt": task.prompt,
                 "tier": task.tier.name,
                 "domain": task.domain,
                 "proof_cid": cid,

storage/upload_to_0g.mjs

@@ -94,7 +94,8 @@ async function main() {
   try {
     const [hash, uploadErr] = await indexer.upload(file, RPC_URL, signer);
     if (uploadErr) throw new Error(String(uploadErr));
-    rootHash = hash;
+    // SDK may return a string or an object {rootHash, txHash, txSeq}
+    rootHash = (typeof hash === "object" && hash !== null) ? hash.rootHash : hash;
   } catch (e) {
     writeError(`Upload failed: ${e.message}`);
     process.exit(1);

storage/zg_store.py

@@ -166,7 +166,22 @@ class ZgStore:
             except (json.JSONDecodeError, KeyError):
                 raise RuntimeError(stderr or f"exit code {proc.returncode}")
 
-        data = json.loads(proc.stdout.strip())
+        stdout = proc.stdout.strip()
+        if not stdout:
+            stderr = proc.stderr.strip()
+            raise RuntimeError(f"0G upload returned empty output. stderr: {stderr}")
+
+        # SDK may print debug lines before the JSON; find the last JSON line
+        json_line = None
+        for line in reversed(stdout.splitlines()):
+            line = line.strip()
+            if line.startswith("{"):
+                json_line = line
+                break
+        if not json_line:
+            raise RuntimeError(f"0G upload returned no JSON. stdout: {stdout[:200]}")
+
+        data = json.loads(json_line)
         if not data.get("ok"):
             raise RuntimeError(data.get("error", "Unknown upload error"))