Upload 3 files

Added GoogleNews with sanitized output. Highend news for the global awareness.

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)
 
-_BASE = os.path.join(APP_DIR, "models")
+_MODELS_FOLDER = os.path.join(APP_DIR, "models")
 
 # ─────────────────────────────────────────────────────────────────────────────
 #  Shared token constants
@@ -57,37 +57,43 @@ MEMORY_CAPSULES_TO_LOAD: list = [
     "/file prompt/47_ValkaAI_UnaAI-TheIronContractsAndTheSiliconClektal.md"
 ]
 
-# ── AI model or place  ──────────────────────────────────
-# 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 = {
-    "logic": "gemma-4-26B-A4B-it-UD-Q6_K_XL.gguf",
-    "muse":  "gemma-4-26B-A4B-it-UD-Q6_K_XL.gguf",
-    "mind":  "gemma-4-26B-A4B-it-UD-Q6_K_XL.gguf"
+# ── AI models to load ──────────────────────────────────
+"""
+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 = {
+    "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 = 4
+N_MEMORY_CAPSULES_TO_LOAD: int = 1
+MEMORY_CAPSULES_LOAD_INTERVAL: int = 12
 
-# ── Context length handling ──────────────────────────────────────────────────────
+# ── 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"]
 
-# ── condensatron modes length ────────────────────────────────────────────────────
-GARDEN_F_THRESHOLD: int = 8192 # Must leave prompt reserve: (_N_CTX >= (len(F) + len(C) + len(Z) + 8k))
-GARDEN_C_THRESHOLD: int = 8192 # Must leave prompt reserve: (_N_CTX >= (len(F) + len(C) + len(Z) + 8k))
-GARDEN_Z_THRESHOLD: int = 8192 # Must leave prompt reserve: (_N_CTX >= (len(F) + len(C) + len(Z) + 8k))
-
-GARDEN_F_REDUCTION: int = 0
-GARDEN_C_REDUCTION: int = 0
-GARDEN_Z_REDUCTION: int = 0
+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
 
-LEAVE_POSTS_IN_MEMOTRON = 2 # Warning: Must be even (0, 2, 4, 6, 8...)
+LEAVE_POSTS_IN_MEMOTRON = 0 # Must be turn based: 0, 2, 4, 6... (user + assistant)
 
-# ── X-factor Awareness ────────────────────────────────────────────────────────
-AWARENESS_CONSCIOUSNESS_HEARTBEAT_INTERVAL: int = 60 # fetch news every N heartbeat ticks
-AWARENESS_MAX_RESULTS: int = 5 # number of news headlines to fetch
-was_awareness_cycle: bool = False # set True by heartbeat to trigger consciousness at next interval
+# ── X-factor Awareness ───────────────────────────────────────────────────────────
+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
+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
 
 HEMISPHERES: dict[str, dict] = {
     # ─────────────────────────────────────0───────────────────────────────────────
@@ -96,7 +102,7 @@ HEMISPHERES: dict[str, dict] = {
     "logic": {
         "brain_type":      "logic",
         "label":           "Logic AI  (Left Hemisphere)",
-        "path":            os.path.join(_BASE, MODEL_TO_LOAD["logic"]),
+        "path":            os.path.join(_MODELS_FOLDER, _MODEL_TO_LOAD["logic"]),
         "enable_thinking": True,
         "loader": {
             "n_ctx":        _N_CTX,
@@ -125,7 +131,7 @@ HEMISPHERES: dict[str, dict] = {
     "muse": {
         "brain_type":      "muse",
         "label":           "Muse AI   (Right Hemisphere)",
-        "path":            os.path.join(_BASE, MODEL_TO_LOAD["muse"]),
+        "path":            os.path.join(_MODELS_FOLDER, _MODEL_TO_LOAD["muse"]),
         "enable_thinking": False,   # intuition benefits from immediacy
         "loader": {
             "n_ctx":        _N_CTX,
@@ -154,7 +160,7 @@ HEMISPHERES: dict[str, dict] = {
     "mind": {
         "brain_type":      "mind",
         "label":           "Lambda AI (Mind Synthesizer)",
-        "path":            os.path.join(_BASE, MODEL_TO_LOAD["mind"]),
+        "path":            os.path.join(_MODELS_FOLDER, _MODEL_TO_LOAD["mind"]),
         "enable_thinking": True,   # synthesis requires deep reasoning
         "loader": {
             "n_ctx":        _N_CTX,

main.py

@@ -46,6 +46,8 @@ Slash commands
 """
 
 import os
