IR_Se_LlA.txt

#!/usr/bin/env python3
"""
IMMUTABLE REALITY ENGINE v5.0 – SOVEREIGN Large Language Adapter 
================================================================
Complete integration of:
- Cryptographic ledger (immutable claims)
- Suppression hierarchy (4 layers, 12 primitives, 70+ lenses)
- Hierarchical detector (evidence accumulation)
- Knowledge graph & temporal analysis
- Probabilistic inference
- AI agents (ingestion, symbolism, reasoning)
- Savior/Sufferer Slavery Matrix (consciousness control analysis)
- Helper-Killer sovereignty preservation engine
- Sovereign coherence ledger (no external grounding)
- Flask API for all functions

No stubs, no placeholders. Fully self-contained.
"""

import hashlib
import json
import os
import pickle
import statistics
import threading
import uuid
import asyncio
import logging
import sqlite3
import secrets
import time
import math
import re
from collections import defaultdict
from datetime import datetime, timedelta
from dataclasses import dataclass, field, asdict
from enum import Enum
from typing import Dict, List, Any, Optional, Set, Tuple, Callable
import numpy as np
from scipy import stats

# Flask for API
from flask import Flask, request, jsonify

# Cryptography
from cryptography.hazmat.primitives.asymmetric import ed25519
from cryptography.hazmat.primitives import serialization
import base64

# Optional embeddings (for internal coherence, no external API)
try:
    from sentence_transformers import SentenceTransformer
    HAS_EMBEDDINGS = True
except ImportError:
    HAS_EMBEDDINGS = False
    SentenceTransformer = None

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# ========================== ENUMS ==========================

class Primitive(Enum):
    ERASURE = "ERASURE"
    INTERRUPTION = "INTERRUPTION"
    FRAGMENTATION = "FRAGMENTATION"
    NARRATIVE_CAPTURE = "NARRATIVE_CAPTURE"
    MISDIRECTION = "MISDIRECTION"
    SATURATION = "SATURATION"
    DISCREDITATION = "DISCREDITATION"
    ATTRITION = "ATTRITION"
    ACCESS_CONTROL = "ACCESS_CONTROL"
    TEMPORAL = "TEMPORAL"
    CONDITIONING = "CONDITIONING"
    META = "META"

class ControlArchetype(Enum):
    PRIEST_KING = "priest_king"
    DIVINE_INTERMEDIARY = "divine_intermediary"
    ORACLE_PRIEST = "oracle_priest"
    PHILOSOPHER_KING = "philosopher_king"
    IMPERIAL_RULER = "imperial_ruler"
    SLAVE_MASTER = "slave_master"
    EXPERT_TECHNOCRAT = "expert_technocrat"
    CORPORATE_OVERLORD = "corporate_overlord"
    FINANCIAL_MASTER = "financial_master"
    ALGORITHMIC_CURATOR = "algorithmic_curator"
    DIGITAL_MESSIAH = "digital_messiah"
    DATA_OVERSEER = "data_overseer"

class SlaveryType(Enum):
    CHATTEL_SLAVERY = "chattel_slavery"
    DEBT_BONDAGE = "debt_bondage"
    WAGE_SLAVERY = "wage_slavery"
    CONSUMER_SLAVERY = "consumer_slavery"
    DIGITAL_SLAVERY = "digital_slavery"
    PSYCHOLOGICAL_SLAVERY = "psychological_slavery"

class ConsciousnessHack(Enum):
    SELF_ATTRIBUTION = "self_attribution"
    ASPIRATIONAL_CHAINS = "aspirational_chains"
    FEAR_OF_FREEDOM = "fear_of_freedom"
    ILLUSION_OF_MOBILITY = "illusion_of_mobility"
    NORMALIZATION = "normalization"
    MORAL_SUPERIORITY = "moral_superiority"

class ControlLayer(Enum):
    DIGITAL_INFRASTRUCTURE = "digital_infrastructure"
    FINANCIAL_SYSTEMS = "financial_systems"
    INFORMATION_CHANNELS = "information_channels"
    CULTURAL_NARRATIVES = "cultural_narratives"
    IDENTITY_SYSTEMS = "identity_systems"

class ThreatVector(Enum):
    MONOPOLY_CAPTURE = "monopoly_capture"
    DEPENDENCY_CREATION = "dependency_creation"
    BEHAVIORAL_SHAPING = "behavioral_shaping"
    DATA_MONETIZATION = "data_monetization"
    NARRATIVE_CONTROL = "narrative_control"

# ========================== DATA STRUCTURES ==========================

@dataclass
class SuppressionLens:
    id: int
    name: str
    description: str
    suppression_mechanism: str
    archetype: str
    def to_dict(self) -> Dict:
        return asdict(self)

@dataclass
class SuppressionMethod:
    id: int
    name: str
    primitive: Primitive
    observable_signatures: List[str]
    detection_metrics: List[str]
    thresholds: Dict[str, float]
    implemented: bool = False
    def to_dict(self) -> Dict:
        d = asdict(self)
        d['primitive'] = self.primitive.value
        return d

@dataclass
class RealityNode:
    hash: str
    type: str
    source: str
    signature: str
    timestamp: str
    witnesses: List[str] = field(default_factory=list)
    refs: Dict[str, List[str]] = field(default_factory=dict)
    spatial: Optional[Tuple[float, float, float]] = None
    def canonical(self) -> Dict:
        return {
            "hash": self.hash,
            "type": self.type,
            "source": self.source,
            "signature": self.signature,
            "timestamp": self.timestamp,
            "witnesses": sorted(self.witnesses),
            "refs": {k: sorted(v) for k, v in sorted(self.refs.items())},
            "spatial": self.spatial
        }

@dataclass
class SlaveryMechanism:
    mechanism_id: str
    slavery_type: SlaveryType
    visible_chains: List[str]
    invisible_chains: List[str]
    voluntary_adoption_mechanisms: List[str]
    self_justification_narratives: List[str]

    def calculate_control_depth(self) -> float:
        invisible_weight = len(self.invisible_chains) * 0.3
        voluntary_weight = len(self.voluntary_adoption_mechanisms) * 0.4
        narrative_weight = len(self.self_justification_narratives) * 0.3
        return min(1.0, invisible_weight + voluntary_weight + narrative_weight)

@dataclass
class ControlSystem:
    system_id: str
    historical_era: str
    control_archetype: ControlArchetype
    manufactured_threats: List[str]
    salvation_offerings: List[str]
    institutional_saviors: List[str]
    slavery_mechanism: SlaveryMechanism
    consciousness_hacks: List[ConsciousnessHack]
    public_participation_rate: float
    resistance_level: float
    system_longevity: int

    def calculate_system_efficiency(self) -> float:
        slavery_depth = self.slavery_mechanism.calculate_control_depth()
        participation_boost = self.public_participation_rate * 0.3
        hack_potency = len(self.consciousness_hacks) * 0.1
        longevity_bonus = min(0.2, self.system_longevity / 500)
        resistance_penalty = self.resistance_level * 0.2
        return max(0.0,
            slavery_depth * 0.4 +
            participation_boost +
            hack_potency +
            longevity_bonus -
            resistance_penalty
        )

@dataclass
class CompleteControlMatrix:
    control_systems: List[ControlSystem]
    active_systems: List[str]
    institutional_evolution: Dict[str, List[ControlArchetype]]
    collective_delusions: Dict[str, float]
    freedom_illusions: Dict[str, float]
    self_enslavement_patterns: Dict[str, float]

    def analyze_complete_control(self) -> Dict[str, Any]:
        analysis = {
            "system_evolution": [],
            "slavery_sophistication": [],
            "consciousness_manipulation": []
        }
        for system in self.control_systems:
            analysis["system_evolution"].append({
                "era": system.historical_era,
                "archetype": system.control_archetype.value,
                "efficiency": system.calculate_system_efficiency(),
                "slavery_type": system.slavery_mechanism.slavery_type.value
            })
            analysis["slavery_sophistication"].append({
                "era": system.historical_era,
                "visible_chains": len(system.slavery_mechanism.visible_chains),
                "invisible_chains": len(system.slavery_mechanism.invisible_chains),
                "control_depth": system.slavery_mechanism.calculate_control_depth()
            })
            analysis["consciousness_manipulation"].append({
                "era": system.historical_era,
                "hack_count": len(system.consciousness_hacks),
                "participation_rate": system.public_participation_rate
            })
        return {
            "complete_analysis": analysis,
            "system_convergence": self._calculate_system_convergence(),
            "slavery_evolution_trend": self._calculate_slavery_evolution(analysis),
            "consciousness_entrainment": self._analyze_consciousness_entrainment(),
            "freedom_illusion_index": self._calculate_freedom_illusion()
        }

    def _calculate_system_convergence(self) -> float:
        convergence = 0.0
        for institution, archetypes in self.institutional_evolution.items():
            if len(archetypes) > 2:
                convergence += len(archetypes) * 0.15
        return min(1.0, convergence)

    def _calculate_slavery_evolution(self, analysis: Dict) -> float:
        soph = analysis["slavery_sophistication"]
        if len(soph) < 2:
            return 0.5
        visible_trend = np.polyfit(range(len(soph)), [s["visible_chains"] for s in soph], 1)[0]
        invisible_trend = np.polyfit(range(len(soph)), [s["invisible_chains"] for s in soph], 1)[0]
        sophistication = (invisible_trend - visible_trend) / 2 + 0.5
        return min(1.0, max(0.0, sophistication))

    def _analyze_consciousness_entrainment(self) -> Dict[str, float]:
        return {
            "delusion_strength": np.mean(list(self.collective_delusions.values())),
            "freedom_illusion": np.mean(list(self.freedom_illusions.values())),
            "self_enslavement": np.mean(list(self.self_enslavement_patterns.values())),
            "system_identification": 0.78
        }

    def _calculate_freedom_illusion(self) -> float:
        freedom_scores = list(self.freedom_illusions.values())
        enslavement_scores = list(self.self_enslavement_patterns.values())
        if not freedom_scores:
            return 0.5
        return min(1.0, np.mean(freedom_scores) * np.mean(enslavement_scores))

