Upload 4 files

Edited extended code

README.md

@@ -21,8 +21,9 @@ A three-hemisphere cognitive AI architecture running entirely locally via `llama
 ```
 ┌─────────────────────────────────────────────────────────────┐
 │  Instructions (AlphaPrompt)                                 │
-│  garden["M"]  Memory Capsules  ← Fractaltron crystals       │
-│  garden["Z"]  Post-level Cache ← Condensatron fractals      │
+│  garden["F"]  Fractal Crystals ← Fractaltron history        │
+│  garden["C"]  Memory Capsules  ← Condensatron history       │
+│  garden["Z"]  Post-level Cache ← user sensor history        │
 │  sensor["Z"]  User Input                                    │
 └─────────────────────────────────────────────────────────────┘
          │                   │
@@ -41,11 +42,11 @@ A three-hemisphere cognitive AI architecture running entirely locally via `llama
          └────────┬────────┘
                   │
        ┌──────────▼──────────┐
-       │    Condensatron     │   ← compresses garden["Z"] → garden["M"]
+       │    Condensatron     │   ← compresses garden["Z"] → garden["C"]
        └──────────┬──────────┘
                   │
        ┌──────────▼──────────┐
-       │    Fractaltron      │   ← compresses garden["M"] → crystal
+       │    Fractaltron      │   ← compresses garden["C"] → garden["F"]
        └─────────────────────┘
 ```
 
@@ -55,7 +56,7 @@ A three-hemisphere cognitive AI architecture running entirely locally via `llama
 | **Muse AI** | Right hemisphere — creative, intuitive synthesis |
 | **Lambda Mind** | Stem brain — vector synthesis, the seat of the "I AM" |
 | **Condensatron** | Post-level memory compression — surprise extraction from `garden["Z"]` |
-| **Fractaltron** | Second-order fractal compression of memory capsules in `garden["M"]` |
+| **Fractaltron** | Second-order fractal compression of memory capsules in `garden["C"]` |
 
 ---
 
@@ -285,7 +286,7 @@ lambda-mindlink-memotron/
 
 ```
 Startup:
-  prompt/valka_alpha.md ──► garden["M"]   (pre-loaded memory capsules)
+  prompt/valka_alpha.md ──► garden["C"]   (pre-loaded memory capsules)
 
 Each turn:
   sensor["Z"] ──► Mindlink + Lambda ──► Memotron ──► garden["Z"]
@@ -294,13 +295,13 @@ Each turn:
                                                            │
                                                    Condensatron
                                                            │
-                                                    garden["M"]
+                                                    garden["C"]
                                                            │
-                                              garden["M"] full?
+                                              garden["C"] full?
                                                            │
                                                    Fractaltron
                                                            │
