diff --git a/v2/crates/wifi-densepose-wasm-edge/examples/run_all_skills.rs b/v2/crates/wifi-densepose-wasm-edge/examples/run_all_skills.rs
new file mode 100644
index 00000000..9ce92bb0
--- /dev/null
+++ b/v2/crates/wifi-densepose-wasm-edge/examples/run_all_skills.rs
@@ -0,0 +1,108 @@
+//! Runnable demo of the unified [`EdgePipeline`]: constructs every registered
+//! skill, feeds a short deterministic synthetic CSI frame sequence, and prints
+//! the per-skill events plus a registration summary.
+//!
+//! ```bash
+//! cd v2/crates/wifi-densepose-wasm-edge
+//! cargo run --example run_all_skills --features std
+//! cargo run --example run_all_skills --features std,medical-experimental
+//! ```
+//!
+//! [`EdgePipeline`]: wifi_densepose_wasm_edge::pipeline_all::EdgePipeline
+
+#[cfg(not(feature = "std"))]
+fn main() {
+    eprintln!("run_all_skills requires --features std");
+}
+
+#[cfg(feature = "std")]
+fn main() {
+    use std::collections::BTreeMap;
+    use wifi_densepose_wasm_edge::pipeline_all::{CsiFrameView, EdgePipeline};
+
+    const N_SC: usize = 32;
+    let mut pipeline = EdgePipeline::new();
+
+    println!("=== EdgePipeline registration ===");
+    println!("registered skills: {}", pipeline.skill_count());
+    let med = pipeline
+        .skills()
+        .iter()
+        .filter(|s| s.medical_experimental)
+        .count();
+    println!(
+        "  default tier: {}   medical-experimental tier: {}",
+        pipeline.skill_count() - med,
+        med
+    );
+    println!();
+
+    let mut phases = [0.0f32; N_SC];
+    let mut amps = [0.0f32; N_SC];
+    let mut vars = [0.0f32; N_SC];
+    let mut prev = [0.0f32; N_SC];
+
+    // Per-skill event counters over the run.
+    let mut counts: BTreeMap<&'static str, usize> = BTreeMap::new();
+    for s in pipeline.skills() {
+        counts.insert(s.name, 0);
+    }
+
+    let frames = 300usize;
+    for t in 0..frames {
+        let tf = t as f32;
+        let breath = (tf * 2.0 * std::f32::consts::PI * 0.3 / 20.0).sin();
+        let heart = (tf * 2.0 * std::f32::consts::PI * 1.2 / 20.0).sin();
+        let mut vmean = 0.0f32;
+        for i in 0..N_SC {
+            let sc = i as f32;
+            phases[i] = (sc * 0.21 + tf * 0.05).sin() + 0.15 * breath;
+            amps[i] = 1.0 + 0.3 * (sc * 0.11 + tf * 0.03).cos() + 0.1 * heart;
+            vars[i] = 0.02 + 0.01 * (sc * 0.3).sin().abs()
+                + if (t / 40) % 2 == 0 { 0.05 } else { 0.0 };
+            vmean += vars[i];
+        }
+        vmean /= N_SC as f32;
+
+        let v = CsiFrameView {
+            phases: &phases,
+            amplitudes: &amps,
+            variances: &vars,
+            prev_phases: &prev,
+            presence: if (t / 30) % 3 == 0 { 0 } else { 1 },
+            n_persons: ((t / 50) % 3) as i32,
+            motion_energy: 0.3 + 0.2 * (tf * 0.07).sin().abs(),
+            breathing_bpm: 18.0 + 2.0 * (tf * 0.01).sin(),
+            heartrate_bpm: 72.0 + 5.0 * (tf * 0.02).sin(),
+            coherence: 0.5 + 0.4 * (tf * 0.03).cos(),
+            variance_mean: vmean,
+        };
+
+        for e in pipeline.on_frame(&v) {
+            *counts.entry(e.skill).or_insert(0) += 1;
+            // Print the first few events from the last frame to show liveness.
+            if t == frames - 1 {
+                println!(
+                    "  frame {} | {:<26} event {:>3} = {:.4}",
+                    t, e.skill, e.event_id, e.value
+                );
+            }
+        }
+        prev.copy_from_slice(&phases);
+    }
+
+    println!();
+    println!("=== per-skill event totals over {} synthetic frames ===", frames);
+    let total: usize = counts.values().sum();
+    let active = counts.values().filter(|&&c| c > 0).count();
+    for (name, c) in &counts {
+        println!("  {:<28} {}", name, c);
+    }
+    println!();
+    println!(
+        "TOTAL events: {}   skills that emitted at least once: {}/{}",
+        total,
+        active,
+        pipeline.skill_count()
+    );
+}
diff --git a/v2/crates/wifi-densepose-wasm-edge/src/lib.rs b/v2/crates/wifi-densepose-wasm-edge/src/lib.rs
index b38b1308..2b3b7065 100644
--- a/v2/crates/wifi-densepose-wasm-edge/src/lib.rs
+++ b/v2/crates/wifi-densepose-wasm-edge/src/lib.rs
@@ -94,6 +94,18 @@ pub mod ind_structural_vibration;
 
 pub mod vendor_common;
 
+// ── Unified edge pipeline (ADR-160 deliverable) ──────────────────────────────
+//
+// `EdgePipeline` registers EVERY runtime skill module behind one uniform
+// `EdgeSkill` trait and runs them all per CSI frame. Host-only (`std`): it uses
+// Box/Vec for dynamic dispatch; the wasm `no_std` build keeps the small flagship
+// pipeline in this file. The `med_*` tier is registered only under
+// `medical-experimental` (preserves the ADR-160 safety gate).
+#[cfg(feature = "std")]
+pub mod pipeline_all;
+#[cfg(feature = "std")]
+pub mod skill_registry;
+
 // ── Vendor-integrated modules (ADR-041 Category 7) ──────────────────────────
 //
 // 24 modules organised into 7 sub-categories.  Each module file lives in