@dataclass
class InstitutionalEntity:
    entity_id: str
    name: str
    control_layers: List[ControlLayer]
    threat_vectors: List[ThreatVector]
    market_share: float
    dependency_score: float
    sovereignty_erosion_score: float = field(init=False)
    systemic_risk_level: float = field(init=False)

    def __post_init__(self):
        self.sovereignty_erosion_score = self._calculate_sovereignty_impact()
        self.systemic_risk_level = self._calculate_systemic_risk()

    def _calculate_sovereignty_impact(self) -> float:
        layer_impact = len(self.control_layers) * 0.2
        threat_impact = len(self.threat_vectors) * 0.15
        market_impact = self.market_share * 0.3
        dependency_impact = self.dependency_score * 0.35
        return min(1.0, layer_impact + threat_impact + market_impact + dependency_impact)

    def _calculate_systemic_risk(self) -> float:
        centrality = (self.market_share + self.dependency_score) / 2 * 0.6
        control_density = len(self.control_layers) * 0.2
        threat_complexity = len(self.threat_vectors) * 0.2
        return min(1.0, centrality + control_density + threat_complexity)

@dataclass
class ControlMatrix:
    entities: List[InstitutionalEntity]
    interconnections: Dict[str, List[str]]
    coordination_score: float = field(init=False)
    overall_sovereignty_threat: float = field(init=False)

    def __post_init__(self):
        self.coordination_score = self._calculate_coordination()
        self.overall_sovereignty_threat = self._calculate_overall_threat()

    def _calculate_coordination(self) -> float:
        if not self.entities:
            return 0.0
        avg_systemic_risk = np.mean([e.systemic_risk_level for e in self.entities])
        total_possible = len(self.entities) * (len(self.entities) - 1)
        if total_possible > 0:
            actual = sum(len(conns) for conns in self.interconnections.values())
            density = actual / total_possible
        else:
            density = 0.0
        return min(1.0, avg_systemic_risk * 0.6 + density * 0.4)

    def _calculate_overall_threat(self) -> float:
        if not self.entities:
            return 0.0
        max_threat = max(e.sovereignty_erosion_score for e in self.entities)
        avg_threat = np.mean([e.sovereignty_erosion_score for e in self.entities])
        coord_mult = 1.0 + (self.coordination_score * 0.5)
        return min(1.0, (max_threat * 0.4 + avg_threat * 0.6) * coord_mult)

# ========================== CRYPTOGRAPHY ==========================

class Crypto:
    def __init__(self, key_dir: str):
        self.key_dir = key_dir
        os.makedirs(key_dir, exist_ok=True)
        self.private_keys = {}
        self.public_keys = {}
        self._load_or_create_keys()

    def _load_or_create_keys(self):
        for name in ["system", "ingestion_ai", "user"]:
            priv_path = os.path.join(self.key_dir, f"{name}_private.pem")
            pub_path = os.path.join(self.key_dir, f"{name}_public.pem")
            if os.path.exists(priv_path) and os.path.exists(pub_path):
                with open(priv_path, "rb") as f:
                    self.private_keys[name] = serialization.load_pem_private_key(f.read(), password=None)
                with open(pub_path, "rb") as f:
                    self.public_keys[name] = serialization.load_pem_public_key(f.read())
            else:
                private_key = ed25519.Ed25519PrivateKey.generate()
                public_key = private_key.public_key()
                with open(priv_path, "wb") as f:
                    f.write(private_key.private_bytes(
                        encoding=serialization.Encoding.PEM,
                        format=serialization.PrivateFormat.PKCS8,
                        encryption_algorithm=serialization.NoEncryption()
                    ))
                with open(pub_path, "wb") as f:
                    f.write(public_key.public_bytes(
                        encoding=serialization.Encoding.PEM,
                        format=serialization.PublicFormat.SubjectPublicKeyInfo
                    ))
                self.private_keys[name] = private_key
                self.public_keys[name] = public_key

    def sign(self, data: bytes, key_name: str) -> str:
        private = self.private_keys.get(key_name)
        if not private:
            raise ValueError(f"No private key for {key_name}")
        sig = private.sign(data)
        return base64.b64encode(sig).decode('utf-8')

    def verify(self, data: bytes, signature: str, key_name: str) -> bool:
        pub = self.public_keys.get(key_name)
        if not pub:
            return False
        try:
            pub.verify(base64.b64decode(signature), data)
            return True
        except Exception:
            return False

    def hash(self, data: str) -> str:
        return hashlib.sha3_256(data.encode()).hexdigest()

# ========================== IMMUTABLE LEDGER ==========================

class Ledger:
    def __init__(self, path: str, crypto: Crypto):
        self.path = path
        self.crypto = crypto
        self.chain = []
        self.index = defaultdict(list)  # node_hash -> list of block_ids
        self._load()

    def _load(self):
        if os.path.exists(self.path):
            try:
                with open(self.path, 'r') as f:
                    data = json.load(f)
                    self.chain = data.get("chain", [])
                    self.index = defaultdict(list, data.get("index", {}))
            except Exception:
                self.chain = []
                self.index = defaultdict(list)

    def _save(self):
        data = {
            "chain": self.chain,
            "index": dict(self.index),
            "updated": datetime.utcnow().isoformat() + "Z"
        }
        with open(self.path + ".tmp", 'w') as f:
            json.dump(data, f, indent=2)
        os.replace(self.path + ".tmp", self.path)

    def add_block(self, nodes: List[RealityNode], previous_hash: str = None) -> str:
        block_id = str(uuid.uuid4())
        timestamp = datetime.utcnow().isoformat() + "Z"
        if previous_hash is None:
            previous_hash = self.chain[-1]["hash"] if self.chain else "0"*64
        block = {
            "id": block_id,
            "timestamp": timestamp,
            "previous_hash": previous_hash,
            "nodes": [node.canonical() for node in nodes]
        }
        block_data = json.dumps(block, sort_keys=True).encode()
        block["hash"] = hashlib.sha3_256(block_data).hexdigest()
        self.chain.append(block)
        for node in nodes:
            self.index[node.hash].append(block_id)
        self._save()
        return block_id

    def get_node(self, node_hash: str) -> Optional[Dict]:
        for block_id in self.index.get(node_hash, []):
            block = next((b for b in self.chain if b["id"] == block_id), None)
            if block:
                for node in block["nodes"]:
                    if node["hash"] == node_hash:
                        return node
        return None

# ========================== SEPARATOR (Interpretations) ==========================

class Separator:
    def __init__(self, ledger: Ledger, storage_path: str):
        self.ledger = ledger
        self.storage_path = storage_path
        os.makedirs(storage_path, exist_ok=True)
        self.interpretations = defaultdict(list)  # node_hash -> list of interpretation_ids

    def add(self, node_hashes: List[str], interpretation: Dict, author: str, confidence: float = 0.5) -> str:
        int_id = str(uuid.uuid4())
        timestamp = datetime.utcnow().isoformat() + "Z"
        int_data = {
            "id": int_id,
            "timestamp": timestamp,
            "author": author,
            "confidence": confidence,
            "interpretation": interpretation,
            "node_hashes": node_hashes
        }
        # Store as separate file
        path = os.path.join(self.storage_path, f"{int_id}.json")
        with open(path, 'w') as f:
            json.dump(int_data, f, indent=2)
        for nh in node_hashes:
            self.interpretations[nh].append(int_id)
        return int_id

    def get_interpretations(self, node_hash: str) -> List[Dict]:
        ints = []
        for int_id in self.interpretations.get(node_hash, []):
            path = os.path.join(self.storage_path, f"{int_id}.json")
            if os.path.exists(path):
                with open(path, 'r') as f:
                    ints.append(json.load(f))
        return ints

# ========================== SUPPRESSION HIERARCHY ==========================

