Enum SocialPhase 

pub enum SocialPhase {
    ShyObserver,
    StartledRetreat,
    QuietlyBeloved,
    ProtectiveGuardian,
}

Behavioral phase from the 2D (coherence × tension) space.

The four quadrants of the phase plane:

             │ Low tension        │ High tension
─────────────┼────────────────────┼──────────────────────
Low coherence│ ShyObserver        │ StartledRetreat
High coherence│ QuietlyBeloved    │ ProtectiveGuardian

Transitions use hysteresis (CCF-004) to prevent oscillation at boundaries.

Patent Claims 14–18.

Variants

ShyObserver

Low coherence, low tension: minimal expression, cautious observation.

StartledRetreat

Low coherence, high tension: protective reflex with additional withdrawal.

QuietlyBeloved

High coherence, low tension: full expressive range — “small flourishes”.

ProtectiveGuardian

High coherence, high tension: protective but with relational context.

Implementations

impl SocialPhase

pub fn classify( effective_coherence: f32, tension: f32, prev: SocialPhase, ps: &PhaseSpace, ) -> SocialPhase

Determine the current social phase using Schmitt trigger hysteresis (CCF-004).

• effective_coherence: output of CoherenceField::effective_coherence() in [0.0, 1.0].
• tension: current tension from homeostasis in [0.0, 1.0].
• prev: the phase from the previous tick (enables hysteresis).
• ps: configurable thresholds for quadrant transitions.

Examples found in repository

examples/mbot2.rs (line 133)

fn main() {
    println!("CCF mBot2 — Emergent Behaviour Simulation");
    println!("==========================================\n");

    // ── Personality ──────────────────────────────────────────────────────────
    //
    // These three parameters shape how the robot accumulates and loses trust.
    // They are analogous to temperament — the same events produce different
    // magnitudes of response depending on personality.
    //
    // This configuration: eager to engage (high curiosity), not easily startled
    // (low sensitivity), recovers quickly from disruption (high recovery).
    let personality = Personality {
        curiosity_drive:     0.8,
        startle_sensitivity: 0.3,
        recovery_speed:      0.7,
    };

    // ── Trust field ──────────────────────────────────────────────────────────
    //
    // The field maintains an independent trust state per sensory context.
    // It starts empty — the robot has no experience yet.
    let mut field: CoherenceField<MbotSensors, 6> = CoherenceField::new();

    // ── Phase space ──────────────────────────────────────────────────────────
    //
    // Configurable thresholds for the four-quadrant classifier.
    // The default values (enter 0.65 / exit 0.55 on coherence) are a good
    // starting point. Adjust to tune how quickly the robot "warms up".
    let ps = PhaseSpace::new();
    let mut phase = SocialPhase::ShyObserver;

    // ── Two sensor contexts ──────────────────────────────────────────────────
    //
    // The living room: bright, quiet, a familiar person nearby.
    // The basement:    dark, moderate noise, no one present.
    //
    // These are entirely independent trust contexts. Experience in one
    // does not transfer to the other.
    let living_room = ContextKey::new(MbotSensors {
        brightness:  BrightnessBand::Bright,
        noise:       NoiseBand::Quiet,
        presence:    PresenceSignature::Close,
        motion:      MotionContext::Static,
        orientation: Orientation::Upright,
        time_period: TimePeriod::Day,
    });

    let basement = ContextKey::new(MbotSensors {
        brightness:  BrightnessBand::Dark,
        noise:       NoiseBand::Moderate,
        presence:    PresenceSignature::Absent,
        motion:      MotionContext::Static,
        orientation: Orientation::Upright,
        time_period: TimePeriod::Evening,
    });

    // ── Phase 1: Build trust in the living room ───────────────────────────────
    //
    // Simulate 80 ticks of positive interaction in the living room.
    // The person is present, the environment is calm, interactions go well.
    println!("Phase 1: 80 positive interactions in the living room");
    println!("------------------------------------------------------");

    for tick in 0u64..80 {
        // alone=false: the person is present; the interaction is social
        field.positive_interaction(&living_room, &personality, tick, false);

        // instant: the current sensor-level signal (1.0 = fully coherent reading)
        // In a real system this comes from your homeostasis / sensor fusion layer.
        let instant: f32 = 0.9;
        let coherence = field.effective_coherence(instant, &living_room);
        let tension: f32 = 0.1; // calm environment
        phase = SocialPhase::classify(coherence, tension, phase, &ps);

        if tick % 20 == 19 {
            let led = phase.led_tint();
            println!(
                "  tick {:>3} | coherence {:.2} | phase {:?} | LED #{:02X}{:02X}{:02X}",
                tick + 1,
                coherence,
                phase,
                led[0], led[1], led[2]
            );
        }
    }

    // ── Phase 2: The basement — zero trust, same robot ───────────────────────
    //
    // The robot is moved to the basement. It has never been here before.
    // All the trust it built in the living room is irrelevant in this context.
    // It starts from zero — exactly as it should.
    println!("\nPhase 2: Robot moved to the basement (zero prior experience)");
    println!("--------------------------------------------------------------");

    let basement_coherence = field.effective_coherence(0.9, &basement);
    let basement_tension: f32 = 0.5; // unfamiliar, slightly unnerving
    phase = SocialPhase::classify(basement_coherence, basement_tension, phase, &ps);

    let led = phase.led_tint();
    println!(
        "  coherence in basement: {:.2} | phase {:?} | LED #{:02X}{:02X}{:02X}",
        basement_coherence,
        phase,
        led[0], led[1], led[2]
    );
    println!("  (Trust does not transfer. The robot earned nothing here yet.)");

    // ── Phase 3: A startle event back in the living room ─────────────────────
    //
    // The robot returns to the familiar living room. Someone slams a door.
    // Because the robot has deep trust in this context (earned floor > 0),
    // the negative event causes a drop — but cannot erase the accumulated history.
    println!("\nPhase 3: Return to living room — startle event (door slam)");
    println!("------------------------------------------------------------");

    let before = field.effective_coherence(0.9, &living_room);
    field.negative_interaction(&living_room, &personality, 81);
    let after = field.effective_coherence(0.9, &living_room);

    println!("  coherence before startle: {:.2}", before);
    println!("  coherence after startle:  {:.2}", after);
    println!(
        "  drop: {:.2} (earned floor protects against erasure)",
        before - after
    );

    let tension: f32 = 0.55; // brief spike from the startle
    phase = SocialPhase::classify(after, tension, phase, &ps);
    let led = phase.led_tint();
    println!(
        "  phase: {:?} | LED #{:02X}{:02X}{:02X}",
        phase, led[0], led[1], led[2]
    );

    // ── Phase 4: Recovery ─────────────────────────────────────────────────────
    //
    // A few more positive interactions and the robot recovers. The familiar
    // environment reasserts itself. This is not scripted — it emerges from the
    // accumulated trust floor protecting the relationship.
    println!("\nPhase 4: Recovery — 5 positive interactions");
    println!("--------------------------------------------");

    for tick in 82u64..87 {
        field.positive_interaction(&living_room, &personality, tick, false);
    }
    let recovered = field.effective_coherence(0.9, &living_room);
    let tension: f32 = 0.1;
    phase = SocialPhase::classify(recovered, tension, phase, &ps);
    let led = phase.led_tint();
    println!(
        "  coherence after recovery: {:.2} | phase {:?} | LED #{:02X}{:02X}{:02X}",
        recovered, phase, led[0], led[1], led[2]
    );

    // ── Summary ───────────────────────────────────────────────────────────────
    println!("\nSummary");
    println!("-------");
    println!(
        "  Living room trust:  {:.2} ({} interactions)",
        field.effective_coherence(0.9, &living_room),
        field.context_interaction_count(&living_room),
    );
    println!(
        "  Basement trust:     {:.2} ({} interactions)",
        field.effective_coherence(0.9, &basement),
        field.context_interaction_count(&basement),
    );
    println!("\nThe robot knows where it belongs.");
    println!("No rules. No scripts. Earned.");
}

