add-on -> dream mode

app.py

@@ -109,6 +109,23 @@ with gr.Blocks() as demo:
             gr.Markdown("#### 📊 Deployment Telemetry Logs")
             output_log = gr.Markdown("_Awaiting local environment staging completion..._")
 
+            # --- 💤 COGNITIVE DREAM CORE ADDITION ---
+            # 1. Dedicated dynamic UI layer addition to house the Dream mode, reconsolidation telemetry logic
+            gr.Markdown("---")
+            gr.Markdown("### 💤 Cognitive Dream Core")
+            dream_btn = gr.Button("🌙 Trigger Autonomous Audit", variant="secondary")
+            
+            # This hidden box holds the human-in-the-loop verification gate controls
+            with gr.Box(visible=False) as review_gate_panel:
+                gr.Markdown("### 🚨 Pending Architectural Patch Proposal")
+                proposal_display = gr.Markdown()  # Renders the audit analysis report
+                
+                with gr.Row():
+                    apply_patch_btn = gr.Button("✅ Apply Changes", variant="primary")
+                    discard_patch_btn = gr.Button("❌ Discard", variant="stop")
+            
+            dream_status_log = gr.Markdown("_System operating at nominal capacities._")
+
     # --- UI ROUTING HANDLERS ---
     def process_login_validation(password_attempt):
         """Step 1: Authenticates strings and updates layout toggles and browser session state."""
@@ -191,6 +208,38 @@ with gr.Blocks() as demo:
         result = manage_github_repo(repo_name.strip(), commit_msg, files)
         yield f"{result}"
 
+    # ==================== BIND COGNITIVE DREAM LIFECYCLES ====================
+    # A hidden internal string tracking state to isolate the raw proposal across loops
+    active_proposal_state = gr.State("")
+
+    def run_background_dream_cycle():
+        """Triggers the non-destructive reflection loop and reveals the confirmation buttons."""
+        yield gr.update(value="◌ _Cognitive pipeline active: Running simulation audit on core_logic.py..._"), gr.update(visible=False), ""
+        
+        from dream_agent import execute_dream_reflection
+        raw_proposal = execute_dream_reflection(target_file="core_logic.py")
+        
+        # Clean up XML tags from the markdown display presentation so it reads cleanly to the user
+        user_report_view = raw_proposal.replace("<proposed_patch>", "```python\n[PROPOSED SOURCE CODE CHANGES]").replace("</proposed_patch>", "\n```")
+        
+        yield (
+            gr.update(value="🟢 **Simulation Audit Complete.** Review proposal below before authorizing deployment."), 
+            gr.update(visible=True),  # Reveal the action validation confirmation buttons
+            user_report_view,         # Send text report to the markdown viewing element
+            raw_proposal              # Lock raw payload text into state memory buffer
+        )
+
+    def commit_authorized_dream_patch(proposal_buffer):
+        """Executes patch write operations once explicit user verification is asserted."""
+        from dream_agent import apply_authorized_patch
+        result_msg = apply_authorized_patch(proposal_buffer, target_file="core_logic.py")
+        return gr.update(visible=False), result_msg
+
+    def discard_dream_patch():
+        """Declines updates cleanly and zeroes out layout states."""
+        return gr.update(visible=False), "_Proposal safely discarded. Local file state left unchanged._"
+
+
     # ==================== BIND EVENT LISTENER LIFECYCLES ====================
     
     # Decoupled sequence: Click validates credentials and captures token -> THEN queries data array conditionally
@@ -258,4 +307,23 @@ with gr.Blocks() as demo:
         outputs=[output_log]
     )
 
+    # Event Assignments
+    dream_btn.click(
+        fn=run_background_dream_cycle,
+        inputs=[],
+        outputs=[dream_status_log, review_gate_panel, proposal_display, active_proposal_state]
+    )
+
+    apply_patch_btn.click(
+        fn=commit_authorized_dream_patch,
+        inputs=[active_proposal_state],
+        outputs=[review_gate_panel, dream_status_log]
+    )
+
+    discard_patch_btn.click(
+        fn=discard_dream_patch,
+        inputs=[],
+        outputs=[review_gate_panel, dream_status_log]
+    )
+
 demo.launch(theme=gr.themes.Soft(), css="styles.css")

dream_agent.py

