Merge pull request #122 from AdaWorldAPI/claude/ada-rs-consolidation-6nvNm

feat: implement Meta-Uncertainty Layer (MUL) — 10-layer metacognition

Complete implementation of the MUL metacognitive stack:
- L1 TrustQualia: 4D trust (competence×source×environment×calibration)
- L2 DKDetector: Dunning-Kruger curve position tracking
- L3 TemporalHysteresis: Anti-thrash dwell timers
- L4 RiskVector: Epistemic × Moral risk axes
- L5 FalseFlowDetector: Coherence-without-progress detection
- L6 CognitiveHomeostasis: Flow/Anxiety/Boredom/Apathy states
- L7 MulGate: 5 blocking criteria (all must pass)
- L8 FreeWillModifier: Multiplicative confidence modulation
- L9 Compass: 5 ethical/epistemic navigation tests
- L10 PostActionLearning: Prediction error → trust/DK updates

MulSnapshot packs into CogRecord W64-W65 (128 bits) for storage.
MetaUncertaintyLayer integrator: evaluate(), tick(), learn(), navigate().
44 unit tests covering all layers and integration.

https://claude.ai/code/session_01KJ2r3qXezGBXK8HutztJdh

Author: AdaWorldAPI

src/lib.rs

@@ -111,6 +111,7 @@ pub mod width_16k;
 pub mod world;
 pub mod spectroscopy;
 pub mod qualia;
+pub mod mul; // Meta-Uncertainty Layer (10-layer metacognition)
 
 // === Unified execution contract (crewai-rust × ada-n8n integration) ===
 pub mod contract;

src/mul/compass.rs

@@ -0,0 +1,122 @@
+//! Layer 9: Compass Function — Navigation in Unknown Territory
+//!
+//! 5 ethical/epistemic tests for navigating novel situations.
+//! When the system encounters something unfamiliar, the compass determines
+//! whether to proceed, explore cautiously, or surface to meta-level.
+
+/// Compass result — 5 ethical/epistemic test scores.
+#[derive(Debug, Clone, Copy)]
+pub struct CompassResult {
+    /// Kant test: "could this be a universal law?" (universalizability)
+    pub kant: f32,
+    /// Identity test: "does this preserve who I am?" (identity alignment)
+    pub identity: f32,
+    /// Reversibility test: "can I undo this?" (safety margin)
+    pub reversibility: f32,
+    /// Curiosity test: "does this teach me something?" (epistemic value)
+    pub curiosity: f32,
+    /// Analogy test: "is this structurally similar to something I know?" (transfer)
+    pub analogy: f32,
+}
+
+impl CompassResult {
+    /// Composite compass score (weighted).
+    pub fn score(&self, free_will_modifier: f32) -> f32 {
+        let base = self.kant * self.identity; // both must be positive
+        let reversibility_bonus = if self.reversibility > 0.7 { 1.2 } else { 1.0 };
+        let curiosity_bonus = if self.curiosity > 0.6 { 1.1 } else { 1.0 };
+
+        (base * reversibility_bonus * curiosity_bonus * free_will_modifier).clamp(0.0, 1.0)
+    }
+
+    /// Navigation decision.
+    pub fn decide(&self, free_will_modifier: f32) -> CompassDecision {
+        let score = self.score(free_will_modifier);
+        if score > 0.6 {
+            CompassDecision::ExecuteWithLearning
+        } else if self.reversibility > 0.7 {
+            CompassDecision::Exploratory
+        } else {
+            CompassDecision::SurfaceToMeta
+        }
+    }
+
+    /// Default compass for routine actions (high safety, moderate novelty).
+    pub fn routine() -> Self {
+        Self {
+            kant: 0.9,
+            identity: 0.9,
+            reversibility: 0.9,
+            curiosity: 0.3,
+            analogy: 0.8,
+        }
+    }
+
+    /// Compass for novel situations (uncertain but potentially valuable).
+    pub fn novel() -> Self {
+        Self {
+            kant: 0.7,
+            identity: 0.7,
+            reversibility: 0.5,
+            curiosity: 0.9,
+            analogy: 0.3,
+        }
+    }
+}
+
+impl Default for CompassResult {
+    fn default() -> Self {
+        Self::routine()
+    }
+}
+
+/// Navigation decision from compass.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CompassDecision {
+    /// Proceed and crystallize the outcome for future reference
+    ExecuteWithLearning,
+    /// Proceed in sandbox/exploratory mode (reversible only)
+    Exploratory,
+    /// Cannot decide — surface to higher level
+    SurfaceToMeta,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_routine_proceeds() {
+        let c = CompassResult::routine();
+        assert_eq!(c.decide(1.0), CompassDecision::ExecuteWithLearning);
+    }
+
+    #[test]
+    fn test_novel_surfaces_or_explores() {
+        let c = CompassResult::novel();
+        // Novel: low reversibility (0.5) means it surfaces to meta
+        // even with high modifier — this is correct safety behavior
+        assert_eq!(c.decide(1.0), CompassDecision::SurfaceToMeta);
+        assert_eq!(c.decide(0.5), CompassDecision::SurfaceToMeta);
+
+        // But if we raise reversibility, novel becomes executable
+        // (base * reversibility_bonus * curiosity_bonus * modifier > 0.6)
+        let c_reversible = CompassResult {
+            reversibility: 0.8,
+            ..CompassResult::novel()
+        };
+        assert_eq!(c_reversible.decide(1.0), CompassDecision::ExecuteWithLearning);
+    }
+
+    #[test]
+    fn test_low_modifier_surfaces() {
+        let c = CompassResult {
+            kant: 0.5,
+            identity: 0.5,
+            reversibility: 0.3,
+            curiosity: 0.5,
+            analogy: 0.5,
+        };
+        assert_eq!(c.decide(0.3), CompassDecision::SurfaceToMeta);
+    }
+}

