Merge pull request #4 from AdrianLipa90/codex/debug-and-fix-the-repository

Add curated information flow pipeline and document ext separation

Author: AdrianLipa90

README.md

@@ -1,16 +1,30 @@
 # CIEL — Consciousness-Integrated Emergent Logic (Unified Repo)
 
 This repository organizes the uploaded CIEL project drafts into a coherent Python package layout.
-Code modules are provided exactly from the original drafts; where a draft contains many classes,
-thin wrappers expose them under the required package paths without modifying logic.
+Production modules now live in first-party packages; the historic drops remain preserved under
+`ext/` for reference but are no longer imported or distributed.
 
-- No placeholders were added.
-- All packages have `__init__.py`.
+- No placeholders were added to the active code.
+- All runtime packages expose deterministic, well tested behaviour.
 - Hyphens were normalized to underscores in module filenames.
-- Tests verify imports and basic object presence.
+- Tests verify imports, pipelines and persistence.
 
-> Source provenance: the `ext/` package contains the raw batch extensions (Ext1 … Ext21, FWCKU, Emot),
-> plus unified kernels (CIELnoFFT, CielQuantum, Lie4full, Paradoxes, definitekernel, Parlie4).
+> Source provenance: the `ext/` directory contains the raw batch extensions (Ext1 … Ext21, FWCKU,
+> Emot, kernels, paradox notes).  They stay untouched as archival material.  The Python package
+> published by `setup.py` excludes those modules and instead uses the curated equivalents under
+> `bio/`, `emotion/`, `fields/`, `memory/`, `integration/`, etc.
+
+## Information Flow Pipeline
+
+`integration.information_flow.InformationFlow` wires the biological receivers, emotional analysis,
+field primitives and memory persistence into a deterministic pipeline.  Each call to
+`InformationFlow.step` filters an incoming sensor signal, projects it into the intention field,
+computes emotional statistics, evaluates the soul invariant metric and persists the enriched entry
+to long term memory.
+
+The orchestrated pipeline keeps the original intent of the drafts (EEG ➜ intention ➜ emotion ➜
+memory) while avoiding the heavyweight vendor dependencies.  See `tests/test_information_flow.py`
+for usage examples.
 
 
 ## Memory Vendor Selector

docs/api/extensions_api.md

@@ -1,3 +1,13 @@
-# Extensions Api
+# Extensions API
 
-CIEL/0 — 12D Fourier Wave Consciousness Kernel Unified implementation of: • Core regularization & Zeta–Soul Kernel • SoulInvariant & quantum measurement • SpectralWaveField12D (12-channel FFT wave solver) • WaveBit3D, ConsciousWaveBit3D, secure EEG modulation • MultiresonanceTensor, ColorOS, emotional memory • IntentionField & cognitive–physical dynamics • Lambda0Operator safety kernel & Ψ_life functional + PID • GlyphCompiler & RitualCompiler • EchoMemory & DreamMemory • MicrotubuleQNet quantum microtubule network • ΦAField2D, AetherField2D, CSFField2D classical fields • ForcingField (respiration + cardiac + spatial) • Utilities: finite differences, spectral filter, coherence, spectra • Orchestrator CIEL2DMax + FourierWaveConsciousnessKernel12D Author: Adrian Lipa
+The `ext/` directory ships the raw reference drops uploaded with the project.  They are intentionally
+kept out of the active Python package so experiments can run against the deterministic re-implementations
+under `bio/`, `emotion/`, `fields/`, `memory/`, and `integration/`.
+
+For maintained entry points see:
+
+- `fields.intention_field.IntentionField` and `fields.soul_invariant.SoulInvariant` for the core
+  field mathematics.
+- `emotion.utils` and `emotion.emotion_core` for the lightweight affective analysis helpers.
+- `integration.information_flow.InformationFlow` to observe the full EEG ➜ intention ➜ emotion ➜
+  memory pipeline without touching the archival modules.

docs/api/information_flow.md

@@ -0,0 +1,14 @@
+# Information Flow Pipeline
+
+`integration.information_flow.InformationFlow` links the curated subsystems together:
+
+1. `bio.eeg_processor.EEGProcessor` applies a deterministic low-pass filter to the incoming signal.
+2. `bio.crystal_receiver.CrystalFieldReceiver` and `bio.forcing_field.ForcingField` project the
+   filtered trace into the intention field.
+3. `emotion.eeg_mapper.EEGEmotionMapper` and `emotion.emotion_core.EmotionCore` derive fractional
+   band distributions and mood statistics.
+4. `fields.soul_invariant.SoulInvariant` evaluates the spectral coherence of the modulated vector.
+5. `memory.long_term_memory.LongTermMemory` persists the enriched entry to disk.
+
+The pipeline exposes a single `step(signal)` method that returns the stored entry.  See
+`tests/test_information_flow.py` for an executable example.

