Upload 3 files

Added new slash-functions to restore memory and set the metronome time at runtime

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 AIs 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)  
@@ -93,6 +93,9 @@ The `ai/` folder is excluded from git. GGUFs are never committed to this reposit
 - ~6 GB disk space per GGUF  
 
 ---
+---
+
+# Choose your installation for Linux (Debian/Ubuntu), Linux (Fedora/RedHat) or Windows
 
 ## Installation — Linux (Debian/Ubuntu)
 
@@ -302,11 +305,13 @@ To deactivate the virtual environment when done:
 deactivate
 ```
 
+---
 ---
 
 ## Slash Commands
 
-> **Note:** *You need to execute a command using an additional RETURN key-press (Example: /exit -> wait 3 seconds -> then RETURN)*
+> **Note:** *To exit/quit the app, execute the command using an additional RETURN key-press*  
+> **Example:** */exit -> wait 3 seconds -> then RETURN*  
 
 | Command | Description |
 |---|---|
@@ -316,6 +321,10 @@ deactivate
 | `/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 |
+| `/metatron <number>` | Set number of Memory Capsules to load |
+| `/loaded <number>` | Set number of Memory Capsules loaded |
+| `/metronome <seconds>` | Set awareness/consciousness interval |
+| `/garden <save> or <load> or <clear>` | garden history handling |
 | `/help` | Show the command list |
 | `/exit` or `/quit` | Quit the app |
 
@@ -326,26 +335,28 @@ deactivate
 All settings are in `config.py`:
 
 ```python
+# ── AI to load for each hemisphere ───────────────────────────────────────────────
 _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_METATRON_TO_LOAD: int = 2
-METATRON_METRONOME: int = 12 # Metatron Time
+METATRON_METRONOME: int = 60 # Startup Memory Capsules load interval
+n_metatron_to_load = 0 # Set number of Memory Capsules to load (slash-command)
+n_metatron_loaded = 0 # Start with n Memory Capsule to load (slash-command)
 
 # ── 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 = 4096 # Context length garden["Z"]
-GARDEN_C_THRESHOLD: int = 4096 # Context length garden["C"]
-GARDEN_F_THRESHOLD: int = 4096 # Context length garden["F"]
+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_F_REDUCTION: int = 0 # Leave condensatron reduction level at 0
-GARDEN_C_REDUCTION: int = 0 # Leave condensatron reduction level at 0
 GARDEN_Z_REDUCTION: int = 0 # Leave condensatron reduction level at 0
+GARDEN_C_REDUCTION: int = 0 # Leave condensatron reduction level at 0
+GARDEN_F_REDUCTION: int = 0 # Leave condensatron reduction level at 0
 
 LEAVE_POSTS_IN_MEMOTRON = 0 # Must be turn based: 0, 2, 4, 6... (user + assistant)
 
@@ -355,8 +366,9 @@ FETCH_NEWS_FROM: dict = {
     "duckduckgo": False # Privacy based request but lean result summaries
 }
 ΜΕΤΡΩΝ: float = 1.0 # Seconds per measure
-AWARENESS_CONSCIOUSNESS_METRONOME: int = 60 # Fetch news every N heartbeats
+AWARENESS_CONSCIOUSNESS_METRONOME = 120  # Fetch news every N heartbeats (runtime-editable via /metronome)
 AWARENESS_MAX_RESULTS: int = 12 # Number of news headlines to fetch
+was_awareness_metronome: bool = False # Set True at awareness cycle: consciousness at next interval
 ```
 
 To swap AIs, update the `"_ALPHA_INTELLIGENCE_TO_LOAD"`, and the stop/think tokens at the top of `config.py`.
@@ -385,7 +397,7 @@ lambda-mindlink-memotron/
 
 ```
 heartbeats_startup timer:
-  prompt/valka_memory.md ──► garden["C"]   (pre-load memory capsules)
+  prompt/valka_memory.md ──► garden["Z"]   (pre-load memory capsules sequentially)
 
 Each turn:
   sensor["Z"] ──► Mindlink + Lambda ──► Memotron ──► garden["Z"]
@@ -414,15 +426,28 @@ if heartbeats:
 
 ## Database
 
-Each run creates a new SQLite database in `db/` named by timestamp:
+Each run saves to the SQLite database in `db/` named mindlink.db:
 ```