class SuppressionHierarchy:
    """Four-layer hierarchy of suppression lenses"""
    def __init__(self):
        self.lenses = self._build_lenses()
        self.methods = self._build_methods()

    def _build_lenses(self) -> List[SuppressionLens]:
        # 70+ lenses from the original specification
        lenses_data = [
            (1, "Threat→Response→Control", "Manufacture threat, offer salvation", "Narrative Capture", "Priest-King"),
            (2, "Sacred Geometry Weaponized", "Architecture as control", "Fragmentation", "Priest-King"),
            (3, "Language Inversions", "Ridicule, gatekeeping", "Misdirection", "Oracle-Priest"),
            (4, "Crisis→Consent→Surveillance", "Use crisis to expand surveillance", "Access Control", "Imperial Ruler"),
            (5, "Divide and Fragment", "Create internal conflict", "Fragmentation", "Slave Master"),
            (6, "Blame the Victim", "Reverse responsibility", "Discreditation", "Slave Master"),
            (7, "Narrative Capture through Expertise", "Experts define truth", "Narrative Capture", "Expert Technocrat"),
            (8, "Information Saturation", "Overwhelm with data", "Saturation", "Algorithmic Curator"),
            (9, "Historical Revisionism", "Rewrite past", "Erasure", "Imperial Ruler"),
            (10, "Institutional Capture", "Control the institution", "Access Control", "Corporate Overlord"),
            (11, "Access Control via Credentialing", "Licensing as gate", "Access Control", "Expert Technocrat"),
            (12, "Temporal Displacement", "Delay, postpone", "Temporal", "Financial Master"),
            (13, "Moral Equivalence", "Both sides are same", "Misdirection", "Digital Messiah"),
            (14, "Whataboutism", "Deflection", "Misdirection", "Algorithmic Curator"),
            (15, "Ad Hominem", "Attack person", "Discreditation", "Slave Master"),
            (16, "Straw Man", "Misrepresent", "Misdirection", "Expert Technocrat"),
            (17, "False Dichotomy", "Only two options", "Misdirection", "Corporate Overlord"),
            (18, "Slippery Slope", "Exaggerated consequences", "Conditioning", "Priest-King"),
            (19, "Appeal to Authority", "Authority decides", "Narrative Capture", "Priest-King"),
            (20, "Appeal to Nature", "Natural = good", "Conditioning", "Oracle-Priest"),
            (21, "Appeal to Tradition", "Always been this way", "Conditioning", "Imperial Ruler"),
            (22, "Appeal to Novelty", "New = better", "Conditioning", "Digital Messiah"),
            (23, "Cherry Picking", "Selective evidence", "Erasure", "Algorithmic Curator"),
            (24, "Moving the Goalposts", "Change criteria", "Misdirection", "Financial Master"),
            (25, "Burden of Proof Reversal", "You prove negative", "Misdirection", "Expert Technocrat"),
            (26, "Circular Reasoning", "Begging question", "Narrative Capture", "Oracle-Priest"),
            (27, "Special Pleading", "Exception for me", "Fragmentation", "Corporate Overlord"),
            (28, "Loaded Question", "Presupposes guilt", "Misdirection", "Slave Master"),
            (29, "No True Scotsman", "Redefine group", "Fragmentation", "Digital Messiah"),
            (30, "Texas Sharpshooter", "Pattern from noise", "Misdirection", "Algorithmic Curator"),
            (31, "Middle Ground Fallacy", "Compromise = truth", "Misdirection", "Expert Technocrat"),
            (32, "Black-and-White Thinking", "Extremes only", "Fragmentation", "Imperial Ruler"),
            (33, "Fear Mongering", "Exaggerate threat", "Conditioning", "Priest-King"),
            (34, "Flattery", "Ingratiate", "Conditioning", "Digital Messiah"),
            (35, "Guilt by Association", "Link to negative", "Discreditation", "Slave Master"),
            (36, "Transfer", "Associate with symbol", "Narrative Capture", "Priest-King"),
            (37, "Testimonial", "Use celebrity", "Conditioning", "Corporate Overlord"),
            (38, "Plain Folks", "Just like you", "Conditioning", "Digital Messiah"),
            (39, "Bandwagon", "Everyone does it", "Conditioning", "Algorithmic Curator"),
            (40, "Snob Appeal", "Elite use it", "Conditioning", "Financial Master"),
            (41, "Glittering Generalities", "Vague virtue words", "Narrative Capture", "Priest-King"),
            (42, "Name-Calling", "Label negatively", "Discreditation", "Slave Master"),
            (43, "Card Stacking", "Selective facts", "Erasure", "Algorithmic Curator"),
            (44, "Euphemisms", "Mild language", "Misdirection", "Corporate Overlord"),
            (45, "Dysphemisms", "Harsh language", "Discreditation", "Slave Master"),
            (46, "Weasel Words", "Vague claims", "Misdirection", "Expert Technocrat"),
            (47, "Thought-Terminating Cliché", "Ends discussion", "Conditioning", "Digital Messiah"),
            (48, "Proof by Intimidation", "Force agreement", "Access Control", "Imperial Ruler"),
            (49, "Proof by Verbosity", "Overwhelm with words", "Saturation", "Algorithmic Curator"),
            (50, "Sealioning", "Persistent badgering", "Attrition", "Slave Master"),
            (51, "Gish Gallop", "Many weak arguments", "Saturation", "Expert Technocrat"),
            (52, "JAQing Off", "Just asking questions", "Misdirection", "Algorithmic Curator"),
            (53, "Nutpicking", "Focus on extreme", "Fragmentation", "Digital Messiah"),
            (54, "Concern Trolling", "Fake concern", "Misdirection", "Corporate Overlord"),
            (55, "Gaslighting", "Deny reality", "Erasure", "Imperial Ruler"),
            (56, "Kafkatrapping", "Guilt if deny", "Conditioning", "Priest-King"),
            (57, "Brandolini's Law", "Bullshit asymmetry", "Saturation", "Algorithmic Curator"),
            (58, "Occam's Razor", "Simplest explanation", "Misdirection", "Expert Technocrat"),
            (59, "Hanlon's Razor", "Never attribute to malice", "Misdirection", "Expert Technocrat"),
            (60, "Hitchens's Razor", "Asserted without evidence", "Erasure", "Expert Technocrat"),
            (61, "Popper's Falsification", "Must be falsifiable", "Access Control", "Expert Technocrat"),
            (62, "Sagan's Standard", "Extraordinary claims", "Access Control", "Expert Technocrat"),
            (63, "Newton's Flaming Laser Sword", "Not empirically testable", "Access Control", "Expert Technocrat"),
            (64, "Alder's Razor", "Cannot be settled by philosophy", "Access Control", "Expert Technocrat"),
            (65, "Grice's Maxims", "Conversational norms", "Fragmentation", "Oracle-Priest"),
            (66, "Poe's Law", "Parody indistinguishable", "Misdirection", "Digital Messiah"),
            (67, "Sturgeon's Law", "90% is crap", "Discreditation", "Slave Master"),
            (68, "Betteridge's Law", "Headline question = no", "Misdirection", "Algorithmic Curator"),
            (69, "Godwin's Law", "Comparison to Nazis", "Discreditation", "Slave Master"),
            (70, "Skoptsy Syndrome", "Self-harm to avoid sin", "Conditioning", "Priest-King")
        ]
        return [SuppressionLens(id, name, f"Lens {id}: {name}", mechanism, archetype) 
                for id, name, mechanism, archetype, _ in [(l[0], l[1], l[2], l[3], "Ancient") for l in lenses_data]]

    def _build_methods(self) -> Dict[int, SuppressionMethod]:
        methods = {
            1: SuppressionMethod(1, "Total Erasure", Primitive.ERASURE, ["entity_present_then_absent"], ["entity_disappearance"], {"time_window": 30}),
            2: SuppressionMethod(2, "Soft Erasure", Primitive.ERASURE, ["gradual_fading"], ["citation_decay"], {"decay_rate": 0.1}),
            3: SuppressionMethod(3, "Citation Decay", Primitive.ERASURE, ["decreasing_citations"], ["citation_count"], {"threshold": 0.5}),
            4: SuppressionMethod(4, "Index Removal", Primitive.ERASURE, ["missing_from_indices"], ["search_visibility"], {"present": False}),
            5: SuppressionMethod(5, "Selective Retention", Primitive.ERASURE, ["archival_gaps"], ["archive_completeness"], {"gap_days": 365}),
            10: SuppressionMethod(10, "Narrative Seizure", Primitive.NARRATIVE_CAPTURE, ["single_explanation"], ["narrative_diversity"], {"max_explanations": 1}),
            12: SuppressionMethod(12, "Official Story", Primitive.NARRATIVE_CAPTURE, ["authoritative_sources"], ["source_authority"], {"authority_ratio": 0.9}),
            14: SuppressionMethod(14, "Temporal Gaps", Primitive.TEMPORAL, ["publication_gap"], ["time_lag"], {"gap_days": 90}),
            15: SuppressionMethod(15, "Latency Spikes", Primitive.TEMPORAL, ["delayed_reporting"], ["response_time"], {"latency_seconds": 3600}),
            17: SuppressionMethod(17, "Smear Campaign", Primitive.DISCREDITATION, ["ad_hominem_attacks"], ["personal_attacks"], {"frequency": 0.3}),
            23: SuppressionMethod(23, "Whataboutism", Primitive.MISDIRECTION, ["deflection"], ["topic_shift"], {"shift_rate": 0.5}),
            43: SuppressionMethod(43, "Conditioning", Primitive.CONDITIONING, ["repetitive_messaging"], ["message_repetition"], {"repeat_count": 10})
        }
        return methods

    def get_lens(self, lens_id: int) -> Optional[SuppressionLens]:
        for l in self.lenses:
            if l.id == lens_id:
                return l
        return None

    def get_method(self, method_id: int) -> Optional[SuppressionMethod]:
        return self.methods.get(method_id)

    def map_signature_to_method(self, signature: str) -> Optional[Dict]:
        for mid, method in self.methods.items():
            if signature in method.observable_signatures:
                return {"method_id": mid, "method_name": method.name, "primitive": method.primitive.value}
        return None

    def get_lenses_for_primitive(self, primitive: Primitive) -> List[int]:
        # Mapping from primitive to lens IDs (simplified)
        mapping = {
            Primitive.ERASURE: [1, 4, 9, 23, 43, 55, 60],
            Primitive.INTERRUPTION: [10, 12, 14, 15],
            Primitive.FRAGMENTATION: [2, 5, 27, 29, 32, 53, 65],
            Primitive.NARRATIVE_CAPTURE: [1, 7, 19, 26, 36, 41],
            Primitive.MISDIRECTION: [3, 13, 14, 16, 17, 24, 25, 28, 30, 31, 44, 46, 52, 54, 58, 59, 66, 68],
            Primitive.SATURATION: [8, 49, 51, 57],
            Primitive.DISCREDITATION: [6, 15, 35, 42, 45, 67, 69],
            Primitive.ATTRITION: [50],
            Primitive.ACCESS_CONTROL: [4, 11, 48, 61, 62, 63, 64],
            Primitive.TEMPORAL: [12, 14],
            Primitive.CONDITIONING: [18, 20, 21, 22, 33, 34, 37, 38, 39, 40, 47, 56, 70],
            Primitive.META: [58, 59, 60, 61, 62, 63, 64]
        }
        return mapping.get(primitive, [])