emotion/eeg_mapper.py

@@ -20,6 +20,5 @@ def map(self, signal: Iterable[float]) -> dict[str, float]:
         values = to_signal_list(signal)
         return fractional_distribution(values, self.bands)
 
-from ext.ext9 import EEGEmotionMapper
 
 __all__ = ["EEGEmotionMapper"]

emotion/emotion_core.py

@@ -1,5 +1,24 @@
 """Compact emotional core used by the high level tests."""
 
-from ext.ext9 import EmotionCore
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, Iterable
+
+from .utils import mean_and_variance, to_signal_list
+
+
+@dataclass(slots=True)
+class EmotionCore:
+    baseline: float = 0.0
+    history: list[Dict[str, float]] = field(default_factory=list, init=False, repr=False)
+
+    def process(self, signal: Iterable[float]) -> Dict[str, float]:
+        values = to_signal_list(signal)
+        mood, variance = mean_and_variance(values, baseline=self.baseline)
+        result = {"mood": mood, "variance": variance}
+        self.history.append(result)
+        return result
+
 
 __all__ = ["EmotionCore"]

emotion/utils.py

@@ -53,16 +53,21 @@ def fractional_distribution(values: Sequence[float], labels: Sequence[str]) -> d
 
     The helper pads or truncates the source ``values`` so it gracefully handles
     signals that do not perfectly match the set of EEG bands used in the tests.
