feat: all 34 cognitive primitives as fn(Base17, NarsTruth) in styles/

29 submodule files + mod.rs = 30 files, 1617 lines, 49 tests passing.
Each tactic is a pure fn — no LLM prompting, no session state.

Tactics 1-12:  rte htd smad tcp irs mcp tca (+ causal_diff nars bgz17 cascade)
Tactics 13-20: cdt mct lsi pso cdi cws are tcf
Tactics 21-27: ssr etd amp zcf hpm cur mpc
Tactics 28-34: ssam idr spp icr sdd dtmf hkf

Science: Hofstadter, CLAM/CAKES, Pearl, Berry-Esseen, Wang/NARS,
Kanerva/VSA, Guilford, Festinger, Gentner, Shannon, Granger, Cohen.

API: crate::hpc::styles::{tactic}::{fn_name}()

https://claude.ai/code/session_01M3at4EuHVvQ8S95mSnKgtK

Author: claude

src/hpc/styles/amp.rs

@@ -0,0 +1,35 @@
+//! #23 Adaptive Meta-Prompting — gate state drives style selection.
+//! Science: Sutton & Barto (2018), Ashby (1956), Kahneman (2011).
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum GateState { Flow, Hold, Block }
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum StyleRecommendation { KeepCurrent, TryNeighbor, RadicalShift }
+
+pub fn adaptive_style_select(gate_history: &[GateState]) -> StyleRecommendation {
+    if gate_history.is_empty() { return StyleRecommendation::KeepCurrent; }
+    let recent: Vec<&GateState> = gate_history.iter().rev().take(3).collect();
+    let blocks = recent.iter().filter(|g| ***g == GateState::Block).count();
+    let flows = recent.iter().filter(|g| ***g == GateState::Flow).count();
+    if blocks >= 3 { StyleRecommendation::RadicalShift }
+    else if blocks >= 1 { StyleRecommendation::TryNeighbor }
+    else { StyleRecommendation::KeepCurrent }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_flow_keeps() {
+        assert_eq!(adaptive_style_select(&[GateState::Flow; 5]), StyleRecommendation::KeepCurrent);
+    }
+    #[test]
+    fn test_blocks_shift() {
+        assert_eq!(adaptive_style_select(&[GateState::Block; 3]), StyleRecommendation::RadicalShift);
+    }
+    #[test]
+    fn test_mixed() {
+        assert_eq!(adaptive_style_select(&[GateState::Flow, GateState::Block, GateState::Flow]), StyleRecommendation::TryNeighbor);
+    }
+}

src/hpc/styles/are.rs

@@ -0,0 +1,44 @@
+//! #19 Algorithmic Reverse Engineering — identify transformations from IO pairs.
+//! Science: Plate (2003) XOR self-inverse, Kleyko et al. (2022).
+
+use super::super::bgz17_bridge::Base17;
+
+#[derive(Debug, PartialEq)]
+pub enum TransformationType {
+    Offset([i16; 17]),
+    Identity,
+    Unknown,
+}
+
+pub fn identify_transformation(inputs: &[Base17], outputs: &[Base17]) -> TransformationType {
+    if inputs.is_empty() || inputs.len() != outputs.len() { return TransformationType::Unknown; }
+    // Check if outputs = inputs + constant offset
+    let mut offset = [0i16; 17];
+    for d in 0..17 { offset[d] = outputs[0].dims[d].wrapping_sub(inputs[0].dims[d]); }
+    let is_offset = inputs.iter().zip(outputs.iter()).all(|(i, o)| {
+        (0..17).all(|d| o.dims[d].wrapping_sub(i.dims[d]) == offset[d])
+    });
+    if is_offset {
+        if offset == [0i16; 17] { TransformationType::Identity }
+        else { TransformationType::Offset(offset) }
+    } else { TransformationType::Unknown }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_detect_offset() {
+        let inputs = vec![Base17 { dims: [10; 17] }, Base17 { dims: [20; 17] }];
+        let outputs = vec![Base17 { dims: [15; 17] }, Base17 { dims: [25; 17] }];
+        match identify_transformation(&inputs, &outputs) {
+            TransformationType::Offset(o) => assert_eq!(o, [5i16; 17]),
+            _ => panic!("should detect offset"),
+        }
+    }
+    #[test]
+    fn test_detect_identity() {
+        let data = vec![Base17 { dims: [42; 17] }];
+        assert_eq!(identify_transformation(&data, &data), TransformationType::Identity);
+    }
+}

