Upload 3 files

Added slash-commands

config.py

@@ -18,8 +18,8 @@ Version: v1.0
 import os
 from datetime import datetime
 
-APP_DIR:      str = os.path.dirname(os.path.abspath(__file__))
-PROMPTS_BASE: str = APP_DIR
+APP_DIR:          str = os.path.dirname(os.path.abspath(__file__))
+PROMPTS_BASE:     str = APP_DIR
 GARDEN_SAVE_PATH: str = os.path.join(APP_DIR, "db", "garden_state.json")
 
 # ── SQLite database ───────────────────────────────────────────────────────────
@@ -82,10 +82,6 @@ _ALPHA_INTELLIGENCE_TO_LOAD: dict = {
     "muse":  "gemma-4-26B-A4B-it-UD-Q6_K_XL.gguf",
     "mind":  "gemma-4-26B-A4B-it-UD-Q6_K_XL.gguf"
 }
-# ── Startup Memory restore for vector synthesis ──────────────────────────────────
-METATRON_METRONOME: int = 120 # 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  
@@ -106,10 +102,21 @@ FETCH_NEWS_FROM: dict = {
     "google": True, # Better news and cleaner result summaries
     "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_MAX_RESULTS: int = 12 # Number of news headlines to fetch
+# ── Startup Memory restore for vector synthesis ──────────────────────────────────
+n_metatron_to_load: int = 0 # Set number of Memory Capsules to load (slash-command)
+n_metatron_loaded:  int = 0 # Start with n Memory Capsule to load (slash-command)
+
+# ── Set metronome time for each cycle ────────────────────────────────────────────
+metatron_metronome:                int = 120 # Startup Memory Capsules load interval (slash-command)
+condensatron_metronome:            int = 30 # Time before condesatron cycle execution (slash-command)
+awareness_consciousness_metronome: int = 120  # Fetch news every N heartbeats (slash-command)
+
+# ── Enable awareness mode and n results ──────────────────────────────────────────
+AWARENESS_MAX_RESULTS:    int = 12 # Number of news headlines to fetch
+enable_awareness:        bool = True # disable awareness mode if offline (slash-command)
+
 was_awareness_metronome: bool = False # Set True at awareness cycle: consciousness at next interval
+ΜΕΤΡΩΝ: float = 1.0 # Seconds per measure
 
 HEMISPHERES: dict[str, dict] = {
     # ─────────────────────────────────────────────────────────────────────────────

main.py

@@ -80,7 +80,6 @@ from config import clektal
 from config import sensor
 
 from config import ΜΕΤΡΩΝ
-from config import METATRON_METRONOME
 from config import METATRON_TO_LOAD
 from config import AWARENESS_MAX_RESULTS
 from config import FETCH_NEWS_FROM
@@ -408,9 +407,9 @@ def _cmd_export(arg: str) -> None:
         return
     db_export_session(int(_parts[0]), _parts[1].strip())
 
-def _cmd_metatron(arg: str) -> None:
+def _cmd_n_metatron(arg: str) -> None:
     if not arg.strip().isdigit():
-        print(f"  {c.green}Usage: /metatron <number>   e.g.  /metatron 5{c.res}")
+        print(f"  {c.green}Usage: /n_metatron <number>   e.g.  /n_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}")
@@ -424,6 +423,22 @@ def _cmd_loaded(arg: str) -> None:
     print(f"  {c.green}[loaded] n_metatron_loaded set to {config.n_metatron_loaded}{c.res}")
     return None
 
+def _cmd_metatron(arg: str) -> None:
+    if not arg.strip().isdigit():
+        print(f"  {c.green}Usage: /metatron <seconds>   e.g.  /metatron 30{c.res}")
+        return None
+    config.metatron_metronome = int(arg.strip())
+    print(f"  {c.green}[metronome] metatron_metronome set to {config.metatron_metronome}s{c.res}")
+    return None
+
+def _cmd_condensatron(arg: str) -> None:
+    if not arg.strip().isdigit():
+        print(f"  {c.green}Usage: /condensatron <seconds>   e.g.  /condensatron 30{c.res}")
+        return None
+    config.condensatron_metronome = int(arg.strip())
+    print(f"  {c.green}[metronome] condensatron_metronome set to {config.condensatron_metronome}s{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 120{c.res}")
@@ -432,6 +447,15 @@ def _cmd_metronome(arg: str) -> None:
     print(f"  {c.green}[metronome] awareness_consciousness_metronome set to {config.awareness_consciousness_metronome}s{c.res}")
     return None
 
+def _cmd_enable_awareness(arg: str) -> None:
+    arg_clean = arg.strip().lower()
+    if arg_clean not in ("true", "false"):
+        print(f"  {c.green}Usage: /enable_awareness <boolean>   e.g.  /enable_awareness False{c.res}")
+        return None
+    config.enable_awareness = (arg_clean == "true") # "true"  == "true" → True (bool) # "false" == "true" → False (bool)
+    print(f"  {c.green}[awareness] enable_awareness set to {config.enable_awareness}{c.res}")
+    return None
+
 def _cmd_garden(arg: str) -> None:
     if arg == "save":
         save_garden_state()
@@ -444,29 +468,54 @@ def _cmd_garden(arg: str) -> None:
         print(f"  {c.green}Usage: /garden save | load | clear{c.res}")
     return None
 
+
 def _cmd_help(arg: str) -> None:
     print()
     print(f"  {c.green}Slash commands")
     print("  " + "─" * 56)
-    for name, (_, description) in COMMANDS.items():
-        print(f"  /{name:<14}  {description}")
+
+    # Descriptions built dynamically so they reflect current config values
+    descriptions = {
+        "n_metatron":     f"<number>                   — set number of Memory Capsules to load: {config.n_metatron_to_load}",
+        "loaded":         f"<number>                   — set number of Memory Capsules loaded: {config.n_metatron_loaded}",
+        "metatron":       f"<seconds>                  — set metatron interval: {config.metatron_metronome}s",
+        "condensatron":   f"<seconds>                  — set condensatron interval: {config.condensatron_metronome}s",
+        "metronome":      f"<seconds>                  — set awareness/consciousness interval: {config.awareness_consciousness_metronome}s",
+        "enable_awareness": f"<True | False>           — disable awareness mode if offline: {config.enable_awareness}",
+    }
+
+    for name, (_, base_desc) in COMMANDS.items():
+        desc = descriptions.get(name, base_desc)
+        print(f"  /{name:<14}  {desc}")
     print(c.res)
     return None
 
+# def _cmd_help(arg: str) -> None:
+#     print()
+#     print(f"  {c.green}Slash commands")
+#     print("  " + "─" * 56)
+#     for name, (_, description) in COMMANDS.items():
+#         print(f"  /{name:<14}  {description}")
+#     print(c.res)
+#     return None
+
 COMMANDS: dict[str, tuple] = {
-    "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)")
+    "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"),
+    "n_metatron":   (_cmd_n_metatron,  "<number>                   — set number of Memory Capsules to load"),
+    "loaded":       (_cmd_loaded,      "<number>                   — set number of Memory Capsules loaded"),
+    "metatron":     (_cmd_metatron,    "<seconds>                  — set metatron interval"),
+    "condensatron": (_cmd_condensatron, "<seconds>                  — set condensatron interval"),
+    "metronome":    (_cmd_metronome,   "<seconds>                  — set awareness/consciousness interval"),
+    "enable_awareness": (_cmd_enable_awareness, "<True | False>      — disable awareness mode if offline"),
+    "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:
@@ -1259,7 +1308,6 @@ def main() -> None:
     print()
     print(f"  {c.green}[*] All hemispheres loaded and ready.{c.res}")
 
-    _metatron_heartbeats: int = 0
     _heartbeats: int = 0
     _timings: dict[str, TimingResult] = {}
     _tree: str = ""
@@ -1272,25 +1320,25 @@ def main() -> None:
         _tree = "Z" # Set to sentience history garden tree
 
         time.sleep(ΜΕΤΡΩΝ)
-        _metatron_heartbeats += ΜΕΤΡΩΝ
         _heartbeats += ΜΕΤΡΩΝ
 
         # ── Condensatron cycle - extract surprises ───────────────────────────────
-        for c_tree in ("Z", "C", "F"):
-            if garden["condensatron_state"][c_tree]:
-                print(f"  {c.inv} ── Start condensatron cycle: garden['{c_tree}'] ──────────────────────────── {c.res}")
-                # ── Brain pipeline condensatron cycle ────────────────────────────
-                _timings = Mindlink(_models, c_tree)
-                _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
-                _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
+        if _heartbeats >= config.condensatron_metronome:
+            for c_tree in ("Z", "C", "F"):
+                if garden["condensatron_state"][c_tree]:
+                    print(f"  {c.inv} ── Start condensatron cycle: garden['{c_tree}'] ──────────────────────────── {c.res}")
+                    # ── Brain pipeline condensatron cycle ────────────────────────────
+                    _timings = Mindlink(_models, c_tree)
+                    _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 = 0 # Reset heartbeats time
+                    reset_turn_content(tree=c_tree)
+                    print(f"\n{c.inv} You: {c.res} ", end="", flush=True)
+                    continue # Restart the while loop
 
         # ── Startup: Load Metatron memory capsules ───────────────────────────────
-        if _metatron_heartbeats >= METATRON_METRONOME: # Timed loop
+        if _heartbeats >= config.metatron_metronome: # Timed loop
             if config.n_metatron_to_load and config.n_metatron_loaded < config.n_metatron_to_load:
                 _print_metatron_loaded = config.n_metatron_loaded + 1 # Print only start at 1
                 print(f"\n  {c.inv} ── n_metatron_loaded: {_print_metatron_loaded} _sensor_input: {_sensor_input} ──────────────────────────── {c.res}")
@@ -1299,15 +1347,18 @@ def main() -> None:
         # ── Z-factor sentience user input ────────────────────────────────────────
         try:
             _sensor_input = input_queue.get_nowait()
-            _metatron_heartbeats, _heartbeats = 0, 0
+            _heartbeats = 0 # Reset heartbeats time
         except queue.Empty:
             pass
 
         # ── X-factor Awarenss and Y-factor Consciousness heartbeats ──────────────
         if _heartbeats >= config.awareness_consciousness_metronome:
-            # ── X-factor awareness cycle ─────────────────────────────────────────
+            # ── X-factor awareness cycle ─────────────────────────────────────────                
+            if not config.enable_awareness:
+                config.was_awareness_metronome = True
+
             if not config.was_awareness_metronome:
-                _metatron_heartbeats, _heartbeats = 0, 0
+                _heartbeats = 0 # Reset heartbeats time
                 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}")
