Clean up horus/ codebase: zero clippy warnings, consistent formatting

- Fix all clippy warnings across workspace (48 warnings → 0):
  - Remove unnecessary pointer cast in dispatch.rs
  - Add BackendMap type alias to reduce type complexity in registry.rs
  - Replace loop-index patterns with iterator enumerate in tests
  - Use .is_some() instead of if-let-Some(_) pattern
  - Collapse nested if-else into else-if chains
  - Replace manual range checks with .contains()
  - Remove redundant u64 casts where type already matches
  - Fix doc list indentation in benchmarks
  - Remove dead code in loom tests (identical if/else branches)
  - Suppress too_many_arguments for PyO3 bindings
  - Replace approximate PI value with non-PI test data
- Run cargo fmt across all 72 files with formatting drift
- Fix compilation errors:
  - Restore TopicMetadata re-export dropped from lib.rs
  - Add missing SchedulerConfig import in doctest
- Delete unused driver.rs, examples, version.rs, yaml_utils.rs
- Refactor scheduling: add blackbox/config/safety_monitor improvements
- Update CI workflows, READMEs, Python bindings

Author: neos-builder

.github/workflows/integration-tests.yml

@@ -16,7 +16,6 @@ on:
 env:
   CARGO_TERM_COLOR: always
   # Minimum Supported Rust Version
-  # Requires 1.92.0+ due to horus_ai crate requirements
   MSRV: "1.92.0"
 
 jobs:
@@ -180,7 +179,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        rust: ["1.92.0"]  # MSRV - horus_ai requires 1.92.0
+        rust: ["1.92.0"]  # MSRV
     steps:
       - uses: actions/checkout@v4
 

.github/workflows/multi-platform.yml

@@ -95,6 +95,13 @@ jobs:
         uses: dtolnay/rust-toolchain@stable
 
       # Publish crates in dependency order
+      - name: Publish horus_types
+        run: cargo publish -p horus_types --token ${{ secrets.CARGO_REGISTRY_TOKEN }}
+        continue-on-error: true
+
+      - name: Wait for crates.io
+        run: sleep 30
+
       - name: Publish horus_core
         run: cargo publish -p horus_core --token ${{ secrets.CARGO_REGISTRY_TOKEN }}
         continue-on-error: true
@@ -116,13 +123,6 @@ jobs:
       - name: Wait for crates.io
         run: sleep 30
 
-      - name: Publish horus_ai
-        run: cargo publish -p horus_ai --token ${{ secrets.CARGO_REGISTRY_TOKEN }}
-        continue-on-error: true
-
-      - name: Wait for crates.io
-        run: sleep 30
-
       - name: Publish horus
         run: cargo publish -p horus --token ${{ secrets.CARGO_REGISTRY_TOKEN }}
         continue-on-error: true

.github/workflows/release.yml

@@ -21,7 +21,6 @@ on:
       # Only run on PRs that touch unsafe code
       - 'horus_core/src/memory/**'
       - 'horus_core/src/communication/**'
-      - 'horus_core/src/ipc/**'
 
 env:
   CARGO_TERM_COLOR: always
@@ -66,12 +65,6 @@ jobs:
         env:
           MIRIFLAGS: -Zmiri-disable-isolation -Zmiri-permissive-provenance
 
-      - name: MIRI - horus_core ipc module
-        run: |
-          cargo miri test -p horus_core --lib -- ipc::
-        env:
-          MIRIFLAGS: -Zmiri-disable-isolation -Zmiri-permissive-provenance
-
       # Run MIRI on horus_library Pod types (landmark, tracking, detection_pod, etc.)
       - name: MIRI - horus_library Pod types
         run: |

.github/workflows/safety.yml

@@ -230,8 +230,8 @@ horus/
 ├── horus_core/         # Core framework (Node, Topic, Scheduler)
 ├── horus_macros/       # Procedural macros (node!, message!)
 ├── horus_library/      # Standard message types and HFrame transforms
+├── horus_types/        # Core type definitions (descriptors, encodings, tensors)
 ├── horus_manager/      # CLI tool (horus command)
-├── horus_ai/           # ML model registry
 ├── horus_py/           # Python bindings
 ├── benchmarks/         # Performance benchmarks
 └── tests/              # Integration tests

CONTRIBUTING.md

