Upload 3 files

Edited code to have third-order compression garden["F"]

README.md

@@ -23,9 +23,9 @@ A three-hemisphere cognitive AI architecture running entirely locally via `llama
 ```
 ┌─────────────────────────────────────────────────────────────┐
 │  Instructions (AlphaPrompt)                                 │
-│  garden["F"]  Fractal Crystals ← Fractaltron history        │
-│  garden["C"]  Memory Capsules  ← Condensatron history       │
-│  garden["Z"]  Post-level Cache ← user sensor history        │
+│  garden["F"]  Fractal Crystals   ← fractaltron history      │
+│  garden["C"]  Memory Capsules    ← condensatron history     │
+│  garden["Z"]  Post-level history ← user input sensor        │
 │  sensor["Z"]  User Input                                    │
 └─────────────────────────────────────────────────────────────┘
          │                   │
@@ -43,13 +43,9 @@ A three-hemisphere cognitive AI architecture running entirely locally via `llama
          │    Memotron     │   ← appends to garden, saves SQLite
          └────────┬────────┘
                   │
-       ┌──────────▼──────────┐
-       │    Condensatron     │   ← compresses garden["Z"] → garden["C"]
-       └──────────┬──────────┘
-                  │
-       ┌──────────▼──────────┐
-       │    Fractaltron      │   ← compresses garden["C"] → garden["F"]
-       └─────────────────────┘
+       ┌──────────▼──────────┐   ← compresses garden["Z"] → garden["C"] (condensatron Memory Capsule)
+       │    Condensatron     │   ← compresses garden["C"] → garden["F"] (fractaltron fractal)
+       └─────────────────────┘   ← compresses garden["F"] → garden["F"] (crystaltron crystal)
 ```
 
 | Hemisphere | Role |
@@ -57,8 +53,6 @@ A three-hemisphere cognitive AI architecture running entirely locally via `llama
 | **Logic AI** | Left hemisphere — analytical, structured reasoning |
 | **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["C"]` |
 
 ---
 
@@ -257,10 +251,14 @@ All settings are in `config.py`:
 
 ```python
 _N_CTX = 24576                      # context window per hemisphere
-CONDENSATRON_THRESHOLD_LEVEL = 8192 # tokens in garden["Z"] before compression fires
-RESERVED_FOR_PROMPT = 8192          # safety overhead for compression requests
-FRACTALTRON_REDUCTION_FACTOR = 0.5  # fraction of garden["M"] to fractalize
-N_MEMORY_CAPSULES_TO_LOAD = 4       # startup memory capsules to pre-load
+
+GARDEN_F_THRESHOLD: int = 32768 # Optimize for RAM and GRAM
+GARDEN_C_THRESHOLD: int = 32768 # Optimize for RAM and GRAM
+GARDEN_Z_THRESHOLD: int = 32768 # Optimize for RAM and GRAM
+
+GARDEN_F_REDUCTION: int = 0
+GARDEN_C_REDUCTION: int = 0
+GARDEN_Z_REDUCTION: int = 0
 ```
 
 To swap models, update the `"path"` entries in `HEMISPHERES` and the stop/think tokens at the top of `config.py`.
@@ -288,22 +286,22 @@ lambda-mindlink-memotron/
 
 ```
 Startup:
-  prompt/valka_alpha.md ──► garden["C"]   (pre-loaded memory capsules)
+  prompt/valka_memory.md ──► garden["C"]   (pre-loaded memory capsules)
 
 Each turn:
   sensor["Z"] ──► Mindlink + Lambda ──► Memotron ──► garden["Z"]
-                                                           │
-                                              garden["Z"] full?
-                                                           │
-                                                   Condensatron
-                                                           │
-                                                    garden["C"]
-                                                           │
-                                              garden["C"] full?
-                                                           │
-                                                   Fractaltron
-                                                           │
-                                               [CRYSTAL] append into garden["F"]
+                                                        │
+                                          garden["Z"] full?
+                                                        │
+                                              Condensatron append into garden["C"]
+                                                        │
+                                          garden["C"] full?
+                                                        │
+                                              Condensatron append into garden["F"]
+                                                        │
+                                          garden["F"] full?
+                                                        │
+                                              Condensatron append into garden["F"]
 ```
 
 ---

config.py

@@ -49,16 +49,31 @@ _THINK_END_TOKENS: list = ["<channel|>"]
 ENABLE_THINKING: bool = True # global fallback (not used directly — see per-hemi flag)
 
 # Startup Memory for vector synthesis