@@ -1315,6 +1366,8 @@ def main() -> None:
                     config.was_awareness_metronome = True
                     _sensor_input = _news # Use the sensor["Z"]["input"]
                     print(f"\n  {c.inv} ── X-factor: awareness pipeline ── {c.res}")
+                else:
+                    config.was_awareness_metronome = True  # Skip to Y-phase if offline
             # ── Y-factor consciousness cycle ─────────────────────────────────────
             elif config.was_awareness_metronome:
                 config.was_awareness_metronome = False
@@ -1325,12 +1378,12 @@ 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
-                _metatron_heartbeats, _heartbeats = 0, 0
+                _heartbeats = 0 # Reset heartbeats time
                 reset_turn_content(tree=_tree)
                 print(f"\n{c.inv} You: {c.res} ", end="", flush=True)
                 continue # Restart the while loop
 
-        if not _sensor_input: # wait state loop restart here
+        if not _sensor_input: # wait state loop restarts here if empty input
             continue
 
         # ── Slash command detection ──────────────────────────────────────────
@@ -1343,7 +1396,7 @@ def main() -> None:
             except _Clear:
                 garden[_tree].clear()
                 # Reset turn-based data
-                _metatron_heartbeats, _heartbeats = 0, 0
+                _heartbeats = 0 # Reset heartbeats time
                 reset_turn_content()
                 print(f"  {c.green}[*] History cleared. Models and session stay active.{c.res}")
                 print_banner(_tree, _session_id)
@@ -1372,7 +1425,7 @@ def main() -> None:
 
         memotron(_models, _tree, _session_id, _timings) # Store the response
         # Reset turn-based data and preset terminal for next cycle
-        _metatron_heartbeats, _heartbeats = 0, 0
+        _heartbeats = 0 # Reset heartbeats time
         reset_turn_content() # Reset Z-factor data only
         print(f"\n{c.inv} You: {c.res} ", end="", flush=True)