diff --git a/v2/crates/wifi-densepose-wasm-edge/src/pipeline_all.rs b/v2/crates/wifi-densepose-wasm-edge/src/pipeline_all.rs
new file mode 100644
index 00000000..572eb1fc
--- /dev/null
+++ b/v2/crates/wifi-densepose-wasm-edge/src/pipeline_all.rs
@@ -0,0 +1,217 @@
+//! Unified edge pipeline — registers **every** runtime skill module in the crate
+//! behind one uniform [`EdgeSkill`] trait and runs them all per CSI frame.
+//!
+//! # Why this module exists
+//!
+//! Each skill in `src/*.rs` is an independently-loadable DSP module with its own
+//! bespoke `process_frame` / `on_timer` signature (some take `&[f32]` phases,
+//! some scalars like `motion_energy`, some `breathing_bpm`/`heartrate_bpm`, etc.).
+//! On the wasm target only the flagship `gesture + coherence + adversarial`
+//! pipeline (in `lib.rs`) is on the default `on_frame` path. This module wires
+//! **all** of them into a single [`EdgePipeline`] so a host can run the whole
+//! skill library over one CSI frame stream and collect every emitted event,
+//! tagged by its source skill.
+//!
+//! # Design
+//!
+//! - [`CsiFrameView`] — a borrowed, host-supplied view of one CSI frame carrying
+//!   every input any skill needs (phase/amplitude/variance slices + the scalar
+//!   features the host derives: presence, n_persons, motion_energy, breathing &
+//!   heart rate, coherence, plus the previous frame's phases for delta skills).
+//! - [`EdgeSkill`] — the uniform adapter trait. Each skill gets a small adapter
+//!   (see `skill_registry`) that pulls the fields it needs out of the view, calls
+//!   the underlying detector **unchanged**, and returns an aggregated
+//!   `&[(i32, f32)]` event buffer. **No skill DSP is modified.**
+//! - [`EdgePipeline`] — owns one boxed adapter per skill, dispatches `on_frame`
+//!   to all of them, and aggregates `(skill_name, event_id, value)` triples.
+//!
+//! # Feature gating (preserves the ADR-160 safety gate)
+//!
+//! The five `med_*` skills are registered **only** under
+//! `--features medical-experimental`. They are NOT pulled into the default
+//! pipeline, so they cannot be silently built into a shipping artifact. The
+//! medical tier is opt-in; see `EdgePipeline::new` and `skills()`.
+//!
+//! Requires `std` (uses `Box`/`Vec`); the wasm `no_std` build keeps the small
+//! flagship `lib.rs` pipeline instead.
+
+#![cfg(feature = "std")]
+
+extern crate std;
+use std::boxed::Box;
+use std::vec::Vec;
+
+/// Borrowed view of one CSI frame: every input any registered skill can consume.
+///
+/// The host derives these from the Tier-2 DSP output. Slices are
+/// per-subcarrier; scalars are frame-level aggregates. A skill adapter reads
+/// only the fields it needs and ignores the rest — heterogeneity is absorbed
+/// here, not in the skills.
+#[derive(Clone, Copy)]
+pub struct CsiFrameView<'a> {
+    /// Per-subcarrier unwrapped phase (radians).
+    pub phases: &'a [f32],
+    /// Per-subcarrier amplitude (linear).
+    pub amplitudes: &'a [f32],
+    /// Per-subcarrier short-window variance.
+    pub variances: &'a [f32],
+    /// Previous frame's phases (for delta/velocity skills like the spiking tracker).
+    pub prev_phases: &'a [f32],
+    /// Presence flag from host (0 = empty, 1 = occupied).
+    pub presence: i32,
+    /// Estimated person count from host.
+    pub n_persons: i32,
+    /// Frame-level motion energy.
+    pub motion_energy: f32,
+    /// Breathing rate estimate (breaths/min); 0 if unavailable.
+    pub breathing_bpm: f32,
+    /// Heart rate estimate (beats/min); 0 if unavailable.
+    pub heartrate_bpm: f32,
+    /// Coherence score [0,1] from the coherence monitor (for gate-style skills).
+    pub coherence: f32,
+    /// Mean variance across `variances` (convenience scalar for skills wanting one).
+    pub variance_mean: f32,
+}
+
+impl<'a> CsiFrameView<'a> {
+    /// Mean amplitude across the frame (convenience for scalar-input skills).
+    #[inline]
+    pub fn amplitude_mean(&self) -> f32 {
+        if self.amplitudes.is_empty() {
+            return 0.0;
+        }
+        let mut s = 0.0f32;
+        for &a in self.amplitudes {
+            s += a;
+        }
+        s / self.amplitudes.len() as f32
+    }
+
+    /// Mean phase across the frame.
+    #[inline]
+    pub fn phase_mean(&self) -> f32 {
+        if self.phases.is_empty() {
+            return 0.0;
+        }
+        let mut s = 0.0f32;
+        for &p in self.phases {
+            s += p;
+        }
+        s / self.phases.len() as f32
+    }
+}
+
+/// One emitted event, tagged by its source skill.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct SkillEvent {
+    /// Stable name of the skill that produced this event (e.g. `"occupancy"`).
+    pub skill: &'static str,
+    /// Event type id (the registry id from `event_types`).
+    pub event_id: i32,
+    /// Event payload value.
+    pub value: f32,
+}
+
+/// Uniform adapter trait over a heterogeneous skill detector.
+///
+/// Implementors live in `skill_registry`; each wraps exactly one underlying
+/// detector and forwards `on_frame` to its real `process_frame`/`on_timer`
+/// without changing the DSP. `event_ids()` is introspection only.
+pub trait EdgeSkill {
+    /// Stable skill name (matches the `src/<name>.rs` module).
+    fn name(&self) -> &'static str;
+    /// The event ids this skill can emit (for introspection / docs).
+    fn event_ids(&self) -> &'static [i32];
+    /// Run this skill over one frame, returning its emitted `(event_id, value)`
+    /// pairs. Returns an empty slice if the skill emitted nothing this frame.
+    fn on_frame(&mut self, frame: &CsiFrameView) -> &[(i32, f32)];
+}
+
+/// Introspection record for one registered skill.
+#[derive(Clone, Copy, Debug)]
+pub struct SkillInfo {
+    /// Skill name.
+    pub name: &'static str,
+    /// Event ids the skill can emit.
+    pub event_ids: &'static [i32],
+    /// Whether the skill is part of the gated `medical-experimental` tier.
+    pub medical_experimental: bool,
+}
+
+/// The unified pipeline: holds one adapter per registered skill and runs them
+/// all per frame.
+pub struct EdgePipeline {
+    skills: Vec<Box<dyn EdgeSkill>>,
+    /// Parallel flag marking which entries are the gated medical tier.
+    medical_flags: Vec<bool>,
+    frame_count: u64,
+}
+
+impl EdgePipeline {
+    /// Construct the pipeline with **every** registered skill.
+    ///
+    /// The five `med_*` skills are included **only** when the crate is built
+    /// with `--features medical-experimental`; otherwise the default
+    /// (non-medical) tier is registered. This preserves the ADR-160 safety gate.
+    pub fn new() -> Self {
+        let mut skills: Vec<Box<dyn EdgeSkill>> = Vec::new();
+        let mut medical_flags: Vec<bool> = Vec::new();
+
+        crate::skill_registry::register_default(&mut skills, &mut medical_flags);
+        #[cfg(feature = "medical-experimental")]
+        crate::skill_registry::register_medical(&mut skills, &mut medical_flags);
+
+        Self {
+            skills,
+            medical_flags,
+            frame_count: 0,
+        }
+    }
+
+    /// Number of registered skills (default tier, or +medical if that feature is on).
+    pub fn skill_count(&self) -> usize {
+        self.skills.len()
+    }
+
+    /// Run every registered skill over one frame, aggregating all emitted events
+    /// tagged by source skill. Order matches registration order.
+    pub fn on_frame(&mut self, frame: &CsiFrameView) -> Vec<SkillEvent> {
+        self.frame_count += 1;
+        let mut out: Vec<SkillEvent> = Vec::new();
+        for skill in self.skills.iter_mut() {
+            let name = skill.name();
+            for &(event_id, value) in skill.on_frame(frame) {
+                out.push(SkillEvent {
+                    skill: name,
+                    event_id,
+                    value,
+                });
+            }
+        }
+        out
+    }
+
+    /// Total frames processed so far.
+    pub fn frame_count(&self) -> u64 {
+        self.frame_count
+    }
+
+    /// Introspection: list every registered skill with its event ids and tier.
+    pub fn skills(&self) -> Vec<SkillInfo> {
+        let mut out = Vec::with_capacity(self.skills.len());
+        for (i, skill) in self.skills.iter().enumerate() {
+            out.push(SkillInfo {
+                name: skill.name(),
+                event_ids: skill.event_ids(),
+                medical_experimental: self.medical_flags.get(i).copied().unwrap_or(false),
+            });
+        }
+        out
+    }
+}
+
+impl Default for EdgePipeline {
+    fn default() -> Self {
+        Self::new()
+    }
+}
diff --git a/v2/crates/wifi-densepose-wasm-edge/src/skill_registry.rs b/v2/crates/wifi-densepose-wasm-edge/src/skill_registry.rs
new file mode 100644
index 00000000..00a418e0
--- /dev/null
+++ b/v2/crates/wifi-densepose-wasm-edge/src/skill_registry.rs
@@ -0,0 +1,630 @@
+//! Adapters wiring every runtime skill detector to the uniform [`EdgeSkill`]
+//! trait, plus the registration functions consumed by [`EdgePipeline::new`].
+//!
+//! [`EdgePipeline::new`]: crate::pipeline_all::EdgePipeline::new
+//! [`EdgeSkill`]: crate::pipeline_all::EdgeSkill
+//!
+//! # How adapters work
+//!
+//! Each underlying detector keeps its own bespoke `process_frame`/`on_timer`
+//! signature and its owned `events: [(i32,f32); N]` buffer (the ADR-160 M6
+//! soundness fix). An adapter holds the detector, implements [`EdgeSkill`], and
+//! in `on_frame` simply pulls the needed fields out of [`CsiFrameView`] and
+//! forwards the call **unchanged**. The detector returns `&self.events[..n]`;
+//! the adapter forwards that borrow directly, so no extra buffer or copy is
+//! needed for the common case.
+//!
+//! Three families need a small owned scratch buffer in the adapter instead of a
+//! direct forward, because the underlying entry point does not itself return a
+//! `&[(i32,f32)]`:
+//! - `gesture` (`-> Option<u8>`), `coherence` (`-> f32`), `adversarial`
+//!   (`-> bool`): the adapter synthesizes a single tagged event.
+//! - `sig_sparse_recovery` (`process_frame(&mut [f32])`): the adapter copies the
+//!   frame amplitudes into an owned scratch slice so the in-place ISTA recovery
+//!   never mutates the shared frame, then forwards the borrow.
+//! - timer-driven skills (`vital_trend`, `lrn_meta_adapt`, `sig_temporal_compress`,
+//!   `tmp_goap_autonomy`, `tmp_pattern_sequence`): their `on_timer()` is driven
+//!   once per frame here (a frame *is* the tick at the edge), forwarding the
+//!   borrow. `tmp_pattern_sequence` additionally calls its `on_frame(...)`
+//!   accumulator first.
+//!
+//! **No skill's DSP is changed.** Only the call wiring lives here.
+
+#![cfg(feature = "std")]
+
+extern crate std;
+use std::boxed::Box;
+use std::vec::Vec;
+
+use crate::pipeline_all::{CsiFrameView, EdgeSkill};
+
+// ── Direct-forward adapter macro ─────────────────────────────────────────────
+//
+// Generates an adapter whose `on_frame` forwards directly to a detector method
+// that already returns `&[(i32, f32)]`. `$call` is an expression over `self.0`
+// (the detector) and `f` (the `&CsiFrameView`).
+macro_rules! fwd_skill {
+    ($adapter:ident, $detector:path, $name:literal, $ids:expr, |$d:ident, $f:ident| $call:expr) => {
+        pub struct $adapter($detector);
+        impl $adapter {
+            pub fn new() -> Self {
+                Self(<$detector>::new())
+            }
+        }
+        impl EdgeSkill for $adapter {
+            fn name(&self) -> &'static str {
+                $name
+            }
+            fn event_ids(&self) -> &'static [i32] {
+                &$ids
+            }
+            fn on_frame(&mut self, $f: &CsiFrameView) -> &[(i32, f32)] {
+                let $d = &mut self.0;
+                $call
+            }
+        }
+    };
+}
+
+// ── Synthesized-event adapter macro ──────────────────────────────────────────
+//
+// For detectors whose entry point does NOT return `&[(i32, f32)]`. The adapter
+// owns a tiny scratch buffer; `$body` (over `self`, `f`, and `self.buf`/`self.n`)
+// fills it and the trait returns the filled prefix.
+macro_rules! synth_skill {
+    ($adapter:ident, $detector:path, $name:literal, $ids:expr, $buf:literal,
+     |$s:ident, $f:ident| $body:block) => {
+        pub struct $adapter {
+            det: $detector,
+            buf: [(i32, f32); $buf],
+            n: usize,
+        }
+        impl $adapter {
+            pub fn new() -> Self {
+                Self {
+                    det: <$detector>::new(),
+                    buf: [(0, 0.0); $buf],
+                    n: 0,
+                }
+            }
+        }
+        impl EdgeSkill for $adapter {
+            fn name(&self) -> &'static str {
+                $name
+            }
+            fn event_ids(&self) -> &'static [i32] {
+                &$ids
+            }
+            fn on_frame(&mut self, $f: &CsiFrameView) -> &[(i32, f32)] {
+                let $s = self;
+                $s.n = 0;
+                $body
+                &$s.buf[..$s.n]
+            }
+        }
+    };
+}
+
+use crate::event_types as ev;
+
+// ── Flagship (synthesized) ───────────────────────────────────────────────────
+
+synth_skill!(GestureAdapter, crate::gesture::GestureDetector, "gesture",
+    [ev::GESTURE_DETECTED], 1, |s, f| {
+        if let Some(id) = s.det.process_frame(f.phases) {
+            s.buf[0] = (ev::GESTURE_DETECTED, id as f32);
+            s.n = 1;
+        }
+    });
+
+synth_skill!(CoherenceAdapter, crate::coherence::CoherenceMonitor, "coherence",
+    [ev::COHERENCE_SCORE], 1, |s, f| {
+        let score = s.det.process_frame(f.phases);
+        s.buf[0] = (ev::COHERENCE_SCORE, score);
+        s.n = 1;
+    });
+
+synth_skill!(AdversarialAdapter, crate::adversarial::AnomalyDetector, "adversarial",
+    [ev::ANOMALY_DETECTED], 1, |s, f| {
+        if s.det.process_frame(f.phases, f.amplitudes) {
+            s.buf[0] = (ev::ANOMALY_DETECTED, 1.0);
+            s.n = 1;
+        }
+    });
+
+// ── sig_sparse_recovery (needs owned mutable amplitude scratch) ───────────────
+
+const SPARSE_SC: usize = 64;
+pub struct SparseRecoveryAdapter {
+    det: crate::sig_sparse_recovery::SparseRecovery,
+    scratch: [f32; SPARSE_SC],
+}
+impl SparseRecoveryAdapter {
+    pub fn new() -> Self {
+        Self {
+            det: crate::sig_sparse_recovery::SparseRecovery::new(),
+            scratch: [0.0; SPARSE_SC],
+        }
+    }
+}
+impl EdgeSkill for SparseRecoveryAdapter {
+    fn name(&self) -> &'static str {
+        "sig_sparse_recovery"
+    }
+    fn event_ids(&self) -> &'static [i32] {
+        &[ev::RECOVERY_COMPLETE, ev::RECOVERY_ERROR, ev::DROPOUT_RATE]
+    }
+    fn on_frame(&mut self, f: &CsiFrameView) -> &[(i32, f32)] {
+        let n = f.amplitudes.len().min(SPARSE_SC);
+        self.scratch[..n].copy_from_slice(&f.amplitudes[..n]);
+        self.det.process_frame(&mut self.scratch[..n])
+    }
+}
+
+// ── Standard direct-forward skills (return &[(i32,f32)]) ─────────────────────
+
+fwd_skill!(AisBehavioralAdapter, crate::ais_behavioral_profiler::BehavioralProfiler,
+    "ais_behavioral_profiler",
+    [ev::BEHAVIOR_ANOMALY, ev::PROFILE_DEVIATION, ev::NOVEL_PATTERN, ev::PROFILE_MATURITY],
+    |d, f| d.process_frame(f.presence != 0, f.motion_energy, f.n_persons.max(0) as u8));
+
+fwd_skill!(AisPromptShieldAdapter, crate::ais_prompt_shield::PromptShield,
+    "ais_prompt_shield",
+    [ev::REPLAY_ATTACK, ev::INJECTION_DETECTED, ev::JAMMING_DETECTED, ev::SIGNAL_INTEGRITY],
+    |d, f| d.process_frame(f.phases, f.amplitudes));
+
+fwd_skill!(AutPsychoAdapter, crate::aut_psycho_symbolic::PsychoSymbolicEngine,
+    "aut_psycho_symbolic",
+    [ev::INFERENCE_RESULT, ev::INFERENCE_CONFIDENCE, ev::RULE_FIRED, ev::CONTRADICTION],
+    |d, f| d.process_frame(f.presence as f32, f.motion_energy, f.breathing_bpm,
+        f.heartrate_bpm, f.n_persons as f32, 0.0));
+
+fwd_skill!(AutMeshAdapter, crate::aut_self_healing_mesh::SelfHealingMesh,
+    "aut_self_healing_mesh",
+    [ev::NODE_DEGRADED, ev::MESH_RECONFIGURE, ev::COVERAGE_SCORE, ev::HEALING_COMPLETE],
+    |d, f| d.process_frame(f.variances));
+
+fwd_skill!(BldElevatorAdapter, crate::bld_elevator_count::ElevatorCounter,
+    "bld_elevator_count",
+    [ev::ELEVATOR_COUNT, ev::DOOR_OPEN, ev::DOOR_CLOSE, ev::OVERLOAD_WARNING],
+    |d, f| d.process_frame(f.amplitudes, f.phases, f.motion_energy, f.n_persons));
+
+fwd_skill!(BldEnergyAdapter, crate::bld_energy_audit::EnergyAuditor,
+    "bld_energy_audit",
+    [ev::SCHEDULE_SUMMARY, ev::AFTER_HOURS_ALERT, ev::UTILIZATION_RATE],
+    |d, f| d.process_frame(f.presence, f.n_persons));
+
+fwd_skill!(BldHvacAdapter, crate::bld_hvac_presence::HvacPresenceDetector,
+    "bld_hvac_presence",
+    [ev::HVAC_OCCUPIED, ev::ACTIVITY_LEVEL, ev::DEPARTURE_COUNTDOWN],
+    |d, f| d.process_frame(f.presence as f32, f.motion_energy));
+
+fwd_skill!(BldLightingAdapter, crate::bld_lighting_zones::LightingZoneController,
+    "bld_lighting_zones",
+    [ev::LIGHT_ON, ev::LIGHT_DIM, ev::LIGHT_OFF],
+    |d, f| d.process_frame(f.amplitudes, f.motion_energy));
+
+fwd_skill!(BldMeetingAdapter, crate::bld_meeting_room::MeetingRoomTracker,
+    "bld_meeting_room",
+    [ev::MEETING_START, ev::MEETING_END, ev::PEAK_HEADCOUNT, ev::ROOM_AVAILABLE],
+    |d, f| d.process_frame(f.presence, f.n_persons, f.motion_energy));
+
+fwd_skill!(ExoBreathingSyncAdapter, crate::exo_breathing_sync::BreathingSyncDetector,
+    "exo_breathing_sync",
+    [ev::SYNC_DETECTED, ev::SYNC_PAIR_COUNT, ev::GROUP_COHERENCE, ev::SYNC_LOST],
+    |d, f| d.process_frame(f.phases, f.variances, f.breathing_bpm, f.n_persons));
+
+fwd_skill!(ExoEmotionAdapter, crate::exo_emotion_detect::EmotionDetector,
+    "exo_emotion_detect",
+    [ev::AROUSAL_LEVEL, ev::STRESS_INDEX, ev::CALM_DETECTED, ev::AGITATION_DETECTED],
+    |d, f| d.process_frame(f.breathing_bpm, f.heartrate_bpm, f.motion_energy,
+        f.phase_mean(), f.variance_mean));
+
+fwd_skill!(ExoDreamAdapter, crate::exo_dream_stage::DreamStageDetector,
+    "exo_dream_stage",
+    [ev::SLEEP_STAGE, ev::SLEEP_QUALITY, ev::REM_EPISODE, ev::DEEP_SLEEP_RATIO],
+    |d, f| d.process_frame(f.breathing_bpm, f.heartrate_bpm, f.motion_energy,
+        f.phase_mean(), f.variance_mean, f.presence));
+
+fwd_skill!(ExoGestureLangAdapter, crate::exo_gesture_language::GestureLanguageDetector,
+    "exo_gesture_language",
+    [ev::LETTER_RECOGNIZED, ev::LETTER_CONFIDENCE, ev::WORD_BOUNDARY, ev::GESTURE_REJECTED],
+    |d, f| d.process_frame(f.phases, f.amplitudes, f.variance_mean, f.motion_energy, f.presence));
+
+fwd_skill!(ExoGhostAdapter, crate::exo_ghost_hunter::GhostHunterDetector,
+    "exo_ghost_hunter",
+    [ev::EXO_ANOMALY_DETECTED, ev::EXO_ANOMALY_CLASS, ev::HIDDEN_PRESENCE, ev::ENVIRONMENTAL_DRIFT],
+    |d, f| d.process_frame(f.phases, f.amplitudes, f.variances, f.presence, f.motion_energy));
+
+fwd_skill!(ExoHappinessAdapter, crate::exo_happiness_score::HappinessScoreDetector,
+    "exo_happiness_score",
+    [ev::HAPPINESS_SCORE, ev::GAIT_ENERGY, ev::AFFECT_VALENCE, ev::SOCIAL_ENERGY, ev::TRANSIT_DIRECTION],
+    |d, f| d.process_frame(f.phases, f.amplitudes, f.variances, f.presence,
+        f.motion_energy, f.breathing_bpm, f.heartrate_bpm));
+
+fwd_skill!(ExoHyperbolicAdapter, crate::exo_hyperbolic_space::HyperbolicEmbedder,
+    "exo_hyperbolic_space",
+    [ev::HIERARCHY_LEVEL, ev::HYPERBOLIC_RADIUS, ev::LOCATION_LABEL],
+    |d, f| d.process_frame(f.amplitudes));
+
+fwd_skill!(ExoMusicAdapter, crate::exo_music_conductor::MusicConductorDetector,
+    "exo_music_conductor",
+    [ev::CONDUCTOR_BPM, ev::BEAT_POSITION, ev::DYNAMIC_LEVEL, ev::GESTURE_CUTOFF, ev::GESTURE_FERMATA],
+    |d, f| d.process_frame(f.phase_mean(), f.amplitude_mean(), f.motion_energy, f.variance_mean));
+
+fwd_skill!(ExoPlantAdapter, crate::exo_plant_growth::PlantGrowthDetector,
+    "exo_plant_growth",
+    [ev::GROWTH_RATE, ev::CIRCADIAN_PHASE, ev::WILT_DETECTED, ev::WATERING_EVENT],
+    |d, f| d.process_frame(f.amplitudes, f.phases, f.variances, f.presence));
+
+fwd_skill!(ExoRainAdapter, crate::exo_rain_detect::RainDetector,
+    "exo_rain_detect",
+    [ev::RAIN_ONSET, ev::RAIN_INTENSITY, ev::RAIN_CESSATION],
+    |d, f| d.process_frame(f.phases, f.variances, f.amplitudes, f.presence));
+
+fwd_skill!(ExoTimeCrystalAdapter, crate::exo_time_crystal::TimeCrystalDetector,
+    "exo_time_crystal",
+    [ev::CRYSTAL_DETECTED, ev::CRYSTAL_STABILITY, ev::COORDINATION_INDEX],
+    |d, f| d.process_frame(f.motion_energy));
+
+fwd_skill!(IndCleanRoomAdapter, crate::ind_clean_room::CleanRoomMonitor,
+    "ind_clean_room",
+    [ev::OCCUPANCY_COUNT, ev::OCCUPANCY_VIOLATION, ev::TURBULENT_MOTION, ev::COMPLIANCE_REPORT],
+    |d, f| d.process_frame(f.n_persons, f.presence, f.motion_energy));
+
+fwd_skill!(IndConfinedAdapter, crate::ind_confined_space::ConfinedSpaceMonitor,
+    "ind_confined_space",
+    [ev::WORKER_ENTRY, ev::WORKER_EXIT, ev::BREATHING_OK, ev::EXTRACTION_ALERT, ev::IMMOBILE_ALERT],
+    |d, f| d.process_frame(f.presence, f.breathing_bpm, f.motion_energy, f.variance_mean));
+
+fwd_skill!(IndForkliftAdapter, crate::ind_forklift_proximity::ForkliftProximityDetector,
+    "ind_forklift_proximity",
+    [ev::PROXIMITY_WARNING, ev::VEHICLE_DETECTED, ev::HUMAN_NEAR_VEHICLE],
+    |d, f| d.process_frame(f.phases, f.amplitudes, f.variances, f.motion_energy, f.presence, f.n_persons));
+
+fwd_skill!(IndLivestockAdapter, crate::ind_livestock_monitor::LivestockMonitor,
+    "ind_livestock_monitor",
+    [ev::ANIMAL_PRESENT, ev::ABNORMAL_STILLNESS, ev::LABORED_BREATHING, ev::ESCAPE_ALERT],
+    |d, f| d.process_frame(f.presence, f.breathing_bpm, f.motion_energy, f.variance_mean));
+
+fwd_skill!(IndVibrationAdapter, crate::ind_structural_vibration::StructuralVibrationMonitor,
+    "ind_structural_vibration",
+    [ev::SEISMIC_DETECTED, ev::MECHANICAL_RESONANCE, ev::STRUCTURAL_DRIFT, ev::VIBRATION_SPECTRUM],
+    |d, f| d.process_frame(f.phases, f.amplitudes, f.variances, f.presence));
+
+fwd_skill!(IntrusionAdapter, crate::intrusion::IntrusionDetector,
+    "intrusion",
+    [ev::INTRUSION_ALERT, ev::INTRUSION_ZONE, 202],
+    |d, f| d.process_frame(f.phases, f.amplitudes));
+
+fwd_skill!(LrnAttractorAdapter, crate::lrn_anomaly_attractor::AttractorDetector,
+    "lrn_anomaly_attractor",
+    [ev::ATTRACTOR_TYPE, ev::LYAPUNOV_EXPONENT, ev::BASIN_DEPARTURE, ev::LEARNING_COMPLETE],
+    |d, f| d.process_frame(f.phases, f.amplitudes, f.motion_energy));
+
+fwd_skill!(LrnDtwAdapter, crate::lrn_dtw_gesture_learn::GestureLearner,
+    "lrn_dtw_gesture_learn",
+    [ev::GESTURE_LEARNED, ev::GESTURE_MATCHED, ev::LRN_MATCH_DISTANCE, ev::TEMPLATE_COUNT],
+    |d, f| d.process_frame(f.phases, f.motion_energy));
+
+fwd_skill!(LrnEwcAdapter, crate::lrn_ewc_lifelong::EwcLifelong,
+    "lrn_ewc_lifelong",
+    [ev::KNOWLEDGE_RETAINED, ev::NEW_TASK_LEARNED, ev::FISHER_UPDATE, ev::FORGETTING_RISK],
+    |d, f| d.process_frame(f.variances, f.presence));
+
+fwd_skill!(OccupancyAdapter, crate::occupancy::OccupancyDetector,
+    "occupancy",
+    [ev::ZONE_OCCUPIED, ev::ZONE_COUNT, ev::ZONE_TRANSITION],
+    |d, f| d.process_frame(f.phases, f.amplitudes));
+
+fwd_skill!(QntInterferenceAdapter, crate::qnt_interference_search::InterferenceSearch,
+    "qnt_interference_search",
+    [ev::HYPOTHESIS_WINNER, ev::HYPOTHESIS_AMPLITUDE, ev::SEARCH_ITERATIONS],
+    |d, f| d.process_frame(f.presence, f.motion_energy, f.n_persons));
+
+fwd_skill!(QntCoherenceAdapter, crate::qnt_quantum_coherence::QuantumCoherenceMonitor,
+    "qnt_quantum_coherence",
+    [ev::ENTANGLEMENT_ENTROPY, ev::DECOHERENCE_EVENT, ev::BLOCH_DRIFT],
+    |d, f| d.process_frame(f.phases));
+
+fwd_skill!(RetFlowAdapter, crate::ret_customer_flow::CustomerFlowTracker,
+    "ret_customer_flow",
+    [ev::INGRESS, ev::EGRESS, ev::NET_OCCUPANCY, ev::HOURLY_TRAFFIC],
+    |d, f| d.process_frame(f.phases, f.amplitudes, f.variance_mean, f.motion_energy));
+
+fwd_skill!(RetDwellAdapter, crate::ret_dwell_heatmap::DwellHeatmapTracker,
+    "ret_dwell_heatmap",
+    [ev::DWELL_ZONE_UPDATE, ev::HOT_ZONE, ev::COLD_ZONE, ev::SESSION_SUMMARY],
+    |d, f| d.process_frame(f.presence, f.variances, f.motion_energy, f.n_persons));
+
+fwd_skill!(RetQueueAdapter, crate::ret_queue_length::QueueLengthEstimator,
+    "ret_queue_length",
+    [ev::QUEUE_LENGTH, ev::WAIT_TIME_ESTIMATE, ev::SERVICE_RATE, ev::QUEUE_ALERT],
+    |d, f| d.process_frame(f.presence, f.n_persons, f.variance_mean, f.motion_energy));
+
+fwd_skill!(RetShelfAdapter, crate::ret_shelf_engagement::ShelfEngagementDetector,
+    "ret_shelf_engagement",
+    [ev::SHELF_BROWSE, ev::SHELF_CONSIDER, ev::SHELF_ENGAGE, ev::REACH_DETECTED],
+    |d, f| d.process_frame(f.presence, f.motion_energy, f.variance_mean, f.phases));
+
+fwd_skill!(RetTableAdapter, crate::ret_table_turnover::TableTurnoverTracker,
+    "ret_table_turnover",
+    [ev::TABLE_SEATED, ev::TABLE_VACATED, ev::TABLE_AVAILABLE, ev::TURNOVER_RATE],
+    |d, f| d.process_frame(f.presence, f.motion_energy, f.n_persons));
+
+fwd_skill!(SecLoiteringAdapter, crate::sec_loitering::LoiteringDetector,
+    "sec_loitering",
+    [ev::LOITERING_START, ev::LOITERING_ONGOING, ev::LOITERING_END],
+    |d, f| d.process_frame(f.presence, f.motion_energy));
+
+fwd_skill!(SecPanicAdapter, crate::sec_panic_motion::PanicMotionDetector,
+    "sec_panic_motion",
+    [ev::PANIC_DETECTED, ev::STRUGGLE_PATTERN, ev::FLEEING_DETECTED],
+    |d, f| d.process_frame(f.motion_energy, f.variance_mean, f.phase_mean(), f.presence));
+
+fwd_skill!(SecPerimeterAdapter, crate::sec_perimeter_breach::PerimeterBreachDetector,
+    "sec_perimeter_breach",
+    [ev::PERIMETER_BREACH, ev::APPROACH_DETECTED, ev::DEPARTURE_DETECTED, ev::SEC_ZONE_TRANSITION],
+    |d, f| d.process_frame(f.phases, f.amplitudes, f.variances, f.motion_energy));
+
+fwd_skill!(SecTailgateAdapter, crate::sec_tailgating::TailgateDetector,
+    "sec_tailgating",
+    [ev::TAILGATE_DETECTED, ev::SINGLE_PASSAGE, ev::MULTI_PASSAGE],
+    |d, f| d.process_frame(f.motion_energy, f.presence, f.n_persons, f.variance_mean));
+
+fwd_skill!(SecWeaponAdapter, crate::sec_weapon_detect::WeaponDetector,
+    "sec_weapon_detect",
+    [ev::METAL_ANOMALY, ev::HIGH_METAL_REFLECTIVITY, ev::CALIBRATION_NEEDED],
+    |d, f| d.process_frame(f.phases, f.amplitudes, f.variances, f.motion_energy, f.presence));
+
+fwd_skill!(SigCoherenceGateAdapter, crate::sig_coherence_gate::CoherenceGate,
+    "sig_coherence_gate",
+    [ev::GATE_DECISION, ev::SIG_COHERENCE_SCORE, ev::RECALIBRATE_NEEDED],
+    |d, f| d.process_frame(f.phases));
+
+fwd_skill!(SigFlashAttnAdapter, crate::sig_flash_attention::FlashAttention,
+    "sig_flash_attention",
+    [ev::ATTENTION_PEAK_SC, ev::ATTENTION_SPREAD, ev::SPATIAL_FOCUS_ZONE],
+    |d, f| d.process_frame(f.phases, f.amplitudes));
+
+fwd_skill!(SigMincutAdapter, crate::sig_mincut_person_match::PersonMatcher,
+    "sig_mincut_person_match",
+    [ev::PERSON_ID_ASSIGNED, ev::PERSON_ID_SWAP, ev::MATCH_CONFIDENCE],
+    |d, f| d.process_frame(f.amplitudes, f.variances, f.n_persons.max(0) as usize));
+
+fwd_skill!(SigTransportAdapter, crate::sig_optimal_transport::OptimalTransportDetector,
+    "sig_optimal_transport",
+    [ev::WASSERSTEIN_DISTANCE, ev::DISTRIBUTION_SHIFT, ev::SUBTLE_MOTION],
+    |d, f| d.process_frame(f.amplitudes));
+
+fwd_skill!(SptHnswAdapter, crate::spt_micro_hnsw::MicroHnsw,
+    "spt_micro_hnsw",
+    [ev::NEAREST_MATCH_ID, ev::HNSW_MATCH_DISTANCE, ev::CLASSIFICATION, ev::LIBRARY_SIZE],
+    |d, f| d.process_frame(f.variances));
+
+fwd_skill!(SptPagerankAdapter, crate::spt_pagerank_influence::PageRankInfluence,
+    "spt_pagerank_influence",
+    [ev::DOMINANT_PERSON, ev::INFLUENCE_SCORE, ev::INFLUENCE_CHANGE],
+    |d, f| d.process_frame(f.phases, f.n_persons.max(0) as usize));
+
+fwd_skill!(SptSpikingAdapter, crate::spt_spiking_tracker::SpikingTracker,
+    "spt_spiking_tracker",
+    [ev::TRACK_UPDATE, ev::TRACK_VELOCITY, ev::SPIKE_RATE, ev::TRACK_LOST],
+    |d, f| d.process_frame(f.phases, f.prev_phases));
+
+fwd_skill!(TmpLogicGuardAdapter, crate::tmp_temporal_logic_guard::TemporalLogicGuard,
+    "tmp_temporal_logic_guard",
+    [ev::LTL_VIOLATION, ev::LTL_SATISFACTION, ev::COUNTEREXAMPLE],
+    |d, f| {
+        let input = crate::tmp_temporal_logic_guard::FrameInput {
+            presence: f.presence,
+            n_persons: f.n_persons,
+            motion_energy: f.motion_energy,
+            coherence: f.coherence,
+            breathing_bpm: f.breathing_bpm,
+            heartrate_bpm: f.heartrate_bpm,
+            fall_alert: false,
+            intrusion_alert: false,
+            person_id_active: f.n_persons > 0,
+            vital_signs_active: f.breathing_bpm > 0.0,
+            seizure_detected: false,
+            normal_gait: true,
+        };
+        d.on_frame(&input)
+    });
+
+// ── Timer-driven skills (driven once per frame) ──────────────────────────────
+
+fwd_skill!(VitalTrendAdapter, crate::vital_trend::VitalTrendAnalyzer,
+    "vital_trend",
+    // 101-105 = brady/tachypnea, brady/tachycardia, apnea; 110/111 = breathing/heartrate
+    // moving averages (module-local EVENT_BREATHING_AVG / EVENT_HEARTRATE_AVG).
+    [ev::BRADYPNEA, ev::TACHYPNEA, ev::BRADYCARDIA, ev::TACHYCARDIA, ev::APNEA, 110, 111],
+    |d, f| d.on_timer(f.breathing_bpm, f.heartrate_bpm));
+
+fwd_skill!(LrnMetaAdapter, crate::lrn_meta_adapt::MetaAdapter,
+    "lrn_meta_adapt",
+    [ev::PARAM_ADJUSTED, ev::ADAPTATION_SCORE, ev::ROLLBACK_TRIGGERED, ev::META_LEVEL],
+    |d, _f| d.on_timer());
+
+fwd_skill!(SigTemporalCompressAdapter, crate::sig_temporal_compress::TemporalCompressor,
+    "sig_temporal_compress",
+    [ev::COMPRESSION_RATIO, ev::TIER_TRANSITION, ev::HISTORY_DEPTH_HOURS],
+    |d, _f| d.on_timer());
+
+fwd_skill!(TmpGoapAdapter, crate::tmp_goap_autonomy::GoapPlanner,
+    "tmp_goap_autonomy",
+    [ev::GOAL_SELECTED, ev::MODULE_ACTIVATED, ev::MODULE_DEACTIVATED, ev::PLAN_COST],
+    |d, _f| d.on_timer());
+
+// tmp_pattern_sequence: accumulate via on_frame, then drive on_timer per frame.
+pub struct TmpPatternAdapter(crate::tmp_pattern_sequence::PatternSequenceAnalyzer);
+impl TmpPatternAdapter {
+    pub fn new() -> Self {
+        Self(crate::tmp_pattern_sequence::PatternSequenceAnalyzer::new())
+    }
+}
+impl EdgeSkill for TmpPatternAdapter {
+    fn name(&self) -> &'static str {
+        "tmp_pattern_sequence"
+    }
+    fn event_ids(&self) -> &'static [i32] {
+        &[ev::PATTERN_DETECTED, ev::PATTERN_CONFIDENCE, ev::ROUTINE_DEVIATION, ev::PREDICTION_NEXT]
+    }
+    fn on_frame(&mut self, f: &CsiFrameView) -> &[(i32, f32)] {
+        self.0.on_frame(f.presence, f.motion_energy, f.n_persons);
+        self.0.on_timer()
+    }
+}
+
+// ── Medical tier (gated) ─────────────────────────────────────────────────────
+
+#[cfg(feature = "medical-experimental")]
+mod medical {
+    use super::*;
+
+    // Medical event ids verified against each module's local consts (100-199 block).
+    fwd_skill!(MedCardiacAdapter, crate::med_cardiac_arrhythmia::CardiacArrhythmiaDetector,
+        "med_cardiac_arrhythmia",
+        [110, 111, 112, 113],
+        |d, f| d.process_frame(f.heartrate_bpm, f.phase_mean()));
+
+    fwd_skill!(MedGaitAdapter, crate::med_gait_analysis::GaitAnalyzer,
+        "med_gait_analysis",
+        [130, 131, 132, 133, 134],
+        |d, f| d.process_frame(f.phase_mean(), f.amplitude_mean(), f.variance_mean, f.motion_energy));
+
+    fwd_skill!(MedRespiratoryAdapter, crate::med_respiratory_distress::RespiratoryDistressDetector,
+        "med_respiratory_distress",
+        [120, 121, 122, 123],
+        |d, f| d.process_frame(f.breathing_bpm, f.phase_mean(), f.variance_mean));
+
+    fwd_skill!(MedSeizureAdapter, crate::med_seizure_detect::SeizureDetector,
+        "med_seizure_detect",
+        [140, 141, 142, 143],
+        |d, f| d.process_frame(f.phase_mean(), f.amplitude_mean(), f.motion_energy, f.presence));
+
+    fwd_skill!(MedApneaAdapter, crate::med_sleep_apnea::SleepApneaDetector,
+        "med_sleep_apnea",
+        [100, 101, 102],
+        |d, f| d.process_frame(f.breathing_bpm, f.presence, f.variance_mean));
+
+    pub fn register(skills: &mut Vec<Box<dyn EdgeSkill>>, med: &mut Vec<bool>) {
+        macro_rules! push {
+            ($a:ty) => {{
+                skills.push(Box::new(<$a>::new()));
+                med.push(true);
+            }};
+        }
+        push!(MedSeizureAdapter);
+        push!(MedCardiacAdapter);
+        push!(MedRespiratoryAdapter);
+        push!(MedApneaAdapter);
+        push!(MedGaitAdapter);
+    }
+}
+
+// ── Registration ─────────────────────────────────────────────────────────────
+
+/// Register every default-tier (non-medical) skill.
+pub fn register_default(skills: &mut Vec<Box<dyn EdgeSkill>>, med: &mut Vec<bool>) {
+    macro_rules! push {
+        ($a:ty) => {{
+            skills.push(Box::new(<$a>::new()));
+            med.push(false);
+        }};
+    }
+
+    // Flagship + synthesized
+    push!(GestureAdapter);
+    push!(CoherenceAdapter);
+    push!(AdversarialAdapter);
+    push!(OccupancyAdapter);
+    push!(IntrusionAdapter);
+    push!(VitalTrendAdapter);
+
+    // Security
+    push!(SecPerimeterAdapter);
+    push!(SecWeaponAdapter);
+    push!(SecTailgateAdapter);
+    push!(SecLoiteringAdapter);
+    push!(SecPanicAdapter);
+
+    // Smart building
+    push!(BldHvacAdapter);
+    push!(BldLightingAdapter);
+    push!(BldElevatorAdapter);
+    push!(BldMeetingAdapter);
+    push!(BldEnergyAdapter);
+
+    // Retail
+    push!(RetQueueAdapter);
+    push!(RetDwellAdapter);
+    push!(RetFlowAdapter);
+    push!(RetTableAdapter);
+    push!(RetShelfAdapter);
+
+    // Industrial
+    push!(IndForkliftAdapter);
+    push!(IndConfinedAdapter);
+    push!(IndCleanRoomAdapter);
+    push!(IndLivestockAdapter);
+    push!(IndVibrationAdapter);
+
+    // Exotic / research
+    push!(ExoTimeCrystalAdapter);
+    push!(ExoHyperbolicAdapter);
+    push!(ExoDreamAdapter);
+    push!(ExoEmotionAdapter);
+    push!(ExoGestureLangAdapter);
+    push!(ExoMusicAdapter);
+    push!(ExoPlantAdapter);
+    push!(ExoGhostAdapter);
+    push!(ExoRainAdapter);
+    push!(ExoBreathingSyncAdapter);
+    push!(ExoHappinessAdapter);
+
+    // Signal intelligence
+    push!(SigCoherenceGateAdapter);
+    push!(SigFlashAttnAdapter);
+    push!(SigTemporalCompressAdapter);
+    push!(SparseRecoveryAdapter);
+    push!(SigMincutAdapter);
+    push!(SigTransportAdapter);
+
+    // Adaptive learning
+    push!(LrnDtwAdapter);
+    push!(LrnAttractorAdapter);
+    push!(LrnMetaAdapter);
+    push!(LrnEwcAdapter);
+
+    // Spatial reasoning
+    push!(SptPagerankAdapter);
+    push!(SptHnswAdapter);
+    push!(SptSpikingAdapter);
+
+    // Temporal analysis
+    push!(TmpPatternAdapter);
+    push!(TmpLogicGuardAdapter);
+    push!(TmpGoapAdapter);
+
+    // AI security
+    push!(AisPromptShieldAdapter);
+    push!(AisBehavioralAdapter);
+
+    // Quantum-inspired
+    push!(QntCoherenceAdapter);
+    push!(QntInterferenceAdapter);
+
+    // Autonomous systems
+    push!(AutPsychoAdapter);
+    push!(AutMeshAdapter);
+
+    let _ = (skills.len(), med.len());
+}
+
+/// Register the gated `medical-experimental` tier (5 `med_*` skills).
+#[cfg(feature = "medical-experimental")]
+pub fn register_medical(skills: &mut Vec<Box<dyn EdgeSkill>>, med: &mut Vec<bool>) {
+    medical::register(skills, med);
+}
diff --git a/v2/crates/wifi-densepose-wasm-edge/tests/pipeline_all.rs b/v2/crates/wifi-densepose-wasm-edge/tests/pipeline_all.rs
new file mode 100644
index 00000000..8e0c26ec
--- /dev/null
+++ b/v2/crates/wifi-densepose-wasm-edge/tests/pipeline_all.rs
@@ -0,0 +1,208 @@
+//! Integration test for the unified [`EdgePipeline`] (ADR-160 deliverable 1).
+//!
+//! Proves that EVERY registered skill executes over a deterministic synthetic
+//! CSI frame sequence without panicking, that the aggregated event stream is
+//! well-formed (each event tagged with a known skill name + a declared event
+//! id), and pins the registered-skill count (default vs +medical-experimental).
+//!
+//! Run:
+//!   cargo test --features std --test pipeline_all
+//!   cargo test --features std,medical-experimental --test pipeline_all
+//!
+//! [`EdgePipeline`]: wifi_densepose_wasm_edge::pipeline_all::EdgePipeline
+
+#![cfg(feature = "std")]
+
+use wifi_densepose_wasm_edge::pipeline_all::{CsiFrameView, EdgePipeline};
+
+const N_SC: usize = 32;
+
+/// Deterministic synthetic frame: a moving breathing/heartbeat target plus
+/// structured per-subcarrier phase/amplitude. No randomness — fully reproducible.
+fn synth_frame(t: usize, phases: &mut [f32], amps: &mut [f32], vars: &mut [f32]) {
+    let tf = t as f32;
+    // 0.3 Hz breathing modulation @ 20 Hz frame rate -> period ~66 frames.
+    let breath = (tf * 2.0 * core::f32::consts::PI * 0.3 / 20.0).sin();
+    // 1.2 Hz heartbeat.
+    let heart = (tf * 2.0 * core::f32::consts::PI * 1.2 / 20.0).sin();
+    for i in 0..phases.len() {
+        let sc = i as f32;
+        phases[i] = (sc * 0.21 + tf * 0.05).sin() + 0.15 * breath;
+        amps[i] = 1.0 + 0.3 * (sc * 0.11 + tf * 0.03).cos() + 0.1 * heart;
+        // motion-correlated variance, with one occasionally-hot zone.
+        vars[i] = 0.02 + 0.01 * (sc * 0.3).sin().abs() + if (t / 40) % 2 == 0 { 0.05 } else { 0.0 };
+    }
+}
+
+/// Build a view over the supplied buffers for frame `t`.
+fn view<'a>(
+    t: usize,
+    phases: &'a [f32],
+    amps: &'a [f32],
+    vars: &'a [f32],
+    prev_phases: &'a [f32],
+) -> CsiFrameView<'a> {
+    let tf = t as f32;
+    let motion = 0.3 + 0.2 * (tf * 0.07).sin().abs();
+    let mut vmean = 0.0f32;
+    for &v in vars {
+        vmean += v;
+    }
+    vmean /= vars.len().max(1) as f32;
+    CsiFrameView {
+        phases,
+        amplitudes: amps,
+        variances: vars,
+        prev_phases,
+        presence: if (t / 30) % 3 == 0 { 0 } else { 1 },
+        n_persons: ((t / 50) % 3) as i32,
+        motion_energy: motion,
+        breathing_bpm: 18.0 + 2.0 * (tf * 0.01).sin(),
+        heartrate_bpm: 72.0 + 5.0 * (tf * 0.02).sin(),
+        coherence: 0.5 + 0.4 * (tf * 0.03).cos(),
+        variance_mean: vmean,
+    }
+}
+
+#[test]
+fn all_skills_execute_without_panic_over_synthetic_stream() {
+    let mut pipeline = EdgePipeline::new();
+    let n_skills = pipeline.skill_count();
+    assert!(n_skills > 0, "pipeline must register skills");
+
+    let mut phases = [0.0f32; N_SC];
+    let mut amps = [0.0f32; N_SC];
+    let mut vars = [0.0f32; N_SC];
+    let mut prev_phases = [0.0f32; N_SC];
+
+    let known: std::collections::HashSet<&'static str> =
+        pipeline.skills().iter().map(|s| s.name).collect();
+
+    // Feed 300 frames (15 s @ 20 Hz) — enough for calibration windows, DTW
+    // enrollment, periodicity buffers, and timer cadences to fire.
+    let mut total_events = 0usize;
+    for t in 0..300 {
+        synth_frame(t, &mut phases, &mut amps, &mut vars);
+        let v = view(t, &phases, &amps, &vars, &prev_phases);
+        let events = pipeline.on_frame(&v);
+        for e in &events {
+            // Every event must be tagged with a registered skill name.
+            assert!(known.contains(e.skill), "unknown skill tag: {}", e.skill);
+            // Value must be finite (no NaN/Inf leaking from the DSP).
+            assert!(e.value.is_finite(), "non-finite value from {}", e.skill);
+        }
+        total_events += events.len();
+        prev_phases.copy_from_slice(&phases);
+    }
+
+    assert_eq!(pipeline.frame_count(), 300);
+    // A real run over 300 frames must emit *some* events across 59+ skills.
+    assert!(
+        total_events > 0,
+        "expected the skill library to emit events over 300 frames, got 0"
+    );
+    println!(
+        "pipeline: {} skills, {} aggregated events over 300 synthetic frames",
+        n_skills, total_events
+    );
+}
+
+#[test]
+fn every_emitted_event_id_is_declared_by_its_skill() {
+    // Stronger well-formedness: each event's id must be one the producing skill
+    // declared in its `event_ids()` introspection list.
+    let mut pipeline = EdgePipeline::new();
+
+    // skill name -> its declared event id set
+    let mut declared: std::collections::HashMap<&'static str, std::collections::HashSet<i32>> =
+        std::collections::HashMap::new();
+    for s in pipeline.skills() {
+        declared.insert(s.name, s.event_ids.iter().copied().collect());
+    }
+
+    let mut phases = [0.0f32; N_SC];
+    let mut amps = [0.0f32; N_SC];
+    let mut vars = [0.0f32; N_SC];
+    let mut prev_phases = [0.0f32; N_SC];
+
+    for t in 0..300 {
+        synth_frame(t, &mut phases, &mut amps, &mut vars);
+        let v = view(t, &phases, &amps, &vars, &prev_phases);
+        for e in &pipeline.on_frame(&v) {
+            let set = declared.get(e.skill).expect("skill declared");
+            assert!(
+                set.contains(&e.event_id),
+                "{} emitted undeclared event id {}",
+                e.skill,
+                e.event_id
+            );
+        }
+        prev_phases.copy_from_slice(&phases);
+    }
+}
+
+#[test]
+fn introspection_lists_every_skill_with_event_ids() {
+    let pipeline = EdgePipeline::new();
+    let infos = pipeline.skills();
+    assert_eq!(infos.len(), pipeline.skill_count());
+    for info in &infos {
+        assert!(!info.name.is_empty());
+        assert!(
+            !info.event_ids.is_empty(),
+            "skill {} declares no event ids",
+            info.name
+        );
+    }
+    // No duplicate skill names.
+    let names: std::collections::HashSet<_> = infos.iter().map(|i| i.name).collect();
+    assert_eq!(names.len(), infos.len(), "duplicate skill registration");
+}
+
+#[cfg(not(feature = "medical-experimental"))]
+#[test]
+fn default_tier_count_excludes_medical() {
+    let pipeline = EdgePipeline::new();
+    assert_eq!(
+        pipeline.skill_count(),
+        59,
+        "default (non-medical) tier must register exactly 59 skills"
+    );
+    // The ADR-160 safety gate: no med_* skill is present in the default build.
+    for info in pipeline.skills() {
+        assert!(
+            !info.medical_experimental,
+            "medical skill {} leaked into default tier",
+            info.name
+        );
+        assert!(
+            !info.name.starts_with("med_"),
+            "med_* skill {} present without the medical-experimental feature",
+            info.name
+        );
+    }
+}
+
+#[cfg(feature = "medical-experimental")]
+#[test]
+fn medical_tier_adds_five_skills() {
+    let pipeline = EdgePipeline::new();
+    assert_eq!(
+        pipeline.skill_count(),
+        64,
+        "default 59 + 5 medical = 64 skills"
+    );
+    let med: Vec<_> = pipeline
+        .skills()
+        .into_iter()
+        .filter(|s| s.medical_experimental)
+        .collect();
+    assert_eq!(med.len(), 5, "exactly 5 medical-experimental skills");
+    for m in &med {
+        assert!(
+            m.name.starts_with("med_"),
+            "medical-flagged skill has non-med_ name: {}",
+            m.name
+        );
+    }
+}