@@ -0,0 +1,120 @@
+
+# ./dream_agent.py
+
+"""
+By design, the dream_agent will only inspect, analyze, and report. It operates like an engineering consultant presenting a formal change proposal. It will generate a clear visual report of what it wants to optimize, but it is programmatically barred from altering a single character of the source code until the end-user explicitly clicks 'Apply Changes'. If clicked 'Discard', the proposal is immediately deleted from memory, leaving files completely untouched.
+
+To achieve this cleanly, dream_agent.py is built to extract code modifications using structured XML tags (<proposed_patch>...</proposed_patch>). The app will display the text outside these tags as the review proposal, while storing the raw code safely inside a hidden Gradio State component until chosen to authorize or kill the transaction.
+
+The standalone module - dream_agent.py - reads the workspace targets, consults dream.md protocols, executes a non-destructive simulation via llama-3.1-8b-instant, and formats the actionable proposal layout.
+
+"""
+
+import os
+import re
+from groq import Groq  # Substituted automatically if utilizing alternative client wrappers
+
+def execute_dream_reflection(target_file="core_logic.py"):
+    """
+    Phase 1: Deep Cognitive Audit Run
+    Reads local workspace files and drafts optimized changes without writing them to disk.
+    """
+    # 1. Verification Guardrails
+    if not os.path.exists(target_file):
+        return f"### ❌ Audit Aborted\nTarget workspace asset `{target_file}` could not be located for tracing."
+
+    if not os.path.exists("dream.md"):
+        return "### ❌ Audit Aborted\nCognitive ruleset configuration `dream.md` is missing from root."
+
+    # 2. Ingest Environment Source Files
+    with open(target_file, "r", encoding="utf-8") as f:
+        source_code = f.read()
+
+    with open("dream.md", "r", encoding="utf-8") as f:
+        dream_rules = f.read()
+
+    # 3. Initialize Independent Client API
+    # Uses the same environment token configuration pattern as core_logic/storage
+    #client = Groq(api_key=os.getenv("GROQ_API_KEY") or os.getenv("HF_TOKEN"))
+    client = Groq(api_key=os.getenv("GROQ_API_KEY") or os.getenv("HF_TOKEN"))
+    
+    # 4. Construct Isolated Simulation Prompt
+    simulation_prompt = f"""{dream_rules}
+
+    You are running a deep structural code simulation. Analyze the following live Python file for efficiency bottlenecks, redundant structures, or logic holes.
+
+    LIVE WORKSPACE CODE TARGET: `{target_file}`
+    ```python
+    {source_code}
+
+    CRITICAL COMPILATION MATRIX FOR YOUR OUTPUT:
+
+    Provide a clear Markdown analysis of what you found under "👁️ ANALYSIS SUMMARY".
+
+    Provide the complete, production-ready replacement code under "📐 TARGET PATCH PROPOSAL".
+
+    Wrap your replacement code EXACTLY within structural <proposed_patch> and </proposed_patch> tags.
+
+    YOUR RESPONSE MUST FOLLOW THIS EXACT TEMPLATE:
+    👁️ ANALYSIS SUMMARY
+    [Detail the exact code gaps, risks, or performance debt you identified here]
+
+    📐 TARGET PATCH PROPOSAL
+    <proposed_patch>
+
+    Complete, modified ready-to-run replacement code block goes here
+    </proposed_patch>
+    """
+
+    try:
+        completion = client.chat.completions.create(
+            model="llama-3.1-8b-instant",
+            messages=[{"role": "user", "content": simulation_prompt}],
+            temperature=0.1  # Low temperature to preserve structural discipline
+        )
+        
+        proposal_payload = completion.choices[0].message.content
+        return proposal_payload
+
+    except Exception as simulation_error:
+        return f"### ❌ Cognitive Run Exception\nAPI interaction layer encountered an execution fault: {str(simulation_error)}"
+    
+def apply_authorized_patch(proposal_text, target_file="core_logic.py"):
+    """
+    Phase 2: Gated Confirmation Commit Execution
+    Extracts code from XML tags, creates a rollback backup, and overwrites the target file.
+    """
+    try:
+        # Extract content between <proposed_patch> tags
+        patch_match = re.search(r"<proposed_patch>([\s\S]*?)</proposed_patch>", proposal_text)
+
+        if not patch_match:
+            return "❌ **Patch Aborted:** Could not extract structural `<proposed_patch>` bounds from model proposal."
+            
+        clean_extracted_code = patch_match.group(1).strip()
+        
+        # Strip away markdown code block wrappers if the model wrapped them inside the XML tags
+        if clean_extracted_code.startswith("```python"):
+            clean_extracted_code = clean_extracted_code[9:]
+        if clean_extracted_code.startswith("```"):
+            clean_extracted_code = clean_extracted_code[3:]
+        if clean_extracted_code.endswith("```"):
+            clean_extracted_code = clean_extracted_code[:-3]
+            
+        clean_extracted_code = clean_extracted_code.strip()
+
+        # Safety Step: Establish a recovery point backup before committing changes
+        if os.path.exists(target_file):
+            backup_path = f"{target_file}.bak"
+            import shutil
+            shutil.copy2(target_file, backup_path)
+            print(f"[+] Local rollback checkpoint generated at: {backup_path}")
+
+        # Execute File Writing Commit Transaction
+        with open(target_file, "w", encoding="utf-8") as f:
+            f.write(clean_extracted_code)
+
+        return f"✅ **Environment Patched Successfully:** `{target_file}` has been updated. Rollback backup preserved at `{target_file}.bak`."
+
+    except Exception as write_fault:
+        return f"❌ **Systemic Write Failure:** Execution aborted while updating file system: {str(write_fault)}"