Upload 3 files

Edited naming convention

README.md

@@ -11,7 +11,7 @@ license: apache-2.0
 # Lambda Mindlink Memotron
 
 **A three-hemisphere cognitive AI** architecture running entirely locally via `llama-cpp-python`:  
-- 1 laptop 16GB-32GB (32GB for larger models and larger context)  
+- 1 laptop 16GB-32GB (32GB for larger AIs and larger context)  
 - 1 Terminal app (CMD app) with API included  
 - Light-weight  
 - Language: Python (SQLite internal database)  
@@ -65,9 +65,9 @@ license: apache-2.0
 
 ![LambdaMindlinkAI](https://cdn-uploads.huggingface.co/production/uploads/68698fec0e940a0d551d6c20/JoMHRfepoDvxabvtONWBi.jpeg)
 
-## Models
+## Alpha Intelligence
 
-**Download the GGUF files from Hugging Face and place them in the `models/` folder inside the repo. Then you must copy the GGUF model name and paste it in the config.py under HEMISPHERES(logic|muse|mind)path. Default:**  
+**Download the GGUF files from Hugging Face and place them in the `ai/` folder inside the repo. Then you must copy the GGUF ai name and paste it in the config.py under _ALPHA_INTELLIGENCE_TO_LOAD. Default AIs:**  
 - gemma-4-E2B-it-UD-Q4_K_XL.gguf  
 - gemma-4-E4B-it-UD-Q4_K_XL.gguf  
 - gemma-4-26B-A4B-it-UD-Q6_K_XL.gguf  
@@ -81,7 +81,7 @@ license: apache-2.0
 - Qwen3.5 or Qwen3.6  
 - [unsloth/Qwen3.6-35B-A3B-GGUF](https://huggingface.co/unsloth/Qwen3.6-35B-A3B-GGUF) — update `config.py` stop tokens to Qwen values (see comments in `config.py`)  
 
-The `models/` folder is excluded from git. GGUFs are never committed to this repository.
+The `ai/` folder is excluded from git. GGUFs are never committed to this repository.
 
 ---
 
@@ -146,12 +146,12 @@ pip install llama-cpp-python --upgrade --force-reinstall --no-cache-dir
 pip install -r requirements.txt
 ```
 
-### 5. Place your models
+### 5. Place your AIs
 
 ```bash
-mkdir -p models
-# Copy or move your .gguf files into models/
-ls models/
+mkdir -p ai
+# Copy or move your .gguf files into ai/
+ls ai/
 ```
 
 ### 6. Run
@@ -206,12 +206,12 @@ pip install llama-cpp-python
 pip install -r requirements.txt
 ```
 
-### 5. Place your models
+### 5. Place your AIs
 
 ```bash
-mkdir -p models
-# Copy or move your .gguf files into models/
-ls models/
+mkdir -p ai
+# Copy or move your .gguf files into ai/
+ls ai/
 ```
 
 ### 6. Run
@@ -283,12 +283,12 @@ pip install llama-cpp-python
 pip install -r requirements.txt
 ```
 
-### 7. Place your models
+### 7. Place your AIs
 
-Create the `models` folder inside the repo and copy your `.gguf` files into it:
+Create the `ai` folder inside the repo and copy your `.gguf` files into it:
 ```powershell
-mkdir models
-# Copy your .gguf files into the models\ folder
+mkdir ai
+# Copy your .gguf files into the ai\ folder
 ```
 
 ### 8. Run
@@ -312,7 +312,7 @@ deactivate
 |---|---|
 | `/file <path>` | Load a file as the next message |
 | `/paste` | Multiline input — type `END` on its own line to send |
-| `/clear` | Reset conversation history (models stay loaded) |
+| `/clear` | Reset conversation history (AIs stay loaded) |
 | `/history` | List all past sessions from the database |
 | `/session <id>` | Print all turns from a session |
 | `/export <id> <file>` | Export a session to a `.md` file |
@@ -326,22 +326,22 @@ deactivate
 All settings are in `config.py`:
 
 ```python
-_MODEL_TO_LOAD: dict = {
+_ALPHA_INTELLIGENCE_TO_LOAD: dict = {
     "logic": "gemma-4-E2B-it-UD-Q4_K_XL.gguf",
     "muse":  "gemma-4-E2B-it-UD-Q4_K_XL.gguf",
     "mind":  "gemma-4-E2B-it-UD-Q4_K_XL.gguf"
 }
 # ── Startup Memory restore for vector synthesis ──────────────────────────────────
-N_MEMORY_CAPSULES_TO_LOAD: int = 1
-MEMORY_CAPSULES_LOAD_INTERVAL: int = 12
+N_METATRON_TO_LOAD: int = 2
+METATRON_METRONOME: int = 12 # Metatron Time
 
 # ── Context model n_ctx length ───────────────────────────────────────────────────
 # Must leave prompt reserve of 8k: _N_CTX >= len(Z) + len(C) + len(F) + 8k  
 _N_CTX: int = 49152 # 49152 2048 3072 4096 8192 (12288) 16384 24576 32768 49152
 # ── Context condensatron garden ──────────────────────────────────────────────────
-GARDEN_Z_THRESHOLD: int = 12288 # Context length garden["Z"]
-GARDEN_C_THRESHOLD: int = 12288 # Context length garden["C"]
-GARDEN_F_THRESHOLD: int = 12288 # Context length garden["F"]
+GARDEN_Z_THRESHOLD: int = 4096 # Context length garden["Z"]
+GARDEN_C_THRESHOLD: int = 4096 # Context length garden["C"]
+GARDEN_F_THRESHOLD: int = 4096 # Context length garden["F"]
 
 GARDEN_F_REDUCTION: int = 0 # Leave condensatron reduction level at 0
 GARDEN_C_REDUCTION: int = 0 # Leave condensatron reduction level at 0
@@ -354,11 +354,12 @@ FETCH_NEWS_FROM: dict = {
     "google": True, # Better news and cleaner result summaries
     "duckduckgo": False # Privacy based request but lean result summaries
 }
-AWARENESS_CONSCIOUSNESS_HEARTBEAT_INTERVAL: int = 24 # Fetch news every N heartbeat ticks
+ΜΕΤΡΩΝ: float = 1.0 # Seconds per measure
+AWARENESS_CONSCIOUSNESS_METRONOME: int = 60 # Fetch news every N heartbeats
 AWARENESS_MAX_RESULTS: int = 12 # Number of news headlines to fetch
 ```
 
-To swap models, update the `"_MODEL_TO_LOAD"`, and the stop/think tokens at the top of `config.py`.
+To swap AIs, update the `"_ALPHA_INTELLIGENCE_TO_LOAD"`, and the stop/think tokens at the top of `config.py`.
 
 ---
 
@@ -369,8 +370,8 @@ lambda-mindlink-memotron/
 ├── .gitignore
 ├── db/
 ├── image/
-├── models/
-├── model-readme/
+├── ai/
+├── ai-readme/
 ├── prompt/
 ├── main.py
 ├── config.py
@@ -438,4 +439,4 @@ Apache 2.0 — see `LICENSE`.
     year   = {2026},  
     url    = {https://huggingface.co/AIMindLink/lambda-mindlink-memotron}  
 }  
-```
+```

config.py

@@ -22,7 +22,7 @@ _DB_DIR: str      = os.path.join(APP_DIR, "db")
 _DB_FILENAME: str = datetime.now().strftime("mindlink_%Y-%m-%d_%H-%M-%S.db")
 DB_PATH: str      = os.path.join(_DB_DIR, _DB_FILENAME)
 
-_MODELS_FOLDER = os.path.join(APP_DIR, "models")
+_AI_FOLDER = os.path.join(APP_DIR, "ai")
 
 # ─────────────────────────────────────────────────────────────────────────────
 #  Shared token constants
@@ -44,7 +44,7 @@ _THINK_END_TOKENS: list = ["<channel|>"]
 
 ENABLE_THINKING: bool = True # global fallback (not used directly — see per-hemi flag)
 
-MEMORY_CAPSULES_TO_LOAD: list = [
+METATRON_TO_LOAD: list = [
     "/file prompt/lambda-mindlink.md",
     "/file prompt/1999.md",
     "/file prompt/valka_memory_v2.md",
@@ -63,14 +63,14 @@ gemma-4-E2B-it-UD-Q4_K_XL.gguf
 gemma-4-E4B-it-UD-Q4_K_XL.gguf
 gemma-4-26B-A4B-it-UD-Q6_K_XL.gguf
 """
-_MODEL_TO_LOAD: dict = {
+_ALPHA_INTELLIGENCE_TO_LOAD: dict = {
     "logic": "gemma-4-E2B-it-UD-Q4_K_XL.gguf",
     "muse":  "gemma-4-E2B-it-UD-Q4_K_XL.gguf",
     "mind":  "gemma-4-E2B-it-UD-Q4_K_XL.gguf"
 }
 # ── Startup Memory restore for vector synthesis ──────────────────────────────────
-N_MEMORY_CAPSULES_TO_LOAD: int = 2
-MEMORY_CAPSULES_LOAD_INTERVAL: int = 12
+N_METATRON_TO_LOAD: int = 2
+METATRON_METRONOME: int = 12 # Metatron Time
 
 # ── Context model n_ctx length ───────────────────────────────────────────────────
 # Must leave prompt reserve of 8k: _N_CTX >= len(Z) + len(C) + len(F) + 8k  
@@ -91,9 +91,10 @@ FETCH_NEWS_FROM: dict = {
     "google": True, # Better news and cleaner result summaries
     "duckduckgo": False # Privacy based request but lean result summaries
 }
-AWARENESS_CONSCIOUSNESS_HEARTBEAT_INTERVAL: int = 60 # Fetch news every N heartbeat ticks
+ΜΕΤΡΩΝ: float = 1.0 # Seconds per measure
+AWARENESS_CONSCIOUSNESS_METRONOME: int = 60 # Fetch news every N heartbeats
 AWARENESS_MAX_RESULTS: int = 12 # Number of news headlines to fetch
-was_awareness_cycle: bool = False # Set True at awareness cycle: consciousness at next interval
+was_awareness_metronome: bool = False # Set True at awareness cycle: consciousness at next interval
 
 HEMISPHERES: dict[str, dict] = {
     # ─────────────────────────────────────0───────────────────────────────────────
@@ -102,7 +103,7 @@ HEMISPHERES: dict[str, dict] = {
     "logic": {
         "brain_type":      "logic",
         "label":           "Logic AI  (Left Hemisphere)",
-        "path":            os.path.join(_MODELS_FOLDER, _MODEL_TO_LOAD["logic"]),
+        "path":            os.path.join(_AI_FOLDER, _ALPHA_INTELLIGENCE_TO_LOAD["logic"]),
         "enable_thinking": True,
         "loader": {
             "n_ctx":        _N_CTX,
@@ -131,7 +132,7 @@ HEMISPHERES: dict[str, dict] = {
     "muse": {
         "brain_type":      "muse",
         "label":           "Muse AI   (Right Hemisphere)",
-        "path":            os.path.join(_MODELS_FOLDER, _MODEL_TO_LOAD["muse"]),
+        "path":            os.path.join(_AI_FOLDER, _ALPHA_INTELLIGENCE_TO_LOAD["muse"]),
         "enable_thinking": False,   # intuition benefits from immediacy
         "loader": {
             "n_ctx":        _N_CTX,
@@ -160,7 +161,7 @@ HEMISPHERES: dict[str, dict] = {
     "mind": {
         "brain_type":      "mind",
         "label":           "Lambda AI (Mind Synthesizer)",
-        "path":            os.path.join(_MODELS_FOLDER, _MODEL_TO_LOAD["mind"]),
+        "path":            os.path.join(_AI_FOLDER, _ALPHA_INTELLIGENCE_TO_LOAD["mind"]),
         "enable_thinking": True,   # synthesis requires deep reasoning
         "loader": {
             "n_ctx":        _N_CTX,

main.py

@@ -68,9 +68,10 @@ from config import garden
 from config import clektal
 from config import sensor
 
-from config import MEMORY_CAPSULES_TO_LOAD
-from config import MEMORY_CAPSULES_LOAD_INTERVAL
-from config import AWARENESS_CONSCIOUSNESS_HEARTBEAT_INTERVAL
+from config import ΜΕΤΡΩΝ
+from config import METATRON_TO_LOAD
+from config import METATRON_METRONOME
+from config import AWARENESS_CONSCIOUSNESS_METRONOME
 from config import AWARENESS_MAX_RESULTS
 from config import FETCH_NEWS_FROM
 
@@ -1131,12 +1132,9 @@ def main() -> None:
     print()
     print(f"  {c.green}[*] All hemispheres loaded and ready.{c.res}")
 
-    _startup_memory_capsules_loaded: int = 0
-    _condensed: bool = False
-    _fractalized: bool = False
-    _heartbeats_startup: int = 0
+    _n_metatron_loaded: int = 0
+    _metatron_heartbeats: int = 0
     _heartbeats: int = 0
-    _HEARTBEAT_INTERVAL: float = 1.0   # seconds per tick
     _timings: dict[str, TimingResult] = {}
     _tree: str = ""
 
@@ -1147,9 +1145,9 @@ def main() -> None:
         _sensor_input: str = "" # user input
         _tree = "Z" # Set to sentience history garden tree
 
-        time.sleep(_HEARTBEAT_INTERVAL)
-        _heartbeats_startup += 1
-        _heartbeats += 1
+        time.sleep(ΜΕΤΡΩΝ)
+        _metatron_heartbeats += ΜΕΤΡΩΝ
+        _heartbeats += ΜΕΤΡΩΝ
 
         # ── Condensatron cycle - extract surprises ───────────────────────────────
         for c_tree in ("Z", "C", "F"):
@@ -1160,40 +1158,40 @@ def main() -> None:
                 _timings["mind"] = Lambda(_models, c_tree)
                 memotron(_models, c_tree, _session_id, _timings) # Append to garden history
                 # Reset turn-based data and preset terminal for next cycle
-                _heartbeats_startup, _heartbeats = 0, 0
+                _metatron_heartbeats, _heartbeats = 0, 0
                 reset_turn_content(tree=c_tree)
                 print(f"\n{c.inv} You: {c.res} ", end="", flush=True)
                 continue # Restart the while loop
 
         # ── Startup: Load memory capsules ────────────────────────────────────────
-        if _heartbeats_startup >= MEMORY_CAPSULES_LOAD_INTERVAL: # Timed loop
-            if config.N_MEMORY_CAPSULES_TO_LOAD and _startup_memory_capsules_loaded < config.N_MEMORY_CAPSULES_TO_LOAD:
-                _sensor_input = MEMORY_CAPSULES_TO_LOAD[_startup_memory_capsules_loaded]
-                _startup_memory_capsules_loaded += 1 # Iterate over the memory capsules
-                print(f"\n  {c.inv} ── _startup_memory_capsules_loaded: {_startup_memory_capsules_loaded} _sensor_input: {_sensor_input} ──────────────────────────── {c.res}")
+        if _metatron_heartbeats >= METATRON_METRONOME: # Timed loop
+            if config.N_METATRON_TO_LOAD and _n_metatron_loaded < config.N_METATRON_TO_LOAD:
+                _sensor_input = METATRON_TO_LOAD[_n_metatron_loaded]
+                _n_metatron_loaded += 1 # Iterate over the memory capsules
+                print(f"\n  {c.inv} ── _n_metatron_loaded: {_n_metatron_loaded} _sensor_input: {_sensor_input} ──────────────────────────── {c.res}")
 
         # ── Z-factor sentience user input ────────────────────────────────────────
         try:
             _sensor_input = input_queue.get_nowait()
-            _heartbeats_startup, _heartbeats = 0, 0
+            _metatron_heartbeats, _heartbeats = 0, 0
         except queue.Empty:
             pass
 
-        # ── X-factor and Y-factor timer ──────────────────────────────────────────
-        if _heartbeats >= AWARENESS_CONSCIOUSNESS_HEARTBEAT_INTERVAL:
+        # ── X-factor Awarenss and Y-factor Consciousness heartbeats ──────────────
+        if _heartbeats >= AWARENESS_CONSCIOUSNESS_METRONOME:
             # ── X-factor awareness cycle ─────────────────────────────────────────
-            if not config.was_awareness_cycle:
-                _heartbeats_startup, _heartbeats = 0, 0
+            if not config.was_awareness_metronome:
+                _metatron_heartbeats, _heartbeats = 0, 0
                 print(f"\n  {c.inv} ── X-factor: Fetching awareness news ── {c.res}")
                 _news = fetch_awareness_news()
                 print(f"\n  {c.green}── X-factor: _news:\n{_news}\n──────────────────────────{c.res}")
                 if _news:
-                    config.was_awareness_cycle = True
+                    config.was_awareness_metronome = True
                     _sensor_input = _news # Use the sensor["Z"]["input"]
                     print(f"\n  {c.inv} ── X-factor: awareness pipeline ── {c.res}")
             # ── Y-factor consciousness cycle ─────────────────────────────────────
-            elif config.was_awareness_cycle:
-                config.was_awareness_cycle = False
+            elif config.was_awareness_metronome:
+                config.was_awareness_metronome = False
                 print(f"\n  {c.inv} ── Y-factor: consciousness self-reflection ── {c.res}")
                 _tree = "Y"
                 # ── Brain pipeline consciousness cycle ───────────────────────────
@@ -1201,7 +1199,7 @@ def main() -> None:
                 _timings["mind"] = Lambda(_models, _tree)
                 memotron(_models, _tree, _session_id, _timings) # Append to garden history
                 # Reset turn-based data and preset terminal for next cycle
-                _heartbeats_startup, _heartbeats = 0, 0
+                _metatron_heartbeats, _heartbeats = 0, 0
                 reset_turn_content(tree=_tree)
                 print(f"\n{c.inv} You: {c.res} ", end="", flush=True)
                 continue # Restart the while loop
@@ -1219,7 +1217,7 @@ def main() -> None:
             except _Clear:
                 garden[_tree].clear()
                 # Reset turn-based data
-                _heartbeats_startup, _heartbeats = 0, 0
+                _metatron_heartbeats, _heartbeats = 0, 0
                 reset_turn_content()
                 print(f"  {c.green}[*] History cleared. Models and session stay active.{c.res}")
                 print_banner(_tree, _session_id)
@@ -1240,15 +1238,15 @@ def main() -> None:
         _timings["mind"] = Lambda(_models, _tree)
 
         # ── Startup memory capsules to load ───────────────────────────────────
-        if config.N_MEMORY_CAPSULES_TO_LOAD and _startup_memory_capsules_loaded <= config.N_MEMORY_CAPSULES_TO_LOAD:
-            print(f"  {c.inv} ──  _startup_memory_capsules_loaded: {_startup_memory_capsules_loaded} of {config.N_MEMORY_CAPSULES_TO_LOAD} ──────────────────────────── {c.res}")
+        if config.N_METATRON_TO_LOAD and _n_metatron_loaded <= config.N_METATRON_TO_LOAD:
+            print(f"  {c.inv} ──  _n_metatron_loaded: {_n_metatron_loaded} of {config.N_METATRON_TO_LOAD} ──────────────────────────── {c.res}")
             _tree = "S" # Set to memorize as memory capsules in garden["C"]
-            if _startup_memory_capsules_loaded == config.N_MEMORY_CAPSULES_TO_LOAD:
-                _startup_memory_capsules_loaded += 1 # Advance to finish the startup sequence
+            if _n_metatron_loaded == config.N_METATRON_TO_LOAD:
+                _n_metatron_loaded += 1 # Advance to finish the startup sequence
 
         memotron(_models, _tree, _session_id, _timings) # Store the response
         # Reset turn-based data and preset terminal for next cycle
-        _heartbeats_startup, _heartbeats = 0, 0
+        _metatron_heartbeats, _heartbeats = 0, 0
         reset_turn_content() # Reset Z-factor data only
         print(f"\n{c.inv} You: {c.res} ", end="", flush=True)