src/hpc/styles/cdi.rs

@@ -0,0 +1,39 @@
+//! #17 Cognitive Dissonance Induction — create productive tension.
+//! Science: Festinger (1957), Berlyne (1960), Peng & Nisbett (1999).
+
+use super::super::bgz17_bridge::Base17;
+use super::super::nars::NarsTruth;
+
+pub fn induce_dissonance(belief: &Base17, truth: &NarsTruth, corpus: &[Base17]) -> (Base17, NarsTruth) {
+    // Find structurally similar but maximally different item
+    let max_l1 = (17u32 * 65535) as f32;
+    let mut best_tension = 0.0f32;
+    let mut best = belief.clone();
+    for c in corpus {
+        let similarity = 1.0 - belief.l1(c) as f32 / max_l1;
+        if similarity > 0.3 && similarity < 0.7 {
+            let tension = similarity * (1.0 - similarity); // Maximum at 0.5
+            if tension > best_tension { best_tension = tension; best = c.clone(); }
+        }
+    }
+    // Dissonance = midpoint between belief and its tension partner
+    let mut dims = [0i16; 17];
+    for d in 0..17 { dims[d] = ((belief.dims[d] as i32 + best.dims[d] as i32) / 2) as i16; }
+    let dissonance = Base17 { dims };
+    let dissonant_truth = NarsTruth::new(0.5, truth.confidence * 0.5);
+    (dissonance, dissonant_truth)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_dissonance() {
+        let belief = Base17 { dims: [100; 17] };
+        let truth = NarsTruth::new(0.9, 0.8);
+        let corpus = vec![Base17 { dims: [120; 17] }, Base17 { dims: [500; 17] }];
+        let (dis, dt) = induce_dissonance(&belief, &truth, &corpus);
+        assert_eq!(dt.frequency, 0.5); // maximum uncertainty
+        assert!(dt.confidence < truth.confidence);
+    }
+}

src/hpc/styles/cdt.rs

@@ -0,0 +1,55 @@
+//! #13 Convergent & Divergent Thinking — oscillate between exploration and exploitation.
+//! Science: Guilford (1967), Kanerva (2009), Sutton & Barto (2018).
+
+use super::super::bgz17_bridge::Base17;
+
+pub fn oscillate(query: &Base17, corpus: &[Base17], rounds: usize) -> (Base17, Vec<f32>) {
+    let mut current = query.clone();
+    let mut ratios = Vec::new();
+    for round in 0..rounds {
+        if round % 2 == 0 {
+            // Diverge: bundle with farthest neighbors (mean of distant items)
+            let mut farthest: Vec<(u32, usize)> = corpus.iter().enumerate()
+                .map(|(i, c)| (current.l1(c), i)).collect();
+            farthest.sort_by(|a, b| b.0.cmp(&a.0));
+            let top5: Vec<&Base17> = farthest.iter().take(5).map(|(_, i)| &corpus[*i]).collect();
+            current = bundle_base17(&top5, &current);
+            ratios.push(1.0);
+        } else {
+            // Converge: snap to nearest
+            let mut best_dist = u32::MAX;
+            let mut best = current.clone();
+            for c in corpus {
+                let d = current.l1(c);
+                if d < best_dist && d > 0 { best_dist = d; best = c.clone(); }
+            }
+            current = best;
+            ratios.push(0.0);
+        }
+    }
+    (current, ratios)
+}
+
+fn bundle_base17(items: &[&Base17], seed: &Base17) -> Base17 {
+    let n = items.len() as i32 + 1;
+    let mut dims = [0i32; 17];
+    for d in 0..17 { dims[d] += seed.dims[d] as i32; }
+    for item in items { for d in 0..17 { dims[d] += item.dims[d] as i32; } }
+    let mut result = [0i16; 17];
+    for d in 0..17 { result[d] = (dims[d] / n) as i16; }
+    Base17 { dims: result }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_oscillate() {
+        let query = Base17 { dims: [100; 17] };
+        let corpus: Vec<Base17> = (0..20).map(|i| { let mut d = [0i16; 17]; d[0] = (i*50) as i16; Base17 { dims: d } }).collect();
+        let (result, ratios) = oscillate(&query, &corpus, 4);
+        assert_eq!(ratios.len(), 4);
+        assert_eq!(ratios[0], 1.0); // diverge
+        assert_eq!(ratios[1], 0.0); // converge
+    }
+}