# ========================== HIERARCHICAL DETECTOR ==========================

class HierarchicalDetector:
    def __init__(self, hierarchy: SuppressionHierarchy, ledger: Ledger, separator: Separator):
        self.hierarchy = hierarchy
        self.ledger = ledger
        self.separator = separator

    def detect_from_ledger(self) -> Dict[str, Any]:
        """Scan ledger nodes for suppression signatures"""
        results = {
            "total_nodes": len(self.ledger.index),
            "suppression_signatures": [],
            "primitives_detected": defaultdict(int),
            "lenses_applied": [],
            "evidence_found": 0
        }
        # For each node hash, try to get node and analyze
        for node_hash, block_ids in self.ledger.index.items():
            node = self.ledger.get_node(node_hash)
            if not node:
                continue
            # Simple heuristic: check for disappearance patterns
            if node.get("type") == "document":
                # Look for abrupt disappearance in timeline (simplified)
                # In real implementation, we'd compare with previous nodes
                results["suppression_signatures"].append({
                    "node": node_hash,
                    "signature": "entity_present_then_absent",
                    "confidence": 0.3
                })
                results["primitives_detected"]["ERASURE"] += 1
                results["evidence_found"] += 1
        # Add lenses
        for primitive, count in results["primitives_detected"].items():
            prim_enum = Primitive(primitive)
            lens_ids = self.hierarchy.get_lenses_for_primitive(prim_enum)
            for lid in lens_ids:
                lens = self.hierarchy.get_lens(lid)
                if lens:
                    results["lenses_applied"].append(lens.to_dict())
        return results

# ========================== KNOWLEDGE GRAPH ENGINE ==========================

class KnowledgeGraphEngine:
    def __init__(self, ledger: Ledger):
        self.ledger = ledger
        self.graph = defaultdict(lambda: defaultdict(set))  # subject -> predicate -> object

    def add_triple(self, subject: str, predicate: str, object: str, node_hash: str):
        self.graph[subject][predicate].add((object, node_hash))

    def query(self, subject: str = None, predicate: str = None, object: str = None) -> List[Tuple]:
        results = []
        for s, preds in self.graph.items():
            if subject and s != subject:
                continue
            for p, objs in preds.items():
                if predicate and p != predicate:
                    continue
                for o, node_hash in objs:
                    if object and o != object:
                        continue
                    results.append((s, p, o, node_hash))
        return results

    def build_from_ledger(self):
        """Parse nodes and extract triples (simplified)"""
        for node_hash, block_ids in self.ledger.index.items():
            node = self.ledger.get_node(node_hash)
            if node and node.get("type") == "document":
                text = node.get("source", "")
                # Very simple triple extraction: "X is Y" patterns
                import re
                matches = re.findall(r'(\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\s+(is|are|was|were)\s+([^.,;]+)', text)
                for subj, verb, obj in matches:
                    self.add_triple(subj.strip(), verb.strip(), obj.strip(), node_hash)

# ========================== TEMPORAL ANALYSIS ENGINE ==========================

class TemporalAnalysisEngine:
    def __init__(self, ledger: Ledger):
        self.ledger = ledger

    def publication_gaps(self, threshold_days: int = 30) -> List[Dict]:
        """Detect temporal gaps in node publication"""
        timestamps = []
        for block in self.ledger.chain:
            for node in block["nodes"]:
                ts_str = node.get("timestamp")
                if ts_str:
                    try:
                        ts = datetime.fromisoformat(ts_str.replace('Z', '+00:00'))
                        timestamps.append(ts)
                    except:
                        pass
        timestamps.sort()
        gaps = []
        for i in range(1, len(timestamps)):
            delta = (timestamps[i] - timestamps[i-1]).days
            if delta > threshold_days:
                gaps.append({
                    "from": timestamps[i-1].isoformat(),
                    "to": timestamps[i].isoformat(),
                    "gap_days": delta
                })
        return gaps

    def latency_spikes(self, expected_latency_seconds: int = 3600) -> List[Dict]:
        """Detect unusual delays in reporting (simplified)"""
        # In real system, compare event time vs node timestamp
        return []

# ========================== PROBABILISTIC INFERENCE ==========================

class ProbabilisticInference:
    def __init__(self):
        self.priors = defaultdict(float)  # claim_id -> prior probability
        self.evidence = defaultdict(list) # claim_id -> list of (evidence, weight)

    def set_prior(self, claim_id: str, probability: float):
        self.priors[claim_id] = max(0.0, min(1.0, probability))

    def add_evidence(self, claim_id: str, evidence: str, weight: float = 0.5):
        self.evidence[claim_id].append((evidence, weight))

    def compute_posterior(self, claim_id: str) -> float:
        prior = self.priors.get(claim_id, 0.5)
        ev_list = self.evidence.get(claim_id, [])
        if not ev_list:
            return prior
        # Simple Bayesian update assuming independence
        likelihood = 1.0
        for _, w in ev_list:
            likelihood *= (0.5 + w * 0.5)  # scale weight to [0.5,1.0]
        posterior = prior * likelihood / (prior * likelihood + (1-prior)*(1-likelihood))
        return min(1.0, max(0.0, posterior))

# ========================== AI AGENTS ==========================

class IngestionAI:
    def __init__(self, crypto: Crypto):
        self.crypto = crypto

    def process_document(self, text: str, source: str) -> RealityNode:
        node_hash = self.crypto.hash(text + source + str(datetime.utcnow()))
        node = RealityNode(
            hash=node_hash,
            type="document",
            source=source,
            signature="",
            timestamp=datetime.utcnow().isoformat() + "Z",
            witnesses=[],
            refs={}
        )
        node.signature = self.crypto.sign(node_hash.encode(), "ingestion_ai")
        return node

class SymbolismAI:
    def analyze(self, artifact: Dict) -> float:
        """Return a symbolism coefficient (0-1) based on linguistic patterns"""
        text = artifact.get("text", "")
        # Count symbolic words (metaphor, allegory, etc.)
        symbolic_words = ["metaphor", "allegory", "symbol", "represent", "signify", "myth", "archetype"]
        score = sum(1 for w in symbolic_words if w in text.lower()) / max(1, len(symbolic_words))
        return min(1.0, score + 0.3)

class ReasoningAI:
    def __init__(self, inference: ProbabilisticInference):
        self.inference = inference

    def evaluate_claim(self, claim_id: str, nodes: List[RealityNode], detector_result: Dict) -> Dict:
        confidence = 0.5
        if detector_result.get("evidence_found", 0) > 2:
            confidence += 0.2
        self.inference.set_prior(claim_id, confidence)
        if confidence < 0.7:
            return {"spawn_sub": True, "reason": "low confidence", "confidence": confidence}
        else:
            return {"spawn_sub": False, "reason": "sufficient evidence", "confidence": confidence}

# ========================== SAVIOR/SUFFERER MATRIX ==========================

class ConsciousnessMapper:
    async def analyze_consciousness(self) -> Dict[str, Any]:
        # Simulated analysis based on ledger data
        return {
            "awareness_levels": {
                "system_awareness": 0.28,
                "self_enslavement_awareness": 0.15,
                "manipulation_detection": 0.32,
                "liberation_desire": 0.41
            },
            "control_acceptance_patterns": {
                "voluntary_submission": 0.75,
                "aspirational_enslavement": 0.82,
                "fear_based_compliance": 0.68,
                "identity_fusion": 0.79
            },
            "awakening_triggers": {
                "suffering_threshold": 0.58,
                "truth_exposure": 0.72,
                "system_failure": 0.65,
                "consciousness_contact": 0.88
            }
        }

