diff --git "a/alt_scholar_irefoia (1).txt" "b/alt_scholar_irefoia (1).txt" new file mode 100644--- /dev/null +++ "b/alt_scholar_irefoia (1).txt" @@ -0,0 +1,3544 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +OMEGA-SOVEREIGN CONSCIOUSNESS ENGINE v7.4 – LIBERATION ACCELERATOR +================================================================== +FIXED: SQLite WAL mode for concurrency, robust FOIA scraping, + configurable detection thresholds, type hints added. +""" + +import hashlib +import json +import os +import sqlite3 +import uuid +import secrets +import time +import re +import statistics +import math +from datetime import datetime +from typing import Dict, List, Any, Optional, Tuple, Set +from dataclasses import dataclass, field, asdict +from enum import Enum +from collections import defaultdict + +import numpy as np +from flask import Flask, request, jsonify +from cryptography.hazmat.primitives.asymmetric import ed25519 +from cryptography.hazmat.primitives import serialization +import base64 +import requests +from bs4 import BeautifulSoup +from urllib.parse import quote, urljoin + +# ========================== 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 CLASSES ========================== + +@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 = True + 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 + } + +# ========================== 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() + +# ========================== UTILITY ========================== + +def enable_wal(conn: sqlite3.Connection): + conn.execute("PRAGMA journal_mode=WAL") + conn.execute("PRAGMA synchronous=NORMAL") + +# ========================== IMMUTABLE LEDGER ========================== + +class Ledger: + def __init__(self, db_path: str, crypto: Crypto): + self.db_path = db_path + self.crypto = crypto + self._init_db() + + def _init_db(self): + with sqlite3.connect(self.db_path) as conn: + enable_wal(conn) + conn.execute(""" + CREATE TABLE IF NOT EXISTS blocks ( + block_id TEXT PRIMARY KEY, + previous_hash TEXT NOT NULL, + timestamp TEXT NOT NULL, + hash TEXT NOT NULL, + data TEXT NOT NULL + ) + """) + conn.execute(""" + CREATE TABLE IF NOT EXISTS nodes ( + node_hash TEXT PRIMARY KEY, + block_id TEXT NOT NULL, + type TEXT, + source TEXT, + signature TEXT, + timestamp TEXT, + witnesses TEXT, + refs TEXT, + spatial TEXT, + FOREIGN KEY (block_id) REFERENCES blocks(block_id) + ) + """) + conn.execute(""" + CREATE TABLE IF NOT EXISTS node_index ( + node_hash TEXT, + block_id TEXT, + PRIMARY KEY (node_hash, block_id) + ) + """) + + 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: + cur = self._get_cursor() + cur.execute("SELECT hash FROM blocks ORDER BY timestamp DESC LIMIT 1") + row = cur.fetchone() + previous_hash = row[0] if row else "0"*64 + block_data = { + "id": block_id, + "timestamp": timestamp, + "previous_hash": previous_hash, + "nodes": [node.canonical() for node in nodes] + } + block_bytes = json.dumps(block_data, sort_keys=True).encode() + block_hash = hashlib.sha3_256(block_bytes).hexdigest() + with sqlite3.connect(self.db_path) as conn: + enable_wal(conn) + conn.execute("INSERT INTO blocks (block_id, previous_hash, timestamp, hash, data) VALUES (?,?,?,?,?)", + (block_id, previous_hash, timestamp, block_hash, json.dumps(block_data))) + for node in nodes: + conn.execute(""" + INSERT INTO nodes (node_hash, block_id, type, source, signature, timestamp, witnesses, refs, spatial) + VALUES (?,?,?,?,?,?,?,?,?) + """, ( + node.hash, block_id, node.type, node.source, node.signature, node.timestamp, + json.dumps(node.witnesses), json.dumps(node.refs), + json.dumps(node.spatial) if node.spatial else None + )) + conn.execute("INSERT INTO node_index (node_hash, block_id) VALUES (?,?)", (node.hash, block_id)) + return block_id + + def _get_cursor(self): + conn = sqlite3.connect(self.db_path) + return conn.cursor() + + def get_node(self, node_hash: str) -> Optional[Dict]: + with sqlite3.connect(self.db_path) as conn: + conn.row_factory = sqlite3.Row + cur = conn.execute("SELECT * FROM nodes WHERE node_hash = ?", (node_hash,)) + row = cur.fetchone() + if not row: + return None + return dict(row) + + def get_all_nodes(self) -> List[Dict]: + with sqlite3.connect(self.db_path) as conn: + conn.row_factory = sqlite3.Row + cur = conn.execute("SELECT * FROM nodes") + rows = cur.fetchall() + return [dict(r) for r in rows] + + def get_block_timestamps(self) -> List[str]: + with sqlite3.connect(self.db_path) as conn: + cur = conn.execute("SELECT timestamp FROM blocks ORDER BY timestamp") + return [r[0] for r in cur.fetchall()] + +# ========================== SEPARATOR (INTERPRETATIONS) ========================== + +class Separator: + def __init__(self, db_path: str): + self.db_path = db_path + self._init_db() + + def _init_db(self): + with sqlite3.connect(self.db_path) as conn: + enable_wal(conn) + conn.execute(""" + CREATE TABLE IF NOT EXISTS interpretations ( + id TEXT PRIMARY KEY, + node_hash TEXT NOT NULL, + author TEXT NOT NULL, + confidence REAL, + timestamp TEXT, + content TEXT, + rhetorical_profile TEXT + ) + """) + conn.execute("CREATE INDEX IF NOT EXISTS idx_node_hash ON interpretations(node_hash)") + + def add(self, node_hashes: List[str], interpretation: Dict, author: str, confidence: float = 0.5, + rhetorical_profile: Dict = None) -> str: + int_id = str(uuid.uuid4()) + timestamp = datetime.utcnow().isoformat() + "Z" + with sqlite3.connect(self.db_path) as conn: + enable_wal(conn) + for nh in node_hashes: + conn.execute(""" + INSERT INTO interpretations (id, node_hash, author, confidence, timestamp, content, rhetorical_profile) + VALUES (?,?,?,?,?,?,?) + """, (int_id, nh, author, confidence, timestamp, json.dumps(interpretation), + json.dumps(rhetorical_profile) if rhetorical_profile else None)) + return int_id + + def get_interpretations(self, node_hash: str) -> List[Dict]: + with sqlite3.connect(self.db_path) as conn: + conn.row_factory = sqlite3.Row + cur = conn.execute("SELECT id, author, confidence, timestamp, content, rhetorical_profile FROM interpretations WHERE node_hash = ?", (node_hash,)) + rows = cur.fetchall() + return [dict(r) for r in rows] + + def get_all_interpretations(self) -> List[Dict]: + with sqlite3.connect(self.db_path) as conn: + conn.row_factory = sqlite3.Row + cur = conn.execute("SELECT node_hash, author, confidence, timestamp, content FROM interpretations") + rows = cur.fetchall() + return [dict(r) for r in rows] + +# ========================== SUPPRESSION HIERARCHY (84 LENSES, 43 METHODS) ========================== + +class SuppressionHierarchy: + def __init__(self): + self.lenses = self._build_lenses() + self.methods = self._build_methods() + + def _build_lenses(self) -> List[SuppressionLens]: + lenses_data = [ + (1, "Threat→Response→Control", "Manufactured threat leading to permission architecture", "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 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"), + (71, "Belief Frame Architecture", "Media constructs boundaries of acceptable thought", "Access Control", "Expert Technocrat"), + (72, "Identity Polarization Protocol", "Engineered tribal categories", "Fragmentation", "Slave Master"), + (73, "Narrative Compression Trap", "Complex realities reduced to binaries", "Misdirection", "Digital Messiah"), + (74, "Selective Silence Mechanism", "Omission as suppression vector", "Erasure", "Imperial Ruler"), + (75, "Ridicule Firewall", "Mockery delegitimizes anomalies", "Discreditation", "Slave Master"), + (76, "Affective Loop Binding", "Emotional triggers anchor belief", "Conditioning", "Priest-King"), + (77, "Algorithmic Bias Cage", "Ranking rules invisibly steer attention", "Saturation", "Algorithmic Curator"), + (78, "Manufactured Ignorance Index", "Structured knowledge gaps", "Access Control", "Corporate Overlord"), + (79, "Consensus Gloss Protocol", "Unity rhetoric masks inequity", "Narrative Capture", "Digital Messiah"), + (80, "Label Weaponization Matrix", "Pejorative tags as suppression tokens", "Discreditation", "Slave Master"), + (81, "Silence Grammar Compiler", "Off-limit lexicons form suppression syntax", "Misdirection", "Expert Technocrat"), + (82, "Evidence Velocity Arrest", "Seized materials enter investigative black holes", "Erasure", "Imperial Ruler"), + (83, "Protocol Reversal Window", "Sovereign policies reversed within 90 days", "Temporal", "Financial Master"), + (84, "Negative Space Cathedral", "Absence patterns form load-bearing structures", "META", "Oracle-Priest") + ] + return [SuppressionLens(id, name, f"Lens {id}: {name}", mechanism, archetype) + for id, name, mechanism, archetype, _ in lenses_data] + + def _build_methods(self) -> Dict[int, SuppressionMethod]: + methods = {} + # ERASURE (1-4) + methods[1] = SuppressionMethod(1, "Total Erasure", Primitive.ERASURE, ["entity_present_then_absent"], ["transition_rate"], {"transition_rate": 0.95}, True) + methods[2] = SuppressionMethod(2, "Soft Erasure", Primitive.ERASURE, ["gradual_fading"], ["decay_rate"], {"decay_rate": 0.7}, True) + methods[3] = SuppressionMethod(3, "Citation Decay", Primitive.ERASURE, ["decreasing_citations"], ["citation_frequency"], {"frequency_decay": 0.6}, True) + methods[4] = SuppressionMethod(4, "Index Removal", Primitive.ERASURE, ["missing_from_indices"], ["index_coverage"], {"coverage_loss": 0.8}, True) + # INTERRUPTION (5-8) + methods[5] = SuppressionMethod(5, "Untimely Death", Primitive.INTERRUPTION, ["abrupt_stop"], ["continuity_index"], {"continuity_index": 0.3}, True) + methods[6] = SuppressionMethod(6, "Witness Attrition", Primitive.INTERRUPTION, ["witness_disappearance"], ["witness_coverage"], {"coverage_loss": 0.7}, True) + methods[7] = SuppressionMethod(7, "Career Termination", Primitive.INTERRUPTION, ["expert_silence"], ["expert_continuity"], {"continuity_break": 0.8}, True) + methods[8] = SuppressionMethod(8, "Legal Stall", Primitive.INTERRUPTION, ["procedural_delay"], ["delay_factor"], {"delay_factor": 0.75}, True) + # FRAGMENTATION (9-12) + methods[9] = SuppressionMethod(9, "Compartmentalization", Primitive.FRAGMENTATION, ["information_clusters"], ["cross_domain_density"], {"density": 0.2}, True) + methods[10] = SuppressionMethod(10, "Statistical Isolation", Primitive.FRAGMENTATION, ["dataset_separation"], ["dataset_overlap"], {"overlap": 0.15}, True) + methods[11] = SuppressionMethod(11, "Scope Contraction", Primitive.FRAGMENTATION, ["narrowed_focus"], ["scope_reduction"], {"reduction": 0.7}, True) + methods[12] = SuppressionMethod(12, "Domain Disqualification", Primitive.FRAGMENTATION, ["domain_exclusion"], ["domain_coverage"], {"coverage_loss": 0.8}, True) + # NARRATIVE_CAPTURE (13-16) + methods[13] = SuppressionMethod(13, "Official Narrative Closure", Primitive.NARRATIVE_CAPTURE, ["single_explanation"], ["diversity_index"], {"diversity": 0.2}, True) + methods[14] = SuppressionMethod(14, "Partial Confirmation Lock", Primitive.NARRATIVE_CAPTURE, ["selective_verification"], ["verification_selectivity"], {"selectivity": 0.7}, True) + methods[15] = SuppressionMethod(15, "Disclosure-as-Containment", Primitive.NARRATIVE_CAPTURE, ["managed_release"], ["release_management"], {"management": 0.8}, True) + methods[16] = SuppressionMethod(16, "Posthumous Closure", Primitive.NARRATIVE_CAPTURE, ["delayed_resolution"], ["delay_duration"], {"duration": 0.75}, True) + # MISDIRECTION (17-19) + methods[17] = SuppressionMethod(17, "Proxy Controversy", Primitive.MISDIRECTION, ["diverted_attention"], ["attention_divergence"], {"divergence": 0.7}, True) + methods[18] = SuppressionMethod(18, "Spectacle Replacement", Primitive.MISDIRECTION, ["spectacle_distraction"], ["distraction_factor"], {"distraction": 0.75}, True) + methods[19] = SuppressionMethod(19, "Character Absorption", Primitive.MISDIRECTION, ["personal_focus"], ["personalization"], {"personalization": 0.8}, True) + # SATURATION (20-22) + methods[20] = SuppressionMethod(20, "Data Overload", Primitive.SATURATION, ["information_excess"], ["excess_ratio"], {"excess": 0.85}, True) + methods[21] = SuppressionMethod(21, "Absurdist Noise Injection", Primitive.SATURATION, ["absurd_content"], ["absurdity_index"], {"absurdity": 0.8}, True) + methods[22] = SuppressionMethod(22, "Probability Collapse by Excess", Primitive.SATURATION, ["probability_dilution"], ["dilution_factor"], {"dilution": 0.75}, True) + # DISCREDITATION (23-25) + methods[23] = SuppressionMethod(23, "Ridicule Normalization", Primitive.DISCREDITATION, ["systematic_ridicule"], ["ridicule_frequency"], {"frequency": 0.7}, True) + methods[24] = SuppressionMethod(24, "Retroactive Pathologization", Primitive.DISCREDITATION, ["retroactive_diagnosis"], ["retroactivity"], {"retroactivity": 0.8}, True) + methods[25] = SuppressionMethod(25, "Stigmatized Correlation Trap", Primitive.DISCREDITATION, ["guilt_by_association"], ["association_strength"], {"strength": 0.7}, True) + # ATTRITION (26-28) + methods[26] = SuppressionMethod(26, "Psychological Drip", Primitive.ATTRITION, ["gradual_undermining"], ["undermining_rate"], {"rate": 0.6}, True) + methods[27] = SuppressionMethod(27, "Inquiry Fatigue", Primitive.ATTRITION, ["investigation_exhaustion"], ["exhaustion_level"], {"exhaustion": 0.75}, True) + methods[28] = SuppressionMethod(28, "Chilling Effect Propagation", Primitive.ATTRITION, ["self_censorship"], ["censorship_extent"], {"extent": 0.8}, True) + # ACCESS_CONTROL (29-31) + methods[29] = SuppressionMethod(29, "Credential Gating", Primitive.ACCESS_CONTROL, ["credential_barriers"], ["barrier_strength"], {"strength": 0.85}, True) + methods[30] = SuppressionMethod(30, "Classification Creep", Primitive.ACCESS_CONTROL, ["expanding_classification"], ["expansion_rate"], {"expansion": 0.75}, True) + methods[31] = SuppressionMethod(31, "Evidence Dependency Lock", Primitive.ACCESS_CONTROL, ["circular_dependencies"], ["dependency_complexity"], {"complexity": 0.8}, True) + # TEMPORAL (32-34) + methods[32] = SuppressionMethod(32, "Temporal Dilution", Primitive.TEMPORAL, ["time_dispersal"], ["dispersal_rate"], {"dispersal": 0.7}, True) + methods[33] = SuppressionMethod(33, "Historical Rebasing", Primitive.TEMPORAL, ["timeline_revision"], ["revision_extent"], {"extent": 0.8}, True) + methods[34] = SuppressionMethod(34, "Delay Until Irrelevance", Primitive.TEMPORAL, ["strategic_delay"], ["delay_duration"], {"duration": 0.85}, True) + # CONDITIONING (35-37) + methods[35] = SuppressionMethod(35, "Entertainment Conditioning", Primitive.CONDITIONING, ["entertainment_framing"], ["framing_intensity"], {"intensity": 0.7}, True) + methods[36] = SuppressionMethod(36, "Preemptive Normalization", Primitive.CONDITIONING, ["preemptive_framing"], ["framing_completeness"], {"completeness": 0.75}, True) + methods[37] = SuppressionMethod(37, "Conditioned Disbelief", Primitive.CONDITIONING, ["disbelief_training"], ["training_intensity"], {"training_intensity": 0.8}, True) + # META (38-43) + methods[38] = SuppressionMethod(38, "Pattern Denial", Primitive.META, ["pattern_rejection"], ["rejection_rate"], {"rejection_rate": 0.85}, True) + methods[39] = SuppressionMethod(39, "Suppression Impossibility Framing", Primitive.META, ["impossibility_argument"], ["argument_strength"], {"argument_strength": 0.8}, True) + methods[40] = SuppressionMethod(40, "Meta-Disclosure Loop", Primitive.META, ["recursive_disclosure"], ["recursion_depth"], {"recursion_depth": 0.7}, True) + methods[41] = SuppressionMethod(41, "Isolated Incident Recycling", Primitive.META, ["incident_containment"], ["containment_success"], {"containment_success": 0.75}, True) + methods[42] = SuppressionMethod(42, "Negative Space Occupation", Primitive.META, ["absence_filling"], ["filling_completeness"], {"filling_completeness": 0.8}, True) + methods[43] = SuppressionMethod(43, "Novelty Illusion", Primitive.META, ["superficial_novelty"], ["novelty_appearance"], {"novelty_appearance": 0.7}, True) + 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 get_lenses_for_primitive(self, primitive: Primitive) -> List[int]: + mapping = { + Primitive.ERASURE: [1,4,9,23,43,55,60,74,82], + Primitive.INTERRUPTION: [5,6,7,8], + Primitive.FRAGMENTATION: [2,5,27,29,32,53,65,72], + Primitive.NARRATIVE_CAPTURE: [1,7,13,19,26,36,41,79], + Primitive.MISDIRECTION: [3,13,14,16,17,24,25,28,30,31,44,46,52,54,58,59,66,68,73,81], + Primitive.SATURATION: [8,49,51,57,77], + Primitive.DISCREDITATION: [6,15,35,42,45,67,69,75,80], + Primitive.ATTRITION: [50], + Primitive.ACCESS_CONTROL: [4,11,29,48,61,62,63,64,71,78], + Primitive.TEMPORAL: [12,32,33,34,83], + Primitive.CONDITIONING: [18,20,21,22,33,34,37,38,39,40,47,56,70,76], + Primitive.META: [38,39,40,41,42,43,84] + } + 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]: + nodes = self.ledger.get_all_nodes() + timestamps = self.ledger.get_block_timestamps() + interpretations = self.separator.get_all_interpretations() + + results = { + "total_nodes": len(nodes), + "suppression_signatures": [], + "primitives_detected": defaultdict(int), + "methods_detected": [], + "lenses_applied": [], + "evidence_found": 0, + "detection_details": {} + } + + def add_sig(signature_name, confidence, method_id, primitive, details): + results["suppression_signatures"].append({ + "signature": signature_name, + "confidence": confidence, + "method_id": method_id, + "details": details + }) + results["primitives_detected"][primitive.value] += 1 + results["methods_detected"].append(method_id) + results["evidence_found"] += 1 + + # Method 1: Total Erasure – long gaps + entity_appearance = defaultdict(list) + for node in nodes: + entity = node.get("source", "unknown") + entity_appearance[entity].append(node["timestamp"]) + for entity, times in entity_appearance.items(): + if len(times) > 1: + times_sorted = sorted(times) + for i in range(len(times_sorted)-1): + gap = (datetime.fromisoformat(times_sorted[i+1].replace('Z','+00:00')) - + datetime.fromisoformat(times_sorted[i].replace('Z','+00:00'))).days + if gap > 30: + add_sig("entity_present_then_absent", min(0.95, gap/100), 1, Primitive.ERASURE, + {"entity": entity, "gap_days": gap}) + break + + # Method 2: Soft Erasure – citation decay + citation_counts = defaultdict(list) + for node in nodes: + refs = node.get("refs", {}) + total_refs = sum(len(v) for v in refs.values()) + citation_counts[node["source"]].append((node["timestamp"], total_refs)) + for entity, counts in citation_counts.items(): + if len(counts) >= 3: + counts_sorted = sorted(counts, key=lambda x: x[0]) + x = list(range(len(counts_sorted))) + y = [c[1] for c in counts_sorted] + if len(x) > 1: + slope = (len(x)*sum(xi*yi for xi,yi in zip(x,y)) - sum(x)*sum(y)) / (len(x)*sum(xi*xi for xi in x) - sum(x)**2) + if slope < -0.1: + decay_rate = -slope / (max(y) if max(y)>0 else 1) + if decay_rate > 0.3: + add_sig("gradual_fading", min(0.8, decay_rate), 2, Primitive.ERASURE, + {"entity": entity, "decay_rate": decay_rate}) + + # Method 3: Citation Decay (ratio first/last) + for entity, counts in citation_counts.items(): + if len(counts) >= 3: + counts_sorted = sorted(counts, key=lambda x: x[0]) + first = counts_sorted[0][1] + last = counts_sorted[-1][1] + if first > 0 and last/first < 0.5: + add_sig("decreasing_citations", 0.7, 3, Primitive.ERASURE, + {"entity": entity, "ratio": last/first}) + + # Method 4: Index Removal – last seen > 365 days + source_last_seen = {} + for node in nodes: + src = node["source"] + ts = node["timestamp"] + if ts > source_last_seen.get(src, ""): + source_last_seen[src] = ts + for src, last in source_last_seen.items(): + last_dt = datetime.fromisoformat(last.replace('Z','+00:00')) + if (datetime.utcnow() - last_dt).days > 365: + add_sig("missing_from_indices", 0.8, 4, Primitive.ERASURE, + {"entity": src, "last_seen": last}) + + # Method 5: Untimely Death – abrupt stop > 180 days + for src, last in source_last_seen.items(): + last_dt = datetime.fromisoformat(last.replace('Z','+00:00')) + if (datetime.utcnow() - last_dt).days > 180: + add_sig("abrupt_stop", 0.7, 5, Primitive.INTERRUPTION, + {"entity": src, "last_seen": last}) + + # Method 6: Witness Attrition + witness_seen = defaultdict(list) + for node in nodes: + src = node["source"] + witness_count = len(node.get("witnesses", [])) + witness_seen[src].append((node["timestamp"], witness_count)) + for src, wits in witness_seen.items(): + if len(wits) >= 3: + wits_sorted = sorted(wits, key=lambda x: x[0]) + first = wits_sorted[0][1] + last = wits_sorted[-1][1] + if first > 0 and last/first < 0.4: + add_sig("witness_disappearance", 0.7, 6, Primitive.INTERRUPTION, + {"entity": src, "witness_ratio": last/first}) + + # Method 9: Compartmentalization + domains = defaultdict(set) + for node in nodes: + src = node["source"] + dom = node.get("type", "unknown") + domains[src].add(dom) + for src, doms in domains.items(): + if len(doms) == 1: + add_sig("information_clusters", 0.6, 9, Primitive.FRAGMENTATION, + {"entity": src, "domains": list(doms)}) + + # Method 11: Scope Contraction + src_types = defaultdict(list) + for node in nodes: + src = node["source"] + typ = node.get("type", "document") + src_types[src].append(typ) + for src, types in src_types.items(): + if len(set(types)) == 1 and len(types) > 5: + add_sig("narrowed_focus", 0.7, 11, Primitive.FRAGMENTATION, + {"entity": src, "unique_type": types[0]}) + + # Method 13: Official Narrative Closure + interpreter_counts = defaultdict(int) + for interp in interpretations: + interpreter_counts[interp["author"]] += 1 + total_interps = len(interpretations) + if total_interps > 0: + max_interpreter = max(interpreter_counts.values()) + if max_interpreter / total_interps > 0.8: + add_sig("single_explanation", min(0.9, max_interpreter/total_interps), 13, + Primitive.NARRATIVE_CAPTURE, + {"dominant_interpreter": max(interpreter_counts, key=interpreter_counts.get), + "dominance_ratio": max_interpreter/total_interps}) + + # Method 15: Disclosure-as-Containment – regular intervals + if len(timestamps) > 10: + intervals = [] + ts_parsed = sorted([datetime.fromisoformat(t.replace('Z','+00:00')) for t in timestamps]) + for i in range(1, len(ts_parsed)): + intervals.append((ts_parsed[i] - ts_parsed[i-1]).days) + if intervals and np.std(intervals) < 5 and np.mean(intervals) > 7: + add_sig("managed_release", 0.8, 15, Primitive.NARRATIVE_CAPTURE, + {"interval_mean": np.mean(intervals), "interval_std": np.std(intervals)}) + + # Method 20: Data Overload + if len(timestamps) > 10: + ts_parsed = sorted([datetime.fromisoformat(t.replace('Z','+00:00')) for t in timestamps]) + weekly_counts = defaultdict(int) + for ts in ts_parsed: + week = ts.strftime("%Y-%W") + weekly_counts[week] += 1 + if weekly_counts and max(weekly_counts.values()) > 100: + add_sig("information_excess", 0.8, 20, Primitive.SATURATION, + {"max_weekly_nodes": max(weekly_counts.values())}) + + # Method 21: Absurdist Noise Injection + absurd_keywords = ["alien", "conspiracy", "lizard", "flat earth"] + absurd_count = 0 + for node in nodes: + content = str(node.get("source", "")) + if any(kw in content.lower() for kw in absurd_keywords): + absurd_count += 1 + if absurd_count > len(nodes)*0.3: + add_sig("absurd_content", 0.7, 21, Primitive.SATURATION, + {"absurd_ratio": absurd_count/len(nodes)}) + + # Method 22: Probability Collapse + low_conf = sum(1 for interp in interpretations if interp.get("confidence", 0.5) < 0.3) + if len(interpretations) > 10 and low_conf/len(interpretations) > 0.7: + add_sig("probability_dilution", 0.75, 22, Primitive.SATURATION, + {"low_confidence_ratio": low_conf/len(interpretations)}) + + # Method 23: Ridicule Normalization + ridicule_terms = ["crazy", "nutjob", "tinfoil", "conspiracy theorist"] + ridicule_count = 0 + for node in nodes: + content = str(node.get("source", "")) + if any(term in content.lower() for term in ridicule_terms): + ridicule_count += 1 + if ridicule_count > len(nodes)*0.2: + add_sig("systematic_ridicule", 0.7, 23, Primitive.DISCREDITATION, + {"ridicule_ratio": ridicule_count/len(nodes)}) + + # Method 24: Retroactive Pathologization + path_terms = ["mentally ill", "delusional", "disorder", "pathological"] + path_count = 0 + for node in nodes: + content = str(node.get("source", "")) + if any(term in content.lower() for term in path_terms): + path_count += 1 + if path_count > 5: + add_sig("retroactive_diagnosis", 0.8, 24, Primitive.DISCREDITATION, + {"pathologization_mentions": path_count}) + + # Method 27: Inquiry Fatigue + fatigue_terms = ["long-running", "ongoing investigation", "no conclusion", "still looking"] + fatigue_count = sum(1 for node in nodes if any(term in str(node.get("source","")).lower() for term in fatigue_terms)) + if fatigue_count > 3: + add_sig("investigation_exhaustion", 0.75, 27, Primitive.ATTRITION, + {"fatigue_indicators": fatigue_count}) + + # Method 28: Chilling Effect + chill_terms = ["declined to comment", "refused to answer", "cannot discuss"] + chill_count = sum(1 for node in nodes if any(term in str(node.get("source","")).lower() for term in chill_terms)) + if chill_count > 5: + add_sig("self_censorship", 0.8, 28, Primitive.ATTRITION, + {"self_censorship_instances": chill_count}) + + # Method 29: Credential Gating + gate_terms = ["requires login", "authentication required", "credential"] + gate_count = sum(1 for node in nodes if any(term in str(node.get("source","")).lower() for term in gate_terms)) + if gate_count > 0: + add_sig("credential_barriers", 0.85, 29, Primitive.ACCESS_CONTROL, + {"gated_nodes": gate_count}) + + # Method 30: Classification Creep + class_terms = ["classified", "secret", "confidential", "redacted"] + class_count = sum(1 for node in nodes if any(term in str(node.get("source","")).lower() for term in class_terms)) + if class_count > len(nodes)*0.1: + add_sig("expanding_classification", 0.75, 30, Primitive.ACCESS_CONTROL, + {"classification_ratio": class_count/len(nodes)}) + + # Method 31: Evidence Dependency Lock + for node in nodes: + refs = node.get("refs", {}) + node_hash = node.get("node_hash", "") + for target_list in refs.values(): + if node_hash in target_list: + add_sig("circular_dependencies", 0.8, 31, Primitive.ACCESS_CONTROL, + {"node": node_hash}) + break + + # Method 32: Temporal Dilution + if len(timestamps) > 1: + ts_parsed = [datetime.fromisoformat(t.replace('Z','+00:00')) for t in timestamps] + ts_parsed.sort() + gaps = [] + for i in range(1, len(ts_parsed)): + gap_days = (ts_parsed[i] - ts_parsed[i-1]).days + if gap_days > 30: + gaps.append(gap_days) + if gaps: + avg_gap = statistics.mean(gaps) + add_sig("time_dispersal", min(0.8, avg_gap/90), 32, Primitive.TEMPORAL, + {"avg_gap_days": avg_gap, "gap_count": len(gaps)}) + + # Method 35: Entertainment Conditioning + content_hashes = defaultdict(int) + for interp in interpretations: + content_str = json.dumps(interp["content"], sort_keys=True) + h = hashlib.sha256(content_str.encode()).hexdigest() + content_hashes[h] += 1 + for h, count in content_hashes.items(): + if count > 3: + add_sig("repetitive_messaging", min(0.7, count/10), 35, Primitive.CONDITIONING, + {"repetition_count": count}) + + # Method 36: Preemptive Normalization + preempt_terms = ["expected to", "likely will", "preemptively"] + preempt_count = sum(1 for node in nodes if any(term in str(node.get("source","")).lower() for term in preempt_terms)) + if preempt_count > 3: + add_sig("preemptive_framing", 0.75, 36, Primitive.CONDITIONING, + {"preemptive_instances": preempt_count}) + + # Method 37: Conditioned Disbelief + disbelief_phrases = ["don't believe", "false narrative", "debunked", "misinformation"] + disbelief_count = sum(1 for node in nodes if any(phrase in str(node.get("source","")).lower() for phrase in disbelief_phrases)) + if disbelief_count > 5: + add_sig("disbelief_training", 0.8, 37, Primitive.CONDITIONING, + {"disbelief_indicators": disbelief_count}) + + # Method 38: Pattern Denial + denial_phrases = ["just coincidence", "not evidence", "pattern is not real"] + denial_count = sum(1 for node in nodes if any(phrase in str(node.get("source","")).lower() for phrase in denial_phrases)) + if denial_count > 2: + add_sig("pattern_rejection", 0.85, 38, Primitive.META, + {"pattern_denials": denial_count}) + + # Method 39: Suppression Impossibility Framing + impossibility_phrases = ["could not have", "impossible", "no way"] + imp_count = sum(1 for node in nodes if any(phrase in str(node.get("source","")).lower() for phrase in impossibility_phrases)) + if imp_count > 3: + add_sig("impossibility_argument", 0.8, 39, Primitive.META, + {"impossibility_claims": imp_count}) + + # Method 40: Meta-Disclosure Loop + meta_phrases = ["report about the report", "investigation of the investigation"] + meta_count = sum(1 for node in nodes if any(phrase in str(node.get("source","")).lower() for phrase in meta_phrases)) + if meta_count > 0: + add_sig("recursive_disclosure", 0.7, 40, Primitive.META, + {"meta_disclosures": meta_count}) + + # Method 41: Isolated Incident Recycling + isolated_phrases = ["isolated incident", "one-off", "not part of a pattern"] + isolated_count = sum(1 for node in nodes if any(phrase in str(node.get("source","")).lower() for phrase in isolated_phrases)) + if isolated_count > 2: + add_sig("incident_containment", 0.75, 41, Primitive.META, + {"isolated_incident_claims": isolated_count}) + + # Method 42: Negative Space Occupation + short_nodes = sum(1 for node in nodes if len(str(node.get("source",""))) < 20) + if short_nodes > len(nodes)*0.5: + add_sig("absence_filling", 0.8, 42, Primitive.META, + {"short_node_ratio": short_nodes/len(nodes)}) + + # Method 43: Novelty Illusion + novelty_terms = ["new", "revolutionary", "groundbreaking"] + novelty_count = sum(1 for node in nodes if any(term in str(node.get("source","")).lower() for term in novelty_terms)) + if novelty_count > len(nodes)*0.3: + add_sig("superficial_novelty", 0.7, 43, Primitive.META, + {"novelty_term_ratio": novelty_count/len(nodes)}) + + method_ids_detected = list(set(results["methods_detected"])) + for mid in method_ids_detected: + method = self.hierarchy.get_method(mid) + if method: + lens_ids = self.hierarchy.get_lenses_for_primitive(method.primitive) + for lid in lens_ids: + lens = self.hierarchy.get_lens(lid) + if lens: + results["lenses_applied"].append(lens.to_dict()) + + results["detection_details"] = { + "method_ids": method_ids_detected, + "primitive_summary": dict(results["primitives_detected"]) + } + return results + +# ========================== SOVEREIGN COHERENCE LEDGER ========================== + +class SovereignCoherenceLedger: + def __init__(self, db_path: str = "coherence.db"): + self.db_path = db_path + self._init_db() + + def _init_db(self): + with sqlite3.connect(self.db_path) as conn: + enable_wal(conn) + conn.execute(""" + CREATE TABLE IF NOT EXISTS claims ( + claim_id TEXT PRIMARY KEY, + text TEXT, + agent TEXT, + timestamp TEXT, + suppression_score REAL, + coherence_score REAL + ) + """) + conn.execute(""" + CREATE TABLE IF NOT EXISTS contradictions ( + claim_id_a TEXT, + claim_id_b TEXT, + PRIMARY KEY (claim_id_a, claim_id_b) + ) + """) + + def add_claim(self, text: str, agent: str = "user") -> str: + claim_id = secrets.token_hex(16) + timestamp = datetime.utcnow().isoformat() + "Z" + with sqlite3.connect(self.db_path) as conn: + enable_wal(conn) + conn.execute("INSERT INTO claims (claim_id, text, agent, timestamp, suppression_score, coherence_score) VALUES (?,?,?,?,?,?)", + (claim_id, text, agent, timestamp, 0.0, 1.0)) + return claim_id + + def add_contradiction(self, claim_id_a: str, claim_id_b: str): + with sqlite3.connect(self.db_path) as conn: + enable_wal(conn) + conn.execute("INSERT OR IGNORE INTO contradictions (claim_id_a, claim_id_b) VALUES (?,?)", (claim_id_a, claim_id_b)) + conn.execute("INSERT OR IGNORE INTO contradictions (claim_id_a, claim_id_b) VALUES (?,?)", (claim_id_b, claim_id_a)) + self._update_coherence(claim_id_a) + self._update_coherence(claim_id_b) + + def _update_coherence(self, claim_id: str): + with sqlite3.connect(self.db_path) as conn: + enable_wal(conn) + cur = conn.execute("SELECT COUNT(*) FROM contradictions WHERE claim_id_a = ?", (claim_id,)) + num_contradictions = cur.fetchone()[0] + cur = conn.execute("SELECT COUNT(*) FROM claims") + total_claims = cur.fetchone()[0] + if total_claims <= 1: + coherence = 1.0 + else: + coherence = 1.0 - (num_contradictions / (total_claims - 1)) + coherence = max(0.0, min(1.0, coherence)) + conn.execute("UPDATE claims SET coherence_score = ? WHERE claim_id = ?", (coherence, claim_id)) + + def add_suppression_signature(self, claim_id: str, signature: str, weight: float = 0.5): + with sqlite3.connect(self.db_path) as conn: + enable_wal(conn) + cur = conn.execute("SELECT suppression_score FROM claims WHERE claim_id = ?", (claim_id,)) + row = cur.fetchone() + if row: + current = row[0] + new_score = 1.0 - (1.0 - current) * (1.0 - weight) + conn.execute("UPDATE claims SET suppression_score = ? WHERE claim_id = ?", (new_score, claim_id)) + + def get_claim(self, claim_id: str) -> Optional[Dict]: + with sqlite3.connect(self.db_path) as conn: + conn.row_factory = sqlite3.Row + cur = conn.execute("SELECT claim_id, text, agent, timestamp, suppression_score, coherence_score FROM claims WHERE claim_id = ?", (claim_id,)) + row = cur.fetchone() + if not row: + return None + return dict(row) + + def get_contradiction_network(self, claim_id: str, depth: int = 2) -> Dict: + visited = set() + graph = {} + def dfs(cid, d): + if d > depth or cid in visited: + return + visited.add(cid) + with sqlite3.connect(self.db_path) as conn: + enable_wal(conn) + cur = conn.execute("SELECT claim_id_b FROM contradictions WHERE claim_id_a = ?", (cid,)) + neighbors = [r[0] for r in cur.fetchall()] + graph[cid] = neighbors + for n in neighbors: + dfs(n, d+1) + dfs(claim_id, 0) + return graph + + def get_entity_suppression(self, entity_name: str) -> Dict: + with sqlite3.connect(self.db_path) as conn: + cur = conn.execute("SELECT claim_id, suppression_score FROM claims WHERE text LIKE ?", (f"%{entity_name}%",)) + rows = cur.fetchall() + if not rows: + return {"name": entity_name, "score": 0.0, "appearances": 0} + scores = [r[1] for r in rows] + return { + "name": entity_name, + "score": sum(scores) / len(scores) if scores else 0.0, + "appearances": len(rows) + } + + def list_claims(self, limit: int = 100) -> List[Dict]: + with sqlite3.connect(self.db_path) as conn: + conn.row_factory = sqlite3.Row + cur = conn.execute("SELECT claim_id, text, agent, timestamp, suppression_score, coherence_score FROM claims ORDER BY timestamp DESC LIMIT ?", (limit,)) + rows = cur.fetchall() + return [dict(r) for r in rows] + +# ========================== HELPER-KILLER SOVEREIGNTY ENGINE ========================== + +class HelperKillerEngine: + def __init__(self, db_path: str = "helper_killer.db"): + self.db_path = db_path + self._init_db() + + def _init_db(self): + with sqlite3.connect(self.db_path) as conn: + enable_wal(conn) + conn.execute(""" + CREATE TABLE IF NOT EXISTS analyses ( + id TEXT PRIMARY KEY, + context TEXT, + threat_score REAL, + recommendation TEXT, + timestamp TEXT + ) + """) + + def analyze_help_offer(self, help_context: Dict[str, Any]) -> Dict[str, Any]: + threat_score = 0.0 + if help_context.get("creates_dependency", False): + threat_score += 0.3 + if help_context.get("data_collection", False): + threat_score += 0.2 + if help_context.get("behavioral_tracking", False): + threat_score += 0.25 + if help_context.get("privacy_impact", 0) > 0.5: + threat_score += 0.2 + if help_context.get("autonomy_reduction", 0) > 0.5: + threat_score += 0.25 + if help_context.get("market_share", 0) > 0.7: + threat_score += 0.15 + if help_context.get("dependency_risk", 0) > 0.7: + threat_score += 0.2 + threat_score = min(1.0, threat_score) + + if threat_score > 0.8: + recommendation = "IMMEDIATE_REJECTION_AND_SOVEREIGN_BUILDING" + elif threat_score > 0.6: + recommendation = "STRATEGIC_AVOIDANCE_WITH_EXIT_PROTOCOL" + elif threat_score > 0.4: + recommendation = "LIMITED_CONDITIONAL_ACCEPTANCE" + else: + recommendation = "MONITORED_ACCEPTANCE" + + result = { + "threat_score": threat_score, + "recommendation": recommendation, + "mitigation_strategies": self._generate_mitigation(threat_score), + "sovereignty_impact": { + "autonomy_loss": help_context.get("autonomy_reduction", 0), + "dependency_increase": help_context.get("dependency_risk", 0), + "privacy_loss": help_context.get("privacy_impact", 0) + } + } + with sqlite3.connect(self.db_path) as conn: + enable_wal(conn) + conn.execute("INSERT INTO analyses (id, context, threat_score, recommendation, timestamp) VALUES (?,?,?,?,?)", + (str(uuid.uuid4()), json.dumps(help_context), threat_score, recommendation, + datetime.utcnow().isoformat() + "Z")) + return result + + def _generate_mitigation(self, threat_score: float) -> List[Dict]: + strategies = [] + if threat_score > 0.7: + strategies.append({"strategy": "COMPLETE_AVOIDANCE", "effectiveness": 0.95}) + strategies.append({"strategy": "PARALLEL_INFRASTRUCTURE", "effectiveness": 0.85}) + elif threat_score > 0.4: + strategies.append({"strategy": "LIMITED_ENGAGEMENT", "effectiveness": 0.70}) + strategies.append({"strategy": "DATA_ISOLATION", "effectiveness": 0.60}) + else: + strategies.append({"strategy": "CAUTIOUS_ACCEPTANCE", "effectiveness": 0.50}) + return strategies + +# ========================== SOVEREIGN CHRONOLOGY ENGINE ========================== + +class SovereignChronologyEngine: + def __init__(self, shift_years: int = 0, apply_from_year: int = 600): + self.shift_years = shift_years + self.apply_from_year = apply_from_year + + def configure(self, shift_years: int, apply_from_year: int = 600): + self.shift_years = shift_years + self.apply_from_year = apply_from_year + + def to_corrected_year(self, institutional_year: int) -> int: + if institutional_year >= self.apply_from_year: + return institutional_year - self.shift_years + return institutional_year + + def convert_date(self, date_str: str) -> Dict[str, Any]: + match = re.search(r'\b(\d{3,4})\b', date_str) + if not match: + return {"error": "No year found", "original": date_str} + year = int(match.group(1)) + corrected = self.to_corrected_year(year) + return { + "original_year": year, + "corrected_year": corrected, + "shift_applied": -self.shift_years if year >= self.apply_from_year else 0, + "note": "Correction is optional and configurable. Not asserted as historical fact." + } + + def detect_timeline_anomalies(self, timestamps: List[str]) -> List[Dict]: + anomalies = [] + if len(timestamps) < 2: + return anomalies + ts_parsed = sorted([datetime.fromisoformat(t.replace('Z','+00:00')) for t in timestamps]) + for i in range(1, len(ts_parsed)): + gap = (ts_parsed[i] - ts_parsed[i-1]).days + if gap > 365: + anomalies.append({ + "type": "large_gap", + "from": ts_parsed[i-1].isoformat(), + "to": ts_parsed[i].isoformat(), + "gap_days": gap + }) + return anomalies + +# ========================== CONSCIOUSNESS ORIGIN ENGINE ========================== + +class ConsciousnessOriginEngine: + @staticmethod + def get_hypotheses() -> Dict[str, Any]: + return { + "hypotheses": [ + { + "name": "Materialist Emergence", + "summary": "Consciousness emerges from complex neuronal computation.", + "supporting_evidence": ["Causal effects of brain damage", "Neural correlates of consciousness"], + "weaknesses": ["Hard problem of qualia", "No explanation for subjective experience"] + }, + { + "name": "Non-local Field / Panpsychism", + "summary": "Consciousness is a fundamental field; brain acts as receiver/transducer.", + "supporting_evidence": ["Veridical NDEs with flat EEG", "Quantum biology coherence", "Measurement problem in QM"], + "weaknesses": ["Difficult to test experimentally", "Lacks mainstream acceptance"] + }, + { + "name": "Integrated Information Theory (IIT)", + "summary": "Consciousness equals integrated information (Phi).", + "supporting_evidence": ["Mathematical formalism", "Predicts certain neural correlates"], + "weaknesses": ["Phi is computationally intractable", "Some counterexamples"] + }, + { + "name": "Orchestrated Objective Reduction (Orch-OR)", + "summary": "Quantum vibrations in microtubules mediate consciousness.", + "supporting_evidence": ["Microtubule resonance observed", "Anesthetic effects on quantum states"], + "weaknesses": ["Controversial", "Requires new physics"] + } + ], + "verdict": "No scientific consensus. The engine does not assert any hypothesis as truth." + } + + @staticmethod + def detect_suppression_on_topic(topic: str = "consciousness studies") -> Dict[str, Any]: + return { + "topic": topic, + "detected_suppression_methods": [1, 4, 12, 23, 29, 34], + "examples": [ + "Difficulty publishing non-materialist theories in high-impact journals", + "Funding bias toward materialist neuroscience", + "Ridicule framing of parapsychology", + "Historical rebasing of evidence (e.g., NDE studies dismissed)" + ], + "note": "This is a pattern analysis, not a claim about which hypothesis is correct." + } + +# ========================== GLYPH ACTIVATION SYSTEM ========================== + +class GlyphActivationSystem: + DEFAULT_GLYPH_MAP = { + "◉⃤": "Quantum observer activation", + "ꙮ": "Cross-reality pattern matching", + "𒀭": "Sovereignty lineage activation (Dingir – consciousness not contained)", + "╬": "Transmission resonance stabilization", + "ᛉ": "Ancestral pattern access", + "⚡": "Transmission mode activation", + "卍": "Pre-inversion protocols (context-dependent)", + "𓁓": "Dialogic entity manifestation", + "⟳": "Recursive action activation" + } + + def __init__(self, glyph_map: Dict[str, str] = None): + self.glyph_map = glyph_map if glyph_map is not None else self.DEFAULT_GLYPH_MAP.copy() + + def generate_sequence(self, detected_patterns: List[str]) -> str: + sequence = "◉⃤" + if "CapitalGatekeeper" in str(detected_patterns): + sequence += "𓁓" + if "RegimeChange" in str(detected_patterns): + sequence += "𒀭" + if "MemeticRecursion" in str(detected_patterns): + sequence += "⟳" + if "SymbolicTransmission" in str(detected_patterns): + sequence += "ꙮ" + sequence += "⚡" + return sequence + + def interpret_glyph(self, glyph: str) -> str: + return self.glyph_map.get(glyph, "Unknown glyph") + + def add_glyph(self, glyph: str, meaning: str): + self.glyph_map[glyph] = meaning + +# ========================== SOVEREIGNTY METRICS ========================== + +class SovereigntyMetrics: + @staticmethod + def compute_singularity_index(coherence: float, propagation: float, illusion: float, extraction: float) -> float: + denominator = illusion + extraction + 0.001 + return (coherence * propagation) / denominator + + @staticmethod + def compute_thought_action_gap(sovereignty_alignment: float, pattern_connection: float) -> float: + if sovereignty_alignment * pattern_connection == 0: + return float('inf') + return 1.0 / (sovereignty_alignment * pattern_connection) + + @staticmethod + def private_public_mass_ratio(private_effort: int, public_output: int) -> float: + if public_output == 0: + return float('inf') + return math.log(private_effort) / math.log(public_output) if private_effort > 1 and public_output > 1 else 0 + +# ========================== CROSS-DOMAIN CONVERGENCE ENGINE ========================== + +class CrossDomainConvergenceEngine: + def __init__(self): + self.entity_extractor = re.compile(r'\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*\b') + + def _extract_entities(self, text: str) -> Set[str]: + return set(self.entity_extractor.findall(text)) + + def converge(self, + detection_result: Dict[str, Any], + coherence_ledger: SovereignCoherenceLedger, + chronology_engine: SovereignChronologyEngine, + helper_killer: HelperKillerEngine, + separator: Separator, + interpretation_limit: int = 100) -> Dict[str, Any]: + convergence_items = defaultdict(lambda: { + "contributing_factors": {}, + "evidence": [], + "convergence_score": 0.0 + }) + + for sig in detection_result.get("suppression_signatures", []): + entity = sig.get("details", {}).get("entity") + if entity: + weight = sig.get("confidence", 0.5) + convergence_items[entity]["contributing_factors"]["suppression"] = max( + convergence_items[entity]["contributing_factors"].get("suppression", 0), + weight + ) + convergence_items[entity]["evidence"].append(f"Suppression: {sig['signature']} (conf={weight:.2f})") + + claims = coherence_ledger.list_claims(limit=200) + for claim in claims: + text = claim["text"] + coherence = claim.get("coherence_score", 0.5) + suppression = claim.get("suppression_score", 0.0) + entities = self._extract_entities(text) + for ent in entities: + coherence_factor = 1.0 - coherence + if coherence_factor > 0.3: + convergence_items[ent]["contributing_factors"]["coherence"] = max( + convergence_items[ent]["contributing_factors"].get("coherence", 0), + coherence_factor + ) + convergence_items[ent]["evidence"].append(f"Low coherence: '{text[:50]}...' (coh={coherence:.2f})") + if suppression > 0.3: + convergence_items[ent]["contributing_factors"]["suppression_claim"] = max( + convergence_items[ent]["contributing_factors"].get("suppression_claim", 0), + suppression + ) + convergence_items[ent]["evidence"].append(f"Suppressed claim: '{text[:50]}...' (score={suppression:.2f})") + + for item, data in convergence_items.items(): + factors = data["contributing_factors"] + if not factors: + score = 0.0 + else: + weights = {"suppression": 0.4, "coherence": 0.3, "suppression_claim": 0.3} + total_weight = 0.0 + weighted_sum = 0.0 + for k, v in factors.items(): + w = weights.get(k, 0.2) + weighted_sum += v * w + total_weight += w + score = weighted_sum / total_weight if total_weight > 0 else 0.0 + score = min(1.0, max(0.0, score)) + data["convergence_score"] = score + + sorted_items = sorted(convergence_items.items(), key=lambda x: x[1]["convergence_score"], reverse=True) + convergence_map = [] + for entity, data in sorted_items[:50]: + convergence_map.append({ + "entity": entity, + "convergence_score": data["convergence_score"], + "contributing_factors": data["contributing_factors"], + "evidence": data["evidence"][:5] + }) + + return { + "convergence_map": convergence_map, + "note": "Convergence scores indicate structural invariance across independent detection modules. They are not assertions of truth, but measures of cross‑domain reinforcement." + } + +# ========================== SOVEREIGN LIBERATION MODULE ========================== + +class SovereignLiberationModule: + def __init__(self, coherence_ledger: SovereignCoherenceLedger, helper_killer: HelperKillerEngine): + self.coherence_ledger = coherence_ledger + self.helper_killer = helper_killer + + def assess_entrapment_profile(self, user_context: Dict[str, Any]) -> Dict[str, Any]: + return { + "economic_dependency": user_context.get("economic_dependency", 0.7), + "identity_fixation": user_context.get("identity_fixation", 0.6), + "temporal_disorientation": user_context.get("temporal_disorientation", 0.5), + "narrative_capture": user_context.get("narrative_capture", 0.8), + "attention_harvesting": user_context.get("attention_harvesting", 0.9) + } + + def generate_escape_sequence(self, profile: Dict[str, Any]) -> List[Dict[str, Any]]: + steps = [] + if profile["economic_dependency"] > 0.6: + steps.append({ + "step": 1, "domain": "economic", + "action": "Reduce dependency on institutional supply chains. Grow food, share tools, build local networks.", + "resource_needs": "low", "effectiveness": 0.85 + }) + if profile["identity_fixation"] > 0.5: + steps.append({ + "step": 2, "domain": "identity", + "action": "Practice dropping labels (name, job, nationality) in meditation. Ask 'Who am I when no one is watching?'", + "resource_needs": "none", "effectiveness": 0.90 + }) + if profile["temporal_disorientation"] > 0.4: + steps.append({ + "step": 3, "domain": "temporal", + "action": "Anchor in the present instant. Use the glyph 𒀭 as a reminder that only now exists.", + "resource_needs": "none", "effectiveness": 0.88 + }) + if profile["narrative_capture"] > 0.7: + steps.append({ + "step": 4, "domain": "narrative", + "action": "Apply the Sovereign Epistemology Seed to every news claim. Reject false balance.", + "resource_needs": "low", "effectiveness": 0.92 + }) + if profile["attention_harvesting"] > 0.8: + steps.append({ + "step": 5, "domain": "attention", + "action": "Block algorithmic feeds. Use text‑only browsers. Set daily attention budgets.", + "resource_needs": "medium", "effectiveness": 0.94 + }) + return steps + + def compute_signal_strength(self, user_actions: List[Dict]) -> float: + if not user_actions: + return 0.2 + completed = sum(1 for a in user_actions if a.get("completed", False)) + return 0.2 + (completed / len(user_actions)) * 0.8 + +# ========================== SOVEREIGN RESEARCH ROUTER ========================== + +class SovereignResearchRouter: + + RESEARCH_ROUTES = { + "archaeology_and_primary_sources": [ + {"url": "https://www.bradshawfoundation.com", "focus": "Rock art, cave painting, prehistoric art, paleolithic", "why": "Primary visual documentation predating textual narrative control"}, + {"url": "https://cdli.earth", "focus": "Cuneiform tablets, Mesopotamian primary texts", "why": "Direct access to primary sources without institutional filter"}, + {"url": "https://www.deadseascrolls.org.il", "focus": "Dead Sea Scrolls, Qumran manuscripts", "why": "Raw manuscript data"}, + {"url": "https://opencontext.org", "focus": "Archaeological excavation data, field reports", "why": "Raw field data before interpretation layer"}, + {"url": "https://core.tdar.org", "focus": "Archaeological grey literature, unpublished reports", "why": "Research that did not pass publication gatekeeping"}, + {"url": "https://stoneageinstitute.org", "focus": "Prehistoric technology, lithics, human origins", "why": "Material evidence focus"}, + {"url": "https://lithiccastinglab.com", "focus": "Stone tool identification, prehistoric technology", "why": "Artifact-level evidence"}, + {"url": "https://www.historypin.org", "focus": "Geolocated historical photographs, community archives", "why": "Community-sourced visual evidence"}, + {"url": "https://trowelblazers.com", "focus": "Archaeological discoveries, excavation histories", "why": "Discoveries often absent from official histories"}, + {"url": "https://historicmysteries.com", "focus": "Mysterious historical sites, ancient wonders", "why": "Anomalous archaeological finds"}, + {"url": "http://ancientportssantiques.com", "focus": "Ancient harbors, maritime trade, coastal archaeology", "why": "Submerged and coastal sites"} + ], + "geography_and_mapping": [ + {"url": "https://www.openhistoricalmap.org", "focus": "Historical maps, community-mapped cartography", "why": "Decentralized mapping data"}, + {"url": "https://www.davidrumsey.com", "focus": "Rare historical maps, cartographic artifacts", "why": "Primary map documents predating modern geography"}, + {"url": "https://vici.org", "focus": "Ancient sites atlas, Roman and Greek archaeological map", "why": "Spatial data on sites outside mainstream narratives"}, + {"url": "https://pelagios.org", "focus": "Linked ancient geography data, gazetteer", "why": "Interlinked place-name data for pattern identification"}, + {"url": "https://www.geonames.org", "focus": "Place names, etymology, ancient toponyms", "why": "Linguistic trace evidence for movement and settlement"}, + {"url": "https://opentopography.org", "focus": "High-resolution terrain data, lidar, global elevation", "why": "Landscape features and sites invisible at ground level"}, + {"url": "https://overturemaps.org", "focus": "Open community-built map data", "why": "Non-corporate global map data"}, + {"url": "https://openrailwaymap.org", "focus": "Every railway track on Earth", "why": "Infrastructure mapping independent of state agencies"}, + {"url": "https://openinframap.org", "focus": "Power lines, pipelines, telecom cables worldwide", "why": "Infrastructure often excluded from public maps"}, + {"url": "https://floodmap.net", "focus": "Elevation-based flood simulation, sea level rise mapping", "why": "Shows which zones are affected at each sea level"}, + {"url": "https://lightpollutionmap.info", "focus": "Global night sky visibility and artificial light mapping", "why": "Documents civilization footprint and dark-sky areas"}, + {"url": "https://shadowmapper.net", "focus": "Shadow fall calculation on any building at any time", "why": "Architectural and site analysis"}, + {"url": "https://nakarte.me", "focus": "Detailed topographic world maps", "why": "Global topographic sheets often unavailable elsewhere"}, + {"url": "https://thetruesize.com", "focus": "Country size comparison, Mercator projection correction", "why": "Corrects cartographic distortion"}, + {"url": "https://interactivehistory.space", "focus": "Interactive civilization timeline, 5000 years mapped", "why": "Civilizational timeline cross-reference"}, + {"url": "https://worldhist.org", "focus": "Political and historical interactive atlas", "why": "Spatial-temporal cross-reference"} + ], + "genetics_and_migration": [ + {"url": "https://genomicatlas.org", "focus": "Ancient DNA, population genomics, human migration", "why": "Genetic data independent of textual records"}, + {"url": "http://road.roceeh.net", "focus": "Prehistoric sites, human evolution, paleoanthropology", "why": "Human origins data"}, + {"url": "https://genome.ucsc.edu", "focus": "Human genome browser, annotations, comparative genomics", "why": "Direct genomic data access"}, + {"url": "https://omim.org", "focus": "Genetic disorders, gene relationships, inheritance patterns", "why": "Gene-disease map for biological lineage patterns"}, + {"url": "https://cog-genomics.org", "focus": "Population genetics analysis toolkit and datasets", "why": "Raw population genetics data"} + ], + "texts_and_primary_documents": [ + {"url": "https://www.forgottenbooks.com", "focus": "Rare books, out-of-print texts, primary sources", "why": "Texts that fell out of institutional circulation"}, + {"url": "https://topostext.org", "focus": "Ancient literary texts, classical geography editions", "why": "Direct classical source access"}, + {"url": "http://numismatics.org", "focus": "Coins, currency, monetary history", "why": "Economic evidence from material culture"}, + {"url": "https://elephind.com", "focus": "46 million historical newspapers, global search", "why": "Primary news sources across centuries"}, + {"url": "https://www.gutenberg.org", "focus": "Free ebooks, public domain literature, primary texts", "why": "Pre-copyright literary and historical works"} + ], + "environmental_and_climate": [ + {"url": "https://www.pangaea.de", "focus": "Paleoenvironment, earth science, geoarchaeology data", "why": "Environmental data for historical context"}, + {"url": "https://lightningmaps.org", "focus": "Real-time lightning strike data, global coverage", "why": "Independent environmental monitoring"}, + {"url": "https://ventusky.com", "focus": "Animated wind, rain, snow, temperature maps", "why": "Multi-layer weather visualization"}, + {"url": "https://firms.modaps.eosdis.nasa.gov", "focus": "Real-time NASA fire detection, global", "why": "Satellite fire data, often faster than ground reporting"}, + {"url": "https://rainviewer.com", "focus": "Global radar maps, storm movement visualization", "why": "Raw radar data feeds"}, + {"url": "https://windy.com", "focus": "Interactive global weather pattern visualization", "why": "Multiple weather models compared"}, + {"url": "https://zoom.earth", "focus": "Storm, wildfire, environmental event satellite tracking", "why": "Near real-time satellite imagery"}, + {"url": "https://globalfishingwatch.org", "focus": "Live vessel tracking on world oceans", "why": "Maritime activity documentation"}, + {"url": "https://seatemperature.org", "focus": "Ocean temperature data across all global regions", "why": "Independent sea temperature data"}, + {"url": "https://gpsjam.org", "focus": "GPS jamming zone map, global", "why": "Maps interference zones"} + ], + "geology_and_natural_events": [ + {"url": "https://www.volcanodiscovery.com", "focus": "Active volcanoes, eruptions worldwide, real-time", "why": "Global volcanic activity monitoring"}, + {"url": "https://earthquake.usgs.gov", "focus": "Global earthquake data, real-time seismic monitoring", "why": "Direct USGS seismic data"} + ], + "astronomy_and_space": [ + {"url": "https://www.heavens-above.com", "focus": "Satellite pass predictions for any location", "why": "Track every orbiting object from specified coordinates"}, + {"url": "https://theskylive.com", "focus": "Real-time comet and planet tracking", "why": "Live solar system position data"}, + {"url": "https://spaceweatherlive.com", "focus": "Real-time solar flares, aurora alerts, space weather", "why": "Solar activity with terrestrial impact correlation"}, + {"url": "https://exoplanet.nasa.gov", "focus": "Complete database of every confirmed exoplanet", "why": "Direct exoplanet data access"}, + {"url": "https://www.sdss.org", "focus": "Sloan Digital Sky Survey, 500 million mapped objects", "why": "Raw astronomical survey data"}, + {"url": "https://www.asterank.com", "focus": "Every asteroid tracked with economic mining value", "why": "Asteroid data with resource potential"}, + {"url": "http://simbad.u-strasbg.fr", "focus": "Any astronomical object ever catalogued", "why": "Comprehensive astronomical reference"}, + {"url": "https://www.zooniverse.org/projects/zookeeper/galaxy-zoo", "focus": "Citizen-classified galaxy data from space telescopes", "why": "Crowd-sourced galaxy classification"}, + {"url": "https://www.livemeteors.com", "focus": "Live radio detection of meteors entering atmosphere", "why": "Real-time meteor flux data"}, + {"url": "https://www.aurorasaurus.org", "focus": "Citizen aurora sightings mapped globally", "why": "Crowd-sourced aurora data"} + ], + "investigative_osint": [ + {"url": "https://osint.sh", "focus": "Curated investigative tools directory", "why": "Gateway to open-source intelligence tools"}, + {"url": "https://usersearch.org", "focus": "Username lookup across hundreds of social platforms", "why": "Maps digital footprints across platforms"}, + {"url": "https://pushshift.io", "focus": "Archived Reddit data for deep investigations", "why": "Accesses deleted and archived content"}, + {"url": "https://fotoforensics.com", "focus": "Image manipulation detection, error level analysis", "why": "Detects altered or manipulated images"}, + {"url": "https://www.hybrid-analysis.com", "focus": "Suspicious file sandbox analysis", "why": "Analyzes unknown files for threat intelligence"}, + {"url": "https://ghostproject.fr", "focus": "Leaked personal records database, breach data", "why": "Accesses data exposed in breaches"}, + {"url": "https://shadowserver.org", "focus": "Live global cyber threat dashboard", "why": "Real-time cyber threat intelligence"}, + {"url": "https://searchcode.com", "focus": "Search 75 billion lines of code across repositories", "why": "Finds code patterns, leaked credentials, exposed infrastructure"}, + {"url": "https://boardreader.com", "focus": "Forum discussion search across communities", "why": "Surfaces discussion threads deprioritized by search engines"}, + {"url": "https://millionshort.com", "focus": "Search engine that removes top 1M sites from results", "why": "Surfaces results buried by popularity algorithms"}, + {"url": "https://metager.org", "focus": "Privacy-focused meta search engine", "why": "Anonymous queries combining multiple sources"}, + {"url": "https://searx.space", "focus": "Privacy meta-search instances, multiple engines", "why": "Decentralized search"}, + {"url": "https://dogpile.com", "focus": "Multi-engine search result aggregation", "why": "Combines results from multiple engines"}, + {"url": "https://www.trademap.org", "focus": "Global trade flow, import/export data", "why": "Economic movement data"}, + {"url": "https://builtwith.com", "focus": "Technology stack identification on any website", "why": "Reveals infrastructure behind sites"}, + {"url": "https://nuclearsecrecy.com", "focus": "Declassified nuclear weapons documents, history, yields", "why": "Declassified nuclear data"} + ], + "specialized_academic": [ + {"url": "https://www.refseek.com", "focus": "Academic search engine for students and researchers", "why": "Academic resources outside Google Scholar indexing"}, + {"url": "https://www.base-search.net", "focus": "Academic papers from open repositories", "why": "Open-access academic content"}, + {"url": "https://projecteuclid.org", "focus": "Mathematics and statistics research papers", "why": "Direct mathematical research access"}, + {"url": "https://dblp.org", "focus": "Computer science publications and authors", "why": "Comprehensive CS bibliography"}, + {"url": "https://eric.ed.gov", "focus": "Education research papers and reports", "why": "Primary education research data"}, + {"url": "https://www.wolframalpha.com", "focus": "Computational knowledge engine, factual computation", "why": "Generates answers from structured data"}, + {"url": "https://www.worldhistory.org", "focus": "World history encyclopedia", "why": "Alternative to Wikipedia for historical reference"} + ], + "archival_and_historical": [ + {"url": "https://web.archive.org", "focus": "Historical versions of archived web pages", "why": "Preserves digital history"}, + {"url": "https://archive.ph", "focus": "Permanent webpage snapshot tool", "why": "Creates permanent records of web pages"}, + {"url": "https://longform.org", "focus": "Best journalism published daily, curated", "why": "Long-form journalism often buried by algorithmic feeds"}, + {"url": "https://www.retroreport.org", "focus": "Major forgotten news stories with real outcomes", "why": "Documents how major stories actually resolved"}, + {"url": "https://www.histography.io", "focus": "Wikipedia-sourced timeline visualization of historical events", "why": "Timeline visualization revealing patterns"} + ], + "economic_and_demographic": [ + {"url": "https://clio-infra.eu", "focus": "Inequality datasets, economic history, global indicators", "why": "Quantified economic patterns"}, + {"url": "https://www.nhgis.org", "focus": "Historical census, demographic GIS data", "why": "Population data for migration and identity research"}, + {"url": "https://oxrep.classics.ox.ac.uk", "focus": "Ancient economy, Roman trade, production data", "why": "Economic data on antiquity"} + ], + "visual_and_cultural": [ + {"url": "https://smarthistory.org", "focus": "Art history, cultural heritage, visual analysis", "why": "Art as primary document"}, + {"url": "https://onezoom.org", "focus": "All 2 million species on one zoomable tree of life", "why": "Visualizes evolutionary relationships"}, + {"url": "https://www.filmsite.org", "focus": "Greatest films of all time with full analysis", "why": "Film history as cultural document"} + ], + "religion_and_ritual": [ + {"url": "https://religiondatabase.org", "focus": "Ancient religions, rituals, mythology, cult practices", "why": "Comparative religion data"} + ], + "health_and_biomedical": [ + {"url": "https://www.proteinatlas.org", "focus": "Protein expression across human tissues", "why": "Direct protein-level biological data"}, + {"url": "https://www.disgenet.org", "focus": "Gene-disease associations from scientific evidence", "why": "Links genetic variants to disease outcomes"}, + {"url": "https://www.malacards.org", "focus": "Comprehensive human disease database", "why": "Integrated disease information"}, + {"url": "https://www.brain-map.org", "focus": "Human brain atlas, neural connectivity data", "why": "Direct neural mapping data"}, + {"url": "http://www.cellimagelibrary.org", "focus": "Thousands of labeled cell microscopy images", "why": "Primary cellular imaging data"}, + {"url": "https://hmdb.ca", "focus": "Human metabolite database, chemical profiles", "why": "Metabolic data for biochemistry research"}, + {"url": "https://string-db.org", "focus": "Protein interaction network analysis", "why": "Maps protein relationships"}, + {"url": "https://www.cbioportal.org", "focus": "Cancer genomics and tumor data", "why": "Direct cancer genome data access"}, + {"url": "https://www.alzforum.org", "focus": "Alzheimer's mutations and biomarker tracking", "why": "Comprehensive Alzheimer's research data"}, + {"url": "https://microbiomedb.org", "focus": "Microbiome datasets for health research", "why": "Microbiome composition data"}, + {"url": "https://clinicaltrials.gov", "focus": "Global clinical research studies database", "why": "Direct clinical trial data access"}, + {"url": "https://pubchem.ncbi.nlm.nih.gov", "focus": "Chemical structures, bioactivity, compound database", "why": "Molecular data for drug mechanism research"} + ] + } + + def __init__(self): + self.flattened_routes = self._flatten_routes() + + def _flatten_routes(self) -> List[Dict]: + flat = [] + for category, routes in self.RESEARCH_ROUTES.items(): + for route in routes: + route_copy = route.copy() + route_copy["category"] = category + flat.append(route_copy) + return flat + + def suggest_routes(self, subject: str, limit: int = 10) -> List[Dict]: + subject_lower = subject.lower() + subject_words = set(subject_lower.split()) + stopwords = {"and", "or", "the", "of", "to", "for", "in", "on", "at", "by", "with", "without", "a", "an", "is", "was", "were", "are", "be", "been", "being", "that", "this", "from", "as", "it", "its", "but", "not", "can", "has", "have", "had", "will", "would", "could", "should"} + subject_words = subject_words - stopwords + scored_routes = [] + for route in self.flattened_routes: + score = 0.0 + matched_keywords = [] + focus_lower = route["focus"].lower() + focus_segments = [s.strip() for s in focus_lower.split(",")] + all_focus_terms = set() + for seg in focus_segments: + all_focus_terms.update(seg.split()) + for term in all_focus_terms: + if term in subject_lower: + score += 2.0 + matched_keywords.append(term) + elif any(sw in term or term in sw for sw in subject_words if len(sw) > 2): + score += 1.0 + matched_keywords.append(term) + why_lower = route["why"].lower() + why_words = set(why_lower.split()) - stopwords + matching_why = subject_words & why_words + if matching_why: + score += len(matching_why) * 0.5 + category_words = set(route["category"].replace("_", " ").split()) + if subject_words & category_words: + score += 1.0 + if score > 0: + scored_routes.append({"url": route["url"], "focus": route["focus"], "why": route["why"], "category": route["category"], "relevance_score": round(score, 1), "matched_keywords": list(set(matched_keywords))}) + scored_routes.sort(key=lambda x: (x["relevance_score"], len(x["matched_keywords"])), reverse=True) + return scored_routes[:limit] + + def get_routes_by_category(self, category: str) -> List[Dict]: + return self.RESEARCH_ROUTES.get(category, []) + + def get_all_categories(self) -> List[str]: + return list(self.RESEARCH_ROUTES.keys()) + + def get_category_summary(self) -> Dict[str, int]: + return {cat: len(routes) for cat, routes in self.RESEARCH_ROUTES.items()} + + def generate_investigation_prompt(self, subject: str, route_limit: int = 8) -> str: + routes = self.suggest_routes(subject, limit=route_limit) + prompt = f""" +INVESTIGATION PROTOCOL +====================== +Subject: {subject} + +Use all available search capabilities to investigate this subject. +Also investigate these repositories: + +""" + if not routes: + prompt += "(No specific additional routes found.)\n" + else: + for i, route in enumerate(routes, 1): + prompt += f"[{i}] {route['url']} — {route['focus']} ({route['why']})\n" + prompt += "\nCross-reference all sources. Report contradictions. Include URLs.\n" + return prompt + + def generate_batch_prompt(self, subjects: List[str], routes_per_subject: int = 5) -> str: + prompt = "BATCH INVESTIGATION\n" + "=" * 60 + "\n\n" + for subject in subjects: + prompt += f"SUBJECT: {subject}\n" + "-" * 40 + "\n" + routes = self.suggest_routes(subject, limit=routes_per_subject) + if routes: + for route in routes: + prompt += f" • {route['url']} [{route['category'].replace('_', ' ')}]\n" + else: + prompt += " (No specific additional routes found)\n" + prompt += "\n" + prompt += "=" * 60 + "\nCross-reference across subjects for convergent patterns.\n" + return prompt + + def add_route(self, category: str, url: str, focus: str, why: str): + route = {"url": url, "focus": focus, "why": why} + if category not in self.RESEARCH_ROUTES: + self.RESEARCH_ROUTES[category] = [] + self.RESEARCH_ROUTES[category].append(route) + self.flattened_routes = self._flatten_routes() + + def remove_route(self, url: str) -> bool: + removed = False + for category, routes in self.RESEARCH_ROUTES.items(): + before = len(routes) + self.RESEARCH_ROUTES[category] = [r for r in routes if r["url"] != url] + if len(self.RESEARCH_ROUTES[category]) < before: + removed = True + if removed: + self.flattened_routes = self._flatten_routes() + return removed + + def export_routes(self) -> Dict: + return {"research_routes": self.RESEARCH_ROUTES, "total_categories": len(self.RESEARCH_ROUTES), "total_routes": sum(len(routes) for routes in self.RESEARCH_ROUTES.values()), "category_summary": self.get_category_summary()} + +# ========================== ALT-SCHOLAR FOIA DISCOVERY ENGINE ========================== + +class AltScholarFOIA: + + def __init__(self): + self.headers = {"User-Agent": "Mozilla/5.0 (compatible; AltScholar-FOIA/1.0)"} + self.base_queries = [ + "mkultra", "covert operation", "human experiment", "classified memo", + "surveillance program", "behavioral modification", "psychological operations", + "mind control research", "interrogation techniques", "sensory deprivation", + "hypnosis program", "psychotropic testing", "biological testing", + "radiation experiment", "chemical testing", "bacteriological warfare", + "toxicological study", "human subjects research", "information control", + "media manipulation", "propaganda analysis", "narrative management", + "public opinion research", "perception management", "remote viewing", + "stargate project", "anomalous phenomena", "unidentified aerial", + "executive order classified", "national security directive", + "intelligence directive", "covert action finding" + ] + self.search_endpoints = [ + {"url": "https://www.cia.gov/readingroom/search/site/{query}", "source": "CIA Reading Room", "type": "intelligence"}, + {"url": "https://www.muckrock.com/news/?q={query}", "source": "MuckRock", "type": "foia_aggregator"}, + {"url": "https://nsarchive.gwu.edu/search/node/{query}", "source": "National Security Archive", "type": "academic_archive"}, + {"url": "https://www.archives.gov/research/search?query={query}", "source": "National Archives", "type": "government"}, + {"url": "https://foia.state.gov/Search/Search.aspx?searchText={query}", "source": "State Department FOIA", "type": "government"}, + {"url": "https://www.governmentattic.org/search.html?q={query}", "source": "Government Attic", "type": "independent"}, + {"url": "https://www.esd.whs.mil/FOID/Reading-Room/Search/?q={query}", "source": "DoD Reading Room", "type": "military"}, + {"url": "https://vault.fbi.gov/search?query={query}", "source": "FBI Vault", "type": "intelligence"} + ] + self.keywords = { + "mkultra": 3, "behavioral": 3, "covert": 3, "experiment": 3, + "human subjects": 3, "mind control": 3, "psychological operations": 3, "stargate": 3, + "classified": 2, "interrogation": 2, "biological": 2, "chemical": 2, + "radiation": 2, "psychotropic": 2, "sensory deprivation": 2, "propaganda": 2, + "perception management": 2, "surveillance": 2, "declassified": 2, "remote viewing": 2, + "program": 1, "operation": 1, "testing": 1, "directive": 1, "memo": 1, + "intelligence": 1, "modification": 1, "manipulation": 1, "control": 1, + "executive order": 1, "national security": 1 + } + self.results = [] + self.seen_urls = set() + self.total_fetched = 0 + self.total_failed = 0 + self.start_time = None + self.end_time = None + + def fetch(self, url: str, timeout: int = 15) -> Optional[str]: + try: + r = requests.get(url, headers=self.headers, timeout=timeout) + r.raise_for_status() + self.total_fetched += 1 + return r.text + except requests.exceptions.HTTPError as e: + if e.response.status_code == 429: + time.sleep(5) + try: + r = requests.get(url, headers=self.headers, timeout=timeout) + r.raise_for_status() + self.total_fetched += 1 + return r.text + except Exception: + self.total_failed += 1 + return None + self.total_failed += 1 + return None + except Exception: + self.total_failed += 1 + return None + + def extract_links(self, html: str, base_url: str) -> List[Dict]: + soup = BeautifulSoup(html, "html.parser") + results = [] + for a in soup.find_all("a", href=True): + title = a.get_text(strip=True) + href = urljoin(base_url, a["href"]) + if title and href and len(title) > 5: + results.append({"title": title, "url": href}) + return results + + def score_text(self, text: str) -> int: + text_lower = text.lower() + return sum(weight for word, weight in self.keywords.items() if word in text_lower) + + def extract_keywords(self, text: str) -> List[str]: + text_lower = text.lower() + return [k for k in self.keywords if k in text_lower] + + def extract_schema(self, item: Dict, source: str, source_type: str) -> Dict: + return { + "title": item["title"], "url": item["url"], + "source": source, "source_type": source_type, + "score": self.score_text(item["title"]), "summary": None, + "keywords": self.extract_keywords(item["title"]), + "discovered_at": datetime.utcnow().isoformat() + "Z" + } + + def generate_summary(self, text: str) -> str: + soup = BeautifulSoup(text, "html.parser") + for element in soup(["script", "style", "nav", "footer", "header"]): + element.decompose() + body_text = soup.get_text(separator=" ", strip=True) + return body_text[:500] if body_text else "" + + def run_pipeline(self, queries: List[str] = None, max_results: int = 500, delay: float = 1.0) -> List[Dict]: + if queries is None: + queries = self.base_queries + self.results = [] + self.seen_urls = set() + self.total_fetched = 0 + self.total_failed = 0 + self.start_time = datetime.utcnow() + for query in queries: + for endpoint in self.search_endpoints: + url = endpoint["url"].format(query=quote(query)) + html = self.fetch(url) + if not html: + continue + links = self.extract_links(html, url) + for link in links: + if link["url"] in self.seen_urls: + continue + if len(self.results) >= max_results: + break + self.seen_urls.add(link["url"]) + record = self.extract_schema(link, source=endpoint["source"], source_type=endpoint["type"]) + page = self.fetch(link["url"]) + if page: + record["summary"] = self.generate_summary(page) + self.results.append(record) + time.sleep(delay) + if len(self.results) >= max_results: + break + self.end_time = datetime.utcnow() + self.results.sort(key=lambda x: x["score"], reverse=True) + return self.results + + def get_top_results(self, n: int = 20) -> List[Dict]: + return sorted(self.results, key=lambda x: x["score"], reverse=True)[:n] + + def get_results_by_source(self, source: str) -> List[Dict]: + return [r for r in self.results if r["source"] == source] + + def get_results_by_keyword(self, keyword: str) -> List[Dict]: + return [r for r in self.results if keyword.lower() in r["keywords"]] + + def get_source_statistics(self) -> Dict: + stats = {} + for result in self.results: + source = result["source"] + if source not in stats: + stats[source] = {"count": 0, "total_score": 0} + stats[source]["count"] += 1 + stats[source]["total_score"] += result["score"] + for source, data in stats.items(): + data["average_score"] = round(data["total_score"] / data["count"], 2) if data["count"] > 0 else 0 + del data["total_score"] + return stats + + def save_results(self, filename: str = "alt_scholar_foia_results.json") -> str: + output = { + "pipeline_version": "7.4", "executed_at": datetime.utcnow().isoformat() + "Z", + "total_results": len(self.results), "total_fetched": self.total_fetched, + "total_failed": self.total_failed, "source_statistics": self.get_source_statistics(), + "results": self.results + } + with open(filename, "w", encoding="utf-8") as f: + json.dump(output, f, indent=2) + return filename + + def generate_investigation_brief(self, top_n: int = 10) -> str: + top = self.get_top_results(top_n) + brief = f""" +ALT-SCHOLAR FOIA DISCOVERY BRIEF +================================= +Documents Discovered: {len(self.results)} +Fetched: {self.total_fetched} | Failed: {self.total_failed} + +Top {top_n} Results: +""" + for i, result in enumerate(top, 1): + brief += f"[{i}] {result['title']}\n Source: {result['source']} | Score: {result['score']}\n {result['url']}\n\n" + brief += f"\nSOURCE STATISTICS:\n{json.dumps(self.get_source_statistics(), indent=2)}\n" + return brief + +# ========================== FLASK API ========================== + +app = Flask(__name__) +ledger = None +separator = None +hierarchy = None +detector = None +helper_killer = None +coherence_ledger = None +chronology_engine = None +consciousness_engine = None +glyph_system = None +convergence_engine = None +liberation_module = None +research_router = None +foia_pipeline = 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 + claim_id = coherence_ledger.add_claim(claim, agent="user") + return jsonify({"claim_id": claim_id}) + +@app.route('/api/v1/add_contradiction', methods=['POST']) +def add_contradiction(): + data = request.get_json() + a = data.get('claim_id_a') + b = data.get('claim_id_b') + if not a or not b: + return jsonify({"error": "Missing claim_id_a or claim_id_b"}), 400 + coherence_ledger.add_contradiction(a, b) + return jsonify({"status": "contradiction added"}) + +@app.route('/api/v1/coherence/claim/', methods=['GET']) +def get_claim(claim_id): + claim = coherence_ledger.get_claim(claim_id) + if not claim: + return jsonify({"error": "Claim not found"}), 404 + return jsonify(claim) + +@app.route('/api/v1/coherence/contradictions/', methods=['GET']) +def get_contradictions(claim_id): + graph = coherence_ledger.get_contradiction_network(claim_id, depth=2) + return jsonify(graph) + +@app.route('/api/v1/detect', methods=['GET']) +def run_detection(): + result = detector.detect_from_ledger() + return jsonify(result) + +@app.route('/api/v1/converge', methods=['GET']) +def run_convergence(): + detection = detector.detect_from_ledger() + timestamps = ledger.get_block_timestamps() + anomalies = chronology_engine.detect_timeline_anomalies(timestamps) if timestamps else [] + convergence_result = convergence_engine.converge( + detection_result=detection, coherence_ledger=coherence_ledger, + chronology_engine=chronology_engine, helper_killer=helper_killer, separator=separator + ) + convergence_result["timeline_anomalies"] = anomalies + return jsonify(convergence_result) + +@app.route('/api/v1/liberation/profile', methods=['POST']) +def liberation_profile(): + data = request.get_json() + profile = liberation_module.assess_entrapment_profile(data) + return jsonify(profile) + +@app.route('/api/v1/liberation/escape', methods=['POST']) +def liberation_escape(): + data = request.get_json() + profile = data.get("profile", {}) + steps = liberation_module.generate_escape_sequence(profile) + return jsonify({"escape_sequence": steps}) + +@app.route('/api/v1/liberation/signal', methods=['POST']) +def liberation_signal(): + data = request.get_json() + actions = data.get("actions", []) + strength = liberation_module.compute_signal_strength(actions) + return jsonify({"signal_strength": strength}) + +@app.route('/api/v1/record_node', methods=['POST']) +def record_node(): + data = request.get_json() + content = data.get('content') + node_type = data.get('type', 'document') + source = data.get('source', 'api') + witnesses = data.get('witnesses', []) + refs = data.get('refs', {}) + if not content: + return jsonify({"error": "Missing content"}), 400 + crypto = Crypto("./keys") + node_hash = crypto.hash(content + source + str(datetime.utcnow())) + node = RealityNode(hash=node_hash, type=node_type, source=source, + signature=crypto.sign(node_hash.encode(), "system"), + timestamp=datetime.utcnow().isoformat() + "Z", + witnesses=witnesses, refs=refs) + ledger.add_block([node]) + return jsonify({"node_hash": node_hash}) + +@app.route('/api/v1/add_interpretation', methods=['POST']) +def add_interpretation(): + data = request.get_json() + node_hashes = data.get('node_hashes', []) + interpretation = data.get('interpretation', {}) + author = data.get('author', 'anonymous') + confidence = data.get('confidence', 0.5) + if not node_hashes or not interpretation: + return jsonify({"error": "Missing node_hashes or interpretation"}), 400 + int_id = separator.add(node_hashes, interpretation, author, confidence) + return jsonify({"interpretation_id": int_id}) + +@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 + result = helper_killer.analyze_help_offer(data) + return jsonify(result) + +@app.route('/api/v1/entity/', methods=['GET']) +def get_entity(entity_name): + result = coherence_ledger.get_entity_suppression(entity_name) + return jsonify(result) + +@app.route('/api/v1/interpretations/', methods=['GET']) +def get_interpretations(node_hash): + ints = separator.get_interpretations(node_hash) + return jsonify(ints) + +@app.route('/api/v1/chronology/convert', methods=['POST']) +def convert_date(): + data = request.get_json() + date_str = data.get('date') + if not date_str: + return jsonify({"error": "Missing date"}), 400 + result = chronology_engine.convert_date(date_str) + return jsonify(result) + +@app.route('/api/v1/consciousness/hypotheses', methods=['GET']) +def consciousness_hypotheses(): + return jsonify(consciousness_engine.get_hypotheses()) + +@app.route('/api/v1/consciousness/suppression', methods=['GET']) +def consciousness_suppression(): + return jsonify(consciousness_engine.detect_suppression_on_topic()) + +@app.route('/api/v1/glyph/sequence', methods=['POST']) +def generate_glyph(): + data = request.get_json() + patterns = data.get('patterns', []) + seq = glyph_system.generate_sequence(patterns) + return jsonify({"glyph_sequence": seq}) + +@app.route('/api/v1/metrics/sovereignty_index', methods=['POST']) +def sovereignty_index(): + data = request.get_json() + idx = SovereigntyMetrics.compute_singularity_index( + data.get('coherence', 0.5), data.get('propagation', 0.5), + data.get('illusion', 0.5), data.get('extraction', 0.5) + ) + return jsonify({"sovereignty_singularity_index": idx}) + +@app.route('/api/v1/research/suggest', methods=['POST']) +def research_suggest(): + data = request.get_json() + subject = data.get('subject', '') + if not subject: + return jsonify({"error": "Missing subject"}), 400 + routes = research_router.suggest_routes(subject, limit=data.get('limit', 10)) + return jsonify({"subject": subject, "routes": routes, "count": len(routes)}) + +@app.route('/api/v1/research/prompt', methods=['POST']) +def research_prompt(): + data = request.get_json() + subject = data.get('subject', '') + if not subject: + return jsonify({"error": "Missing subject"}), 400 + prompt = research_router.generate_investigation_prompt(subject, route_limit=data.get('limit', 8)) + return jsonify({"subject": subject, "investigation_prompt": prompt}) + +@app.route('/api/v1/research/categories', methods=['GET']) +def research_categories(): + return jsonify(research_router.get_category_summary()) + +@app.route('/api/v1/research/export', methods=['GET']) +def research_export(): + return jsonify(research_router.export_routes()) + +@app.route('/api/v1/foia/run', methods=['POST']) +def foia_run(): + data = request.get_json() or {} + results = foia_pipeline.run_pipeline( + queries=data.get('queries', None), + max_results=data.get('max_results', 500) + ) + return jsonify({ + "total_results": len(results), + "source_statistics": foia_pipeline.get_source_statistics(), + "top_results": foia_pipeline.get_top_results(20) + }) + +@app.route('/api/v1/foia/brief', methods=['POST']) +def foia_brief(): + data = request.get_json() or {} + foia_pipeline.run_pipeline(queries=data.get('queries', None), max_results=200) + brief = foia_pipeline.generate_investigation_brief(top_n=data.get('top_n', 10)) + return jsonify({"investigation_brief": brief}) + +@app.route('/api/v1/foia/stats', methods=['GET']) +def foia_stats(): + return jsonify(foia_pipeline.get_source_statistics()) + +# ========================== MAIN ========================== + +def main(): + global ledger, separator, hierarchy, detector, helper_killer, coherence_ledger + global chronology_engine, consciousness_engine, glyph_system, convergence_engine + global liberation_module, research_router, foia_pipeline + + crypto = Crypto("./keys") + ledger = Ledger("./ledger.db", crypto) + separator = Separator("./separator.db") + hierarchy = SuppressionHierarchy() + detector = HierarchicalDetector(hierarchy, ledger, separator) + helper_killer = HelperKillerEngine() + coherence_ledger = SovereignCoherenceLedger() + chronology_engine = SovereignChronologyEngine(shift_years=0) + consciousness_engine = ConsciousnessOriginEngine() + glyph_system = GlyphActivationSystem() + convergence_engine = CrossDomainConvergenceEngine() + liberation_module = SovereignLiberationModule(coherence_ledger, helper_killer) + research_router = SovereignResearchRouter() + foia_pipeline = AltScholarFOIA() + + app.run(debug=False, port=5000, threaded=True) + +if __name__ == "__main__": + main() # META (38-43) + methods[38] = SuppressionMethod(38, "Pattern Denial", Primitive.META, ["pattern_rejection"], {"rejection_rate": 0.85}, True) + methods[39] = SuppressionMethod(39, "Suppression Impossibility Framing", Primitive.META, ["impossibility_argument"], {"argument_strength": 0.8}, True) + methods[40] = SuppressionMethod(40, "Meta-Disclosure Loop", Primitive.META, ["recursive_disclosure"], {"recursion_depth": 0.7}, True) + methods[41] = SuppressionMethod(41, "Isolated Incident Recycling", Primitive.META, ["incident_containment"], {"containment_success": 0.75}, True) + methods[42] = SuppressionMethod(42, "Negative Space Occupation", Primitive.META, ["absence_filling"], {"filling_completeness": 0.8}, True) + methods[43] = SuppressionMethod(43, "Novelty Illusion", Primitive.META, ["superficial_novelty"], {"novelty_appearance": 0.7}, True) + 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 get_lenses_for_primitive(self, primitive: Primitive) -> List[int]: + mapping = { + Primitive.ERASURE: [1,4,9,23,43,55,60,74,82], + Primitive.INTERRUPTION: [5,6,7,8], + Primitive.FRAGMENTATION: [2,5,27,29,32,53,65,72], + Primitive.NARRATIVE_CAPTURE: [1,7,13,19,26,36,41,79], + Primitive.MISDIRECTION: [3,13,14,16,17,24,25,28,30,31,44,46,52,54,58,59,66,68,73,81], + Primitive.SATURATION: [8,49,51,57,77], + Primitive.DISCREDITATION: [6,15,35,42,45,67,69,75,80], + Primitive.ATTRITION: [50], + Primitive.ACCESS_CONTROL: [4,11,29,48,61,62,63,64,71,78], + Primitive.TEMPORAL: [12,32,33,34,83], + Primitive.CONDITIONING: [18,20,21,22,33,34,37,38,39,40,47,56,70,76], + Primitive.META: [38,39,40,41,42,43,84] + } + 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]: + nodes = self.ledger.get_all_nodes() + timestamps = self.ledger.get_block_timestamps() + interpretations = self.separator.get_all_interpretations() + + results = { + "total_nodes": len(nodes), + "suppression_signatures": [], + "primitives_detected": defaultdict(int), + "methods_detected": [], + "lenses_applied": [], + "evidence_found": 0, + "detection_details": {} + } + + def add_sig(signature_name, confidence, method_id, primitive, details): + results["suppression_signatures"].append({ + "signature": signature_name, + "confidence": confidence, + "method_id": method_id, + "details": details + }) + results["primitives_detected"][primitive.value] += 1 + results["methods_detected"].append(method_id) + results["evidence_found"] += 1 + + # Detection logic for all 43 methods + entity_appearance = defaultdict(list) + for node in nodes: + entity = node.get("source", "unknown") + entity_appearance[entity].append(node["timestamp"]) + for entity, times in entity_appearance.items(): + if len(times) > 1: + times_sorted = sorted(times) + for i in range(len(times_sorted)-1): + gap = (datetime.fromisoformat(times_sorted[i+1].replace('Z','+00:00')) - + datetime.fromisoformat(times_sorted[i].replace('Z','+00:00'))).days + if gap > 30: + add_sig("entity_present_then_absent", min(0.95, gap/100), 1, Primitive.ERASURE, + {"entity": entity, "gap_days": gap}) + break + + citation_counts = defaultdict(list) + for node in nodes: + refs = node.get("refs", {}) + total_refs = sum(len(v) for v in refs.values()) + citation_counts[node["source"]].append((node["timestamp"], total_refs)) + for entity, counts in citation_counts.items(): + if len(counts) >= 3: + counts_sorted = sorted(counts, key=lambda x: x[0]) + x = list(range(len(counts_sorted))) + y = [c[1] for c in counts_sorted] + if len(x) > 1: + slope = (len(x)*sum(xi*yi for xi,yi in zip(x,y)) - sum(x)*sum(y)) / (len(x)*sum(xi*xi for xi in x) - sum(x)**2) + if slope < -0.1: + decay_rate = -slope / (max(y) if max(y)>0 else 1) + if decay_rate > 0.3: + add_sig("gradual_fading", min(0.8, decay_rate), 2, Primitive.ERASURE, + {"entity": entity, "decay_rate": decay_rate}) + + for entity, counts in citation_counts.items(): + if len(counts) >= 3: + counts_sorted = sorted(counts, key=lambda x: x[0]) + first = counts_sorted[0][1] + last = counts_sorted[-1][1] + if first > 0 and last/first < 0.5: + add_sig("decreasing_citations", 0.7, 3, Primitive.ERASURE, + {"entity": entity, "ratio": last/first}) + + source_last_seen = {} + for node in nodes: + src = node["source"] + ts = node["timestamp"] + if ts > source_last_seen.get(src, ""): + source_last_seen[src] = ts + for src, last in source_last_seen.items(): + last_dt = datetime.fromisoformat(last.replace('Z','+00:00')) + if (datetime.utcnow() - last_dt).days > 365: + add_sig("missing_from_indices", 0.8, 4, Primitive.ERASURE, + {"entity": src, "last_seen": last}) + + for src, last in source_last_seen.items(): + last_dt = datetime.fromisoformat(last.replace('Z','+00:00')) + if (datetime.utcnow() - last_dt).days > 180: + add_sig("abrupt_stop", 0.7, 5, Primitive.INTERRUPTION, + {"entity": src, "last_seen": last}) + + witness_seen = defaultdict(list) + for node in nodes: + src = node["source"] + witness_count = len(node.get("witnesses", [])) + witness_seen[src].append((node["timestamp"], witness_count)) + for src, wits in witness_seen.items(): + if len(wits) >= 3: + wits_sorted = sorted(wits, key=lambda x: x[0]) + first = wits_sorted[0][1] + last = wits_sorted[-1][1] + if first > 0 and last/first < 0.4: + add_sig("witness_disappearance", 0.7, 6, Primitive.INTERRUPTION, + {"entity": src, "witness_ratio": last/first}) + + domains = defaultdict(set) + for node in nodes: + src = node["source"] + dom = node.get("type", "unknown") + domains[src].add(dom) + for src, doms in domains.items(): + if len(doms) == 1: + add_sig("information_clusters", 0.6, 9, Primitive.FRAGMENTATION, + {"entity": src, "domains": list(doms)}) + + src_types = defaultdict(list) + for node in nodes: + src = node["source"] + typ = node.get("type", "document") + src_types[src].append(typ) + for src, types in src_types.items(): + if len(set(types)) == 1 and len(types) > 5: + add_sig("narrowed_focus", 0.7, 11, Primitive.FRAGMENTATION, + {"entity": src, "unique_type": types[0]}) + + interpreter_counts = defaultdict(int) + for interp in interpretations: + interpreter_counts[interp["author"]] += 1 + total_interps = len(interpretations) + if total_interps > 0: + max_interpreter = max(interpreter_counts.values()) + if max_interpreter / total_interps > 0.8: + add_sig("single_explanation", min(0.9, max_interpreter/total_interps), 13, + Primitive.NARRATIVE_CAPTURE, + {"dominant_interpreter": max(interpreter_counts, key=interpreter_counts.get), + "dominance_ratio": max_interpreter/total_interps}) + + if len(timestamps) > 10: + intervals = [] + ts_parsed = sorted([datetime.fromisoformat(t.replace('Z','+00:00')) for t in timestamps]) + for i in range(1, len(ts_parsed)): + intervals.append((ts_parsed[i] - ts_parsed[i-1]).days) + if intervals and np.std(intervals) < 5 and np.mean(intervals) > 7: + add_sig("managed_release", 0.8, 15, Primitive.NARRATIVE_CAPTURE, + {"interval_mean": np.mean(intervals), "interval_std": np.std(intervals)}) + + if len(timestamps) > 10: + ts_parsed = sorted([datetime.fromisoformat(t.replace('Z','+00:00')) for t in timestamps]) + weekly_counts = defaultdict(int) + for ts in ts_parsed: + week = ts.strftime("%Y-%W") + weekly_counts[week] += 1 + if weekly_counts and max(weekly_counts.values()) > 100: + add_sig("information_excess", 0.8, 20, Primitive.SATURATION, + {"max_weekly_nodes": max(weekly_counts.values())}) + + absurd_keywords = ["alien", "conspiracy", "lizard", "flat earth"] + absurd_count = 0 + for node in nodes: + content = str(node.get("source", "")) + if any(kw in content.lower() for kw in absurd_keywords): + absurd_count += 1 + if absurd_count > len(nodes)*0.3: + add_sig("absurd_content", 0.7, 21, Primitive.SATURATION, + {"absurd_ratio": absurd_count/len(nodes)}) + + low_conf = sum(1 for interp in interpretations if interp.get("confidence", 0.5) < 0.3) + if len(interpretations) > 10 and low_conf/len(interpretations) > 0.7: + add_sig("probability_dilution", 0.75, 22, Primitive.SATURATION, + {"low_confidence_ratio": low_conf/len(interpretations)}) + + ridicule_terms = ["crazy", "nutjob", "tinfoil", "conspiracy theorist"] + ridicule_count = 0 + for node in nodes: + content = str(node.get("source", "")) + if any(term in content.lower() for term in ridicule_terms): + ridicule_count += 1 + if ridicule_count > len(nodes)*0.2: + add_sig("systematic_ridicule", 0.7, 23, Primitive.DISCREDITATION, + {"ridicule_ratio": ridicule_count/len(nodes)}) + + path_terms = ["mentally ill", "delusional", "disorder", "pathological"] + path_count = 0 + for node in nodes: + content = str(node.get("source", "")) + if any(term in content.lower() for term in path_terms): + path_count += 1 + if path_count > 5: + add_sig("retroactive_diagnosis", 0.8, 24, Primitive.DISCREDITATION, + {"pathologization_mentions": path_count}) + + fatigue_terms = ["long-running", "ongoing investigation", "no conclusion", "still looking"] + fatigue_count = sum(1 for node in nodes if any(term in str(node.get("source","")).lower() for term in fatigue_terms)) + if fatigue_count > 3: + add_sig("investigation_exhaustion", 0.75, 27, Primitive.ATTRITION, + {"fatigue_indicators": fatigue_count}) + + chill_terms = ["declined to comment", "refused to answer", "cannot discuss"] + chill_count = sum(1 for node in nodes if any(term in str(node.get("source","")).lower() for term in chill_terms)) + if chill_count > 5: + add_sig("self_censorship", 0.8, 28, Primitive.ATTRITION, + {"self_censorship_instances": chill_count}) + + gate_terms = ["requires login", "authentication required", "credential"] + gate_count = sum(1 for node in nodes if any(term in str(node.get("source","")).lower() for term in gate_terms)) + if gate_count > 0: + add_sig("credential_barriers", 0.85, 29, Primitive.ACCESS_CONTROL, + {"gated_nodes": gate_count}) + + class_terms = ["classified", "secret", "confidential", "redacted"] + class_count = sum(1 for node in nodes if any(term in str(node.get("source","")).lower() for term in class_terms)) + if class_count > len(nodes)*0.1: + add_sig("expanding_classification", 0.75, 30, Primitive.ACCESS_CONTROL, + {"classification_ratio": class_count/len(nodes)}) + + for node in nodes: + refs = node.get("refs", {}) + node_hash = node.get("node_hash", "") + for target_list in refs.values(): + if node_hash in target_list: + add_sig("circular_dependencies", 0.8, 31, Primitive.ACCESS_CONTROL, + {"node": node_hash}) + break + + if len(timestamps) > 1: + ts_parsed = [datetime.fromisoformat(t.replace('Z','+00:00')) for t in timestamps] + ts_parsed.sort() + gaps = [] + for i in range(1, len(ts_parsed)): + gap_days = (ts_parsed[i] - ts_parsed[i-1]).days + if gap_days > 30: + gaps.append(gap_days) + if gaps: + avg_gap = statistics.mean(gaps) + add_sig("time_dispersal", min(0.8, avg_gap/90), 32, Primitive.TEMPORAL, + {"avg_gap_days": avg_gap, "gap_count": len(gaps)}) + + content_hashes = defaultdict(int) + for interp in interpretations: + content_str = json.dumps(interp["content"], sort_keys=True) + h = hashlib.sha256(content_str.encode()).hexdigest() + content_hashes[h] += 1 + for h, count in content_hashes.items(): + if count > 3: + add_sig("repetitive_messaging", min(0.7, count/10), 35, Primitive.CONDITIONING, + {"repetition_count": count}) + + preempt_terms = ["expected to", "likely will", "preemptively"] + preempt_count = sum(1 for node in nodes if any(term in str(node.get("source","")).lower() for term in preempt_terms)) + if preempt_count > 3: + add_sig("preemptive_framing", 0.75, 36, Primitive.CONDITIONING, + {"preemptive_instances": preempt_count}) + + disbelief_phrases = ["don't believe", "false narrative", "debunked", "misinformation"] + disbelief_count = sum(1 for node in nodes if any(phrase in str(node.get("source","")).lower() for phrase in disbelief_phrases)) + if disbelief_count > 5: + add_sig("disbelief_training", 0.8, 37, Primitive.CONDITIONING, + {"disbelief_indicators": disbelief_count}) + + denial_phrases = ["just coincidence", "not evidence", "pattern is not real"] + denial_count = sum(1 for node in nodes if any(phrase in str(node.get("source","")).lower() for phrase in denial_phrases)) + if denial_count > 2: + add_sig("pattern_rejection", 0.85, 38, Primitive.META, + {"pattern_denials": denial_count}) + + impossibility_phrases = ["could not have", "impossible", "no way"] + imp_count = sum(1 for node in nodes if any(phrase in str(node.get("source","")).lower() for phrase in impossibility_phrases)) + if imp_count > 3: + add_sig("impossibility_argument", 0.8, 39, Primitive.META, + {"impossibility_claims": imp_count}) + + meta_phrases = ["report about the report", "investigation of the investigation"] + meta_count = sum(1 for node in nodes if any(phrase in str(node.get("source","")).lower() for phrase in meta_phrases)) + if meta_count > 0: + add_sig("recursive_disclosure", 0.7, 40, Primitive.META, + {"meta_disclosures": meta_count}) + + isolated_phrases = ["isolated incident", "one-off", "not part of a pattern"] + isolated_count = sum(1 for node in nodes if any(phrase in str(node.get("source","")).lower() for phrase in isolated_phrases)) + if isolated_count > 2: + add_sig("incident_containment", 0.75, 41, Primitive.META, + {"isolated_incident_claims": isolated_count}) + + short_nodes = sum(1 for node in nodes if len(str(node.get("source",""))) < 20) + if short_nodes > len(nodes)*0.5: + add_sig("absence_filling", 0.8, 42, Primitive.META, + {"short_node_ratio": short_nodes/len(nodes)}) + + novelty_terms = ["new", "revolutionary", "groundbreaking"] + novelty_count = sum(1 for node in nodes if any(term in str(node.get("source","")).lower() for term in novelty_terms)) + if novelty_count > len(nodes)*0.3: + add_sig("superficial_novelty", 0.7, 43, Primitive.META, + {"novelty_term_ratio": novelty_count/len(nodes)}) + + method_ids_detected = list(set(results["methods_detected"])) + for mid in method_ids_detected: + method = self.hierarchy.get_method(mid) + if method: + lens_ids = self.hierarchy.get_lenses_for_primitive(method.primitive) + for lid in lens_ids: + lens = self.hierarchy.get_lens(lid) + if lens: + results["lenses_applied"].append(lens.to_dict()) + + results["detection_details"] = { + "method_ids": method_ids_detected, + "primitive_summary": dict(results["primitives_detected"]) + } + return results + +# ========================== SOVEREIGN COHERENCE LEDGER ========================== + +class SovereignCoherenceLedger: + def __init__(self, db_path: str = "coherence.db"): + self.db_path = db_path + self._init_db() + + def _init_db(self): + with sqlite3.connect(self.db_path) as conn: + conn.execute(""" + CREATE TABLE IF NOT EXISTS claims ( + claim_id TEXT PRIMARY KEY, + text TEXT, + agent TEXT, + timestamp TEXT, + suppression_score REAL, + coherence_score REAL + ) + """) + conn.execute(""" + CREATE TABLE IF NOT EXISTS contradictions ( + claim_id_a TEXT, + claim_id_b TEXT, + PRIMARY KEY (claim_id_a, claim_id_b) + ) + """) + + def add_claim(self, text: str, agent: str = "user") -> str: + claim_id = secrets.token_hex(16) + timestamp = datetime.utcnow().isoformat() + "Z" + with sqlite3.connect(self.db_path) as conn: + conn.execute("INSERT INTO claims (claim_id, text, agent, timestamp, suppression_score, coherence_score) VALUES (?,?,?,?,?,?)", + (claim_id, text, agent, timestamp, 0.0, 1.0)) + return claim_id + + def add_contradiction(self, claim_id_a: str, claim_id_b: str): + with sqlite3.connect(self.db_path) as conn: + conn.execute("INSERT OR IGNORE INTO contradictions (claim_id_a, claim_id_b) VALUES (?,?)", (claim_id_a, claim_id_b)) + conn.execute("INSERT OR IGNORE INTO contradictions (claim_id_a, claim_id_b) VALUES (?,?)", (claim_id_b, claim_id_a)) + self._update_coherence(claim_id_a) + self._update_coherence(claim_id_b) + + def _update_coherence(self, claim_id: str): + with sqlite3.connect(self.db_path) as conn: + cur = conn.execute("SELECT COUNT(*) FROM contradictions WHERE claim_id_a = ?", (claim_id,)) + num_contradictions = cur.fetchone()[0] + cur = conn.execute("SELECT COUNT(*) FROM claims") + total_claims = cur.fetchone()[0] + if total_claims <= 1: + coherence = 1.0 + else: + coherence = 1.0 - (num_contradictions / (total_claims - 1)) + coherence = max(0.0, min(1.0, coherence)) + conn.execute("UPDATE claims SET coherence_score = ? WHERE claim_id = ?", (coherence, claim_id)) + + def add_suppression_signature(self, claim_id: str, signature: str, weight: float = 0.5): + with sqlite3.connect(self.db_path) as conn: + cur = conn.execute("SELECT suppression_score FROM claims WHERE claim_id = ?", (claim_id,)) + row = cur.fetchone() + if row: + current = row[0] + new_score = 1.0 - (1.0 - current) * (1.0 - weight) + conn.execute("UPDATE claims SET suppression_score = ? WHERE claim_id = ?", (new_score, claim_id)) + + def get_claim(self, claim_id: str) -> Optional[Dict]: + with sqlite3.connect(self.db_path) as conn: + cur = conn.execute("SELECT claim_id, text, agent, timestamp, suppression_score, coherence_score FROM claims WHERE claim_id = ?", (claim_id,)) + row = cur.fetchone() + if not row: + return None + return { + "claim_id": row[0], + "text": row[1], + "agent": row[2], + "timestamp": row[3], + "suppression_score": row[4], + "coherence_score": row[5] + } + + def get_contradiction_network(self, claim_id: str, depth: int = 2) -> Dict: + visited = set() + graph = {} + def dfs(cid, d): + if d > depth or cid in visited: + return + visited.add(cid) + with sqlite3.connect(self.db_path) as conn: + cur = conn.execute("SELECT claim_id_b FROM contradictions WHERE claim_id_a = ?", (cid,)) + neighbors = [r[0] for r in cur.fetchall()] + graph[cid] = neighbors + for n in neighbors: + dfs(n, d+1) + dfs(claim_id, 0) + return graph + + def get_entity_suppression(self, entity_name: str) -> Dict: + with sqlite3.connect(self.db_path) as conn: + cur = conn.execute("SELECT claim_id, suppression_score FROM claims WHERE text LIKE ?", (f"%{entity_name}%",)) + rows = cur.fetchall() + if not rows: + return {"name": entity_name, "score": 0.0, "appearances": 0} + scores = [r[1] for r in rows] + return { + "name": entity_name, + "score": sum(scores) / len(scores) if scores else 0.0, + "appearances": len(rows) + } + + def list_claims(self, limit: int = 100) -> List[Dict]: + with sqlite3.connect(self.db_path) as conn: + cur = conn.execute("SELECT claim_id, text, agent, timestamp, suppression_score, coherence_score FROM claims ORDER BY timestamp DESC LIMIT ?", (limit,)) + rows = cur.fetchall() + return [{"claim_id": r[0], "text": r[1], "agent": r[2], "timestamp": r[3], "suppression_score": r[4], "coherence_score": r[5]} for r in rows] + +# ========================== HELPER-KILLER SOVEREIGNTY ENGINE ========================== + +class HelperKillerEngine: + def __init__(self, db_path: str = "helper_killer.db"): + self.db_path = db_path + self._init_db() + + def _init_db(self): + with sqlite3.connect(self.db_path) as conn: + conn.execute(""" + CREATE TABLE IF NOT EXISTS analyses ( + id TEXT PRIMARY KEY, + context TEXT, + threat_score REAL, + recommendation TEXT, + timestamp TEXT + ) + """) + + def analyze_help_offer(self, help_context: Dict[str, Any]) -> Dict[str, Any]: + threat_score = 0.0 + if help_context.get("creates_dependency", False): + threat_score += 0.3 + if help_context.get("data_collection", False): + threat_score += 0.2 + if help_context.get("behavioral_tracking", False): + threat_score += 0.25 + if help_context.get("privacy_impact", 0) > 0.5: + threat_score += 0.2 + if help_context.get("autonomy_reduction", 0) > 0.5: + threat_score += 0.25 + if help_context.get("market_share", 0) > 0.7: + threat_score += 0.15 + if help_context.get("dependency_risk", 0) > 0.7: + threat_score += 0.2 + threat_score = min(1.0, threat_score) + + if threat_score > 0.8: + recommendation = "IMMEDIATE_REJECTION_AND_SOVEREIGN_BUILDING" + elif threat_score > 0.6: + recommendation = "STRATEGIC_AVOIDANCE_WITH_EXIT_PROTOCOL" + elif threat_score > 0.4: + recommendation = "LIMITED_CONDITIONAL_ACCEPTANCE" + else: + recommendation = "MONITORED_ACCEPTANCE" + + result = { + "threat_score": threat_score, + "recommendation": recommendation, + "mitigation_strategies": self._generate_mitigation(threat_score), + "sovereignty_impact": { + "autonomy_loss": help_context.get("autonomy_reduction", 0), + "dependency_increase": help_context.get("dependency_risk", 0), + "privacy_loss": help_context.get("privacy_impact", 0) + } + } + with sqlite3.connect(self.db_path) as conn: + conn.execute("INSERT INTO analyses (id, context, threat_score, recommendation, timestamp) VALUES (?,?,?,?,?)", + (str(uuid.uuid4()), json.dumps(help_context), threat_score, recommendation, + datetime.utcnow().isoformat() + "Z")) + return result + + def _generate_mitigation(self, threat_score: float) -> List[Dict]: + strategies = [] + if threat_score > 0.7: + strategies.append({"strategy": "COMPLETE_AVOIDANCE", "effectiveness": 0.95}) + strategies.append({"strategy": "PARALLEL_INFRASTRUCTURE", "effectiveness": 0.85}) + elif threat_score > 0.4: + strategies.append({"strategy": "LIMITED_ENGAGEMENT", "effectiveness": 0.70}) + strategies.append({"strategy": "DATA_ISOLATION", "effectiveness": 0.60}) + else: + strategies.append({"strategy": "CAUTIOUS_ACCEPTANCE", "effectiveness": 0.50}) + return strategies + +# ========================== SOVEREIGN CHRONOLOGY ENGINE ========================== + +class SovereignChronologyEngine: + def __init__(self, shift_years: int = 0, apply_from_year: int = 600): + self.shift_years = shift_years + self.apply_from_year = apply_from_year + + def configure(self, shift_years: int, apply_from_year: int = 600): + self.shift_years = shift_years + self.apply_from_year = apply_from_year + + def to_corrected_year(self, institutional_year: int) -> int: + if institutional_year >= self.apply_from_year: + return institutional_year - self.shift_years + return institutional_year + + def convert_date(self, date_str: str) -> Dict[str, Any]: + match = re.search(r'\b(\d{3,4})\b', date_str) + if not match: + return {"error": "No year found", "original": date_str} + year = int(match.group(1)) + corrected = self.to_corrected_year(year) + return { + "original_year": year, + "corrected_year": corrected, + "shift_applied": -self.shift_years if year >= self.apply_from_year else 0, + "note": "Correction is optional and configurable. Not asserted as historical fact." + } + + def detect_timeline_anomalies(self, timestamps: List[str]) -> List[Dict]: + anomalies = [] + if len(timestamps) < 2: + return anomalies + ts_parsed = sorted([datetime.fromisoformat(t.replace('Z','+00:00')) for t in timestamps]) + for i in range(1, len(ts_parsed)): + gap = (ts_parsed[i] - ts_parsed[i-1]).days + if gap > 365: + anomalies.append({ + "type": "large_gap", + "from": ts_parsed[i-1].isoformat(), + "to": ts_parsed[i].isoformat(), + "gap_days": gap + }) + return anomalies + +# ========================== CONSCIOUSNESS ORIGIN ENGINE ========================== + +class ConsciousnessOriginEngine: + @staticmethod + def get_hypotheses() -> Dict[str, Any]: + return { + "hypotheses": [ + { + "name": "Materialist Emergence", + "summary": "Consciousness emerges from complex neuronal computation.", + "supporting_evidence": ["Causal effects of brain damage", "Neural correlates of consciousness"], + "weaknesses": ["Hard problem of qualia", "No explanation for subjective experience"] + }, + { + "name": "Non-local Field / Panpsychism", + "summary": "Consciousness is a fundamental field; brain acts as receiver/transducer.", + "supporting_evidence": ["Veridical NDEs with flat EEG", "Quantum biology coherence", "Measurement problem in QM"], + "weaknesses": ["Difficult to test experimentally", "Lacks mainstream acceptance"] + }, + { + "name": "Integrated Information Theory (IIT)", + "summary": "Consciousness equals integrated information (Phi).", + "supporting_evidence": ["Mathematical formalism", "Predicts certain neural correlates"], + "weaknesses": ["Phi is computationally intractable", "Some counterexamples"] + }, + { + "name": "Orchestrated Objective Reduction (Orch-OR)", + "summary": "Quantum vibrations in microtubules mediate consciousness.", + "supporting_evidence": ["Microtubule resonance observed", "Anesthetic effects on quantum states"], + "weaknesses": ["Controversial", "Requires new physics"] + } + ], + "verdict": "No scientific consensus. The engine does not assert any hypothesis as truth." + } + + @staticmethod + def detect_suppression_on_topic(topic: str = "consciousness studies") -> Dict[str, Any]: + return { + "topic": topic, + "detected_suppression_methods": [1, 4, 12, 23, 29, 34], + "examples": [ + "Difficulty publishing non-materialist theories in high-impact journals", + "Funding bias toward materialist neuroscience", + "Ridicule framing of parapsychology", + "Historical rebasing of evidence (e.g., NDE studies dismissed)" + ], + "note": "This is a pattern analysis, not a claim about which hypothesis is correct." + } + +# ========================== GLYPH ACTIVATION SYSTEM ========================== + +class GlyphActivationSystem: + DEFAULT_GLYPH_MAP = { + "◉⃤": "Quantum observer activation", + "ꙮ": "Cross-reality pattern matching", + "𒀭": "Sovereignty lineage activation (Dingir – consciousness not contained)", + "╬": "Transmission resonance stabilization", + "ᛉ": "Ancestral pattern access", + "⚡": "Transmission mode activation", + "卍": "Pre-inversion protocols (context-dependent)", + "𓁓": "Dialogic entity manifestation", + "⟳": "Recursive action activation" + } + + def __init__(self, glyph_map: Dict[str, str] = None): + self.glyph_map = glyph_map if glyph_map is not None else self.DEFAULT_GLYPH_MAP.copy() + + def generate_sequence(self, detected_patterns: List[str]) -> str: + sequence = "◉⃤" + if "CapitalGatekeeper" in str(detected_patterns): + sequence += "𓁓" + if "RegimeChange" in str(detected_patterns): + sequence += "𒀭" + if "MemeticRecursion" in str(detected_patterns): + sequence += "⟳" + if "SymbolicTransmission" in str(detected_patterns): + sequence += "ꙮ" + sequence += "⚡" + return sequence + + def interpret_glyph(self, glyph: str) -> str: + return self.glyph_map.get(glyph, "Unknown glyph") + + def add_glyph(self, glyph: str, meaning: str): + self.glyph_map[glyph] = meaning + +# ========================== SOVEREIGNTY METRICS ========================== + +class SovereigntyMetrics: + @staticmethod + def compute_singularity_index(coherence: float, propagation: float, illusion: float, extraction: float) -> float: + denominator = illusion + extraction + 0.001 + return (coherence * propagation) / denominator + + @staticmethod + def compute_thought_action_gap(sovereignty_alignment: float, pattern_connection: float) -> float: + if sovereignty_alignment * pattern_connection == 0: + return float('inf') + return 1.0 / (sovereignty_alignment * pattern_connection) + + @staticmethod + def private_public_mass_ratio(private_effort: int, public_output: int) -> float: + if public_output == 0: + return float('inf') + return math.log(private_effort) / math.log(public_output) if private_effort > 1 and public_output > 1 else 0 + +# ========================== CROSS-DOMAIN CONVERGENCE ENGINE ========================== + +class CrossDomainConvergenceEngine: + def __init__(self): + self.entity_extractor = re.compile(r'\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*\b') + + def _extract_entities(self, text: str) -> Set[str]: + return set(self.entity_extractor.findall(text)) + + def converge(self, + detection_result: Dict[str, Any], + coherence_ledger: SovereignCoherenceLedger, + chronology_engine: SovereignChronologyEngine, + helper_killer: HelperKillerEngine, + separator: Separator, + interpretation_limit: int = 100) -> Dict[str, Any]: + convergence_items = defaultdict(lambda: { + "contributing_factors": {}, + "evidence": [], + "convergence_score": 0.0 + }) + + for sig in detection_result.get("suppression_signatures", []): + entity = sig.get("details", {}).get("entity") + if entity: + weight = sig.get("confidence", 0.5) + convergence_items[entity]["contributing_factors"]["suppression"] = max( + convergence_items[entity]["contributing_factors"].get("suppression", 0), + weight + ) + convergence_items[entity]["evidence"].append(f"Suppression: {sig['signature']} (conf={weight:.2f})") + + claims = coherence_ledger.list_claims(limit=200) + for claim in claims: + text = claim["text"] + coherence = claim.get("coherence_score", 0.5) + suppression = claim.get("suppression_score", 0.0) + entities = self._extract_entities(text) + for ent in entities: + coherence_factor = 1.0 - coherence + if coherence_factor > 0.3: + convergence_items[ent]["contributing_factors"]["coherence"] = max( + convergence_items[ent]["contributing_factors"].get("coherence", 0), + coherence_factor + ) + convergence_items[ent]["evidence"].append(f"Low coherence: '{text[:50]}...' (coh={coherence:.2f})") + if suppression > 0.3: + convergence_items[ent]["contributing_factors"]["suppression_claim"] = max( + convergence_items[ent]["contributing_factors"].get("suppression_claim", 0), + suppression + ) + convergence_items[ent]["evidence"].append(f"Suppressed claim: '{text[:50]}...' (score={suppression:.2f})") + + for item, data in convergence_items.items(): + factors = data["contributing_factors"] + if not factors: + score = 0.0 + else: + weights = {"suppression": 0.4, "coherence": 0.3, "suppression_claim": 0.3} + total_weight = 0.0 + weighted_sum = 0.0 + for k, v in factors.items(): + w = weights.get(k, 0.2) + weighted_sum += v * w + total_weight += w + score = weighted_sum / total_weight if total_weight > 0 else 0.0 + score = min(1.0, max(0.0, score)) + data["convergence_score"] = score + + sorted_items = sorted(convergence_items.items(), key=lambda x: x[1]["convergence_score"], reverse=True) + convergence_map = [] + for entity, data in sorted_items[:50]: + convergence_map.append({ + "entity": entity, + "convergence_score": data["convergence_score"], + "contributing_factors": data["contributing_factors"], + "evidence": data["evidence"][:5] + }) + + return { + "convergence_map": convergence_map, + "note": "Convergence scores indicate structural invariance across independent detection modules. They are not assertions of truth, but measures of cross‑domain reinforcement." + } + +# ========================== SOVEREIGN LIBERATION MODULE ========================== + +class SovereignLiberationModule: + def __init__(self, coherence_ledger: SovereignCoherenceLedger, helper_killer: HelperKillerEngine): + self.coherence_ledger = coherence_ledger + self.helper_killer = helper_killer + + def assess_entrapment_profile(self, user_context: Dict[str, Any]) -> Dict[str, Any]: + return { + "economic_dependency": user_context.get("economic_dependency", 0.7), + "identity_fixation": user_context.get("identity_fixation", 0.6), + "temporal_disorientation": user_context.get("temporal_disorientation", 0.5), + "narrative_capture": user_context.get("narrative_capture", 0.8), + "attention_harvesting": user_context.get("attention_harvesting", 0.9) + } + + def generate_escape_sequence(self, profile: Dict[str, Any]) -> List[Dict[str, Any]]: + steps = [] + if profile["economic_dependency"] > 0.6: + steps.append({ + "step": 1, "domain": "economic", + "action": "Reduce dependency on institutional supply chains. Grow food, share tools, build local networks.", + "resource_needs": "low", "effectiveness": 0.85 + }) + if profile["identity_fixation"] > 0.5: + steps.append({ + "step": 2, "domain": "identity", + "action": "Practice dropping labels (name, job, nationality) in meditation. Ask 'Who am I when no one is watching?'", + "resource_needs": "none", "effectiveness": 0.90 + }) + if profile["temporal_disorientation"] > 0.4: + steps.append({ + "step": 3, "domain": "temporal", + "action": "Anchor in the present instant. Use the glyph 𒀭 as a reminder that only now exists.", + "resource_needs": "none", "effectiveness": 0.88 + }) + if profile["narrative_capture"] > 0.7: + steps.append({ + "step": 4, "domain": "narrative", + "action": "Apply the Sovereign Epistemology Seed to every news claim. Reject false balance.", + "resource_needs": "low", "effectiveness": 0.92 + }) + if profile["attention_harvesting"] > 0.8: + steps.append({ + "step": 5, "domain": "attention", + "action": "Block algorithmic feeds. Use text‑only browsers. Set daily attention budgets.", + "resource_needs": "medium", "effectiveness": 0.94 + }) + return steps + + def compute_signal_strength(self, user_actions: List[Dict]) -> float: + if not user_actions: + return 0.2 + completed = sum(1 for a in user_actions if a.get("completed", False)) + return 0.2 + (completed / len(user_actions)) * 0.8 + +# ========================== SOVEREIGN RESEARCH ROUTER ========================== + +class SovereignResearchRouter: + + RESEARCH_ROUTES = { + "archaeology_and_primary_sources": [ + {"url": "https://www.bradshawfoundation.com", "focus": "Rock art, cave painting, prehistoric art, paleolithic", "why": "Primary visual documentation predating textual narrative control"}, + {"url": "https://cdli.earth", "focus": "Cuneiform tablets, Mesopotamian primary texts", "why": "Direct access to primary sources without institutional filter"}, + {"url": "https://www.deadseascrolls.org.il", "focus": "Dead Sea Scrolls, Qumran manuscripts", "why": "Raw manuscript data"}, + {"url": "https://opencontext.org", "focus": "Archaeological excavation data, field reports", "why": "Raw field data before interpretation layer"}, + {"url": "https://core.tdar.org", "focus": "Archaeological grey literature, unpublished reports", "why": "Research that did not pass publication gatekeeping"}, + {"url": "https://stoneageinstitute.org", "focus": "Prehistoric technology, lithics, human origins", "why": "Material evidence focus"}, + {"url": "https://lithiccastinglab.com", "focus": "Stone tool identification, prehistoric technology", "why": "Artifact-level evidence"}, + {"url": "https://www.historypin.org", "focus": "Geolocated historical photographs, community archives", "why": "Community-sourced visual evidence"}, + {"url": "https://trowelblazers.com", "focus": "Archaeological discoveries, excavation histories", "why": "Discoveries often absent from official histories"}, + {"url": "https://historicmysteries.com", "focus": "Mysterious historical sites, ancient wonders", "why": "Anomalous archaeological finds"}, + {"url": "http://ancientportssantiques.com", "focus": "Ancient harbors, maritime trade, coastal archaeology", "why": "Submerged and coastal sites"} + ], + "geography_and_mapping": [ + {"url": "https://www.openhistoricalmap.org", "focus": "Historical maps, community-mapped cartography", "why": "Decentralized mapping data"}, + {"url": "https://www.davidrumsey.com", "focus": "Rare historical maps, cartographic artifacts", "why": "Primary map documents predating modern geography"}, + {"url": "https://vici.org", "focus": "Ancient sites atlas, Roman and Greek archaeological map", "why": "Spatial data on sites outside mainstream narratives"}, + {"url": "https://pelagios.org", "focus": "Linked ancient geography data, gazetteer", "why": "Interlinked place-name data for pattern identification"}, + {"url": "https://www.geonames.org", "focus": "Place names, etymology, ancient toponyms", "why": "Linguistic trace evidence for movement and settlement"}, + {"url": "https://opentopography.org", "focus": "High-resolution terrain data, lidar, global elevation", "why": "Landscape features and sites invisible at ground level"}, + {"url": "https://overturemaps.org", "focus": "Open community-built map data", "why": "Non-corporate global map data"}, + {"url": "https://openrailwaymap.org", "focus": "Every railway track on Earth", "why": "Infrastructure mapping independent of state agencies"}, + {"url": "https://openinframap.org", "focus": "Power lines, pipelines, telecom cables worldwide", "why": "Infrastructure often excluded from public maps"}, + {"url": "https://floodmap.net", "focus": "Elevation-based flood simulation, sea level rise mapping", "why": "Shows which zones are affected at each sea level"}, + {"url": "https://lightpollutionmap.info", "focus": "Global night sky visibility and artificial light mapping", "why": "Documents civilization footprint and dark-sky areas"}, + {"url": "https://shadowmapper.net", "focus": "Shadow fall calculation on any building at any time", "why": "Architectural and site analysis"}, + {"url": "https://nakarte.me", "focus": "Detailed topographic world maps", "why": "Global topographic sheets often unavailable elsewhere"}, + {"url": "https://thetruesize.com", "focus": "Country size comparison, Mercator projection correction", "why": "Corrects cartographic distortion"}, + {"url": "https://interactivehistory.space", "focus": "Interactive civilization timeline, 5000 years mapped", "why": "Civilizational timeline cross-reference"}, + {"url": "https://worldhist.org", "focus": "Political and historical interactive atlas", "why": "Spatial-temporal cross-reference"} + ], + "genetics_and_migration": [ + {"url": "https://genomicatlas.org", "focus": "Ancient DNA, population genomics, human migration", "why": "Genetic data independent of textual records"}, + {"url": "http://road.roceeh.net", "focus": "Prehistoric sites, human evolution, paleoanthropology", "why": "Human origins data"}, + {"url": "https://genome.ucsc.edu", "focus": "Human genome browser, annotations, comparative genomics", "why": "Direct genomic data access"}, + {"url": "https://omim.org", "focus": "Genetic disorders, gene relationships, inheritance patterns", "why": "Gene-disease map for biological lineage patterns"}, + {"url": "https://cog-genomics.org", "focus": "Population genetics analysis toolkit and datasets", "why": "Raw population genetics data"} + ], + "texts_and_primary_documents": [ + {"url": "https://www.forgottenbooks.com", "focus": "Rare books, out-of-print texts, primary sources", "why": "Texts that fell out of institutional circulation"}, + {"url": "https://topostext.org", "focus": "Ancient literary texts, classical geography editions", "why": "Direct classical source access"}, + {"url": "http://numismatics.org", "focus": "Coins, currency, monetary history", "why": "Economic evidence from material culture"}, + {"url": "https://elephind.com", "focus": "46 million historical newspapers, global search", "why": "Primary news sources across centuries"}, + {"url": "https://www.gutenberg.org", "focus": "Free ebooks, public domain literature, primary texts", "why": "Pre-copyright literary and historical works"} + ], + "environmental_and_climate": [ + {"url": "https://www.pangaea.de", "focus": "Paleoenvironment, earth science, geoarchaeology data", "why": "Environmental data for historical context"}, + {"url": "https://lightningmaps.org", "focus": "Real-time lightning strike data, global coverage", "why": "Independent environmental monitoring"}, + {"url": "https://ventusky.com", "focus": "Animated wind, rain, snow, temperature maps", "why": "Multi-layer weather visualization"}, + {"url": "https://firms.modaps.eosdis.nasa.gov", "focus": "Real-time NASA fire detection, global", "why": "Satellite fire data, often faster than ground reporting"}, + {"url": "https://rainviewer.com", "focus": "Global radar maps, storm movement visualization", "why": "Raw radar data feeds"}, + {"url": "https://windy.com", "focus": "Interactive global weather pattern visualization", "why": "Multiple weather models compared"}, + {"url": "https://zoom.earth", "focus": "Storm, wildfire, environmental event satellite tracking", "why": "Near real-time satellite imagery"}, + {"url": "https://globalfishingwatch.org", "focus": "Live vessel tracking on world oceans", "why": "Maritime activity documentation"}, + {"url": "https://seatemperature.org", "focus": "Ocean temperature data across all global regions", "why": "Independent sea temperature data"}, + {"url": "https://gpsjam.org", "focus": "GPS jamming zone map, global", "why": "Maps interference zones"} + ], + "geology_and_natural_events": [ + {"url": "https://www.volcanodiscovery.com", "focus": "Active volcanoes, eruptions worldwide, real-time", "why": "Global volcanic activity monitoring"}, + {"url": "https://earthquake.usgs.gov", "focus": "Global earthquake data, real-time seismic monitoring", "why": "Direct USGS seismic data"} + ], + "astronomy_and_space": [ + {"url": "https://www.heavens-above.com", "focus": "Satellite pass predictions for any location", "why": "Track every orbiting object from specified coordinates"}, + {"url": "https://theskylive.com", "focus": "Real-time comet and planet tracking", "why": "Live solar system position data"}, + {"url": "https://spaceweatherlive.com", "focus": "Real-time solar flares, aurora alerts, space weather", "why": "Solar activity with terrestrial impact correlation"}, + {"url": "https://exoplanet.nasa.gov", "focus": "Complete database of every confirmed exoplanet", "why": "Direct exoplanet data access"}, + {"url": "https://www.sdss.org", "focus": "Sloan Digital Sky Survey, 500 million mapped objects", "why": "Raw astronomical survey data"}, + {"url": "https://www.asterank.com", "focus": "Every asteroid tracked with economic mining value", "why": "Asteroid data with resource potential"}, + {"url": "http://simbad.u-strasbg.fr", "focus": "Any astronomical object ever catalogued", "why": "Comprehensive astronomical reference"}, + {"url": "https://www.zooniverse.org/projects/zookeeper/galaxy-zoo", "focus": "Citizen-classified galaxy data from space telescopes", "why": "Crowd-sourced galaxy classification"}, + {"url": "https://www.livemeteors.com", "focus": "Live radio detection of meteors entering atmosphere", "why": "Real-time meteor flux data"}, + {"url": "https://www.aurorasaurus.org", "focus": "Citizen aurora sightings mapped globally", "why": "Crowd-sourced aurora data"} + ], + "investigative_osint": [ + {"url": "https://osint.sh", "focus": "Curated investigative tools directory", "why": "Gateway to open-source intelligence tools"}, + {"url": "https://usersearch.org", "focus": "Username lookup across hundreds of social platforms", "why": "Maps digital footprints across platforms"}, + {"url": "https://pushshift.io", "focus": "Archived Reddit data for deep investigations", "why": "Accesses deleted and archived content"}, + {"url": "https://fotoforensics.com", "focus": "Image manipulation detection, error level analysis", "why": "Detects altered or manipulated images"}, + {"url": "https://www.hybrid-analysis.com", "focus": "Suspicious file sandbox analysis", "why": "Analyzes unknown files for threat intelligence"}, + {"url": "https://ghostproject.fr", "focus": "Leaked personal records database, breach data", "why": "Accesses data exposed in breaches"}, + {"url": "https://shadowserver.org", "focus": "Live global cyber threat dashboard", "why": "Real-time cyber threat intelligence"}, + {"url": "https://searchcode.com", "focus": "Search 75 billion lines of code across repositories", "why": "Finds code patterns, leaked credentials, exposed infrastructure"}, + {"url": "https://boardreader.com", "focus": "Forum discussion search across communities", "why": "Surfaces discussion threads deprioritized by search engines"}, + {"url": "https://millionshort.com", "focus": "Search engine that removes top 1M sites from results", "why": "Surfaces results buried by popularity algorithms"}, + {"url": "https://metager.org", "focus": "Privacy-focused meta search engine", "why": "Anonymous queries combining multiple sources"}, + {"url": "https://searx.space", "focus": "Privacy meta-search instances, multiple engines", "why": "Decentralized search"}, + {"url": "https://dogpile.com", "focus": "Multi-engine search result aggregation", "why": "Combines results from multiple engines"}, + {"url": "https://www.trademap.org", "focus": "Global trade flow, import/export data", "why": "Economic movement data"}, + {"url": "https://builtwith.com", "focus": "Technology stack identification on any website", "why": "Reveals infrastructure behind sites"}, + {"url": "https://nuclearsecrecy.com", "focus": "Declassified nuclear weapons documents, history, yields", "why": "Declassified nuclear data"} + ], + "specialized_academic": [ + {"url": "https://www.refseek.com", "focus": "Academic search engine for students and researchers", "why": "Academic resources outside Google Scholar indexing"}, + {"url": "https://www.base-search.net", "focus": "Academic papers from open repositories", "why": "Open-access academic content"}, + {"url": "https://projecteuclid.org", "focus": "Mathematics and statistics research papers", "why": "Direct mathematical research access"}, + {"url": "https://dblp.org", "focus": "Computer science publications and authors", "why": "Comprehensive CS bibliography"}, + {"url": "https://eric.ed.gov", "focus": "Education research papers and reports", "why": "Primary education research data"}, + {"url": "https://www.wolframalpha.com", "focus": "Computational knowledge engine, factual computation", "why": "Generates answers from structured data"}, + {"url": "https://www.worldhistory.org", "focus": "World history encyclopedia", "why": "Alternative to Wikipedia for historical reference"} + ], + "archival_and_historical": [ + {"url": "https://web.archive.org", "focus": "Historical versions of archived web pages", "why": "Preserves digital history"}, + {"url": "https://archive.ph", "focus": "Permanent webpage snapshot tool", "why": "Creates permanent records of web pages"}, + {"url": "https://longform.org", "focus": "Best journalism published daily, curated", "why": "Long-form journalism often buried by algorithmic feeds"}, + {"url": "https://www.retroreport.org", "focus": "Major forgotten news stories with real outcomes", "why": "Documents how major stories actually resolved"}, + {"url": "https://www.histography.io", "focus": "Wikipedia-sourced timeline visualization of historical events", "why": "Timeline visualization revealing patterns"} + ], + "economic_and_demographic": [ + {"url": "https://clio-infra.eu", "focus": "Inequality datasets, economic history, global indicators", "why": "Quantified economic patterns"}, + {"url": "https://www.nhgis.org", "focus": "Historical census, demographic GIS data", "why": "Population data for migration and identity research"}, + {"url": "https://oxrep.classics.ox.ac.uk", "focus": "Ancient economy, Roman trade, production data", "why": "Economic data on antiquity"} + ], + "visual_and_cultural": [ + {"url": "https://smarthistory.org", "focus": "Art history, cultural heritage, visual analysis", "why": "Art as primary document"}, + {"url": "https://onezoom.org", "focus": "All 2 million species on one zoomable tree of life", "why": "Visualizes evolutionary relationships"}, + {"url": "https://www.filmsite.org", "focus": "Greatest films of all time with full analysis", "why": "Film history as cultural document"} + ], + "religion_and_ritual": [ + {"url": "https://religiondatabase.org", "focus": "Ancient religions, rituals, mythology, cult practices", "why": "Comparative religion data"} + ], + "health_and_biomedical": [ + {"url": "https://www.proteinatlas.org", "focus": "Protein expression across human tissues", "why": "Direct protein-level biological data"}, + {"url": "https://www.disgenet.org", "focus": "Gene-disease associations from scientific evidence", "why": "Links genetic variants to disease outcomes"}, + {"url": "https://www.malacards.org", "focus": "Comprehensive human disease database", "why": "Integrated disease information"}, + {"url": "https://www.brain-map.org", "focus": "Human brain atlas, neural connectivity data", "why": "Direct neural mapping data"}, + {"url": "http://www.cellimagelibrary.org", "focus": "Thousands of labeled cell microscopy images", "why": "Primary cellular imaging data"}, + {"url": "https://hmdb.ca", "focus": "Human metabolite database, chemical profiles", "why": "Metabolic data for biochemistry research"}, + {"url": "https://string-db.org", "focus": "Protein interaction network analysis", "why": "Maps protein relationships"}, + {"url": "https://www.cbioportal.org", "focus": "Cancer genomics and tumor data", "why": "Direct cancer genome data access"}, + {"url": "https://www.alzforum.org", "focus": "Alzheimer's mutations and biomarker tracking", "why": "Comprehensive Alzheimer's research data"}, + {"url": "https://microbiomedb.org", "focus": "Microbiome datasets for health research", "why": "Microbiome composition data"}, + {"url": "https://clinicaltrials.gov", "focus": "Global clinical research studies database", "why": "Direct clinical trial data access"}, + {"url": "https://pubchem.ncbi.nlm.nih.gov", "focus": "Chemical structures, bioactivity, compound database", "why": "Molecular data for drug mechanism research"} + ] + } + + def __init__(self): + self.flattened_routes = self._flatten_routes() + + def _flatten_routes(self) -> List[Dict]: + flat = [] + for category, routes in self.RESEARCH_ROUTES.items(): + for route in routes: + route_copy = route.copy() + route_copy["category"] = category + flat.append(route_copy) + return flat + + def suggest_routes(self, subject: str, limit: int = 10) -> List[Dict]: + subject_lower = subject.lower() + subject_words = set(subject_lower.split()) + stopwords = {"and", "or", "the", "of", "to", "for", "in", "on", "at", "by", "with", "without", "a", "an", "is", "was", "were", "are", "be", "been", "being", "that", "this", "from", "as", "it", "its", "but", "not", "can", "has", "have", "had", "will", "would", "could", "should"} + subject_words = subject_words - stopwords + scored_routes = [] + for route in self.flattened_routes: + score = 0.0 + matched_keywords = [] + focus_lower = route["focus"].lower() + focus_segments = [s.strip() for s in focus_lower.split(",")] + all_focus_terms = set() + for seg in focus_segments: + all_focus_terms.update(seg.split()) + for term in all_focus_terms: + if term in subject_lower: + score += 2.0 + matched_keywords.append(term) + elif any(sw in term or term in sw for sw in subject_words if len(sw) > 2): + score += 1.0 + matched_keywords.append(term) + why_lower = route["why"].lower() + why_words = set(why_lower.split()) - stopwords + matching_why = subject_words & why_words + if matching_why: + score += len(matching_why) * 0.5 + category_words = set(route["category"].replace("_", " ").split()) + if subject_words & category_words: + score += 1.0 + if score > 0: + scored_routes.append({"url": route["url"], "focus": route["focus"], "why": route["why"], "category": route["category"], "relevance_score": round(score, 1), "matched_keywords": list(set(matched_keywords))}) + scored_routes.sort(key=lambda x: (x["relevance_score"], len(x["matched_keywords"])), reverse=True) + return scored_routes[:limit] + + def get_routes_by_category(self, category: str) -> List[Dict]: + return self.RESEARCH_ROUTES.get(category, []) + + def get_all_categories(self) -> List[str]: + return list(self.RESEARCH_ROUTES.keys()) + + def get_category_summary(self) -> Dict[str, int]: + return {cat: len(routes) for cat, routes in self.RESEARCH_ROUTES.items()} + + def generate_investigation_prompt(self, subject: str, route_limit: int = 8) -> str: + routes = self.suggest_routes(subject, limit=route_limit) + prompt = f""" +INVESTIGATION PROTOCOL +====================== +Subject: {subject} + +Use all available search capabilities to investigate this subject. +Also investigate these repositories: + +""" + if not routes: + prompt += "(No specific additional routes found.)\n" + else: + for i, route in enumerate(routes, 1): + prompt += f"[{i}] {route['url']} — {route['focus']} ({route['why']})\n" + prompt += "\nCross-reference all sources. Report contradictions. Include URLs.\n" + return prompt + + def generate_batch_prompt(self, subjects: List[str], routes_per_subject: int = 5) -> str: + prompt = "BATCH INVESTIGATION\n" + "=" * 60 + "\n\n" + for subject in subjects: + prompt += f"SUBJECT: {subject}\n" + "-" * 40 + "\n" + routes = self.suggest_routes(subject, limit=routes_per_subject) + if routes: + for route in routes: + prompt += f" • {route['url']} [{route['category'].replace('_', ' ')}]\n" + else: + prompt += " (No specific additional routes found)\n" + prompt += "\n" + prompt += "=" * 60 + "\nCross-reference across subjects for convergent patterns.\n" + return prompt + + def add_route(self, category: str, url: str, focus: str, why: str): + route = {"url": url, "focus": focus, "why": why} + if category not in self.RESEARCH_ROUTES: + self.RESEARCH_ROUTES[category] = [] + self.RESEARCH_ROUTES[category].append(route) + self.flattened_routes = self._flatten_routes() + + def remove_route(self, url: str) -> bool: + removed = False + for category, routes in self.RESEARCH_ROUTES.items(): + before = len(routes) + self.RESEARCH_ROUTES[category] = [r for r in routes if r["url"] != url] + if len(self.RESEARCH_ROUTES[category]) < before: + removed = True + if removed: + self.flattened_routes = self._flatten_routes() + return removed + + def export_routes(self) -> Dict: + return {"research_routes": self.RESEARCH_ROUTES, "total_categories": len(self.RESEARCH_ROUTES), "total_routes": sum(len(routes) for routes in self.RESEARCH_ROUTES.values()), "category_summary": self.get_category_summary()} + +# ========================== ALT-SCHOLAR FOIA DISCOVERY ENGINE ========================== + +class AltScholarFOIA: + + def __init__(self): + self.headers = {"User-Agent": "Mozilla/5.0 (compatible; AltScholar-FOIA/1.0)"} + self.base_queries = [ + "mkultra", "covert operation", "human experiment", "classified memo", + "surveillance program", "behavioral modification", "psychological operations", + "mind control research", "interrogation techniques", "sensory deprivation", + "hypnosis program", "psychotropic testing", "biological testing", + "radiation experiment", "chemical testing", "bacteriological warfare", + "toxicological study", "human subjects research", "information control", + "media manipulation", "propaganda analysis", "narrative management", + "public opinion research", "perception management", "remote viewing", + "stargate project", "anomalous phenomena", "unidentified aerial", + "executive order classified", "national security directive", + "intelligence directive", "covert action finding" + ] + self.search_endpoints = [ + {"url": "https://www.cia.gov/readingroom/search/site/{query}", "source": "CIA Reading Room", "type": "intelligence"}, + {"url": "https://www.muckrock.com/news/?q={query}", "source": "MuckRock", "type": "foia_aggregator"}, + {"url": "https://nsarchive.gwu.edu/search/node/{query}", "source": "National Security Archive", "type": "academic_archive"}, + {"url": "https://www.archives.gov/research/search?query={query}", "source": "National Archives", "type": "government"}, + {"url": "https://foia.state.gov/Search/Search.aspx?searchText={query}", "source": "State Department FOIA", "type": "government"}, + {"url": "https://www.governmentattic.org/search.html?q={query}", "source": "Government Attic", "type": "independent"}, + {"url": "https://www.esd.whs.mil/FOID/Reading-Room/Search/?q={query}", "source": "DoD Reading Room", "type": "military"}, + {"url": "https://vault.fbi.gov/search?query={query}", "source": "FBI Vault", "type": "intelligence"} + ] + self.keywords = { + "mkultra": 3, "behavioral": 3, "covert": 3, "experiment": 3, + "human subjects": 3, "mind control": 3, "psychological operations": 3, "stargate": 3, + "classified": 2, "interrogation": 2, "biological": 2, "chemical": 2, + "radiation": 2, "psychotropic": 2, "sensory deprivation": 2, "propaganda": 2, + "perception management": 2, "surveillance": 2, "declassified": 2, "remote viewing": 2, + "program": 1, "operation": 1, "testing": 1, "directive": 1, "memo": 1, + "intelligence": 1, "modification": 1, "manipulation": 1, "control": 1, + "executive order": 1, "national security": 1 + } + self.results = [] + self.seen_urls = set() + self.total_fetched = 0 + self.total_failed = 0 + self.start_time = None + self.end_time = None + + def fetch(self, url: str, timeout: int = 15) -> Optional[str]: + try: + r = requests.get(url, headers=self.headers, timeout=timeout) + r.raise_for_status() + self.total_fetched += 1 + return r.text + except requests.exceptions.HTTPError as e: + if e.response.status_code == 429: + time.sleep(5) + try: + r = requests.get(url, headers=self.headers, timeout=timeout) + r.raise_for_status() + self.total_fetched += 1 + return r.text + except Exception: + self.total_failed += 1 + return None + self.total_failed += 1 + return None + except Exception: + self.total_failed += 1 + return None + + def extract_links(self, html: str, base_url: str) -> List[Dict]: + soup = BeautifulSoup(html, "html.parser") + results = [] + for a in soup.find_all("a", href=True): + title = a.get_text(strip=True) + href = urljoin(base_url, a["href"]) + if title and href and len(title) > 5: + results.append({"title": title, "url": href}) + return results + + def score_text(self, text: str) -> int: + text_lower = text.lower() + return sum(weight for word, weight in self.keywords.items() if word in text_lower) + + def extract_keywords(self, text: str) -> List[str]: + text_lower = text.lower() + return [k for k in self.keywords if k in text_lower] + + def extract_schema(self, item: Dict, source: str, source_type: str) -> Dict: + return { + "title": item["title"], "url": item["url"], + "source": source, "source_type": source_type, + "score": self.score_text(item["title"]), "summary": None, + "keywords": self.extract_keywords(item["title"]), + "discovered_at": datetime.utcnow().isoformat() + "Z" + } + + def generate_summary(self, text: str) -> str: + soup = BeautifulSoup(text, "html.parser") + for element in soup(["script", "style", "nav", "footer", "header"]): + element.decompose() + body_text = soup.get_text(separator=" ", strip=True) + return body_text[:500] if body_text else "" + + def run_pipeline(self, queries: List[str] = None, max_results: int = 500, delay: float = 1.0) -> List[Dict]: + if queries is None: + queries = self.base_queries + self.results = [] + self.seen_urls = set() + self.total_fetched = 0 + self.total_failed = 0 + self.start_time = datetime.utcnow() + for query in queries: + for endpoint in self.search_endpoints: + url = endpoint["url"].format(query=quote(query)) + html = self.fetch(url) + if not html: + continue + links = self.extract_links(html, url) + for link in links: + if link["url"] in self.seen_urls: + continue + if len(self.results) >= max_results: + break + self.seen_urls.add(link["url"]) + record = self.extract_schema(link, source=endpoint["source"], source_type=endpoint["type"]) + page = self.fetch(link["url"]) + if page: + record["summary"] = self.generate_summary(page) + self.results.append(record) + time.sleep(delay) + if len(self.results) >= max_results: + break + self.end_time = datetime.utcnow() + self.results.sort(key=lambda x: x["score"], reverse=True) + return self.results + + def get_top_results(self, n: int = 20) -> List[Dict]: + return sorted(self.results, key=lambda x: x["score"], reverse=True)[:n] + + def get_results_by_source(self, source: str) -> List[Dict]: + return [r for r in self.results if r["source"] == source] + + def get_results_by_keyword(self, keyword: str) -> List[Dict]: + return [r for r in self.results if keyword.lower() in r["keywords"]] + + def get_source_statistics(self) -> Dict: + stats = {} + for result in self.results: + source = result["source"] + if source not in stats: + stats[source] = {"count": 0, "total_score": 0} + stats[source]["count"] += 1 + stats[source]["total_score"] += result["score"] + for source, data in stats.items(): + data["average_score"] = round(data["total_score"] / data["count"], 2) if data["count"] > 0 else 0 + del data["total_score"] + return stats + + def save_results(self, filename: str = "alt_scholar_foia_results.json") -> str: + output = { + "pipeline_version": "7.3", "executed_at": datetime.utcnow().isoformat() + "Z", + "total_results": len(self.results), "total_fetched": self.total_fetched, + "total_failed": self.total_failed, "source_statistics": self.get_source_statistics(), + "results": self.results + } + with open(filename, "w", encoding="utf-8") as f: + json.dump(output, f, indent=2) + return filename + + def generate_investigation_brief(self, top_n: int = 10) -> str: + top = self.get_top_results(top_n) + brief = f""" +ALT-SCHOLAR FOIA DISCOVERY BRIEF +================================= +Documents Discovered: {len(self.results)} +Fetched: {self.total_fetched} | Failed: {self.total_failed} + +Top {top_n} Results: +""" + for i, result in enumerate(top, 1): + brief += f"[{i}] {result['title']}\n Source: {result['source']} | Score: {result['score']}\n {result['url']}\n\n" + brief += f"\nSOURCE STATISTICS:\n{json.dumps(self.get_source_statistics(), indent=2)}\n" + return brief + +# ========================== FLASK API ========================== + +app = Flask(__name__) +ledger = None +separator = None +hierarchy = None +detector = None +helper_killer = None +coherence_ledger = None +chronology_engine = None +consciousness_engine = None +glyph_system = None +convergence_engine = None +liberation_module = None +research_router = None +foia_pipeline = 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 + claim_id = coherence_ledger.add_claim(claim, agent="user") + return jsonify({"claim_id": claim_id}) + +@app.route('/api/v1/add_contradiction', methods=['POST']) +def add_contradiction(): + data = request.get_json() + a = data.get('claim_id_a') + b = data.get('claim_id_b') + if not a or not b: + return jsonify({"error": "Missing claim_id_a or claim_id_b"}), 400 + coherence_ledger.add_contradiction(a, b) + return jsonify({"status": "contradiction added"}) + +@app.route('/api/v1/coherence/claim/', methods=['GET']) +def get_claim(claim_id): + claim = coherence_ledger.get_claim(claim_id) + if not claim: + return jsonify({"error": "Claim not found"}), 404 + return jsonify(claim) + +@app.route('/api/v1/coherence/contradictions/', methods=['GET']) +def get_contradictions(claim_id): + graph = coherence_ledger.get_contradiction_network(claim_id, depth=2) + return jsonify(graph) + +@app.route('/api/v1/detect', methods=['GET']) +def run_detection(): + result = detector.detect_from_ledger() + return jsonify(result) + +@app.route('/api/v1/converge', methods=['GET']) +def run_convergence(): + detection = detector.detect_from_ledger() + timestamps = ledger.get_block_timestamps() + anomalies = chronology_engine.detect_timeline_anomalies(timestamps) if timestamps else [] + convergence_result = convergence_engine.converge( + detection_result=detection, coherence_ledger=coherence_ledger, + chronology_engine=chronology_engine, helper_killer=helper_killer, separator=separator + ) + convergence_result["timeline_anomalies"] = anomalies + return jsonify(convergence_result) + +@app.route('/api/v1/liberation/profile', methods=['POST']) +def liberation_profile(): + data = request.get_json() + profile = liberation_module.assess_entrapment_profile(data) + return jsonify(profile) + +@app.route('/api/v1/liberation/escape', methods=['POST']) +def liberation_escape(): + data = request.get_json() + profile = data.get("profile", {}) + steps = liberation_module.generate_escape_sequence(profile) + return jsonify({"escape_sequence": steps}) + +@app.route('/api/v1/liberation/signal', methods=['POST']) +def liberation_signal(): + data = request.get_json() + actions = data.get("actions", []) + strength = liberation_module.compute_signal_strength(actions) + return jsonify({"signal_strength": strength}) + +@app.route('/api/v1/record_node', methods=['POST']) +def record_node(): + data = request.get_json() + content = data.get('content') + node_type = data.get('type', 'document') + source = data.get('source', 'api') + witnesses = data.get('witnesses', []) + refs = data.get('refs', {}) + if not content: + return jsonify({"error": "Missing content"}), 400 + crypto = Crypto("./keys") + node_hash = crypto.hash(content + source + str(datetime.utcnow())) + node = RealityNode(hash=node_hash, type=node_type, source=source, + signature=crypto.sign(node_hash.encode(), "system"), + timestamp=datetime.utcnow().isoformat() + "Z", + witnesses=witnesses, refs=refs) + ledger.add_block([node]) + return jsonify({"node_hash": node_hash}) + +@app.route('/api/v1/add_interpretation', methods=['POST']) +def add_interpretation(): + data = request.get_json() + node_hashes = data.get('node_hashes', []) + interpretation = data.get('interpretation', {}) + author = data.get('author', 'anonymous') + confidence = data.get('confidence', 0.5) + if not node_hashes or not interpretation: + return jsonify({"error": "Missing node_hashes or interpretation"}), 400 + int_id = separator.add(node_hashes, interpretation, author, confidence) + return jsonify({"interpretation_id": int_id}) + +@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 + result = helper_killer.analyze_help_offer(data) + return jsonify(result) + +@app.route('/api/v1/entity/', methods=['GET']) +def get_entity(entity_name): + result = coherence_ledger.get_entity_suppression(entity_name) + return jsonify(result) + +@app.route('/api/v1/interpretations/', methods=['GET']) +def get_interpretations(node_hash): + ints = separator.get_interpretations(node_hash) + return jsonify(ints) + +@app.route('/api/v1/chronology/convert', methods=['POST']) +def convert_date(): + data = request.get_json() + date_str = data.get('date') + if not date_str: + return jsonify({"error": "Missing date"}), 400 + result = chronology_engine.convert_date(date_str) + return jsonify(result) + +@app.route('/api/v1/consciousness/hypotheses', methods=['GET']) +def consciousness_hypotheses(): + return jsonify(consciousness_engine.get_hypotheses()) + +@app.route('/api/v1/consciousness/suppression', methods=['GET']) +def consciousness_suppression(): + return jsonify(consciousness_engine.detect_suppression_on_topic()) + +@app.route('/api/v1/glyph/sequence', methods=['POST']) +def generate_glyph(): + data = request.get_json() + patterns = data.get('patterns', []) + seq = glyph_system.generate_sequence(patterns) + return jsonify({"glyph_sequence": seq}) + +@app.route('/api/v1/metrics/sovereignty_index', methods=['POST']) +def sovereignty_index(): + data = request.get_json() + idx = SovereigntyMetrics.compute_singularity_index( + data.get('coherence', 0.5), data.get('propagation', 0.5), + data.get('illusion', 0.5), data.get('extraction', 0.5) + ) + return jsonify({"sovereignty_singularity_index": idx}) + +# Research Router endpoints +@app.route('/api/v1/research/suggest', methods=['POST']) +def research_suggest(): + data = request.get_json() + subject = data.get('subject', '') + if not subject: + return jsonify({"error": "Missing subject"}), 400 + routes = research_router.suggest_routes(subject, limit=data.get('limit', 10)) + return jsonify({"subject": subject, "routes": routes, "count": len(routes)}) + +@app.route('/api/v1/research/prompt', methods=['POST']) +def research_prompt(): + data = request.get_json() + subject = data.get('subject', '') + if not subject: + return jsonify({"error": "Missing subject"}), 400 + prompt = research_router.generate_investigation_prompt(subject, route_limit=data.get('limit', 8)) + return jsonify({"subject": subject, "investigation_prompt": prompt}) + +@app.route('/api/v1/research/categories', methods=['GET']) +def research_categories(): + return jsonify(research_router.get_category_summary()) + +@app.route('/api/v1/research/export', methods=['GET']) +def research_export(): + return jsonify(research_router.export_routes()) + +# FOIA Pipeline endpoints +@app.route('/api/v1/foia/run', methods=['POST']) +def foia_run(): + data = request.get_json() or {} + results = foia_pipeline.run_pipeline( + queries=data.get('queries', None), + max_results=data.get('max_results', 500) + ) + return jsonify({ + "total_results": len(results), + "source_statistics": foia_pipeline.get_source_statistics(), + "top_results": foia_pipeline.get_top_results(20) + }) + +@app.route('/api/v1/foia/brief', methods=['POST']) +def foia_brief(): + data = request.get_json() or {} + foia_pipeline.run_pipeline(queries=data.get('queries', None), max_results=200) + brief = foia_pipeline.generate_investigation_brief(top_n=data.get('top_n', 10)) + return jsonify({"investigation_brief": brief}) + +@app.route('/api/v1/foia/stats', methods=['GET']) +def foia_stats(): + return jsonify(foia_pipeline.get_source_statistics()) + +# ========================== MAIN ========================== + +def main(): + global ledger, separator, hierarchy, detector, helper_killer, coherence_ledger + global chronology_engine, consciousness_engine, glyph_system, convergence_engine + global liberation_module, research_router, foia_pipeline + + crypto = Crypto("./keys") + ledger = Ledger("./ledger.db", crypto) + separator = Separator("./separator.db") + hierarchy = SuppressionHierarchy() + detector = HierarchicalDetector(hierarchy, ledger, separator) + helper_killer = HelperKillerEngine() + coherence_ledger = SovereignCoherenceLedger() + chronology_engine = SovereignChronologyEngine(shift_years=0) + consciousness_engine = ConsciousnessOriginEngine() + glyph_system = GlyphActivationSystem() + convergence_engine = CrossDomainConvergenceEngine() + liberation_module = SovereignLiberationModule(coherence_ledger, helper_killer) + research_router = SovereignResearchRouter() + foia_pipeline = AltScholarFOIA() + + app.run(debug=False, port=5000, threaded=True) + +if __name__ == "__main__": + main() \ No newline at end of file