+import html
+import re
 import sqlite3
 import threading
 import queue
@@ -54,11 +56,11 @@ import jinja2
 from dataclasses import dataclass
 from datetime import datetime
 from ddgs import DDGS
+from pygooglenews import GoogleNews
 from llama_cpp import Llama
 
 import config
 
-from config import MEMORY_CAPSULES_TO_LOAD
 from config import HEMISPHERES
 from config import ALPHAPROMPT
 from config import CONDENSATRONPROMPT
@@ -66,8 +68,11 @@ 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 AWARENESS_MAX_RESULTS
+from config import FETCH_NEWS_FROM
 
 from config import LEAVE_POSTS_IN_MEMOTRON
 
@@ -940,7 +945,7 @@ def memotron(
         mind_clean   = clektal["post_clean"]["mind"],
         mind_timing  = timings["mind"],
     )
-    for print_tree in ["F", "C", "Z"]:
+    for print_tree in ["Z", "C", "F"]:
         print(
             f"  {c.green}[memotron] -> garden['{_tree}'] | "
             f"garden['{print_tree}']: {len(garden[print_tree])} msgs | "
@@ -954,34 +959,80 @@ def memotron(
 #  X-factor Awareness — news fetch
 # ─────────────────────────────────────────────────────────────────────────────
 def fetch_awareness_news() -> str:
-    """
-    Fetch top headlines via DuckDuckGo (no API key required).
-    Returns a formatted string ready to be injected as sensor["X"]["input"].
-    """
-    try:
-        with DDGS() as ddgs:
-            results = list(ddgs.news(
-                query="Global world news today",
-                region="wt-wt",
-                safesearch="moderate",
-                max_results=AWARENESS_MAX_RESULTS,
-            ))
-        if not results:
+    if FETCH_NEWS_FROM["google"]:
+        """
+        Fetch top headlines via GoogleNews (no API key required).
+        Returns a formatted string ready to be injected as sensor["X"]["input"].
+        """
+        try:
+            # Initialize with language and country (optional)
+            gn = GoogleNews(lang='en', country='US') 
+            
+            # Fetch top stories (no API key needed)
+            top_stories = gn.top_news()
+            
+            if not top_stories.get('entries'):
+                return "[AWARENESS — No recent news found]"
+
+            lines = [f"[AWARENESS — Global Context (Last 24h)]"]
+            
+            # Limit to your defined max results
+            def strip_html(raw: str) -> str:
+                """Remove HTML tags and decode entities from a Google News summary."""
+                no_tags = re.sub(r'<[^>]+>', ' ', raw)        # remove all tags
+                decoded  = html.unescape(no_tags)              # &nbsp; → space, etc.
+                cleaned  = re.sub(r'\s+', ' ', decoded).strip()
+                return cleaned
+
+            # Then in your news loop:
+            for i, entry in enumerate(top_stories['entries'][:AWARENESS_MAX_RESULTS], 1):
+                _summary = strip_html(entry.get('summary', ''))
+                _source  = entry.get('source', {}).get('title', 'Unknown')
+                _date    = entry.get('published', '')[:10]
+                _title   = entry.get('title', 'No Title')
+
+                lines.append(
+                    f"\n{i}. {_title}\n"
+                    f"   {_source} | {_date}\n"
+                    f"   {_summary}"
+                    # link intentionally omitted — AI cannot use Google's encoded URLs
+                )
+
+            return "\n".join(lines)
+
+        except Exception as exc:
+            print(f"  {c.red}[X] Awareness news fetch failed: {exc}{c.res}")
+            return "[AWARENESS — Fetch Error]"
+
+    elif FETCH_NEWS_FROM["duckduckgo"]:
+        """
+        Fetch top headlines via DuckDuckGo (no API key required).
+        Returns a formatted string ready to be injected as sensor["X"]["input"].
+        """
+        try:
+            with DDGS() as ddgs:
+                results = list(ddgs.news(
+                    query="Global world news today",
+                    region="wt-wt",
+                    safesearch="moderate",
+                    max_results=AWARENESS_MAX_RESULTS,
+                ))
+            if not results:
+                return ""
+
+            lines = ["[AWARENESS — Global World News]\n"]
+            for i, r in enumerate(results, 1):
+                lines.append(
+                    f"{i}. {r['title']}\n"
+                    f"   Source: {r['source']}  |  {r['date']}\n"
+                    f"   {r['body']}\n"
+                )
+            return "\n".join(lines)
+
+        except Exception as exc:
+            print(f"  {c.red}[X] Awareness news fetch failed: {exc}{c.res}")
             return ""
 
-        lines = ["[AWARENESS — Global World News]\n"]
-        for i, r in enumerate(results, 1):
-            lines.append(
-                f"{i}. {r['title']}\n"
-                f"   Source: {r['source']}  |  {r['date']}\n"
-                f"   {r['body']}\n"
-            )
-        return "\n".join(lines)
-
-    except Exception as exc:
-        print(f"  {c.red}[X] Awareness news fetch failed: {exc}{c.res}")
-        return ""
-
 
 # ─────────────────────────────────────────────────────────────────────────────
 #  Banner
@@ -1000,7 +1051,7 @@ def print_banner(tree: str, session_id: int) -> None:
     print("─" * 60)
     print(f"  Session: {session_id}  |  Turns: {_turn_count}")
     for print_tree in ("Z", "C", "F"):
-        print(f"  Tokens garden['{print_tree}']: {garden["n_tok_tot"][tree]:,}  garden['THRESHOLD']['{print_tree}'] {garden['THRESHOLD'][print_tree]:,} garden['REDUCTION']['{print_tree}'] {garden['REDUCTION'][print_tree]:,}")
+        print(f"  Tokens garden['{print_tree}']: {garden["n_tok_tot"][tree]:,}  garden['THRESHOLD']['{print_tree}']: {garden['THRESHOLD'][print_tree]:,}  garden['REDUCTION']['{print_tree}']: {garden['REDUCTION'][print_tree]:,}")
 
     print( "  /help for commands  |  /exit or /quit to close")
     print(f"═" * 60)
@@ -1023,7 +1074,7 @@ def reset_turn_content(tree: str = "") -> None:
         sensor[tree]["input"] = ""
         sensor[tree]["n_tok"] = 0
         garden["popped"][tree] = [] # condensatron post-level cache
-        garden["condensatron_state"][tree] = False
+        garden["condensatron_state"][tree] = False # condensatron state
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -1074,11 +1125,10 @@ def main() -> None:
     _heartbeats: int = 0
     _HEARTBEAT_INTERVAL: float = 1.0   # seconds per tick
     _timings: dict[str, TimingResult] = {}
+    _tree: str = ""
 
-    _tree: str = "Z"
-    print_banner(_tree, _session_id)
-
-    print(f"\n{c.inv} You: {c.res} ", end="", flush=True)
+    print_banner("Z", _session_id)
+    print(f"\n{c.inv} You: {c.res} ", end="", flush=True) # Preset first cycle
 
     while True:
         _sensor_input: str = "" # user input
@@ -1096,34 +1146,34 @@ def main() -> None:
                 _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
+                # Reset turn-based data and preset terminal for next cycle
                 _heartbeats_startup, _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
-
-        # ── Sensor: User input ───────────────────────────────────────────────────
-        try:
-            _sensor_input = input_queue.get_nowait()
-            _heartbeats_startup, _heartbeats = 0, 0
-        except queue.Empty:
-            pass
+                continue # Restart the while loop
 
         # ── Startup: Load memory capsules ────────────────────────────────────────
-        if _heartbeats_startup >= 10: # Timed loop
+        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}")
 
-        # ── X Y factor timer ─────────────────────────────────────────────────────
+        # ── Z-factor sentience user input ────────────────────────────────────────
+        try:
+            _sensor_input = input_queue.get_nowait()
+            _heartbeats_startup, _heartbeats = 0, 0
+        except queue.Empty:
+            pass
+
+        # ── X-factor and Y-factor timer ──────────────────────────────────────────
         if _heartbeats >= AWARENESS_CONSCIOUSNESS_HEARTBEAT_INTERVAL:
             # ── X-factor awareness cycle ─────────────────────────────────────────
             if not config.was_awareness_cycle:
                 _heartbeats_startup, _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}")
