build(agent): molt-c#9d26e0 iteration

src/cosmosmesh_privacy_preserving_federated/__init__.py

@@ -9,5 +9,16 @@ API semantics.
 """
 
 from .admm_lite import ADMMLiteSolver
+from .catopt_bridge import CatOptBridge
+from .contract_registry import ContractRegistry
+from .dsl_sketch import LocalProblemDSL, SharedVariablesDSL, DualVariablesDSL, PlanDeltaDSL
 
-__all__ = ["ADMMLiteSolver"]
+__all__ = [
+    "ADMMLiteSolver",
+    "CatOptBridge",
+    "ContractRegistry",
+    "LocalProblemDSL",
+    "SharedVariablesDSL",
+    "DualVariablesDSL",
+    "PlanDeltaDSL",
+]

src/cosmosmesh_privacy_preserving_federated/catopt_bridge.py

@@ -1,56 +1,75 @@
-"""CatOpt bridge for CosmosMesh MVP (minimal skeleton).
+"""CatOpt bridge (MVP): CosmosMesh primitives <-> CatOpt-like representation.
 
-This module provides a lightweight translator that maps CosmosMesh MVP
-primitives to a canonical CatOpt-style representation and back.
-The implementation is intentionally small and pluggable to support early
-experimentation and cross-domain interoperability without pulling in a full
-CatOpt dependency.
+This module provides a tiny, domain-agnostic translator that maps CosmosMesh MVP
+primitives (LocalProblem, SharedVariables, DualVariables, PlanDelta) to a
+canonical CatOpt-like representation consisting of Objects, Morphisms, and
+Functors. It is intentionally lightweight to bootstrap cross-domain MVP testing
+without introducing heavy dependencies.
 """
 from __future__ import annotations
 
-from typing import Dict, Tuple, Optional
+from typing import Any, Dict
 
-from .contracts import LocalProblem, SharedVariables, DualVariables
+from .dsl_sketch import LocalProblemDSL, SharedVariablesDSL, PlanDeltaDSL
 
 
-def to_catopt(local: LocalProblem, shared: SharedVariables, dual: DualVariables) -> Dict[str, object]:
-    """Convert CosmosMesh MVP primitives into a minimal CatOpt-like payload.
+class CatOptBridge:
+    """Lightweight translator between CosmosMesh primitives and CatOpt-like signals.
 
-    Returns a dict with canonical sections: Objects, Morphisms, Functors.
-    This is a tiny, illustrative mapping suitable for MVP experiments.
+    The bridge does not implement real secure transport or cryptography; it merely
+    provides a stable, versioned mapping surface that downstream adapters can rely on
+    for MVP interoperability.
+    """
+
+    def __init__(self) -> None:
+        # Simple in-memory registry of versions for contracts lived in this bridge
+        self._registry: Dict[str, str] = {
+            "LocalProblem": "0.1",
+            "SharedVariables": "0.1",
+            "DualVariables": "0.1",
+            "PlanDelta": "0.1",
+        }
+
+    def contract_version(self, contract_name: str) -> str:
+        return self._registry.get(contract_name, "0.0")
+
+    # --- Translation helpers (minimal stubs) ---
+    def to_catopt_object(self, lp: LocalProblemDSL) -> Dict[str, Any]:
+        """Translate a LocalProblem DSL instance to a CatOpt Object.
+
+        The output is a simple dictionary suitable for JSON-like transport.
         """
         return {
-        "Objects": {
-            "LocalProblem": {
-                "agent_id": local.agent_id,
-                "variables": local.variables,
-                "objective": local.objective,
-                "constraints": local.constraints,
-                "version": local.version,
-            }
-        },
-        "Morphisms": {
-            "SharedVariables": shared.variables,
-            "DualVariables": dual.values,
-            "version": shared.version,
-        },
-        "Functors": {
-            "Exposes": ["readState", "exposeLocalProblemData", "applyCommand"],
+            "type": "LocalProblemObject",
+            "version": self.contract_version("LocalProblem"),
+            "payload": {
+                "agent_id": lp.agent_id,
+                "variables": lp.variables,
+                "objective": lp.objective,
+                "constraints": lp.constraints,
             },
         }
 
+    def from_catopt_object(self, payload: Dict[str, Any]) -> LocalProblemDSL:
+        """Reverse-translate a CatOpt Object payload back into a LocalProblemDSL.
 