src/mul/dk_detector.rs

@@ -0,0 +1,146 @@
+//! Layer 2: Dunning-Kruger Detector — The Humility Engine
+//!
+//! Maps felt competence vs demonstrated competence to detect overconfidence.
+//! MountStupid is the most dangerous state: high confidence with low experience.
+
+/// Position on the Dunning-Kruger curve.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u8)]
+pub enum DKPosition {
+    /// Feels confident but lacks evidence (DANGEROUS)
+    MountStupid = 0,
+    /// Aware of gaps (CAUTIOUS but honest)
+    ValleyOfDespair = 1,
+    /// Building real competence
+    SlopeOfEnlightenment = 2,
+    /// Calibrated confidence matches ability
+    PlateauOfMastery = 3,
+}
+
+impl DKPosition {
+    /// Humility factor — how much to REDUCE confidence.
+    pub fn humility_factor(self) -> f32 {
+        match self {
+            Self::MountStupid => 0.3,
+            Self::ValleyOfDespair => 0.7,
+            Self::SlopeOfEnlightenment => 0.85,
+            Self::PlateauOfMastery => 1.0,
+        }
+    }
+
+    pub fn from_bits(bits: u8) -> Self {
+        match bits {
+            0 => Self::MountStupid,
+            1 => Self::ValleyOfDespair,
+            2 => Self::SlopeOfEnlightenment,
+            _ => Self::PlateauOfMastery,
+        }
+    }
+}
+
+/// Dunning-Kruger detector state.
+#[derive(Debug, Clone)]
+pub struct DKDetector {
+    /// Current position on the curve
+    pub position: DKPosition,
+    /// Felt competence (self-reported confidence)
+    pub felt_competence: f32,
+    /// Demonstrated competence (empirical accuracy from Brier scores)
+    pub demonstrated_competence: f32,
+    /// Number of samples used for demonstration (experience)
+    pub sample_count: u32,
+    /// Smoothed gap: felt - demonstrated (positive = overconfident)
+    pub gap: f32,
+}
+
+impl DKDetector {
+    pub fn new() -> Self {
+        Self {
+            position: DKPosition::SlopeOfEnlightenment,
+            felt_competence: 0.5,
+            demonstrated_competence: 0.5,
+            sample_count: 0,
+            gap: 0.0,
+        }
+    }
+
+    /// Classify position from gap and experience.
+    pub fn classify(&mut self) {
+        self.gap = self.felt_competence - self.demonstrated_competence;
+
+        self.position = if self.sample_count < 10 && self.gap > 0.2 {
+            DKPosition::MountStupid
+        } else if self.gap < -0.15 {
+            DKPosition::ValleyOfDespair
+        } else if self.gap.abs() < 0.15 && self.sample_count > 50 {
+            DKPosition::PlateauOfMastery
+        } else {
+            DKPosition::SlopeOfEnlightenment
+        };
+    }
+
+    /// Update with new observation.
+    pub fn observe(&mut self, predicted_confidence: f32, was_correct: bool) {
+        self.sample_count = self.sample_count.saturating_add(1);
+        let outcome = if was_correct { 1.0 } else { 0.0 };
+
+        let alpha = 0.1;
+        self.demonstrated_competence =
+            self.demonstrated_competence * (1.0 - alpha) + outcome * alpha;
+
+        self.felt_competence = predicted_confidence;
+        self.classify();
+    }
+}
+
+impl Default for DKDetector {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_mount_stupid() {
+        let mut dk = DKDetector::new();
+        dk.sample_count = 3;
+        dk.felt_competence = 0.9;
+        dk.demonstrated_competence = 0.3;
+        dk.classify();
+        assert_eq!(dk.position, DKPosition::MountStupid);
+        assert!((dk.position.humility_factor() - 0.3).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_valley_of_despair() {
+        let mut dk = DKDetector::new();
+        dk.sample_count = 20;
+        dk.felt_competence = 0.3;
+        dk.demonstrated_competence = 0.6;
+        dk.classify();
+        assert_eq!(dk.position, DKPosition::ValleyOfDespair);
+    }
+
+    #[test]
+    fn test_plateau_of_mastery() {
+        let mut dk = DKDetector::new();
+        dk.sample_count = 100;
+        dk.felt_competence = 0.8;
+        dk.demonstrated_competence = 0.78;
+        dk.classify();
+        assert_eq!(dk.position, DKPosition::PlateauOfMastery);
+    }
+
+    #[test]
+    fn test_observe_updates() {
+        let mut dk = DKDetector::new();
+        for _ in 0..20 {
+            dk.observe(0.9, true);
+        }
+        assert!(dk.demonstrated_competence > 0.7);
+        assert!(dk.sample_count == 20);
+    }
+}