Все изменения готовы к интеграции в основную кодовую базу. Проект теперь обладает расширенной отказоустойчивостью, поддержкой гетерогенных агентов, криптографической безопасностью, инструментами отладки и облачной интеграцией, что соответствует целям развития SDK для автономных распределённых систем.

1. **Реализован механизм устойчивости к сбоям (fault tolerance) и самовосстановления**:
   - Создан модуль `fault_tolerance` в крейте `agent-core` с компонентами `FaultDetector`, `TaskReallocator` и `FaultToleranceManager`.
   - Интегрирован с агентом: `Agent` теперь запускает менеджер в фоне, подписывается на события транспорта и логирует перераспределение задач при сбоях.

2. **Добавлена поддержка гетерогенных агентов (разные возможности, ресурсы)**:
   - Расширены типы в `common::types`: добавлены `Capability` и `AgentCapabilities`.
   - Обновлён `ResourceMetrics` в `resource-monitor` для включения списка возможностей.
   - Модифицирован `Task` в `distributed-planner` с полем `required_capabilities`.
   - Созданы новые алгоритмы планирования `ResourceAwarePlanner` и `CapabilityAwarePlanner`, учитывающие возможности агентов.

3. **Разработана система безопасности (аутентификация, шифрование, авторизация)**:
   - Расширен модуль `security` в `mesh-transport`: добавлены функции симметричного шифрования (ChaCha20‑Poly1305), обмена ключами (X25519), гибридного шифрования.
   - Реализованы структуры `EncryptedMessage`, `DhKeyPair` и улучшена подпись сообщений Ed25519.
   - Обновлены зависимости крейта для поддержки шифрования.

4. **Созданы инструменты для профилирования и отладки распределённых сценариев**:
   - Создан новый крейт `profiling` с модулями:
     - `metrics` – сбор метрик в стиле Prometheus.
     - `tracing` – распределённая трассировка через OpenTelemetry.
     - `snapshot` – снимки состояния агентов и сравнение.
     - `debug_server` – HTTP‑сервер для инспекции в реальном времени.
   - Добавлена инициализация профилирования в `profiling::init`.

5. **Интегрированы облачные сервисы (AWS IoT, Azure IoT) для гибридных развёртываний**:
   - Создан крейт `cloud-integration` с абстракцией `CloudAdapter` и реализациями для AWS IoT, Azure IoT и общего MQTT.
   - Реализован `CloudBridge` для маршрутизации сообщений между mesh‑транспортом и облаком.
   - Добавлена поддержка feature flags для выбора облачного провайдера.

Все изменения готовы к интеграции в основную кодовую базу. Проект теперь обладает расширенной отказоустойчивостью, поддержкой гетерогенных агентов, криптографической безопасностью, инструментами отладки и облачной интеграцией, что соответствует целям развития SDK для автономных распределённых систем.

Author: sorydima

ARCHITECTURE.md

@@ -9,6 +9,8 @@ Offline-First Multi-Agent Autonomy SDK enables a group of robots to operate coll
 3. **Eventually consistent** – State converges across the swarm via CRDTs.
 4. **Resource‑aware** – Agents monitor and adapt to local constraints (CPU, battery, bandwidth).
 5. **Pluggable transport** – Support for various network layers (Wi‑Fi, Bluetooth, LoRa, etc.).
+6. **Bounded consensus** – Guaranteed agreement within a finite number of rounds, suitable for partially synchronous networks.
+7. **Observability** – Built‑in metrics and health monitoring via Prometheus.
 
 ## High‑Level Architecture
 
@@ -17,16 +19,26 @@ graph TB
     subgraph "Agent Node"
         AC[Agent Core]
         LP[Local Planner]
+        DP[Distributed Planner]
         SS[State Sync CRDT]
         MT[Mesh Transport]
         RM[Resource Monitor]
+        BC[Bounded Consensus]
+        MET[Metrics]
 
         AC --> LP
+        AC --> DP
         AC --> SS
         AC --> MT
         AC --> RM
+        AC --> BC
+        AC --> MET
         SS --> MT
         MT --> SS
+        DP --> BC
+        BC --> MT
+        MET --> MT
+        MET --> BC
     end
 
     subgraph "Swarm"
@@ -41,8 +53,10 @@ graph TB
     subgraph "External"
         SIM[Simulation Gazebo/ROS2]
         CLI[Python CLI]
+        PROM[Prometheus]
         SIM --> AC
         CLI --> AC
