chore: restructure 6a2ml files into .machine_readable/6a2/

Author: hyperpolymath

.machine_readable/AGENTIC.a2ml .machine_readable/6a2/AGENTIC.a2ml.machine_readable/AGENTIC.a2ml renamed to .machine_readable/6a2/AGENTIC.a2ml

@@ -142,11 +142,17 @@ pub fn recommend_response(snap SpectrumSnapshot) DefensiveRecommendation {
 
 // freq_in_band checks whether a frequency falls within a given band.
 pub fn freq_in_band(freq_hz u64, band FreqBand) bool {
-	lower, upper := match band {
-		.hf { u64(0), u64(30_000_000) }
-		.vhf { u64(30_000_000), u64(300_000_000) }
-		.uhf { u64(300_000_000), u64(3_000_000_000) }
-		.shf { u64(3_000_000_000), u64(30_000_000_000) }
+	lower := match band {
+		.hf { u64(0) }
+		.vhf { u64(30_000_000) }
+		.uhf { u64(300_000_000) }
+		.shf { u64(3_000_000_000) }
+	}
+	upper := match band {
+		.hf { u64(30_000_000) }
+		.vhf { u64(300_000_000) }
+		.uhf { u64(3_000_000_000) }
+		.shf { u64(30_000_000_000) }
 	}
 	return freq_hz >= lower && freq_hz < upper
 }

.machine_readable/ECOSYSTEM.a2ml .machine_readable/6a2/ECOSYSTEM.a2ml.machine_readable/ECOSYSTEM.a2ml renamed to .machine_readable/6a2/ECOSYSTEM.a2ml

@@ -0,0 +1,163 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+// Copyright (c) 2026 Jonathan D.A. Jewell (hyperpolymath) <j.d.a.jewell@open.ac.uk>
+
+// ecm_api_test.v — Tests for the V-lang ECM API.
+
+module ecm_api
+
+// ── Point-to-point tests ────────────────────────────────────────────────
+
+fn test_classify_cw_jammer() {
+	sig := DetectedSignal{
+		frequency_hz: 2_400_000_000
+		bandwidth_hz: 50_000_000
+		snr_db: 30.0
+		modulation: .cw
+		classification: .neutral
+		bearing_deg: none
+		timestamp_s: 0.0
+	}
+	assert classify_signal(sig) == .suspected_jammer
+}
+
+fn test_classify_normal_ofdm() {
+	sig := DetectedSignal{
+		frequency_hz: 2_412_000_000
+		bandwidth_hz: 20_000_000
+		snr_db: 25.0
+		modulation: .ofdm
+		classification: .neutral
+		bearing_deg: none
+		timestamp_s: 0.0
+	}
+	assert classify_signal(sig) == .neutral
+}
+
+fn test_classify_wideband_jammer() {
+	sig := DetectedSignal{
+		frequency_hz: 1_000_000_000
+		bandwidth_hz: 50_000_000
+		snr_db: 15.0
+		modulation: .fm
+		classification: .neutral
+		bearing_deg: none
+		timestamp_s: 0.0
+	}
+	assert classify_signal(sig) == .suspected_jammer
+}
+
+// ── Frequency band tests ────────────────────────────────────────────────
+
+fn test_freq_in_band_vhf() {
+	assert freq_in_band(150_000_000, .vhf) == true
+	assert freq_in_band(500_000_000, .vhf) == false
+}
+
+fn test_freq_in_band_uhf() {
+	assert freq_in_band(1_000_000_000, .uhf) == true
+	assert freq_in_band(30_000_000, .uhf) == false
+}
+
+fn test_freq_bands_contiguous() {
+	// HF ends where VHF starts
+	assert freq_in_band(29_999_999, .hf) == true
+	assert freq_in_band(30_000_000, .hf) == false
+	assert freq_in_band(30_000_000, .vhf) == true
+}
+
+// ── Distance and separation tests ───────────────────────────────────────
+
+fn test_distance_squared_basic() {
+	a := Position3D{ x: 0, y: 0, z: 0 }
+	b := Position3D{ x: 3000, y: 4000, z: 0 }
+	// 3^2 + 4^2 = 25 (in metres), so 3000^2 + 4000^2 = 25,000,000 mm^2
+	assert distance_squared_mm(a, b) == 25_000_000
+}
+
+fn test_distance_symmetric() {
+	a := Position3D{ x: 1000, y: 2000, z: 3000 }
+	b := Position3D{ x: -500, y: 1500, z: 0 }
+	assert distance_squared_mm(a, b) == distance_squared_mm(b, a)
+}
+
+fn test_ground_safe() {
+	a := Position3D{ x: 0, y: 0, z: 0 }
+	far := Position3D{ x: 3000, y: 0, z: 0 }
+	close := Position3D{ x: 1000, y: 0, z: 0 }
+	assert ground_safe(a, far) == true
+	assert ground_safe(a, close) == false
+}
+
+fn test_aerial_safe() {
+	a := Position3D{ x: 0, y: 0, z: 0 }
+	far := Position3D{ x: 15000, y: 0, z: 0 }
+	close := Position3D{ x: 5000, y: 0, z: 0 }
+	assert aerial_safe(a, far) == true
+	assert aerial_safe(a, close) == false
+}
+
+// ── Snapshot and recommendation tests ───────────────────────────────────
+
+fn test_has_jamming_false() {
+	snap := SpectrumSnapshot{
+		centre_freq_hz: 2_400_000_000.0
+		bandwidth_hz: 20_000_000.0
+		noise_floor_dbm: -90.0
+		signals: []
+		timestamp_s: 0.0
+	}
+	assert has_jamming(snap) == false
+}
+
+fn test_has_jamming_true() {
+	snap := SpectrumSnapshot{
+		centre_freq_hz: 2_400_000_000.0
+		bandwidth_hz: 20_000_000.0
+		noise_floor_dbm: -90.0
+		signals: [
+			DetectedSignal{
+				frequency_hz: 2_400_000_000
+				bandwidth_hz: 50_000_000
+				snr_db: 40.0
+				modulation: .cw
+				classification: .suspected_jammer
+				bearing_deg: none
+				timestamp_s: 0.0
+			},
+		]
+		timestamp_s: 0.0
+	}
+	assert has_jamming(snap) == true
+}
+
+fn test_recommend_no_action() {
+	snap := SpectrumSnapshot{
+		centre_freq_hz: 150_000_000.0
+		bandwidth_hz: 10_000_000.0
+		noise_floor_dbm: -100.0
+		signals: []
+		timestamp_s: 0.0
+	}
+	assert recommend_response(snap) == .no_action
+}
+
+fn test_recommend_alert_on_jammer() {
+	snap := SpectrumSnapshot{
+		centre_freq_hz: 2_400_000_000.0
+		bandwidth_hz: 20_000_000.0
+		noise_floor_dbm: -90.0
+		signals: [
+			DetectedSignal{
+				frequency_hz: 2_400_000_000
+				bandwidth_hz: 50_000_000
+				snr_db: 40.0
+				modulation: .cw
+				classification: .suspected_jammer
+				bearing_deg: none
+				timestamp_s: 0.0
+			},
+		]
+		timestamp_s: 0.0
+	}
+	assert recommend_response(snap) == .alert_operator
+}

.machine_readable/META.a2ml .machine_readable/6a2/META.a2ml.machine_readable/META.a2ml renamed to .machine_readable/6a2/META.a2ml

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: PMPL-1.0-or-later
 // Copyright (c) 2026 Jonathan D.A. Jewell (hyperpolymath) <j.d.a.jewell@open.ac.uk>
 //
-// build.zig — Zig FFI bridge for Robodog ECM.
+// build.zig — Zig FFI bridge for Robodog ECM (Zig 0.15.x).
 // Builds a C-ABI shared library that bridges Idris2 ABI types to the Rust core.
 
 const std = @import("std");
@@ -11,39 +11,55 @@ pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
 
     // Shared library for FFI consumers (Idris2, V-lang API).
-    const lib = b.addSharedLibrary(.{
+    const lib = b.addLibrary(.{
         .name = "robodog_ffi",
-        .root_source_file = b.path("src/main.zig"),
-        .target = target,
-        .optimize = optimize,
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("src/main.zig"),
+            .target = target,
+            .optimize = optimize,
+        }),
+        .linkage = .dynamic,
     });
 
     // Also build a static library for embedding.
-    const static_lib = b.addStaticLibrary(.{
-        .name = "robodog_ffi",
-        .root_source_file = b.path("src/main.zig"),
-        .target = target,
-        .optimize = optimize,
+    const static_lib = b.addLibrary(.{
+        .name = "robodog_ffi_static",
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("src/main.zig"),
+            .target = target,
+            .optimize = optimize,
+        }),
+        .linkage = .static,
     });
 
     b.installArtifact(lib);
     b.installArtifact(static_lib);
 
     // Unit tests.
     const unit_tests = b.addTest(.{
-        .root_source_file = b.path("src/main.zig"),
-        .target = target,
-        .optimize = optimize,
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("src/main.zig"),
+            .target = target,
+            .optimize = optimize,
+        }),
     });
 
     const run_unit_tests = b.addRunArtifact(unit_tests);
 
     // Integration tests.