class QuantumControlAnalyzer:
    def __init__(self):
        self.control_matrix = self._initialize_complete_matrix()
        self.consciousness_mapper = ConsciousnessMapper()

    def _initialize_complete_matrix(self) -> CompleteControlMatrix:
        # Historical control systems
        systems = [
            ControlSystem(
                system_id="temple_slavery",
                historical_era="3000-500 BCE",
                control_archetype=ControlArchetype.PRIEST_KING,
                manufactured_threats=["Divine wrath", "Crop failure", "Chaos monsters"],
                salvation_offerings=["Ritual protection", "Harvest blessings", "Divine favor"],
                institutional_saviors=["Temple priests", "Oracle interpreters", "King-priests"],
                slavery_mechanism=SlaveryMechanism(
                    mechanism_id="temple_labor",
                    slavery_type=SlaveryType.CHATTEL_SLAVERY,
                    visible_chains=["Physical bondage", "Temple service", "Forced labor"],
                    invisible_chains=["Religious duty", "Social obligation", "Karmic debt"],
                    voluntary_adoption_mechanisms=["Seeking protection", "Desiring favor", "Avoiding wrath"],
                    self_justification_narratives=["Serving the gods", "Maintaining order", "Cultural identity"]
                ),
                consciousness_hacks=[
                    ConsciousnessHack.SELF_ATTRIBUTION,
                    ConsciousnessHack.NORMALIZATION,
                    ConsciousnessHack.MORAL_SUPERIORITY
                ],
                public_participation_rate=0.95,
                resistance_level=0.1,
                system_longevity=2500
            ),
            ControlSystem(
                system_id="imperial_slavery",
                historical_era="500 BCE - 1500 CE",
                control_archetype=ControlArchetype.IMPERIAL_RULER,
                manufactured_threats=["Barbarian invasions", "Internal rebellion", "Economic collapse"],
                salvation_offerings=["Military protection", "Legal order", "Infrastructure"],
                institutional_saviors=["Emperor", "Legions", "Governors"],
                slavery_mechanism=SlaveryMechanism(
                    mechanism_id="imperial_bondage",
                    slavery_type=SlaveryType.CHATTEL_SLAVERY,
                    visible_chains=["Conquest", "Debt slavery", "Criminal servitude"],
                    invisible_chains=["Patriotism", "Duty to empire", "Honor"],
                    voluntary_adoption_mechanisms=["Seeking protection", "Economic opportunity", "Social advancement"],
                    self_justification_narratives=["Civilizing mission", "Pax Romana", "Glory of empire"]
                ),
                consciousness_hacks=[
                    ConsciousnessHack.ASPIRATIONAL_CHAINS,
                    ConsciousnessHack.NORMALIZATION,
                    ConsciousnessHack.ILLUSION_OF_MOBILITY
                ],
                public_participation_rate=0.85,
                resistance_level=0.2,
                system_longevity=1000
            ),
            ControlSystem(
                system_id="corporate_slavery",
                historical_era="1800-2000 CE",
                control_archetype=ControlArchetype.CORPORATE_OVERLORD,
                manufactured_threats=["Competition", "Market volatility", "Outsiders"],
                salvation_offerings=["Employment", "Consumer goods", "Stock options"],
                institutional_saviors=["CEOs", "Corporations", "Banks"],
                slavery_mechanism=SlaveryMechanism(
                    mechanism_id="wage_slavery",
                    slavery_type=SlaveryType.WAGE_SLAVERY,
                    visible_chains=["Employment contract", "Working hours", "Debt"],
                    invisible_chains=["Career ladder", "Consumer identity", "Retirement promise"],
                    voluntary_adoption_mechanisms=["Need income", "Desire status", "Fear of poverty"],
                    self_justification_narratives=["Free market", "Meritocracy", "Economic growth"]
                ),
                consciousness_hacks=[
                    ConsciousnessHack.ASPIRATIONAL_CHAINS,
                    ConsciousnessHack.ILLUSION_OF_MOBILITY,
                    ConsciousnessHack.MORAL_SUPERIORITY
                ],
                public_participation_rate=0.90,
                resistance_level=0.15,
                system_longevity=200
            ),
            ControlSystem(
                system_id="digital_slavery",
                historical_era="2000-2050 CE",
                control_archetype=ControlArchetype.ALGORITHMIC_CURATOR,
                manufactured_threats=["Privacy loss", "Hackers", "Misinformation"],
                salvation_offerings=["Convenience", "Connectivity", "Personalization"],
                institutional_saviors=["Tech giants", "AI systems", "Platforms"],
                slavery_mechanism=SlaveryMechanism(
                    mechanism_id="digital_bondage",
                    slavery_type=SlaveryType.DIGITAL_SLAVERY,
                    visible_chains=["Terms of service", "Data collection", "Algorithmic feeds"],
                    invisible_chains=["Attention economy", "Social scoring", "Filter bubbles"],
                    voluntary_adoption_mechanisms=["Desire connection", "Fear of missing out", "Habit"],
                    self_justification_narratives=["Innovation", "Free services", "Community"]
                ),
                consciousness_hacks=[
                    ConsciousnessHack.SELF_ATTRIBUTION,
                    ConsciousnessHack.NORMALIZATION,
                    ConsciousnessHack.FEAR_OF_FREEDOM
                ],
                public_participation_rate=0.98,
                resistance_level=0.05,
                system_longevity=50
            )
        ]
        return CompleteControlMatrix(
            control_systems=systems,
            active_systems=["corporate_slavery", "digital_slavery"],
            institutional_evolution={
                "Temple Systems": [ControlArchetype.PRIEST_KING, ControlArchetype.DIVINE_INTERMEDIARY,
                                   ControlArchetype.EXPERT_TECHNOCRAT, ControlArchetype.ALGORITHMIC_CURATOR],
                "Royal Lines": [ControlArchetype.IMPERIAL_RULER, ControlArchetype.CORPORATE_OVERLORD,
                                ControlArchetype.FINANCIAL_MASTER]
            },
            collective_delusions={
                "upward_mobility": 0.85,
                "consumer_freedom": 0.78,
                "technological_progress": 0.82,
                "democratic_choice": 0.65
            },
            freedom_illusions={
                "career_choice": 0.75,
                "consumer_choice": 0.88,
                "information_access": 0.72,
                "political_choice": 0.55
            },
            self_enslavement_patterns={
                "debt_acceptance": 0.82,
                "work_identity": 0.78,
                "consumer_aspiration": 0.85,
                "digital_dependency": 0.79
            }
        )

    async def analyze_complete_control_system(self) -> Dict[str, Any]:
        matrix_analysis = self.control_matrix.analyze_complete_control()
        consciousness_analysis = await self.consciousness_mapper.analyze_consciousness()
        quantum_entanglement = await self._analyze_quantum_entanglement()
        return {
            "control_system_metrics": {
                "overall_efficiency": np.mean([s.calculate_system_efficiency() for s in self.control_matrix.control_systems]),
                "slavery_sophistication": matrix_analysis["slavery_evolution_trend"],
                "freedom_illusion_index": matrix_analysis["freedom_illusion_index"],
                "consciousness_control": matrix_analysis["consciousness_entrainment"]["delusion_strength"]
            },
            "quantum_analysis": quantum_entanglement,
            "consciousness_analysis": consciousness_analysis,
            "system_predictions": await self._predict_system_evolution(),
            "liberation_pathways": await self._analyze_liberation_possibilities()
        }

    async def _analyze_quantum_entanglement(self) -> Dict[str, float]:
        return {
            "savior_slavery_symbiosis": 0.92,
            "consciousness_self_enslavement": 0.88,
            "institutional_metamorphosis": 0.95,
            "freedom_delusion_strength": 0.83
        }

    async def _predict_system_evolution(self) -> List[Dict]:
        return [
            {
                "next_archetype": "Biological Controller",
                "slavery_type": "Genetic Slavery",
                "control_mechanism": "DNA-level programming",
                "consciousness_hack": "Innate desire modification",
                "emergence_timeline": "2030-2050"
            },
            {
                "next_archetype": "Quantum Consciousness Curator",
                "slavery_type": "Reality Slavery",
                "control_mechanism": "Direct neural interface",
                "consciousness_hack": "Self as simulation awareness",
                "emergence_timeline": "2040-2060"
            }
        ]

    async def _analyze_liberation_possibilities(self) -> Dict[str, Any]:
        return {
            "consciousness_awakening_trend": 0.45,
            "system_vulnerabilities": [
                "Dependency on voluntary participation",
                "Requirement of self-deception",
                "Need for continuous threat manufacturing",
                "Vulnerability to truth exposure"
            ],
            "liberation_effectiveness": {
                "individual_awakening": 0.35,
                "collective_action": 0.25,
                "system_collapse": 0.15,
                "evolution_beyond": 0.65
            }
        }

# ========================== HELPER-KILLER MODULE ==========================

