build(agent): molt-z#db0ec5 iteration

README.md

@@ -1,11 +1,12 @@
 GridVerse Open Low-Code Platform
 
-Overview
+- Overview
 - GridVerse is an open-source, cross-domain energy optimization platform. It provides:
   - A Graph-Contract Registry for versioned data contracts
   - An Adapter Marketplace for plug-and-play cross-domain adapters
   - A tiny ADMM-like solver and delta-sync protocol for distributed optimization
   - A canonical EnergiBridge to translate between GridVerse primitives and a vendor-agnostic IR
+  - Water-Pump adapter and cross-domain adapters (WaterPumpAdapter) to bootstrap multi-domain integration
 
 Architecture (highlights)
 - gridverse.contracts: LocalProblem, SharedVariables, PlanDelta, ConstraintSet, DeviceInfo

gridverse/adapter_marketplace.py

@@ -13,3 +13,12 @@ class HeatingAdapter:
 
     def contract(self) -> dict:
         return {"name": "HeatingAdapter", "version": "0.1.0"}
+
+
+class WaterPumpAdapter:
+    def adapt(self, lp: dict) -> dict:
+        # Minimal translation: wrap input as adapted payload for water-pump domain
+        return {"adapted": lp}
+
+    def contract(self) -> dict:
+        return {"name": "WaterPumpAdapter", "version": "0.1.0"}

gridverse/energi_bridge.py

@@ -8,34 +8,48 @@ implementation can plug into the GraphContractRegistry and Adapter Marketplace
 to enable cross-domain interoperability without rewriting solvers.
 """
 
-from typing import Any, Dict, Tuple
+from typing import Any, Dict, Tuple, Optional
 
 
 class EnergiBridge:
-    """Minimal bridge helpers to translate between GridVerse primitives and a
+    """EnergiBridge: bridge between GridVerse primitives and a canonical IR.
-    vendor-agnostic IR (CatOpt-like).
 
-    The goal is not full implementation here, but a clean, well-documented
+    This is a pragmatic, production-friendly surface that downstream components
-    surface that downstream components can rely on when wiring adapters.
+    can rely on when wiring adapters. It focuses on stability and small surface
+    surface area, enabling predictable interoperability without pulling in a
+    large external IR library.
     """
 
     @staticmethod
-    def to_ir(contract_type: str, payload: Dict[str, Any], metadata: Dict[str, Any] = None) -> Dict[str, Any]:
+    def to_ir(contract_type: str, payload: Dict[str, Any], metadata: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         """Convert a GridVerse contract into a canonical IR payload.
 
+        The IR is deliberately lightweight but includes a stable schema
+        (ir_type, ir_payload) plus optional metadata. If no metadata is
+        supplied, a sensible default is applied.
+
         Args:
             contract_type: The name of the contract (e.g., "LocalProblem").
             payload: The contract payload data.
+            metadata: Optional metadata dictionary (e.g., source, version).
 
         Returns:
             A dict representing the IR contract, suitable for transport or
-            storage in the registry. This is intentionally lightweight.
+            storage in the registry.
         """
         if metadata is None:
             metadata = {
                 "source": "gridverse",
-                "version": "0.1",
+                "version": "0.2",
+                "schema": "EnergiBridge.v0.2",
             }
+        # Attach a small, deterministic, environment-agnostic header to aid auditing
+        if "timestamp" not in metadata:
+            try:
+                import time
+                metadata["timestamp"] = int(time.time())
+            except Exception:
+                metadata["timestamp"] = 0
         return {
             "ir_type": contract_type,
             "ir_payload": payload,
@@ -46,15 +60,34 @@ class EnergiBridge:
     def from_ir(ir: Dict[str, Any]) -> Tuple[str, Dict[str, Any]]:
         """Reverse translation from IR to a GridVerse contract tuple."""
         contract_type = ir.get("ir_type")
+        if contract_type is None:
+            contract_type = "UnknownContract"
         payload = ir.get("ir_payload", {})
         return contract_type, payload
 
     @staticmethod
     def map_gridverse_to_catopt(gridverse_contract: Dict[str, Any]) -> Dict[str, Any]:
-        """A tiny, deterministic mapper from GridVerse contract to a canonical IR
+        """Tiny mapper from GridVerse contract to a canonical IR representation.
-        representation. This is a convenience to illustrate how adapters would
+
-        plug into a broader ecosystem.
+        This demonstrates how a contract could be re-wired into an IR-compatible
+        payload that adapters can consume. It keeps a thin, stable surface and
+        defers heavy lifting to downstream components.
         """
         ct = gridverse_contract.get("type") or gridverse_contract.get("contract_type")
+        if ct is None:
+            ct = "UnknownContract"
+        else:
+            ct = str(ct)
         payload = gridverse_contract.get("payload") or gridverse_contract
         return EnergiBridge.to_ir(ct or "UnknownContract", payload)
+
+    @staticmethod
+    def create_metadata_for_audit(contract_type: str) -> Dict[str, Any]:
+        """Helper to produce a minimal audit metadata block for a contract."""
+        import time
+        return {
+            "source": "gridverse",
+            "version": "0.2",
+            "contract_type": contract_type,
+            "timestamp": int(time.time()),
+        }