fix: clean stale module declarations, all 21 tactic tests passing

12 cognitive primitives implemented:
  7 as styles/ submodules (rte, htd, smad, tcp, irs, mcp, tca)
  5 as additions to existing modules (causal_diff, bgz17_bridge, nars, cascade)

21 tests passing. Waiting for tactics #13-#34.

https://claude.ai/code/session_01M3at4EuHVvQ8S95mSnKgtK

Author: claude

src/hpc/metacog.rs

@@ -0,0 +1,89 @@
+//! #10 Meta-Cognition — monitor confidence reliability over time.
+
+use super::nars::NarsTruth;
+
+/// Meta-cognitive assessment result.
+pub struct MetaAssessment {
+    pub confidence: f32,
+    pub meta_confidence: f32,
+    pub should_admit_ignorance: bool,
+}
+
+/// Meta-cognition monitor: tracks confidence history, computes meta-confidence.
+/// Science: Fleming & Dolan (2012), Brier (1950), Yeung & Summerfield (2012).
+pub struct MetaCognition {
+    history: Vec<f32>,
+    max_history: usize,
+    calibration_error: f32,
+}
+
+impl MetaCognition {
+    pub fn new(max_history: usize) -> Self {
+        Self { history: Vec::new(), max_history, calibration_error: 0.5 }
+    }
+
+    /// Assess meta-confidence: how reliable is our confidence?
+    pub fn assess(&mut self, truth: &NarsTruth) -> MetaAssessment {
+        let confidence = truth.confidence;
+        self.history.push(confidence);
+        if self.history.len() > self.max_history {
+            self.history.remove(0);
+        }
+
+        let mean = self.history.iter().sum::<f32>() / self.history.len() as f32;
+        let variance = self.history.iter()
+            .map(|c| (c - mean).powi(2))
+            .sum::<f32>() / self.history.len() as f32;
+
+        let meta_confidence = 1.0 - variance.sqrt();
+
+        MetaAssessment {
+            confidence,
+            meta_confidence,
+            should_admit_ignorance: confidence < 0.3 && self.calibration_error > 0.2,
+        }
+    }
+
+    /// Update calibration error with actual outcome.
+    pub fn update_calibration(&mut self, predicted_confidence: f32, was_correct: bool) {
+        let outcome = if was_correct { 1.0 } else { 0.0 };
+        let brier = (predicted_confidence - outcome).powi(2);
+        self.calibration_error = 0.9 * self.calibration_error + 0.1 * brier;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_metacog_stable_confidence() {
+        let mut mc = MetaCognition::new(100);
+        for _ in 0..10 {
+            mc.assess(&NarsTruth::new(0.8, 0.9));
+        }
+        let result = mc.assess(&NarsTruth::new(0.8, 0.9));
+        assert!(result.meta_confidence > 0.9);
+        assert!(!result.should_admit_ignorance);
+    }
+
+    #[test]
+    fn test_metacog_unstable_confidence() {
+        let mut mc = MetaCognition::new(100);
+        for i in 0..10 {
+            let c = if i % 2 == 0 { 0.9 } else { 0.1 };
+            mc.assess(&NarsTruth::new(0.5, c));
+        }
+        let result = mc.assess(&NarsTruth::new(0.5, 0.5));
+        assert!(result.meta_confidence < 0.7);
+    }
+
+    #[test]
+    fn test_calibration_update() {
+        let mut mc = MetaCognition::new(100);
+        for _ in 0..10 {
+            mc.update_calibration(0.9, false);
+        }
+        assert!(mc.calibration_error > 0.3);
+    }
+}

src/hpc/roleplay.rs

@@ -0,0 +1,93 @@
+//! #9 Iterative Roleplay Synthesis — perspective sweep on Base17 fingerprints.
+
+use super::bgz17_bridge::Base17;
+
+/// One perspective result: which role, what it produced, how novel.
+pub struct PerspectiveResult {
+    pub role_idx: usize,
+    pub result: Base17,
+    pub novelty: f32,
+}
+
+/// Perspective sweep: each role modulates the query via XOR-analog (dim-wise add),
+/// then the nearest in corpus is found. Novelty = L1 from accumulated perspectives.
+/// Science: Kanerva (2009) XOR binding, De Bono (1985), Galton (1907).
+pub fn perspective_sweep(
+    query: &Base17,
+    roles: &[Base17],
+    corpus: &[Base17],
+) -> Vec<PerspectiveResult> {
+    let max_l1 = (17u32 * 65535) as f32;
+    let mut results = Vec::new();
+    let mut seen = query.clone();
+
+    for (idx, role) in roles.iter().enumerate() {
+        // Role-modulate query: dim-wise addition (XOR-analog for i16)
+        let mut modulated = Base17 { dims: [0; 17] };
+        for d in 0..17 {
+            modulated.dims[d] = query.dims[d].wrapping_add(role.dims[d]);
+        }
+
+        // Find nearest in corpus
+        let mut best = corpus.first().cloned().unwrap_or(Base17 { dims: [0; 17] });
+        let mut best_dist = u32::MAX;
+        for c in corpus {
+            let d = modulated.l1(c);
+            if d < best_dist {
+                best_dist = d;
+                best = c.clone();
+            }
+        }
+
+        // Novelty: how different from accumulated perspectives
+        let novelty = best.l1(&seen) as f32 / max_l1;
+        results.push(PerspectiveResult { role_idx: idx, result: best.clone(), novelty });
+
+        // Accumulate: running mean
+        for d in 0..17 {
+            seen.dims[d] = ((seen.dims[d] as i32 + best.dims[d] as i32) / 2) as i16;
+        }
+    }
+
+    results.sort_by(|a, b| b.novelty.partial_cmp(&a.novelty).unwrap());
+    results
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_perspective_sweep() {
+        let query = Base17 { dims: [100; 17] };
+        let roles = vec![
+            Base17 { dims: [10; 17] },
+            Base17 { dims: [-50; 17] },
+            Base17 { dims: [200; 17] },
+        ];
+        let corpus: Vec<Base17> = (0..20).map(|i| {
+            let mut dims = [0i16; 17];
+            dims[0] = (i * 50) as i16;
+            Base17 { dims }
+        }).collect();
+
+        let results = perspective_sweep(&query, &roles, &corpus);
+        assert_eq!(results.len(), 3);
+        assert!(results[0].novelty >= results[1].novelty);
+    }
+
+    #[test]
+    fn test_perspective_novelty() {
+        let query = Base17 { dims: [0; 17] };
+        let roles = vec![
+            Base17 { dims: [0; 17] },
+            Base17 { dims: [10000; 17] },
+        ];
+        let corpus = vec![
+            Base17 { dims: [0; 17] },
+            Base17 { dims: [10000; 17] },
+        ];
+        let results = perspective_sweep(&query, &roles, &corpus);
+        assert!(results[0].novelty > results[1].novelty);
+    }
+}

src/hpc/temporal.rs

@@ -0,0 +1,77 @@
+//! #12 Temporal Context Augmentation — embed timestamps into Base17 fingerprints.
+
+use super::bgz17_bridge::Base17;
+
+/// Temporal context: event time, reference time, speech time (Reichenbach).
+pub struct TemporalContext {
+    pub event_time: u64,
+    pub reference_time: u64,
+    pub speech_time: u64,
+}
+
+/// Temporally augmented Base17: original fingerprint + temporal signal.
+pub struct TemporalFingerprint {
+    pub base: Base17,
+    pub temporal: TemporalContext,
+    pub recency: f32,
+}
+
+/// Augment a Base17 fingerprint with temporal context.
+/// Recency decays with time distance from reference.
+/// Science: Reichenbach (1947), Kamp & Reyle (1993 Ch.5), Vendler (1957).
+pub fn temporalize(
+    base: &Base17,
+    event_time: u64,
+    reference_time: u64,
+) -> TemporalFingerprint {
+    let speech_time = reference_time;
+    let time_delta = if event_time > reference_time {
+        event_time - reference_time
+    } else {
+        reference_time - event_time
+    };
+    let scale = 3600.0;
+    let recency = (-1.0 * time_delta as f64 / scale).exp() as f32;
+
+    TemporalFingerprint {
+        base: base.clone(),
+        temporal: TemporalContext { event_time, reference_time, speech_time },
+        recency,
+    }
+}
+
+/// Temporal similarity: combine Base17 L1 with recency weighting.
+pub fn temporal_similarity(a: &TemporalFingerprint, b: &TemporalFingerprint) -> (u32, f32) {
+    let spatial = a.base.l1(&b.base);
+    let temporal_weight = (a.recency * b.recency).sqrt();
+    (spatial, temporal_weight)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_temporalize_recent() {
+        let base = Base17 { dims: [100; 17] };
+        let tf = temporalize(&base, 1000, 1000);
+        assert!((tf.recency - 1.0).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_temporalize_old() {
+        let base = Base17 { dims: [100; 17] };
+        let tf = temporalize(&base, 0, 36000);
+        assert!(tf.recency < 0.01);
+    }
+
+    #[test]
+    fn test_temporal_similarity() {
+        let base = Base17 { dims: [100; 17] };
+        let recent = temporalize(&base, 1000, 1000);
+        let old = temporalize(&base, 0, 1000);
+        let (spatial, weight) = temporal_similarity(&recent, &old);
+        assert_eq!(spatial, 0);
+        assert!(weight < 1.0);
+    }
+}