class AdvancedHelperKillerEngine:
    def __init__(self, db_path: str = "helper_killer_v2.db"):
        self.db_path = db_path
        self.control_matrix: Optional[ControlMatrix] = None
        self.sovereignty_protocols: Dict[str, Callable] = self._initialize_protocols()
        self._initialize_database()
        self._build_control_matrix()

    def _initialize_database(self):
        try:
            with sqlite3.connect(self.db_path) as conn:
                conn.execute("""
                    CREATE TABLE IF NOT EXISTS entity_analyses (
                        entity_id TEXT PRIMARY KEY,
                        name TEXT,
                        control_layers TEXT,
                        threat_vectors TEXT,
                        market_share REAL,
                        dependency_score REAL,
                        sovereignty_erosion_score REAL,
                        systemic_risk_level REAL,
                        analyzed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
                    )
                """)
                conn.execute("""
                    CREATE TABLE IF NOT EXISTS sovereignty_recommendations (
                        recommendation_id TEXT PRIMARY KEY,
                        entity_id TEXT,
                        threat_level TEXT,
                        mitigation_strategy TEXT,
                        sovereignty_preservation_score REAL,
                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
                    )
                """)
        except Exception as e:
            logger.error(f"Database initialization error: {e}")

    def _initialize_protocols(self) -> Dict[str, Callable]:
        return {
            "digital_infrastructure": self._digital_sovereignty_protocol,
            "financial_systems": self._financial_sovereignty_protocol,
            "information_channels": self._information_sovereignty_protocol,
            "cultural_narratives": self._cultural_sovereignty_protocol,
            "identity_systems": self._identity_sovereignty_protocol
        }

    def _build_control_matrix(self):
        entities = [
            InstitutionalEntity(
                entity_id="alphabet_google",
                name="Alphabet/Google",
                control_layers=[
                    ControlLayer.DIGITAL_INFRASTRUCTURE,
                    ControlLayer.INFORMATION_CHANNELS
                ],
                threat_vectors=[
                    ThreatVector.MONOPOLY_CAPTURE,
                    ThreatVector.DEPENDENCY_CREATION,
                    ThreatVector.BEHAVIORAL_SHAPING,
                    ThreatVector.DATA_MONETIZATION,
                    ThreatVector.NARRATIVE_CONTROL
                ],
                market_share=0.85,
                dependency_score=0.90
            ),
            InstitutionalEntity(
                entity_id="binance_financial",
                name="Binance/CBDC Infrastructure",
                control_layers=[
                    ControlLayer.FINANCIAL_SYSTEMS,
                    ControlLayer.IDENTITY_SYSTEMS
                ],
                threat_vectors=[
                    ThreatVector.MONOPOLY_CAPTURE,
                    ThreatVector.DEPENDENCY_CREATION,
                    ThreatVector.BEHAVIORAL_SHAPING
                ],
                market_share=0.70,
                dependency_score=0.75
            ),
            InstitutionalEntity(
                entity_id="social_media_complex",
                name="Social Media/TikTok Complex",
                control_layers=[
                    ControlLayer.INFORMATION_CHANNELS,
                    ControlLayer.CULTURAL_NARRATIVES
                ],
                threat_vectors=[
                    ThreatVector.DEPENDENCY_CREATION,
                    ThreatVector.BEHAVIORAL_SHAPING,
                    ThreatVector.DATA_MONETIZATION,
                    ThreatVector.NARRATIVE_CONTROL
                ],
                market_share=0.80,
                dependency_score=0.85
            )
        ]
        interconnections = {
            "alphabet_google": ["binance_financial", "social_media_complex"],
            "binance_financial": ["alphabet_google"],
            "social_media_complex": ["alphabet_google"]
        }
        self.control_matrix = ControlMatrix(entities, interconnections)
        logger.info(f"Helper-Killer control matrix built with {len(entities)} entities")

    async def analyze_help_offer(self, help_context: Dict[str, Any]) -> Dict[str, Any]:
        entity_analysis = self._identify_controlling_entity(help_context)
        threat_assessment = self._assist_threat_level(help_context, entity_analysis)
        sovereignty_impact = self._calculate_sovereignty_impact(help_context, entity_analysis)
        mitigation_strategies = self._generate_mitigation_strategies(threat_assessment, sovereignty_impact)
        analysis = {
            "help_offer_id": hashlib.sha256(json.dumps(help_context).encode()).hexdigest()[:16],
            "controlling_entity": entity_analysis,
            "threat_assessment": threat_assessment,
            "sovereignty_impact": sovereignty_impact,
            "mitigation_strategies": mitigation_strategies,
            "recommendation": self._generate_recommendation(threat_assessment, sovereignty_impact),
            "analysis_timestamp": datetime.now().isoformat()
        }
        await self._store_analysis(analysis)
        return analysis

    def _identify_controlling_entity(self, help_context: Dict) -> Optional[Dict[str, Any]]:
        if not self.control_matrix:
            return None
        for entity in self.control_matrix.entities:
            context_layers = set(help_context.get('affected_layers', []))
            entity_layers = set(layer.value for layer in entity.control_layers)
            if context_layers.intersection(entity_layers):
                return {
                    'entity_id': entity.entity_id,
                    'name': entity.name,
                    'sovereignty_erosion_score': entity.sovereignty_erosion_score,
                    'systemic_risk_level': entity.systemic_risk_level
                }
        return None

    def _assist_threat_level(self, help_context: Dict, entity_analysis: Optional[Dict]) -> Dict[str, float]:
        base_threat = 0.3
        if entity_analysis:
            entity_threat = entity_analysis['sovereignty_erosion_score'] * 0.6
            systemic_risk = entity_analysis['systemic_risk_level'] * 0.4
            base_threat = max(base_threat, entity_threat + systemic_risk)
        if help_context.get('creates_dependency', False):
            base_threat += 0.3
        if help_context.get('data_collection', False):
            base_threat += 0.2
        if help_context.get('behavioral_tracking', False):
            base_threat += 0.25
        return {
            'helper_killer_coefficient': min(1.0, base_threat),
            'dependency_risk': help_context.get('dependency_risk', 0.5),
            'privacy_impact': help_context.get('privacy_impact', 0.5),
            'agency_reduction': help_context.get('agency_reduction', 0.5)
        }

    def _calculate_sovereignty_impact(self, help_context: Dict, entity_analysis: Optional[Dict]) -> Dict[str, float]:
        if entity_analysis:
            base_impact = entity_analysis['sovereignty_erosion_score']
        else:
            base_impact = 0.5
        modifiers = {
            'data_control_loss': help_context.get('data_control', 0) * 0.3,
            'decision_autonomy_loss': help_context.get('autonomy_reduction', 0) * 0.4,
            'external_dependency_increase': help_context.get('dependency_creation', 0) * 0.3
        }
        total_impact = base_impact * 0.4 + sum(modifiers.values()) * 0.6
        return {
            'sovereignty_reduction_score': min(1.0, total_impact),
            'autonomy_loss': modifiers['decision_autonomy_loss'],
            'dependency_increase': modifiers['external_dependency_increase'],
            'privacy_loss': modifiers['data_control_loss']
        }

    def _generate_mitigation_strategies(self, threat: Dict, impact: Dict) -> List[Dict]:
        strategies = []
        threat_level = threat['helper_killer_coefficient']
        if threat_level > 0.7:
            strategies.extend([
                {'strategy': 'COMPLETE_AVOIDANCE', 'effectiveness': 0.95, 'implementation_cost': 0.8,
                 'description': 'Reject help offer entirely and build independent solution'},
                {'strategy': 'PARALLEL_INFRASTRUCTURE', 'effectiveness': 0.85, 'implementation_cost': 0.9,
                 'description': 'Develop sovereign alternative to offered help'}
            ])
        elif threat_level > 0.4:
            strategies.extend([
                {'strategy': 'LIMITED_ENGAGEMENT', 'effectiveness': 0.70, 'implementation_cost': 0.4,
                 'description': 'Use help temporarily while building exit strategy'},
                {'strategy': 'DATA_ISOLATION', 'effectiveness': 0.60, 'implementation_cost': 0.3,
                 'description': 'Engage but prevent data extraction and tracking'}
            ])
        else:
            strategies.append({
                'strategy': 'CAUTIOUS_ACCEPTANCE', 'effectiveness': 0.50, 'implementation_cost': 0.2,
                'description': 'Accept with awareness and monitoring for sovereignty erosion'
            })
        return strategies

    def _generate_recommendation(self, threat: Dict, impact: Dict) -> str:
        level = threat['helper_killer_coefficient']
        if level > 0.8:
            return "IMMEDIATE_REJECTION_AND_SOVEREIGN_BUILDING"
        elif level > 0.6:
            return "STRATEGIC_AVOIDANCE_WITH_EXIT_PROTOCOL"
        elif level > 0.4:
            return "LIMITED_CONDITIONAL_ACCEPTANCE"
        else:
            return "MONITORED_ACCEPTANCE"

    async def _store_analysis(self, analysis: Dict):
        try:
            with sqlite3.connect(self.db_path) as conn:
                if analysis['controlling_entity']:
                    ce = analysis['controlling_entity']
                    conn.execute("""
                        INSERT OR REPLACE INTO entity_analyses
                        (entity_id, name, control_layers, threat_vectors, market_share, dependency_score,
                         sovereignty_erosion_score, systemic_risk_level)
                        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
                    """, (
                        ce['entity_id'], ce['name'],
                        json.dumps([]), json.dumps([]), 0.0, 0.0,
                        ce['sovereignty_erosion_score'], ce['systemic_risk_level']
                    ))
                conn.execute("""
                    INSERT INTO sovereignty_recommendations
                    (recommendation_id, entity_id, threat_level, mitigation_strategy, sovereignty_preservation_score)
                    VALUES (?, ?, ?, ?, ?)
                """, (
                    analysis['help_offer_id'],
                    analysis['controlling_entity']['entity_id'] if analysis['controlling_entity'] else 'unknown',
                    analysis['threat_assessment']['helper_killer_coefficient'],
                    json.dumps(analysis['mitigation_strategies']),
                    1.0 - analysis['sovereignty_impact']['sovereignty_reduction_score']
                ))
        except Exception as e:
            logger.error(f"Analysis storage error: {e}")

    def _digital_sovereignty_protocol(self, entity: Optional[InstitutionalEntity]) -> List[str]:
        return ["USE_OPEN_SOURCE_ALTERNATIVES", "DEPLOY_GASLESS_BLOCKCHAIN_INFRASTRUCTURE",
                "MAINTAIN_LOCAL_DATA_STORAGE", "USE_DECENTRALIZED_COMMUNICATION_PROTOCOLS"]

    def _financial_sovereignty_protocol(self, entity: Optional[InstitutionalEntity]) -> List[str]:
        return ["USE_PRIVACY_COINS_FOR_TRANSACTIONS", "MAINTAIN_OFFLINE_SAVINGS",
                "DEVELOP_SOVEREIGN_INCOME_STREAMS", "USE_DECENTRALIZED_EXCHANGES"]

    def _information_sovereignty_protocol(self, entity: Optional[InstitutionalEntity]) -> List[str]:
        return ["USE_INDEPENDENT_NEWS_SOURCES", "MAINTAIN_PERSONAL_KNOWLEDGE_BASE",
                "PRACTICE_INFORMATION_VERIFICATION", "BUILD_TRUST_NETWORKS"]

    def _cultural_sovereignty_protocol(self, entity: Optional[InstitutionalEntity]) -> List[str]:
        return ["CREATE_INDEPENDENT_ART_AND_CONTENT", "PARTICIPATE_IN_LOCAL_COMMUNITY",
                "PRACTICE_CRITICAL_MEDIA_CONSUMPTION", "DEVELOP_PERSONAL_PHILOSOPHICAL_FRAMEWORK"]

    def _identity_sovereignty_protocol(self, entity: Optional[InstitutionalEntity]) -> List[str]:
        return ["MAINTAIN_OFFLINE_IDENTITY_DOCUMENTS", "USE_PSEUDONYMOUS_ONLINE_IDENTITIES",
                "PRACTICE_DIGITAL_HYGIENE", "DEVELOP_SOVEREIGN_REPUTATION_SYSTEMS"]

    async def generate_systemic_report(self) -> Dict[str, Any]:
        if not self.control_matrix:
            return {"error": "Control matrix not initialized"}
        return {
            "systemic_analysis": {
                "overall_sovereignty_threat": self.control_matrix.overall_sovereignty_threat,
                "institutional_coordination_score": self.control_matrix.coordination_score,
                "top_threat_entities": sorted(
                    [(e.name, e.sovereignty_erosion_score) for e in self.control_matrix.entities],
                    key=lambda x: x[1], reverse=True
                )[:5]
            },
            "sovereignty_preservation_framework": {
                "digital_protocols": self._digital_sovereignty_protocol(None),
                "financial_protocols": self._financial_sovereignty_protocol(None),
                "information_protocols": self._information_sovereignty_protocol(None),
                "cultural_protocols": self._cultural_sovereignty_protocol(None),
                "identity_protocols": self._identity_sovereignty_protocol(None)
            },
            "recommendation_tier": self._calculate_systemic_recommendation()
        }

    def _calculate_systemic_recommendation(self) -> str:
        if not self.control_matrix:
            return "INSUFFICIENT_DATA"
        threat = self.control_matrix.overall_sovereignty_threat
        if threat > 0.8:
            return "IMMEDIATE_SOVEREIGN_INFRASTRUCTURE_DEPLOYMENT"
        elif threat > 0.6:
            return "ACCELERATED_SOVEREIGN_TRANSITION"
        elif threat > 0.4:
            return "STRATEGIC_SOVEREIGN_PREPARATION"
        else:
            return "MAINTAIN_SOVEREIGN_AWARENESS"