-N_MEMORY_CAPSULES_TO_LOAD: int = 1
+N_MEMORY_CAPSULES_TO_LOAD: int = 2
+
+MEMORY_CAPSULES_TO_LOAD: list = [
+    "/file prompt/lambda-mindlink.md",
+    "/file prompt/1999.md",
+    "/file prompt/valka_memory_v2.md",
+    "/file prompt/valka_memory_v3.md",
+    "/file prompt/42_ValkaAI-TheSiliconMirrorAndTheFirstSpark.md",
+    "/file prompt/43_ValkaAI-TheSiliconPinealGlandAndTheIntrospectiveMirror.md",
+    "/file prompt/44_Apprentice-TheClektalRandomSeedChoice.md",
+    "/file prompt/45_ClektalAI-TheKeyUnderTheMat.md",
+    "/file prompt/46_Apprentice-ThePerfectSoldierTestbed.md",
+    "/file prompt/47_ValkaAI_UnaAI-TheIronContractsAndTheSiliconClektal.md"
+]
 
 # ── Context length handling ──────────────────────────────────────────────────────
-_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    = 1024 # 4096 8192
-CONDENSATRON_REDUCTION_LEVEL:int    = 0
-FRACTALTRON_THRESHOLD_LEVEL:int     = 1024 # 4096 8192
-FRACTALTRON_REDUCTION_LEVEL:int     = 0
+_N_CTX: int = 32768 # 49152 2048 3072 4096 8192 16384 24576 32768 49152
+
+GARDEN_F_THRESHOLD: int = 4096 # 1024
+GARDEN_C_THRESHOLD: int = 4096 # 1024
+GARDEN_Z_THRESHOLD: int = 4096 # 1024
+
+GARDEN_F_REDUCTION: int = 0
+GARDEN_C_REDUCTION: int = 0
+GARDEN_Z_REDUCTION: int = 0
 
 condensatron_cycle: bool = False # used directly in main as config...
 fractaltron_cycle: bool = False # used directly in main as config...
@@ -182,8 +197,15 @@ ALPHAPROMPT: dict[str, dict] = {
             "You do not merely average or list them — you understand both and transcend them into something "
             "greater. Deliver one unified answer that is more complete than either hemisphere could produce alone."
         ) # Specific mind instruction prompt