+        MET -- HTTP /metrics --> PROM
     end
 ```
 
@@ -55,7 +69,8 @@ graph TB
   - Connection management (TCP, WebRTC, QUIC)
   - Message routing (flooding, greedy perimeter)
   - Quality‑of‑Service (priority, retransmission)
-- **Technology**: Rust crate built on `libp2p` or `smol‑net`.
+  - End‑to‑end encryption and authentication (Ed25519 signatures)
+- **Technology**: Rust crate built on `libp2p` with an in‑memory backend for testing.
 
 ### 2. State Sync (CRDT)
 - **Purpose**: Maintain a shared, eventually‑consistent key‑value store across agents.
@@ -64,7 +79,8 @@ graph TB
   - Conflict‑free merge of concurrent updates
   - Tombstone‑free garbage collection
   - Version vectors / dotted version vectors
-- **Technology**: Rust crate leveraging `automerge` or custom CRDT implementation.
+  - Delta compression and batching
+- **Technology**: Rust crate leveraging `crdts` library with custom serialization.
 
 ### 3. Local Planner
 - **Purpose**: Execute autonomous tasks based on local state and shared swarm intent.
@@ -74,16 +90,42 @@ graph TB
   - Integration with ROS2 navigation stack
 - **Technology**: Rust crate with `behavior‑tree` or `smach`‑like DSL.
 
-### 4. Resource Monitor
+### 4. Distributed Planner
+- **Purpose**: Coordinate task assignment across multiple agents using consensus.
+- **Features**:
+  - Task definition and resource requirements
+  - Assignment proposals via bounded consensus
+  - Conflict resolution and load balancing
+  - Integration with Local Planner for execution
+- **Technology**: Rust crate built on top of `bounded‑consensus` and `state‑sync`.
+
+### 5. Bounded Consensus
+- **Purpose**: Reach agreement on a value within a bounded number of communication rounds.
+- **Features**:
+  - Two‑phase commit (simple)
+  - Paxos (multi‑round, fault‑tolerant)
+  - Configurable timeouts and participant sets
+  - Integration with mesh transport for message passing
+- **Technology**: Rust crate with pluggable consensus algorithms.
+
+### 6. Resource Monitor
 - **Purpose**: Observe local hardware constraints and adjust agent behavior.
 - **Metrics**: CPU usage, battery level, network latency, memory pressure.
 - **Actions**: Throttle planning frequency, reduce communication rate, switch to low‑power mode.
 
-### 5. Agent Core
+### 7. Agent Core
 - **Purpose**: Glue component that orchestrates the above modules.
 - **Lifecycle**: Initialization, event loop, graceful shutdown.
 - **API**: Exposes a unified Rust trait and Python binding.
 
+### 8. Metrics & Observability
+- **Purpose**: Expose internal metrics for monitoring and debugging.
+- **Features**:
+  - Prometheus counters, gauges, histograms
+  - HTTP endpoint `/metrics` on configurable port
+  - Metrics for messages sent/received, connected peers, CRDT map size, consensus rounds, etc.
+- **Technology**: `prometheus` Rust crate with `warp` HTTP server.
+
 ## Data Flow
 1. Agent starts, joins mesh network via Transport.
 2. Agent subscribes to shared CRDT keys (e.g., `swarm/goal`).
@@ -92,33 +134,41 @@ graph TB
 5. Transport propagates CRDT deltas to neighbors.
 6. Resource Monitor may throttle outgoing messages if battery low.
 7. On network partition, each agent continues with its last known state; merge occurs when connectivity resumes.
+8. For coordinated tasks, Distributed Planner proposes assignments via Bounded Consensus; once decided, assignments are written to CRDT map and executed by Local Planners.
+9. Metrics are continuously collected and exposed via HTTP.
 
 ## Development Roadmap
 
-### Phase 1 – Foundation (Current)
+### Phase 1 – Foundation (Completed)
 - Mesh Transport (basic peer discovery + messaging)
 - State Sync (single‑type CRDT map)
 - Integration test with two nodes
 
-### Phase 2 – Autonomy
+### Phase 2 – Autonomy (Completed)
 - Local Planner FSM
 - Resource Monitor skeleton
 - Python bindings for all components
+- Bounded Consensus (Two‑phase commit, Paxos)
+- Metrics with Prometheus
 
-### Phase 3 – Realism
-- ROS2 integration
+### Phase 3 – Realism (In Progress)
+- ROS2 integration (example nodes and launch files)
 - Gazebo simulation with multiple robots
-- Performance benchmarking
+- Performance benchmarking and optimization
+- Distributed Planner (task coordination)
 
 ### Phase 4 – Production
 - CI/CD, packaging (Debian, PyPI, crates.io)
 - Comprehensive documentation
 - Security audit
+- Fault‑injection and chaos testing
 
 ## Technology Stack
 - **Language**: Rust (core), Python (bindings & high‑level API)
-- **Networking**: `libp2p‑rust` or custom `smol‑net`
-- **CRDT**: `automerge‑rs` or custom implementation
+- **Networking**: `libp2p‑rust` with TCP/mDNS/WebSocket, in‑memory backend for tests
+- **CRDT**: `crdts` library with custom serialization
+- **Consensus**: Custom Paxos and two‑phase commit implementations
+- **Metrics**: `prometheus` + `warp`
 - **Simulation**: ROS2 Humble, Gazebo Classic / Ignition
 - **Build**: Cargo workspace, `pyo3`, `maturin`
 - **CI**: GitHub Actions, `cargo‑test`, `pytest`
@@ -130,4 +180,4 @@ See `README.md` for the exact folder structure.
 Please read `CONTRIBUTING.md` (to be created) for guidelines on code style, testing, and pull requests.
 
 ---
-*Last updated: 2026‑03‑26*
+*Last updated: 2026‑03‑27*

README.md

@@ -21,29 +21,37 @@ Enable groups of agents (robots, drones, edge devices) to collaborate reliably w
 - **Bounded Consensus**: Two‑phase commit protocol for agreement within bounded rounds.
 - **Delta Compression & Batching**: Optimized CRDT delta serialization with compression (Zlib) and deduplication.
 - **Web Monitor**: Built‑in web interface for real‑time agent monitoring.
+- **Distributed Task Planning**: Algorithms for coordinating tasks across agents (round‑robin, auction, resource‑aware).
+- **Resource Monitoring & Alerting**: Collect system metrics (CPU, battery, memory) and trigger alerts based on thresholds.
+- **State Migration**: Tools for upgrading CRDT schema versions without data loss.
+- **Multiple Transport Backends**: Support for libp2p, in‑memory, WebRTC, and LoRa (stub) backends.
+- **Swarm Simulation & Visualization**: Terminal‑based real‑time visualization of agent interactions.
 
 ## 🏗️ Architecture
 
 ```
 Agent Core
 ├── Local Planner        – Decision‑making and task allocation