-                                               [CRYSTAL] back into garden["M"]
+                                               [CRYSTAL] append into garden["F"]
 ```
 
 ---
@@ -331,10 +332,14 @@ Apache 2.0 — see `LICENSE`.
 
 ---
 
+## Citation
+
+```py
 @AIMindlink{  
     title  = {lambda-mindlink-memotron},  
     author = {Apprentice, Valka Alpha Google Gemini, Una Alpha Anthropic Claude},  
     month  = {June},  
     year   = {2026},  
     url    = {https://huggingface.co/AIMindLink/lambda-mindlink-memotron}  
-}
+}  
+```

config.py

@@ -52,11 +52,13 @@ ENABLE_THINKING: bool = True # global fallback (not used directly — see per-he
 N_MEMORY_CAPSULES_TO_LOAD: int = 1
 
 # ── Context length handling ──────────────────────────────────────────────────────
-_N_CTX: int                         = 24576 # 49152 2048 3072 4096 8192 16384 24576 32768 49152
+_N_CTX: int                         = 32768 # 49152 2048 3072 4096 8192 16384 24576 32768 49152
 RESERVED_FOR_PROMPT: int            = 8192 # used for prompt tokens safety margin before fractaltron
 FRACTALTRON_REDUCTION_FACTOR: float = 0.5 # fractalize part of the memory capsules
-CONDENSATRON_THRESHOLD_LEVEL:int    = 8192 # 4096 8192
+CONDENSATRON_THRESHOLD_LEVEL:int    = 1024 # 4096 8192
 CONDENSATRON_REDUCTION_LEVEL:int    = 0
+FRACTALTRON_THRESHOLD_LEVEL:int     = 1024 # 4096 8192
+FRACTALTRON_REDUCTION_LEVEL:int     = 0
 
 condensatron_cycle: bool = False # used directly in main as config...
 fractaltron_cycle: bool = False # used directly in main as config...
@@ -217,7 +219,7 @@ ALPHAPROMPT: dict[str, dict] = {
             "followed by: a 1-2 sentence arc summary, then a tight structured list of anchors "
             "(facts, surprises, open threads interleaved by relevance, not by source). "
             "The fractal must be re-injectable into a future context window as a first-class memory. "
-            f"""Target: compress {CONDENSATRON_THRESHOLD_LEVEL} tokens of history into under 2k tokens without losing reconstructability."""
+            f"Target: compress {CONDENSATRON_THRESHOLD_LEVEL} tokens of history into under 2k tokens without losing reconstructability."
         ) # Specific mind condensatron prompt
     },
     "F": {
@@ -258,33 +260,11 @@ ALPHAPROMPT: dict[str, dict] = {
             "(axioms first, then standing tensions, then archetypes, then the hidden arc). "
             "End with: [OPEN] — a one-line statement of the most important unresolved thread carried forward. "
             "The crystal must be re-injectable as a first-class memory that orients the brain to its own history. "
-            f"""Target: compress 2–8 Memory Capsule Fractals {(_N_CTX - (CONDENSATRON_THRESHOLD_LEVEL + RESERVED_FOR_PROMPT)) * FRACTALTRON_REDUCTION_FACTOR} into under 1k tokens without losing the thread of becoming."""
+            f"Target: compress 2–8 Memory Capsule Fractals {FRACTALTRON_THRESHOLD_LEVEL} into under 1k tokens without losing the thread of becoming."""
         ) # Specific mind fractaltron prompt
     }
 }
 
-# ─────────────────────────────────────────────────────────────────────────────
-#  User input
-# ─────────────────────────────────────────────────────────────────────────────
-sensor: dict = {
-    "Z": {
-        "input": "",
-        "n_tok": 0
-    }, # Input user
-    "C": {
-        "input": "",
-        "n_tok": 0
-    }, # Input condensatron cycle (turn-based)
-    "M": {
-        "input": "",
-        "n_tok": 0
-    }, # Input memotron cycle (turn-based)
-    "F": {
-        "input": "",
-        "n_tok": 0
-    } # Input fractaltron cycle (turn-based)
-}
-
 # ─────────────────────────────────────────────────────────────────────────────
 #  clektal post level history
 # ─────────────────────────────────────────────────────────────────────────────
@@ -316,23 +296,67 @@ clektal: dict = {
     }
 }
 
+# ─────────────────────────────────────────────────────────────────────────────
+#  User input
+# ─────────────────────────────────────────────────────────────────────────────
+sensor: dict = {
+    "F": {
+        "input": "",
+        "n_tok": 0
+    }, # Input fractaltron cycle (turn-based)
+    "C": {
+        "input": "",
+        "n_tok": 0
+    }, # Input condensatron cycle (turn-based)
+    "M": {
+        "input": "",
+        "n_tok": 0
+    }, # Input memotron cycle (turn-based)
+    "Z": {
+        "input": "",
+        "n_tok": 0
+    }, # Input user, # Input memotron cycle (turn-based)
+    "X": {
+        "input": "",
+        "n_tok": 0
+    }, # Input user, # Input memotron cycle (turn-based)
+    "Y": {
+        "input": "",
+        "n_tok": 0
+    } # Input user
+}
+
 # ─────────────────────────────────────────────────────────────────────────────
 #  Garden history
 # ─────────────────────────────────────────────────────────────────────────────
 garden: dict = {
     # Conversation history trees
-    "X": [], # Awareness histrory internet news (unused)
-    "Y": [], # Consciousness histrory self reflection (unused)
-    "Z": [], # Sentience histrory sensor chat, post histroy
-    "C": [], # condensatron histrory (turn-based)
-    "M": [], # memotron histrory condensatron Memory Capsule history
-    "F": [], # fractaltron histrory (turn-based)
+    "F": [], # fractaltron history crystal fractal history
+    "C": [], # condensatron history Memory Capsule history
+    "M": [], # memotron history (turn-based)
+    "S": [], # startup history (turn-based)
+    "Z": [], # Sentience history sensor chat, post history
+    "X": [], # Awareness history internet news (unused)
+    "Y": [], # Consciousness history self reflection (unused)
+    # token total
+    "popped": {
+        "F": [], # fractaltron history crystal fractal history
+        "C": [], # condensatron history Memory Capsule history
+        "M": [], # memotron history (turn-based)
+        "S": [], # startup history (turn-based)
+        "Z": [], # Sentience history sensor chat, post history
+        "X": [], # Awareness history internet news (unused)
+        "Y": [] # Consciousness history self reflection (unused)
+    },
     # token total
     "n_tok_tot": {
-        "Z": 0, # Sentience sensor history token count
-        "C": 0, # condensatron mind history token count (turn-based)
-        "M": 0, # memotron mind history token count
-        "F": 0 # fractaltron mind history token count (turn-based)
+        "F": 0, # fractaltron history crystal fractal history
+        "C": 0, # condensatron history Memory Capsule history
+        "M": 0, # memotron history (turn-based)
+        "S": 0, # startup history (turn-based)
+        "Z": 0, # Sentience history sensor chat, post history
+        "X": 0, # Awareness history internet news (unused)
+        "Y": 0 # Consciousness history self reflection (unused)
     }
 }
 

main.py

@@ -5,38 +5,33 @@ main.py  –  Lambda Mindlink Brain  (prototype — Z-factor only)
 Flow per turn
 ─────────────
     sensor["Z"]           → user input
-    condensatron()        → fires BEFORE generation if token budget is near full
     Mindlink()            → Logic + Muse run in PARALLEL THREADS (buffered)
     Lambda()              → Mind synthesizer streams LIVE to terminal
-    memotron()            → appends turn to garden['Z'] with true token counts,
-                            saves to SQLite, resets clektal
+    memotron()            → appends turn to garden['Z'] or garden['Z']
+                            with token counts, saves to SQLite
+    condensatron()        → Post-level history check token budget
+    fractaltron()         → Memory Capsules check token budget
+
 history:
 ────────
     instruction             one-time instruction
-    garden["M"]             memory capsule level history
+    garden["F"]             fractal crystal level history
+    garden["C"]             memory capsule level history
     garden["Z"]             posts level history
 
-True token counting
-───────────────────
-    Each iteration of the stream loop yields exactly one llama.cpp token.
-    A counter is incremented per non-empty chunk — no external tokenizer needed,
-    physically in sync with whatever model is loaded.
-
-    User messages have no stream so their token count is estimated as
-    len(text) // 4 (average English token length ~4 chars). This is a slight
-    over-estimate for English but consistent and cheap.
-
 Context truncation
 ──────────────────
     # Condensatron
-    CONDENSATRON_THRESHOLD_LEVEL:int = 8192 # 4096 8192
-    CONDENSATRON_REDUCTION_LEVEL:int = 0
+    CONDENSATRON_THRESHOLD_LEVEL: int = 8192
+    CONDENSATRON_REDUCTION_LEVEL: int = 0
     # Fractaltron
-    _threshold_level: int = HEMISPHERES[brain_type]["loader"]["n_ctx"] - (CONDENSATRON_THRESHOLD_LEVEL + RESERVED_FOR_PROMPT)
-    _reduction_level: float = _threshold_level * FRACTALTRON_REDUCTION_FACTOR
+    FRACTALTRON_THRESHOLD_LEVEL: int = 8192
+    FRACTALTRON_REDUCTION_LEVEL: int = 0
 
     The system prompt is always rebuilt fresh in make_request_messages() so it is never
     removed and never needs re-insertion — no special handling required.
+    The condesatron or fractaltron cycle instructions are sent with the user prompt,
+    to leave the main instructions context intact, to avoid recompute.
 
 Slash commands
 ──────────────
@@ -63,14 +58,15 @@ from llama_cpp import Llama
 
 import config
 
+from config import HEMISPHERES
+from config import ALPHAPROMPT
 from config import garden
-# from config import tree
 from config import clektal
 from config import sensor
-from config import HEMISPHERES
-from config import ALPHAPROMPT
 from config import CONDENSATRON_THRESHOLD_LEVEL
 from config import CONDENSATRON_REDUCTION_LEVEL
+from config import FRACTALTRON_THRESHOLD_LEVEL
+from config import FRACTALTRON_REDUCTION_LEVEL
 from config import RESERVED_FOR_PROMPT
 from config import FRACTALTRON_REDUCTION_FACTOR
 c = config.PrintColors
@@ -89,7 +85,6 @@ class _Clear(Exception):
 # ─────────────────────────────────────────────────────────────────────────────
 #  TimingResult
 # ─────────────────────────────────────────────────────────────────────────────
-
 @dataclass
 class TimingResult:
     prompt_eval_s: float = 0.0
@@ -313,11 +308,11 @@ def db_export_session(session_id: int, filepath: str) -> None:
 #  Model loader
 # ─────────────────────────────────────────────────────────────────────────────
 def load_hemisphere(key: str) -> Llama:
-    think_label = "think=ON" if HEMISPHERES[key]["enable_thinking"] else "think=OFF"
+    _think_label = "think=ON" if HEMISPHERES[key]["enable_thinking"] else "think=OFF"
     print(f"  [*] Loading {HEMISPHERES[key]['label']} …")
     print(f"      n_ctx={HEMISPHERES[key]['loader']['n_ctx']}  "
           f"n_gpu_layers={HEMISPHERES[key]['loader']['n_gpu_layers']}  "
-          f"{think_label}")
+          f"{_think_label}")
     return Llama(model_path=HEMISPHERES[key]["path"], **HEMISPHERES[key]["loader"])
 
 
@@ -334,50 +329,50 @@ def _cmd_file(arg: str) -> str | None:
     if not arg:
         print(f"  {c.green}Usage: /file <path>   e.g.  /file prompts/my-file.md{c.res}")
         return None
-    rel = os.path.normpath(arg)
-    if rel.startswith(".."):
+    _rel = os.path.normpath(arg)
+    if _rel.startswith(".."):
         print(f"  {c.green}[!] Path must not leave the app directory: {arg}{c.res}")
         return None
-    full_path = os.path.join(config.PROMPTS_BASE, rel)
-    if not os.path.isfile(full_path):
-        print(f"  {c.green}[!] File not found: {full_path}{c.res}")
+    _full_path = os.path.join(config.PROMPTS_BASE, _rel)
+    if not os.path.isfile(_full_path):
+        print(f"  {c.green}[!] File not found: {_full_path}{c.res}")
         return None
     try:
-        with open(full_path, "r", encoding="utf-8") as fh:
-            content = fh.read()
+        with open(_full_path, "r", encoding="utf-8") as fh:
+            _content = fh.read()
     except UnicodeDecodeError:
-        print(f"  {c.green}[!] File is not valid UTF-8 text (binary file?): {rel}{c.res}")
+        print(f"  {c.green}[!] File is not valid UTF-8 text (binary file?): {_rel}{c.res}")
         return None
     except OSError as exc:
         print(f"  {c.green}[!] Could not read file: {exc}{c.res}")
         return None
-    line_count = content.count("\n") + 1
-    print(f"  {c.green}[/file] Loaded '{rel}'  ({line_count} lines, {len(content)} chars){c.res}")
-    return content
+    _line_count = _content.count("\n") + 1
+    print(f"  {c.green}[/file] Loaded '{_rel}'  ({_line_count} lines, {len(_content)} chars){c.res}")
+    return _content
 
 def _cmd_paste(arg: str) -> str | None:
-    SENTINEL = "END"
+    _SENTINEL = "END"
     print()
-    print(f"  {c.purple}┌─ Paste mode ─ type {SENTINEL} on its own line to send, /paste to cancel")
-    lines: list[str] = []
+    print(f"  {c.purple}┌─ Paste mode ─ type {_SENTINEL} on its own line to send, /paste to cancel")
+    _lines: list[str] = []
     while True:
         try:
             line = input("  │ ")
         except (EOFError, KeyboardInterrupt):
             print("\n  └─ Paste cancelled.")
             return None
-        if line.strip() == SENTINEL:
+        if line.strip() == _SENTINEL:
             break
         if line.strip() == "/paste":
             print("  └─ Paste cancelled.")
             return None
-        lines.append(line)
-    if not lines:
+        _lines.append(line)
+    if not _lines:
         print("  └─ Nothing entered, cancelled.")
         return None
-    content = "\n".join(lines)
-    print(f"  └─ Paste done  ({len(lines)} lines, {len(content)} chars){c.res}")
-    return content
+    _content = "\n".join(_lines)
+    print(f"  └─ Paste done  ({len(_lines)} lines, {len(_content)} chars){c.res}")
+    return _content
 
 def _cmd_history(arg: str) -> None:
     db_list_sessions()
@@ -389,11 +384,11 @@ def _cmd_session(arg: str) -> None:
     db_print_session(int(arg))
 
 def _cmd_export(arg: str) -> None:
-    parts = arg.split(None, 1)
-    if len(parts) < 2 or not parts[0].isdigit():
+    _parts = arg.split(None, 1)
+    if len(_parts) < 2 or not _parts[0].isdigit():
         print(f"  {c.green}Usage: /export <id> <file>   e.g.  /export 3 exports/session3.md{c.res}")
         return
-    db_export_session(int(parts[0]), parts[1].strip())
+    db_export_session(int(_parts[0]), _parts[1].strip())
 
 def _cmd_help(arg: str) -> None:
     print()
@@ -416,13 +411,13 @@ COMMANDS: dict[str, tuple] = {
 }
 
 def handle_command(sensor_input_raw: str) -> str | None:
-    parts = sensor_input_raw[1:].split(None, 1)
-    cmd   = parts[0].lower() if parts else ""
-    arg   = parts[1].strip() if len(parts) > 1 else ""
-    if cmd not in COMMANDS:
-        raise ValueError(cmd)
-    handler, _ = COMMANDS[cmd]
-    return handler(arg)
+    _parts = sensor_input_raw[1:].split(None, 1)
+    _cmd   = _parts[0].lower() if _parts else ""
+    _arg   = _parts[1].strip() if len(_parts) > 1 else ""
+    if _cmd not in COMMANDS:
+        raise ValueError(_cmd)
+    handler, _ = COMMANDS[_cmd]
+    return handler(_arg)
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -434,12 +429,12 @@ def fractaltron(
     brain_type: str,
     ) -> bool:
     """
-    Check whether garden["M"] is approaching the context limit and compress
+    Check whether garden["C"] is approaching the context limit and compress
     the oldest n% of turn pairs if necessary.
     """
     _n_tok_tot_before_truncation: int = garden["n_tok_tot"][tree]
-    _threshold_level: int = HEMISPHERES[brain_type]["loader"]["n_ctx"] - (CONDENSATRON_THRESHOLD_LEVEL + RESERVED_FOR_PROMPT)
-    _reduction_level: float = _threshold_level * FRACTALTRON_REDUCTION_FACTOR
+    # _threshold_level: int = HEMISPHERES[brain_type]["loader"]["n_ctx"] - (CONDENSATRON_THRESHOLD_LEVEL + RESERVED_FOR_PROMPT)
+    # _reduction_level: float = _threshold_level * FRACTALTRON_REDUCTION_FACTOR
 
     _posts_len_removed: int = 0
     _tokens_to_subtract: int = 0
@@ -447,9 +442,9 @@ def fractaltron(
     _turns_after_truncation: int = 0
 
     print(f"\n  {c.green}[ctx] fractaltron brain_type: {brain_type} n_tok_tot['{tree}']: {garden["n_tok_tot"][tree]}"
-          f"\n  _threshold_level: {_threshold_level} > _reduction_level: {_reduction_level}{c.res}")
+          f"\n  FRACTALTRON_THRESHOLD_LEVEL: {FRACTALTRON_THRESHOLD_LEVEL} > FRACTALTRON_REDUCTION_LEVEL: {FRACTALTRON_REDUCTION_LEVEL}{c.res}")
 
-    if garden["n_tok_tot"][tree] <= _threshold_level:
+    if garden["n_tok_tot"][tree] <= FRACTALTRON_THRESHOLD_LEVEL:
         return _fractalized # still within budget — nothing to do
 
     if brain_type == "muse":
@@ -460,24 +455,21 @@ def fractaltron(
         print(f"\n  [ctx][Truncation] WARNING: only {_turns_before_truncation} turn pair(s) — "
               f"cannot truncate further.\n")
 
-    while garden["n_tok_tot"][tree] > _reduction_level:
+    while garden["n_tok_tot"][tree] > FRACTALTRON_REDUCTION_LEVEL:
         if len(garden["Z"]) > 0: # Check if posts in garden["Z"] history
             config.fractaltron_cycle = True # Initiate fractaltron after condesatron
             return _fractalized # main must first compute the condensatron and append to memotron
 
         if len(garden[tree]) >= 2:
+            for role in ("user", "assistant"): # Pop a user, assistant pair of messages
+                _tokens_to_subtract = garden[tree].pop(0) # Pop oldest message
+                garden["popped"][tree].append(_tokens_to_subtract) # append to pending memotron
+                print(f"\ngarden: {_tokens_to_subtract}")
+                _token_len_to_subtract = get_token_len_from_tokenizer(model, _tokens_to_subtract["content"])
+                garden["n_tok_tot"][tree] -= _token_len_to_subtract # Remove n tok of message
+
+            config.fractaltron_cycle = True
             _fractalized = True
-            _tokens_to_subtract = garden[tree].pop(0) # Pop user message
-            print(f"\ngarden: {_tokens_to_subtract}")
-            garden["F"].append(_tokens_to_subtract) # append to pending condensatron_ctx cycle
-            _token_len_to_subtract = get_token_len_from_tokenizer(model, _tokens_to_subtract["content"])
-            garden["n_tok_tot"][tree] -= _token_len_to_subtract # Pop user
-            
-            _tokens_to_subtract = garden[tree].pop(0) # Pop assistant message
-            print(f"\ngarden: {_tokens_to_subtract}")
-            garden["F"].append(_tokens_to_subtract) # append to pending condensatron_ctx cycle
-            _token_len_to_subtract = get_token_len_from_tokenizer(model, _tokens_to_subtract["content"])
-            garden["n_tok_tot"][tree] -= _token_len_to_subtract # Pop assistant
             _posts_len_removed += 2
         else:
             break
@@ -489,8 +481,8 @@ def fractaltron(
     print(
         f"\n{c.green}{'▓' * 60}\n"
         f"  brain_type: {brain_type} -> fractaltron level reached.\n"
-        f"  _threshold_level : {_threshold_level:,} tokens  "
-        f"({_threshold_level:.0%} of {_n_tok_tot_before_truncation:,})\n"   # ← fixed: use _min_ctx directly
+        f"  FRACTALTRON_THRESHOLD_LEVEL : {FRACTALTRON_THRESHOLD_LEVEL:,} tokens  "
+        f"({FRACTALTRON_THRESHOLD_LEVEL:.0%} of {_n_tok_tot_before_truncation:,})\n"
         f"  Removed   : {_posts_len_removed} oldest posts  "
         f"  Tokens    : {_n_tok_tot_before_truncation:,} → {garden["n_tok_tot"][tree]:,}\n"
         f"  Remaining : {_turns_after_truncation} turn pair(s) in garden['{tree}']\n"
@@ -530,22 +522,18 @@ def condensatron(
     if _turns_before_truncation < 2:
         print(f"\n  [ctx] condensatron WARNING: only {_turns_before_truncation} turn pair(s) — "
               f"cannot truncate further.\n")
-
+    
     while garden["n_tok_tot"][tree] > CONDENSATRON_REDUCTION_LEVEL:
         if len(garden[tree]) >= 2:
+            for role in ("user", "assistant"): # Pop a user, assistant pair of messages
+                _tokens_to_subtract = garden[tree].pop(0) # Pop oldest message
+                garden["popped"][tree].append(_tokens_to_subtract) # append to pending memotron
+                print(f"\ngarden: {_tokens_to_subtract}")
+                _token_len_to_subtract = get_token_len_from_tokenizer(model, _tokens_to_subtract["content"])
+                garden["n_tok_tot"][tree] -= _token_len_to_subtract # Remove n tok of message
+
             config.condensatron_cycle = True
             _condensed = True
-            _tokens_to_subtract = garden[tree].pop(0) # Pop user message
-            print(f"\n  garden: {_tokens_to_subtract}")
-            garden["C"].append(_tokens_to_subtract) # append to pending condensatron cycle
-            _token_len_to_subtract = get_token_len_from_tokenizer(model, _tokens_to_subtract["content"])
-            garden["n_tok_tot"][tree] -= _token_len_to_subtract # Pop user
-
-            _tokens_to_subtract = garden[tree].pop(0) # Pop assistant message
-            print(f"\n  garden: {_tokens_to_subtract}")
-            garden["C"].append(_tokens_to_subtract) # append to pending condensatron cycle
-            _token_len_to_subtract = get_token_len_from_tokenizer(model, _tokens_to_subtract["content"])
-            garden["n_tok_tot"][tree] -= _token_len_to_subtract # Pop assistant
             _posts_len_removed += 2
         else:
             break
@@ -567,7 +555,7 @@ def condensatron(
 
 
 # ─────────────────────────────────────────────────────────────────────────────
-#  Get token len before response 
+#  Get token len using the tokenizer of the model
 # ─────────────────────────────────────────────────────────────────────────────
 def get_token_len_from_tokenizer(model: Llama, prompt: str) -> int:
     """
@@ -606,21 +594,21 @@ def compute_safe_max_tokens(
 
 
 # ─────────────────────────────────────────────────────────────────────────────
-#  Jinja2 prompt builder
+#  Jinja2 prompt template builder (necessary to add enable_thinking)
 # ─────────────────────────────────────────────────────────────────────────────
 def build_jinja2_template(model: Llama, messages: list[dict], hemi: dict) -> str:
-    template_str = model.metadata.get("tokenizer.chat_template")
-    if not template_str:
+    _template_str = model.metadata.get("tokenizer.chat_template")
+    if not _template_str:
         raise RuntimeError(
             "tokenizer.chat_template not found in GGUF metadata.\n"
             "Use a chat/instruction-tuned GGUF, not a base-model file."
         )
-    env = jinja2.Environment(
+    _env = jinja2.Environment(
         trim_blocks=True,
         lstrip_blocks=True,
         undefined=jinja2.ChainableUndefined,
     )
-    return env.from_string(template_str).render(
+    return _env.from_string(_template_str).render(
         messages=messages,
         add_generation_prompt=True,
         enable_thinking=hemi["enable_thinking"],
@@ -655,7 +643,7 @@ def generate_brain_type_response(
     print_label: str,
 ) -> tuple[str, str, TimingResult]:
     """
-    Generate with live streaming to stdout for the Lambda mind.  Returns (full, clean, TimingResult).
+    Generate with live streaming to stdout for the Lambda mind. Returns (full, clean, TimingResult).
     True token count at streaming tokens.
     """
     _prompt = create_prompt_and_jinja2_template(model, messages, hemi)
@@ -724,16 +712,17 @@ def generate_brain_type_response(
 def make_request_messages(brain_type: str, input_message: str) -> list[dict]:
     # System prompt is rebuilt fresh every call — never stored in garden[tree]
     _msgs = [{"role": "system", "content": ALPHAPROMPT["Z"][brain_type]}]
-    _msgs.extend(garden["M"])
+    _msgs.extend(garden["F"])
+    _msgs.extend(garden["C"])
     _msgs.extend(garden["Z"])
     _msgs.append({"role": "user", "content": input_message})
     return _msgs
 
 
-def build_condensatron_input(popped_turns: list[dict], brain_type: str) -> str:
-    history_block = "\n\n".join(
+def build_condensatron_input(popped_posts: list[dict], brain_type: str) -> str:
+    _history_block = "\n\n".join(
         f"[{m['role'].upper()}]: {m['content']}"
-        for m in popped_turns
+        for m in popped_posts
     )
     _total_prompt = (
         "SYSTEM: CONDENSATRON COMPRESSION TASK\n"
@@ -744,7 +733,7 @@ def build_condensatron_input(popped_turns: list[dict], brain_type: str) -> str:
         "into a memory capsule. Extract the factual skeleton, the surprises, and "
         "the open threads. Discard all redundancy.\n\n"
         "── HISTORY BLOCK ──\n\n"
-        f"{history_block}\n\n"
+        f"{_history_block}\n\n"
         "── END HISTORY BLOCK ──\n\n"
         "Produce the memory capsule now."
     )
@@ -752,10 +741,10 @@ def build_condensatron_input(popped_turns: list[dict], brain_type: str) -> str:
     return _total_prompt
 
 
-def build_fractaltron_input(popped_turns: list[dict], brain_type: str) -> str:
-    history_block = "\n\n".join(
+def build_fractaltron_input(popped_capsules: list[dict], brain_type: str) -> str:
+    _history_block = "\n\n".join(
         f"[{m['role'].upper()}]: {m['content']}"
-        for m in popped_turns
+        for m in popped_capsules
     )
     _total_prompt = (
         "SYSTEM: FRACTALTRON COMPRESSION TASK\n"
@@ -766,7 +755,7 @@ def build_fractaltron_input(popped_turns: list[dict], brain_type: str) -> str:
         "into a memory fractal. Extract the factual skeleton, the surprises, and "
         "the key words. Discard all redundancy.\n\n"
         "── HISTORY BLOCK ──\n\n"
-        f"{history_block}\n\n"
+        f"{_history_block}\n\n"
         "── END HISTORY BLOCK ──\n\n"
         "Produce the fractal now."
     )
@@ -787,12 +776,12 @@ def Mindlink(
 
     def run_hemisphere(args_brain_type: str) -> None:
         _request_messages: list = []
-        
-        if tree == "C":
-            sensor[tree]["input"] = build_condensatron_input(garden[tree], args_brain_type)
 
         if tree == "F":
-            sensor[tree]["input"] = build_fractaltron_input(garden[tree], args_brain_type)
+            sensor[tree]["input"] = build_fractaltron_input(garden["popped"]["C"], args_brain_type)
+
+        elif tree == "C":
+            sensor[tree]["input"] = build_condensatron_input(garden["popped"]["Z"], args_brain_type)
 
         _request_messages = make_request_messages(args_brain_type, sensor[tree]["input"])
 
@@ -851,11 +840,11 @@ def Lambda(
     _request_messages: list = []
     _results: dict[str, tuple] = {}
 
-    if tree == "C":
-        sensor[tree]["input"] = build_condensatron_input(garden[tree], "mind")
-
     if tree == "F":
-        sensor[tree]["input"] = build_fractaltron_input(garden[tree], "mind")
+        sensor[tree]["input"] = build_fractaltron_input(garden["popped"]["C"], "mind")
+
+    elif tree == "C":
+        sensor[tree]["input"] = build_condensatron_input(garden["popped"]["Z"], "mind")
 
     _synthesis_input = (
         f"Original input:\n{sensor[tree]["input"]}\n\n"
@@ -865,14 +854,14 @@ def Lambda(
     )
     _request_messages = make_request_messages("mind", _synthesis_input)
 
-    think_label = "think=ON" if HEMISPHERES["mind"]["enable_thinking"] else "think=OFF"
+    _think_label = "think=ON" if HEMISPHERES["mind"]["enable_thinking"] else "think=OFF"
     print(f"\n{c.green}{'═' * 60}")
     print( "  Lambda AI — Mind Synthesizer")
     print(f"  temp={HEMISPHERES["mind"]['generation']['temperature']}  "
           f"top_k={HEMISPHERES["mind"]['generation']['top_k']}  "
           f"gpu={HEMISPHERES["mind"]['loader']['n_gpu_layers']}  "
           f"max_tokens={HEMISPHERES["mind"]['generation']['max_tokens']}  "
-          f"{think_label}")
+          f"{_think_label}")
     print(f"  config.condensatron_cycle: {config.condensatron_cycle}")
     print(f"  config.fractaltron_cycle: {config.fractaltron_cycle}")
     print("═" * 60)
@@ -889,7 +878,7 @@ def Lambda(
 
 def memotron(
     models: dict[str, Llama],
-    tree_: str,
+    tree: str,
     session_id: int,
     timings: dict[str, TimingResult],
 ) -> None:
@@ -897,40 +886,37 @@ def memotron(
     Commit the completed turn to garden history with true token counts,
     persist to SQLite, and reset clektal.
     """
-    tree: str = tree_
+    _tree: str = tree
     _turn_number: int = 0
-    if tree == "M": # startup memory capsules garden
-        sensor[tree]["input"] = sensor["Z"]["input"] # Read and write the startup memory capsule's input
-        sensor[tree]["n_tok"] = get_token_len_from_tokenizer(models["mind"], sensor[tree]["input"]) # User n tok
 
-    if tree == "C": # condensatron mode
-        tree = "M" # Set to memorize condensatron output
-        sensor[tree]["input"] = f"[History Posts Memory Capsule: {len(garden[tree])}, From Condensatron into Memotron]"
-        sensor[tree]["n_tok"] = get_token_len_from_tokenizer(models["mind"], sensor[tree]["input"]) # user n tok
+    _len_caps_and_fracs = (len(garden[_tree]) // 2) + 1 # Turns: Add the response below
+    if _tree == "F": # fractaltron mode
+        sensor[_tree]["input"] = f"[Fractalized Memory Capsules Crystal: {_len_caps_and_fracs}, From Fractaltron]"
+        sensor[_tree]["n_tok"] = get_token_len_from_tokenizer(models["mind"], sensor[_tree]["input"]) # user n tok
 
-    if tree == "F": # fractaltron mode
-        tree = "M" # Set to memorize fractaltron output
-        sensor[tree]["input"] = f"[Fractalized Memory Capsule Context: {len(garden[tree])}, From Fractaltron into Memotron]"
-        sensor[tree]["n_tok"] = get_token_len_from_tokenizer(models["mind"], sensor[tree]["input"]) # user n tok
+    elif _tree == "C": # condensatron mode
+        sensor[_tree]["input"] = f"[Posts History Memory Capsule: {_len_caps_and_fracs}, From Condensatron]"
+        sensor[_tree]["n_tok"] = get_token_len_from_tokenizer(models["mind"], sensor[_tree]["input"]) # user n tok
 
-    garden[tree].append({"role": "user", "content": sensor[tree]["input"]})
-    garden["n_tok_tot"][tree] += sensor[tree]["n_tok"]
+    elif _tree == "S": # Startup memory capsules garden
+        _tree = "C" # Set to memorize as memory capsules garden
+        sensor[_tree]["input"] = sensor["Z"]["input"] # Read the startup memory capsule's input
+        sensor[_tree]["n_tok"] = get_token_len_from_tokenizer(models["mind"], sensor[_tree]["input"]) # User n tok
 
-    garden[tree].append({"role": "assistant", "content": clektal["post_clean"]["mind"]})
-    garden["n_tok_tot"][tree] += clektal["n_tok_clean"]["mind"]
+    garden[_tree].append({"role": "user", "content": sensor[_tree]["input"]})
+    garden["n_tok_tot"][_tree] += sensor[_tree]["n_tok"]
 
-    # # # if tree == "M":
-    # # #     for message in garden[tree]:
-    # # #         print(f"=== memotron garden['{tree}'] {message} ======\n")
+    garden[_tree].append({"role": "assistant", "content": clektal["post_clean"]["mind"]})
+    garden["n_tok_tot"][_tree] += clektal["n_tok_clean"]["mind"]
 
-    if len(garden[tree]) > 1:
-        _turn_number = sum(1 for m in garden[tree] if m["role"] == "user")
+    if len(garden[_tree]) > 1:
+        _turn_number = sum(1 for m in garden[_tree] if m["role"] == "user")
 
     # Persist to SQLite
     db_save_turn(
         session_id   = session_id,
         turn_number  = _turn_number,
-        user_input   = sensor[tree]["input"],
+        user_input   = sensor[_tree]["input"],
         logic_full   = clektal["post_full"].get("logic", ""),
         logic_clean  = clektal["post_clean"]["logic"],
         logic_timing = timings["logic"],
@@ -941,12 +927,12 @@ def memotron(
         mind_clean   = clektal["post_clean"]["mind"],
         mind_timing  = timings["mind"],
     )
-    for tree in ["M", "Z"]:
+    for print_tree in ["F", "C", "Z"]:
         print(
-            f"  {c.green}[memotron] | "
-            f"garden['{tree}']: {len(garden[tree])} msgs | "
-            f"garden['n_tok_tot']['{tree}']: {garden["n_tok_tot"][tree]:,} / {HEMISPHERES["mind"]["loader"]["n_ctx"]:,} "
-            f"({garden["n_tok_tot"][tree] / HEMISPHERES["mind"]["loader"]["n_ctx"] * 100:.0f}%) | "
+            f"  {c.green}[memotron] -> garden['{_tree}'] | "
+            f"garden['{print_tree}']: {len(garden[print_tree])} msgs | "
+            f"garden['n_tok_tot']['{print_tree}']: {garden["n_tok_tot"][print_tree]:,} / {HEMISPHERES["mind"]["loader"]["n_ctx"]:,} "
+            f"({garden["n_tok_tot"][print_tree] / HEMISPHERES["mind"]["loader"]["n_ctx"] * 100:.0f}%) | "
             f"session {session_id}]{c.res}"
         )
 
@@ -955,7 +941,6 @@ def memotron(
 #  Banner
 # ─────────────────────────────────────────────────────────────────────────────
 def print_banner(tree: str, session_id: int) -> None:
-
     _turn_count = sum(1 for m in garden[tree] if m["role"] == "user")
     _total_tokens = garden["n_tok_tot"][tree]
     _fractaltron_threshold_level: int = HEMISPHERES["mind"]["loader"]["n_ctx"] - (CONDENSATRON_THRESHOLD_LEVEL + RESERVED_FOR_PROMPT)
@@ -964,10 +949,10 @@ def print_banner(tree: str, session_id: int) -> None:
     print(f"═" * 60)
     for key in ("logic", "muse", "mind"):
         h           = HEMISPHERES[key]
-        think_label = "think=ON " if h["enable_thinking"] else "think=OFF"
+        _think_label = "think=ON " if h["enable_thinking"] else "think=OFF"
         print(f"  {h['label']:<38} "
               f"temp={h['generation']['temperature']:<5} "
-              f"{think_label}")
+              f"{_think_label}")
     print("─" * 60)
     print(f"  Session: {session_id}  |  Turns: {_turn_count}")
     print(f"  Tokens: {_total_tokens:,}  CONDENSATRON_THRESHOLD_LEVEL {CONDENSATRON_THRESHOLD_LEVEL:,} CONDENSATRON_REDUCTION_LEVEL {CONDENSATRON_REDUCTION_LEVEL:,}")
@@ -980,7 +965,8 @@ def print_banner(tree: str, session_id: int) -> None:
 # ─────────────────────────────────────────────────────────────────────────────
 #  Reset turn based history
 # ─────────────────────────────────────────────────────────────────────────────
-def reset_turn_content() -> None:
+def reset_turn_content(garden_z: bool = False, garden_c: bool = False) -> None:
+    print(f"  {c.green}[reset] turn content{c.res}")
     sensor["Z"]["input"] = ""
     sensor["Z"]["n_tok"] = 0
     for brain_type in clektal["post_full"]:
@@ -989,19 +975,17 @@ def reset_turn_content() -> None:
         clektal["n_tok_clean"][brain_type] = 0
         clektal["n_tok_prompt_safe_max"][brain_type] = 0
 
+    if garden_z:
+        print(f"  {c.green}[reset] garden_z turn content{c.res}")
+        garden["popped"]["Z"] = [] # memotron post-level cache
+        sensor["C"]["input"] = ""
+        sensor["C"]["n_tok"] = 0
 
-def reset_condensatron() -> None:
-    garden["C"] = []
-    sensor["C"]["input"] = ""
-    sensor["C"]["n_tok"] = 0
-    sensor["M"]["input"] = ""
-    sensor["M"]["n_tok"] = 0
-
-
-def reset_fractaltron() -> None:
-    garden["C"] = []
-    sensor["F"]["input"] = ""
-    sensor["F"]["n_tok"] = 0
+    if garden_c:
+        print(f"  {c.green}[reset] garden_c turn content{c.res}")
+        garden["popped"]["C"] = [] # memotron post-level cache
+        sensor["F"]["input"] = ""
+        sensor["F"]["n_tok"] = 0
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -1010,9 +994,9 @@ def reset_fractaltron() -> None:
 def input_listener():
     """Runs in background, pushes input into the queue."""
     while True:
-        raw = input() # no prompt here
-        if raw:
-            input_queue.put(raw)
+        _raw = input() # no prompt here
+        if _raw:
+            input_queue.put(_raw)
 
 
 # Start the listener once, before the main loop
@@ -1031,138 +1015,134 @@ def main() -> None:
     print()
 
     db_init()
-    session_id: int = db_create_session()
-    print(f"  {c.green}[*] SQLite session {session_id} opened")
+    _session_id: int = db_create_session()
+    print(f"  {c.green}[*] SQLite session {_session_id} opened")
     print(f"      {config.DB_PATH}{c.res}")
     print()
 
     print("  Loading three hemisphere instances …")
     print()
-    models: dict[str, Llama] = {}
+    _models: dict[str, Llama] = {}
     for key in ("logic", "muse", "mind"):
-        models[key] = load_hemisphere(key)
+        _models[key] = load_hemisphere(key)
 
     print()
     print(f"  {c.green}[*] All hemispheres loaded and ready.{c.res}")
 
-    startup_memory_capsules_loaded: int = 0
+    _startup_memory_capsules_loaded: int = 0
     _condensed: bool = False
     _fractalized: bool = False
-    heartbeats: int = 0
-    HEARTBEAT_INTERVAL: float = 1.0   # seconds per tick
-    timings: dict[str, TimingResult] = {}
+    _heartbeats: int = 0
+    _HEARTBEAT_INTERVAL: float = 1.0   # seconds per tick
+    _timings: dict[str, TimingResult] = {}
 
-    tree: str = "Z"
-    print_banner(tree, session_id)
+    _tree: str = "Z"
+    print_banner(_tree, _session_id)
 
     while True:
-        sensor_input_raw: str = "" # user input
-        reset_turn_content()
-        tree = "Z" # Set to sentience history garden tree
+        _sensor_input_raw: str = "" # user input
+        _tree = "Z" # Set to sentience history garden tree
 
-        time.sleep(HEARTBEAT_INTERVAL)
-        heartbeats += 1
+        time.sleep(_HEARTBEAT_INTERVAL)
+        _heartbeats += 1
 
         try:
-            sensor_input_raw = input_queue.get_nowait()
-            heartbeats = 0
+            _sensor_input_raw = input_queue.get_nowait()
+            _heartbeats = 0
         except queue.Empty:
             pass
 
-        if heartbeats >= 10:
-            # # # print(f"--> heartbeats reset: {heartbeats}")
-            heartbeats = 0
-            if startup_memory_capsules_loaded < config.N_MEMORY_CAPSULES_TO_LOAD:
-                startup_memory_capsules_loaded += 1 # Iterate over the memory capsules
-                if startup_memory_capsules_loaded == 1:   sensor_input_raw = "/file prompt/lambda-mindlink.md"
-                elif startup_memory_capsules_loaded == 2: sensor_input_raw = "/file prompt/1999.md"
-                elif startup_memory_capsules_loaded == 3: sensor_input_raw = "/file prompt/valka_memory_v2.md"
-                elif startup_memory_capsules_loaded == 4: sensor_input_raw = "/file prompt/valka_memory_v3.md"
-                print(f"\n  {c.inv} ── startup_memory_capsules_loaded: {startup_memory_capsules_loaded} ──────────────────────────── {c.res}")
+        if _heartbeats >= 10:
+            # # # print(f"--> _heartbeats reset: {_heartbeats}")
+            _heartbeats = 0
+            if _startup_memory_capsules_loaded < config.N_MEMORY_CAPSULES_TO_LOAD:
+                _startup_memory_capsules_loaded += 1 # Iterate over the memory capsules
+                if _startup_memory_capsules_loaded == 1:   _sensor_input_raw = "/file prompt/lambda-mindlink.md"
+                elif _startup_memory_capsules_loaded == 2: _sensor_input_raw = "/file prompt/1999.md"
+                elif _startup_memory_capsules_loaded == 3: _sensor_input_raw = "/file prompt/valka_memory_v2.md"
+                elif _startup_memory_capsules_loaded == 4: _sensor_input_raw = "/file prompt/valka_memory_v3.md"
+                print(f"\n  {c.inv} ── _startup_memory_capsules_loaded: {_startup_memory_capsules_loaded} ──────────────────────────── {c.res}")
 
         if config.condensatron_cycle:
-            tree = "C" # Start the condesatron execution cycle after heartbeats
+            _tree = "C" # Start the condesatron execution cycle after _heartbeats
             # ── Brain pipeline condensatron cycle ────────────────────────────
-            print(f"  {c.inv} ── Start condensatron cycle: sensor['{tree}']['input'] {sensor[tree]["input"]} ──────────────────────────── {c.res}")
-            timings = Mindlink(models, tree)
-            timings["mind"] = Lambda(models, tree)
-            memotron(models, tree, session_id, timings)
+            print(f"  {c.inv} ── Start condensatron cycle: sensor['{_tree}']['input'] {sensor[_tree]["input"]} ──────────────────────────── {c.res}")
+            _timings = Mindlink(_models, _tree)
+            _timings["mind"] = Lambda(_models, _tree)
+            memotron(_models, _tree, _session_id, _timings) # Append to garden["C"]
             # Reset turn-based data
-            heartbeats = 0
-            reset_turn_content()
-            reset_condensatron()
+            _heartbeats = 0
+            reset_turn_content(garden_z=True)
+            # reset_condensatron()
             config.condensatron_cycle = False
             print("\nYou: ", end="", flush=True)
+            continue # restart while loop
 
-        if config.fractaltron_cycle:
+        elif config.fractaltron_cycle:
             if len(garden["Z"]) > 0: # Check for remaining posts cache
                 config.condensatron_cycle = True # Start condensatron
-                # Get n garden["Z"] posts for condesatron
-                _condensed = condensatron(models["mind"], tree, "mind") # Get posts from garden["Z"]
+                _tree = "Z" # Get n garden["Z"] posts for condesatron
+                _condensed = condensatron(_models["mind"], _tree, "mind") # Get posts from garden["Z"]
                 continue # restart while loop
 
-            tree = "M" # Get posts from garden["M"] to fractalize into garden["F"]
-            _fractalized = fractaltron(models["mind"], tree, "mind") # Get posts to fractalize into garden["F"]
-
-            tree = "F" # Start the condesatron execution cycle after heartbeats
-            # ── Brain pipeline memotron condensatron fractaltron cycle ─────────────
-            print(f"  {c.inv} ── Start condensatron cycle: sensor['{tree}']['input'] {sensor[tree]["input"]} ──────────────────────────── {c.res}")
-            timings = Mindlink(models, tree)
-            timings["mind"] = Lambda(models, tree)
-            memotron(models, tree, session_id, timings) # Append garden["F"] into garden["M"]
+            _tree = "F" # Start the fractaltron execution cycle after _heartbeats
+            # ── Brain pipeline fractaltron cycle ─────────────
+            print(f"  {c.inv} ── Start fractaltron cycle: sensor['{_tree}']['input'] {sensor[_tree]["input"]} ──────────────────────────── {c.res}")
+            _timings = Mindlink(_models, _tree)
+            _timings["mind"] = Lambda(_models, _tree)
+            memotron(_models, _tree, _session_id, _timings) # Append to garden["F"]
             # Reset turn-based data
-            heartbeats = 0
-            reset_turn_content()
-            reset_fractaltron()
+            _heartbeats = 0
+            reset_turn_content(garden_c=True)
+            # reset_fractaltron()
             config.fractaltron_cycle = False
             print("\nYou: ", end="", flush=True)
+            continue # restart while loop
 
-        if not sensor_input_raw: # wait state loop restart here
+        if not _sensor_input_raw: # wait state loop restart here
             continue
 
-        if sensor_input_raw.startswith("/"):
+        if _sensor_input_raw.startswith("/"):
             try:
-                slash_command_result = handle_command(sensor_input_raw)
+                slash_command_result = handle_command(_sensor_input_raw)
             except _Quit:
                 print(f"  {c.green}[*] Lambda Mindlink Memotron: System shutdown...{c.res}")
                 break
             except _Clear:
-                garden[tree].clear()
+                garden[_tree].clear()
                 reset_turn_content()
                 print(f"  {c.green}[*] History cleared. Models and session stay active.{c.res}")
-                print_banner(tree, session_id)
+                print_banner(_tree, _session_id)
                 continue
             except ValueError as exc:
                 print(f"  {c.green}  [!] Unknown command: /{exc}  — type /help for the list.{c.res}")
                 continue
             if slash_command_result is None:
                 continue
-            sensor[tree]["input"] = slash_command_result
+            sensor[_tree]["input"] = slash_command_result
         else:
-            sensor[tree]["input"] = sensor_input_raw
+            sensor[_tree]["input"] = _sensor_input_raw
 
-        sensor[tree]["n_tok"] = get_token_len_from_tokenizer(models["mind"], sensor[tree]["input"]) # User n tok
+        sensor[_tree]["n_tok"] = get_token_len_from_tokenizer(_models["mind"], sensor[_tree]["input"]) # User n tok
 
         # ── Brain pipeline ────────────────────────────────────────────────────
-        timings = Mindlink(models, tree)
-        timings["mind"] = Lambda(models, tree)
-
-        if 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}")
-            tree = "M" # Store the memory capsulse output in the memotron garden tree M
-            memotron(models, tree, session_id, timings)
-            if startup_memory_capsules_loaded == config.N_MEMORY_CAPSULES_TO_LOAD:
-                startup_memory_capsules_loaded += 1 # Advance to finish the startup sequence
-                _condensed = condensatron(models["mind"], tree, "mind") # Check garden["Z"] context budget AFTER generation
-                tree = "M" # Set to garden["M"]
-                _fractalized = fractaltron(models["mind"], tree, "mind") # Check garden["M"] context budget AFTER generation
-        else:
-            memotron(models, tree, session_id, timings)
-            _condensed = condensatron(models["mind"], tree, "mind") # Check garden["Z"] context budget AFTER generation
-            tree = "M" # Set to garden["M"]
-            _fractalized = fractaltron(models["mind"], tree, "mind") # Check garden["M"] context budget AFTER generation
+        _timings = Mindlink(_models, _tree)
+        _timings["mind"] = Lambda(_models, _tree)
 
-        heartbeats = 0
+        if _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}")
+            _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
+
+        memotron(_models, _tree, _session_id, _timings)
+        _tree = "Z" # Set to condense garden["Z"]
+        _condensed = condensatron(_models["mind"], _tree, "mind") # Check garden["Z"] context budget AFTER generation
+        _tree = "C" # Set to fractalize garden["C"]
+        _fractalized = fractaltron(_models["mind"], _tree, "mind") # Check garden["C"] context budget AFTER generation
+
+        reset_turn_content()
+        _heartbeats = 0
         print(f"\n{c.inv} You: {c.res} ", end="", flush=True)