pub fn expression_scale(&self) -> f32

Scale factor for expressive output in this phase [0.0, 1.0].

Delegates to permeability with representative mid-range values (coherence = 0.5, tension = 0.3) for backward-compatible ordering. New code should call permeability directly for full control.

pub fn led_tint(&self) -> [u8; 3]

LED color tint for this phase (overlaid on reflex mode color).

Examples found in repository

examples/mbot2.rs (line 136)

fn main() {
    println!("CCF mBot2 — Emergent Behaviour Simulation");
    println!("==========================================\n");

    // ── Personality ──────────────────────────────────────────────────────────
    //
    // These three parameters shape how the robot accumulates and loses trust.
    // They are analogous to temperament — the same events produce different
    // magnitudes of response depending on personality.
    //
    // This configuration: eager to engage (high curiosity), not easily startled
    // (low sensitivity), recovers quickly from disruption (high recovery).
    let personality = Personality {
        curiosity_drive:     0.8,
        startle_sensitivity: 0.3,
        recovery_speed:      0.7,
    };

    // ── Trust field ──────────────────────────────────────────────────────────
    //
    // The field maintains an independent trust state per sensory context.
    // It starts empty — the robot has no experience yet.
    let mut field: CoherenceField<MbotSensors, 6> = CoherenceField::new();

    // ── Phase space ──────────────────────────────────────────────────────────
    //
    // Configurable thresholds for the four-quadrant classifier.
    // The default values (enter 0.65 / exit 0.55 on coherence) are a good
    // starting point. Adjust to tune how quickly the robot "warms up".
    let ps = PhaseSpace::new();
    let mut phase = SocialPhase::ShyObserver;

    // ── Two sensor contexts ──────────────────────────────────────────────────
    //
    // The living room: bright, quiet, a familiar person nearby.
    // The basement:    dark, moderate noise, no one present.
    //
    // These are entirely independent trust contexts. Experience in one
    // does not transfer to the other.
    let living_room = ContextKey::new(MbotSensors {
        brightness:  BrightnessBand::Bright,
        noise:       NoiseBand::Quiet,
        presence:    PresenceSignature::Close,
        motion:      MotionContext::Static,
        orientation: Orientation::Upright,
        time_period: TimePeriod::Day,
    });

    let basement = ContextKey::new(MbotSensors {
        brightness:  BrightnessBand::Dark,
        noise:       NoiseBand::Moderate,
        presence:    PresenceSignature::Absent,
        motion:      MotionContext::Static,
        orientation: Orientation::Upright,
        time_period: TimePeriod::Evening,
    });

    // ── Phase 1: Build trust in the living room ───────────────────────────────
    //
    // Simulate 80 ticks of positive interaction in the living room.
    // The person is present, the environment is calm, interactions go well.
    println!("Phase 1: 80 positive interactions in the living room");
    println!("------------------------------------------------------");

    for tick in 0u64..80 {
        // alone=false: the person is present; the interaction is social
        field.positive_interaction(&living_room, &personality, tick, false);

        // instant: the current sensor-level signal (1.0 = fully coherent reading)
        // In a real system this comes from your homeostasis / sensor fusion layer.
        let instant: f32 = 0.9;
        let coherence = field.effective_coherence(instant, &living_room);
        let tension: f32 = 0.1; // calm environment
        phase = SocialPhase::classify(coherence, tension, phase, &ps);

        if tick % 20 == 19 {
            let led = phase.led_tint();
            println!(
                "  tick {:>3} | coherence {:.2} | phase {:?} | LED #{:02X}{:02X}{:02X}",
                tick + 1,
                coherence,
                phase,
                led[0], led[1], led[2]
            );
        }
    }

    // ── Phase 2: The basement — zero trust, same robot ───────────────────────
    //
    // The robot is moved to the basement. It has never been here before.
    // All the trust it built in the living room is irrelevant in this context.
    // It starts from zero — exactly as it should.
    println!("\nPhase 2: Robot moved to the basement (zero prior experience)");
    println!("--------------------------------------------------------------");

    let basement_coherence = field.effective_coherence(0.9, &basement);
    let basement_tension: f32 = 0.5; // unfamiliar, slightly unnerving
    phase = SocialPhase::classify(basement_coherence, basement_tension, phase, &ps);

    let led = phase.led_tint();
    println!(
        "  coherence in basement: {:.2} | phase {:?} | LED #{:02X}{:02X}{:02X}",
        basement_coherence,
        phase,
        led[0], led[1], led[2]
    );
    println!("  (Trust does not transfer. The robot earned nothing here yet.)");

    // ── Phase 3: A startle event back in the living room ─────────────────────
    //
    // The robot returns to the familiar living room. Someone slams a door.
    // Because the robot has deep trust in this context (earned floor > 0),
    // the negative event causes a drop — but cannot erase the accumulated history.
    println!("\nPhase 3: Return to living room — startle event (door slam)");
    println!("------------------------------------------------------------");

    let before = field.effective_coherence(0.9, &living_room);
    field.negative_interaction(&living_room, &personality, 81);
    let after = field.effective_coherence(0.9, &living_room);

    println!("  coherence before startle: {:.2}", before);
    println!("  coherence after startle:  {:.2}", after);
    println!(
        "  drop: {:.2} (earned floor protects against erasure)",
        before - after
    );

    let tension: f32 = 0.55; // brief spike from the startle
    phase = SocialPhase::classify(after, tension, phase, &ps);
    let led = phase.led_tint();
    println!(
        "  phase: {:?} | LED #{:02X}{:02X}{:02X}",
        phase, led[0], led[1], led[2]
    );

    // ── Phase 4: Recovery ─────────────────────────────────────────────────────
    //
    // A few more positive interactions and the robot recovers. The familiar
    // environment reasserts itself. This is not scripted — it emerges from the
    // accumulated trust floor protecting the relationship.
    println!("\nPhase 4: Recovery — 5 positive interactions");
    println!("--------------------------------------------");

    for tick in 82u64..87 {
        field.positive_interaction(&living_room, &personality, tick, false);
    }
    let recovered = field.effective_coherence(0.9, &living_room);
    let tension: f32 = 0.1;
    phase = SocialPhase::classify(recovered, tension, phase, &ps);
    let led = phase.led_tint();
    println!(
        "  coherence after recovery: {:.2} | phase {:?} | LED #{:02X}{:02X}{:02X}",
        recovered, phase, led[0], led[1], led[2]
    );

    // ── Summary ───────────────────────────────────────────────────────────────
    println!("\nSummary");
    println!("-------");
    println!(
        "  Living room trust:  {:.2} ({} interactions)",
        field.effective_coherence(0.9, &living_room),
        field.context_interaction_count(&living_room),
    );
    println!(
        "  Basement trust:     {:.2} ({} interactions)",
        field.effective_coherence(0.9, &basement),
        field.context_interaction_count(&basement),
    );
    println!("\nThe robot knows where it belongs.");
    println!("No rules. No scripts. Earned.");
}

Trait Implementations

impl Clone for SocialPhase

fn clone(&self) -> SocialPhase

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SocialPhase

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for SocialPhase

fn eq(&self, other: &SocialPhase) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for SocialPhase

impl Eq for SocialPhase

impl StructuralPartialEq for SocialPhase