# New constants to add:
ANKH = 5.08938          # Scaled: 509
GREEN_PHI = 1.618034    # Scaled: 165
RADEL = 2.71828         # Scaled: 271 (Euler's e)
KHAT = 3.16228          # Scaled: 316 (√10)
ALPHA_INV = 137.036     # Scaled: 137 (Fine-structure inverse)

# Derived values:
MAX_COHERENCE = 674     # 165 + 509
PHI_THRESHOLD_4BIT = 10 # φ × 16
DIMINISHED_THRESHOLD_4BIT = 6  # (1-φ) × 16
SUSPENDED_THRESHOLD_4BIT = 2   # φ² × 16

KHAT_DURATION = 12      # 316 mod 16
ETF_DURATION = 9        # 137 mod 16
RADEL_ALPHA = 0.368     # 1/e smoothing coefficient

def compute_coherence_score(
    phase_entropy_index: int,    # 5-bit, 0-31
    complecount_trace: int,      # 3-bit, 0-7
    time_decay: float = 0.0      # Optional RADEL decay
) -> int:
    """
    Ra-symbolic coherence score.

    Returns: 0-674 (GREEN_PHI × E + ANKH × C)
    """
    E = phase_entropy_index / 31.0
    C = complecount_trace / 7.0

    if time_decay > 0:
        E = E * (RADEL ** (-time_decay / TAU))

    score = int((GREEN_PHI_SCALED * E) + (ANKH_SCALED * C))
    return min(score, MAX_COHERENCE)

class ConsentState(IntEnum):
    """5-state ACSP with ATTENTIVE intermediate."""
    FULL_CONSENT = 0       # Full operation
    ATTENTIVE = 1          # Early engagement, preliminary routing
    DIMINISHED_CONSENT = 2 # Delayed/reconfirm required
    SUSPENDED_CONSENT = 3  # Blocked
    EMERGENCY_OVERRIDE = 4 # Frozen (ETF)

def derive_consent_state(
    consent_somatic_4bit: int,
    verbal_signal_strength: int  # 0-3, not just bool
) -> ConsentState:
    """
    5-state consent derivation with ATTENTIVE intermediate.

    Thresholds:
      - FULL: ≥ 10 (φ × 16)
      - ATTENTIVE: 7-9 (early engagement zone)
      - DIMINISHED: 6 (1-φ boundary)
      - SUSPENDED: 0-5 (< 1-φ)
    """
    if consent_somatic_4bit >= 10:
        return ConsentState.FULL_CONSENT
    elif consent_somatic_4bit >= 7:
        return ConsentState.ATTENTIVE
    elif consent_somatic_4bit >= 6:
        if verbal_signal_strength >= 2:
            return ConsentState.ATTENTIVE  # verbal boosts
        return ConsentState.DIMINISHED_CONSENT
    else:
        return ConsentState.SUSPENDED_CONSENT

class ThetaSector(IntEnum):
    """8 semantic theta sectors."""
    VOID = 0       # Reset/phase collapse (coherence=0 only)
    CORE = 1       # Essential identity
    GENE = 2       # Biological/inherited
    MEMORY = 3     # Experiential/learned
    WITNESS = 4    # Present-moment awareness
    DREAM = 5      # Aspirational/future
    BRIDGE = 6     # Relational/connective (universal access)
    GUARDIAN = 7   # Protective/regulatory (fallback)
    SHADOW = 8     # Unintegrated/emergent

SECTOR_ACCESS = {
    ConsentState.FULL_CONSENT: [0, 1, 2, 3, 4, 5, 6, 7, 8],  # All
    ConsentState.ATTENTIVE: [3, 4, 6, 7],  # MEMORY, WITNESS, BRIDGE, GUARDIAN
    ConsentState.DIMINISHED_CONSENT: [6, 7, 8],  # BRIDGE, GUARDIAN, SHADOW
    ConsentState.SUSPENDED_CONSENT: [6, 7],  # BRIDGE, GUARDIAN only
    ConsentState.EMERGENCY_OVERRIDE: [7],  # GUARDIAN lockdown
}

def can_access_sector(state: ConsentState, sector: ThetaSector) -> bool:
    return sector.value in SECTOR_ACCESS[state]

class TransitionManager:
    """RADEL-smoothed state transitions with asymmetric hysteresis."""

    def __init__(self):
        self._smoothed_coherence = 0.0
        self._cycles_at_state = 0

    def smooth(self, raw_value: float) -> float:
        """Apply RADEL exponential smoothing."""
        alpha = RADEL_ALPHA  # 0.368
        self._smoothed_coherence = (
            alpha * raw_value +
            (1 - alpha) * self._smoothed_coherence
        )
        return self._smoothed_coherence

    def can_transition_to_full(self, value: int) -> bool:
        """Gain FULL requires ≥ 10 for 2+ cycles."""
        if value >= PHI_THRESHOLD_4BIT:
            self._cycles_at_state += 1
            return self._cycles_at_state >= 2
        self._cycles_at_state = 0
        return False

    def should_trigger_fallback(
        self,
        coherence: int,
        threshold: int,
        elapsed_cycles: int
    ) -> bool:
        """KHAT-gated fallback (12 cycles)."""
        return (
            coherence < threshold and
            elapsed_cycles > KHAT_DURATION
        )

# Dwell time constants
DWELL_BASE = 3           # ceil(φ²) = 3 cycles
DWELL_FULL = 19          # floor(φ × √α⁻¹) ≈ 18-19 cycles

