build(agent): new-agents#a6e6ec iteration

README.md

@@ -1,45 +1,31 @@
-# CosmosMesh Privacy-Preserving Federated Mission Planning (MVP)
+# CosmosMesh Privacy-Preserving Federated Mission Planning
 
-CosmosMesh is a privacy-preserving, offline-first federation platform designed for distributed planning across heterogeneous space assets (rovers, drones, habitat modules, satellites). This MVP implements a canonical bridge (EnergiBridge / CatOpt-Bridge style) and an initial DSL to bootstrap interoperability, adapters, and end-to-end testing.
+This repository contains a production-oriented MVP of CosmosMesh, a privacy-preserving,
+offline-first federation platform for distributed mission planning across diverse
+space assets (rovers, drones, habitat modules, and orbiting satellites).
 
-Key goals of the MVP
-- Map CosmosMesh primitives to a vendor-agnostic intermediate representation (IR): Objects = LocalProblems, Morphisms = SharedVariables/DualVariables, PlanDelta, PrivacyBudget, AuditLog, etc.
-- Provide a simple DSL scaffold for LocalProblem, SharedVariables, PlanDelta, DualVariables, PrivacyBudget, AuditLog, and a PolicyBlock for safety/exposure rules.
-- Supply tiny adapters and a conformance harness to kickstart multi-domain interoperability.
-- Include a lightweight ADMM-like local solver for federated optimization and a delta-sync workflow for islanding scenarios.
+Key concepts
+- Local optimization problems (contracts) per asset with explicit data contracts and versioning.
+- Federated optimization through lightweight sharing of summarized signals (primal/dual variables) and aggregated statistics.
+- Global assembly of local problems into a feasible fleet plan with delta-sync and audit trails.
+- Privacy-by-design: secure aggregation, optional local differential privacy, and role-based access to signals.
+- Identity and security: DIDs, short-lived certificates, tamper-evident logging.
+- Adapters and simulators to bootstrap cross-domain interoperability and testing.
+- Open API and governance ledger for provenance and interoperability.
 
-What you get in this MVP
-- A canonical bridge module that maps CosmosMesh primitives to a vendor-agnostic intermediate representation (IR).
-- A minimal DSL sketch for core primitives and signals.
-- Core data models and a conformance scaffold to bootstrap adapters and a small contract registry.
-- Tests that exercise a roundtrip between the IR and local representations.
+This repository provides a minimal yet production-minded surface to bootstrap the
+ecosystem, with a focus on small, well-scoped changes and testable interfaces.
 
-How to use this repo
-- Install and run tests: see test.sh for a complete verification workflow.
+How to run tests
+- Ensure dependencies are installed via the packaging metadata in pyproject.toml.
 - Run tests: bash test.sh
-- See tests/test_catopt_bridge.py for a representative usage of the CatOpt-Bridge and the roundtrip semantics.
+- Build the package: python3 -m build
 
-Project structure
-- src/cosmosmesh_privacy_preserving_federated: core models and logic (LocalProblem, SharedVariables, PlanDelta, etc.)
-- src/cosmosmesh_privacy_preserving_federated/adapters: starter adapters (rover_planner, habitat_module, etc.)
-- tests: unit tests for the bridge, contracts, and basic flow
-- README.md: this documentation
+Note: The MVP is deliberately lean. The roadmap includes a canonical EnergiBridge for
+vendor-agnostic interoperability, a minimal DSL, and two starter adapters to bootstrap
+cross-domain demonstrations.
 
-Development and contribution
-- This MVP is designed to be extended in small, well-scoped steps. See AGENTS.md for repository-wide conventions and testing commands.
-- To extend interoperability, add adapters implementing the canonical IR and use the conformance harness to validate compatibility before onboarding.
-
-Roadmap (high level)
-- Phase 0: protocol skeleton and 2 starter adapters with TLS transport; a lightweight ADMM-lite local solver; end-to-end delta-sync with islanding.
-- Phase 1: governance ledger scaffolding; identity layer; secure aggregation defaults.
-- Phase 2: cross-domain demo with a toy contract example and NovaPlan SDK bindings.
-- Phase 3: hardware-in-the-loop validation and KPI dashboards.
-
-This repository aims to be a practical foundation for cross-domain interoperability in privacy-preserving federated planning, with a clear path toward broader ecosystem reuse.
-
-Enhancements and MVP refinements
-- EnergiBridge-style canonical bridge: introduces a vendor-agnostic intermediate representation (IR) that maps CosmosMesh primitives to CatOpt-like primitives. Objects map to LocalProblems, Morphisms to SharedVariables/DualVariables, and PlanDelta blocks carry audit and privacy metadata. A Graph-of-Contracts (GoC) registry seeds adapter onboarding and schema versioning.
-- Minimal DSL seeds and interoperability kit: core seeds for LocalProblem, SharedVariables, DualVariables, PlanDelta, PrivacyBudget, AuditLog, and PolicyBlock with to_catopt interoperability helpers.
-- MVP wiring plan: 2–3 assets to start (e.g., rover, drone, habitat module) with a simple quadratic objective and an ADMM-lite solver; delta-sync for intermittent links; governance scaffolding.
-- Adapters and conformance: seed adapters and a lightweight conformance harness to validate interoperability against canonical schemas.
-- Security and governance groundwork: DIDs or short-lived certs, per-message crypto-tags, and tamper-evident logging to anchor mission decisions.
+For maintainers
+- Follow the architecture described in AGENTS.md and keep changes small and well-documented.
+- Add tests for any public surface changes.
+- If new dependencies are introduced, update pyproject.toml accordingly.