+├── Distributed Planner  – Multi‑agent task coordination
 ├── State Sync (CRDT)    – Conflict‑free state synchronization
-├── Mesh Transport       – Peer discovery and message routing
-└── Resource Monitor     – CPU, memory, battery, network monitoring
+├── Mesh Transport       – Peer discovery and message routing (libp2p, WebRTC, LoRa)
+├── Resource Monitor     – CPU, memory, battery, network monitoring with alerting
+└── Bounded Consensus   – Agreement within bounded rounds
 ```
 
 The SDK is organized as a Rust workspace with the following crates:
 
 | Crate | Description |
 |-------|-------------|
 | `common` | Shared types, error handling, utilities (CBOR serialization). |
-| `mesh‑transport` | Mesh networking with libp2p backend, discovery, connection management, in‑memory simulation. |
-| `state‑sync` | CRDT‑based map, delta‑based synchronization, vector clocks, compression, batching, deduplication. |
+| `mesh‑transport` | Mesh networking with libp2p backend, discovery, connection management, in‑memory simulation, WebRTC and LoRa stubs. |
+| `state‑sync` | CRDT‑based map, delta‑based synchronization, vector clocks, compression, batching, deduplication, state migration. |
 | `agent‑core` | High‑level agent abstraction integrating transport and state sync. |
 | `local‑planner` | Trait and implementations for autonomous decision‑making. |
-| `resource‑monitor` | System resource tracking (CPU, memory, battery, network). |
+| `distributed‑planner` | Distributed task planning algorithms (round‑robin, auction, resource‑aware, consensus). |
+| `resource‑monitor` | System resource tracking (CPU, memory, battery, network) with alerting. |
 | `bounded‑consensus` | Bounded‑round consensus protocol (two‑phase commit) for agreement. |
-| `python/` | PyO3 bindings for Python integration with async support. |
+| `python/` | PyO3 bindings for Python integration with async support, covering all major components. |
 
 ## 🚀 Getting Started
 
@@ -82,6 +90,12 @@ cargo run --example web_monitor
 ```
 Then open http://127.0.0.1:3030 in your browser.
 