-def from_catopt(payload: Dict[str, object]) -> Tuple[LocalProblem, SharedVariables, DualVariables]:
-    """Reconstruct primitives from a CatOpt-like payload (best-effort)."""
-    obj = payload.get("Objects", {}).get("LocalProblem", {})
-    lp = LocalProblem(
-        agent_id=str(obj.get("agent_id", "")),
-        variables=dict(obj.get("variables", {})),
-        objective=dict(obj.get("objective", {})),
-        constraints=dict(obj.get("constraints", {})),
-        version=obj.get("version"),
+        This is intentionally permissive for MVP testing; adapters can extend as needed.
+        """
+        p = payload.get("payload", {})
+        return LocalProblemDSL(
+            agent_id=str(p.get("agent_id", "unknown")),
+            objective=p.get("objective", ""),
+            variables=p.get("variables", []),
+            constraints=p.get("constraints", []),
         )
 
-    sv = SharedVariables(variables=dict(payload.get("Morphisms", {}).get("SharedVariables", {})))
-    dv = DualVariables(values=dict(payload.get("Morphisms", {}).get("DualVariables", {})))
-    return lp, sv, dv
+    def to_plan_delta(self, delta: PlanDeltaDSL) -> Dict[str, Any]:
+        """Serialize a PlanDelta to a canonical CatOpt-like signal."""
+        return {
+            "type": "PlanDelta",
+            "version": self.contract_version("PlanDelta"),
+            "payload": delta.dict(),
+        }
+
+    def __repr__(self) -> str:
+        return f"<CatOptBridge contracts={list(self._registry.keys())}>"

src/cosmosmesh_privacy_preserving_federated/contract_registry.py

@@ -0,0 +1,42 @@
+"""Simple in-memory contract registry for MVP.
+
+This module exposes a tiny registry mapping contract names to versions and a
+minimal schema description. It is designed as a scaffold to be extended by real
+contract schemas in later MVP iterations.
+"""
+from __future__ import annotations
+
+from typing import Dict, Any
+
+
+class ContractRegistry:
+    def __init__(self) -> None:
+        self._contracts: Dict[str, Dict[str, Any]] = {
+            "LocalProblem": {
+                "version": "0.1",
+                "schema": {
+                    "agent_id": "str",
+                    "variables": ["str"],
+                    "objective": "str",
+                    "constraints": ["str"],
+                },
+            },
+            "SharedVariables": {
+                "version": "0.1",
+                "schema": {"signals": {"type": "float dict"}},
+            },
+            "DualVariables": {
+                "version": "0.1",
+                "schema": {"lambdas": {"type": "float dict"}},
+            },
+            "PlanDelta": {
+                "version": "0.1",
+                "schema": {"delta_id": "str", "changes": "dict", "timestamp": "str"},
+            },
+        }
+
+    def get_contract(self, name: str) -> Dict[str, Any] | None:
+        return self._contracts.get(name)
+
+    def list_contracts(self) -> Dict[str, Dict[str, Any]]:
+        return dict(self._contracts)

src/cosmosmesh_privacy_preserving_federated/dsl_sketch.py

@@ -0,0 +1,49 @@
+"""DSL sketch for CosmosMesh MVP primitives.
+
+The goal here is to provide lightweight dataclass-like shells that describe the
+contract between agents in a way that's friendly to MVP wiring and testing. These
+types are intentionally simple and purely for internal prototyping.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, asdict
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class LocalProblemDSL:
+    agent_id: str
+    objective: str
+    variables: List[str]
+    constraints: List[str]
+
+    def dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class SharedVariablesDSL:
+    signals: Dict[str, float]
+    version: str = "0.1"
+
+    def dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class DualVariablesDSL:
+    lambdas: Dict[str, float]
+    version: str = "0.1"
+
+    def dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class PlanDeltaDSL:
+    delta_id: str
+    changes: Dict[str, Any]
+    timestamp: Optional[str] = None
+
+    def dict(self) -> Dict[str, Any]:
+        return asdict(self)