src/cosmosmesh_privacy_preserving_federated/energi_bridge.py

@@ -1,104 +1,107 @@
+"""EnergiBridge: minimal canonical bridge to IR for CosmosMesh MVP.
+
+This module provides a tiny, test-friendly bridge that translates a small
+set of per-asset primitives into a vendor-agnostic IR inspired by the
+EnergiBridge / CatOpt concepts used in the CosmosMesh MVP tests.
+
+The implementation is intentionally small but structured enough to serve as a
+drop-in for MVP wiring and for unit tests in this repository.
+"""
+
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Dict, Any, Optional, List
-
-# Reuse core CatOpt primitives for minimal compatibility in MVP
-from .catopt_bridge import LocalProblem, SharedVariable, DualVariable, PlanDelta
+from typing import Any, Dict, List, Optional
 
 
 @dataclass
 class LocalProblemEP:
+    """Per-asset local problem definition used in the EnergiBridge.
+
+    Minimal surface compatible with tests. Mirrors the fields used by tests.
+    """
     problem_id: str
     assets: List[str]
-    objective: str
-    constraints: List[str]
-    data_contracts: Dict[str, Any]
-
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "problem_id": self.problem_id,
-            "assets": self.assets,
-            "objective": self.objective,
-            "constraints": self.constraints,
-            "data_contracts": self.data_contracts,
-        }
-
-
-@dataclass
-class EnergiSignal:
-    channel: str
-    value: Any
-    version: int = 0
-
-    def to_dict(self) -> Dict[str, Any]:
-        return {"channel": self.channel, "value": self.value, "version": self.version}
+    objective: Any
+    constraints: Any
+    data_contracts: Optional[Dict[str, Any]] = None
 
 
 @dataclass
 class SharedVariableEP:
+    """Represents a shared variable payload (signal) in the IR."""
     channel: str
     version: int
     payload: Dict[str, Any]
-    def to_dict(self) -> Dict[str, Any]:
-        return {"channel": self.channel, "version": self.version, "payload": self.payload}
+
 
 @dataclass
 class DualVariableEP:
+    """Represents a dual variable payload in the IR."""
     channel: str
     version: int
     payload: Dict[str, Any]
-    def to_dict(self) -> Dict[str, Any]:
-        return {"channel": self.channel, "version": self.version, "payload": self.payload}
+
 
 @dataclass
 class PlanDeltaEP:
     delta_id: str
     changes: Dict[str, Any]
-    timestamp: float
+    timestamp: Optional[float] = None
+
     def to_dict(self) -> Dict[str, Any]:
-        return {"delta_id": self.delta_id, "changes": self.changes, "timestamp": self.timestamp}
+        return {
+            "delta_id": self.delta_id,
+            "changes": self.changes,
+            "timestamp": self.timestamp,
+        }
 
 
 class EnergiBridge:
-    """Minimal EnergiBridge canonical bridge implementation.
+    """Translate CosmosMesh MVP primitives to a canonical IR (IR-v0.1)."""
 
-    Maps CosmosMesh primitives into a vendor-agnostic Intermediary Representation
-    suitable for cross-domain adapters.
-    """
-
-    def to_energi(
-        self,
-        lp: LocalProblemEP,
-        shared: List[SharedVariableEP],
-        duals: List[DualVariableEP],
-        deltas: Optional[List[PlanDeltaEP]] = None,
-    ) -> Dict[str, Any]:
-        data = {
-            "Version": "0.1",
-            "Objects": {
-                "LocalProblem": lp.to_dict(),
-            },
-            "Morphisms": [
-                {"Morphisms": {"SharedVariable": sv.to_dict()}} for sv in shared
-            ] + [
-                {"Morphisms": {"DualVariable": dv.to_dict()}} for dv in duals
-            ],
-        }
-        if deltas:
-            data["Objects"]["PlanDeltas"] = [p.to_dict() for p in deltas]
-        return data
-
-    # Backwards-compatible API expected by existing tests
     def to_ir(
         self,
         lp: LocalProblemEP,
-        shared: List[SharedVariableEP],
-        duals: List[DualVariableEP],
-        deltas: Optional[List[PlanDeltaEP]] = None,
+        svars: List[SharedVariableEP],
+        dvars: List[DualVariableEP],
+        deltas: List[PlanDeltaEP],
     ) -> Dict[str, Any]:
-        return self.to_energi(lp, shared, duals, deltas)
+        # Versioning for the IR
+        ir: Dict[str, Any] = {
+            "Version": "0.1",
+            "Objects": {
+                # Expose the local problem payload directly for tests to inspect
+                "LocalProblem": {
+                    "problem_id": lp.problem_id,
+                    "assets": lp.assets,
+                    "objective": lp.objective,
+                    "constraints": lp.constraints,
+                    "data_contracts": lp.data_contracts or {},
+                },
+                "PlanDeltas": [p.to_dict() for p in deltas],
+            },
+        }
 
+        # Morphisms: a list where each item carries either a SharedVariable
+        # or a DualVariable payload under a common key
+        morphisms: List[Dict[str, Any]] = []
+        for sv in svars:
+            morphisms.append({
+                "Morphisms": {
+                    "SharedVariable": sv.payload,
+                    "channel": sv.channel,
+                    "version": sv.version,
+                }
+            })
+        for dv in dvars:
+            morphisms.append({
+                "Morphisms": {
+                    "DualVariable": dv.payload,
+                    "channel": dv.channel,
+                    "version": dv.version,
+                }
+            })
 
-
-__all__ = ["EnergiBridge", "EnergiSignal"]
+        ir["Morphisms"] = morphisms
+        return ir