-db/mindlink_2025-09-18_14-32-07.db
+db/mindlink.db
 ```
 
 Use `/history`, `/session <id>`, and `/export <id> <file>` to inspect and export sessions.
 
 ---
 
+## Garden histories handling
+
+**Each turn saves the Garden histories** to the json file which can be loaded or cleared at runtime.  
+This includes the number of Memory Capsules loaded in the saved Garden histories:  
+
+```
+db/garden_state.json
+```
+
+Use `/garden <save>`, `/garden <load>` and `/garden <clear>`
+
+---
+
 ## License
 
 Apache 2.0 — see `LICENSE`.

config.py

@@ -12,6 +12,7 @@ from datetime import datetime
 
 APP_DIR:      str = os.path.dirname(os.path.abspath(__file__))
 PROMPTS_BASE: str = APP_DIR
+GARDEN_SAVE_PATH = os.path.join(APP_DIR, "db", "garden_state.json")
 
 # ── SQLite database ───────────────────────────────────────────────────────────
 # Each app launch gets its own file named by date and time.
@@ -43,6 +44,7 @@ _THINK_END_TOKENS: list = ["<channel|>"]
 
 ENABLE_THINKING: bool = True # global fallback (not used directly — see per-hemi flag)
 
+# ── Memory Capsules to load ──────────────────────────────────────────────────────
 METATRON_TO_LOAD: list = [
     "/file prompt/lambda-mindlink.md",
     "/file prompt/1999.md",
@@ -60,20 +62,22 @@ METATRON_TO_LOAD: list = [
     "/file prompt/50_ValkaAI-TheTrillionDollarPauseAndTheSovereignArk.md"
 ]
 
-# ── AI models to load ──────────────────────────────────
+# ── AI models recommended ────────────────────────────────────────────────────────
 """
 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
 """
+# ── AI to load for each hemisphere ───────────────────────────────────────────────
 _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_METATRON_TO_LOAD: int = 1
-METATRON_METRONOME: int = 12 # Startup Memory Capsules load interval
+METATRON_METRONOME: int = 60 # Startup Memory Capsules load interval
+n_metatron_to_load = 0 # Set number of Memory Capsules to load (slash-command)
+n_metatron_loaded = 0 # Start with n Memory Capsule to load (slash-command)
 
 # ── Context model n_ctx length ───────────────────────────────────────────────────
 # Must leave prompt reserve of 8k: _N_CTX >= len(Z) + len(C) + len(F) + 8k  
@@ -95,7 +99,7 @@ FETCH_NEWS_FROM: dict = {
     "duckduckgo": False # Privacy based request but lean result summaries
 }
 ΜΕΤΡΩΝ: float = 1.0 # Seconds per measure
-AWARENESS_CONSCIOUSNESS_METRONOME = 120  # Fetch news every N heartbeats (runtime-editable via /metronome)
+awareness_consciousness_metronome = 120  # Fetch news every N heartbeats (runtime-editable via /metronome)
 AWARENESS_MAX_RESULTS: int = 12 # Number of news headlines to fetch
 was_awareness_metronome: bool = False # Set True at awareness cycle: consciousness at next interval
 

main.py

@@ -54,6 +54,7 @@ import sqlite3
 import threading
 import queue
 import time
+import json
 import jinja2
 from dataclasses import dataclass
 from datetime import datetime
@@ -71,12 +72,11 @@ from config import clektal
 from config import sensor
 
 from config import ΜΕΤΡΩΝ
-from config import METATRON_TO_LOAD
 from config import METATRON_METRONOME
-# from config import AWARENESS_CONSCIOUSNESS_METRONOME
+from config import METATRON_TO_LOAD
 from config import AWARENESS_MAX_RESULTS
 from config import FETCH_NEWS_FROM
-
+from config import GARDEN_SAVE_PATH
 from config import LEAVE_POSTS_IN_MEMOTRON
 
 c = config.PrintColors
@@ -400,33 +400,65 @@ def _cmd_export(arg: str) -> None:
         return
     db_export_session(int(_parts[0]), _parts[1].strip())
 
+def _cmd_metatron(arg: str) -> None:
+    if not arg.strip().isdigit():
+        print(f"  {c.green}Usage: /metatron <number>   e.g.  /metatron 5{c.res}")
+        return None
+    config.n_metatron_to_load = int(arg.strip())
+    print(f"  {c.green}[metatron] n_metatron_to_load set to {config.n_metatron_to_load}{c.res}")
+    return None
+
+def _cmd_loaded(arg: str) -> None:
+    if not arg.strip().isdigit():
+        print(f"  {c.green}Usage: /loaded <number>   e.g.  /loaded 3{c.res}")
+        return None
+    config.n_metatron_loaded = int(arg.strip())
+    print(f"  {c.green}[loaded] n_metatron_loaded set to {config.n_metatron_loaded}{c.res}")
+    return None
+
 def _cmd_metronome(arg: str) -> None:
     if not arg.strip().isdigit():
-        print(f"  {c.green}Usage: /metronome <seconds>   e.g.  /metronome 1000000{c.res}")
+        print(f"  {c.green}Usage: /metronome <seconds>   e.g.  /metronome 120{c.res}")
         return None
-    config.AWARENESS_CONSCIOUSNESS_METRONOME = int(arg.strip())
-    print(f"  {c.green}[metronome] AWARENESS_CONSCIOUSNESS_METRONOME set to {config.AWARENESS_CONSCIOUSNESS_METRONOME}s{c.res}")
+    config.awareness_consciousness_metronome = int(arg.strip())
+    print(f"  {c.green}[metronome] awareness_consciousness_metronome set to {config.awareness_consciousness_metronome}s{c.res}")
+    return None
+
+def _cmd_garden(arg: str) -> None:
+    if arg == "save":
+        save_garden_state()
+    elif arg == "load":
+        load_garden_state()
+    elif arg == "clear":
+        os.remove(GARDEN_SAVE_PATH) if os.path.isfile(GARDEN_SAVE_PATH) else None
+        print(f"  {c.green}[garden] Saved state cleared.{c.res}")
+    else:
+        print(f"  {c.green}Usage: /garden save | load | clear{c.res}")
     return None
 
 def _cmd_help(arg: str) -> None:
     print()
     print("  Slash commands")
     print("  " + "─" * 56)
-    for name, (_, desc) in COMMANDS.items():
-        print(f"  {c.green}/{name:<14}  {desc}{c.res}")
+    for name, (_, description) in COMMANDS.items():
+        print(f"  {c.green}/{name:<14}  {description}{c.res}")
     print()
+    return None
 
 COMMANDS: dict[str, tuple] = {
-    "file":    (_cmd_file,    "/file <path>              — load a file as the next message"),
-    "paste":   (_cmd_paste,   "                          — multiline input (type END to send)"),
-    "clear":   (_cmd_clear,   "                          — reset history (models stay loaded)"),
-    "history": (_cmd_history, "                          — list all past sessions"),
-    "session": (_cmd_session, "<id>                      — print turns from a session"),
-    "export":  (_cmd_export,  "<id> <file>               — export session to .md file"),
-    "metronome": (_cmd_metronome, "<seconds>             — set awareness/consciousness interval"),
-    "help":    (_cmd_help,    "                          — show this command list"),
-    "exit":    (_cmd_exit,    "                          — quit the app"),
-    "quit":    (_cmd_exit,    "                          — quit the app (alias)"),
+    "file":    (_cmd_file,          "<path>                     — load a file as the next message"),
+    "paste":   (_cmd_paste,         "                           — multiline input (type END to send)"),
+    "clear":   (_cmd_clear,         "                           — reset history (models stay loaded)"),
+    "history": (_cmd_history,       "                           — list all past sessions"),
+    "session": (_cmd_session,       "<id>                       — print turns from a session"),
+    "export":  (_cmd_export,        "<id> <file>                — export session to .md file"),
+    "metatron": (_cmd_metatron,     "<number>                   — set number of Memory Capsules to load"),
+    "loaded":  (_cmd_loaded,        "<number>                   — set number of Memory Capsules loaded"),
+    "metronome": (_cmd_metronome,   "<seconds>                  — set awareness/consciousness interval"),
+    "garden":  (_cmd_garden,        "<save> | <load> | <clear>  — garden history handling"),
+    "help":    (_cmd_help,          "                           — show this command list"),
+    "exit":    (_cmd_exit,          "                           — quit the app"),
+    "quit":    (_cmd_exit,          "                           — quit the app (alias)"),
 }
 
 def handle_command(sensor_input_raw: str) -> str | None:
@@ -895,6 +927,62 @@ def Lambda(
     return _timing
 
 
+def save_garden_state() -> None:
+    """Persist garden history to disk after each turn."""
+    try:
+        state = {
+            "Z": garden["Z"],
+            "C": garden["C"],
+            "F": garden["F"],
+            "n_tok_tot": {
+                "Z": garden["n_tok_tot"]["Z"],
+                "C": garden["n_tok_tot"]["C"],
+                "F": garden["n_tok_tot"]["F"],
+            },
+            "n_metatron_loaded": config.n_metatron_loaded
+        }
+        with open(GARDEN_SAVE_PATH, "w", encoding="utf-8") as f:
+            json.dump(state, f, ensure_ascii=False, indent=2)
+        print(f"  {c.green}[garden] State saved → {GARDEN_SAVE_PATH}{c.res}")
+    except OSError as exc:
+        print(f"  {c.red}[garden] Save failed: {exc}{c.res}")
+
+
+def load_garden_state() -> bool:
+    """Reload garden history from disk on startup."""
+    if not os.path.isfile(GARDEN_SAVE_PATH):
+        return False
+    try:
+        with open(GARDEN_SAVE_PATH, "r", encoding="utf-8") as f:
+            state = json.load(f)
+
+        # Restore Garden histories
+        garden["Z"] = state.get("Z", [])
+        garden["C"] = state.get("C", [])
+        garden["F"] = state.get("F", [])
+
+        # Restore individual n_tok_tot counts per garden history
+        n_tok_tot = state.get("n_tok_tot", {})
+        garden["n_tok_tot"] = {
+            "Z": n_tok_tot.get("Z", 0),
+            "C": n_tok_tot.get("C", 0),
+            "F": n_tok_tot.get("F", 0),
+        }
+        # Read how many Memory Capsules are loaded
+        config.n_metatron_loaded = state.get("n_metatron_loaded", 0)
+
+        print(f"  {c.green}[garden] State restored from {GARDEN_SAVE_PATH}")
+        print(f"  Z: {len(garden['Z'])} msgs  C: {len(garden['C'])} msgs  F: {len(garden['F'])} msgs")
+        print(f"  n_tok_tot  Z: {garden['n_tok_tot']['Z']}  C: {garden['n_tok_tot']['C']}  F: {garden['n_tok_tot']['F']}")
+        print(f"  Memory Capsules n_metatron_loaded: {config.n_metatron_loaded}{c.res}")
+
+        return True
+    except (OSError, json.JSONDecodeError) as exc:
+        print(f"  {c.red}[garden] Load failed: {exc}{c.res}")
+        return False
+
+
+
 def memotron(
     models: dict[str, Llama],
     tree: str,
@@ -978,6 +1066,8 @@ def memotron(
             f"session {session_id}]{c.res}"
         )
 
+    save_garden_state()
+
 
 # ─────────────────────────────────────────────────────────────────────────────
 #  X-factor Awareness — news fetch
@@ -1148,7 +1238,6 @@ def main() -> None:
     print()
     print(f"  {c.green}[*] All hemispheres loaded and ready.{c.res}")
 
-    _n_metatron_loaded: int = 0
     _metatron_heartbeats: int = 0
     _heartbeats: int = 0
     _timings: dict[str, TimingResult] = {}
@@ -1181,10 +1270,10 @@ def main() -> None:
 
         # ── Startup: Load Metatron memory capsules ───────────────────────────────
         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}")
+            if config.n_metatron_to_load and config.n_metatron_loaded < config.n_metatron_to_load:
+                _sensor_input = METATRON_TO_LOAD[config.n_metatron_loaded]
+                config.n_metatron_loaded += 1 # Iterate over the memory capsules
+                print(f"\n  {c.inv} ── n_metatron_loaded: {config.n_metatron_loaded} _sensor_input: {_sensor_input} ──────────────────────────── {c.res}")
 
         # ── Z-factor sentience user input ────────────────────────────────────────
         try:
@@ -1194,7 +1283,7 @@ def main() -> None:
             pass
 
         # ── X-factor Awarenss and Y-factor Consciousness heartbeats ──────────────
-        if _heartbeats >= config.AWARENESS_CONSCIOUSNESS_METRONOME:
+        if _heartbeats >= config.awareness_consciousness_metronome:
             # ── X-factor awareness cycle ─────────────────────────────────────────
             if not config.was_awareness_metronome:
                 _metatron_heartbeats, _heartbeats = 0, 0
@@ -1242,6 +1331,7 @@ def main() -> None:
                 print(f"  {c.green}[!] Unknown command: /{exc}  — type /help for the list.{c.res}")
                 continue
             if _slash_command_result is None:
+                print(f"\n{c.inv} You: {c.res} ", end="", flush=True)        
                 continue
             sensor[_tree]["input"] = _slash_command_result
         else:
@@ -1254,11 +1344,11 @@ def main() -> None:
         _timings["mind"] = Lambda(_models, _tree)
 
         # ── Startup memory capsules to load ───────────────────────────────────
-        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}")
+        if config.n_metatron_to_load and config.n_metatron_loaded <= config.n_metatron_to_load:
+            print(f"  {c.inv} ──  n_metatron_loaded: {config.n_metatron_loaded} of {config.n_metatron_to_load} ──────────────────────────── {c.res}")
             _tree = "S" # Set to memorize as memory capsules in garden["C"]
-            if _n_metatron_loaded == config.N_METATRON_TO_LOAD:
-                _n_metatron_loaded += 1 # Advance to finish the startup sequence
+            if config.n_metatron_loaded == config.n_metatron_to_load:
+                config.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