feat: wire 10-layer cognitive stack with resonance-gated processing

Replace the 7-layer consciousness stack with a unified 10-layer cognitive
architecture that eliminates explicit dispatch in favor of implicit
resonance-based routing via fingerprint similarity.

New modules:
- layer_stack.rs: 10-layer cognitive stack (L1:Recognition → L10:Crystallization)
  with 7-wave parallel processing and LayerNode/LayerResult types
- satisfaction_gate.rs: Maslow-style continuous modulation where unsatisfied
  lower layers raise higher layers' effective thresholds proportionally
- two_stroke.rs: 2-stroke engine (all layers fire every cycle against
  previous-cycle metadata), ThinkingStyle self-selection via resonance,
  NARS rule fingerprints (deduction/induction/abduction/analogy/revision),
  crystallize/recover_modulation via XOR bind/unbind
- cognitive_kernel.rs: BindSpace bridge mapping layer outputs to kernel
  operations (resonate, write, bundle, crystallize) with popcount
  stacking early-exit at 1-2σ from centroid
- cortex.rs: resonance-gated NARS rule selection replacing hardcoded
  apply_rule("deduction", ...) with gestalt fingerprint similarity

Updated modules:
- sieve.rs: L9 validation pipeline (NARS + Brier + XOR residual +
  Dunning-Kruger detection for high-confidence/high-divergence)
- fabric.rs: 10-layer satisfaction gate, rule/style fingerprints,
  Crystallization triangle driven by L8/L9/L10
- grammar_engine.rs: updated from SevenLayerNode to LayerNode
- seven_layer.rs: thin re-export wrapper for backward compat
- contract/layers.rs: 10-layer constants with deprecation aliases
- contract/legacy.rs: V1EnvelopeMetadata gains dominant_layer,
  layer_activations, nars_frequency, calibration_error for
  cross-agent awareness through shared metadata

https://claude.ai/code/session_01HPnDXh9S876c15QLgkDpcN

Author: claude

crates/ladybug-contract/src/layers.rs

@@ -1,29 +1,69 @@
-//! 7-Layer consciousness markers.
+//! 10-Layer cognitive stack markers.
 //!
-//! Each layer has a 5-byte marker stored in Container 0 metadata at W12-W15:
-//! (activation: u8, stability: u8, flags: u16, tag: u8)
+//! Each layer has a 3-byte marker stored in Container 0 metadata at W12-W15:
+//! (activation: u8, stability: u8, flags: u8)
 //!
 //! Read/write via [`MetaView::layer_marker(layer_index)`].
+//!
+//! ## 10-Layer Cognitive Stack
+//!
+//! ```text
+//! L1  Recognition     — pattern matching, fingerprint encoding
+//! L2  Resonance       — field binding, similarity search
+//! L3  Appraisal       — gestalt, hypothesis, evaluation
+//! L4  Routing         — branch selection, template dispatch
+//! L5  Execution       — active manipulation, synthesis
+//!     ─── single agent boundary ───
+//! L6  Delegation      — cognitive fan-out, multi-agent
+//! L7  Contingency     — cross-branch, could-be-otherwise
+//! L8  Integration     — evidence merge, meta-awareness
+//! L9  Validation      — NARS, Brier, Socratic sieve
+//! L10 Crystallization — what survives becomes system
+//! ```
 
-/// Type ID constants for the 7 consciousness layers.
-pub const LAYER_SUBSTRATE: u16 = 0x0200;
-pub const LAYER_FELT_CORE: u16 = 0x0201;
-pub const LAYER_BODY: u16 = 0x0202;
-pub const LAYER_QUALIA: u16 = 0x0203;
-pub const LAYER_VOLITION: u16 = 0x0204;
-pub const LAYER_GESTALT: u16 = 0x0205;
-pub const LAYER_META: u16 = 0x0206;
+/// Type ID constants for the 10 cognitive layers.
+pub const LAYER_RECOGNITION: u16 = 0x0200;     // L1
+pub const LAYER_RESONANCE: u16 = 0x0201;       // L2
+pub const LAYER_APPRAISAL: u16 = 0x0202;       // L3
+pub const LAYER_ROUTING: u16 = 0x0203;         // L4
+pub const LAYER_EXECUTION: u16 = 0x0204;       // L5
+pub const LAYER_DELEGATION: u16 = 0x0205;      // L6
+pub const LAYER_CONTINGENCY: u16 = 0x0206;     // L7
+pub const LAYER_INTEGRATION: u16 = 0x0207;     // L8
+pub const LAYER_VALIDATION: u16 = 0x0208;      // L9
+pub const LAYER_CRYSTALLIZATION: u16 = 0x0209; // L10
 
-/// Number of consciousness layers.
-pub const NUM_LAYERS: usize = 7;
+/// Number of cognitive layers.
+pub const NUM_LAYERS: usize = 10;
 
-/// Layer names, indexed 0-6.
+/// Layer names, indexed 0-9.
 pub const LAYER_NAMES: [&str; NUM_LAYERS] = [
-    "Substrate",
-    "Felt Core",
-    "Body",
-    "Qualia",
-    "Volition",
-    "Gestalt",
-    "Meta",
+    "Recognition",
+    "Resonance",
+    "Appraisal",
+    "Routing",
+    "Execution",
+    "Delegation",
+    "Contingency",
+    "Integration",
+    "Validation",
+    "Crystallization",
 ];