-    const integration_tests = b.addTest(.{
+    const integration_mod = b.createModule(.{
         .root_source_file = b.path("test/integration_test.zig"),
         .target = target,
         .optimize = optimize,
     });
+    integration_mod.addImport("main", b.createModule(.{
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+    }));
+    const integration_tests = b.addTest(.{
+        .root_module = integration_mod,
+    });
 
     const run_integration_tests = b.addRunArtifact(integration_tests);
 

.machine_readable/NEUROSYM.a2ml .machine_readable/6a2/NEUROSYM.a2ml.machine_readable/NEUROSYM.a2ml renamed to .machine_readable/6a2/NEUROSYM.a2ml

@@ -78,7 +78,7 @@ const MAX_LEGITIMATE_BW_HZ: u64 = 40_000_000;
 ///   modulation:   Modulation enum value.
 ///
 /// Returns: SignalClass enum value.
-export fn robodog_classify_signal(
+pub export fn robodog_classify_signal(
     freq_hz: u64,
     bandwidth_hz: u64,
     snr_db: i32,
@@ -109,7 +109,7 @@ export fn robodog_classify_signal(
 /// Check whether a frequency falls within a given band.
 ///
 /// Returns: 1 if in band, 0 if not.
-export fn robodog_freq_in_band(freq_hz: u64, band: i32) callconv(.c) i32 {
+pub export fn robodog_freq_in_band(freq_hz: u64, band: i32) callconv(.c) i32 {
     const b: FreqBand = @enumFromInt(band);
     const lower: u64 = switch (b) {
         .hf => 0,
@@ -130,7 +130,7 @@ export fn robodog_freq_in_band(freq_hz: u64, band: i32) callconv(.c) i32 {
 /// Compute squared distance between two 3D positions (in mm^2).
 ///
 /// Uses integer arithmetic — no floating point, fully deterministic.
-export fn robodog_distance_squared_mm(
+pub export fn robodog_distance_squared_mm(
     ax: i64,
     ay: i64,
     az: i64,
@@ -147,7 +147,7 @@ export fn robodog_distance_squared_mm(
 /// Check ground separation safety (minimum 2.0m = 2000mm).
 ///
 /// Returns: 1 if safe, 0 if violation.
-export fn robodog_ground_safe(
+pub export fn robodog_ground_safe(
     ax: i64,
     ay: i64,
     az: i64,
@@ -163,7 +163,7 @@ export fn robodog_ground_safe(
 /// Check aerial separation safety (minimum 10.0m = 10000mm).
 ///
 /// Returns: 1 if safe, 0 if violation.
-export fn robodog_aerial_safe(
+pub export fn robodog_aerial_safe(
     ax: i64,
     ay: i64,
     az: i64,
@@ -180,7 +180,7 @@ export fn robodog_aerial_safe(
 ///
 /// Writes positions to out_buf as an array of Position3D structs.
 /// Returns: 0 on success, -1 on invalid parameters.
-export fn robodog_compute_formation(
+pub export fn robodog_compute_formation(
     shape: i32,
     num_agents: i32,
     spacing_mm: u64,