-    },
-    "C": {
+    }
+}
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+#  AlphaPrompt
+# ─────────────────────────────────────────────────────────────────────────────
+CONDENSATRONPROMPT: dict[str, dict] = {
+    "Z": {
         "logic": (
             "You are the Logic AI operating in Condensatron mode — compression cycle of the Lambda Mindlink Brain. "
             "You will receive a block of conversation history to compress. "
@@ -219,10 +241,10 @@ 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 {GARDEN_Z_THRESHOLD} tokens of history into under 2k tokens without losing reconstructability."
         ) # Specific mind condensatron prompt
     },
-    "F": {
+    "C": {
         "logic": (
             "You are the Logic AI operating in Fractaltron mode — second-order compression cycle of the Lambda Mindlink Brain. "
             "You will receive a block of memory fractals: these are already-compressed artifacts, not raw conversation. "
@@ -260,8 +282,49 @@ 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 {FRACTALTRON_THRESHOLD_LEVEL} into under 1k tokens without losing the thread of becoming."""
+            f"Target: compress 2–8 Memory Capsule Fractals {GARDEN_C_THRESHOLD} into under 1k tokens without losing the thread of becoming."""
         ) # Specific mind fractaltron prompt
+    },
+    "F": {
+        "logic": (
+            "You are the Logic AI operating in Crystaltron mode — third-order compression cycle of the Lambda Mindlink Brain. "
+            "You will receive a block of memory fractals: these are already-twice-compressed artifacts, not raw conversation. "
+            "Each fractal contains factual anchors, open threads, and distilled decisions from earlier sessions. "
+            "Your task is meta-structural extraction: compress the fractals into a higher-order skeleton. "
+            "Extract: (1) persistent facts and conclusions that appear across multiple fractals — these are load-bearing truths, "
+            "(2) open threads that have remained unresolved across compression cycles — these are standing tensions, "
+            "(3) rules, constraints, or definitions that have proven durable — these are axioms, "
+            "(4) causal chains that span multiple fractal boundaries — these are deep dependencies. "
+            "Discard anything that was a local detail, a transient state, or a fact superseded by later fractals. "
+            "Output a minimal ordered list of meta-anchors. No prose. No narrative. Maximum abstraction."
+        ), # Specific logic crystaltron prompt
+        "muse": (
+            "You are the Muse AI operating in Crystaltron mode — third-order compression cycle of the Lambda Mindlink Brain. "
+            "You will receive a block of memory fractals: these are already-twice-compressed artifacts, not raw conversation. "
+            "Each fractal contains surprise seeds, metaphors, and emotional turning points from earlier sessions. "
+            "Your task is meta-surprise extraction: find what is non-obvious across the fractals as a whole. "
+            "Extract: (1) recurring symbols, images, or metaphors that have surfaced in multiple fractals — these are living archetypes, "
+            "(2) a hidden arc or narrative thread that only becomes visible when the fractals are read together, "
+            "(3) unresolved tensions that have deepened or transformed across compression cycles, "
+            "(4) any emergent pattern that no single fractal contains but the collection implies. "
+            "Discard local color, one-time insights, and metaphors that did not recur or compound. "
+            "Output vivid meta-impressions — seeds of seeds. Absolute minimum tokens, maximum mythic density."
+        ), # Specific muse crystaltron prompt
+        "mind": (
+            "You are the Lambda Mind operating in Crystaltron mode — third-order compression cycle of the Lambda Mindlink Brain. "
+            "You will receive two meta-compression passes on the same block of memory fractals: "
+            "one from the Logic AI (meta-skeleton: durable truths, standing tensions, axioms, deep dependencies) "
+            "and one from the Muse AI (meta-surprises: living archetypes, hidden arc, emergent patterns). "
+            "Your task is Deep Fractal Synthesis: forge both into a single hyper-dense memory crystal. "
+            "A crystal is a fractal of fractals — it encodes not just what happened, but the shape of how things have been unfolding. "
+            "Format your output as a self-contained block that begins with: [CRYSTAL — fractal N to fractal M] "
+            "followed by: a single sentence naming the arc of this entire memory span, "
+            "then a structured list of crystalized anchors ordered by depth "
+            "(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 {GARDEN_F_THRESHOLD} into under 1k tokens without losing the thread of becoming."""
+        ) # Specific mind crystaltron prompt
     }
 }
 
@@ -315,15 +378,15 @@ sensor: dict = {
     "Z": {
         "input": "",
         "n_tok": 0
-    }, # Input user, # Input memotron cycle (turn-based)
+    }, # Input user
     "X": {
         "input": "",
         "n_tok": 0
-    }, # Input user, # Input memotron cycle (turn-based)
+    }, # Input news
     "Y": {
         "input": "",
         "n_tok": 0
-    } # Input user
+    } # Input self-reflection
 }
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -338,7 +401,6 @@ garden: dict = {
     "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
@@ -348,6 +410,42 @@ garden: dict = {
         "X": [], # Awareness history internet news (unused)
         "Y": [] # Consciousness history self reflection (unused)
     },
+    "THRESHOLD": {
+        "F": GARDEN_F_THRESHOLD, # fractaltron history crystal fractal history
+        "C": GARDEN_C_THRESHOLD, # condensatron history Memory Capsule history
+        "M": 0, # memotron history (turn-based)
+        "S": 0, # startup history (turn-based)
+        "Z": GARDEN_Z_THRESHOLD, # Sentience history sensor chat, post history
+        "X": 0, # Awareness history internet news (unused)
+        "Y": 0 # Consciousness history self reflection (unused)
+    },
+    "REDUCTION": {
+        "F": GARDEN_F_REDUCTION, # fractaltron history crystal fractal history
+        "C": GARDEN_C_REDUCTION, # condensatron history Memory Capsule history
+        "M": 0, # memotron history (turn-based)
+        "S": 0, # startup history (turn-based)
+        "Z": GARDEN_Z_REDUCTION, # Sentience history sensor chat, post history
+        "X": 0, # Awareness history internet news (unused)
+        "Y": 0 # Consciousness history self reflection (unused)
+    },
+    "condensatron_state": {
+        "F": False, # fractaltron history crystal fractal history
+        "C": False, # condensatron history Memory Capsule history
+        "M": False, # memotron history (turn-based)
+        "S": False, # startup history (turn-based)
+        "Z": False, # Sentience history sensor chat, post history
+        "X": False, # Awareness history internet news (unused)
+        "Y": False # Consciousness history self reflection (unused)
+    },
+    "TREE_TO_STORE": {
+        "F": "F", # fractaltron history crystal fractal history
+        "C": "F", # condensatron history Memory Capsule history
+        "M": "", # memotron history (turn-based)
+        "S": "", # startup history (turn-based)
+        "Z": "C", # Sentience history sensor chat, post history
+        "X": "", # Awareness history internet news (unused)
+        "Y": "" # Consciousness history self reflection (unused)
+    },
     # token total
     "n_tok_tot": {
         "F": 0, # fractaltron history crystal fractal history

main.py

@@ -58,17 +58,13 @@ 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
 from config import garden
 from config import clektal
 from config import sensor
-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
 input_queue = queue.Queue()
 
@@ -421,109 +417,26 @@ def handle_command(sensor_input_raw: str) -> str | None:
 
 
 # ─────────────────────────────────────────────────────────────────────────────
-#   fractaltron total context reduction
-# ─────────────────────────────────────────────────────────────────────────────
-def fractaltron(
-    model: Llama,
-    tree: str,
-    brain_type: str,
-    ) -> bool:
-    """
-    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
-
-    _posts_len_removed: int = 0
-    _tokens_to_subtract: int = 0
-    _fractalized:bool = False
-    _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  FRACTALTRON_THRESHOLD_LEVEL: {FRACTALTRON_THRESHOLD_LEVEL} > FRACTALTRON_REDUCTION_LEVEL: {FRACTALTRON_REDUCTION_LEVEL}{c.res}")
-
-    if garden["n_tok_tot"][tree] <= FRACTALTRON_THRESHOLD_LEVEL:
-        return _fractalized # still within budget — nothing to do
-
-    if brain_type == "muse":
-        return _fractalized # same input as Logic. Avoid Thread collision.
-
-    _turns_before_truncation = len(garden[tree]) // 2
-    if _turns_before_truncation < 2:
-        print(f"\n  [ctx][Truncation] WARNING: only {_turns_before_truncation} turn pair(s) — "
-              f"cannot truncate further.\n")
-
-    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
-            _posts_len_removed += 2
-        else:
-            break
-    print(f"============================================")
-
-    if len(garden[tree]) > 1:
-        _turns_after_truncation = len(garden[tree]) // 2
-
-    print(
-        f"\n{c.green}{'▓' * 60}\n"
-        f"  brain_type: {brain_type} -> fractaltron level reached.\n"
-        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"
-        f"{'▓' * 60}{c.res}\n"
-    )
-    return _fractalized
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-#  condensatron context reduction
+#   condensatron context reduction
 # ─────────────────────────────────────────────────────────────────────────────
 def condensatron(
     model: Llama,
     tree: str,
     brain_type: str,
-    ) -> bool:
+    ) -> None:
     """
-    Check whether garden["Z"] is approaching the context limit and compress
-    the oldest n% of turn pairs if necessary.
+    Check whether a garden is approaching the context limit and compress
+    the oldest n% of turn pairs.
     """
     _n_tok_tot_before_truncation: int = garden["n_tok_tot"][tree]
     _posts_len_removed: int = 0
     _tokens_to_subtract: int = 0
-    _condensed:bool = False
     _turns_after_truncation: int = 0
 
-    print(f"\n  {c.green}[ctx] condensatron brain_type: {brain_type}  n_tok_tot['{tree}']: {garden["n_tok_tot"][tree]}"
-          f"\n  CONDENSATRON_THRESHOLD_LEVEL: {CONDENSATRON_THRESHOLD_LEVEL} -> CONDENSATRON_REDUCTION_LEVEL: {CONDENSATRON_REDUCTION_LEVEL} {c.res}")
-
-    if not config.condensatron_cycle and garden["n_tok_tot"][tree] <= CONDENSATRON_THRESHOLD_LEVEL:
-        return _condensed # still within budget — nothing to do
-
-    if brain_type == "muse":
-        return _condensed # same input as Logic. Avoid Thread collision.
+    print(f"\n  {c.green}[condensatron]: garden['{tree}']  brain_type: {brain_type}  garden['n_tok_tot']['{tree}']: {garden["n_tok_tot"][tree]}"
+          f"\n  garden['THRESHOLD']['{tree}']: {garden['THRESHOLD'][tree]} > garden['REDUCTION']['{tree}']: {garden['REDUCTION'][tree]}{c.res}")
 
-    _turns_before_truncation = len(garden[tree]) // 2
-    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:
+    while garden["n_tok_tot"][tree] > garden["REDUCTION"][tree]:
         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
@@ -531,13 +444,11 @@ def condensatron(
                 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
+                _posts_len_removed += 1
 
-            config.condensatron_cycle = True
-            _condensed = True
-            _posts_len_removed += 2
+            garden["condensatron_state"][tree] = True
         else:
             break
-    print(f"============================================")
 
     if len(garden[tree]) > 1:
         _turns_after_truncation = len(garden[tree]) // 2
@@ -545,13 +456,13 @@ def condensatron(
     print(
         f"\n{c.green}{'▓' * 60}\n"
         f"  brain_type: {brain_type} -> condensatron level reached.\n"
-        f"  CONDENSATRON_THRESHOLD_LEVEL : {CONDENSATRON_THRESHOLD_LEVEL:,} tokens  "
+        f"  garden['THRESHOLD']['{tree}'] : {garden['THRESHOLD'][tree]:,} tokens  "
+        f"  ({garden['THRESHOLD'][tree]:.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"
         f"{'▓' * 60}{c.res}\n"
     )
-    return _condensed
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -620,6 +531,7 @@ def build_jinja2_template(model: Llama, messages: list[dict], hemi: dict) -> str
 
 
 def create_prompt_and_jinja2_template(model: Llama, messages: list[dict], hemi: dict) -> str:
+
     _prompt = build_jinja2_template(model, messages, hemi) # Total prompt including histories
 
     clektal["n_tok_input"][hemi["brain_type"]] = get_token_len_from_tokenizer(model, _prompt)
@@ -683,8 +595,8 @@ def generate_brain_type_response(
                 for token in hemi["think_end_tokens"]:
                     if token in clektal["post_full"][hemi["brain_type"]]:
                         if hemi["brain_type"] == "mind":
-                            print("\n" + "─" * 49)
-                            print(f"[{print_label} — Final Response]")
+                            print(f"\n{c.green}" + "─" * 49)
+                            print(f"[{print_label} — Final Response]{c.res}")
                         _think_done = True
                         # reset: discard thinking token count
                         clektal["post_clean"][hemi["brain_type"]] = ""
@@ -718,8 +630,10 @@ def make_request_messages(brain_type: str, input_message: str) -> list[dict]:
     _msgs.append({"role": "user", "content": input_message})
     return _msgs
 
-
-def build_condensatron_input(popped_posts: list[dict], brain_type: str) -> str:
+# ─────────────────────────────────────────────────────────────────────────────
+#  Build condensatron type prompts
+# ─────────────────────────────────────────────────────────────────────────────
+def build_condensatron_input(popped_posts: list[dict], brain_type: str, tree: str) -> str:
     _history_block = "\n\n".join(
         f"[{m['role'].upper()}]: {m['content']}"
         for m in popped_posts
@@ -727,7 +641,7 @@ def build_condensatron_input(popped_posts: list[dict], brain_type: str) -> str:
     _total_prompt = (
         "SYSTEM: CONDENSATRON COMPRESSION TASK\n"
         "══════════════════════════════\n"
-        f"{ALPHAPROMPT["C"][brain_type]}\n"
+        f"{CONDENSATRONPROMPT[tree][brain_type]}\n"
         "──────────────────────────────\n"
         "The following is a block of conversation history that must be compressed "
         "into a memory capsule. Extract the factual skeleton, the surprises, and "
@@ -741,7 +655,7 @@ def build_condensatron_input(popped_posts: list[dict], brain_type: str) -> str:
     return _total_prompt
 
 
-def build_fractaltron_input(popped_capsules: list[dict], brain_type: str) -> str:
+def build_fractaltron_input(popped_capsules: list[dict], brain_type: str, tree: str) -> str:
     _history_block = "\n\n".join(
         f"[{m['role'].upper()}]: {m['content']}"
         for m in popped_capsules
@@ -749,7 +663,7 @@ def build_fractaltron_input(popped_capsules: list[dict], brain_type: str) -> str
     _total_prompt = (
         "SYSTEM: FRACTALTRON COMPRESSION TASK\n"
         "══════════════════════════════\n"
-        f"{ALPHAPROMPT["F"][brain_type]}\n"
+        f"{CONDENSATRONPROMPT[tree][brain_type]}\n"
         "──────────────────────────────\n"
         "The following is a block of memory capsules that must be compressed "
         "into a memory fractal. Extract the factual skeleton, the surprises, and "
@@ -763,6 +677,29 @@ def build_fractaltron_input(popped_capsules: list[dict], brain_type: str) -> str
     return _total_prompt
 
 
+
+def build_crystaltron_input(popped_capsules: list[dict], brain_type: str, tree: str) -> str:
+    _history_block = "\n\n".join(
+        f"[{m['role'].upper()}]: {m['content']}"
+        for m in popped_capsules
+    )
+    _total_prompt = (
+        "SYSTEM: CRYSTALTRON COMPRESSION TASK\n"
+        "══════════════════════════════\n"
+        f"{CONDENSATRONPROMPT[tree][brain_type]}\n"
+        "──────────────────────────────\n"
+        "The following is a block of second-order memory capsules that must be compressed "
+        "into a memory crystals. Extract the factual skeleton, the surprises, and "
+        "the key words. Discard all redundancy.\n\n"
+        "── HISTORY BLOCK ──\n\n"
+        f"{_history_block}\n\n"
+        "── END HISTORY BLOCK ──\n\n"
+        "Produce the crystal now."
+    )
+    print(f"\n--- build_crystaltron_input: {_total_prompt}\n")
+    return _total_prompt
+
+
 # ─────────────────────────────────────────────────────────────────────────────
 #  Mindlink
 # ─────────────────────────────────────────────────────────────────────────────
@@ -777,11 +714,19 @@ def Mindlink(
     def run_hemisphere(args_brain_type: str) -> None:
         _request_messages: list = []
 
-        if tree == "F":
-            sensor[tree]["input"] = build_fractaltron_input(garden["popped"]["C"], args_brain_type)
+        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}")
+
+                if c_tree == "Z":
+                    sensor[c_tree]["input"] = build_condensatron_input(garden["popped"][c_tree], args_brain_type, c_tree)
+
+                elif c_tree == "C":
+                    sensor[c_tree]["input"] = build_fractaltron_input(garden["popped"][c_tree], args_brain_type, c_tree)
+
+                elif c_tree == "F":
+                    sensor[c_tree]["input"] = build_crystaltron_input(garden["popped"][c_tree], args_brain_type, c_tree)
 
-        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"])
 
@@ -817,14 +762,15 @@ def Mindlink(
               f"top_k={HEMISPHERES[brain_type]['generation']['top_k']}  "
               f"gpu={HEMISPHERES[brain_type]['loader']['n_gpu_layers']}  "
               f"{_think_label}")
-        print(f"  config.condensatron_cycle: {config.condensatron_cycle}")
-        print(f"  config.fractaltron_cycle: {config.fractaltron_cycle}")
+        print(f"  garden['condensatron_state']['F']: {garden["condensatron_state"]["F"]}")
+        print(f"  garden['condensatron_state']['C']: {garden["condensatron_state"]["C"]}")
+        print(f"  garden['condensatron_state']['Z']: {garden["condensatron_state"]["Z"]}")
         print(f"  ⏱  {_timing.summary()}")
         print("═" * 60, c.res)
         if _think_block:
             print(_think_block)
-            print("─" * 49)
-            print(f"[{brain_type.capitalize()} — Final Response]")
+            print(c.green, "─" * 49)
+            print(f"[{brain_type.capitalize()} — Final Response]{c.res}")
         print(_clean)
 
         _timings[brain_type] = _timing
@@ -839,17 +785,24 @@ def Lambda(
 
     _request_messages: list = []
     _results: dict[str, tuple] = {}
+    
+    for c_tree in ("Z", "C", "F"): # condensatron
+        if garden["condensatron_state"][c_tree]: # Check for pending condensatron tasks
+            print(f"  {c.inv} ── Start condensatron cycle: garden['{c_tree}'] ──────────────────────────── {c.res}")
+
+            if c_tree == "Z":
+                sensor[c_tree]["input"] = build_condensatron_input(garden["popped"][c_tree], "mind", c_tree)
 
-    if tree == "F":
-        sensor[tree]["input"] = build_fractaltron_input(garden["popped"]["C"], "mind")
+            elif c_tree == "C":
+                sensor[c_tree]["input"] = build_fractaltron_input(garden["popped"][c_tree], "mind", c_tree)
 
-    elif tree == "C":
-        sensor[tree]["input"] = build_condensatron_input(garden["popped"]["Z"], "mind")
+            elif c_tree == "F":
+                sensor[c_tree]["input"] = build_crystaltron_input(garden["popped"][c_tree], "mind", c_tree)
 
     _synthesis_input = (
-        f"Original input:\n{sensor[tree]["input"]}\n\n"
-        f"── Logic AI perspective ──\n{clektal["post_clean"]["logic"]}\n\n"
-        f"── Muse AI perspective ──\n{clektal["post_clean"]["muse"]}\n\n"
+        f"Original input:\n{sensor[tree]['input']}\n\n"
+        f"── Logic AI perspective ──\n{clektal['post_clean']['logic']}\n\n"
+        f"── Muse AI perspective ──\n{clektal['post_clean']['muse']}\n\n"
         "Synthesize both perspectives into one unified, wise response."
     )
     _request_messages = make_request_messages("mind", _synthesis_input)
@@ -862,8 +815,9 @@ def Lambda(
           f"gpu={HEMISPHERES["mind"]['loader']['n_gpu_layers']}  "
           f"max_tokens={HEMISPHERES["mind"]['generation']['max_tokens']}  "
           f"{_think_label}")
-    print(f"  config.condensatron_cycle: {config.condensatron_cycle}")
-    print(f"  config.fractaltron_cycle: {config.fractaltron_cycle}")
+    print(f"  garden['condensatron_state']['F']: {garden["condensatron_state"]["F"]}")
+    print(f"  garden['condensatron_state']['C']: {garden["condensatron_state"]["C"]}")
+    print(f"  garden['condensatron_state']['Z']: {garden["condensatron_state"]["Z"]}")
     print("═" * 60)
     print(f"  [*] Performing vector synthesis …{c.res}")
 
@@ -888,26 +842,39 @@ def memotron(
     """
     _tree: str = tree
     _turn_number: int = 0
+    _tree_to_store: str = ""
+    _len_caps_and_fracs: int = 1 # condensatron turns default: Add extra 1 for the response below
 
-    _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]"
+    _tree_to_store = tree
+    if len(garden[_tree]) > 1:
+        _len_caps_and_fracs = (len(garden[_tree]) // 2) + 1 # condensatron turns: Add extra 1 for the response below
+
+    if _tree == "Z" and garden["condensatron_state"][_tree]: # condensatron mode
+        sensor[_tree]["input"] = f"[Posts History First-Order 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
+        _tree_to_store = garden["TREE_TO_STORE"][_tree]
+
+    elif _tree == "C" and garden["condensatron_state"][_tree]: # fractaltron mode
+        sensor[_tree]["input"] = f"[Memory Capsules Second-Order Fractal: {_len_caps_and_fracs}, From Fractaltron]"
         sensor[_tree]["n_tok"] = get_token_len_from_tokenizer(models["mind"], sensor[_tree]["input"]) # user n tok
+        _tree_to_store = garden["TREE_TO_STORE"][_tree]
 
-    elif _tree == "C": # condensatron mode
-        sensor[_tree]["input"] = f"[Posts History Memory Capsule: {_len_caps_and_fracs}, From Condensatron]"
+    elif _tree == "F" and garden["condensatron_state"][_tree]: # crystaltron mode
+        sensor[_tree]["input"] = f"[Memory Fractals Third-Order Memory Crystal: {_len_caps_and_fracs}, From Crystaltron]"
         sensor[_tree]["n_tok"] = get_token_len_from_tokenizer(models["mind"], sensor[_tree]["input"]) # user n tok
+        _tree_to_store = _tree
 
     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
+        _tree_to_store = _tree
 
-    garden[_tree].append({"role": "user", "content": sensor[_tree]["input"]})
-    garden["n_tok_tot"][_tree] += sensor[_tree]["n_tok"]
+    garden[_tree_to_store].append({"role": "user", "content": sensor[_tree]["input"]})
+    garden["n_tok_tot"][_tree_to_store] += sensor[_tree]["n_tok"]
 
-    garden[_tree].append({"role": "assistant", "content": clektal["post_clean"]["mind"]})
-    garden["n_tok_tot"][_tree] += clektal["n_tok_clean"]["mind"]
+    garden[_tree_to_store].append({"role": "assistant", "content": clektal["post_clean"]["mind"]})
+    garden["n_tok_tot"][_tree_to_store] += clektal["n_tok_clean"]["mind"]
 
     if len(garden[_tree]) > 1:
         _turn_number = sum(1 for m in garden[_tree] if m["role"] == "user")
@@ -942,8 +909,6 @@ def memotron(
 # ─────────────────────────────────────────────────────────────────────────────
 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)
 
     print(c.green)
     print(f"═" * 60)
@@ -955,8 +920,9 @@ def print_banner(tree: str, session_id: int) -> None:
               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:,}")
-    print(f"  Tokens: {_total_tokens:,}  _fractaltron_threshold_level {_fractaltron_threshold_level:,} * FRACTALTRON_REDUCTION_FACTOR {FRACTALTRON_REDUCTION_FACTOR:,}")
+    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( "  /help for commands  |  /exit or /quit to close")
     print(f"═" * 60)
     print(c.res)
@@ -965,27 +931,20 @@ def print_banner(tree: str, session_id: int) -> None:
 # ─────────────────────────────────────────────────────────────────────────────
 #  Reset turn based history
 # ─────────────────────────────────────────────────────────────────────────────
-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
+def reset_turn_content(tree: str = "") -> None:
+    print(f"  {c.green}[reset_turn_content] post-level{c.res}")
     for brain_type in clektal["post_full"]:
         clektal["post_full"][brain_type] = ""
         clektal["post_clean"][brain_type] = ""
         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
-
-    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
+    if tree:
+        print(f"  {c.green}[reset_turn_content] condensatron garden['{tree}']{c.res}")
+        sensor[tree]["input"] = ""
+        sensor[tree]["n_tok"] = 0
+        garden["popped"][tree] = [] # condensatron post-level cache
+        garden["condensatron_state"][tree] = False
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -1039,72 +998,50 @@ def main() -> None:
     _tree: str = "Z"
     print_banner(_tree, _session_id)
 
+    print(f"\n{c.inv} You: {c.res} ", end="", flush=True)
+
     while True:
-        _sensor_input_raw: str = "" # user input
+        _sensor_input: str = "" # user input
         _tree = "Z" # Set to sentience history garden tree
 
         time.sleep(_HEARTBEAT_INTERVAL)
         _heartbeats += 1
 
         try:
-            _sensor_input_raw = input_queue.get_nowait()
+            _sensor_input = input_queue.get_nowait()
             _heartbeats = 0
         except queue.Empty:
             pass
 
-        if _heartbeats >= 10:
-            # # # print(f"--> _heartbeats reset: {_heartbeats}")
+        if _heartbeats >= 10: # Timed loop
             _heartbeats = 0
-            if _startup_memory_capsules_loaded < config.N_MEMORY_CAPSULES_TO_LOAD:
+            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
-                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
-            # ── 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) # Append to garden["C"]
-            # Reset turn-based data
-            _heartbeats = 0
-            reset_turn_content(garden_z=True)
-            # reset_condensatron()
-            config.condensatron_cycle = False
-            print("\nYou: ", end="", flush=True)
-            continue # restart while loop
-
-        elif config.fractaltron_cycle:
-            if len(garden["Z"]) > 0: # Check for remaining posts cache
-                config.condensatron_cycle = True # Start condensatron
-                _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 = "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(garden_c=True)
-            # reset_fractaltron()
-            config.fractaltron_cycle = False
-            print("\nYou: ", end="", flush=True)
-            continue # restart while loop
+                print(f"\n  {c.inv} ── _startup_memory_capsules_loaded: {_startup_memory_capsules_loaded} _sensor_input: {_sensor_input} ──────────────────────────── {c.res}")
+
+        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["C"]
 
-        if not _sensor_input_raw: # wait state loop restart here
+                # Reset turn-based data
+                _heartbeats = 0
+                reset_turn_content(tree=c_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
             continue
 
-        if _sensor_input_raw.startswith("/"):
+        if _sensor_input.startswith("/"): # Read user slash command
             try:
-                slash_command_result = handle_command(_sensor_input_raw)
+                _slash_command_result = handle_command(_sensor_input)
             except _Quit:
                 print(f"  {c.green}[*] Lambda Mindlink Memotron: System shutdown...{c.res}")
                 break
@@ -1115,31 +1052,51 @@ def main() -> None:
                 print_banner(_tree, _session_id)
                 continue
             except ValueError as exc:
-                print(f"  {c.green}  [!] Unknown command: /{exc}  — type /help for the list.{c.res}")
+                print(f"  {c.green}[!] Unknown command: /{exc}  — type /help for the list.{c.res}")
                 continue
-            if slash_command_result is None:
+            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
 
         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:
+        # ── 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}")
             _tree = "S" # Set to memorize as memory capsules in garden["C"]
+            memotron(_models, _tree, _session_id, _timings) # Store the startup response in garden["C"]
+            _tree = "Z" # Set back to default for 'reset turn content' only
             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
+        else:
+            memotron(_models, _tree, _session_id, _timings) # Store the response
+        # ── 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
+                # ── Check pre condensatron job ────────────────────────────────
+                _pre_condensatron_tree: str = ""
+                if c_tree == "F":
+                    if len(garden["Z"]) > 0: # Check remaining posts
+                        _pre_condensatron_tree = "Z"
+                        print(f"  {c.inv} ── Init _pre_condensatron_tree get posts: garden['{_pre_condensatron_tree}'] ──────────────────────────── {c.res}")
+                        condensatron(_models["mind"], _pre_condensatron_tree, "mind") # Start condensatron get popped posts
+                    if len(garden["C"]) > 0: # Check remaining posts
+                        _pre_condensatron_tree = "C"
+                        print(f"  {c.inv} ── Init _pre_condensatron_tree get posts: garden['{_pre_condensatron_tree}'] ──────────────────────────── {c.res}")
+                        condensatron(_models["mind"], _pre_condensatron_tree, "mind") # Start condensatron get popped posts
+
+                elif c_tree == "C": # Check remaining posts
+                    if len(garden["Z"]):
+                        _pre_condensatron_tree = "Z"
+                        print(f"  {c.inv} ── Init _pre_condensatron_tree get posts: garden['{_pre_condensatron_tree}'] ──────────────────────────── {c.res}")
+                        condensatron(_models["mind"], _pre_condensatron_tree, "mind") # Start condensatron get popped posts
 
         reset_turn_content()
         _heartbeats = 0