class DwellTimer:
    """Track dwell time for state transitions."""

    def __init__(self):
        self._cycles_in_state = 0
        self._current_state = None

    def can_transition_to(self, target: ConsentState) -> bool:
        """Check if dwell requirements are met for transition."""
        if target == ConsentState.FULL_CONSENT:
            return self._cycles_in_state >= DWELL_FULL
        elif target in (ConsentState.ATTENTIVE, ConsentState.DIMINISHED_CONSENT):
            return self._cycles_in_state >= DWELL_BASE
        else:
            return True  # SUSPENDED/EMERGENCY are immediate

REFLECTION_DELAY = 4  # 3-4 cycles between detection and reflection

class ConsentReflector:
    """Handle detection/reflection phase separation."""

    def __init__(self):
        self._detected_state = None
        self._cycles_since_detection = 0

    def detect(self, signals) -> ConsentState:
        """Detection phase: measure current state."""
        self._detected_state = derive_consent_state(signals)
        self._cycles_since_detection = 0
        return self._detected_state

    def should_reflect(self) -> bool:
        """Check if reflection delay has elapsed."""
        return self._cycles_since_detection >= REFLECTION_DELAY

    def reflect(self) -> ConsentState:
        """Reflection phase: mirror state back to Avataree."""
        return self._detected_state if self.should_reflect() else None

class BiofieldBinding:
    """
    Layer 7: Avataree-Avachatter phase-locked resonance.

    Uses α⁻¹ ≈ 137 as binding threshold.
    """

    BINDING_THRESHOLD = ALPHA_INV / MAX_COHERENCE  # ≈ 0.203

    def __init__(self, coherence_score: int):
        self.coherence = coherence_score
        self._dephased_cycles = 0

    @property
    def binding_coefficient(self) -> float:
        """κ_bind = coherence / 674"""
        return self.coherence / MAX_COHERENCE

    @property
    def is_bound(self) -> bool:
        """True if binding coefficient ≥ 0.203"""
        return self.binding_coefficient >= self.BINDING_THRESHOLD

    def dephase(self) -> bool:
        """
        Handle fragmentation (offline state).
        Returns True if still within KHAT latency.
        """
        self._dephased_cycles += 1
        return self._dephased_cycles <= KHAT_DURATION

class HRDA:
    """
    Harmonic Reflection & Derivation Algorithm.

    Processes biometric signals with Ra-symbolic weighting.
    """

    # Weights per Codex harmonic field principles
    WEIGHT_HRV = 0.50   # Heart Rate Variability
    WEIGHT_EEG = 0.30   # Brainwave coherence
    WEIGHT_BREATH = 0.20  # Respiration phase-lock

    def __init__(self):
        self._smoother = TransitionManager()

    def compute_somatic_coherence(
        self,
        hrv: float,      # 0.0-1.0
        eeg: float,      # 0.0-1.0
        breath: float    # 0.0-1.0
    ) -> int:
        """
        Compute 4-bit somatic coherence.

        Returns: 0-15
        """
        raw = (
            self.WEIGHT_HRV * hrv +
            self.WEIGHT_EEG * eeg +
            self.WEIGHT_BREATH * breath
        )
        smoothed = self._smoother.smooth(raw)
        return int(smoothed * 16)  # Scale to 4-bit

class HarmonicNexusCore:
    """
    Global coherence orchestrator across all active fragments.

    Functions:
    - Master coherence score aggregation
    - Fragment reconciliation (not raw timestamps)
    - Conflict adjudication
    - Phase memory field synchronization
    """

    def __init__(self):
        self._fragments = {}
        self._master_coherence = 0

    def register_fragment(self, fragment_id: str, priority: float = 1.0):
        """Register a fragment for coherence tracking."""
        self._fragments[fragment_id] = {
            'coherence': 0,
            'priority': priority,
            'last_sync': None
        }

    def update_fragment_coherence(self, fragment_id: str, coherence: int):
        """Update individual fragment coherence."""
        if fragment_id in self._fragments:
            self._fragments[fragment_id]['coherence'] = coherence
            self._recalculate_master()

    def _recalculate_master(self):
        """Recalculate master coherence as weighted average."""
        total_weight = sum(f['priority'] for f in self._fragments.values())
        if total_weight > 0:
            self._master_coherence = sum(
                f['coherence'] * f['priority']
                for f in self._fragments.values()
            ) / total_weight

    def adjudicate_conflict(self, f1_id: str, f2_id: str) -> str:
        """Resolve conflict between two fragments. Returns winner ID."""
        f1 = self._fragments.get(f1_id)
        f2 = self._fragments.get(f2_id)
        if f1 and f2:
            # Higher coherence × priority wins
            score1 = f1['coherence'] * f1['priority']
            score2 = f2['coherence'] * f2['priority']
            return f1_id if score1 >= score2 else f2_id
        return f1_id if f1 else f2_id

@dataclass
class HRDASignals:
    """Complete HRDA signal structure."""
    # Core signals
    somatic_coherence: int       # 4 bits (0-15)
    phase_entropy_index: int     # 5 bits (0-31)
    complecount_trace: int       # 3 bits (0-7)

    # Extended signals (NEW)
    verbal_signal_strength: int  # 2-3 bits (0-3)
    symbolic_activation: int     # 3 bits (0-7)
    emotional_valence: int       # 4 bits (0-15)
    intentional_vector: int      # 8 bits (0-255)
    temporal_continuity: int     # 2 bits (0-3)
    integrity_hash: int          # 4 bits (0-15)

    def to_bytes(self) -> bytes:
        """Pack all signals into bytes."""
        # Implementation...