@@ -50,7 +50,7 @@ message!(MotorCommand = (f64,));       // voltage
 
 node! {
     SensorNode {
-        pub { reading: SensorReading -> "sensor/data" }
+        pub { reading: SensorReading -> "sensor.data" }
         data { position: f64 = 0.0 }
 
         tick {
@@ -62,8 +62,8 @@ node! {
 
 node! {
     ControllerNode {
-        sub { sensor: SensorReading -> "sensor/data" }
-        pub { command: MotorCommand -> "motor/cmd" }
+        sub { sensor: SensorReading -> "sensor.data" }
+        pub { command: MotorCommand -> "motor.cmd" }
         data { target: f64 = 1.0 }
 
         tick {
@@ -125,24 +125,14 @@ Nodes communicate through topics. The framework automatically picks the fastest
 ```rust
 use horus::prelude::*;
 
-let topic: Topic<f64> = Topic::new("sensor_data", None)?;
+let topic: Topic<f64> = Topic::new("sensor_data")?;
 
 topic.send(42.0);
 if let Some(value) = topic.recv() {
     println!("Got: {}", value);
 }
 ```
 
-For multi-machine setups, just add an address:
-
-```rust
-// Same-machine: shared memory (sub-microsecond)
-let local: Topic<f64> = Topic::new("sensors", None)?;
-
-// Cross-machine: network (microseconds)
-let remote: Topic<f64> = Topic::new("sensors@192.168.1.100:8000", None)?;
-```
-
 ### Custom Nodes
 
 Define nodes with the `node!` macro:
@@ -154,8 +144,8 @@ message!(SensorData = (f64, u32));
 
 node! {
     MyNode {
-        pub { output: SensorData -> "sensor/output" }
-        sub { input: SensorData -> "sensor/input" }
+        pub { output: SensorData -> "sensor.output" }
+        sub { input: SensorData -> "sensor.input" }
         data { counter: u32 = 0 }
 
         tick {
@@ -184,7 +174,7 @@ HORUS includes standard robotics message types:
 ```rust
 use horus::prelude::*;
 
-let cmd_topic: Topic<CmdVel> = Topic::new("cmd_vel", None)?;
+let cmd_topic: Topic<CmdVel> = Topic::new("cmd_vel")?;
 cmd_topic.send(CmdVel::new(1.0, 0.0));
 ```
 
@@ -219,7 +209,6 @@ horus topic list            # See active topics
 horus node list             # See running nodes
 horus pkg install <name>    # Install packages
 horus deploy <target>       # Deploy to robot
-horus sim                   # Launch simulator
 ```
 
 Run `horus --help` for all commands.

README.md

@@ -45,9 +45,7 @@ use horus_benchmarks::platform::{detect_platform, has_constant_tsc, PlatformInfo
 use horus_benchmarks::set_cpu_affinity;
 use horus_benchmarks::stats::Statistics;
 use horus_benchmarks::timing::{rdtsc, rdtscp, serialize, PrecisionTimer, RdtscCalibration};
-use horus_benchmarks::{
-    BenchmarkConfig, BenchmarkResult, DeterminismMetrics, ThroughputMetrics,
-};
+use horus_benchmarks::{BenchmarkConfig, BenchmarkResult, DeterminismMetrics, ThroughputMetrics};
 use horus_library::messages::cmd_vel::CmdVel;
 use std::hint::spin_loop;
 use std::process::{Command, Stdio};
@@ -69,6 +67,7 @@ const TIMEOUT: Duration = Duration::from_secs(30);
 /// 1. Setup (spawn consumer, wait for topology, trigger migration) takes ~350ms
 /// 2. At ~100ns/msg SHM speed, 105K msgs finishes in ~10ms
 /// 3. Publishers must still be running during the measurement phase
+///
 /// 10M msgs × ~100ns = ~1s — enough headroom for setup + warmup + measurement.
 const PODSHM_MSGS_PER_PUB: u64 = 10_000_000;
 
@@ -143,7 +142,12 @@ fn main() {
     // --- Child process entry points ---
     if args.len() >= 5 && args[1] == "--child-publisher" {
         let paced = args.get(5).map(|s| s == "--paced").unwrap_or(false);
-        run_child_publisher(&args[2], args[3].parse().unwrap(), args[4].parse().unwrap(), paced);
+        run_child_publisher(
+            &args[2],
+            args[3].parse().unwrap(),
+            args[4].parse().unwrap(),
+            paced,
+        );
         return;
     }
     if args.len() >= 5 && args[1] == "--child-consumer" {
@@ -174,11 +178,7 @@ fn main() {
     let mut results: Vec<ScenarioResult> = Vec::new();
 
     // === Intra-process (5 scenarios) ===
-    println!(
-        "{} Intra-Process {}",
-        "───",
-        "─".repeat(BOX_W - 19)
-    );
+    println!("─── Intra-Process {}", "─".repeat(BOX_W - 19));
     println!();
 
     let r = bench_direct_channel(&timer);
@@ -203,8 +203,7 @@ fn main() {
 
     // === Cross-process (4 scenarios) ===
     println!(
-        "{} Cross-Process (RDTSC-in-payload) {}",
-        "───",
+        "─── Cross-Process (RDTSC-in-payload) {}",
         "─".repeat(BOX_W - 37)
     );
     println!();
@@ -229,8 +228,7 @@ fn main() {
     // === Raw atomic probe (hardware floor) ===
     println!();
     println!(
-        "{} Hardware Floor (raw SHM atomic) {}",
-        "───",
+        "─── Hardware Floor (raw SHM atomic) {}",
         "─".repeat(BOX_W - 38)
     );
     println!();
@@ -243,8 +241,7 @@ fn main() {
     if !skip_stress {
         println!();
         println!(
-            "{} Scalability Stress (PodShm N-pub x M-sub) {}",
-            "───",
+            "─── Scalability Stress (PodShm N-pub x M-sub) {}",
             "─".repeat(BOX_W - 47)
         );
         println!();
@@ -290,10 +287,7 @@ fn print_header(platform: &PlatformInfo, cal: &RdtscCalibration) {
     println!();
     println!("{}", box_top());
     println!("{}", box_center("HORUS IPC Latency Benchmark v2.0"));
-    println!(
-        "{}",
-        box_center("Per-Message RDTSC-Instrumented Latency")
-    );
+    println!("{}", box_center("Per-Message RDTSC-Instrumented Latency"));
     println!("{}", box_sep());
 
     let model = truncate(&platform.cpu.model, BOX_W - 8);
@@ -1176,7 +1170,10 @@ fn wait_for_topology(topic: &Topic<CmdVel>, min_pubs: u32, min_subs: u32, timeou
         if Instant::now() > deadline {
             eprintln!(
                 "  [warn] topology timeout: wanted pubs>={} subs>={}, got pubs={} subs={}",
-                min_pubs, min_subs, topic.pub_count(), topic.sub_count()
+                min_pubs,
+                min_subs,
+                topic.pub_count(),
+                topic.sub_count()
             );
             break;
         }
@@ -1274,7 +1271,9 @@ fn collect_cross_proc(
         if let Some(msg) = consumer.recv() {
             let recv_cycles = rdtscp();
             let send_cycles = msg.stamp_nanos;
-            let delta = recv_cycles.wrapping_sub(send_cycles).saturating_sub(overhead);
+            let delta = recv_cycles
+                .wrapping_sub(send_cycles)
+                .saturating_sub(overhead);
             latencies.push(cal.cycles_to_ns(delta));
             total += 1;
             last_recv_cycles = recv_cycles;
@@ -1357,7 +1356,9 @@ fn collect_pod_shm(
         if let Some(msg) = consumer.recv() {
             let recv_cycles = rdtscp();
             let send_cycles = msg.stamp_nanos;
-            let delta = recv_cycles.wrapping_sub(send_cycles).saturating_sub(overhead);
+            let delta = recv_cycles
+                .wrapping_sub(send_cycles)
+                .saturating_sub(overhead);
             latencies.push(cal.cycles_to_ns(delta));
             total += 1;
             last_recv_cycles = recv_cycles;
@@ -1742,10 +1743,7 @@ fn print_detail(r: &ScenarioResult) {
 
     if r.latencies_ns.is_empty() {
         println!("  NO SAMPLES -- topology did not route messages to parent consumer");
-        println!(
-            "  Messages: {}/{} received",
-            r.total_received, r.total_sent
-        );
+        println!("  Messages: {}/{} received", r.total_received, r.total_sent);
         println!();
         return;
     }
@@ -1817,10 +1815,7 @@ fn print_pod_shm_detail(r: &ScenarioResult) {
             let fresh_stats = Statistics::from_samples(freshness, 95.0, false);
             println!(
                 "    Freshness (msgs between reads):  p50: {}  p95: {}  p99: {}  max: {}",
-                fresh_stats.median as u64,
-                fresh_stats.p95,
-                fresh_stats.p99,
-                fresh_stats.max,
+                fresh_stats.median as u64, fresh_stats.p95, fresh_stats.p99, fresh_stats.max,
             );
         }
     }
@@ -1853,8 +1848,8 @@ fn print_summary(results: &[ScenarioResult]) {
     let w = BOX_W + 4;
     println!("{}", "=".repeat(w));
     println!(
-        "  {:<18} {:>7}  {:>8}  {:>8}  {:>8}  {:>8}  {:>8}  {}",
-        "Scenario", "Type", "p50", "p95", "p99", "p99.9", "max", "Backend"
+        "  {:<18} {:>7}  {:>8}  {:>8}  {:>8}  {:>8}  {:>8}  Backend",
+        "Scenario", "Type", "p50", "p95", "p99", "p99.9", "max"
     );
     println!("{}", "-".repeat(w));
 
@@ -1916,8 +1911,7 @@ fn print_overhead_analysis(results: &[ScenarioResult]) {
     let Some(floor_ns) = hw_floor else { return };
 
     println!(
-        "{} Framework Overhead (vs hardware floor: {}ns) {}",
-        "───",
+        "─── Framework Overhead (vs hardware floor: {}ns) {}",
         floor_ns,
         "─".repeat(BOX_W - 55)
     );
@@ -1955,11 +1949,7 @@ fn print_overhead_analysis(results: &[ScenarioResult]) {
 // ============================================================================
 
 fn print_methodology(cal: &RdtscCalibration) {
-    println!(
-        "{} Methodology {}",
-        "───",
-        "─".repeat(BOX_W - 18)
-    );
+    println!("─── Methodology {}", "─".repeat(BOX_W - 18));
     println!();
     println!("  Measurement types:");
     println!("    send      = producer-side send() latency (RDTSC, overhead subtracted)");
@@ -1990,7 +1980,9 @@ fn print_methodology(cal: &RdtscCalibration) {
         times[times.len() / 2]
     );
     println!("    Intra-process: RDTSC overhead subtracted from each sample");
-    println!("    Cross-process: RDTSC overhead subtracted (rdtsc on producer + rdtscp on consumer)");
+    println!(
+        "    Cross-process: RDTSC overhead subtracted (rdtsc on producer + rdtscp on consumer)"
+    );
     println!();
 
     println!("  Known limitations:");
@@ -2035,11 +2027,7 @@ fn write_json_output(path: &str, platform: &PlatformInfo, results: &[ScenarioRes
             raw_latencies_ns: Vec::new(),
             statistics: s.clone(),
             throughput: ThroughputMetrics {
-                messages_per_sec: if s.mean > 0.0 {
-                    1e9 / s.mean
-                } else {
-                    0.0
-                },
+                messages_per_sec: if s.mean > 0.0 { 1e9 / s.mean } else { 0.0 },
                 bytes_per_sec: if s.mean > 0.0 {
                     (std::mem::size_of::<CmdVel>() as f64) * 1e9 / s.mean
                 } else {
@@ -2106,12 +2094,7 @@ fn box_center(text: &str) -> String {
     let pad = BOX_W.saturating_sub(text.len());
     let left = pad / 2;
     let right = pad - left;
-    format!(
-        "║ {}{}{} ║",
-        " ".repeat(left),
-        text,
-        " ".repeat(right)
-    )
+    format!("║ {}{}{} ║", " ".repeat(left), text, " ".repeat(right))
 }
 fn box_left(text: &str) -> String {
     let content = if text.len() > BOX_W {

benchmarks/src/bin/all_paths_latency.rs

@@ -173,4 +173,3 @@ where
         std::hint::black_box(());
     }
 }
-

benchmarks/src/lib.rs

@@ -331,5 +331,4 @@ mod tests {
             min_latency
         );
     }
-
 }