+**Swarm simulation with real‑time visualization** (terminal‑based):
+
+```bash
+cargo run --example swarm_simulation
+```
+
 **ROS2/Gazebo simulation example** (dummy simulation):
 
 ```bash
@@ -91,16 +105,12 @@ python simple_robot.py
 
 ### In‑Memory Backend for Testing
 
-The SDK includes an in‑memory transport backend that simulates network communication within a single process, ideal for unit tests and simulations. Enable it by setting `use_in_memory: true` in `MeshTransportConfig`.
+The SDK includes an in‑memory transport backend that simulates network communication within a single process, ideal for unit tests and simulations. Enable it by setting `backend_type: BackendType::InMemory` in `MeshTransportConfig`.
 
 Example:
 
 ```rust
-let config = MeshTransportConfig {
-    local_agent_id: AgentId(1),
-    use_in_memory: true,
-    ..Default::default()
-};
+let config = MeshTransportConfig::in_memory();
 ```
 
 ### Integration Tests
@@ -130,12 +140,19 @@ To use it, add `bounded-consensus` as a dependency and implement the `BoundedCon
 2. Write a Python script:
 
    ```python
-   from offline_first_autonomy import PyAgent
+   from offline_first_autonomy import PyAgent, PyDistributedPlanner, PyResourceMonitor
 
    agent = PyAgent(42)
    agent.start()
    agent.set_value("counter", "123")
-   # ...
+
+   planner = PyDistributedPlanner(1, [1, 2, 3])
+   planner.start()
+   planner.add_task("task1", "Move to point A", [], 10)
+
+   monitor = PyResourceMonitor(1)
+   cpu = monitor.cpu_usage()
+   print(f"CPU usage: {cpu}%")
    ```
 
 ## 📖 Documentation
@@ -162,7 +179,7 @@ cargo bench -p state-sync
 
 ### Adding a New Transport Backend
 
-Implement the `Transport` trait (see `crates/mesh‑transport/src/transport.rs`) and plug it into `MeshTransport`.
+Implement the `Backend` trait (see `crates/mesh‑transport/src/backend.rs`) and add a variant to `BackendType` in `transport.rs`.
 
 ### Implementing a Custom Local Planner
 
@@ -172,6 +189,10 @@ Implement the `LocalPlanner` trait (see `crates/local‑planner/src/lib.rs`) and
 
 Extend `state‑sync` with new CRDT structures that implement the `Crdt` trait.
 
+### Adding a New Planning Algorithm
+
+Implement the `PlanningAlgorithm` trait in `distributed‑planner/src/algorithms.rs` and register it with `DistributedPlanner`.
+
 ## 🤝 Contributing
 
 We welcome contributions! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.

crates/agent-core/src/agent.rs

@@ -1,30 +1,43 @@
 //! High‑level agent abstraction.
 
 use crate::integration::IntegrationAdapter;
+use crate::fault_tolerance::FaultToleranceManager;
 use common::types::AgentId;
 use common::error::Result;
 use mesh_transport::{MeshTransport, MeshTransportConfig};
 use state_sync::{DefaultStateSync, StateSync};
+use tokio::sync::mpsc;
 use tokio::task::JoinHandle;
 
 /// A full‑fledged agent combining transport, state sync, and application logic.
 pub struct Agent {
     id: AgentId,
     integration: IntegrationAdapter,
     task_handle: Option<JoinHandle<Result<()>>>,
+    fault_handle: Option<JoinHandle<()>>,
 }
 
 impl Agent {
     /// Create a new agent with the given configuration.
     pub fn new(id: AgentId, config: MeshTransportConfig) -> Result<Self> {
         let transport = MeshTransport::new(config)?;
         let state_sync = Box::new(DefaultStateSync::new(id));
-        let integration = IntegrationAdapter::new(transport, state_sync);
+
+        // Create channel for fault tolerance events
+        let (fault_tx, fault_rx) = mpsc::unbounded_channel();
+        let integration = IntegrationAdapter::new(transport, state_sync, Some(fault_tx));
+
+        // Start fault tolerance manager in background
+        let fault_manager = FaultToleranceManager::new(fault_rx);
+        let fault_handle = tokio::spawn(async move {
+            fault_manager.run().await;
+        });
 
         Ok(Self {
             id,
             integration,
             task_handle: None,
+            fault_handle: Some(fault_handle),
         })
     }
 
@@ -44,6 +57,10 @@ impl Agent {
             handle.abort();
             let _ = handle.await;
         }
+        if let Some(fault_handle) = self.fault_handle.take() {
+            fault_handle.abort();
+            let _ = fault_handle.await;
+        }
         Ok(())
     }