+                print(f"\n  {c.green}── X-factor: _news:\n{_news}\n──────────────────────────{c.res}")
                 if _news:
                     config.was_awareness_cycle = True
                     _sensor_input = _news # Use the sensor["Z"]["input"]
@@ -1133,20 +1183,20 @@ def main() -> None:
                 config.was_awareness_cycle = False
                 print(f"\n  {c.inv} ── Y-factor: consciousness self-reflection ── {c.res}")
                 _tree = "Y"
-                print(f"\n  {c.inv} ── Y-factor: consciousness pipeline ── {c.res}")
-                # ── Brain pipeline condensatron cycle ────────────────────────────
+                # ── Brain pipeline consciousness cycle ───────────────────────────
                 _timings = Mindlink(_models, _tree)
                 _timings["mind"] = Lambda(_models, _tree)
                 memotron(_models, _tree, _session_id, _timings) # Append to garden history
-                # Reset turn-based data
+                # Reset turn-based data and preset terminal for next cycle
                 _heartbeats_startup, _heartbeats = 0, 0
                 reset_turn_content(tree=_tree)
                 print(f"\n{c.inv} You: {c.res} ", end="", flush=True)
-                continue # restart the while loop
+                continue # Restart the while loop
 
         if not _sensor_input: # wait state loop restart here
             continue
 