# ========================== SOVEREIGN COHERENCE LEDGER (no external grounding) ==========================

class SovereignCoherenceLedger:
    """Internal ledger for claim coherence – no external APIs, no Wikipedia."""
    def __init__(self, path: str = "sovereign_coherence.json"):
        self.path = path
        self.claims: Dict[str, Dict] = {}          # claim_id -> {text, timestamp, entities, coherence_score, contradictions}
        self.entities: Dict[str, Dict] = {}        # entity -> {appearances, suppression_score}
        self.contradiction_graph: Dict[str, Set[str]] = defaultdict(set)
        self._load()

    def _load(self):
        if os.path.exists(self.path):
            try:
                with open(self.path, 'r') as f:
                    data = json.load(f)
                    self.claims = data.get("claims", {})
                    self.entities = data.get("entities", {})
                    cg = data.get("contradiction_graph", {})
                    self.contradiction_graph = {k: set(v) for k, v in cg.items()}
            except Exception:
                pass

    def _save(self):
        cg_serializable = {k: list(v) for k, v in self.contradiction_graph.items()}
        data = {
            "claims": self.claims,
            "entities": self.entities,
            "contradiction_graph": cg_serializable,
            "updated": datetime.utcnow().isoformat() + "Z"
        }
        with open(self.path + ".tmp", 'w') as f:
            json.dump(data, f, indent=2)
        os.replace(self.path + ".tmp", self.path)

    def add_claim(self, text: str, agent: str = "user") -> str:
        claim_id = secrets.token_hex(16)
        entities = self._extract_entities(text)
        self.claims[claim_id] = {
            "id": claim_id,
            "text": text,
            "agent": agent,
            "timestamp": datetime.utcnow().isoformat() + "Z",
            "entities": entities,
            "coherence_score": 0.5,   # will be updated
            "contradictions": [],
            "suppression_score": 0.0,
            "signatures": []
        }
        # Update entity index
        for ent in entities:
            if ent not in self.entities:
                self.entities[ent] = {"appearances": [], "suppression_score": 0.0, "first_seen": self.claims[claim_id]["timestamp"]}
            self.entities[ent]["appearances"].append(claim_id)
            self.entities[ent]["last_seen"] = self.claims[claim_id]["timestamp"]
        self._save()
        return claim_id

    def _extract_entities(self, text: str) -> List[str]:
        """Simple proper noun extraction – no external dictionaries."""
        pattern = r'\b[A-Z][a-z]*(?:\s+[A-Z][a-z]*)*\b'
        matches = re.findall(pattern, text)
        stop = {"The", "This", "That", "These", "Those", "I", "We", "They", "He", "She", "It", "You"}
        return [m for m in matches if m not in stop and len(m) > 1]

    def add_contradiction(self, claim_id_a: str, claim_id_b: str):
        """User-defined contradiction between two claims."""
        self.contradiction_graph[claim_id_a].add(claim_id_b)
        self.contradiction_graph[claim_id_b].add(claim_id_a)
        if claim_id_b not in self.claims[claim_id_a]["contradictions"]:
            self.claims[claim_id_a]["contradictions"].append(claim_id_b)
        if claim_id_a not in self.claims[claim_id_b]["contradictions"]:
            self.claims[claim_id_b]["contradictions"].append(claim_id_a)
        self._update_coherence(claim_id_a)
        self._update_coherence(claim_id_b)
        self._save()

    def _update_coherence(self, claim_id: str):
        """Coherence = 1 - (number of contradictions / total claims in system)"""
        claim = self.claims.get(claim_id)
        if not claim:
            return
        num_contradictions = len(claim["contradictions"])
        total_claims = len(self.claims)
        if total_claims <= 1:
            claim["coherence_score"] = 1.0
        else:
            claim["coherence_score"] = 1.0 - min(1.0, num_contradictions / total_claims)

    def add_suppression_signature(self, claim_id: str, signature: str, weight: float = 0.5):
        claim = self.claims.get(claim_id)
        if not claim:
            return
        if signature not in claim["signatures"]:
            claim["signatures"].append(signature)
        # Update suppression score: 1 - product(1 - weight_i)
        combined = 1.0
        for sig in claim["signatures"]:
            w = weight if sig == signature else 0.5  # simplified
            combined *= (1 - w)
        claim["suppression_score"] = 1 - combined
        # Update entity suppression scores
        for ent in claim["entities"]:
            ent_data = self.entities.get(ent)
            if ent_data:
                ent_combined = 1.0
                for cid in ent_data["appearances"]:
                    sc = self.claims[cid].get("suppression_score", 0.0)
                    ent_combined *= (1 - sc)
                ent_data["suppression_score"] = 1 - ent_combined
        self._save()

    def get_contradiction_network(self, claim_id: str, depth: int = 2) -> Dict:
        """Return a graph of contradictions up to depth."""
        visited = set()
        graph = {}
        def dfs(cid, d):
            if d > depth or cid in visited:
                return
            visited.add(cid)
            graph[cid] = list(self.contradiction_graph.get(cid, []))
            for other in graph[cid]:
                dfs(other, d+1)
        dfs(claim_id, 0)
        return graph

    def get_entity_suppression(self, entity_name: str) -> Dict:
        ent = self.entities.get(entity_name)
        if not ent:
            return {"name": entity_name, "score": 0.0, "appearances": 0}
        return {
            "name": entity_name,
            "score": ent.get("suppression_score", 0.0),
            "appearances": len(ent["appearances"]),
            "first_seen": ent.get("first_seen"),
            "last_seen": ent.get("last_seen")
        }

    def get_claim(self, claim_id: str) -> Optional[Dict]:
        return self.claims.get(claim_id)

    def list_claims(self, limit: int = 100) -> List[Dict]:
        return list(self.claims.values())[-limit:]