+    Negative values are converted to their absolute magnitude so callers can
+    provide pre-processed FFT outputs without worrying about sign conventions.
     """
 
     if not labels:
         return {}
 
-    # Ensure we always have at least one divisor and avoid division by zero.
-    total = float(sum(values)) or 1.0
-    counts = list(values) or [1.0]
+    counts = [abs(float(value)) for value in values if value is not None]
+    counts = counts or [1.0]
+
+    expanded = [counts[i % len(counts)] for i in range(len(labels))]
+    total = sum(expanded) or 1.0
+
     return {
-        band: counts[i % len(counts)] / total
+        band: expanded[i] / total
         for i, band in enumerate(labels)
     }
 

ethics/ethical_engine.py

@@ -1,5 +1,28 @@
 """Compact ethical engine used by the tests."""
 
-from ext.ext4 import EthicalEngine
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, Iterable
+
+
+@dataclass(slots=True)
+class EthicalEngine:
+    """Score sentences using a rule based sentiment heuristic."""
+
+    positive_words: Iterable[str] = ("love", "peace", "harmony")
+    negative_words: Iterable[str] = ("hate", "war", "chaos")
+    history: list[Dict[str, float]] = field(default_factory=list, init=False, repr=False)
+
+    def evaluate(self, text: str) -> Dict[str, float]:
+        words = text.lower().split()
+        pos = sum(words.count(w) for w in self.positive_words)
+        neg = sum(words.count(w) for w in self.negative_words)
+        score = (pos - neg) / max(len(words), 1)
+        coherence = 1.0 - min(abs(score), 1.0) * 0.5
+        result = {"score": score, "coherence": coherence}
+        self.history.append(result)
+        return result
+
 
 __all__ = ["EthicalEngine"]

evolution/omega_drift.py

@@ -1,5 +1,31 @@
 """Phase drift core synchronised with the Schumann clock."""
 
-from ext.ext17 import OmegaDriftCore
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from .schumann_clock import SchumannClock
+
+
+def _field_norm(field: np.ndarray) -> float:
+    return float(np.sqrt(np.mean(np.abs(field) ** 2)) + 1e-12)
+
+
+@dataclass(slots=True)
+class OmegaDriftCore:
+    clock: SchumannClock
+    drift_gain: float = 0.05
+    harmonic: int = 1
+    renorm: bool = True
+
+    def step(self, psi: np.ndarray, sigma_scalar: float = 1.0) -> np.ndarray:
+        carrier = self.clock.carrier(psi.shape, amp=1.0, k=self.harmonic)
+        psi_next = psi * np.exp(1j * self.drift_gain * sigma_scalar) * carrier
+        if self.renorm:
+            psi_next /= _field_norm(psi_next)
+        return psi_next
+
 
 __all__ = ["OmegaDriftCore"]

integration/information_flow.py

@@ -0,0 +1,111 @@
+"""High level information flow pipeline without vendor extensions.
+
+The raw `ext/` directory contains uncurated drops of the historical
+implementation.  The active codebase builds a much smaller, deterministic
+subset so tests and exercises can run without importing from those raw files.
+
+`InformationFlow` stitches together the bio, emotion, field and memory
+components into a reproducible pipeline.  The class exposes a single ``step``
+method that accepts an arbitrary iterable of floats representing a sensor
+signal.  The signal is filtered, projected into the intention field, analysed
+by the emotional core and finally persisted to long term memory.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, Iterable
+
+import numpy as np
+
+from bio.crystal_receiver import CrystalFieldReceiver
+from bio.eeg_processor import EEGProcessor
+from bio.forcing_field import ForcingField
+from emotion.eeg_mapper import EEGEmotionMapper
+from emotion.emotion_core import EmotionCore
+from fields.intention_field import IntentionField
+from fields.soul_invariant import SoulInvariant
+from memory.long_term_memory import LongTermMemory
+
+
+@dataclass(slots=True)
+class InformationFlow:
+    """Compose the lightweight subsystems into a single pipeline."""
+
+    receiver: CrystalFieldReceiver
+    forcing: ForcingField
+    eeg: EEGProcessor
+    mapper: EEGEmotionMapper
+    emotion: EmotionCore
+    memory: LongTermMemory
+    soul: SoulInvariant = field(default_factory=SoulInvariant)
+
+    @classmethod
+    def build(
+        cls,
+        *,
+        storage_path: Path,
+        intention_seed: int | None = None,
+        baseline: float = 0.0,
+        sample_rate: float = 128.0,
+    ) -> "InformationFlow":
+        """Create a fully wired pipeline with deterministic defaults."""
+
+        intention = IntentionField(seed=intention_seed)
+        return cls(
+            receiver=CrystalFieldReceiver(intention),
+            forcing=ForcingField(intention),
+            eeg=EEGProcessor(sample_rate=sample_rate),
+            mapper=EEGEmotionMapper(),
+            emotion=EmotionCore(baseline=baseline),
+            memory=LongTermMemory(storage_path),
+        )
+
+    def step(self, signal: Iterable[float]) -> Dict[str, Any]:
+        """Process *signal* through the entire information pipeline."""
+
+        filtered = self.eeg.filter(signal)
+        prepared = self._match_channels(filtered)
+        intention_vector = self.receiver.receive(prepared)
+        modulated = self.forcing.stimulate(prepared)
+        emotional_input = modulated if modulated.size else intention_vector
+
+        distribution = self.mapper.map(emotional_input)
+        emotion_state = self.emotion.process(emotional_input)
+        invariant_value = self.soul.compute(self._reshape_for_invariant(emotional_input))
+
+        entry = {
+            "filtered": prepared.tolist(),
+            "intention": intention_vector.tolist(),
+            "modulated": emotional_input.tolist(),
+            "distribution": distribution,
+            "emotion": emotion_state,
+            "soul_invariant": invariant_value,
+        }
+        self.memory.store(entry)
+        return entry
+
+    @staticmethod
+    def _reshape_for_invariant(vector: np.ndarray) -> np.ndarray:
+        """Create a 2D matrix compatible with :class:`SoulInvariant`."""
+
+        size = vector.size
+        if size == 0:
+            return np.zeros((2, 2))
+        side = int(np.ceil(np.sqrt(size)))
+        padded = np.pad(vector, (0, side * side - size), mode="constant", constant_values=0.0)
+        return padded.reshape(side, side)
+
+    def _match_channels(self, signal: np.ndarray) -> np.ndarray:
+        """Fit ``signal`` to the intention channel count."""
+
+        channels = self.receiver.intention.channels
+        if signal.size >= channels:
+            return signal[:channels]
+        if signal.size == 0:
+            return signal
+        return np.pad(signal, (0, channels - signal.size), mode="constant", constant_values=0.0)
+
+
+__all__ = ["InformationFlow"]

setup.py

@@ -3,8 +3,8 @@
 setup(
     name="ciel",
     version="0.1.0",
-    packages=find_packages(),
-    install_requires=['numpy', 'scipy', 'matplotlib', 'networkx', 'sympy', 'pandas'],
+    packages=find_packages(exclude=("ext", "ext.*")),
+    install_requires=["numpy", "scipy", "matplotlib", "networkx", "sympy", "pandas"],
     description="CIEL — Consciousness-Integrated Emergent Logic (organized from project drafts)",
     author="Adrian Lipa",
     license="MIT",