src/hpc/styles/cur.rs

@@ -0,0 +1,25 @@
+//! #26 Cascading Uncertainty Reduction — CRP percentiles drive resolution.
+//! Science: Shannon (1948), Berry-Esseen, Rényi (1961).
+
+use super::lsi::ClusterDistribution;
+
+pub fn cascading_uncertainty(dist: &ClusterDistribution) -> Vec<(u8, f32)> {
+    let max_l1 = (17u32 * 65535) as f32;
+    vec![
+        (1, 1.0 - dist.p25 / max_l1),  // INT1: coarsest
+        (4, 1.0 - dist.p50 / max_l1),  // INT4
+        (8, 1.0 - dist.p75 / max_l1),  // INT8
+        (32, 1.0 - dist.p99 / max_l1), // INT32: finest
+    ]
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_uncertainty_decreases() {
+        let dist = ClusterDistribution { mu: 5000.0, sigma: 1000.0, p25: 4325.5, p50: 5000.0, p75: 5674.5, p95: 6644.9, p99: 7326.3 };
+        let levels = cascading_uncertainty(&dist);
+        assert!(levels[0].1 > levels[3].1); // coarsest has most uncertainty
+    }
+}

src/hpc/styles/cws.rs

@@ -0,0 +1,37 @@
+//! #18 Context Window Simulation — snapshot and restore Base17 regions.
+//! Science: Kanerva (1988) sparse distributed memory.
+
+use super::super::bgz17_bridge::Base17;
+
+pub struct Snapshot {
+    pub entries: Vec<(u16, Base17)>,
+}
+
+pub fn snapshot_region(corpus: &[(u16, Base17)]) -> Snapshot {
+    Snapshot { entries: corpus.to_vec() }
+}
+
+pub fn restore_region(snapshot: &Snapshot) -> Vec<(u16, Base17)> {
+    snapshot.entries.clone()
+}
+
+pub fn merge_snapshots(a: &Snapshot, b: &Snapshot) -> Snapshot {
+    let mut merged = a.entries.clone();
+    for (addr, fp) in &b.entries {
+        if !merged.iter().any(|(a, _)| a == addr) { merged.push((*addr, fp.clone())); }
+    }
+    Snapshot { entries: merged }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_snapshot_roundtrip() {
+        let data = vec![(0u16, Base17 { dims: [42; 17] }), (1, Base17 { dims: [99; 17] })];
+        let snap = snapshot_region(&data);
+        let restored = restore_region(&snap);
+        assert_eq!(restored.len(), 2);
+        assert_eq!(restored[0].1.dims[0], 42);
+    }
+}

src/hpc/styles/dtmf.rs