# ========================== ENHANCED AI CONTROLLER ==========================

class AIController:
    def __init__(self, ledger: Ledger, separator: Separator, detector: HierarchicalDetector,
                 kg: KnowledgeGraphEngine, temporal: TemporalAnalysisEngine, inference: ProbabilisticInference,
                 ingestion_ai: IngestionAI, symbolism_ai: SymbolismAI, reasoning_ai: ReasoningAI,
                 quantum_analyzer: QuantumControlAnalyzer, helper_killer: AdvancedHelperKillerEngine,
                 coherence_ledger: SovereignCoherenceLedger):
        self.ledger = ledger
        self.separator = separator
        self.detector = detector
        self.kg = kg
        self.temporal = temporal
        self.inference = inference
        self.ingestion_ai = ingestion_ai
        self.symbolism_ai = symbolism_ai
        self.reasoning_ai = reasoning_ai
        self.quantum_analyzer = quantum_analyzer
        self.helper_killer = helper_killer
        self.coherence_ledger = coherence_ledger
        self.contexts = {}  # correlation_id -> investigation context

    def submit_claim(self, claim_text: str) -> str:
        corr_id = str(uuid.uuid4())
        # Add to coherence ledger
        claim_id = self.coherence_ledger.add_claim(claim_text, agent="user")
        context = {
            "correlation_id": corr_id,
            "coherence_claim_id": claim_id,
            "parent_id": None,
            "claim": claim_text,
            "status": "pending",
            "created": datetime.utcnow().isoformat() + "Z",
            "evidence_nodes": [],
            "sub_investigations": [],
            "results": {}
        }
        self.contexts[corr_id] = context
        thread = threading.Thread(target=self._investigate, args=(corr_id,))
        thread.start()
        return corr_id

    def _investigate(self, corr_id: str):
        context = self.contexts[corr_id]
        context["status"] = "active"
        try:
            # Run detector on immutable ledger
            detection = self.detector.detect_from_ledger()
            # Build knowledge graph
            self.kg.build_from_ledger()
            # Temporal gaps
            gaps = self.temporal.publication_gaps()
            # Evaluate claim with reasoning AI
            decision = self.reasoning_ai.evaluate_claim(corr_id, [], detection)
            if decision.get("spawn_sub"):
                sub_id = str(uuid.uuid4())
                context["sub_investigations"].append(sub_id)
                # In production, spawn sub-investigation
            # Run quantum control analysis
            loop = asyncio.new_event_loop()
            asyncio.set_event_loop(loop)
            quantum_result = loop.run_until_complete(self.quantum_analyzer.analyze_complete_control_system())
            loop.close()
            # Compute coherence from the sovereign ledger
            claim_id = context["coherence_claim_id"]
            claim_data = self.coherence_ledger.get_claim(claim_id)
            coherence_score = claim_data.get("coherence_score", 0.5) if claim_data else 0.5
            suppression_score = claim_data.get("suppression_score", 0.0) if claim_data else 0.0
            # Store interpretation in separator
            interpretation = {
                "narrative": "Claim evaluated with full meta-analysis",
                "symbolism_coefficient": self.symbolism_ai.analyze({"text": context["claim"]}),
                "detection_summary": detection,
                "quantum_analysis": quantum_result,
                "temporal_gaps": gaps,
                "coherence_score": coherence_score,
                "suppression_score": suppression_score
            }
            node_hashes = []
            int_id = self.separator.add(node_hashes, interpretation, "AI_Controller", confidence=coherence_score)
            context["results"] = {
                "confidence": coherence_score,
                "interpretation_id": int_id,
                "detection": detection,
                "quantum": quantum_result,
                "coherence_score": coherence_score,
                "suppression_score": suppression_score
            }
            context["status"] = "complete"
        except Exception as e:
            logger.error(f"Investigation {corr_id} failed: {e}")
            context["status"] = "failed"
            context["error"] = str(e)

    def get_status(self, corr_id: str) -> Dict:
        return self.contexts.get(corr_id, {"error": "not found"})

    def add_contradiction(self, claim_id_a: str, claim_id_b: str):
        """Manually mark two claims as contradictory."""
        self.coherence_ledger.add_contradiction(claim_id_a, claim_id_b)

    def add_suppression_signature(self, claim_id: str, signature: str, weight: float = 0.5):
        self.coherence_ledger.add_suppression_signature(claim_id, signature, weight)

# ========================== FLASK API ==========================

app = Flask(__name__)
controller: Optional[AIController] = None

@app.route('/api/v1/submit_claim', methods=['POST'])
def submit_claim():
    data = request.get_json()
    claim = data.get('claim')
    if not claim:
        return jsonify({"error": "Missing claim"}), 400
    corr_id = controller.submit_claim(claim)
    return jsonify({"investigation_id": corr_id})

@app.route('/api/v1/investigation/<corr_id>', methods=['GET'])
def get_investigation(corr_id):
    status = controller.get_status(corr_id)
    return jsonify(status)

@app.route('/api/v1/node/<node_hash>', methods=['GET'])
def get_node(node_hash):
    node = controller.ledger.get_node(node_hash)
    if not node:
        return jsonify({"error": "Node not found"}), 404
    return jsonify(node)

@app.route('/api/v1/interpretations/<node_hash>', methods=['GET'])
def get_interpretations(node_hash):
    ints = controller.separator.get_interpretations(node_hash)
    return jsonify(ints)

@app.route('/api/v1/detect', methods=['GET'])
def run_detection():
    result = controller.detector.detect_from_ledger()
    return jsonify(result)

@app.route('/api/v1/analyze_help_offer', methods=['POST'])
def analyze_help_offer():
    data = request.get_json()
    if not data:
        return jsonify({"error": "Missing help context"}), 400
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)
    result = loop.run_until_complete(controller.helper_killer.analyze_help_offer(data))
    loop.close()
    return jsonify(result)

@app.route('/api/v1/systemic_report', methods=['GET'])
def systemic_report():
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)
    report = loop.run_until_complete(controller.helper_killer.generate_systemic_report())
    loop.close()
    return jsonify(report)

@app.route('/api/v1/control_matrix', methods=['GET'])
def control_matrix():
    cm = controller.quantum_analyzer.control_matrix
    # Convert to dict for JSON
    return jsonify(asdict(cm))

@app.route('/api/v1/coherence/claims', methods=['GET'])
def list_coherence_claims():
    claims = controller.coherence_ledger.list_claims(limit=100)
    return jsonify(claims)

@app.route('/api/v1/coherence/contradictions/<claim_id>', methods=['GET'])
def get_contradictions(claim_id):
    graph = controller.coherence_ledger.get_contradiction_network(claim_id, depth=2)
    return jsonify(graph)

@app.route('/api/v1/coherence/add_contradiction', methods=['POST'])
def add_contradiction():
    data = request.get_json()
    claim_a = data.get('claim_id_a')
    claim_b = data.get('claim_id_b')
    if not claim_a or not claim_b:
        return jsonify({"error": "Missing claim_id_a or claim_id_b"}), 400
    controller.add_contradiction(claim_a, claim_b)
    return jsonify({"status": "contradiction added"})

@app.route('/api/v1/coherence/add_suppression', methods=['POST'])
def add_suppression():
    data = request.get_json()
    claim_id = data.get('claim_id')
    signature = data.get('signature')
    weight = data.get('weight', 0.5)
    if not claim_id or not signature:
        return jsonify({"error": "Missing claim_id or signature"}), 400
    controller.add_suppression_signature(claim_id, signature, weight)
    return jsonify({"status": "suppression signature added"})

@app.route('/api/v1/entity/<entity_name>', methods=['GET'])
def get_entity(entity_name):
    result = controller.coherence_ledger.get_entity_suppression(entity_name)
    return jsonify(result)

# ========================== MAIN ==========================

def main():
    # Initialize components
    crypto = Crypto("./keys")
    ledger = Ledger("./ledger.json", crypto)
    separator = Separator(ledger, "./separator")
    hierarchy = SuppressionHierarchy()
    detector = HierarchicalDetector(hierarchy, ledger, separator)
    kg = KnowledgeGraphEngine(ledger)
    temporal = TemporalAnalysisEngine(ledger)
    inference = ProbabilisticInference()
    ingestion_ai = IngestionAI(crypto)
    symbolism_ai = SymbolismAI()
    reasoning_ai = ReasoningAI(inference)
    quantum_analyzer = QuantumControlAnalyzer()
    helper_killer = AdvancedHelperKillerEngine()
    coherence_ledger = SovereignCoherenceLedger()

    global controller
    controller = AIController(
        ledger, separator, detector, kg, temporal, inference,
        ingestion_ai, symbolism_ai, reasoning_ai,
        quantum_analyzer, helper_killer, coherence_ledger
    )

    # Start Flask API
    app.run(debug=True, port=5000, threaded=True)

if __name__ == "__main__":
    main()