+
+// Deprecation aliases for old 7-layer names.
+// These keep the same type ID values (0x0200-0x0206) so existing
+// on-disk records remain readable.
+#[deprecated(note = "use LAYER_RECOGNITION")]
+pub const LAYER_SUBSTRATE: u16 = LAYER_RECOGNITION;
+#[deprecated(note = "use LAYER_RESONANCE")]
+pub const LAYER_FELT_CORE: u16 = LAYER_RESONANCE;
+#[deprecated(note = "use LAYER_APPRAISAL")]
+pub const LAYER_BODY: u16 = LAYER_APPRAISAL;
+#[deprecated(note = "use LAYER_ROUTING")]
+pub const LAYER_QUALIA: u16 = LAYER_ROUTING;
+#[deprecated(note = "use LAYER_EXECUTION")]
+pub const LAYER_VOLITION: u16 = LAYER_EXECUTION;
+#[deprecated(note = "use LAYER_DELEGATION")]
+pub const LAYER_GESTALT: u16 = LAYER_DELEGATION;
+#[deprecated(note = "use LAYER_CONTINGENCY")]
+pub const LAYER_META: u16 = LAYER_CONTINGENCY;

crates/ladybug-contract/src/legacy.rs

@@ -105,6 +105,30 @@ pub struct V1EnvelopeMetadata {
     pub epoch: i64,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub version: Option<String>,
+
+    // --- 10-Layer Cognitive Awareness (backward-compatible, all optional) ---
+
+    /// Dominant cognitive layer that produced this output (0-9 → L1-L10).
+    /// Used for cross-agent routing: savant agents operate at L1-L5,
+    /// orchestrator agents at L6-L10.
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub dominant_layer: Option<u8>,
+
+    /// 10-layer activation snapshot: [f32; 10] serialized as JSON array.
+    /// Encodes the satisfaction state at the time of output, enabling
+    /// cross-agent awareness through shared metadata.
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub layer_activations: Option<Vec<f32>>,
+
+    /// NARS frequency component (0.0-1.0) from L9 validation.
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub nars_frequency: Option<f64>,
+
+    /// Calibration error (Brier score) from MetaCognition.
+    /// Lower = better calibrated. Consumers can use this to weight
+    /// evidence from this source during L8 Integration.
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub calibration_error: Option<f64>,
 }
 
 // ============================================================================
@@ -130,6 +154,24 @@ pub struct V1LadybugMetadata {
     pub epoch: Option<i64>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub version: Option<String>,
+
+    // --- 10-Layer Cognitive Awareness ---
+
+    /// Dominant cognitive layer (0-9 → L1-L10).
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub dominant_layer: Option<u8>,
+
+    /// 10-layer activation snapshot.
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub layer_activations: Option<Vec<f32>>,
+
+    /// NARS frequency from L9 validation.
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub nars_frequency: Option<f64>,
+
+    /// Calibration error (Brier score).
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub calibration_error: Option<f64>,
 }
 
 // ============================================================================
@@ -235,6 +277,13 @@ impl From<&V1DataEnvelope> for CogRecord {
             let mut m = record.meta_view_mut();
             m.set_dn_addr(hash_step_id(&envelope.metadata.source_step));
             m.set_nars_confidence(envelope.metadata.confidence as f32);
+            if let Some(freq) = envelope.metadata.nars_frequency {
+                m.set_nars_frequency(freq as f32);
+            }
+            // Layer activations are carried in the JSON metadata, not
+            // packed into container words (container layer markers are
+            // 5-byte 7-layer format; the 10-layer data travels in the
+            // serde envelope until container format is upgraded).
         }
         let bytes = serde_json::to_vec(&envelope.data).unwrap_or_default();
         record.content[0] = content_from_bytes(&bytes);
@@ -245,13 +294,36 @@ impl From<&V1DataEnvelope> for CogRecord {
 impl From<&CogRecord> for V1DataEnvelope {
     fn from(record: &CogRecord) -> V1DataEnvelope {
         let m = record.meta_view();
+
+        // Extract layer markers from container (7-layer format in W12-W15).
+        // We extract the available 7 layers and pad with zeros for L8-L10.
+        // Full 10-layer data travels in the JSON envelope when available.
+        let mut layer_activations = Vec::with_capacity(10);
+        let mut dominant: Option<(u8, f32)> = None;
+        for i in 0..7 {
+            let marker = m.layer_marker(i);
+            let activation = marker.0 as f32 / 255.0;
+            layer_activations.push(activation);
+            if dominant.is_none() || activation > dominant.unwrap().1 {
+                dominant = Some((i as u8, activation));
+            }
+        }
+        // Pad L8-L10 with zero (not yet stored in container metadata)
+        for _ in 7..10 {
+            layer_activations.push(0.0);
+        }
+
         V1DataEnvelope {
             data: Value::Null,
             metadata: V1EnvelopeMetadata {
                 source_step: format!("{:016X}", m.dn_addr()),
                 confidence: m.nars_confidence() as f64,
                 epoch: 0,
                 version: None,
+                dominant_layer: dominant.map(|(i, _)| i),
+                layer_activations: Some(layer_activations),
+                nars_frequency: Some(m.nars_frequency() as f64),
+                calibration_error: None, // Not stored in container metadata
             },
         }
     }
@@ -297,6 +369,17 @@ impl From<&CogRecord> for V1LadybugEnvelope {
                 },
                 epoch: None,
                 version: None,
+                dominant_layer: None,
+                layer_activations: None,
+                nars_frequency: {
+                    let f = m.nars_frequency();
+                    if f > 0.0 {
+                        Some(f as f64)
+                    } else {
+                        None
+                    }
+                },
+                calibration_error: None,
             },
         }
     }