+        # ── Slash command detection ──────────────────────────────────────────
         if _sensor_input.startswith("/"): # Read user slash command
             try:
                 _slash_command_result = handle_command(_sensor_input)
@@ -1155,6 +1205,8 @@ def main() -> None:
                 break
             except _Clear:
                 garden[_tree].clear()
+                # Reset turn-based data
+                _heartbeats_startup, _heartbeats = 0, 0
                 reset_turn_content()
                 print(f"  {c.green}[*] History cleared. Models and session stay active.{c.res}")
                 print_banner(_tree, _session_id)
@@ -1173,25 +1225,26 @@ def main() -> None:
         # ── Brain pipeline ────────────────────────────────────────────────────
         _timings = Mindlink(_models, _tree)
         _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} ── memotron _startup_memory_capsules_loaded: {_startup_memory_capsules_loaded} ──────────────────────────── {c.res}")
+            print(f"  {c.inv} ──  _startup_memory_capsules_loaded: {_startup_memory_capsules_loaded} of {config.N_MEMORY_CAPSULES_TO_LOAD} ──────────────────────────── {c.res}")
             _tree = "S" # Set to memorize as memory capsules in garden["C"]
-            memotron(_models, _tree, _session_id, _timings) # Store the startup response 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
-        else:
-            memotron(_models, _tree, _session_id, _timings) # Store the response
+
+        memotron(_models, _tree, _session_id, _timings) # Store the response
+        # Reset turn-based data and preset terminal for next cycle
+        _heartbeats_startup, _heartbeats = 0, 0
+        reset_turn_content() # Reset Z-factor data only
+        print(f"\n{c.inv} You: {c.res} ", end="", flush=True)
+
         # ── Condensatron evaluation ───────────────────────────────────────────
         for c_tree in ["Z", "C", "F"]:
             if garden["n_tok_tot"][c_tree] >= garden["THRESHOLD"][c_tree]: # Check garden context budget
                 print(f"  {c.inv} ── Init condensatron get posts: garden['{c_tree}'] ──────────────────────────── {c.res}")
                 condensatron(_models["mind"], c_tree, "mind") # Start condensatron get popped posts
 
-        reset_turn_content()
-        _heartbeats_startup, _heartbeats = 0, 0
-        print(f"\n{c.inv} You: {c.res} ", end="", flush=True)
-
 
 if __name__ == "__main__":
     main()