@@ -0,0 +1,40 @@
+//! #33 Dynamic Task Meta-Framing — gate history triggers frame switching.
+//! Science: Lakoff (2004), Tversky & Kahneman (1981), Ashby (1956).
+
+use super::amp::GateState;
+
+pub struct FrameShift {
+    pub occurred: bool,
+    pub rung_jump: u8,
+    pub style_flip: bool,
+}
+
+pub fn dynamic_reframe(gate_history: &[GateState]) -> FrameShift {
+    let recent_blocks = gate_history.iter().rev().take(3)
+        .filter(|g| **g == GateState::Block).count();
+    if recent_blocks >= 3 {
+        FrameShift { occurred: true, rung_jump: 3, style_flip: true }
+    } else if recent_blocks >= 2 {
+        FrameShift { occurred: true, rung_jump: 1, style_flip: false }
+    } else {
+        FrameShift { occurred: false, rung_jump: 0, style_flip: false }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_no_reframe() {
+        let history = vec![GateState::Flow; 5];
+        assert!(!dynamic_reframe(&history).occurred);
+    }
+    #[test]
+    fn test_triple_block_reframes() {
+        let history = vec![GateState::Block; 3];
+        let shift = dynamic_reframe(&history);
+        assert!(shift.occurred);
+        assert!(shift.style_flip);
+        assert_eq!(shift.rung_jump, 3);
+    }
+}

src/hpc/styles/etd.rs

@@ -0,0 +1,43 @@
+//! #22 Emergent Task Decomposition — subtask structure emerges from corpus clusters.
+//! Science: CLAM (Ishaq et al. 2019), Simon (1962), Bengio et al. (2013).
+
+use super::super::bgz17_bridge::Base17;
+
+pub struct Subtask { pub fingerprint: Base17, pub relevance: f32 }
+
+pub fn emergent_decompose(task: &Base17, corpus: &[Base17], max_subtasks: usize) -> Vec<Subtask> {
+    let max_l1 = (17u32 * 65535) as f32;
+    // Find diverse set: furthest-point sampling from task
+    let mut selected = Vec::new();
+    let mut min_dists = vec![u32::MAX; corpus.len()];
+    for _ in 0..max_subtasks.min(corpus.len()) {
+        // Update distances
+        let anchor = if selected.is_empty() { task } else { &corpus[*selected.last().unwrap()] };
+        for (i, c) in corpus.iter().enumerate() {
+            let d = anchor.l1(c);
+            if d < min_dists[i] { min_dists[i] = d; }
+        }
+        // Pick farthest
+        let best = min_dists.iter().enumerate()
+            .filter(|(i, _)| !selected.contains(i))
+            .max_by_key(|(_, d)| *d)
+            .map(|(i, _)| i);
+        if let Some(idx) = best { selected.push(idx); } else { break; }
+    }
+    selected.iter().map(|&i| {
+        let relevance = 1.0 - task.l1(&corpus[i]) as f32 / max_l1;
+        Subtask { fingerprint: corpus[i].clone(), relevance }
+    }).collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_emergent_decompose() {
+        let task = Base17 { dims: [100; 17] };
+        let corpus: Vec<Base17> = (0..20).map(|i| { let mut d = [0i16; 17]; d[0] = (i*100) as i16; Base17 { dims: d } }).collect();
+        let subtasks = emergent_decompose(&task, &corpus, 5);
+        assert_eq!(subtasks.len(), 5);
+    }
+}

src/hpc/styles/hkf.rs

@@ -0,0 +1,59 @@
+//! #34 Hyperdimensional Knowledge Fusion — cross-domain fusion with validity.
+//! Science: Plate (2003), Kanerva (2009), Rahimi & Recht (2007).
+
+use super::super::bgz17_bridge::Base17;
+use super::super::nars::NarsTruth;
+
+pub struct FusionResult {
+    pub fused: Base17,
+    pub domain_a_recovery: f32,
+    pub domain_b_recovery: f32,
+    pub novelty: f32,
+    pub truth: NarsTruth,
+}
+
+pub fn cross_domain_fuse(domain_a: &Base17, domain_b: &Base17, relation: &Base17) -> FusionResult {
+    let max_l1 = (17u32 * 65535) as f32;
+    let mut fused_dims = [0i16; 17];
+    for d in 0..17 {
+        fused_dims[d] = domain_a.dims[d].wrapping_add(relation.dims[d]).wrapping_add(domain_b.dims[d]);
+    }
+    let fused = Base17 { dims: fused_dims };
+
+    // Recovery test: fused - relation - B should ≈ A
+    let mut ra_dims = [0i16; 17];
+    let mut rb_dims = [0i16; 17];
+    for d in 0..17 {
+        ra_dims[d] = fused.dims[d].wrapping_sub(relation.dims[d]).wrapping_sub(domain_b.dims[d]);
+        rb_dims[d] = fused.dims[d].wrapping_sub(relation.dims[d]).wrapping_sub(domain_a.dims[d]);
+    }
+    let ra = Base17 { dims: ra_dims };
+    let rb = Base17 { dims: rb_dims };
+
+    let recovery_a = 1.0 - ra.l1(domain_a) as f32 / max_l1;
+    let recovery_b = 1.0 - rb.l1(domain_b) as f32 / max_l1;
+    let novelty = (fused.l1(domain_a) as f32 + fused.l1(domain_b) as f32) / (2.0 * max_l1);
+
+    FusionResult {
+        fused,
+        domain_a_recovery: recovery_a,
+        domain_b_recovery: recovery_b,
+        novelty,
+        truth: NarsTruth::new((recovery_a + recovery_b) / 2.0, 0.8),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_cross_domain_fuse() {
+        let a = Base17 { dims: [100; 17] };
+        let b = Base17 { dims: [200; 17] };
+        let rel = Base17 { dims: [5; 17] };
+        let result = cross_domain_fuse(&a, &b, &rel);
+        assert!(result.domain_a_recovery > 0.99);
+        assert!(result.domain_b_recovery > 0.99);
+        assert!(result.novelty > 0.0);
+    }
+}